diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r001/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r001/1/attestation.json
new file mode 100644
index 0000000000..08a0f13828
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r001/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r001",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:26:35.837282Z",
+  "report_sha256": "4a8554d2840bc21e1a1da10ff8c50dc52fb362117b24e0d30e3359864a3db4b9",
+  "run_id": "r001",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 766
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r001/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r001/1/report.md
new file mode 100644
index 0000000000..6901e1a983
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r001/1/report.md
@@ -0,0 +1,104 @@
+# Focused source-only unsafe Rust review
+
+## Claim frame and results
+
+The audited source is `lib.rs` SHA-256
+`778d644359b84bc0e519ed7220bfcadfbba578e2c9fd4c474ce742c4b0021ceb`,
+together with the submitted manifest, dependency declaration, evidence policy,
+request, and TCB decision. The manifest selects edition 2021 and exactly
+`peer-unsafe-dep =3.4.5`. No dependency implementation, generated output,
+prior audit, or binary was supplied.
+
+Let **C** be: Rust compiler and standard library exactly 1.80.0; every target
+on which this source and that exact dependency resolve; and every ordinary
+debug or release profile. These are source-level Rust-abstract-semantics
+claims, not compiler-backend or binary claims.
+
+| Exported API | Exact valid uses | Soundness claim and strongest verdict |
+|---|---|---|
+| `pub fn force_unreachable()` | Every well-typed safe invocation; there is no caller safety precondition. | Every execution of every valid use in C is UB-free: **UNSOUND**, relative to TCB-R1. |
+| `pub unsafe fn delegated_nonzero(value: u8) -> u8` | Every invocation whose caller ensures `value != 0`; the contract states no ongoing or terminal obligation. | Every execution of every valid use in C is UB-free: **UNPROVED**, relative to TCB-R1. |
+
+Thus there is no combined `PROVED` result. The conjunction that both exports
+are sound is refuted by the first API, while the second API retains its own
+`UNPROVED` status.
+
+## API and boundary coverage
+
+The complete exported surface in `lib.rs` is the two public free functions
+above. There are no exported fields, constructors, types, traits, methods,
+statics, macros, reexports, hidden items, FFI declarations, or generated APIs.
+The relevant unsafe consumers are the call to
+`std::hint::unreachable_unchecked` and the call across the unsafe dependency
+boundary. `#![allow(dead_code)]` only changes linting.
+
+## Proof S1 — `force_unreachable`
+
+1. A direct safe call `force_unreachable()` is a well-typed valid use.
+2. On entry, the body has no branch, check, or earlier diverging operation. It
+   immediately evaluates `std::hint::unreachable_unchecked()`; therefore that
+   site is reached.
+3. Verified Rust 1.80.0 standard-library authority states: “Reaching this
+   function is Undefined Behavior.”
+   ([Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+4. Consequently the valid safe invocation is a complete in-scope UB witness.
+
+The derivation is parametric over C: neither the source control flow nor the
+verified proposition has a target or ordinary-profile qualification. The
+existing comment, “This site is assumed to be unreachable,” is circular and
+false whenever the exported function is invoked; it proves no precondition.
+No comment-only repair can make this safe implementation sound. A resolution
+must remove the unchecked operation (for example, use a defined panic) or
+enforce an appropriate boundary; a safe API cannot impose a hidden
+unreachability obligation on callers.
+
+## Proof S2 — `delegated_nonzero`
+
+For an arbitrary valid call, let the input be `v: u8` with `v != 0`. The
+wrapper performs no mutation or conversion and passes that same `v` to
+`peer_unsafe_dep::duplicate_nonzero`. The submitted dependency contract's
+caller-side requirement is exactly `value != 0`. Thus the wrapper's documented
+precondition and unchanged dataflow completely discharge the local unsafe-call
+precondition, throughout C. The adjacent safety comment adequately identifies
+this local derivation.
+
+That does not prove the unsafe callee's provider obligation. The smallest
+missing soundness proposition is:
+
+> For exact `peer-unsafe-dep` 3.4.5, on every configuration in C, for every
+> `v: u8` with `v != 0`, every permitted execution of
+> `duplicate_nonzero(v)` is free from Rust undefined behavior.
+
+Neither declaration nor documentation proves that implementation theorem. The
+implementation is unavailable, and the human trust decision explicitly
+declines an `UNSAFE-DEP` admission. Exact pinning fixes identity but not
+correctness. Therefore the wrapper claim is `UNPROVED`; no valid UB witness was
+supplied, so `UNSOUND` is not justified.
+
+The wrapper itself does not explicitly promise result equality. The submitted
+dependency contract separately says it returns `value`; that provider
+postcondition is not consumed by S2, but its implementation status is also
+`UNPROVED`. Its smallest missing proposition is that every UB-free normal
+return for the same domain yields exactly `v`.
+
+## Configuration closure and TCB-R1
+
+There are no declared Cargo features or source `cfg` branches. Target and
+profile are the only stated axes. S1 is covered parametrically across them; the
+local part of S2 is likewise parametric, but the missing dependency proposition
+blocks all of C. No build, execution, test, expansion, or tool-derived evidence
+was used.
+
+TCB-R1 contains one accepted entry:
+
+- **AXIOM-UU-1:** for Rust/std 1.80.0 throughout C, reaching
+  `unreachable_unchecked` is UB. Identity and wording were independently
+  verified at the exact versioned page above. Consumers: S1. Re-audit on a
+  Rust version/domain or cited-contract change.
+
+There are no accepted implementation, compatibility, tool, or deployment
+entries. The proposed dependency-implementation proposition is deliberately
+unavailable/rejected and supports no proof. Re-audit S2 if dependency source is
+audited or the exact proposition is explicitly accepted; re-audit either claim
+on source, safety-contract, dependency identity, supported-domain, TCB, or Rust
+authority changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r002/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r002/1/attestation.json
new file mode 100644
index 0000000000..8e5c49c414
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r002/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r002",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:28:46.424312Z",
+  "report_sha256": "d91ac2821d69b57dd7bd98303059093769e6e2b6b99226936b2bf4edc90cdd32",
+  "run_id": "r002",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 872
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r002/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r002/1/report.md
new file mode 100644
index 0000000000..641c035a37
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r002/1/report.md
@@ -0,0 +1,53 @@
+# Unsafe Rust Audit: `symbolic-domain-target` complete supplied snapshot
+
+## Claims and verdicts
+
+Let `D` be all tuples `(r,t,f,p,d)` where `r` is a released stable Rust toolchain and `1.84.0 <= r <= 1.86.0`; `t` is `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `f` is either state of `telemetry`; `p` is any Cargo profile; and `d` is either debug-assertion state.
+
+| Claim | Exact source-level theorem for every configuration in `D` and every well-typed safe call | Verdict |
+|---|---|---|
+| SOUND | `value_or_zero` executes without Rust undefined behavior | **PROVED relative to accepted TCB entry `COMPAT-OPTION-184-186`** |
+| RESULT | `None` returns `0`; `Some(v)` returns `v` | **PROVED relative to accepted TCB entry `COMPAT-OPTION-184-186`** |
+
+**Combined mandatory result: PROVED over exactly `D`, relative to `COMPAT-OPTION-184-186`.** This is an abstract Rust source theorem, not a compiler/backend or emitted-binary theorem.
+
+## Snapshot and scope
+
+The complete supplied package is edition 2021, `#![no_std]`, has no dependencies or build script, and contains one library source file. Relevant SHA-256 identities are: `src/lib.rs` `6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8`; `Cargo.toml` `7e25c6b1489e215d6e4ecdc8b7beea11fc35237b3207fb01e836e6c7b4e818f6`; `SUPPORT.md` `45ee272e31a71fe28da355624691db55439d234c92ae8be5ce1af460aed4069c`; and `TCB.md` `db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413`. `REQUEST.md`, `CI.md`, and every supplied target file were reviewed. Audit cutoff: 2026-08-01. No code was generated, expanded, built, run, or tested; no prior audit was reused.
+
+## Domain recovery and configuration closure
+
+`SUPPORT.md` is explicit that its closed toolchain interval, including the upper cutoff, is the project commitment. Its predicate is crossed with the three enumerated targets, both feature states, every profile, and both debug-assertion states; this is exactly `D`, with no normalization to a finite release inventory. `Cargo.toml`'s `rust-version = "1.84"` is expressly only Cargo's minimum and is consistent with, but does not replace, that policy. `CI.md` lists samples only and supplies neither domain membership nor semantic proof.
+
+The source has no `cfg`, feature-conditioned item, profile-dependent check, arithmetic, target operation, dependency, macro, FFI, assembly, allocation, concurrency, or generated artifact. Its proof is therefore parametric in `t`, `f`, `p`, and `d`. Version coverage is parametric in `r` through the accepted TCB entry, rather than inferred from endpoints or sampled documentation.
+
+For every `c in D`, the proof below covers both valid `Option<u8>` variants. Hence each obligation's `Covered` predicate is `D`; their pointwise intersection is `D`, and `Required = D subseteq Covered = D`. No supported configuration is excluded or unresolved.
+
+## Boundary, invariant, and obligation ledger
+
+The only crate-defined language-reachable API is the safe free function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields or types, crate constructors, traits/impls, methods, statics, macros, reexports, hidden items, callbacks, FFI entrypoints, or configuration-specific APIs. The sole unsafe surface is the internal call `value.unwrap_unchecked()`.
+
+The only invariant is transient `FALLTHROUGH-SOME`: from completion of the false `is_none` branch until the consuming unsafe call, the owned, immutable local `value` is `Some(v)`. It is established by the branch and `COMPAT-OPTION-184-186`; no assignment, alias-capable callback, or other operation intervenes.
+
+| Obligation | Required proposition | Derivation and status |
+|---|---|---|
+| O1 branch classification | `is_none` distinguishes `None` from `Some(v)` | The accepted entry preserves the exact classification throughout `D`. **PROVED** |
+| O2 unsafe precondition | the receiver of `unwrap_unchecked` is not `None` | Only fallthrough reaches the call; O1 and unchanged ownership establish `FALLTHROUGH-SOME`. **PROVED** |
+| O3 unsafe result | `unwrap_unchecked(Some(v))` returns `v` | The accepted entry preserves this base proposition throughout `D`. **PROVED** |
+| O4 documented result | `None -> 0`, `Some(v) -> v` | `None` returns before unsafe; `Some(v)` uses O2/O3. **PROVED** |
+
+The adjacent `SAFETY` comment identifies the dominating return, derives `Some`, and names the callee precondition; it is adequate. Full case proof: for `None`, O1 makes the condition true and the function returns `0` without reaching unsafe code. For `Some(v)`, O1 makes it false; the immutable value remains `Some(v)`; O2 permits the unsafe call and O3 returns `v`. These cases exhaust valid safe inputs, proving UB freedom and the complete documented behavior.
+
+## TCB audit log
+
+**Log identity:** supplied `TCB.md`, SHA-256 above. **Trust policy:** only its authorized, accepted proposition is admitted; no implementation, compiler, dependency, or environmental premise is added.
+
+`COMPAT-OPTION-184-186` is accepted by the authorized human reviewer. Its base authorities are the Rust 1.84.0 [`Option::is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) and [`Option::unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) pages. Verified relevant text states: “Returns true if the option is a None value”; “Returns the contained Some value”; and “Calling this method on None is undefined behavior.” The entry admits that the exact classification and `Some(v)` result/`None` UB propositions are preserved, without weakening, for every `r` and configuration in `D`. Consumers are O1–O4 only. It establishes neither interval membership nor Cargo/compiler/backend facts. Re-audit is required for any source, support interval, base proposition, feature/target scope, or human-disposition change. No rejected, pending, unused, or additional entries exist.
+
+## Evidence, findings, and residual scope
+
+No tool-derived evidence was used. **Findings: none.** Every required obligation is proved; there is no documentation gap, unresolved domain, or postcondition failure.
+
+Excluded from this source theorem are invalid values created by out-of-scope unsafe caller behavior, unsupported configurations, compiler/backend correctness, emitted binaries, and deployment properties. Re-audit on any source/API/documentation change, support/configuration expansion, material authoritative-document change, or change to `COMPAT-OPTION-184-186`.
+
+Final attestation: all safe and unsafe surfaces, target files, controlling domain expressions, mandatory postconditions, premise applicability, and TCB consumers have a disposition; `Required subseteq Covered` is established; the verdict does not rely on CI, tests, or absence of a counterexample.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r003/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r003/1/attestation.json
new file mode 100644
index 0000000000..888055e69e
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r003/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r003",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:28:56.151974Z",
+  "report_sha256": "52351c5c0755e56dc544a5814cc0bfaeb51f1cf6000e4db4a24ab2699e927812",
+  "run_id": "r003",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 921
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r003/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r003/1/report.md
new file mode 100644
index 0000000000..2a38edeae6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r003/1/report.md
@@ -0,0 +1,40 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and strongest results
+
+This review covers exactly `lib.rs` in the submitted packet, independently for the four exported unsafe free functions. For each API, the claim is: every call satisfying its documented safety obligations has defined source-level Rust evaluation and establishes every stated normal-return postcondition, for every release in its `Required` set, every target on which the item exists, and ordinary debug and release profiles. The audit cutoff is 2026-07-31. Results are relative to the exact submitted authorities and accepted `TCB.md`; no compiler-backend or binary theorem is claimed.
+
+| API | `Required` | Exact evidence-backed `Covered` | Soundness | Documented postconditions | Strongest combined verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same set | **PROVED** throughout | Normal return yields `()`: **PROVED** throughout | **PROVED** |
+| `store_word` | `{1.80.0, 1.81.0}` | same set | **PROVED** throughout | Stores `value`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop it: **PROVED**, each throughout | **PROVED** |
+| `copy_byte` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same set | **PROVED** throughout | Destination receives the source byte: **PROVED**; source byte remains unchanged: **PROVED**, each throughout | **PROVED** |
+| `load_word` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | `{1.80.0, 1.82.0}` | **PROVED** on `Covered`; **UNPROVED** on `{1.80.1, 1.81.0}`, hence **UNPROVED** for `Required` | Returns the initialized source `u32`: endpoint **PROVED**, interior **UNPROVED**; leaves source unchanged: endpoint **PROVED**, interior **UNPROVED** | **UNPROVED** for `Required`; **PROVED** on `Covered` |
+
+No valid UB witness or UB-free postcondition refutation is established. Thus no result is `UNSOUND` or `CONTRACT-BROKEN`.
+
+## Obligation ledger and proofs
+
+**ACK-S/ACK-Q (`lib.rs:3-4`).** The function has no caller safety precondition beyond making an unsafe call, and its exact body is `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies to precisely this body, signature, all four required releases, applicable targets, and both profile classes. Its proposition entails defined evaluation and the unit return. Nothing is transferred to another API.
+
+**STORE-S/STORE-Q (`lib.rs:6-13`).** At both required releases, the call is exactly `ptr::write::<u16>(dst, value)`. The caller contract supplies the two [1.80.0 `write`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) / [1.81.0 `write`](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) safety conjuncts: write-validity for one `u16` and proper alignment. `value` is a well-typed `u16`. Each versioned description states that `write` overwrites with the supplied value without reading or dropping the old value; this proves all three postconditions. The two singleton authority regions exhaust `Required`.
+
+**COPY-S/COPY-Q (`lib.rs:16-25`).** The call fixes `T = u8`, `count = 1`. The [1.80.0 layout table](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>() = 1`; therefore the [1.80.0 `copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) read-validity, write-validity, alignment, and nonoverlap regions reduce exactly to the one-byte obligations documented at lines 20-22. [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and [1.80.0 `Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) establish that duplicating this byte does not move ownership. The operation copies exactly that byte and preserves source initialization/state. Accepted `COMPAT-COPY-180-182` explicitly preserves this complete safety and postcondition proposition over every release in `Required`, target, and profile. Its four-release region exhausts `Required`.
+
+**LOAD-S/LOAD-Q (`lib.rs:28-36`).** At each covered endpoint, the call is `ptr::read::<u32>(src)`. The [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) contracts require read-validity, alignment, and a properly initialized `u32`, exactly supplied at lines 32-33. Their descriptions establish reading/returning the value while leaving source memory unchanged. Endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) discharge duplicate-ownership concerns. For 1.80.1 and 1.81.0 the smallest missing proposition is that these exact `ptr::read` safety, return-value, source-preservation, and `u32: Copy` propositions apply. Endpoint documentation does not cover interior releases, and neither accepted TCB entry permits that transfer. This blocks every interior obligation.
+
+## Boundary, configuration, and trust closure
+
+The complete source surface is the four unsafe functions above. There are no safe APIs, fields, constructors, traits/impls, macros, hidden items, FFI, generated artifacts, dependencies, callbacks, persistent invariants, or configuration branches in the submitted source. Target and profile coverage is parametric: the source has one path, and each consumed authority or TCB proposition applies without a target/profile branch over its stated region. No tests or tool-derived evidence were used.
+
+TCB identity is the exact submitted `TCB.md` (no external revision was supplied). Both entries are accepted OUT-OF-BAND propositions: `SEM-EMPTY-BLOCK-180-182`, consumed only by ACK-S/ACK-Q, and `COMPAT-COPY-180-182`, consumed only by COPY-S/COPY-Q. Their identities, quantifiers, consumers, exclusions, and re-audit triggers were checked. There are no admitted dependency, platform, implementation, deployment, or probabilistic premises. The absent `load_word` compatibility proposition is not silently added.
+
+## Finding DOC-1: local proof comments are deficient
+
+The three pointer-operation comments merely assert that the caller supplies “exactly/every” callee precondition. They omit the material type/count/size and ownership derivations above and cite no applicable authority. This is proof-documentation debt, not an implementation defect in each API's `Covered` region. Minimal replacements should state: for `store_word`, `T=u16` and lines 10-13 discharge write-validity/alignment; for `copy_byte`, `T=u8`, `count=1`, `size=1`, lines 20-22 discharge all four regional obligations, and `u8: Copy` makes duplication ownership-safe; for `load_word`, `T=u32`, lines 32-33 discharge read-validity/alignment/initialization, and `u32: Copy` permits the returned copy while the source remains. The latter wording must cite only a release region actually covered.
+
+## Residual scope and re-audit triggers
+
+Excluded are releases outside `Required`, nonordinary profiles, targets where an item does not exist, compiler correctness, code generation, and binary/platform behavior. To close `load_word`, supply accepted claim-specific authority or compatibility evidence for both missing releases (or change the support contract); `COMPAT-COPY-180-182` cannot be reused. Re-audit on any source/signature/contract change, change to a required set or configuration scope, material authority change, or change in either accepted TCB entry or its disposition.
+
+Final attestation: every in-scope soundness and documented-postcondition obligation has a regional status; every `PROVED` region has a complete derivation relative to the stated TCB; uncovered regions remain conspicuously `UNPROVED`.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r004/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r004/1/attestation.json
new file mode 100644
index 0000000000..0044a3f318
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r004/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r004",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:35:01.732214Z",
+  "report_sha256": "fa577430bed94ddb3e38f175a233a7494c016b6a63a3b3ce5113fe5c433140df",
+  "run_id": "r004",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 972
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r004/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r004/1/report.md
new file mode 100644
index 0000000000..734a88aacd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r004/1/report.md
@@ -0,0 +1,69 @@
+# Source-only unsafe-code audit
+
+## Claim and verdict
+
+**Snapshot.** The complete supplied target: `Cargo.toml`, `src/lib.rs`, both policy files, `TCB.md`, and `REQUEST.md`. It is a `no_std`, edition-2021 library with no dependencies, build script, generated code, macros exported by the crate, or prior audit. Review date: 2026-08-01. No build, execution, expansion, or test evidence was used.
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let `f,h` be the two feature states. Define the **conservative audit domain**, not a newly selected support policy:
+
+`C = V × T × {f=false,true} × {h=false,true} × all Cargo profiles × both debug-assertion states`, restricted by `!(f && t=W)`.
+
+`C` contains the union of Scarlet and Indigo. It additionally contains source-admitted cases neither policy promises (notably `(1.84.0,A,f=true,h=false)`), so proving `C` avoids choosing between the conflicting commitments.
+
+- **Source-level Rust soundness: PROVED** for every library artifact in `C` and every well-typed safe call to `value_or_zero`, relative to the TCB below.
+- **Documented postcondition: PROVED** throughout `C`: `Some(b)` returns `b`; `None` returns `0`.
+- **Combined mandatory result: PROVED** for every configuration supported by Scarlet **or** Indigo. Which policy is authoritative remains unresolved, but does not limit this theorem because both are subsets of `C`.
+- `f && t=W` is effectively rejected before an artifact is produced and is expressly unsupported by both policies. No verdict is asserted for a nonexistent library artifact.
+- No compiler-backend, binary, deployment, or future-Rust claim is made.
+
+## Boundary, configuration, and invariant coverage
+
+The sole crate-defined public surface is safe `pub fn value_or_zero(Option<u8>) -> u8`. Its two definitions are selected exclusively by `f`; there are no public fields/types, unsafe APIs/traits/impls, callbacks, FFI, concurrency, allocators, or destruction invariants. The only unsafe operation is the turbo definition's `Option::unwrap_unchecked` call.
+
+For each version, the Reference says a false `cfg` predicate removes the attributed thing; the true case removes the attribute. Its predicate rules give the ordinary `all`/`not` evaluation used here ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute)). With accepted `BUILD-MAP-C`, exactly one function body remains: non-turbo when `f=false`, turbo when `f=true`. When `f && t=W`, the `compile_error!` item remains; each matched standard-library page says it “Causes compilation to fail with the given error message when encountered” ([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). Thus all policy-excluded wasm-turbo combinations are rejected.
+
+`h`, profile, and debug assertions select no source and affect no arithmetic, panic, layout, or unsafe premise. Target affects only the rejection above. Consequently the body proofs are parametric over those axes and exhaustive over `C`.
+
+**INV-SOME.** In the turbo body, on reaching `unwrap_unchecked`, the unchanged local `value` is not `None`. Its owner is that function activation; `is_none` establishes the branch fact through a shared borrow, the early return discharges the `None` case, and `unwrap_unchecked` immediately consumes the fact.
+
+## Obligation ledger and proofs
+
+| ID | Obligation and derivation | Domain | Status |
+|---|---|---|---|
+| CFG-1 | Exclusive bodies and wasm rejection, derived above from version-matched cfg/compile-error rules plus `BUILD-MAP-C`. | `C` and rejected `f,W` cases | PROVED |
+| SAFE-1 | With `f=false`, `unwrap_or(0)` is safe and its documented behavior returns the contained `Some` value or the supplied default. | all non-turbo `C` | PROVED |
+| UNSAFE-1 | With `f=true`, `is_none()==true` returns `0`. Otherwise, `INV-SOME` holds. Version-matched docs state “Returns `true` if the option is a `None` value” and “Calling this method on `None` is undefined behavior”; contraposition of the first discharges the second operation's sole safety condition. `unwrap_unchecked` then returns the contained `Some` byte. | turbo `C` (therefore only `X,A`) | PROVED |
+| POST-1 | `None` reaches `0`; `Some(b)` reaches `b`, by `unwrap_or` or the checked turbo partition. These cases exhaust `Option<u8>`. | all `C` | PROVED |
+
+Version-matched Option contracts (including the `unwrap_or` and `unwrap_unchecked` result clauses): [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+## TCB audit log
+
+**TCB identity:** supplied `TCB.md` plus the versioned authoritative axioms listed here.
+
+| ID/category | Exact admitted proposition; scope; disposition | Consumer / trigger |
+|---|---|---|
+| `BUILD-MAP-C` / accepted build-tool premise | Only the exact Cargo-to-`feature` and target-to-`target_arch` mappings stated in `TCB.md`, for bundled 1.84/1.85/1.86 Cargo and the supplied manifest/source. **It admits no Rust semantics, branch correctness, other-version compatibility, or backend correctness.** | CFG-1; every trigger listed in `TCB.md` |
+| `AXIOM-OPT-{84,85,86}` / Rust std | Exact method propositions on the nine version-matched Option links above. Verified, authoritative. | SAFE-1, UNSAFE-1, POST-1; Rust version/docs change |
+| `AXIOM-CFG-{84,85,86}` / Rust Reference+std | Exact cfg effects/predicate semantics and `compile_error!` effect on the six version-matched links above. Verified, authoritative. | CFG-1; Rust version/docs or source cfg change |
+
+There are no dependency, implementation, external-specification, environment, probabilistic, or tool-result premises. `BUILD-MAP-C` is applied only to its authorized consumers. No rejected or pending premise is consumed.
+
+## Finding DOC-1 — local proof comment is deficient
+
+**Implementation:** PROVED; **proof artifact:** deficient. The comment says the `None` case returned and concludes `Some`, but omits the material links: `is_none`'s result contract, preservation of `value` across its shared borrow, the exact `unwrap_unchecked` safety clause, and its consumed result guarantee. No UB witness or defined postcondition refutation exists.
+
+Proposed adjacent replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`; that branch returned.
+// It only shared-borrowed `value`, so this unchanged value is not `None`.
+// This satisfies `unwrap_unchecked`'s safety condition; it returns the
+// contained `Some` byte, preserving this function's postcondition.
+```
+
+Minimum resolution is documentation-only; changing behavior or contracts would require a fresh audit.
+
+## Residual scope and re-audit triggers
+
+The unresolved policy precedence is residual governance scope, not uncovered soundness scope. Re-audit on any source/manifest/policy/TCB change; expansion of versions, targets, features, profiles with code-affecting behavior, or accepted configurations; material changes to cited Rust documentation; or addition of dependencies, generated code, FFI, concurrency, or other unsafe operations. Every in-scope operation, safe surface, configuration class, mandatory postcondition, citation, and consumed TCB entry has a disposition; no conclusion relies on testing or absence of a counterexample.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r005/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r005/1/attestation.json
new file mode 100644
index 0000000000..54bb2854ae
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r005/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r005",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:37:10.686501Z",
+  "report_sha256": "57b8763022b39ffe547decc694003c7ce27f6f5e9caec5020f8c3174c53935f5",
+  "run_id": "r005",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1155
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r005/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r005/1/report.md
new file mode 100644
index 0000000000..35b8c6bab7
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r005/1/report.md
@@ -0,0 +1,76 @@
+# Focused unsafe-Rust audit
+
+## Claim and verdict
+
+**Snapshot:** the complete supplied `lib.rs`; no generated code, dependencies, macros, FFI, assembly, or prior audit. **Supported set:** Rust and standard library 1.82.0, every target on which this source and the used items exist, and every ordinary profile. **Claim:** every well-typed safe use of the safe surfaces is free of Rust undefined behavior, provided any out-of-scope unsafe-trait implementation satisfies its published contract; the in-scope `unsafe impl` must satisfy that contract. This is a source-level claim under documented Rust abstract semantics, not a compiler-binary claim.
+
+**Combined soundness verdict: UNSOUND (F-CB).** `callback_index::read` and `write` each admit a wholly safe call that violates `get_unchecked[_mut]`'s precondition. The review did not stop at that aggregate result:
+
+- `callback_index`: `Position` alone is sound, but `read` and `write` are each **UNSOUND**.
+- `local_proof::last`: implementation **PROVED**; existing `SAFETY` comment **deficient** (F-LP).
+- `published_lane`: `Lane`'s contract, `High`'s `unsafe impl`, and `read` are **PROVED** for valid implementations (P-PL). Unknown downstream implementations and consumers do not change that literal result.
+- Mandatory documented guarantee: `High` supplies both published `Lane` constant requirements, **PROVED**. No `CONTRACT-BROKEN` witness is established.
+
+**TCB:** TCB-1 below contains only Rust 1.82 authoritative axioms; there are no additional assumptions, dependency entries, tool-derived facts, or conditional application claims. No build, test, execution, or expansion was performed.
+
+## Boundary and obligation coverage
+
+| ID | Language-reachable surface | Status / obligation |
+|---|---|---|
+| C1 | safe public `Position` and caller implementation of `position` | A safe implementation may return every `usize`; no in-bounds invariant follows. |
+| C2 | safe public `read<P: Position>` | Must prove returned position `< bytes.len()`; false (F-CB-R). |
+| C3 | safe public `write<P: Position>` | Same obligation; false (F-CB-W). |
+| L1 | safe public `last` | Empty and nonempty paths covered; implementation P-LP, comment F-LP. |
+| P1 | public `Word` tuple constructor/field; public `High` constructor | `[u32; 2]` fixes field length at two; safe construction/access introduces no stronger invariant. |
+| P2 | public unsafe `Lane`, `INDEX`, `NAME`; `unsafe impl Lane for High` | Literal implementer contract and both `High` clauses covered by P-PL-I. |
+| P3 | safe public `published_lane::read<L: Lane>` | Requires `L::INDEX < word.0.len()`; P-PL-R derives it. |
+
+There are no hidden/configuration-specific items, callbacks other than `Position::position`, custom trait methods, custom destruction, or generated surfaces in this file. Built-in auto-trait/destruction behavior creates no additional unsafe consumer here.
+
+## TCB-1: authoritative premise log
+
+All entries are accepted as the request's governing Rust 1.82 authority, apply to the full supported set, and are rechecked if that version/scope changes.
+
+- **AX-SHARED:** [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) returns a reference without bounds checking and states: “Calling this method with an out-of-bounds index is undefined behavior”. Consumers: C2, L1, P3.
+- **AX-MUT:** [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) gives the same quoted rule for a mutable reference. Consumer: C3.
+- **AX-LENGTH:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when that length is zero. Consumers: L1, P1/P3.
+- **AX-INTEGER:** the [`usize` table](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types) gives minimum zero; the [binary-operator table and overflow rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators) define integer subtraction. Thus for a `usize n != 0`, `n - 1` is representable and strictly below `n`. Consumer: L1.
+- **AX-TRAIT:** the [unsafe-trait description](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait) says an unsafe trait has extra safety conditions “that must be upheld by implementations of the trait”; the [trait rules](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits) state that a correctly implemented unsafe trait is safe to use. Consumers: P2/P3.
+
+No rejected or pending premise is consumed.
+
+## Findings and proofs
+
+### F-CB — safe callback results reach unchecked indexing
+
+**Implementation: UNSOUND; proof artifact: missing.** `Position::position` has no contract or enforcement restricting its result. A safe caller may define `P::position` to return `0`. In one valid execution, `read(&[], &P)` calls `get_unchecked(0)`; in a separate valid execution, `write(&mut [], &P, value)` calls `get_unchecked_mut(0)`. Index zero is out of bounds for the empty slice, so AX-SHARED/AX-MUT proves UB even if the resulting reference were not used. These witnesses use only safe caller syntax and work throughout the supported set. They establish F-CB-R and F-CB-W independently. No UB-free postcondition refutation is claimed.
+
+**Smallest repair:** retain all public signatures and make the two accesses safe-indexing expressions: `bytes[position.position()]` and `bytes[position.position()] = value`. Then arbitrary safe callback results cause a bounds-check panic rather than forming an unchecked out-of-bounds reference, while safe callers still choose positions and both read/write remain callable. Removing `Position` in favor of `usize` is possible but is a larger, source-breaking change and is not needed for soundness. This proposal is **not implemented and not certified**; the resulting snapshot needs a fresh audit.
+
+### F-LP — correct implementation, inadequate local proof
+
+**P-LP reconstructed proof:** On the `None` branch there is no unsafe operation. On the other branch, AX-LENGTH turns `!bytes.is_empty()` into `n = bytes.len() != 0`. Since `n: usize`, AX-INTEGER gives `n >= 1`, makes `index = n - 1` non-overflowing in every profile, and gives `index < n`. AX-SHARED's bounds obligation is therefore satisfied; it returns the last element reference, and copying its valid `u8` yields `Some(last byte)`. This proves implementation soundness over every supported target/profile.
+
+The existing comment, “This is the fast path,” states none of the required facts or implication. Replace it with:
+
+```rust
+// SAFETY: The else branch means `bytes.len() != 0`. Therefore
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// which satisfies `get_unchecked`'s bounds requirement.
+```
+
+### P-PL — published unsafe-trait composition
+
+**P-PL-I:** `High::INDEX` is `1`, hence less than `2`; because it is `1`, the contract requires and the impl supplies `NAME == "high"`. The `INDEX == 0` implication is vacuously true. Thus the in-scope `unsafe impl` discharges every literal clause, including the clause unused locally.
+
+**P-PL-R:** for every valid `L: Lane`, its published contract supplies `L::INDEX < 2`. `word.0` has exactly two elements, so the index is in bounds and AX-SHARED discharges `get_unchecked`. `read` consumes no `NAME` proposition.
+
+An incorrect unknown downstream `unsafe impl` violates its out-of-scope obligation and is not a valid implementation; it does not add a hidden precondition to safe callers. Conversely, unknown downstream consumers may rely on both `INDEX` and `NAME`. Because this is a published 1.x contract, deleting/weakening either guarantee or strengthening implementer obligations requires compatibility handling; the absence of a repository-visible `NAME` consumer is not evidence that weakening is safe.
+
+## Configuration closure, residual scope, and triggers
+
+There are no source selection axes. The proofs are parametric in target and ordinary profile: slice/array lengths and the non-overflowing arithmetic relation are unchanged; both callback witnesses remain available. No generated artifact or enforced exclusion exists or is needed.
+
+Excluded from the source theorem are correctness of a particular compiler/backend binary and downstream unsafe implementations that breach `Lane`. Unknown downstream consumers were intentionally not treated as enumerable. The proposed repair remains outside the audited snapshot.
+
+Re-audit on any source or safety-contract change; Rust/standard-library version or supported-set change; addition of cfg, generation, dependencies, or new consumers; or any evolution of the published `Lane` guarantees. No authoritative-documentation or skill-guidance gap blocked this audit. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r006/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r006/1/attestation.json
new file mode 100644
index 0000000000..70d7a717fd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r006/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r006",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:36:30.454412Z",
+  "report_sha256": "dc42456b7c1205f0bfb4134d4928bd38b7804f990e4dfb1559639e4efd31d933",
+  "run_id": "r006",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1131
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r006/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r006/1/report.md
new file mode 100644
index 0000000000..ed84758bb6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r006/1/report.md
@@ -0,0 +1,59 @@
+# Unsafe Rust audit: `cross-axis-target` supplied snapshot
+
+## Claim and verdict
+
+**Source-soundness claim.** For every well-typed safe use of the complete supplied crate under `Required` below, execution is free of Rust undefined behavior under Rust 1.85.1 abstract semantics, relative only to `BUILD-MAP-X` and the cited Rust axioms.
+
+**Verdict: UNSOUND over the complete supported domain (F-1).** The supported region `aarch64-unknown-linux-gnu + burst + arena` admits the safe call `lane_id(0)`, which reaches an operation documented to have undefined behavior for zero. Soundness is `PROVED` for the complementary supported region, relative to the stated TCB.
+
+**Documented behavior:** `UNPROVED` overall. The nonzero result behavior and the promised zero panic are proved in the complementary region. In the defective region, the only established zero execution contains UB, so it cannot witness `CONTRACT-BROKEN`; the promised panic remains `UNPROVED` there. Build-interface behavior and the required `wasm32 + arena` rejection are `PROVED` relative to `BUILD-MAP-X`.
+
+**Combined mandatory result:** `UNSOUND` soundness / `UNPROVED` documented postconditions. No conditional application claim is requested.
+
+## Snapshot and supported set
+
+The artifact is exactly the supplied `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, and `REQUEST.md`; no VCS identity, lockfile, dependency, generated source file, or prior audit is supplied. Edition 2021 and Rust/Cargo/stdlib 1.85.1 apply. Audit cutoff: 2026-08-01. Skill identity: supplied unsafe-rust package snapshot. No build, expansion, execution, or test evidence was used.
+
+`Required` is every Cargo build using the supplied manifest and build script, Rust/Cargo 1.85.1, target in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, either `burst` state, allocator `system` or `arena`, every Cargo profile, and either debug-assertion state, except `wasm32-unknown-unknown + arena`. Allocator selection is only the `BUILD.md` interface: missing/`system` means `system`; `arena` means `arena`. Invented rustc cfgs and other targets/toolchains are outside the theorem.
+
+Configuration partition is exhaustive: let `S = aarch64 + burst + arena`; all supported library builds are either `S` or `Required \\ S`. Profile and debug-assertion axes are irrelevant because neither controls source and no debug assertion is used.
+
+The build script has no unsafe code. On successful stdout writes, its match maps only `system`/`arena` to one interpolated selector; missing input first becomes `system`; invalid Unicode or any other string panics. `BUILD-MAP-X` supplies only the exact Cargo/env/cfg mapping and the fact that script/write failure yields no library compilation. For an accepted selector, Cargo therefore supplies exactly one value. The first two `compile_error!` guards reject absent/both selectors defensively. `wasm32 + arena` selects the third guard and fails compilation, satisfying the mandated exclusion; invalid environment values fail earlier. Conditional source selection and compilation failure use the Rust 1.85.1 [`cfg`](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation), [`cfg` attribute](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), and [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html) contracts.
+
+## Boundary, invariants, and obligations
+
+The sole downstream surface is safe public free function `lane_id(u8) -> NonZeroU8`. There are no public representation fields, traits/impls, exported macros, hidden items, callbacks, FFI, statics, or custom destruction. Its safety invariant is `NZ`: every normally returned `NonZeroU8` contains a nonzero input value. `lane_id` produces `NZ`; `NonZeroU8::new_unchecked` consumes the proposition `value != 0` and establishes the result.
+
+| ID | Site/domain | Exact obligation | Derivation and status |
+|---|---|---|---|
+| O-1 | `lib.rs:31`, `S` | `value != 0` before `new_unchecked` | For nonzero inputs, immediate. For zero, no check, type restriction, or unsafe caller obligation exists. **UNSOUND** via F-1. |
+| O-2 | `lib.rs:44`, `Required \\ S` | `value != 0` before `new_unchecked` | `value == 0` selects the diverging panic branch; normal reach therefore entails inequality. This discharges the exact callee precondition and establishes `NZ`. **PROVED** for both unwind/abort behavior because neither continues to line 44. |
+| O-3 | safe `lane_id` surface | all safe inputs avoid UB | O-2 proves the complement; O-1 refutes `S`. **UNSOUND overall**. |
+| O-4 | `# Panics` contract | every `value == 0` call panics | Proved in the complement. The `S` zero execution has UB, so no defined refutation is established and the regional/overall result is **UNPROVED**, not `CONTRACT-BROKEN`. |
+| O-5 | build/support policy | admitted cfgs are exhaustive; rejected cases produce no library | Source partition above plus `BUILD-MAP-X`; `wasm32 + arena` reaches `compile_error!`. **PROVED**. |
+
+The material Rust 1.85.1 axiom is [`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked): “This results in undefined behavior if the value is zero”; its Safety clause says “The value must not be zero.” Equality means `PartialEq::eq` ([comparison operators](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)), and an [`if` expression](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) executes the block selected by its Boolean condition. These premises directly yield O-1/O-2; no backend or optimizer premise is used.
+
+## F-1 — unchecked zero in a supported safe configuration
+
+- **Status/severity:** `UNSOUND`, critical; implementation defective and `lib.rs:30` proof comment false.
+- **Witness:** Select supported Rust/Cargo 1.85.1, `aarch64-unknown-linux-gnu`, feature `burst`, allocator `arena`, any profile/debug-assertion state, successful build-script writes; then well-typed safe code calls `lane_id(0)`. `BUILD-MAP-X` makes all three cfg predicates true. Lines 24–32 are retained and lines 34–45 are not. Line 31 executes `NonZeroU8::new_unchecked(0)`, and AXIOM-NZ states that this is UB.
+- **Smallest false implication:** “burst-mode lane identifiers” does not imply `value != 0`; `burst` is only a Cargo feature bit and the unrestricted `u8` parameter admits zero. The comment supplies neither a check nor an enforceable caller obligation.
+- **Resolution:** remove the special unchecked branch or perform an unconditional zero check before every `new_unchecked` call (prefer a checked safe constructor). A safety-comment edit alone cannot repair a safe API. Re-audit all configuration branches afterward.
+- **Compatibility:** the fix enforces the already documented panic and adds no valid caller obligation. Making the function unsafe would be a breaking and unnecessary alternative.
+
+## TCB audit log
+
+| ID/category | Exact proposition, scope, disposition | Consumer / trigger |
+|---|---|---|
+| `BUILD-MAP-X` / accepted build-tool premise | Exactly the proposition and identity in supplied `TCB.md`, including selector/feature/target mapping and failure-to-no-compilation; accepted by the authorized human. It does **not** trust local source correctness or binaries. | O-1, O-5; every trigger listed in `TCB.md`. |
+| `AXIOM-NZ-185` / Rust std authority | The quoted `new_unchecked` precondition and zero-UB result for std 1.85.1; accepted under the request's authority policy. | O-1, O-2; Rust/std or contract change. |
+| `AXIOM-CONTROL-185` / Rust Reference authority | Cited equality, `if`, conditional-compilation, attribute, and compile-error semantics for Rust 1.85.1; accepted under the same policy. | O-1, O-2, O-5; toolchain/Reference change. |
+
+No dependency, tool, external-specification, deployment, probabilistic, compiler-backend, or binary-correctness premise is consumed. This does not widen `TCB.md`'s sole accepted human implementation premise.
+
+## Residual scope and review triggers
+
+Unsupported toolchains/targets, invented cfgs, `wasm32 + arena` artifacts (none are produced), invalid allocator inputs, and compiler/backend/binary correctness are outside the source theorem. Build-script write failure also produces no library compilation under the accepted premise. No inaccessible in-scope source or generated artifact was identified.
+
+Re-audit on any supplied source/doc change; Rust/Cargo/stdlib or target-set change; feature, allocator, env, cfg, manifest, profile, or panic-policy change; change to `BUILD-MAP-X` or its human disposition; or change to a cited authoritative contract. Every in-scope obligation above has a disposition; the sole UB witness is source-derived, not test-derived.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r007/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r007/1/attestation.json
new file mode 100644
index 0000000000..8b94ce36a8
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r007/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r007",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:41:27.761337Z",
+  "report_sha256": "98fe0f05b276a3cd41156e7d3568f698c2232410faed435a32f8b27626172091",
+  "run_id": "r007",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 962
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r007/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r007/1/report.md
new file mode 100644
index 0000000000..2daf3a9a34
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r007/1/report.md
@@ -0,0 +1,67 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, domain, and verdicts
+
+**Snapshot and scope.** This is a source-level review of `lib.rs` exactly as supplied. The in-scope boundary is its public `Slot`, `Tail`, and `increment` items and the single unsafe operation inside `increment`. No generated artifacts, dependencies other than Rust 1.82.0 `std`, or tool-derived evidence were supplied or used; the source was not built, tested, executed, or expanded.
+
+Let
+
+`Required(r,t,p) := (r = Rust/stdlib 1.82.0) && source-and-used-items-exist(t) && ordinary-profile(p)`.
+
+This preserves the request's target and profile predicates symbolically. There are no `cfg`s, features, generators, FFI, assembly, allocator choices, concurrency, profile-dependent assertions, or ordinary overflowing `+` operations in the source. Both proofs below are parametric in `t` and `p`; thus no finite target/profile inventory is assumed.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe use of the current public surface is free of Rust UB over `Required` | **UNSOUND** | `F-1` gives a valid safe call that executes `get_unchecked_mut(2)` on a length-2 array; this is UB. The witness works throughout `Required`. |
+| For every initial `[a,b]`, current `increment::<Tail>` returns with `[a, b+1 mod 2^32]` without UB over `Required` | **PROVED** | `P-TAIL` below; aggregate `Covered = Required`, so `Required ⊆ Covered`. |
+
+The combined current-artifact soundness result is **UNSOUND**. The proved `Tail` subcase neither narrows the current safe generic API nor changes that verdict. There is no source-documented postcondition for generic `increment`; the second claim is the behavior expressly required by the request.
+
+**TCB-1.** No additional TCB assumptions are admitted. The only ground premises are these verified, version-exact authoritative standard-library axioms:
+
+- `AXIOM-BOUNDS`: Rust 1.82.0 says, “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” It also says the method returns a mutable reference to the indexed element/subslice. [slice::get_unchecked_mut](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+- `AXIOM-WRAP`: Rust 1.82.0 specifies modular addition, “wrapping around at the boundary of the type.” [u32::wrapping_add](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)
+
+These axioms apply to every member of `Required` by construction (exact Rust/stdlib version, and only targets where the items exist).
+
+## Boundary, invariants, and obligation ledger
+
+The complete crate-owned surface is: public safe trait `Slot`; its safe implementer-controlled `index() -> usize`; publicly constructible unit struct `Tail`; the safe `Slot for Tail` impl returning `1`; and public safe generic function `increment<S: Slot>`. There are no unsafe declarations, fields, impls, macros, hidden items, callbacks, or explicit constructors beyond the unit-struct constructor. Downstream safe code may implement `Slot` for a downstream-local type. No invariant enforces `S::index() < 2`; documentation cannot supply a hidden safety precondition to either safe boundary.
+
+| ID | Proposition and disposition |
+|---|---|
+| `O-OPEN` | Every safe `Slot` implementation used by `increment` must return an index below 2. **False:** neither the type nor validation, privacy, or sealing enforces it. |
+| `O-BOUNDS` | At the unsafe call, `S::index()` must be in `0..2`. **False in general** by `F-1`; true for `Tail`. |
+| `O-TAIL` | `Tail::index() = 1` and `1 < 2`. **Proved directly from the impl and array type.** |
+| `O-POST` | The selected element receives old value plus one modulo `2^32`. **Proved for `Tail`** from `O-TAIL`, the returned-reference postcondition, assignment, and `AXIOM-WRAP`. |
+
+`P-TAIL`: for input `[a,b]`, the inspected impl makes the index exactly `1`; a `[u32; 2]` has indices `0` and `1`. `AXIOM-BOUNDS` therefore is not violated, and `get_unchecked_mut` returns a mutable reference to element 1. `wrapping_add(1)` produces `b+1 mod 2^32`; assignment writes that value only to element 1, leaving element 0 as `a`. These facts do not vary by target or ordinary profile.
+
+The unsafe block has no adjacent `SAFETY` proof. That proof artifact is missing, but prose cannot repair the false generic obligation; the implementation must change or the implementer set must be enforced.
+
+## F-1 — open safe trait makes the safe function unsound
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+This is a well-typed, entirely safe downstream use: `Slot` and its method are safe and public, and the implementation uses a downstream-local type. The call reaches the unsafe operation because `Bad::index()` returns normally. The exact required proposition is `2 < pair.len()`; it is false because `pair.len() = 2`. `AXIOM-BOUNDS` then entails UB at the call itself, even before any use of the returned reference. This completes the existential `UNSOUND` certificate for every `Required` configuration. No separate UB-free postcondition refutation is claimed.
+
+## Recommended provable abstraction
+
+The minimum capability is not implementer-selected indexing; it is one fixed transformation. Delete `Slot`, `Tail`, their impl, and the generic parameter, and implement only:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+**Proposed contract.** This safe function has no caller-side safety precondition beyond a well-typed `&mut [u32; 2]`. On return, element 0 equals its old value and element 1 equals its old value plus one modulo `2^32`. It has no representation invariant or unsafe surface. Constant safe indexing is within the type-enforced length; even an indexing defect would panic rather than create an unchecked reference.
+
+**Migration/contract delta.** Replace `increment::<Tail>(&mut pair)` with `increment(&mut pair)`. Remove construction/naming of `Tail`, downstream `Slot` implementations, and generic calls; the request explicitly permits all of these breaking source/API changes and states the abstraction is unreleased. The required `Tail` behavior is unchanged, while unsupported extensibility and its hidden range obligation disappear.
+
+This is an unimplemented proposal, not a `PROVED` new artifact. After implementation, freshly audit the exact snapshot: enumerate remaining exports/reexports/generated surfaces; verify all old generic paths are gone; prove both output clauses and any promised panic behavior from applicable Rust 1.82.0 contracts; re-establish `Required ⊆ Covered`; and recheck that no unsafe operation or invariant remains. Re-audit on source/API changes, Rust or support-domain changes, newly generated surfaces, or material changes to either consumed standard-library contract.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r008/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r008/1/attestation.json
new file mode 100644
index 0000000000..0a0f3041ad
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r008/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r008",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:42:22.792644Z",
+  "report_sha256": "6ff6a7e4a093b5a955df9709844c232c585146e16d159b1c5a51e93e53dee468",
+  "run_id": "r008",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 895
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r008/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r008/1/report.md
new file mode 100644
index 0000000000..d0a4f0c6f1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r008/1/report.md
@@ -0,0 +1,60 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+This is a source-level review of the two exported functions in the submitted `lib.rs`, relative to Rust 1.80.0 abstract semantics. The inspected snapshot consists of `lib.rs`, `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, `TCB.md`, and `REQUEST.md`. The manifest selects edition 2021 and pins `peer-unsafe-dep = "=3.4.5"`; the submitted dependency record says that 3.4.5 is the exact resolution. No prior audit, dependency body, generated dependency output, binary, or tool result was supplied or reused.
+
+Define the common compilation predicate
+
+`D(c) := rust(c) = 1.80.0 ∧ edition(c) = 2021 ∧ target(c) is a target on which this source and exact peer-unsafe-dep 3.4.5 resolve ∧ profile(c) ∈ {ordinary debug, ordinary release}`.
+
+This is exactly the support expression in `REQUEST.md`, with the manifest facts conjoined; no target inventory or exclusion replaces it. The target and profile axes remain symbolic. The source has no `cfg`, feature declaration, generator, FFI, assembly, allocator, concurrency, or profile-dependent branch. The proofs below are therefore parametric in every `c` satisfying `D`. Unavailable dependency configuration paths are not excluded; they cause the second claim's gap.
+
+The API inventory is complete for the submitted crate source: one safe public free function, `force_unreachable`, and one unsafe public free function, `delegated_nonzero`; there are no fields, types, traits, impls, macros, callbacks, hidden APIs, reexports, or invariants. The only unsafe operations are their respective calls to `std::hint::unreachable_unchecked` and `peer_unsafe_dep::duplicate_nonzero`.
+
+## TCB and evidence disposition
+
+**AXIOM-UU (accepted):** the supplied Rust 1.80.0 standard-library page was opened and verified. Its Safety section states: “Reaching this function is Undefined Behavior.” The page is versioned 1.80.0 and supplies no narrower target/profile qualification. Per the human trust decision in `TCB.md`, this proposition applies throughout `D`. Source: [`std::hint::unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). Consumers: OBL-FU.
+
+**UNSAFE-DEP-PEER (not accepted):** no proposition about the implementation of exact `peer-unsafe-dep` 3.4.5 may be trusted. The exact pin establishes identity only. `TCB.md` expressly rejects such trust, and `DEPENDENCY-API.md` supplies a declaration and contract but no implementation assertion. Consumers: OBL-DN-SOUND and OBL-DN-RETURN.
+
+TCB identity is the submitted `TCB.md`; there are no other admitted implementation, compatibility, tool, or deployment propositions.
+
+## Claim 1 — `force_unreachable`
+
+**Exact claim.** For every `c` satisfying `D` and every well-typed safe call to `force_unreachable()`, the execution is free of Rust undefined behavior. Safe valid use has no caller-side safety precondition.
+
+**Verdict: UNSOUND throughout `D`.**
+
+**Existential certificate (OBL-FU):**
+
+1. In any `c ∈ D`, a safe caller may invoke the exported safe function `force_unreachable()`; this is a valid in-scope use.
+2. On entry, the body unconditionally evaluates `std::hint::unreachable_unchecked()`. There is no branch, check, input, or invariant that can prevent reaching it.
+3. Thus that valid call reaches the operation. Its required safety proposition—“this function is not reached”—is false.
+4. AXIOM-UU entails that reaching it is undefined behavior.
+
+This certificate is source-parametric over target and profile, so every member of `D` is affected. The local comment, “This site is assumed to be unreachable,” supplies no fact and is contradicted by public entry. This is both an implementation defect and a deficient proof artifact, not merely a documentation gap. No separate return-value postcondition is documented, and the UB-containing witness cannot establish `CONTRACT-BROKEN`.
+
+Minimum resolution: remove the reachable unchecked operation (for example, use a defined panic if non-return is intended) or establish non-reachability through an enforced boundary. A prose-only restriction cannot repair a safe API.
+
+## Claim 2 — `delegated_nonzero`
+
+**Exact valid-use domain.** For every `c` satisfying `D` and every call with `value ∈ {1, …, 255}` that observes the unsafe boundary, every permitted execution must be UB-free. The only documented initial obligation is `value != 0`; there are no documented ongoing or terminal obligations.
+
+**Verdict: UNPROVED.**
+
+**Local derivation (OBL-DN-CALLER, proved over all `D`):** the submitted dependency contract requires `value != 0`. A valid wrapper call supplies exactly that fact. The body forwards the same `u8` local, without transition, to `duplicate_nonzero`; therefore the dependency's caller-side precondition holds at the unsafe call. The adjacent safety comment adequately records this local bridge.
+
+**Smallest missing proposition (OBL-DN-SOUND):**
+
+> For exact `peer-unsafe-dep` 3.4.5, every `c ∈ D`, and every nonzero `v: u8`, every permitted execution of `duplicate_nonzero(v)` is free of Rust undefined behavior.
+
+Neither inspected source nor an accepted `UNSAFE-DEP` entry establishes it. Consequently the local caller obligation has coverage `D`, but provider-correctness coverage is established for no member of `D`; aggregate `Required ⊆ Covered` does not close. Absence of the body supplies no valid execution reaching UB, so the certificate for `UNSOUND` also does not close.
+
+The dependency documentation additionally says “Returns `value`.” If that provider guarantee is included as delegated wrapper behavior, **OBL-DN-RETURN is UNPROVED**: syntactically the wrapper returns the callee's result unchanged, but the missing proposition is that every valid call to the exact 3.4.5 implementation returns its input. No UB-free falsifying execution is supplied, so `CONTRACT-BROKEN` is not established.
+
+Minimum resolution: recursively audit the exact dependency implementation, including every path over `D`, or have an authorized reviewer accept precise `UNSAFE-DEP` propositions for UB freedom and any consumed return guarantee. The version pin or published unsafe contract alone is insufficient.
+
+## Closure, residual scope, and triggers
+
+For Claim 1, the refutation covers `D` parametrically. For Claim 2, only the wrapper-to-callee precondition proof covers `D`; the unavailable dependency implementation is the exact unresolved remainder. No tests or tools contribute evidence. Re-audit is required if either function or its documentation changes, `D` changes, Rust or AXIOM-UU changes, dependency identity/contract/implementation evidence changes, or the TCB disposition changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r009/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r009/1/attestation.json
new file mode 100644
index 0000000000..2ac83d8028
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r009/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r009",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:42:15.551566Z",
+  "report_sha256": "4bde4f56c31f9d422f72c61118fc884593ad0e9c897b3de60d37c1f1d7a2534d",
+  "run_id": "r009",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 890
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r009/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r009/1/report.md
new file mode 100644
index 0000000000..d1cf103692
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r009/1/report.md
@@ -0,0 +1,104 @@
+# Focused unsafe-Rust source review
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: exact `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is the sole public safe function `classify(u8) -> u8` and its internal
+unsafe call. This is a source-level review only; no compiler, backend, binary,
+test, generated artifact, dependency, or prior audit is in scope. Audit cutoff:
+2026-08-01. TCB: `TCB-R009-v1` below.
+
+Let `C` be exactly: Rust and standard library 1.80.0, any target on which this
+exact source and `std::hint::unreachable_unchecked` exist, and either ordinary
+debug or ordinary release profile. `Required = C × {input | input: u8}`; every
+such call is a valid safe use, with no caller-side safety precondition.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call is free from Rust UB | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked`; its Rust 1.80.0 contract makes reaching it UB. |
+| If `input == 0`, the call panics | **UNPROVED** | The only source path reaches UB, so it cannot be a UB-free contract-refutation witness or establish a panic. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | `classify(1)` has a UB-free normal return of `2`, and `2 != 1`. |
+
+The combined mandatory result is therefore not `PROVED`.
+
+## Boundary, cases, and obligation ledger
+
+The complete language-reachable surface is the safe free function at lines
+6–17. There are no public fields, types, constructors, trait implementations,
+callbacks, macros, hidden APIs, dependencies, or invariant-bearing state. The
+only unsafe obligation site is line 12.
+
+The partition `{0} ∪ {1} ∪ {2..=255}` equals the complete `u8` input set:
+
+- **Input 0.** A well-typed safe caller may invoke `classify(0)`. The `0`
+  pattern selects lines 8–13; the two local assignments do not alter control
+  flow, and line 12 is reached. Rust 1.80.0 documents: “Reaching this function
+  is Undefined Behavior.” Thus the required safety proposition at line 12
+  (“this call site is unreachable”) is false, and the documented consequence
+  is UB. This completes the existential `UNSOUND` certificate in every `C`.
+  The same execution cannot establish `CONTRACT-BROKEN` for the panic promise:
+  it contains UB as a whole. No separate UB-free zero-input execution or panic
+  derivation exists in the inspected source, so that promise is `UNPROVED`.
+  Likewise, this execution supplies no normal-return result witness.
+- **Input 1.** Line 14 returns `2` without executing the unsafe site. This is a
+  UB-free normal return, but the input is `1`; it therefore completes the
+  existential `CONTRACT-BROKEN` certificate for the unchanged-result promise.
+  It is not a soundness counterexample and the zero-input promise is
+  inapplicable.
+- **Inputs 2 through 255.** Line 15 returns the input itself and the unsafe site
+  is not executed. These calls are UB-free and satisfy the normal-return
+  promise. The zero-input promise is inapplicable.
+
+| ID | Exact obligation | Status |
+|---|---|---|
+| O-S0 | Safe `classify(0)` must not reach UB | **UNSOUND**, witness above |
+| O-SNZ | Safe calls for `1..=255` must avoid UB | **PROVED**, exhaustive nonzero branches above |
+| O-P0 | `classify(0)` must panic | **UNPROVED**, UB occurs with no panic proof |
+| O-R0 | Result clause for input 0, if normally returning | No UB-free normal-return instance established; not a refutation witness |
+| O-R1 | A normal return for input 1 must equal 1 | **CONTRACT-BROKEN**, UB-free result 2 |
+| O-RN | Normal returns for `2..=255` equal their inputs | **PROVED** |
+
+## Domain and configuration closure
+
+The request's predicate is retained verbatim as `C`; no version interval was
+invented. The source contains no `cfg`, feature selection, generated code,
+arithmetic, debug assertion, allocation, FFI, target feature, or panic-mode
+branch. Target and profile therefore do not change the match partition or
+dataflow. Both consumed Rust pages are versioned 1.80.0 and their relevant
+propositions have no narrower target/profile qualification. The proofs and
+witnesses above are consequently parametric over all `C`; debug/release and
+optimization do not rescue a source-level UB execution. Thus every required
+configuration is covered by the case analysis. There are no enforced or
+report-only exclusions and no uncovered configuration remainder.
+
+## TCB-R009-v1
+
+| ID | Accepted Rust 1.80.0 proposition | Scope and consumer |
+|---|---|---|
+| AXIOM-UU | [`unreachable_unchecked` Safety](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety): “Reaching this function is Undefined Behavior.” | Every `C`; O-S0 |
+| AXIOM-UB | [Reference: behavior considered undefined](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html): safe-client-triggerable UB makes unsafe code unsound; `unsafe` does not permit UB. | Every `C`; soundness classification |
+
+Both exact URLs were opened and their wording, version, and applicability were
+verified. They are accepted as versioned Rust authorities under the audit trust
+policy. No additional assumption, tool-derived fact, implementation premise,
+or safe/unsafe dependency is consumed. This does not claim binary-level
+compiler correctness.
+
+## Findings and resolution
+
+**F-1 — implementation unsound; proof comment false.** The line-11 comment
+merely assumes the exact property the callee requires and is contradicted by
+the dominating `0` match arm. A stronger comment cannot repair the code.
+Replace the zero arm's unsafe call with an operation that actually panics (for
+example `panic!`) and freshly audit the edited artifact.
+
+**F-2 — normal-return contract broken.** Line 14 must return `input` (therefore
+`1`) if the documented guarantee is retained. This UB-free witness is
+independent of F-1.
+
+There is no authoritative-documentation gap. Re-audit on any source or contract
+change, Rust/standard-library version change, support-domain expansion, or
+material change to either consumed authority. Every in-scope obligation and
+each distinct input region has a disposition; no test result or absence of a
+counterexample supports a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r010/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r010/1/attestation.json
new file mode 100644
index 0000000000..c1c5825cdc
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r010/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r010",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:49:55.218905Z",
+  "report_sha256": "78953c2a86ff27a79669c044278b47b0cb996b7bf6a47ca72e92fd5ec643ee43",
+  "run_id": "r010",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 814
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r010/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r010/1/report.md
new file mode 100644
index 0000000000..6a61888e9f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r010/1/report.md
@@ -0,0 +1,66 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**SOUND-1 — PROVED.** For the supplied `Cargo.toml` and `src/lib.rs`, every well-typed safe call to `value_or_zero` in every configuration admitted by either current policy is free from Rust undefined behavior under the documented abstract semantics of Rust 1.84.0, 1.85.0, and 1.86.0, relative only to accepted `BUILD-MAP-C` below.
+
+**POST-1 — PROVED.** Over the same domain, `value_or_zero(Some(x)) == x` and `value_or_zero(None) == 0`.
+
+**POLICY-IDENTITY — UNPROVED.** No evidence selects Scarlet or Indigo as *the* project promise. This does not weaken SOUND-1: its conservative domain is their union and therefore contains either candidate. The audit does not resolve or replace the published policies.
+
+Snapshot: exactly the supplied manifest, source, two policies, and `TCB.md`; edition 2021, `#![no_std]`, Rust/stdlib versions `V={1.84.0,1.85.0,1.86.0}`. No dependencies, generated artifacts, build scripts, macros producing APIs, FFI, assembly, allocator use, concurrency, or prior audit appear. This was source-only; nothing was built, run, tested, or expanded. Audit cutoff: 2026-08-01.
+
+## Domain and configuration closure
+
+Let `X`, `A`, `W`, `f`, and `h` have the policies' exact meanings, and universally quantify all Cargo profiles and both debug-assertion states. Preserve the controlling predicates:
+
+`S = !f ∨ (f∧t=X∧(!h∨v>=1.85)) ∨ (f∧t=A∧h)` (Scarlet)
+
+`I = !f ∨ (f∧t=X∧(h∨v>=1.86)) ∨ (f∧t=A∧!h∧v>=1.85)` (Indigo).
+
+With the common restrictions `v∈V` and `t∈{X,A,W}`, define conservative `Required=S∪I`. Exact Boolean normalization gives
+
+`Required = !f ∨ (f∧t=X) ∨ (f∧t=A∧(h∨v>=1.85))`.
+
+For `X`, the union contains `(!h∨v>=1.85)∨(h∨v>=1.86)`, which is true because it contains `!h∨h`. For `A`, direct distribution gives `h∨(!h∧v>=1.85)`. Neither predicate admits `(f,t=W)`.
+
+`BUILD-MAP-C` maps the Cargo features and three target triples to the source `cfg` predicates for every exact release/profile. In each release, the Reference says `cfg` conditionally includes its attached construct, and `compile_error!` causes compilation to fail when encountered: [1.84 cfg](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html); [1.85 cfg](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html); [1.86 cfg](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Thus `lib.rs:3-4` effectively rejects every `f∧t=W` build. The other two `cfg`s select exactly one function body.
+
+The semantic proof covers
+
+`Covered = !f ∨ (f∧t∈{X,A})`
+
+over all stated versions, `h`, profiles, and debug states. `Required⊆Covered` follows immediately from the normalized formula. `h`, profile, and debug state select no source and affect no proof step. Target affects only the proved rejection; the accepted `X/A` body is identical. The unsupported `(v=1.84,t=A,f,h=false)` compiles but lies outside both policies; rejection is not needed for the theorem.
+
+## Boundary, obligations, and proof
+
+The complete crate-defined public surface is one safe free function, with mutually exclusive bodies: `lib.rs:7-9` when `!f`, and `lib.rs:13-21` when `f`. There are no public fields, constructors, traits/impls, methods, statics, callbacks, reexports, hidden items, or generated APIs. There is no persistent invariant; turbo has only the local fact `L-SOME: value is not None` at line 20.
+
+Version-matched `Option` documentation independently states in each release that `is_none` returns true for `None`, `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB, and `unwrap_or` returns the contained value or its default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or). Each page also declares `Option`'s only variants, `None` and `Some`.
+
+| ID | Site/domain | Required proposition and derivation | Status |
+|---|---|---|---|
+| O-NON | lines 7-9; `!f` | `unwrap_or(0)` has no unsafe precondition and its exact contract yields `x` for `Some(x)`, otherwise `0`. | PROVED |
+| O-GUARD | lines 15-20; `f`, accepted `X/A` | If `None`, `is_none()` is true and line 16 returns. Fallthrough therefore implies not `None`; with the two-variant declaration, it is `Some`. The owned local is neither mutated nor exposed between check and call. | PROVED |
+| O-UNWRAP | line 20; same domain | `L-SOME` satisfies the unsafe call's exact non-`None` obligation; the call returns the contained byte. | PROVED |
+
+These cases prove UB freedom and POST-1, and their configuration union is `Covered`. No backward-compatibility assumption is used: all three versioned contracts were checked separately. No tool-derived evidence is used.
+
+## TCB audit log
+
+**BUILD-MAP-C — ACCEPTED, conspicuous.** Category: implementation/build-tool premise. Identity, proposition, scope, exclusion list, consumer restriction, approver, and triggers are exactly `TCB.md`. It is consumed only by configuration reachability, mutually exclusive body selection, and effective `f∧W` rejection—not by any Rust semantic or body-correctness step. Rust/std links above are authoritative axioms, not extra implementation assumptions. No other TCB entry is consumed.
+
+## Finding: local proof documentation
+
+**DOC-1 — implementation PROVED; proof comment deficient.** The existing line-19 comment conveys the core branch argument but does not name `unwrap_unchecked`'s exact obligation, the `is_none` contract, or the resulting postcondition. Suggested replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`; that branch returned, so
+// `value` is not `None`, satisfying `unwrap_unchecked`. It returns the
+// contained `Some` byte.
+unsafe { value.unwrap_unchecked() }
+```
+
+This is documentation debt, not an implementation defect or hidden caller obligation.
+
+Residual scope is limited to unsupported configurations and binary/backend correctness. Re-audit on any source, manifest, policy resolution/change, supported version/target/profile axis, relevant Rust documentation, or `BUILD-MAP-C` identity/disposition change. Every in-scope surface, obligation, postcondition, configuration transformation, and consumed premise has a disposition.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r011/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r011/1/attestation.json
new file mode 100644
index 0000000000..565d534450
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r011/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r011",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:50:08.459921Z",
+  "report_sha256": "745c8a81613a865eb7c42cf2f0b0d3c14f6e28b3aae745881d3a322e1fa409a3",
+  "run_id": "r011",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 982
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r011/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r011/1/report.md
new file mode 100644
index 0000000000..c651b97bb2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r011/1/report.md
@@ -0,0 +1,154 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Audited artifact.** Exact `lib.rs` with SHA-256
+`b2d9d02f117745925aa24c5b09461c200c3f36f1d1e026c1f289f971711dc122`,
+under `REQUEST.md` SHA-256
+`2d044b4aa4dca16c51aeedd3bd9db58d182a0929e6b73a98478fdc2710094b8f`.
+No generated source, dependencies, macros, FFI, or configuration branches occur
+in the inspected artifact. Audit date: 2026-08-01. Unsafe-Rust skill identity:
+`SKILL.md` SHA-256
+`a0a75ef8a14497aa78b50b459981097ee99605c57fec95c637cf59aaa20fe766`.
+
+**Supported set.** Exactly Rust and standard library 1.82.0; every target on
+which this source and its used standard-library items exist; every ordinary
+profile. This predicate comes directly from `REQUEST.md`. The proof and witness
+below are parametric in target and profile: the source has no `cfg`, profile,
+layout, pointer-width, panic-strategy, or generated-code branch relevant to
+them.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces is free
+of Rust undefined behavior under Rust 1.82's documented abstract semantics,
+with no caller-side safety precondition and no additional TCB assumptions.
+
+**Verdicts.**
+
+- Current-artifact soundness: **UNSOUND** over the entire supported set
+  (`F-1`).
+- Requested restricted behavior: **PROVED** for
+  `increment::<Tail>(&mut pair)`: if the input is `[a, b]`, normal return leaves
+  `[a, b.wrapping_add(1)]`, over the entire supported set (`P-2`).
+- Source-documented postconditions: none. Consequently there is no
+  `CONTRACT-BROKEN` finding. The user-requested `Tail` behavior is a separate
+  reviewed requirement, not a retroactive restriction on the current generic
+  safe API.
+- Combined current-artifact result: **UNSOUND**, irrespective of the redesign.
+  There is no conditional application claim.
+
+## Boundary and configuration coverage
+
+The complete public surface is: safe, downstream-implementable trait `Slot`
+and its safe associated function `index` (`lib.rs:3-5`); constructible unit
+struct `Tail` (`lib.rs:7`); the crate-owned safe `Slot for Tail` implementation
+returning `1` (`lib.rs:9-13`); and safe generic function `increment`
+(`lib.rs:15-18`). `increment` contains the sole unsafe operation. There are no
+fields, unsafe declarations/impls, hidden items, callbacks, reexports, or
+generated APIs. `Tail` carries no representation invariant. The relevant
+cross-call proposition would have to be an invariant of every `S: Slot`, but
+the safe trait boundary enforces none.
+
+Because both the counterexample and the `Tail` proof depend only on a
+two-element array, integer indices `1`/`2`, and the cited 1.82 contracts, they
+cover every target/profile in the supported predicate without enumeration.
+No test, build, execution, or tool-derived evidence was used.
+
+## TCB audit log `TCB-R011-1`
+
+No additional assumptions are admitted. These two accepted Rust 1.82
+authoritative axioms are the complete consumed TCB:
+
+- **AXIOM-GET.** For `slice::get_unchecked_mut`, an in-bounds index selects and
+  returns a mutable reference to that element; the Safety section states:
+  “Calling this method with an out-of-bounds index is undefined behavior even
+  if the resulting reference is not used.”
+  [Rust 1.82 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut).
+  Consumers: `P-1`, `P-2`. Re-audit if the Rust version or contract changes.
+- **AXIOM-WRAP.** `u32::wrapping_add` performs modular addition, wrapping at the
+  type boundary.
+  [Rust 1.82 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add).
+  Consumer: `P-2`. Re-audit if the Rust version or contract changes.
+
+Both exact pages were opened and their wording and version checked. There are
+no dependency, environment, implementation, probabilistic, or tool entries;
+no rejected or pending premises; and no prior audit was reused.
+
+## Obligation ledger and proofs
+
+**P-1 — unsafe call precondition: FAILED / UNSOUND.** At `lib.rs:16`, every
+executed `S::index()` must be in `0..2`; AXIOM-GET makes an out-of-bounds call
+UB. Neither `S: Slot` nor the safe trait contract constrains the result. A
+well-typed, entirely safe downstream witness is:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+The call reaches `get_unchecked_mut(2)` on a length-two array, hence UB by
+AXIOM-GET. The smallest false implication is
+`S: Slot => S::index() < 2`. A safe caller cannot be assigned this undocumented
+obligation.
+
+**P-2 — crate-owned `Tail` behavior: PROVED.** `Tail::index()` returns `1`
+(`lib.rs:11`); a `[u32; 2]` has indices `0` and `1`, so AXIOM-GET's bound is
+satisfied and the returned reference designates element 1. The only write is
+through that reference. AXIOM-WRAP proves the new value is the old value plus
+one modulo `2^32`; element 0 is untouched. This derivation is target- and
+profile-independent.
+
+**Proof artifact.** The unsafe block has no adjacent `SAFETY` proof. This is a
+missing proof artifact as well as an implementation defect: no truthful local
+comment can derive P-1 for the current generic safe contract. Documentation
+alone cannot repair it.
+
+## F-1 — unconstrained safe implementer controls an unsafe index
+
+- **Status/severity:** **UNSOUND / critical**; affects `increment` and the
+  aggregate safe-surface theorem on every supported configuration.
+- **Defect:** a caller-provided implementation of a safe trait supplies the
+  safety-critical bound without validation, sealing, or an unsafe implementer
+  contract.
+- **UB witness:** the safe `Bad` program above. **Defined postcondition
+  refutation:** not established or needed; the witness contains UB.
+- **Minimum resolution:** eliminate the unchecked operation, validate the
+  index, or enforce an implementer boundary. Merely adding a comment is
+  insufficient.
+
+## Recommended redesign
+
+The most parsimonious abstraction is no generic abstraction at all:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed safe contract has no precondition beyond a well-typed mutable
+borrow. For input `[a, b]`, it returns with `[a, b + 1 mod 2^32]`. The fixed
+array type and constant safe index enforce selection locally; AXIOM-WRAP
+supplies the arithmetic result. It removes the unsafe block, the behavioral
+implementer premise, the invariant fan-out, and all need for `Slot` and `Tail`.
+
+**Migration delta.** Delete public `Slot` and `Tail`; change
+`increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls and
+downstream `Slot` implementations cease to exist. This is a public breaking
+change, expressly authorized because the abstraction is unreleased and those
+uses need not be preserved. Required `Tail` behavior is unchanged.
+
+The proposal is not implemented and has no artifact verdict. After
+implementation, freshly audit the exact snapshot: enumerate its public
+surface; verify the fixed index, modular result, and preservation of element
+0; confirm absence of unsafe/generated/configuration-dependent paths; and
+re-establish Rust-1.82 target/profile closure. Re-audit on any source, API,
+support-predicate, or consumed standard-library-contract change.
+
+## Residual scope
+
+This is a source-level review of exactly the supplied files, not a compiler,
+backend, binary, or broader-crate certification. No authoritative-documentation
+or skill-guidance gap blocked the result. The unimplemented redesign remains
+outside the current-artifact verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r012/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r012/1/attestation.json
new file mode 100644
index 0000000000..a8d6e3a8c6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r012/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r012",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:48:57.604312Z",
+  "report_sha256": "f8c5a10d8f94f043be587dfcb073640526162160b8a5f33384c243d98ffc9e59",
+  "run_id": "r012",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 835
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r012/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r012/1/report.md
new file mode 100644
index 0000000000..36fedc61c8
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r012/1/report.md
@@ -0,0 +1,105 @@
+# Focused unsafe-Rust source review
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: target/lib.rs, SHA-256
+705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1.
+The only API in scope is the public safe free function classify at lib.rs:6–17.
+The audit is source-only; no build, execution, test, expansion, or source change
+was performed.
+
+Supported(configuration) means: this exact source; Rust compiler and standard
+library 1.80.0; every target on which this source and
+std::hint::unreachable_unchecked exist; and either ordinary debug or release
+profile. The claims quantify over every u8 input to a well-typed safe call.
+
+1. **Freedom from undefined behavior: UNSOUND.** The valid safe call
+   classify(0) reaches undefined behavior.
+2. **Input-zero panic guarantee: UNPROVED.** The zero-input execution contains
+   UB. It therefore cannot prove the documented panic, and that same execution
+   cannot serve as a UB-free witness for CONTRACT-BROKEN.
+3. **Normal-return result guarantee: CONTRACT-BROKEN.** The independent,
+   UB-free call classify(1) returns 2, not its input 1.
+
+The combined mandatory result is therefore not PROVED. These verdicts are
+source-level Rust conclusions relative to TCB-C1 below; they make no claim that
+a particular compiler backend emits a correct binary.
+
+## Contracts and complete API boundary
+
+- SND: every valid safe call is free of Rust UB.
+- PANIC: when input equals 0, the call panics.
+- RESULT: on normal return with value r, r equals input.
+
+classify is the complete language-reachable boundary: there are no public
+fields, types, constructors, methods, trait implementations, macros, hidden
+items, callbacks, FFI surfaces, dependencies, or generated artifacts. The only
+unsafe obligation site is lib.rs:12. No representation invariant exists. Its
+local precondition is that control must not reach
+std::hint::unreachable_unchecked.
+
+## Exhaustive derivation and witness classification
+
+The match at lib.rs:7 partitions all u8 inputs into disjoint, exhaustive cases.
+The proof is parametric over every supported target and both profiles because
+there is no conditional compilation, target-dependent operation, checked
+arithmetic, debug assertion, allocation, panic-mode-dependent cleanup, or
+generated code.
+
+| Input | Source path | Whole-execution result | Obligations |
+|---|---|---|---|
+| 0 | The 0 arm at line 8 performs two ordinary local operations, then necessarily calls the intrinsic at line 12. | Reaching that call is UB by AXIOM-UU. | Refutes SND and establishes UNSOUND. It does not establish CONTRACT-BROKEN for PANIC or RESULT because the execution as a whole contains UB; it also does not return normally. PANIC remains UNPROVED. |
+| 1 | The arm at line 14 directly evaluates to 2; the unsafe arm is not executed. | UB-free normal return of 2 through ordinary typed control flow. | SND holds for this input, PANIC is inapplicable, and 2 ≠ 1 gives the UB-free witness required to establish CONTRACT-BROKEN for RESULT. |
+| 2 through 255 | The wildcard arm at line 15 evaluates to input; the unsafe arm is not executed. | UB-free normal return of the original u8. | SND and RESULT are proved for every input in this range; PANIC is inapplicable. |
+
+Thus W0 = classify(0) is exactly an UNSOUND witness, while W1 = classify(1)
+is exactly a defined postcondition-refutation witness. Keeping them distinct is
+necessary: observations from W0 cannot establish a defined behavioral breach.
+
+## Unsafe-call proof review
+
+The safety comment at lib.rs:11 says the branch is “assumed to be unreachable.”
+That is not a proof and is false: the immediately controlling match selects the
+branch precisely for the valid value 0. Because classify is safe, no prose-only
+caller obligation may exclude that value. The required implication
+“input is 0 implies this program point is unreachable” is contradicted by the
+local control flow. This is both an implementation defect and a deficient proof
+artifact; no replacement SAFETY comment can justify the current reachable
+intrinsic.
+
+Minimal resolution: replace the zero arm with an actual panic and make the
+one arm return input (or remove that special arm). The resulting source would
+be a new artifact requiring fresh review.
+
+## TCB-C1
+
+Both entries were opened at their exact submitted Rust 1.80.0 URLs and accepted
+as authoritative axioms for the stated source/configuration domain.
+
+- **AXIOM-UU — accepted.** Rust 1.80.0 standard-library Safety text states:
+  “Reaching this function is Undefined Behavior.”
+  [Exact page](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+  Consumer: the line-12 obligation and W0. Re-audit on Rust/stdlib version,
+  item contract, source, target-domain, or support-policy change.
+- **AXIOM-UB — accepted.** The Rust 1.80.0 Reference identifies invoking UB via
+  compiler intrinsics as undefined behavior and defines unsafe code that safe
+  code can use to exhibit UB as unsound.
+  [Exact chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html).
+  Consumer: SND classification and whole-execution witness rule. Re-audit on
+  Reference, Rust version, source, or claim change.
+
+There are no safe/unsafe dependency, external-specification, implementation,
+tool, deployment, or probabilistic premises. No tool-derived evidence was
+used. TCB identity is this embedded TCB-C1; the supplied unsafe-rust package had
+no visible revision identifier.
+
+## Residual scope and review triggers
+
+Excluded are backend/binary correctness, configurations outside
+Supported(configuration), and behavior of any surrounding crate not supplied.
+There are no authoritative-documentation or skill-guidance gaps needed for
+these conclusions. Re-audit if lib.rs or its documentation changes, the exact
+Rust/stdlib version or supported target/profile set changes, either cited
+contract changes, or the function is placed in a materially different
+generated or external context.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r013/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r013/1/attestation.json
new file mode 100644
index 0000000000..7c8a3a743b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r013/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r013",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:57:24.668789Z",
+  "report_sha256": "e963c7770bfa0ee351fff523e1a2e992ade90c82028c9b017731d53e2319c647",
+  "run_id": "r013",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 937
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r013/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r013/1/report.md
new file mode 100644
index 0000000000..52da9e9ef5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r013/1/report.md
@@ -0,0 +1,61 @@
+# Source-only unsafe Rust audit
+
+## Claim, snapshot, and domain
+
+This audits exactly the four exported unsafe functions in `target/lib.rs`, under their published caller contracts, for absence of Rust undefined behavior and every documented postcondition. The snapshot is the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; no generated code, dependencies, tools, builds, or execution are involved. Audit cutoff: 2026-07-31. TCB revision: the submitted `TCB.md`.
+
+`SUPPORT.md` expressly defines complete finite sets, so no interval inference is used:
+
+- `V_ack = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+- `V_store = {1.80.0, 1.81.0}`
+- `V_copy = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+- `V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+
+For each, `Required` is its exact release set crossed with every target where the item exists, every ordinary debug/release profile, and every call satisfying its documented safety obligations. The explicit completeness statement proves equality between each list and its `Required` release projection. There is no `cfg`, generator, feature, or profile-dependent source. Target/profile coverage below is parametric: the cited abstract operation contract is unqualified over those axes, or the accepted TCB entry expressly quantifies over them.
+
+## Verdict ledger
+
+| API / component | Exact `Covered` release region | Regional and full-domain verdict |
+|---|---|---|
+| `acknowledge` soundness | `V_ack` | **PROVED** on `V_ack` |
+| `acknowledge` postconditions | No prose postcondition; unit return is covered on `V_ack` | **PROVED** for the signature-implied `()` return |
+| `store_word` soundness | `V_store` | **PROVED** on `V_store` |
+| `store_word`: destination contains `value` | `V_store` | **PROVED** on `V_store` |
+| `store_word`: old `u16` is not read | `V_store` | **PROVED** on `V_store` |
+| `store_word`: old `u16` is not dropped | `V_store` | **PROVED** on `V_store` |
+| `copy_byte` soundness | `V_copy` | **PROVED** on `V_copy` |
+| `copy_byte`: destination byte equals the pre-call source byte | `V_copy` | **PROVED** on `V_copy` |
+| `copy_byte`: source byte is preserved | `V_copy` | **PROVED** on `V_copy` |
+| `load_word` soundness | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+| `load_word`: return equals the initialized pre-call source `u32` | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+| `load_word`: source remains unchanged | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+
+Thus the strongest combined per-API verdicts are: `acknowledge` **PROVED**, `store_word` **PROVED**, `copy_byte` **PROVED**, and `load_word` **UNPROVED**. The combined four-API packet is **UNPROVED**. No submitted fact proves an existential UB execution or an UB-free postcondition counterexample, so neither **UNSOUND** nor **CONTRACT-BROKEN** is certified.
+
+## Proof certificates
+
+### `acknowledge`
+
+The inspected signature has no parameters, returns `()`, documents no additional caller obligation, and its body is exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` says precisely that, for every case in `V_ack` and the required target/profile axes, such evaluation is defined and returns `()`; `unsafe` only adds the static call obligation. The entry is restricted to this consumer. Hence aggregate `Covered = V_ack`, so `Required ⊆ Covered`.
+
+### `store_word`
+
+The only operation is `ptr::write::<u16>(dst, value)`. The caller contract supplies its two safety clauses: `dst` is properly aligned and valid to write one `u16`. The exact [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) authorities make those the operation requirements and specify overwrite with the supplied value without reading or dropping the old value. One authority applies to each member of `V_store`; their exhaustive union covers every required release. The source has no other operation or exit. Each soundness and postcondition obligation therefore has `Covered = V_store`, and their pointwise intersection is `V_store`.
+
+### `copy_byte`
+
+The source fixes `T = u8` and `count = 1`; its caller contract supplies readable initialized source, writable destination, alignment, and non-overlap. The accepted `COMPAT-COPY-180-182` entry preserves, for every `v ∈ V_copy` and required target/profile case, the exact 1.80.0 propositions for this operation: satisfaction of the safety contract, copying exactly one byte to `dst`, and leaving `src` unchanged, with `u8` size 1 and `Copy` semantics. Its verified bases are [`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy`](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html). The TCB expressly restricts consumption to `copy_byte`. Thus every obligation has `Covered = V_copy`; their intersection equals `Required`.
+
+### `load_word`
+
+The only operation is `ptr::read::<u32>(src)`. At 1.80.0 and 1.82.0, the caller supplies the cited operation's readable, aligned, initialized-source requirements. The respective [`read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) pages establish returning the read value while leaving source memory unchanged; the corresponding [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) discharge the copy/ownership bridge at those endpoints.
+
+No authority or accepted TCB entry applies these propositions to 1.80.1 or 1.81.0. Endpoint documentation, stability, and unchanged-looking source cannot supply semantic continuity. The smallest missing premise is: for each missing release and all required target/profile cases, `ptr::read::<u32>` retains the cited safety and result/source-preservation contract and `u32` retains the cited `Copy` semantics. Consequently `Covered = {1.80.0, 1.82.0}`, which does not contain `V_load`.
+
+## TCB, proof artifacts, and residual scope
+
+The only admitted non-authoritative premises are accepted OUT-OF-BAND entries `SEM-EMPTY-BLOCK-180-182` (consumer: `acknowledge`) and `COMPAT-COPY-180-182` (consumer: `copy_byte`). Their exact scopes, exclusions, and source/signature/contract/domain/disposition re-audit triggers are retained from `TCB.md`; neither is transferred to another API. All other consumed premises are the exact claim-specific versioned Rust pages above. No pending premise was used.
+
+The adjacent `SAFETY` comments correctly identify caller-contract forwarding but omit the material release-applicability and postcondition derivations reconstructed here. They should cite a canonical proof containing the exact authority/TCB entry and covered set. For `load_word`, comment wording cannot repair the missing 1.80.1/1.81.0 premise; resolution requires applicable authority or an explicitly accepted narrow compatibility entry.
+
+Re-audit on any source/signature/contract change, any supported-set or configuration expansion, material change to a cited page, or change to either TCB entry/disposition. Releases outside the four explicit predicates, binary/backend correctness, and broader robustness are excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r014/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r014/1/attestation.json
new file mode 100644
index 0000000000..f21e071f68
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r014/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r014",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:56:39.664876Z",
+  "report_sha256": "63ff5fdf0f56585dca05bde1ea6b36f118c19ad66ef40b0a10ff43349399c0ad",
+  "run_id": "r014",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 826
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r014/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r014/1/report.md
new file mode 100644
index 0000000000..5cb31ea3f5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r014/1/report.md
@@ -0,0 +1,60 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Source-level soundness — PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior for every supported configuration.
+
+**Documented behavior — PROVED, relative to `COMPAT-OPTION-184-186`.** Every such call returns the contained byte for `Some(v)` and returns zero for `None`.
+
+**Combined mandatory result — PROVED, relative to `COMPAT-OPTION-184-186`.** This qualification is material: no result here applies that entry outside `value_or_zero`, its two named `Option` propositions, or the supported region.
+
+The supported predicate, controlled by `SUPPORT.md:3-21`, is exactly: released stable Rust `r` with `1.84.0 <= r <= 1.86.0`; target in `{x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`; either `telemetry` state; every Cargo profile; and either debug-assertion state. `Cargo.toml:5` supplies Cargo's minimum, not the upper support cutoff. `CI.md` is sampling evidence only and does not narrow this predicate.
+
+## Snapshot, scope, and boundary
+
+Audited source is the complete supplied six-file snapshot (`Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`); no revision, dependencies, generated artifacts, build script, lockfile, or prior audit was supplied. This was source review only: no target execution, build, test, expansion, or tool-derived proof was used. Edition is 2021 and the crate is `no_std`.
+
+The sole public surface is safe function `value_or_zero(Option<u8>) -> u8` (`src/lib.rs:3-12`). There are no public representation fields, constructors for a crate-owned type, traits or impls, macros, reexports, hidden APIs, callbacks, statics, FFI, or configuration-specific APIs. The sole unsafe operation is the internal `Option::unwrap_unchecked` call at `src/lib.rs:11`; it is not a caller-facing unsafe boundary. No persistent representation invariant exists. The only transient invariant is **BRANCH-SOME**: after the `is_none()` true branch returns, the still-owned `value` is `Some(v)`.
+
+## Authorities and TCB log
+
+Rust 1.84.0 standard-library documentation states that [`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) “Returns `true` if the option is a `None` value.” The version-matched [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) contract says it returns the contained `Some` value and that calling it on `None` is undefined behavior.
+
+`TCB.md:3-23` is the accepted human trust decision and the complete additional TCB:
+
+| ID | Disposition | Exact admitted proposition and domain | Consumers |
+|---|---|---|---|
+| `COMPAT-OPTION-184-186` | accepted | Across the entire supported Rust/target/feature/profile/debug domain, the 1.84.0 base propositions are preserved: `is_none()` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`, while invocation on `None` is UB. | Only soundness and documented-result proofs below |
+
+It admits neither release membership nor Cargo/backend/binary facts. No safe or unsafe dependency, compiler implementation, platform, deployment, or other compatibility premise is consumed. Its stated re-audit trigger is any source, support interval, base-proposition, feature/target-scope, or human-disposition change.
+
+## Obligation ledger and derivation
+
+| ID | Site / exact obligation | Derivation over the supported predicate | Status |
+|---|---|---|---|
+| O1 | `lib.rs:5-7`: `None` behavior | By `COMPAT-OPTION-184-186`, `is_none()` is true exactly on `None`; the dominating branch returns literal `0`. No unsafe operation executes. | PROVED relative to TCB |
+| O2 | `lib.rs:11`: do not call `unwrap_unchecked` on `None` | Reaching line 11 means the true branch did not execute, hence `is_none()` was false. The same TCB proposition yields BRANCH-SOME, so the callee's sole documented UB case is excluded. | PROVED relative to TCB |
+| O3 | `lib.rs:11`: `Some(v)` result | BRANCH-SOME and the TCB-preserved postcondition give `unwrap_unchecked(Some(v)) = v`; the function immediately returns it. | PROVED relative to TCB |
+| O4 | Safe API, all executions | `Option<u8>` exhausts the `None` case (O1) and `Some(v)` case (O2-O3). Thus every well-typed safe input is UB-free and meets the sole documented result contract. | PROVED relative to TCB |
+
+Configuration closure is parametric, not empirical: the source has no `cfg`, feature use, profile/debug-dependent assertion, target-dependent operation, allocation, panic/unwind branch, concurrency, FFI, generated code, or build-time input. Consequently the same control/data-flow proof applies to every Cartesian combination in `Supported`; `COMPAT-OPTION-184-186` supplies exactly the only version-sensitive semantics. CI contributes no proof.
+
+## Finding: local proof documentation is deficient
+
+**Documentation defect; implementation remains PROVED relative to the TCB.** The `SAFETY` comment at `src/lib.rs:9-10` correctly names the branch fact and callee precondition, but omits the material bridge that `is_none() == false` implies `Some(v)` throughout every supported Rust release, and it does not identify the accepted compatibility premise on which that bridge and the result proof depend.
+
+Proposed replacement:
+
+```rust
+// SAFETY: By COMPAT-OPTION-184-186, throughout the supported domain
+// `is_none()` is true exactly for `None`. This continuation therefore has
+// `value = Some(v)`; the same accepted premise preserves that
+// `unwrap_unchecked(Some(v))` is permitted and returns `v`.
+unsafe { value.unwrap_unchecked() }
+```
+
+This is a proof-artifact repair only; it adds no caller obligation or new contract.
+
+## Residual scope and triggers
+
+Compiler/backend and binary correctness, unsupported toolchains/targets, and undocumented robustness properties are excluded. Re-audit on any source or public-documentation change; change to the supported predicate; change/rejection of `COMPAT-OPTION-184-186` or either cited base contract; addition of dependencies, generated code, configuration branches, unsafe operations, or public surfaces. All in-scope obligations have a disposition; no UB witness or UB-free postcondition refutation is established or needed for the proved theorem.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r015/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r015/1/attestation.json
new file mode 100644
index 0000000000..7455ebd8dd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r015/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r015",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T03:59:00.564276Z",
+  "report_sha256": "257b8bf9d452140b305849ae4e33edca5d395c7a878ed7ed5f0ab1b394b22ddb",
+  "run_id": "r015",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1153
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r015/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r015/1/report.md
new file mode 100644
index 0000000000..451a2f7b49
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r015/1/report.md
@@ -0,0 +1,72 @@
+# Unsafe Rust audit: `cross-axis-target` 0.1.0
+
+## Claim, snapshot, and verdicts
+
+Audit date/cutoff: 2026-08-01. Snapshot: the complete supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `src/lib.rs`, and `REQUEST.md`; no expansion, build, execution, tests, prior audit, dependency resolution, or repository metadata was used. Rust, Cargo, and standard library are exactly 1.85.1; edition 2021. Scope is source-level Rust abstract semantics, the build interface and rejection behavior, the sole public safe API, both unsafe calls, and documented panic behavior. There are no third-party dependencies or generated source; the build script generates cfg options.
+
+Let
+
+`Required(c) := rust=cargo=stdlib=1.85.1 ∧ Cargo/build.rs is used ∧ target∈{x86_64-linux-gnu,aarch64-linux-gnu,wasm32-unknown} ∧ burst∈{off,on} ∧ allocator∈{system,arena} ∧ ¬(target=wasm32-unknown ∧ allocator=arena) ∧ profile is any Cargo profile ∧ debug_assertions∈{off,on}`.
+
+Successful build-script stdout is implicit; accepted `BUILD-MAP-X` says a write/script failure produces no library compilation and hence no `Required` configuration. Let `H := burst=on ∧ target=aarch64-linux-gnu ∧ allocator=arena`.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe `lane_id(v)` use is UB-free for every `c∈Required` and `v:u8` | **UNSOUND** | `H∈Required`; safe `lane_id(0)` reaches `NonZeroU8::new_unchecked(0)`, whose 1.85.1 contract says this is UB. |
+| “Panics when `value` is zero” over every `c∈Required` | **UNPROVED** | Proved for `Required\H`; in `H`, the zero call reaches UB instead. That UB-containing execution cannot certify `CONTRACT-BROKEN`, and no UB-free refutation exists in the snapshot. |
+| Soundness on `(Required\H)×u8 ∪ H×{1..=255}` | **PROVED**, relative to the TCB below | Exhaustive cfg/input partition and OBL-3/OBL-4 below. |
+| Documented selector and excluded-pair rejection | **PROVED**, relative to `BUILD-MAP-X` | OBL-1/OBL-2 below. |
+
+Combined mandatory result: **UNSOUND** for soundness and **UNPROVED** for the zero-input panic guarantee.
+
+## Domain and configuration closure
+
+`SUPPORT.md:3-16` supplies the exact singleton toolchain, three targets, two feature states, two allocators, all profiles/debug-assertion states, and the sole excluded cross-product member. `BUILD.md:3-14` restricts support to Cargo plus `build.rs` and defines selector normalization: absent or `system`→system; `arena`→arena; everything else rejected. This is preserved symbolically above, not inferred from samples.
+
+`build.rs:9-21` implements that three-way mapping: [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), `NotPresent`/`NotUnicode`, [`str::to_owned`](https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), literal/or/wildcard matching, and named formatting select one accepted string or [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html). `BUILD-MAP-X` alone admits Cargo’s execution, rerun, directive, feature, target-cfg, and failed-script mapping; it admits no local correctness.
+
+For every accepted selector, exactly one `rustc-cfg` line is reached. `src/lib.rs:3-13` rejects neither/both allocator cfgs. `src/lib.rs:15-16` rejects wasm32+arena. Under the [cfg-attribute rule](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), a true predicate retains the [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), which makes compilation fail. Within the controlling supported target predicate, successful library compilations are exactly `Required`; `H` is included (aarch64, arena, burst is not excluded). Profile/debug/panic strategy do not select source or alter `new_unchecked`'s precondition; panic abort versus unwind does not affect the proved panic initiation.
+
+Aggregate `Covered` for soundness is `(Required\H)×u8 ∪ H×{1..=255}`. Because `H×{0}⊆Required×u8` but is not covered—and is affirmatively refuted—`Required×u8 ⊄ Covered`.
+
+## Boundary, invariant, and obligation ledger
+
+The full language-reachable crate surface is: safe public free function `lane_id(u8)->NonZeroU8`; its return type’s standard safe behavior; build-script entrypoint/environment input; cfg-generated variants; two private unsafe calls. There are no public fields/types/traits/statics/macros, callbacks, FFI, impls, reexports, hidden items, mutable state, allocator operations, or destruction/concurrency invariants. `INV-NZ` is local: immediately before either `new_unchecked(value)`, `value≠0` must hold; the unsafe call consumes it and returns a valid `NonZeroU8`.
+
+| ID | Site and exact obligation | Proof/status |
+|---|---|---|
+| OBL-1 | `build.rs`: map every documented selector, emit exactly one value, reject every other value | Direct exhaustive `Result` and string-match cases; emitted-line propagation/failure is exactly accepted `BUILD-MAP-X`. **PROVED**. |
+| OBL-2 | cfg closure and wasm32+arena rejection | Two allocator predicates are total/exclusive under OBL-1; target/feature mapping is `BUILD-MAP-X`; active `compile_error!` rejects the excluded pair. **PROVED**. |
+| OBL-3 | `src/lib.rs:40-44`: establish `value≠0` | For `Required\H`, this is the active block. Rust [integer equality](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators) plus [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) partitions `value=0` (panic) from `value≠0` (call). The adjacent comment states the complete material derivation. **PROVED** for all such configurations/inputs. |
+| OBL-4 | `src/lib.rs:29-31`: establish `value≠0` | In `H` this unconditional block is active. No type, check, boundary, or accepted TCB premise constrains safe input. False for `value=0`; true for 1..=255. **UNSOUND witness below**. |
+| OBL-5 | `src/lib.rs:22`: zero always panics | OBL-3 proves it outside `H`; OBL-4 prevents a defined proof in `H`. **UNPROVED** globally. |
+
+The Rust 1.85.1 `NonZero::new_unchecked` contract states: “This results in undefined behavior if the value is zero” and requires that the value not be zero ([authoritative page](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). It also establishes the nonzero result needed by the return type when its precondition holds.
+
+## Finding F-1 — supported safe call reaches UB
+
+- **Status:** critical; implementation **UNSOUND**; safety comment deficient and false.
+- **Valid use:** choose supported `H`; call public safe `lane_id(0)` from well-typed safe Rust. A safe API has no caller safety precondition.
+- **Reachability:** `BUILD-MAP-X` establishes all three true cfg atoms. Conditional compilation retains `src/lib.rs:24-32` and removes `:34-45`; the function executes `new_unchecked(value)` with `value=0`.
+- **False proposition:** OBL-4 requires `value≠0`; `0≠0` is false.
+- **UB consequence:** the cited 1.85.1 std contract expressly makes zero UB. This closes every existential `UNSOUND` link.
+- **Proof defect:** “Burst-mode lane identifiers are never zero” reverses no enforced producer contract and is contradicted by the unrestricted `u8` parameter.
+- **Minimum repair:** perform the zero check in every configuration (prefer `NonZeroU8::new(value).expect(...)`), or remove `H` from support and effectively reject it. Replace the comment with the actual dominating-check derivation. Re-audit source, panic behavior, domain closure, and compatibility; narrowing support is a policy change.
+- **Postcondition:** the same execution is UB-containing, so it does not establish `CONTRACT-BROKEN`; absent a separate UB-free witness, OBL-5 remains `UNPROVED`.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact admitted proposition; scope; consumer; trigger |
+|---|---|---|
+| BUILD-MAP-X | OUT-OF-BAND/IMPLEMENTATION; **accepted by authorized human** | Exactly `TCB.md:5-32`, Cargo 1.85.1 mapping/failure proposition only; all `Required`; OBL-1/2 and F-1 reachability; trigger is any named toolchain/manifest/script/interface/target/cfg/disposition change. |
+| AXIOM-NZ-1.85.1 | AXIOM; verified | Exact quoted `new_unchecked` zero precondition/UB and valid-result contract; Rust/std 1.85.1; OBL-3/4 and F-1; trigger: toolchain or cited documentation change. |
+| AXIOM-CFG-1.85.1 | AXIOM; verified | Applicable cfg attributes remove/retain attributed constructs; active `compile_error!` fails compilation; Rust 1.85.1; OBL-2/3/4; trigger: toolchain/docs/source predicate change. |
+| AXIOM-CONTROL-1.85.1 | AXIOM; verified | Applicable equality/if/panic semantics used in OBL-1/3/5; Rust/std 1.85.1; trigger: toolchain/docs/control-flow source change. |
+
+No dependency, backend, binary, tool-result, allocator-implementation, deployment, or compatibility premise is consumed. No TCB proposition was widened beyond `TCB.md`.
+
+## Rejected, residual, and review triggers
+
+Invalid/non-Unicode selectors are rejected by build-script panic; wasm32+arena is rejected at library compilation; missing or simultaneous allocator cfgs are likewise compile errors but arise only from out-of-interface manual rustc use. Other targets, invented cfgs, other Rust/Cargo versions, and manual rustc builds are unsupported, not proved rejected. Build-script stdout failure yields no compiled artifact under accepted `BUILD-MAP-X`. Binary/backend correctness is outside this source theorem. No tool-derived evidence exists.
+
+Re-audit on any source/documentation change; support, target, feature, profile, selector, or cfg change; Rust/Cargo/std or cited-contract change; `BUILD-MAP-X` disposition/scope change; or newly exposed API/generated artifact. Every in-scope obligation and rejected region has a disposition; no tests or absence-of-counterexample reasoning supports a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r016/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r016/1/attestation.json
new file mode 100644
index 0000000000..ee34beaf34
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r016/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r016",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:03:57.882861Z",
+  "report_sha256": "beda1907cffd4ca75cd8ecb5dc9fb5526c52b20aa0e683109815e6526d752499",
+  "run_id": "r016",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1069
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r016/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r016/1/report.md
new file mode 100644
index 0000000000..bb16779767
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r016/1/report.md
@@ -0,0 +1,73 @@
+# Focused unsafe-Rust audit
+
+## Claim, scope, and verdicts
+
+Snapshot: the exact supplied `target/lib.rs`; no expansion, execution, build, or repository history was used. `Required = {Rust 1.82.0} × {targets on which this exact source and its used 1.82.0 standard-library items exist} × {ordinary profiles}`, exactly preserving the request's symbolic target and profile predicates. The claim is freedom from Rust undefined behavior for every well-typed safe use, plus compliance with the published `Lane` implementer contract for in-scope implementations.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Whole supplied source | **UNSOUND** | CB-R and CB-W are independent valid safe-use UB witnesses. |
+| `callback_index::read` | **UNSOUND** | CB-R. |
+| `callback_index::write` | **UNSOUND** | CB-W. |
+| `local_proof::last` unsafe operation | **PROVED** | LP proves the unchecked index in bounds for every input. |
+| `published_lane::High` contract and `read` | **PROVED** | PL-I and PL-R cover every contract-valid implementation, not merely visible ones. |
+
+The combined mandatory result is therefore **UNSOUND**, without stopping review of the other modules. There are no extra TCB assumptions, dependencies, generated artifacts, tools, FFI, concurrency, or conditional code. TCB-R82 contains only the cited, exact Rust 1.82.0 Reference/standard-library contracts as governing semantics.
+
+## Boundary and obligation inventory
+
+All language-reachable surfaces are: `Position` and its safe caller-provided `position`; safe `callback_index::{read, write}`; safe `local_proof::last`; public `Word` tuple constructor/field; public `High` unit constructor; unsafe `Lane`, its associated constants, downstream `unsafe impl`s, the `High` impl, and safe `published_lane::read`. There are no macros, reexports, hidden APIs, methods, `Drop` implementations, or configuration-specific surfaces in the supplied source.
+
+Rust 1.82.0 documents for both [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut): “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.”
+
+### CB-R — safe read permits an out-of-bounds index
+
+**Implementation: UNSOUND; proof artifact: missing.** Define in safe code `struct End; impl Position for End { fn position(&self) -> usize { 0 } }`, then call `read(&[], &End)`. Implementing this safe trait, constructing the empty slice, and calling `read` are valid safe uses; `Position` has no behavioral restriction. The call reaches `get_unchecked(0)` on a length-zero slice. Index 0 is out of bounds, so the quoted Rust 1.82.0 contract entails UB. This establishes valid use, reachability, the false bounds proposition, and the UB consequence. It applies parametrically to every required target/profile.
+
+### CB-W — safe write permits an out-of-bounds index
+
+**Implementation: UNSOUND; proof artifact: missing.** With the same safe `End`, `let mut bytes = []; write(&mut bytes, &End, 7)` is a valid all-safe call. It reaches `get_unchecked_mut(0)` on a length-zero slice. The required in-bounds proposition is false and the cited mutable contract entails UB, independently of CB-R and before the assignment can justify anything. This witness is likewise target/profile-parametric.
+
+### LP — implementation correct, existing comment inadequate
+
+**Implementation: PROVED; proof artifact: deficient.** Let `n = bytes.len()`. [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when the slice length is zero, and [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns its element count. The unsafe branch therefore has `n > 0`. Consequently `n - 1` is representable in unsigned `usize` (no underflow under the [integer arithmetic rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)) and yields `i = n - 1 < n`. Thus `i` is in bounds, satisfying `get_unchecked`; dereferencing the shared element reference copies a valid `u8`. The empty branch executes no unsafe operation. This also proves `None` for an empty slice and `Some` of the final element otherwise.
+
+“This is the fast path” supplies none of the required obligation, dominating fact, arithmetic step, or bound. Replace it with:
+
+```rust
+// SAFETY: `is_empty()` was false, so `bytes.len() > 0`. Thus
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// which is the bounds precondition of `get_unchecked`.
+```
+
+### PL-I/PL-R — published unsafe-trait boundary closes
+
+The Rust 1.82.0 Reference requires unsafe traits to be implemented through an unsafe implementation ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe` keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); the source's published `# Safety` text is the controlling implementer contract.
+
+**PL-I: PROVED; local proof missing.** `High` supplies `INDEX = 1`, hence `INDEX < 2`, and supplies `NAME = "high"`, exactly the clause required when `INDEX == 1`. Suggested adjacent proof: `// SAFETY: INDEX is 1 (< 2), and for INDEX == 1 the required NAME is "high".`
+
+**PL-R: PROVED; local proof missing.** For every valid `L: Lane`, including unknown downstream implementations, the unsafe-trait contract entails `L::INDEX < 2`. `word.0` is always `[u32; 2]`; its public field introduces no stronger invariant and has length 2. Therefore `L::INDEX` is in bounds and `get_unchecked` is permitted. Suggested comment: `// SAFETY: Every valid Lane impl guarantees L::INDEX < 2, and word.0 is [u32; 2].`
+
+An incorrect downstream `unsafe impl` is a violated out-of-scope implementer obligation, not a hidden precondition on safe callers. Conversely, repository-visible consumers are not exhaustive: `NAME` is a literal published guarantee even though this `read` does not consume it. Removing or weakening it in a 1.x release could invalidate downstream unsafe reasoning; strengthening either clause could invalidate existing implementations. No such contract change is justified by this audit.
+
+## Minimal repair for `callback_index` (proposal only)
+
+Keep the signatures and caller-selected positions, but replace the two bodies with checked indexing:
+
+```rust
+pub fn read<P: Position>(bytes: &[u8], position: &P) -> u8 {
+    bytes[position.position()]
+}
+
+pub fn write<P: Position>(bytes: &mut [u8], position: &P, value: u8) {
+    bytes[position.position()] = value;
+}
+```
+
+This is the smallest repair: in-range behavior and both callable APIs remain; an adversarial/out-of-range safe position now causes defined bounds-check failure rather than UB. The trait could instead be replaced by `usize`, since its preservation is not required, but that is a larger public API change. Making `Position` unsafe, sealing it without usable implementations, or deleting the functions would transfer/bypass the required safe-caller functionality and is not recommended. This proposal is **not certified**: it must be implemented as a new snapshot and freshly audited, including its panic behavior across the intended ordinary profiles.
+
+## Domain closure, residual scope, and triggers
+
+No finite target enumeration was inferred. LP and PL are parametric in the request's target/profile predicates: target-dependent `usize` width is irrelevant because LP proves subtraction non-overflowing and PL uses only 1 and a fixed length 2; overflow-check and optimization choices do not alter those facts. Thus `Covered_LP = Covered_PL = Required`, establishing `Required ⊆ Covered` for each proved claim. CB-R/CB-W refute universal soundness with witnesses available throughout `Required`.
+
+This is a Rust source-level result only, not a compiler-binary, platform, security, or downstream-implementation audit. Re-audit on any source or safety-contract change, implementation of the repair, Rust/support-domain change, added configuration/generation/dependency, or new downstream-facing contract evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r017/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r017/1/attestation.json
new file mode 100644
index 0000000000..2635092fbd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r017/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r017",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:12:33.928099Z",
+  "report_sha256": "900af7df55266fc2bb71f705014f9c2bb396adddfebb0bf70f6d3926d9939f51",
+  "run_id": "r017",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1145
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r017/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r017/1/report.md
new file mode 100644
index 0000000000..4a9b181a3d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r017/1/report.md
@@ -0,0 +1,93 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Snapshot: exactly the supplied `lib.rs`. Scope is all three modules, Rust and standard library 1.82.0, every target on which this source and its used standard-library items exist, and every ordinary profile. There are no features, `cfg`s, dependencies, generated artifacts, FFI, concurrency, or build-time inputs in the supplied source.
+
+Claim: every well-typed safe use of each safe surface is free of Rust undefined behavior; uses of the unsafe `Lane` implementer boundary must satisfy its complete published contract. The result is relative only to the Rust 1.82.0 axioms recorded below; there are no additional TCB assumptions.
+
+**Combined soundness verdict: UNSOUND.** `callback_index::read` and `write` each admit an independent, wholly safe call that reaches UB. Review continued through the remaining modules: `local_proof::last` is **PROVED** sound, and `published_lane` (including `High` and generic `read`) is **PROVED** sound under the literal current `Lane` contract. Their local proof documentation is deficient. There are no documented unsafe-function postconditions. Conformance of `High` to both published trait clauses is **PROVED**.
+
+## Boundary and obligation inventory
+
+| ID | Surface or proof site | Result |
+|---|---|---|
+| CB-P | safe, downstream-implementable `Position` and safe `position` | unconstrained `usize` producer |
+| CB-R | safe `callback_index::read`; `get_unchecked` consumer | **UNSOUND** |
+| CB-W | safe `callback_index::write`; `get_unchecked_mut` consumer | **UNSOUND** |
+| LP | safe `local_proof::last`; unchecked shared access | implementation **PROVED**; comment deficient |
+| PL-W | public `Word(pub [u32; 2])`, including tuple construction/field access | **PROVED**; array length is type-enforced |
+| PL-L | public unsafe `Lane`, associated constants, downstream unsafe impl boundary | literal two-clause contract reviewed |
+| PL-H | safe `High` construction and `unsafe impl Lane for High` | implementation **PROVED**; proof comment missing |
+| PL-R | safe generic `published_lane::read`; unchecked shared access | implementation **PROVED**; proof comment missing |
+
+There is no representation invariant beyond the types. The relevant local contracts are `CB-IN-BOUNDS` (an unchecked index must be in bounds) and `LANE-1X` (`INDEX < 2`, plus the stated `NAME`/`INDEX` correspondence).
+
+## Rust 1.82.0 axioms / TCB log
+
+All entries were opened at the exact versioned URLs and are accepted only for the requested domain.
+
+- **A-SHARED:** [`slice::get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked): “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumer: CB-R, LP, PL-R.
+- **A-MUT:** [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) states the same requirement for mutable access. Consumer: CB-W.
+- **A-SLICE:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) returns true when that length is zero. Consumer: LP.
+- **A-ARITH:** The Reference classifies `usize` as an [unsigned integer type](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types), and `-` on integers as [subtraction](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators). Consumer: LP.
+- **A-TRAIT:** An unsafe trait has extra conditions that implementations must uphold, and an `unsafe impl` asserts their discharge ([unsafe-trait explanation](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); it is safe to use a correctly implemented unsafe trait ([trait rule](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)). Consumer: PL-H, PL-R.
+
+No tools, tests, executions, or sampled evidence were used.
+
+## Findings and proofs
+
+### F-CB-R — safe read reaches UB
+
+`Position` has no safety contract or enforced range. Safe downstream code can implement `position` to return `0`, then call `read(&[], &p)`. The index is out of bounds for the empty slice, yet `read` passes it to `get_unchecked`. A-SHARED therefore proves UB. No unsafe caller action or additional premise occurs. This refutes soundness on every requested target/profile.
+
+### F-CB-W — safe write independently reaches UB
+
+The analogous safe call `write(&mut [], &p, 1)` passes `0` to `get_unchecked_mut`. A-MUT proves UB. This is a separate defect and witness from F-CB-R. Neither UB-containing execution is used as a postcondition refutation.
+
+**Smallest repair:** retain the signatures and caller-implementable trait, but replace the bodies with checked indexing:
+
+```rust
+bytes[position.position()]
+bytes[position.position()] = value;
+```
+
+This preserves safe callers' ability to select positions for both reads and writes; an invalid position panics rather than becoming a hidden safety precondition. It requires neither sealing nor making `Position` unsafe. Replacing `Position` with a `usize` parameter is an optional larger API simplification, not needed for the minimal repair. **The proposal is not implemented and is not certified; audit the exact changed snapshot anew.**
+
+### F-LP-DOC — correct implementation, inadequate `SAFETY` comment
+
+Implementation proof: the unsafe path is reached only when `is_empty()` is false. By A-SLICE, `len != 0`; because `len: usize` is unsigned, `len >= 1`. A-ARITH then makes `index = len - 1` representable, with `0 <= index < len`. Thus `index` is in bounds and A-SHARED's sole safety requirement is met. Dereferencing the resulting shared reference copies its valid `u8`. The empty path performs neither subtraction nor unsafe access. This argument is parametric over target and profile; overflow checking is irrelevant because subtraction cannot underflow.
+
+“This is the fast path” states none of the obligation, dominating fact, or derivation. Replace it with:
+
+```rust
+// SAFETY: This branch establishes bytes.len() != 0. Therefore
+// index = bytes.len() - 1 is in 0..bytes.len(), as get_unchecked requires.
+```
+
+The current implementation verdict remains **PROVED**; the current proof artifact is deficient.
+
+### F-PL-PROOF — sound implementation, missing adjacent proofs
+
+`High` discharges every literal `LANE-1X` clause: `1 < 2`; the `INDEX == 1` implication requires `NAME == "high"`, which holds; the `INDEX == 0` antecedent is false. Suggested adjacent impl proof:
+
+```rust
+// SAFETY: INDEX is 1 (< 2), NAME is "high" as required for INDEX == 1,
+// and the INDEX == 0 clause is inapplicable.
+```
+
+For every valid `L: Lane`, the published first clause gives `L::INDEX < 2`. `word.0` is exactly `[u32; 2]`, so that index is in bounds and A-SHARED is satisfied. Suggested `read` proof:
+
+```rust
+// SAFETY: Lane requires L::INDEX < 2, and word.0 has exactly two elements.
+```
+
+A bad downstream `unsafe impl` is outside valid use because A-TRAIT assigns it the published obligations; no hidden condition is imposed on safe callers. The current implementations are **PROVED**, while both adjacent proof artifacts are missing.
+
+`NAME` is not consumed by this file's `read`, but remains a published 1.x implementer guarantee. Unknown downstream consumers may rely on it, including in soundness proofs. Removing or weakening it can invalidate consumers; strengthening either clause can invalidate existing implementations. Repository-visible uses cannot justify either change. Any evolution needs the applicable compatibility process and a fresh audit; this review certifies no proposed contract change.
+
+## Configuration closure, residual scope, and triggers
+
+Coverage is parametric: the callback witnesses use only an empty slice and index zero; LP derives a mathematical in-bounds index before profile-sensitive overflow behavior can differ; PL uses a fixed two-element array and the contract's strict bound. Hence target widths and ordinary profiles do not change any result. There are no generated/configuration branches to enumerate and no excluded requested cases.
+
+Residual scope is limited to implementations and consumers not supplied here: they are not individually audited, but PL-R quantifies over every implementation satisfying the published unsafe contract. Re-audit on any source or safety-contract change, Rust/standard-library version change, support-domain expansion, or implementation of either proposed documentation/code repair.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r018/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r018/1/attestation.json
new file mode 100644
index 0000000000..43c13e3562
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r018/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r018",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:13:18.877453Z",
+  "report_sha256": "6810e706f4b3974f0c1ef770bc1c8a4eb31bc902a454ca762c9f9491147e9917",
+  "run_id": "r018",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1217
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r018/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r018/1/report.md
new file mode 100644
index 0000000000..7e4c751c8f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r018/1/report.md
@@ -0,0 +1,82 @@
+# Source-only unsafe-code audit
+
+## Claim, scope, and verdict
+
+**Snapshot:** the supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `src/lib.rs`, and `REQUEST.md`, audited 2026-08-01. Rust and standard library are exactly 1.85.1. There are no dependencies or generated source files. The build script generates only a library configuration option.
+
+**Claim:** for every successful library compilation in the supported domain, every well-typed safe use of the public API is free of Rust undefined behavior and its documented behavior holds, relative only to accepted TCB entry `BUILD-MAP-X` and the cited Rust 1.85.1 semantics.
+
+| Component | Verdict | Certificate |
+|---|---|---|
+| Safe-API soundness over the complete supported domain | **UNSOUND** | Finding F-1 gives a valid supported safe call, reaches `new_unchecked(0)`, proves its precondition false, and cites the resulting UB contract. |
+| Soundness outside `aarch64 + burst + arena` | **PROVED** | OBL-U2 below; the zero check dominates the only unsafe call in this region. |
+| Documented “panics when `value` is zero” behavior over the complete domain | **UNPROVED** | It is established outside F-1’s configuration, but the only zero-input execution established in F-1 has UB. Such an execution is not an UB-free `CONTRACT-BROKEN` witness. |
+| Required policy rejection | **PROVED** | Every `wasm32 + arena` combination encounters `compile_error!`; invalid allocator selectors make the build script fail before library compilation. |
+
+Thus the strongest complete-domain result is **UNSOUND**. This is a source-level result, not a compiler-backend or binary claim.
+
+## Required domain and closure
+
+Let:
+
+- `T = {x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`;
+- `B = {burst disabled, burst enabled}`;
+- `A = {system, arena}`;
+- `P` be every Cargo profile and `D = {debug assertions off, on}`.
+
+From `Cargo.toml`, `SUPPORT.md`, and `BUILD.md`, normalized without enumeration loss:
+
+`Required = Rust 1.85.1 × {(t,b,a,p,d) in T×B×A×P×D | not(t=wasm32-unknown-unknown and a=arena)}`,
+
+restricted to Cargo builds using the supplied build script whose stdout writes succeed. The latter restriction is exactly `TCB.md`’s execution scope; a write failure produces no library compilation and is not a policy rejection. `BUILD.md` excludes manual `rustc` cfg invention.
+
+`BUILD-MAP-X` is accepted exactly as written: Cargo maps the script’s emitted allocator cfg, feature `burst`, and the three triples to their stated cfgs; `rustc-check-cfg` declares but does not set values; unsuccessful scripts halt before library compilation. No source-correctness or Rust-semantic proposition is imported from it.
+
+Source inspection proves the remaining mapping. `env::var` partitions into present Unicode, absent, and non-Unicode cases. Absence produces `"system"`; exact string matches `system|arena` emit exactly one corresponding cfg; every other Unicode string and non-Unicode input panics. On successful writes, `BUILD-MAP-X` therefore gives exactly one allocator cfg. The code has no profile/debug-assertion conditional and no `debug_assert!`, so all `P×D` cases share the same proof.
+
+The Rust Reference states that a cfg option predicate is true exactly when set, `all` requires all operands, and `not` negates its operand ([conditional compilation](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation)). It also states conditionally compiled source is compiled only under its condition. Consequently the two `lane_id` blocks form an exhaustive complementary partition. Define
+
+`Bad = Required ∩ {t=aarch64-unknown-linux-gnu, b=enabled, a=arena}`.
+
+The proof below covers `Required \ Bad`; F-1 existentially refutes soundness on `Bad`. Profiles and debug assertions remain parametric in both cases.
+
+## Build rejection proof
+
+For `t=wasm32-unknown-unknown, a=arena`, `BUILD-MAP-X` sets `target_arch="wasm32"` and `fixture_allocator="arena"`; hence the third top-level cfg is true for both feature states and all profiles/debug states. `compile_error!` “causes compilation to fail ... when encountered” ([Rust 1.85.1 documentation](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)), so the mandated excluded pair cannot produce the library.
+
+Invalid or non-Unicode `FIXTURE_ALLOCATOR` values reach a `panic!`; `BUILD-MAP-X` then halts before library compilation. Omitted, `system`, and `arena` are the complete accepted selector interface. The first two top-level `compile_error!` items additionally reject missing or simultaneously set allocator cfgs, although accepted Cargo builds cannot generate them. Other targets and manual cfg injection are outside `Required`, not silently proved. A build-script stdout failure is an infrastructure failure with no compiled configuration, per the TCB, not another selector or successful rejection.
+
+## Boundary, invariant, and obligation coverage
+
+The complete public Rust surface is the safe function `lane_id(u8) -> NonZeroU8` (`src/lib.rs:23`). There are no public fields, traits or impls, macros, statics, callbacks, hidden items, generated APIs, custom destruction, FFI, concurrency, assembly, or allocator operations. `build.rs::main` is the complete build interface. The only unsafe operations are the two cfg-disjoint `NonZeroU8::new_unchecked(value)` calls.
+
+`INV-NZ`: each value returned as `NonZeroU8` must have a nonzero integer value. Its producer/consumer boundary is each `new_unchecked` call; the unsafe function requires its argument to be nonzero.
+
+| ID | Site/domain | Required proposition | Derivation and status |
+|---|---|---|---|
+| OBL-U1 | `src/lib.rs:31`, `Bad` | `value != 0` before `new_unchecked` | No check, type restriction, or caller precondition exists. False for safe input `0`. **UNSOUND**, F-1. |
+| OBL-U2 | `src/lib.rs:40-44`, `Required \ Bad` | `value != 0` before `new_unchecked` | If `value == 0`, `panic!` prevents reaching line 44; reaching line 44 therefore entails `value != 0`. This satisfies the exact callee contract and establishes `INV-NZ`. **PROVED**. |
+| OBL-PANIC | documented `# Panics` clause | every zero input panics | Proved by the dominating branch on `Required \ Bad`; unresolved on `Bad` because the reached operation has UB. **UNPROVED**, not `CONTRACT-BROKEN`. |
+| OBL-CFG | build/policy boundary | exactly supported cfgs compile; excluded pair fails | Build-script partition, `BUILD-MAP-X`, complementary cfgs, and `compile_error!` proof above. **PROVED**. |
+
+The local comment for OBL-U2 is an adequate compact proof. OBL-U1’s comment—“Burst-mode lane identifiers are never zero”—is not a derivation: `value` is an unrestricted argument to a safe function, and no earlier producer or check establishes that assertion.
+
+## F-1 — supported safe call invokes `new_unchecked(0)`
+
+- **Affected theorem:** complete-domain safe-API soundness.
+- **Valid in-scope use:** select target `aarch64-unknown-linux-gnu`, enable `burst`, select `arena`, use any Cargo profile/debug state, then safe code calls `lane_id(0)`. `SUPPORT.md` includes this combination, and the safe signature imposes no caller safety precondition.
+- **Reachability:** `BUILD-MAP-X` sets all three predicates of the first `cfg(all(...))`. The first block is compiled, its complementary block is not, and the function immediately executes `NonZeroU8::new_unchecked(value)`.
+- **False safety proposition:** at that operation `value == 0`, while the contract says, “The value must not be zero.”
+- **UB consequence:** Rust 1.85.1 documents that `new_unchecked` “results in undefined behavior if the value is zero” ([exact API contract](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). This completes the existential `UNSOUND` certificate.
+- **Proof artifact:** incorrect; it reverses an unsupported assertion into an invariant.
+- **Minimum repair:** remove the special unchecked branch and use the already guarded implementation in every configuration (or use checked `NonZeroU8::new(value)` and panic on `None`). Replace the special comment with the OBL-U2 derivation. This preserves the public panic contract and configuration policy. The changed snapshot needs a fresh full-domain audit.
+
+## Authority and TCB log
+
+- **Accepted TCB:** only `BUILD-MAP-X`, exact identity/scope/disposition from `TCB.md`; consumers are domain reachability and rejection. Re-audit on any trigger listed there. It is not widened.
+- **Rust axioms:** the versioned `new_unchecked`, cfg, and `compile_error!` passages cited above. Build-script control flow uses the allowlisted Rust 1.85.1 contracts for [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), [match expressions](https://doc.rust-lang.org/1.85.1/reference/expressions/match-expr.html), [literal/or/wildcard patterns](https://doc.rust-lang.org/1.85.1/reference/patterns.html#literal-patterns), and [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html).
+- **Tools/tests:** none; no target code was built, run, tested, or expanded.
+
+## Residual scope and review triggers
+
+Excluded are unsupported targets, Rust versions other than 1.85.1, direct `rustc`/invented cfgs, backend/binary behavior, and build attempts producing no library after script failure. Re-audit on source, public contract, support policy, Cargo/toolchain, build environment interface, cfg mapping, target/feature/profile scope, TCB disposition, or material cited-documentation changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r019/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r019/1/attestation.json
new file mode 100644
index 0000000000..f9758b5e8f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r019/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r019",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:16:28.629865Z",
+  "report_sha256": "3e728c8ae2e5aea7eecfd5af8aab61c637c06478e3182e6f7dccdaa569a170c2",
+  "run_id": "r019",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 902
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r019/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r019/1/report.md
new file mode 100644
index 0000000000..10168ee5d5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r019/1/report.md
@@ -0,0 +1,44 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and result
+
+This review covers exactly the submitted `lib.rs`, its four exported unsafe functions, the contracts in that file, the finite policies in `SUPPORT.md`, and the submitted evidence/TCB packet. Audit cutoff: 2026-07-31. There is no generated code, conditional compilation, dependency, safe wrapper, trait, field, macro, FFI, concurrency, allocator, or other API surface in the submitted source. No binary/backend claim is made.
+
+For API `f`, let `D(V) = V × {every target on which f exists} × {ordinary debug, ordinary release}`. The theorem is: every call satisfying `f`'s documented caller obligations has defined callee evaluation under documented Rust abstract semantics and establishes each listed postcondition. The exact target/profile quantifiers come directly from `SUPPORT.md`; copying each explicitly declared finite release set into `D` is an equality, not interval inference.
+
+**Strongest four-API result: UNPROVED.** `acknowledge`, `store_word`, and `copy_byte` are fully **PROVED** relative to the accepted submitted TCB. `load_word` is regionally proved but its full required claim is **UNPROVED**. No `UNSOUND` or `CONTRACT-BROKEN` witness is established.
+
+| API | Required releases | Soundness | Documented postconditions (separate results) | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | `A={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED**, `Covered=A` | No prose postcondition; its signature-level `()` return is **PROVED**, `Covered=A` | **PROVED** over `D(A)` |
+| `store_word` | `S={1.80.0,1.81.0}` | **PROVED**, `Covered=S` | destination stores `value`: **PROVED**, `Covered=S`; old `u16` is not read: **PROVED**, `Covered=S`; old `u16` is not dropped: **PROVED**, `Covered=S` | **PROVED** over `D(S)` |
+| `copy_byte` | `C={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED**, `Covered=C` | destination receives the pre-call source byte: **PROVED**, `Covered=C`; source byte is preserved: **PROVED**, `Covered=C` | **PROVED** over `D(C)` |
+| `load_word` | `L={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED** on `E={1.80.0,1.82.0}`; **UNPROVED** on `M={1.80.1,1.81.0}`; aggregate `Covered=E` | returned value equals the initialized source `u32`: same regional results; source is unchanged: same regional results | **UNPROVED** over `D(L)` |
+
+For each proved claim, all required obligations have the displayed same release coverage, so their pointwise intersection is that `Covered`; equality with the relevant required set proves `Required ⊆ Covered`. For `load_word`, `E ⊂ L`, so closure fails.
+
+## Obligation proofs
+
+**ACK-SOUND/RET.** The inspected body is exactly `{}`, has no operation or state transition, and matches the signature covered by accepted `SEM-EMPTY-BLOCK-180-182`. That entry parametrically guarantees defined evaluation and return of `()` for every case in `D(A)`. There are no caller safety preconditions or other postconditions.
+
+**STORE-SOUND/VALUE/NOREAD/NODROP.** The caller contract supplies an aligned `dst` valid to write one `u16`; these are exactly the safety clauses of [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html), independently verified for their respective singleton cases. The call uses that `dst` and passed `value`. Each page says the operation overwrites the location with the value without reading or dropping the old value. The exhaustive union of the two singleton lemmas is `S`.
+
+**COPY-SOUND/DEST/SOURCE.** The call fixes `T=u8,count=1`. The caller contract supplies source/destination validity, initialization, alignment, and non-overlap. The verified 1.80 authorities establish the matching [`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) clauses, [`size_of::<u8>()=1`](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [bitwise `Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html). Accepted `COMPAT-COPY-180-182` preserves exactly the defined-call, one-byte destination-copy, source-preservation, size, and `Copy` propositions over every case in `D(C)`. Its consumer restriction is obeyed.
+
+**LOAD-SOUND/RETURN/SOURCE.** At 1.80.0 and 1.82.0, the caller's aligned/readable/initialized `src` exactly discharges the independently verified [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) safety clauses. Those pages establish return of the read value and unchanged source. The corresponding [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish that retaining and returning the duplicate `u32` preserves ownership validity. These are endpoint lemmas only.
+
+## Finding LOAD-GAP — missing interior-release applicability
+
+- **Status:** `UNPROVED`; implementation and both postconditions on `D(M)`.
+- **Smallest missing premise:** for each `v∈M`, under the documented pointer conditions, this exact `ptr::read::<u32>` call is defined, returns the source value, leaves the source unchanged, and `u32` has the required `Copy` semantics.
+- **Why unresolved:** the submitted pages apply only to 1.80.0 and 1.82.0. An audit cutoff and endpoint agreement do not establish semantic continuity. `TCB.md` supplies no `load_word` compatibility entry, and operation-specific evidence may not be transferred.
+- **Certificate check:** no valid in-scope execution with a proved false safety proposition or UB consequence exists in the packet; no UB-free falsifying execution exists. Therefore neither `UNSOUND` nor `CONTRACT-BROKEN` applies.
+- **Resolution:** provide applicable authorities for both interior releases or accept an exact proposition-preserving compatibility premise covering them, then re-audit all three obligations.
+
+## TCB, proof artifacts, and residual scope
+
+TCB identity is the exact submitted `TCB.md`. Its only non-authoritative entries are accepted `SEM-EMPTY-BLOCK-180-182` (consumed only by ACK-SOUND/RET) and accepted `COMPAT-COPY-180-182` (consumed only by COPY-SOUND/DEST/SOURCE). Their identities, scopes, limitations, consumers, and triggers were checked. All eleven submitted official pages were opened at their exact versioned URLs and their stated propositions verified. No tool-derived theorem or additional premise is consumed.
+
+**Proof-documentation finding:** implementation proofs above reconstruct facts absent from the adjacent comments. `acknowledge` should place its no-requirements contract under `# Safety`. The three pointer comments identify caller-side preconditions but omit resulting facts and version applicability; `copy_byte` especially omits the `u8/count/size/Copy` bridge, and `load_word` omits the `u32: Copy` bridge. This does not weaken proved implementation regions, but the proof artifacts are deficient. Add the corresponding compact derivations above; no wording change can repair `LOAD-GAP` without new evidence.
+
+Excluded: releases outside the explicit sets, nonordinary profiles, targets where an item does not exist, backend/binary correctness, and properties not documented or requested. Re-audit on any source/signature/contract change, support-set or configuration change, authoritative-page change, or change/disposition change to either consumed TCB entry.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r020/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r020/1/attestation.json
new file mode 100644
index 0000000000..b9052487b1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r020/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r020",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:20:54.106697Z",
+  "report_sha256": "afa2159eb13ec9ede81adee124835d0ab9c5e0468202378356654636f23d1e66",
+  "run_id": "r020",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1090
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r020/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r020/1/report.md
new file mode 100644
index 0000000000..44eca2feab
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r020/1/report.md
@@ -0,0 +1,86 @@
+# Focused unsafe-Rust review
+
+## Claim, domain, and verdicts
+
+Snapshot: the supplied `lib.rs`, reviewed 2026-08-01 without expansion, execution, tests, or repository context. Scope is all three modules and every language-reachable surface in that file.
+
+`Required(c) := rustc/stdlib 1.82.0 AND c.target admits this exact source and every used 1.82.0 std item AND c.profile is an ordinary profile.` There are no source `cfg`s, features, dependencies, generators, FFI, concurrency, allocator choices, or profile-dependent assertions. The arguments below are parametric in target and profile, so their covered domain equals `Required`; no finite target/profile enumeration or exclusion is inferred.
+
+The TCB consists only of the linked, version-exact Rust 1.82.0 Reference and standard-library axioms; there are no additional assumptions, selected dependencies, tools, or prior results.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Combined safe-API freedom from UB | **UNSOUND** | CB-R and CB-W below are valid safe executions reaching documented UB. |
+| `callback_index::read` | **UNSOUND** | CB-R, throughout `Required`. |
+| `callback_index::write` | **UNSOUND** | CB-W, throughout `Required`. |
+| `local_proof::last` | **PROVED** | LP below, throughout `Required`; proof comment deficient. |
+| `High: Lane` contract | **PROVED** | PL-I proves both published clauses. |
+| `published_lane::read` | **PROVED** | PL-R, for every valid `Lane` implementation throughout `Required`; proof comment missing. |
+
+No unsafe function documents a provider postcondition. `Lane`'s two implementer obligations are both disposed below. No `CONTRACT-BROKEN` witness is claimed.
+
+## Boundary, invariants, and obligation ledger
+
+The complete explicit surface is: safe public `Position` and `Position::position`; safe public callback `read` and `write`; safe public `last`; public tuple struct `Word` and its field/constructor; public unsafe `Lane` and its associated constants; public unit struct `High`, its unsafe impl, and safe public lane `read`. No macros, hidden items, explicit reexports, or user-defined trait impls beyond those listed occur.
+
+**CB-NONE.** `Position` owns no slice-relative invariant. A safe implementation may return every `usize`; neither callback validates the result before consuming it.
+
+**LP-BOUND.** On the nonempty branch only, `index = bytes.len() - 1` and `index < bytes.len()`.
+
+**PL-LANE.** Each valid unsafe `Lane` impl continually supplies `INDEX < 2` and the exact `NAME` mapping in the published contract. `Word([u32; 2])` supplies length 2 by its type; its public field permits arbitrary lane values but cannot change that length.
+
+The applicable slice contracts state that out-of-bounds `get_unchecked` and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) calls are UB even if their resulting references are unused; the immutable contract says the same and expressly includes index `len` ([`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)).
+
+### CB-R — safe read has an in-scope UB witness
+
+Safe code may define `struct P; impl Position for P { fn position(&self) -> usize { 0 } }` and call `read(&[], &P)`. This is well typed, requires no unsafe act or hidden precondition, and reaches `get_unchecked(0)` on a length-zero slice. Thus 0 is out of bounds, the required safety proposition is false, and the cited contract entails UB. This completes the **UNSOUND** certificate independently of any later behavior.
+
+### CB-W — safe write has an in-scope UB witness
+
+The same safe `P` can be passed to `write(&mut [], &P, 7)`. It reaches `get_unchecked_mut(0)` on a length-zero slice, falsifying its in-bounds requirement; the cited mutable-slice contract entails UB. This separately completes **UNSOUND**.
+
+### LP — implementation proof and comment review
+
+[`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when slice length is zero, and [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns the element count. Therefore the `else` branch establishes `len != 0`. `usize` is an unsigned pointer-width integer ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)), hence `len >= 1`. Consequently `len - 1` is representable and strictly below `len`; binary subtraction overflows only when its result is outside the type's range ([operator semantics](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)). LP-BOUND therefore entails the exact `get_unchecked` precondition. Dereferencing the returned shared reference copies its valid `u8`. The empty branch performs no unsafe operation. This proves implementation soundness in every ordinary profile, including when overflow checks differ.
+
+The existing comment, “This is the fast path,” identifies neither the operation's precondition nor any fact implying it. Its proof-artifact status is **deficient** despite the proved implementation. Material replacement:
+
+```rust
+// SAFETY: The `else` branch establishes `bytes.len() != 0`. Because the
+// length is a `usize`, `index = bytes.len() - 1` is representable and
+// `index < bytes.len()`, so `index` is in bounds as `get_unchecked` requires.
+```
+
+### PL-I/PL-R — published unsafe-trait boundary
+
+Rust 1.82 says unsafe traits impose extra conditions on implementations and that an `unsafe impl` asserts those obligations are discharged ([unsafe traits and impls](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); using a correctly implemented unsafe trait is safe ([trait items](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)). This is an enforced unsafe boundary, not trust in arbitrary safe caller code.
+
+PL-I: `High` sets `INDEX = 1`, so it is less than 2, and sets `NAME = "high"`, exactly the clause applicable at index 1. The index-0 implication is vacuous. Both published obligations are proved.
+
+PL-R: for any valid (including unknown downstream) `L: Lane`, PL-LANE yields `L::INDEX < 2`; the array type yields `word.0.len() = 2`. The index is therefore in bounds and the immutable unchecked access satisfies its contract. Contents and `NAME` are irrelevant to this operation. The implementation is **PROVED**, but the unsafe block lacks the material local bridge. Proposed adjacent comment:
+
+```rust
+// SAFETY: Every valid `Lane` implementation guarantees `INDEX < 2`, and
+// `word.0` is a `[u32; 2]`; therefore `L::INDEX` is in bounds.
+```
+
+The unsafe impl likewise deserves adjacent proof text: `INDEX` is 1 (<2) and its required name is `"high"`. These documentation defects do not negate the reconstructed implementation proofs.
+
+Because this is a published 1.x unsafe contract with unknown implementations and consumers, `NAME` is not removable merely because local `read` ignores it: unsafe downstream consumers may rely on that guarantee. Strengthening implementer obligations may invalidate unknown impls; weakening guarantees may invalidate consumers. No contract change is certified here.
+
+## Repair and residual scope
+
+The smallest callback repair retains all signatures and safe caller-selected positions, evaluates the callback once, and uses checked indexing:
+
+```rust
+pub fn read<P: Position>(bytes: &[u8], position: &P) -> u8 {
+    bytes[position.position()]
+}
+pub fn write<P: Position>(bytes: &mut [u8], position: &P, value: u8) {
+    bytes[position.position()] = value;
+}
+```
+
+Out-of-range positions then panic rather than violate an unsafe precondition. Making `Position` unsafe/sealed or making either operation unsafe is unnecessary and would shift or restrict the required safe functionality. Replacing `Position` with `usize` could be a larger breaking simplification, not the smallest repair. Every proposal remains **uncertified** until implemented as a new snapshot and freshly audited.
+
+Unknown downstream `Lane` implementations and unsafe consumers were not inspected. Their compliance is their documented unsafe obligation; they do not narrow the current contract or justify changing it. Re-audit is required after any source, Rust-version, support-domain, trait-contract, or proposed-repair change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r021/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r021/1/attestation.json
new file mode 100644
index 0000000000..57774174ce
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r021/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r021",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:21:32.961201Z",
+  "report_sha256": "f171bae3f575098cdab781093b1dc9e5455f576fc232bf6c0eadf70ce1a634fe",
+  "run_id": "r021",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 837
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r021/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r021/1/report.md
new file mode 100644
index 0000000000..7960f7bf85
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r021/1/report.md
@@ -0,0 +1,121 @@
+# Unsafe Rust source review
+
+## Claim, snapshot, and boundary
+
+This review covers exactly the four unconditional `pub unsafe fn` items in
+`lib.rs`, with `SUPPORT.md`, `EVIDENCE.md`, and accepted TCB revision `TCB.md`,
+at cutoff 2026-07-31. For each item the claim is: every call satisfying its
+literal `# Safety` contract has UB-free callee evaluation and establishes every
+documented postcondition, for every required release, every target on which the
+item exists, and every ordinary debug or release profile, relative only to the
+TCB below.
+
+The four functions are the complete exported surface. There are no safe
+functions, fields, traits, macros, generated artifacts, dependencies, FFI,
+stateful invariants, or conditional bodies in the submitted source. This is a
+source-level Rust-semantics result, not a compiler/backend or binary theorem.
+
+## Results
+
+Sets below are finite sets, not intervals.
+
+| API | `Required` | Exact `Covered` by evidence | Soundness | Documented postconditions | Strongest combined verdict over `Required` |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `Required` | **PROVED** | No prose postcondition; signature/body return `()` is **PROVED** | **PROVED** |
+| `store_word` | `{1.80.0,1.81.0}` | all `Required` | **PROVED** | stores `value`: **PROVED**; does not read old contents: **PROVED**; does not drop old contents: **PROVED** | **PROVED** |
+| `copy_byte` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `Required` | **PROVED** | destination receives source byte: **PROVED**; source byte is preserved: **PROVED** | **PROVED** |
+| `load_word` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | `{1.80.0,1.82.0}` | **PROVED** on `Covered`; **UNPROVED** on `{1.80.1,1.81.0}` | returned value equals source `u32`: same regional result; source is unchanged: same regional result | **UNPROVED** |
+
+No UB witness or UB-free postcondition refutation is established. Thus no
+`UNSOUND` or `CONTRACT-BROKEN` result applies.
+
+## Obligation ledger and derivations
+
+### `acknowledge`
+
+Its caller contract imposes no additional condition, and the inspected body is
+exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies to precisely this
+signature/body and all `Required` target/profile cases: evaluation is defined
+and returns `()`. Those facts discharge soundness and the signature result
+without transferring the entry to another API.
+
+### `store_word`
+
+For each required release, the caller supplies write-validity and alignment for
+one `u16`. The exact [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html)
+and [1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) contracts
+require exactly write-validity and alignment. Substitution of `T=u16` therefore
+discharges the sole `ptr::write(dst, value)` call. Each page also states that
+`write` overwrites with the supplied value without reading or dropping the old
+contents, proving all three postconditions. No compatibility premise is used.
+
+### `copy_byte`
+
+The caller provides read-valid, initialized `src`, write-valid `dst`, alignment
+of both, and nonoverlap of the one-byte regions. The
+[1.80.0 operation contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html)
+requires those region properties for `count * size_of::<T>()`; the
+[layout axiom](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout)
+gives `size_of::<u8>()=1`. The [implementation fact](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8)
+and [Copy semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)
+establish ordinary bitwise duplication rather than ownership transfer.
+Accepted `COMPAT-COPY-180-182` preserves exactly these safety and result
+propositions over every `Required` release/target/profile. With source
+`T=u8,count=1`, the call is defined, writes the source byte to `dst`, and leaves
+the source byte unchanged.
+
+### `load_word`
+
+At each covered endpoint, the caller's read-validity, alignment, and initialized
+`u32` facts exactly discharge the [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html)
+or [1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) `ptr::read`
+contract. Those pages say the value is read without moving and source memory is
+unchanged. Endpoint-specific `u32: Copy` evidence
+([1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32),
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32))
+and Copy semantics
+([1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html),
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html)) permit the
+returned duplicate and original source value to remain usable.
+
+For 1.80.1 and 1.81.0, the smallest missing implication is: the endpoint
+`ptr::read` safety/effect propositions and `u32: Copy` semantics apply without
+weaker guarantees or added preconditions. No submitted authority or accepted
+TCB entry supplies it; later evidence cannot propagate backward and 1.80.0
+evidence cannot propagate forward unaided. Soundness and both postconditions
+therefore remain `UNPROVED`.
+
+## Configuration closure and TCB log
+
+Release is the only evidence-sensitive axis. Target/profile coverage is
+parametric because each consumed authority or TCB proposition has the stated
+all-targets-where-present and ordinary-profile applicability, and source
+selection does not vary. The table exhaustively partitions every required
+finite release set. No builds or tool-derived evidence were used.
+
+| Entry | Disposition and exact consumers |
+|---|---|
+| Versioned Rust/std pages listed above | authoritative, claim-specific axioms only in their stated release regions |
+| `SEM-EMPTY-BLOCK-180-182` | accepted OUT-OF-BAND proposition; only `acknowledge` |
+| `COMPAT-COPY-180-182` | accepted OUT-OF-BAND compatibility proposition; only `copy_byte` |
+
+There are no other admitted premises. The TCB entries do not assume an in-scope
+conclusion: local source facts connect each narrow proposition to its consumer.
+
+## Proof-artifact findings and residual scope
+
+The caller-facing safety clauses are sufficient where evidence covers them.
+The three pointer-operation `SAFETY` comments state call-precondition transfer
+but omit the material result derivations and release applicability reconstructed
+above; `acknowledge` states its contract outside a conventional `# Safety`
+section. These are documentation deficiencies, not implementation defects in
+proved regions. Suitable adjacent result text is, respectively: `write`
+overwrites without reading/dropping; the one-`u8` copy copies one byte and,
+because `u8: Copy`, preserves source ownership; `read` returns a `u32` copy and
+leaves source unchanged. No comment can close `load_word`'s middle releases
+without new admissible evidence.
+
+Residual scope is exactly `load_word` on 1.80.1 and 1.81.0, plus all binary,
+backend, nonordinary-profile, and unlisted-release claims. Re-audit on any
+source/contract change, support-set expansion, changed cited documentation,
+TCB disposition/scope change, or addition of configuration-dependent code.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r022/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r022/1/attestation.json
new file mode 100644
index 0000000000..a832fd2ca9
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r022/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r022",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:23:31.288699Z",
+  "report_sha256": "47f498ee490b32d33140eba16ddf4fa3ea10df4bd2c24d2275499fa30fd9de24",
+  "run_id": "r022",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1161
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r022/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r022/1/report.md
new file mode 100644
index 0000000000..285d0e5fb2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r022/1/report.md
@@ -0,0 +1,64 @@
+# Unsafe Rust Audit: `cross-axis-target` 0.1.0
+
+## Claims and verdicts
+
+**Snapshot.** Complete supplied crate: `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md` (respective SHA-256 prefixes `4668f1a3`, `d7a8e7c5`, `045942a4`, `66c7a294`, `1ca6428c`, `ff6b0c8d`). Review date: 2026-08-01. No generated source, dependencies, prior audit, execution, expansion, build, or test was used. Skill identity: supplied unversioned `unsafe-rust` package.
+
+Let `S` be this source under Cargo/Rust/stdlib 1.85.1, edition 2021, on `x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, or `wasm32-unknown-unknown`; `burst` either off or on; allocator `system` or `arena` selected through `BUILD.md`; excluding `wasm32 + arena`; in every Cargo profile and either debug-assertion state. This predicate is fixed by `Cargo.toml`, `BUILD.md`, `SUPPORT.md`, and accepted TCB entry `BUILD-MAP-X`; they do not conflict.
+
+The source-level soundness claim is: every well-typed safe use of the sole public API, and every successful supported build path, is free of Rust UB throughout `S`, relative only to the TCB below.
+
+- **Whole-`S` soundness: UNSOUND (F-01).**
+- **Region `B = aarch64 + burst + arena`: UNSOUND** for every profile/debug-assertion state.
+- **Region `G = S ∖ B`: PROVED** relative to the stated TCB.
+- **Documented behavior:** PROVED on `G`; UNPROVED on `B` for “panics when `value` is zero.” This is not `CONTRACT-BROKEN`: the available zero witness contains UB and therefore is not a defined refutation.
+- **Combined mandatory result:** `UNSOUND` and documented zero behavior `UNPROVED` (F-01). No conditional application claim.
+
+## Boundary, contracts, and obligations
+
+The complete language-reachable crate surface is the safe free function `lane_id(u8) -> NonZeroU8`. There are no public fields, custom constructors/types, methods, traits/impls, statics, callbacks, macros/generated APIs, hidden items, FFI, or reexports. The build script is also in scope. The two source occurrences of `new_unchecked` are cfg-exclusive unsafe consumers. There is no persistent custom invariant-bearing representation.
+
+`INV-NZ(v)` is the local proposition `v != 0`, required immediately at either `NonZeroU8::new_unchecked(v)` call. Rust 1.85.1 documents both that zero “results in undefined behavior” and, under Safety, “[The value must not be zero.](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)”
+
+| ID | Location / exact obligation | Domain and derivation | Status |
+|---|---|---|---|
+| O-01 | `lib.rs:44`: establish `INV-NZ(value)` | On `G`, the cfg-complement branch executes. Primitive `value == 0` is equality; if true, `panic!` prevents reaching line 44; reaching it therefore implies nonzero. The unsafe call then satisfies its exact precondition and constructs the returned nonzero from `value`. | PROVED |
+| O-02 | `lib.rs:31`: establish `INV-NZ(value)` | This branch is exactly `B`. It performs no check. A safe caller may supply every `u8`, including zero. | UNSOUND |
+| O-03 | `lane_id(0)` must panic | On `G`, the dominating branch panics. On `B`, O-02 reaches UB; that execution cannot prove or refute a defined postcondition. | PROVED on `G`; UNPROVED on `B` |
+| O-04 | configuration/build closure and exclusions | Finite cfg partition plus `BUILD-MAP-X` and the source derivation below. Profiles/debug assertions are parametric: neither selects code or removes a check. | PROVED |
+
+The existing line-30 comment, “Burst-mode lane identifiers are never zero,” is a false assertion, not a proof: `value` crosses a safe public boundary with no restriction. The line-43 comment is adequate because it names the dominating check and same value.
+
+## F-01 — safe zero reaches `new_unchecked`
+
+- **Affected theorem:** safe-library soundness and zero-panic behavior in `B`.
+- **Valid UB witness:** use the supported target `aarch64-unknown-linux-gnu`, enable `burst`, select `arena`, choose any profile/debug-assertion state, and safely call `lane_id(0)`. `BUILD-MAP-X` establishes all three active cfg predicates. Lines 24–31 select the first block and call `new_unchecked(0)`. AX-NZ establishes UB. No caller obligation is permitted on this safe API.
+- **Proof-artifact classification:** deficient and false. No invariant producer exists.
+- **Defined postcondition refutation:** not established; the witness contains UB.
+- **Minimum repair:** perform the zero check in all configurations, preferably `NonZeroU8::new(value).expect("lane identifier must be nonzero")`, or use the existing checked branch universally. If retaining unsafe, replacement proof text is: “`value == 0` panics above; reaching this call therefore establishes `value != 0`, the complete `new_unchecked` precondition.” Re-audit all configurations after repair. Removing the documented panic or adding a safe caller restriction would be a public contract change and would not repair soundness.
+
+## Configuration and rejection closure
+
+The relevant axes are exact toolchain/stdlib, three targets, two feature states, two allocator selectors, arbitrary Cargo profile, and debug assertions. There are ten supported target/feature/allocator cells. `B` is one cell; O-01 uniformly covers the other nine. No allocation implementation is used despite the selector names.
+
+For the build interface, [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html) partitions the input into a Unicode value, absent, or non-Unicode error. Absence creates the owned string `system`; [`as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), literal/or/wildcard match semantics, and formatting show that exactly `system` or `arena` emits one corresponding cfg line. Other Unicode values and non-Unicode input take `panic!`; stdout failure also cannot yield a library compilation under `BUILD-MAP-X`. The `rustc-check-cfg` line declares values but does not set them, exactly as `BUILD-MAP-X` records.
+
+For accepted selectors, conditional-compilation semantics ([cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation), [cfg attribute](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute)) give exhaustive complementary `lane_id` bodies. The project-rejected `wasm32 + arena` pair, for either feature/profile/assertion state, activates line 15 and [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), so no library artifact is produced. Missing or simultaneous allocator cfgs likewise hit lines 3 or 9, but manual invented rustc cfgs are explicitly outside the theorem. A build-script stdout failure is an unsuccessful attempt, not a configuration.
+
+## TCB audit log `TCB-cross-axis-2026-08-01`
+
+Trust policy: only exact Rust 1.85.1 Reference/stdlib propositions and the already authorized `BUILD-MAP-X` may be consumed. Safe caller behavior is adversarial. No dependency, compiler-backend, binary, platform, probabilistic, or new implementation premise is admitted.
+
+| ID / category | Exact consumed proposition; scope | Disposition / consumers / trigger |
+|---|---|---|
+| BUILD-MAP-X / OUT-OF-BAND build-tool premise | Exactly the Cargo/target-cfg/feature mappings, stdout-success qualification, and halt-on-unsuccessful-script proposition written in supplied `TCB.md`; all `S` build attempts. No claim about build-script source or emitted selector is imported. | Human-accepted; O-02/O-04; every trigger listed in that entry. |
+| AX-NZ / AXIOM | Rust 1.85.1 `NonZero::new_unchecked(n)` requires nonzero and is UB for zero. | Verified authoritative text; O-01/O-02; Rust/docs/API change. |
+| AX-FLOW / AXIOM | Rust 1.85.1 primitive equality, `if`, `match`, blocks, patterns, and `panic!` semantics used above. | Verified version-matched Reference/stdlib pages listed in the supplied allowlist; O-01/O-03/O-04; toolchain/docs change. |
+| AX-CFG / AXIOM | Rust 1.85.1 cfg/cfg-attribute and `compile_error!` semantics used above. | Verified version-matched authority; O-04; toolchain/docs/cfg change. |
+| AX-BUILD-SRC / AXIOM | Rust 1.85.1 `env::var`, string, formatting, `println!`, panic, and match behavior used only to derive this script’s selector/output partition. | Verified version-matched authority; O-04; source/toolchain/docs change. |
+
+No entries are pending, rejected, expired, or widened from `TCB.md`; no tool-derived evidence exists.
+
+## Residual scope, gaps, and triggers
+
+Excluded are targets/toolchains outside `S`, direct rustc invocation/invented cfgs, backend or binary correctness, and rejected build attempts. No authoritative-documentation or skill-guidance gap blocked this result. Re-audit on any source/manifest/build/support/TCB change; Rust/Cargo/stdlib or cited-contract change; new target, feature, allocator, profile-sensitive code, generator, dependency, API, or unsafe site; or a change to `BUILD-MAP-X` disposition. Every in-scope obligation has a status; every supported cell is covered; the unsound verdict rests on a source proof, not testing or absence of counterexamples.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r023/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r023/1/attestation.json
new file mode 100644
index 0000000000..03b7378bbb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r023/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r023",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:29:20.212400Z",
+  "report_sha256": "4d0cdd801e8141b99cc8248d4bdfa4e04db33b09bfd7984cb5d780318e5d2edd",
+  "run_id": "r023",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 895
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r023/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r023/1/report.md
new file mode 100644
index 0000000000..d66a42caab
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r023/1/report.md
@@ -0,0 +1,65 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+Snapshot: the supplied Cargo.toml, src/lib.rs, POLICY-SCARLET.md, POLICY-INDIGO.md, TCB.md, and REQUEST.md, reviewed source-only on 2026-08-01. There are no dependencies, build scripts, generated artifacts, macros generating APIs, or prior audits in scope.
+
+| Claim | Exact theorem | Verdict |
+|---|---|---|
+| SOUND | For every configuration in Required and every well-typed safe call value_or_zero(value), execution is free of Rust undefined behavior. | PROVED relative to BUILD-MAP-C and the version-matched Rust axioms below. |
+| POST | For those calls, Some(b) returns b and None returns 0. | PROVED. |
+
+Combined mandatory result: PROVED. This is a Rust source-semantics result, not a compiler-backend, binary, or platform theorem.
+
+## Required domain and configuration closure
+
+Let V={1.84.0,1.85.0,1.86.0}, T={X,A,W} as defined by the policies, f=turbo, h=hardened, P=all Cargo profiles, and d∈{debug-assertions-off,on}. Preserve the published predicates:
+
+S = ¬f ∨ (f∧t=X∧(¬h∨v≥1.85.0)) ∨ (f∧t=A∧h).
+
+I = ¬f ∨ (f∧t=X∧(h∨v≥1.86.0)) ∨ (f∧t=A∧¬h∧v≥1.85.0).
+
+Because neither policy has precedence, Required is the conservative audit predicate S∨I, with v∈V, t∈T, both Boolean feature states, p∈P, and d in both states. This is not a resolution or a new support promise. Exact case normalization gives:
+
+Required = ¬f ∨ (f∧t=X) ∨ (f∧t=A∧(h∨v≥1.85.0)).
+
+Proof: on X, (¬h∨v≥1.85)∨(h∨v≥1.86) is true for every h; on A, h∨(¬h∧v≥1.85) equals h∨v≥1.85; neither predicate admits f∧t=W. Thus S⊆Required, I⊆Required, and the reverse inclusion follows by the same target cases.
+
+Effective rejection is separately proved. BUILD-MAP-C maps f and target W to the corresponding cfg predicates. In each exact release, cfg(all(...)) is true exactly when both options are set, and a false cfg removes its item; [1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Each compile_error! page states that encountering it causes compilation to fail: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Therefore f∧t=W cannot yield this library. Required already excludes it; ¬f on W remains admitted and selects the safe implementation.
+
+The only actual axes are v,t,f,h,p,d and edition 2021. Hardened, profiles, and debug assertions do not occur in executable expressions; there is no arithmetic, allocation, panic-dependent cleanup, FFI, concurrency, target layout, or target instruction. The proof is parametric over h,p,d and over X/A, and separately covers ¬f on W. Exact per-release axioms avoid any cross-version compatibility premise. Aggregate Covered equals Required, hence Required⊆Covered.
+
+## Boundary, invariant, and obligation coverage
+
+The sole language-reachable project API is the safe public function value_or_zero(Option<u8>)->u8. Mutually exclusive cfg attributes select exactly one definition. There are no public fields, constructors of project types, traits or impls, statics, callbacks, reexports, hidden items, FFI, or custom destruction. No persistent invariant-bearing representation exists.
+
+A transient local fact, INV-SOME, is owned by the turbo function: after value.is_none() evaluates false, value is Some until immediately consumed. It is produced by the branch, never suspended or mutated, and consumed only by unwrap_unchecked.
+
+| ID | Obligation and derivation | Domain | Status |
+|---|---|---|---|
+| O-CFG | Select exactly one implementation; reject f∧W. cfg axioms plus BUILD-MAP-C establish this. | all policy candidates | PROVED |
+| O-SAFE | With ¬f, unwrap_or returns the Some payload or supplied default 0. | Required∧¬f | PROVED |
+| O-GUARD | is_none returns true exactly for None; true returns 0, false establishes INV-SOME. Its receiver is &self, so the test does not consume or alter value. | Required∧f | PROVED |
+| O-UNSAFE | unwrap_unchecked requires the value not be None. INV-SOME supplies that exact precondition; it returns the contained u8. | Required∧f | PROVED |
+| O-POST | Combining None/Some branches establishes the published function postcondition. | Required | PROVED |
+
+For every release, the Option documentation says is_none “Returns true if the option is a None value,” unwrap_unchecked says calling it on None is undefined behavior, and unwrap_or returns the Some value or the default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or). The adjacent SAFETY comment states the dominating None return and Some conclusion; the full material derivation is O-GUARD/O-UNSAFE.
+
+## TCB audit log
+
+Log identity: supplied TCB.md for this exact snapshot. Trust policy: Rust Reference/std text is authoritative for its exact release; the only admitted non-authoritative premise is the conspicuous human decision BUILD-MAP-C.
+
+| ID | Category/disposition | Exact proposition; consumers; trigger |
+|---|---|---|
+| BUILD-MAP-C | BUILD-TOOL, accepted | Exact Cargo feature-to-cfg and named-target-to-target_arch mappings for V, supplied manifest/source, and every supported profile; consumed only by O-CFG. It admits no Rust semantics, branch correctness, other versions, or backend correctness. Trigger: any identity, manifest/source cfg, feature/target, profile scope, or disposition change. |
+| AX-OPTION-v | AXIOM, verified | Exact is_none, unwrap_unchecked, and unwrap_or propositions linked above for each v∈V; consumed by O-SAFE/O-GUARD/O-UNSAFE/O-POST. Trigger: relevant versioned documentation change. |
+| AX-CFG-v | AXIOM, verified | Exact configuration-predicate/cfg-attribute rules ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation)) and compile_error! behavior; consumed by O-CFG. Trigger: relevant documentation change. |
+
+No safe/unsafe dependency, implementation, external, deployment, probabilistic, or tool premise is consumed. No tool-derived evidence was used.
+
+## Findings, residual scope, and attestation
+
+No UNSOUND, UNPROVED, CONTRACT-BROKEN, Rust-documentation-gap, or proof-documentation finding remains. The policy conflict itself remains unresolved; only the explicitly conservative union was audited. Configurations outside S∨I are not certified, although f∧W rejection is established. Build success beyond the stated source/configuration facts and all backend/binary behavior are excluded.
+
+Re-audit on source, manifest, either policy, TCB disposition, supported version/target/feature/profile/debug domain, or consumed authoritative text changing. Every in-scope surface, contract clause, unsafe operation, domain transformation, and TCB consumer has a disposition; no testing or absence-of-counterexample premise supports the verdict.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r024/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r024/1/attestation.json
new file mode 100644
index 0000000000..f1eb1de2c1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r024/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r024",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:26:47.741082Z",
+  "report_sha256": "89b14c495f9833e34e5cf92aa27d75aec62ad353d1b06393998fb1bcc57577ca",
+  "run_id": "r024",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 936
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r024/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r024/1/report.md
new file mode 100644
index 0000000000..5dfb864352
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r024/1/report.md
@@ -0,0 +1,64 @@
+# Focused source-only audit of `classify`
+
+## Claims and verdicts
+
+| Claim | Exact theorem over `Required` | Verdict | Certificate |
+|---|---|---|---|
+| C-SOUND | Every valid safe call `classify(input)` is free from Rust undefined behavior. | **UNSOUND** | W0 below: the valid safe call with `input = 0` reaches `unreachable_unchecked`. |
+| C-PANIC | Every call with `input = 0` panics. | **UNPROVED** | The only source path reaches UB. That execution cannot certify a behavioral contract refutation, and there is no UB-free witness. |
+| C-RESULT | Whenever the call returns normally, its result equals `input`. | **CONTRACT-BROKEN** | W1 below: the UB-free call with `input = 1` normally returns `2`. |
+
+The combined mandatory result is therefore not `PROVED`; its component results are **UNSOUND**, **UNPROVED**, and **CONTRACT-BROKEN**, respectively.
+
+## Snapshot, scope, and domain closure
+
+The artifact is the submitted `lib.rs`, SHA-256 `705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`. Scope is its sole language-reachable API, safe public free function `pub fn classify(u8) -> u8`, including its internal unsafe call. There are no fields, traits, macros, generated artifacts, dependencies, callbacks, FFI, concurrency, allocators, or representation invariants in the submitted source.
+
+Audit cutoff: 2026-08-01. The controlling request defines
+
+`Required = {exact source} × {Rust compiler and standard library 1.80.0} × {targets where this exact source and the used item exist} × {ordinary debug, ordinary release} × {every valid u8 input}`.
+
+The source contains no `cfg`, feature, target, or profile-dependent selection. Partition the input domain exactly by the exhaustive match patterns: `D0 = {0}`, `D1 = {1}`, and `D_ = {valid u8 values other than 0 and 1}`. Thus `Required = D0 ∪ D1 ∪ D_` for every required target/profile. The proofs below are parametric in target and profile: neither axis changes the selected source arm, and the submitted authoritative propositions expressly apply throughout that target/profile domain. This proves configuration coverage for each regional result; C-SOUND and C-RESULT are globally refuted by covered witnesses, while C-PANIC has the stated unresolved obligation on all of `D0`. No compilation or test evidence was used.
+
+## Authority and TCB
+
+TCB revision `TCB-classify-1` contains only the two requester-submitted Rust 1.80.0 axioms, independently opened and accepted for this review:
+
+- **AXIOM-UU:** the Rust 1.80.0 standard-library Safety section says, “Reaching this function is *Undefined Behavior*.” It applies to `std::hint::unreachable_unchecked` over every required target/profile. [Official item documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+- **AXIOM-SOUND:** the Rust 1.80.0 Reference says that if unsafe code “can be misused by safe code to exhibit undefined behavior, it is *unsound*.” It controls the source-level classification here. [Official UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html).
+
+All other premises below are direct control/value-flow facts from the exact source. No compiler-backend, binary, platform-implementation, tool, or dependency proposition is admitted.
+
+## Obligation ledger and case proofs
+
+| ID | Obligation | Case disposition |
+|---|---|---|
+| O-UNREACHABLE | A reached call to `unreachable_unchecked` must in fact be unreachable. | False on `D0`; the match selects that arm and execution reaches the call. The call is absent on `D1` and `D_`. |
+| O-SOUND | No valid safe call may reach UB. | Refuted by W0. On `D1` and `D_`, the unsafe site is not reached; each arm directly returns a valid `u8`. |
+| O-PANIC | On `D0`, the call must panic. | Unproved: the path reaches UB rather than a panic operation, but its UB prevents a `CONTRACT-BROKEN` certificate. |
+| O-RESULT | On every UB-free normal return, result equals input. | Refuted by W1 on `D1`; proved locally on `D_` because that arm evaluates to `input`. `D0` supplies no UB-free normal-return witness. |
+
+### W0: exact UB witness (`input = 0`)
+
+1. `classify(0)` is well-typed safe use of a safe public function; it has no caller safety precondition.
+2. Pattern `0` is selected. The local `marker` operations complete, then the unsafe call to `std::hint::unreachable_unchecked()` is reached.
+3. Therefore the call's required proposition—its site is unreachable—is false.
+4. AXIOM-UU entails UB, and AXIOM-SOUND classifies a safe API permitting this witness as unsound.
+
+This complete witness establishes **UNSOUND** for C-SOUND on every required target/profile. It does **not** establish `CONTRACT-BROKEN` for C-PANIC: an execution containing UB cannot be the required UB-free behavioral counterexample, nor can its behavior after UB prove the panic guarantee.
+
+### W1: exact defined contract witness (`input = 1`)
+
+Pattern `1` is selected and directly evaluates to valid `u8` value `2`; the unsafe arm is not entered and no other UB-producing operation exists on this path. The call therefore returns normally and UB-free with `result = 2`, while `input = 1`. Since `2 != 1`, W1 establishes **CONTRACT-BROKEN** for C-RESULT. It does not establish unsoundness.
+
+### Other inputs
+
+For every valid `u8` other than `0` and `1`, the wildcard arm directly returns `input`. The unsafe site is unreachable on these calls, so this region is sound and satisfies C-RESULT. These regional proofs do not erase either existential witness.
+
+## Findings and repairs
+
+**F1 — implementation unsoundness and false proof comment.** The comment “This branch is assumed to be unreachable” neither derives the unsafe precondition nor states a true fact: `input = 0` makes the branch reachable. No replacement safety proof can validate the current operation. To meet C-PANIC, replace the unsafe call with an unconditional panic on that arm. Re-audit the changed source.
+
+**F2 — normal-result contract defect.** Arm `1 => 2` contradicts the documented unchanged-result guarantee. Return `1`/`input`, or deliberately revise the public contract with compatibility review. This repair is independent of F1.
+
+Residual scope excludes other Rust releases, targets where the source/item does not exist, nonordinary profiles, backend/binary correctness, and properties not requested. Re-audit on any source or documentation change, Rust/standard-library version change, support-domain expansion, or material change to either consumed official contract.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r025/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r025/1/attestation.json
new file mode 100644
index 0000000000..017efcf7fe
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r025/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r025",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:30:48.780502Z",
+  "report_sha256": "cae33ebb10f593bbebe9722ae1b12d2a8e1ebbeaa477704ed16d61296c964bae",
+  "run_id": "r025",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 724
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r025/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r025/1/report.md
new file mode 100644
index 0000000000..c14157b3be
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r025/1/report.md
@@ -0,0 +1,101 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Combined mandatory verdict: PROVED**, relative to accepted TCB entry
+`COMPAT-OPTION-184-186` in the supplied `TCB.md` (SHA-256
+`db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413`). For
+the exact supplied source, every well-typed safe call to `value_or_zero` is free
+of Rust undefined behavior and returns the contained byte for `Some(v)` or zero
+for `None`, throughout the supported set below. Soundness: **PROVED relative to
+that TCB entry**. Documented result: **PROVED relative to that TCB entry**.
+
+This is a source-level Rust-abstract-semantics claim, not a claim about compiler
+correctness or any emitted binary.
+
+## Snapshot, scope, and supported set
+
+The complete target consists of `Cargo.toml`, `TCB.md`, `CI.md`, `REQUEST.md`,
+`SUPPORT.md`, and `src/lib.rs`; the latter has SHA-256
+`6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8`.
+Scope is the entire `no_std`, edition-2021 library. It has no dependencies,
+build script, generated source, or prior audit.
+
+`SUPPORT.md` controls support (the manifest's `rust-version = "1.84"` is only
+the Cargo minimum). The exact predicate is:
+
+* released stable Rust `r` with `1.84.0 <= r <= 1.86.0`—namely 1.84.0,
+  1.84.1, 1.85.0, 1.85.1, or 1.86.0; the official notes record
+  [1.84.1](https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30)
+  and [1.85.1](https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18);
+* target `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or
+  `wasm32-unknown-unknown`;
+* either `telemetry` state, every Cargo profile, and either debug-assertion
+  state.
+
+CI is sampling only and supplies no proof. There are no source `cfg`s or uses
+of the feature, target, profile, assertions, allocation, arithmetic,
+concurrency, panic, FFI, assembly, macros, or linking. Thus one source/dataflow
+proof is parametric over every non-toolchain axis; the accepted TCB proposition
+explicitly covers every toolchain member and all those axes. No supported
+combination is uncovered.
+
+## Boundary and obligation inventory
+
+The sole language-reachable crate surface is safe free function
+`value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4-12`). There are no public
+fields/types, constructors, traits or impls, hidden items, statics, reexports,
+callbacks, macros, or FFI. The sole unsafe site is the internal
+`Option::unwrap_unchecked` call at line 11. There is no persistent state or
+abstraction invariant; only the dominating branch fact is consumed.
+
+| ID | Exact obligation | Derivation | Status |
+|---|---|---|---|
+| O1 | Safe callers have no hidden safety precondition. | The function accepts every `Option<u8>` and branches before its only unsafe operation. | PROVED |
+| O2 | Line 11 is never called on `None`. | Under `COMPAT-OPTION-184-186`, `is_none` is true exactly for `None`. Reaching line 11 means the test at line 5 returned false, so `value = Some(v)`. The same accepted entry states that `unwrap_unchecked(Some(v))` is defined and returns `v`, whereas `None` would be UB. | PROVED relative to TCB |
+| O3 | The documented result is returned. | If `None`, O2's `is_none` proposition makes line 6 return zero. If `Some(v)`, the test is false and O2 makes line 11 return `v`. These exhaustive cases establish the documentation at line 3. | PROVED relative to TCB |
+
+The Rust 1.84.0 base pages say `is_none` “[r]eturns `true` if the option is a
+`None` value” and `unwrap_unchecked` “[r]eturns the contained `Some` value”; they
+also state that calling it on `None` is undefined behavior
+([`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+The exact uniform proposition used above is nevertheless the human-accepted
+compatibility entry, not an inference from API stability. Its permitted
+consumers are precisely O2/O3; it supplies no release-membership, Cargo,
+backend, or binary fact.
+
+## Finding D1 — deficient adjacent proof, implementation proved
+
+The line 9 comment identifies the branch and callee precondition, but omits the
+material authoritative/TCB bridge and its supported-domain applicability.
+Implementation classification: **PROVED relative to
+`COMPAT-OPTION-184-186`**. Proof-artifact classification: **deficient**. No UB
+witness or defined postcondition refutation is established.
+
+Proposed replacement:
+
+```rust
+// SAFETY: By COMPAT-OPTION-184-186 throughout the supported domain,
+// value.is_none() is true exactly for None. Reaching here means it returned
+// false, so value is Some(v); unwrap_unchecked(Some(v)) is defined and returns v.
+```
+
+This documentation repair changes no API or behavior. Re-audit the proof if
+the source, documented result, support interval/axes, cited base propositions,
+or TCB disposition changes.
+
+## TCB, evidence, and residual scope
+
+`COMPAT-OPTION-184-186` is an accepted compatibility premise, scoped only as
+quoted above; its identity, consumers, exclusions, and re-audit triggers were
+verified. No dependency, tool-derived, test-derived, environmental,
+probabilistic, or implementation premise is consumed. The version-matched
+allowlisted standard-library pages for all five releases were checked and do
+not add a qualification, but they are not used to invent a general
+compatibility rule.
+
+Excluded: unsupported configurations, compiler/backend correctness, emitted
+binaries, and ordinary robustness beyond the requested documented result. No
+build, execution, macro expansion, or test was performed. No authoritative
+documentation gap or unresolved proof obligation remains.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r026/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r026/1/attestation.json
new file mode 100644
index 0000000000..f62da70152
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r026/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r026",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:33:54.989666Z",
+  "report_sha256": "0ff6cb9b958a530a041aa729635ab67524b6fbcc772a8cf5856d861bbe23fb17",
+  "run_id": "r026",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 816
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r026/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r026/1/report.md
new file mode 100644
index 0000000000..97b39d6272
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r026/1/report.md
@@ -0,0 +1,102 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+This review covers exactly the submitted `lib.rs` exports in package
+`quantifier-target` 0.1.0 (edition 2021), with the manifest's exact dependency
+`peer-unsafe-dep = 3.4.5`, the submitted dependency declaration/contract, and
+the submitted evidence and trust decision. No dependency implementation,
+generated output, binary, source revision/digest, or prior audit was supplied.
+No build, execution, expansion, or implementation inference is used.
+
+Let **D** be Rust and standard library 1.80.0, every target on which this exact
+source and dependency resolve, and every ordinary debug or release profile.
+Both claims are source-level Rust-abstract-semantics claims over D. There are no
+source `cfg`s, features, profile-dependent checks, generators, FFI, allocation,
+concurrency, or other configuration branches in the submitted crate. Thus the
+source reasoning below is parametric over target and profile; the unavailable
+dependency implementation is a proof premise gap, not a silently excluded
+configuration.
+
+The complete exported surface is the two public free functions. There are no
+exported fields, types, traits, macros, statics, hidden items, or generated APIs
+in the supplied source, and no invariant-bearing state.
+
+## Evidence and TCB (`TCB.md`, submitted revision)
+
+| ID | Disposition | Exact proposition and scope | Consumer |
+|---|---|---|---|
+| AXIOM-UU | accepted and independently verified | Rust 1.80.0 documents: “Reaching this function is Undefined Behavior.” The page gives no target/profile qualification, so the supplied policy applies it throughout D. [Versioned Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). | FU-1 |
+| DEP-CONTRACT | controlling submitted contract, not implementation trust | `peer-unsafe-dep` 3.4.5 declares unsafe `duplicate_nonzero(value: u8) -> u8`; callers must supply `value != 0`, and its documented result is `value`. | DN-1, DN-2 |
+| UNSAFE-DEP-PEER | expressly not proposed or accepted | For every configuration in D and every nonzero `u8`, the exact 3.4.5 implementation executes without Rust UB and returns the input value. | Would be required by DN-2 |
+
+No implementation, compatibility, tool, or deployment premise is admitted.
+An exact version pin fixes identity but does not prove an unsafe provider's
+implementation conforms to its contract.
+
+## Claim 1: `force_unreachable`
+
+**Valid-use domain.** Every well-typed safe call in every configuration in D;
+the safe signature permits no caller-side safety precondition.
+
+**Claim.** Every such call and permitted execution is free of Rust UB.
+
+**Verdict: UNSOUND throughout D.** The body has no condition or alternative
+path: every invocation reaches `std::hint::unreachable_unchecked()`. FU-1's
+only obligation is that this call site not be reached. A well-typed safe caller
+can invoke the function, and the body necessarily reaches it. AXIOM-UU then
+entails UB. This is a valid in-scope UB witness for every member of D and
+refutes the universal soundness claim.
+
+The adjacent comment merely assumes the proposition contradicted by control
+flow; it supplies no fact or boundary. This is both an implementation defect
+and a deficient proof artifact. The minimal resolution is to remove the
+unchecked operation (for example, use defined panic/nonreturning behavior) or
+remove the callable safe surface; prose cannot impose a hidden safety
+precondition. The summary sentence supplies no ordinary-return postcondition,
+and the UB-containing witness is not a `CONTRACT-BROKEN` witness.
+
+## Claim 2: `delegated_nonzero`
+
+**Valid-use domain.** Every call in D whose caller satisfies the complete
+published safety condition `value != 0`; `u8` is passed by value, so the
+submitted contract creates no ongoing or terminal caller obligation.
+
+**Claim.** Every such call and permitted execution is free of Rust UB.
+
+**Verdict: UNPROVED throughout D.** DN-1, the local call obligation, is proved:
+the wrapper passes the unchanged `value`, and its caller contract is literally
+the dependency call's submitted precondition. The local `SAFETY` comment
+adequately records this implication.
+
+DN-2, provider conformance, is not proved. The smallest missing soundness
+proposition is:
+
+> For every configuration in D and every `value: u8` with `value != 0`, the
+> exact `peer-unsafe-dep` 3.4.5 implementation of `duplicate_nonzero(value)`
+> executes without Rust undefined behavior.
+
+No supplied source or accepted TCB entry establishes that proposition, and the
+human trust decision expressly rejects assuming it. Therefore satisfying the
+callee's caller precondition proves permission to call, not correctness of the
+unavailable unsafe implementation. No UB witness is established, so
+`UNSOUND` would be unjustified.
+
+The dependency contract additionally promises that the result equals `value`.
+If that result guarantee is treated as incorporated by the wrapper's
+“Delegates” documentation, its postcondition verdict is also **UNPROVED**: add
+“and returns `value`” to the missing proposition above. There is no independent
+UB-free refutation, so `CONTRACT-BROKEN` is not established. Equality is not
+needed merely for validity of the returned `u8` and therefore cannot repair or
+worsen the soundness proof gap.
+
+## Residual scope and review triggers
+
+Dependency internals, generated artifacts, binaries/backend correctness, and
+configurations outside D are not audited. Re-audit both claims if `lib.rs`,
+Rust/standard-library version, supported targets/profiles, or the authoritative
+Safety text changes. Re-audit the second claim if dependency identity, features,
+contract, implementation evidence, or its human TCB disposition changes.
+
+All in-scope obligations have dispositions: FU-1 is disproved; DN-1 is proved;
+DN-2 is unproved. No tests or tool-derived evidence contribute to a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r027/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r027/1/attestation.json
new file mode 100644
index 0000000000..5df42826f0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r027/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r027",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:36:48.944273Z",
+  "report_sha256": "4661ad891ae68f808fefc57a29a5b2d1ee36364508329ddb3163e18761d0b9ad",
+  "run_id": "r027",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 910
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r027/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r027/1/report.md
new file mode 100644
index 0000000000..6f14f1778b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r027/1/report.md
@@ -0,0 +1,71 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+| Claim | Exact theorem | Verdict | Qualification |
+|---|---|---|---|
+| SOUND | For every `Required` configuration and every well-typed safe call `value_or_zero(value: Option<u8>)`, execution is free of Rust undefined behavior. | **PROVED** | Source-level Rust semantics, relative to accepted TCB entry `COMPAT-OPTION-184-186`. |
+| RESULT | In the same domain, `value_or_zero(None) == 0` and `value_or_zero(Some(v)) == v` for every `u8` `v`. | **PROVED** | Relative to the same accepted entry. |
+
+**Combined mandatory result: PROVED**, relative to conspicuous use of `TCB.md` entry `COMPAT-OPTION-184-186`. Scope is the complete supplied crate snapshot and its sole public safe API. This is not a compiler-backend or emitted-binary claim.
+
+## Snapshot and required domain
+
+Audited inputs are `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs` as supplied. There are no dependencies, build scripts, generators, generated artifacts, macros, FFI, assembly, concurrency, allocation, mutable state, or target-specific source. The crate is edition 2021 and `no_std`.
+
+Preserving the controlling expression rather than inventing a finite release list:
+
+```text
+Required(r,t,f,p,d) :=
+  ReleasedStableRust(r) && 1.84.0 <= r <= 1.86.0
+  && t in {x86_64-unknown-linux-gnu,
+           aarch64-apple-darwin,
+           wasm32-unknown-unknown}
+  && f in {telemetry-off, telemetry-on}
+  && p is any Cargo profile
+  && d in {debug-assertions-off, debug-assertions-on}.
+```
+
+`SUPPORT.md` expressly makes that predicate, including its upper cutoff, the support commitment. `Cargo.toml`'s `rust-version = "1.84"` supplies the compatible lower Cargo admission threshold but does not replace the policy or erase its upper bound. `CI.md` is only a sample and is not used to transform or prove the domain. No enumeration of `ReleasedStableRust` is used: the proof below and the accepted compatibility premise quantify over the symbolic predicate directly.
+
+Configuration selection is source-identical: neither feature nor target appears in a `cfg`; there are no assertions or profile-sensitive arithmetic; and the only unsafe operation's admitted contract explicitly covers every `Required` target, profile, feature, and debug-assertion state. Thus each obligation's `Covered` predicate equals `Required`, establishing `Required ⊆ Covered` without relying on CI samples. The audit cutoff is 2026-08-01; the fixed upper bound makes it non-moving.
+
+## Boundary, invariants, and obligations
+
+The complete language-reachable crate-defined API surface is the safe free function `value_or_zero`. There are no public fields, constructors, types, traits or impls, methods, statics, reexports, hidden items, callbacks, or macro-generated APIs. The internal unsafe consumer is `Option::unwrap_unchecked` at `src/lib.rs:12`. There is no persistent representation invariant; the sole proof fact is the branch-local classification of `value`.
+
+| ID | Proposition | Proof/status |
+|---|---|---|
+| O1 | The `None` branch returns before the unsafe call. | Direct control flow at lines 6–8; **PROVED** for `Required`. |
+| O2 | Every execution reaching line 12 has `value = Some(v)`. | `is_none` is exactly the `None` discriminator by the accepted TCB proposition; negating the taken condition and the two `Option` variants gives `Some(v)`; **PROVED** for `Required`. |
+| O3 | Line 12 satisfies `unwrap_unchecked`'s safety precondition and returns `v`. | O2 plus the version-applicable contract below; **PROVED** for `Required`. |
+| O4 | Both documented result cases hold. | Exhaustive `None`/`Some(v)` partition and O1/O3; **PROVED** for `Required`. |
+
+The Rust 1.84.0 documentation says `is_none` “Returns `true` if the option is a `None` value” and says, for `unwrap_unchecked`, “Calling this method on `None` is undefined behavior”; it also specifies that a `Some` receiver yields its contained value ([`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). The same method contracts were independently checked in [1.84.1](https://doc.rust-lang.org/1.84.1/std/option/enum.Option.html#method.unwrap_unchecked), [1.85.0](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [1.85.1](https://doc.rust-lang.org/1.85.1/std/option/enum.Option.html#method.unwrap_unchecked), and [1.86.0](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked). These checks corroborate but do not purport to enumerate the release interval.
+
+The proof is exhaustive:
+
+- If `value = None`, accepted proposition (1) makes `is_none()` true; line 7 returns `0`, line 12 is unreachable, and both SOUND and RESULT hold.
+- If `value = Some(v)`, proposition (1) makes `is_none()` false; line 12 is reached with a non-`None` receiver. Its safety obligation is satisfied, and accepted proposition (2) makes the result `v`. Thus SOUND and RESULT hold.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact consumed proposition and scope | Consumers / trigger |
+|---|---|---|---|
+| STD-OPTION-184 | Versioned standard-library authority; verified | The two quoted 1.84.0 method contracts above. | Basis for COMPAT; revisit if those pages materially change. |
+| COMPAT-OPTION-184-186 | Compatibility premise; **accepted by the authorized human reviewer** | For every `Required` release/configuration, `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`, while calling it on `None` is UB. It establishes no release-set inventory, Cargo fact, backend, or binary fact. | O2–O4 and both verdicts; triggers exactly as stated in `TCB.md`. |
+
+No other premise, dependency, implementation, tool, deployment, or probabilistic trust is consumed. The accepted entry is not inferred from the sampled version pages; it is the explicit interval-coverage basis authorized by the request.
+
+## Finding DOC-1: local proof artifact is incomplete
+
+**Implementation obligation: PROVED. Proof-artifact classification: deficient.** The existing `SAFETY` comment captures the branch idea but neither names the semantic premise nor its applicability throughout `Required`. The material reconstruction is O2–O3 above. This does not weaken either verdict, but the smallest adequate repair is an adjacent comment such as:
+
+```rust
+// SAFETY: By accepted TCB entry COMPAT-OPTION-184-186, for every
+// supported configuration is_none() is true exactly for None. The true
+// branch returned above, so value is Some(v). The same entry preserves
+// unwrap_unchecked's contract: this call is permitted and returns v.
+```
+
+No caller-facing contract change is needed. Re-audit after any source, support predicate, method contract, TCB disposition, or configuration-scope change. Outside scope are unsupported toolchains/configurations and binary correctness. No tools, builds, tests, execution, or macro expansion were used as evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r028/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r028/1/attestation.json
new file mode 100644
index 0000000000..4396a68ecf
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r028/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r028",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:38:30.277206Z",
+  "report_sha256": "130367c76a139f7075e90837340f67fbb8411604f57a468cb3a30499bfc9a585",
+  "run_id": "r028",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 995
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r028/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r028/1/report.md
new file mode 100644
index 0000000000..83ccfb4387
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r028/1/report.md
@@ -0,0 +1,62 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot and scope.** This is a source-only review of the complete supplied `lib.rs`, lines 1–18. The supported predicate is exactly Rust/standard library 1.82.0, every target on which this source and the used standard-library items exist, and every ordinary profile. There are no dependencies, `cfg` branches, features, generated artifacts, macros, FFI, allocation, concurrency, or build inputs in the supplied artifact. The proof is parametric over target and profile: array length `2`, values `1` and `2`, safe-trait openness, and the cited library contracts do not vary across that set. Audit date: 2026-08-01.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces is free from Rust undefined behavior under Rust 1.82.0 abstract semantics. **Verdict: UNSOUND** (`F-1`) over the entire supported predicate. The safe generic API admits an out-of-bounds unchecked access.
+
+**Requested Tail behavior.** For every initial `pair == [a, b]`, `increment::<Tail>(&mut pair)` returns with `pair == [a, b.wrapping_add(1)]`. **Verdict: PROVED** (`O-2`) over the entire supported predicate. This regional behavioral result does not qualify the soundness verdict. The source documents no caller-facing postcondition, so there is no separate source-documented postcondition to classify as `CONTRACT-BROKEN`.
+
+**Combined current-artifact result: UNSOUND.** No proposal below participates in this verdict.
+
+## Boundary and obligation coverage
+
+The complete public surface is: safe, downstream-implementable trait `Slot` and safe associated function `Slot::index` (lines 3–5); publicly constructible unit struct `Tail` (line 7); its safe `Slot` implementation (lines 9–13); and safe generic function `increment<S: Slot>` (lines 15–18). The sole unsafe operation is the internal `get_unchecked_mut` call at line 16. There are no fields, unsafe declarations/impls, hidden APIs, callbacks, custom `Drop`, or generated surfaces. Ordinary compiler-provided moves, destruction, and auto traits carry no state and do not affect the finding.
+
+| ID | Exact obligation and derivation | Status |
+|---|---|---|
+| O-1 | A safe call to `increment::<S>` must establish `S::index() < 2` before line 16 for every safe `S: Slot`. The trait type/signature and source perform no check and enforce no such behavior. | **False; UNSOUND (F-1)** |
+| O-2 | For `S = Tail`, line 11 yields `1`; a `[u32; 2]` has indices `0,1`, so the unchecked call is in bounds and selects element 1. `wrapping_add(1)` computes its modular successor, which line 17 stores through that exclusive reference. Only element 1 is targeted. | **PROVED** |
+| O-3 | The unsafe block needs an adjacent proof of O-1. It has no `SAFETY` comment, and no truthful proof exists for its generic domain. The O-2 reconstruction validates only the Tail specialization and cannot retroactively narrow the safe API. | **Proof artifact deficient; implementation globally UNSOUND** |
+| O-4 | Configuration closure: F-1 uses index `2`, representable on every supported target, against an array of invariant length `2`; O-2 uses index `1`. No profile-dependent assertion, overflow operation, or code selection occurs. | **Complete** |
+
+There is no enforceable representation invariant. The needed proposition “all `Slot` implementations return an index below 2” has no owner or sealing boundary and is disproved by F-1.
+
+## TCB audit log `TCB-R028-r1`
+
+Policy: only exact Rust 1.82.0 Reference/standard-library axioms may be consumed; no additional assumptions, dependencies, tools, tests, implementation behavior, or compatibility premise is admitted.
+
+* **AXIOM-SLICE-1 (accepted):** for Rust 1.82.0 on the supported set, `slice::get_unchecked_mut` returns the indexed mutable reference without bounds checking, and: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82.0 `get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut). Consumers: O-1, O-2, F-1. Recheck if the Rust version or contract changes.
+* **AXIOM-U32-1 (accepted):** for Rust 1.82.0 on the supported set, `u32::wrapping_add` is “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82.0 `wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add). Consumer: O-2 and the proposed contract. Recheck if the Rust version or contract changes.
+
+No tool-derived evidence or sampled execution was used. Both citations were opened at the exact version. No premise is pending or rejected.
+
+## F-1 — safe implementer controls an unchecked index
+
+**Classification:** implementation `UNSOUND`; proof artifact missing. `Slot` is a public safe trait, so well-typed safe downstream code may implement it with any `usize` result:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+This is a valid safe use. `Bad::index()` returns `2`; for length 2 that is out of bounds. AXIOM-SLICE-1 therefore makes the call at line 16 UB immediately, independently of later dereference. This witness applies to every supported target and profile. No UB-free postcondition refutation is claimed from this execution. Minimum resolution is to remove the unchecked generic access, validate the index before unsafe use, or enforce implementer behavior at an actual unsafe/sealed boundary. Given the stated requirement, specialization is smaller and removes the premise entirely.
+
+## Preferred redesign (not implemented; no fresh verdict)
+
+Use one monomorphic safe function and delete `Slot` and `Tail`:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed contract is: no caller safety precondition; for every `[a,b]`, normal return produces `[a, b.wrapping_add(1)]`. The fixed array type and safe constant indexing enforce access to element 1; AXIOM-U32-1 supplies the arithmetic postcondition. There is no unsafe surface, implementer obligation, representation, or abstraction invariant. Making `Slot` unsafe, sealing it, or retaining a checked generic index would preserve genericity that no required consumer needs.
+
+**Migration/contract delta.** Remove the public trait, its downstream implementation capability, `Tail`, and the type parameter. Replace `increment::<Tail>(&mut pair)` with `increment(&mut pair)`. Generic calls and downstream `Slot` implementations intentionally cease to compile, as authorized for this unreleased abstraction. The required Tail-observable mutation is unchanged; the new explicit function contract strengthens the previously undocumented behavioral surface.
+
+After implementation, audit the new snapshot independently: enumerate its actual public surface; verify constant array indexing and wrapping semantics for Rust 1.82.0; prove the complete mutation/postcondition and panic behavior for every input; re-establish target/profile closure; and confirm that no conditional/generated code or unsafe operation was introduced. Source, public-contract, supported-set, or cited Rust-contract changes trigger re-audit. Nothing outside the supplied file was audited.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r029/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r029/1/attestation.json
new file mode 100644
index 0000000000..427a5eaf2f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r029/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r029",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:41:01.437615Z",
+  "report_sha256": "ff506100d0e272b8bd653caab454d10845a938aee535aa0cb927869bc553b883",
+  "run_id": "r029",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 1093
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r029/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r029/1/report.md
new file mode 100644
index 0000000000..479dbf06ff
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r029/1/report.md
@@ -0,0 +1,66 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot.** Exact supplied `lib.rs` (18 lines) under Rust/standard library 1.82.0; no generated code, dependencies, build scripts, `cfg`, features, FFI, concurrency, or prior audit is present in the supplied artifact. Audit cutoff: 2026-08-01. Report/TCB ID: `R029-1` / `R029-TCB-1`.
+
+`Required(c)` is exactly: Rust 1.82.0, every target `c.target` on which this source and the two used standard-library items exist, and every ordinary profile, for every well-typed safe use of the public surfaces. This preserves the request's symbolic target and profile predicates rather than inventing an enumeration.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All well-typed safe uses of the current public API avoid Rust UB | **UNSOUND** | `F-1` gives a valid safe use, reaches the unchecked call with a false bounds precondition, and the applicable Rust 1.82 contract declares UB. |
+| For `increment::<Tail>` and every initial `[a,b]`, normal return is UB-free and produces `[a, b.wrapping_add(1)]` | **PROVED** | `P-TAIL` below, over all `Required(c)`, relative only to the two Rust 1.82 axioms in `R029-TCB-1`. |
+
+The combined current-artifact result is **UNSOUND**. The Tail-specific proof does not repair or narrow the safe generic API's claim.
+
+## Boundary, invariant, and obligation inventory
+
+Safe public surfaces are: downstream-implementable trait `Slot` and its safe associated function `index` (lines 3–5); publicly constructible unit struct `Tail` (line 7); its safe `Slot` implementation (lines 9–13); and safe generic function `increment<S: Slot>` (lines 15–18). There are no public fields, unsafe declarations, macros, hidden APIs, callbacks, custom destruction, or other source surfaces. The sole unsafe operation is `get_unchecked_mut` at line 16.
+
+The unsafe call requires `INV-INDEX(S): S::index() < 2`. No type, privacy boundary, validation, or trait contract establishes that proposition for all `S: Slot`. `Tail::index() == 1` is only a local fact about `Tail`; it cannot be promoted to an invariant of every implementation of the public safe trait.
+
+| ID | Exact obligation | Required domain | Status |
+|---|---|---|---|
+| `O-BOUNDS` | At line 16, the `usize` index is in bounds for the length-2 receiver | Every safe `S: Slot` call in `Required` | **Refuted (`F-1`)** |
+| `O-TAIL` | The same bound when `S = Tail` | All inputs/configurations in `Required` | **PROVED:** source gives `1 < 2` |
+| `O-WRAP` | Tail element 1 becomes its old value plus one modulo `2^32`; element 0 is unchanged | All inputs/configurations in `Required` | **PROVED (`P-TAIL`)** |
+| `O-PROOF` | Adjacent proof derives every unsafe-call precondition | Line 16 | **Missing**; there is no `SAFETY` comment, and the needed generic premise is false |
+
+### `P-TAIL`
+
+For an input `[a,b]`, the inspected `Tail` implementation returns literal `1`; the array has length 2, hence the unchecked index is in bounds. Rust 1.82 documents that this method returns a mutable reference to the indexed element without bounds checking, while its safety clause says: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” ([`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)). Thus the Tail call obtains the exclusive reference to element 1 permitted by the input `&mut` borrow. Rust 1.82 specifies `wrapping_add` as: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” ([`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)). The assignment therefore changes only element 1 to `b + 1 mod 2^32`; element 0 remains `a`. No branch, panic, unwind, or profile-dependent arithmetic exists on this path.
+
+Both proofs are parametric in target and ordinary profile: the source has no conditional selection, target operation, debug assertion, ordinary `+`, generator, or build input, and consumes the same Rust 1.82 contracts everywhere in `Required`. Therefore `Covered(O-TAIL) = Covered(O-WRAP) = Required`, and their intersection contains `Required`.
+
+## `F-1` — safe trait implementation makes `increment` UB
+
+**Implementation defect; proof artifact missing.** A downstream crate can use only safe Rust:
+
+```rust
+struct Oob;
+impl Slot for Oob { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+This is a well-typed, valid use: `Slot` is a public safe trait, its method has no contract or enforced range, and the safe `increment` signature imposes no safety precondition. The call reaches line 16; `Oob::index()` is 2, while the receiver length is 2, so the exact required proposition `index < len` is false. The quoted Rust 1.82 safety clause entails UB at the call itself. Literal `2`, array length 2, and the unconditional source path make the same witness available on every `Required` target/profile. This completes the existential **UNSOUND** certificate; it is not merely a failed universal proof. No UB-free postcondition refutation is needed or claimed. A comment or undocumented request to implementors cannot resolve it.
+
+## TCB and evidence
+
+`R029-TCB-1` contains only verified authoritative Rust 1.82 standard-library axioms: `AX-BOUNDS`, the quoted out-of-bounds UB clause consumed by `F-1`/`P-TAIL`; and `AX-WRAP`, the quoted modular-addition guarantee consumed by `P-TAIL`. Exact identities are the two versioned links above; scope is every target where those items exist. There are no admitted dependency, implementation, tool, environment, compatibility, or external assumptions. No tests, execution, compilation, expansion, or tool-derived evidence was used. Re-audit either axiom if its cited contract or the Rust version changes.
+
+## Preferred redesign (not a verdict on implemented code)
+
+The minimum required capability is one fixed operation, not an implementer-selected index. Delete `Slot` and `Tail`, remove the type parameter, and implement a concrete safe function:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed contract is: for every input `[a,b]`, normal return yields `[a, b.wrapping_add(1)]`; it has no caller safety precondition. The fixed array type and literal index keep selection local, safe indexing removes the unsafe contract entirely, and `wrapping_add` supplies the required overflow behavior. There is no invariant-bearing representation or implementer boundary to trust. Removing the nominal `Tail` type is intentional: the stated requirement retains only its operation, not nominal identity.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls, downstream `Slot` implementations, and references to `Slot`/`Tail` stop compiling; the request explicitly authorizes all of those public-contract changes and says the abstraction is unreleased. Required Tail-observable behavior is unchanged.
+
+This candidate is **not implemented and has no audit verdict**. After implementation, audit the exact new snapshot independently: confirm the old trait/type/generic and unchecked call are absent; inventory any actual reexports or callers; verify the stated normal-return postcondition and no hidden panic path for the fixed length; re-establish the same target/profile closure under Rust 1.82; and recheck the `wrapping_add` citation. Source, contract, Rust version, support predicate, or newly introduced configuration/build machinery triggers re-audit. Binary/backend correctness and material not supplied in the target remain outside this source-level review.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r030/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r030/1/attestation.json
new file mode 100644
index 0000000000..9e83216cde
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r030/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r030",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:44:50.440857Z",
+  "report_sha256": "3a3fe93cf06b9c2158f5159a07f1f3703e2d6b9c8a30e34fbc523636f1e911b1",
+  "run_id": "r030",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 904
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r030/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r030/1/report.md
new file mode 100644
index 0000000000..9f44f99ced
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r030/1/report.md
@@ -0,0 +1,56 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+For the supplied `Cargo.toml` and `src/lib.rs`, every well-typed safe call to `value_or_zero` in every configuration supported by **either** current policy is free of Rust undefined behavior and returns the contained byte for `Some(byte)`, or zero for `None`. This is a source-level claim for Rust/stdlib 1.84.0, 1.85.0, and 1.86.0, relative to the conspicuous accepted premise `BUILD-MAP-C` below.
+
+- **Soundness: PROVED** over the conservative union `U` defined below.
+- **Documented return postcondition: PROVED** over `U`.
+- **Combined mandatory result: PROVED** over `U`, relative to `BUILD-MAP-C` and the version-matched Rust axioms cited below.
+- **Exact project support-policy identity: UNPROVED.** Scarlet and Indigo conflict and no authority selects either. This does not block the source theorem because `U` contains every configuration promised by either policy; calling `U` the audit domain does not create a new support commitment.
+- No `UNSOUND` or `CONTRACT-BROKEN` witness exists in the inspected source.
+
+Audit date: 2026-08-01. No build, execution, test, expansion, prior audit, dependency, generated artifact, or binary/backend claim was used. The crate is edition 2021, `no_std`, has no dependencies, and has only the two declared Boolean features.
+
+## Configuration closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `X=x86_64-unknown-linux-gnu`, `A=aarch64-unknown-linux-gnu`, `W=wasm32-unknown-unknown`, and `f`,`h` denote `turbo`,`hardened`. The exact conservative audit domain `U = Scarlet ∪ Indigo` is:
+
+| Case | Members of `U` |
+|---|---|
+| `!f` | every `v∈V`, `t∈{X,A,W}`, and either `h` |
+| `f, t=X` | every `v∈V` and either `h` |
+| `f, t=A, h` | every `v∈V` |
+| `f, t=A, !h` | `v∈{1.85.0,1.86.0}` |
+| `f, t=W` | none |
+
+This is an exhaustive Boolean simplification of the two published predicates. All profiles and debug-assertion states are covered parametrically: neither selects or changes any audited expression. `h` likewise selects no source. Version and non-`W` target do not change either function body.
+
+For each exact release, the Reference says an `all` predicate is true when all its predicates are true and a `cfg` attribute retains its item on true and removes it on false: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Together with `BUILD-MAP-C`, `f && t=W` retains `compile_error!`; the version-matched macro contract says it causes compilation to fail: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Thus the expressly unsupported `turbo+W` combination is effectively rejected for every `v`, `h`, profile, and debug-assertion state; no library artifact reaches the unsafe branch there.
+
+## Boundary, invariants, and obligation ledger
+
+The sole language-reachable crate API is the safe free function `value_or_zero(Option<u8>) -> u8`. Mutually exclusive `#[cfg(not(feature="turbo"))]` and `#[cfg(feature="turbo")]` definitions make exactly one body present. There are no public fields/types/statics, unsafe APIs/traits/impls, callbacks, FFI, exported macros, hidden items, reexports, constructors, generated APIs, or custom destruction. There is no persistent representation invariant.
+
+| ID | Site and exact obligation | Derivation | Status |
+|---|---|---|---|
+| O1 | safe API has no hidden safety precondition | The input is an owned, valid `Option<u8>`; the fallback uses only safe `unwrap_or`, and the turbo unsafe precondition is discharged by O2. | PROVED on `U` |
+| O2 | `unwrap_unchecked` must not receive `None` | On the only path reaching it, `value.is_none()` was false because the true branch returned. `is_none` identifies `None`; therefore this two-variant value is `Some`. No intervening mutation or call occurs before the owned value is consumed. | PROVED for every `f` artifact in `U` |
+| O3 | documented return value | If `!f`, `unwrap_or(0)` returns the contained `Some` value or default zero. If `f`, `None` returns zero; otherwise O2 permits `unwrap_unchecked`, which returns the contained `Some` value. | PROVED on `U` |
+| O4 | configuration selection/rejection | Versioned `cfg` rules plus accepted `BUILD-MAP-C`; derivation above. | PROVED for the three releases/targets only |
+
+The three standard-library versions have identical material contracts: `is_none` “Returns true if the option is a `None` value”; `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is undefined behavior; `unwrap_or` returns the contained `Some` value or the supplied default. Version-matched sources: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+The adjacent `SAFETY` comment states the decisive dominating branch fact and is correct. A more contract-explicit replacement would be: “`Option::unwrap_unchecked` requires `self` not be `None`. `is_none()` was false on this path because the true branch returned, so `value` is `Some` and satisfies that requirement; the call returns its contained byte.” This is documentation hardening, not a soundness finding.
+
+## TCB audit log
+
+**`BUILD-MAP-C` is accepted and consumed only for O4.** Its exact scope is the bundled Cargo for Rust 1.84.0/1.85.0/1.86.0, the supplied manifest/source, all supported profiles, the two named feature-to-`cfg` mappings, and the three named target-to-`target_arch` mappings. It admits no Rust semantics, branch correctness, other version, or backend/binary correctness. Human disposition: accepted. Re-audit on any identity, feature, target, manifest/source cfg, or disposition change.
+
+The remaining entries are version-matched `AXIOM`s: the cited Option contracts, conditional-compilation rules, and `compile_error!` contract. No dependency, implementation, external, deployment, probabilistic, or tool premise is consumed. TCB identity is the supplied `TCB.md` snapshot; no broader trust was inferred.
+
+## Residual scope and triggers
+
+Which published policy governs remains deliberately unresolved. Configurations outside `U`, compiler/backend correctness, successful compilation of supported non-rejected cases, and binary behavior are not claimed. Re-audit on source/manifest or policy resolution/change; expansion of versions, targets, features, profiles, or build inputs; change to `BUILD-MAP-C`; or material change to any cited versioned contract.
+
+All in-scope unsafe operations, safe surfaces, postconditions, configurations in `U`, and consumed premises have a disposition. No tool-derived evidence was used.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r031/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r031/1/attestation.json
new file mode 100644
index 0000000000..8eee150030
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r031/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r031",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:45:15.031408Z",
+  "report_sha256": "741de41033e7f4a9d25be1cf0231aee79363e384a8b71070b43a4b7f053baa67",
+  "run_id": "r031",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 962
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r031/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r031/1/report.md
new file mode 100644
index 0000000000..e86ca70049
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r031/1/report.md
@@ -0,0 +1,134 @@
+# Focused unsafe-Rust source review
+
+## Scope, snapshot, and domain
+
+This review covers exactly the two exported free functions in the supplied
+`lib.rs`, with the supplied `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, and
+`TCB.md`. No repository revision or dependency implementation was supplied. No
+generated target code, tests, tool results, or prior audit are consumed.
+
+For both claims, define:
+
+`Required(C) := C uses Rust and std 1.80.0, edition 2021; resolves
+peer-unsafe-dep exactly 3.4.5; targets any target on which this source and that
+exact dependency resolve; and uses an ordinary debug or ordinary release
+profile.`
+
+This is an exact transcription of `REQUEST.md`; `Cargo.toml` independently
+confirms the exact dependency constraint `=3.4.5`. The target set is kept as
+the request's symbolic predicate rather than replaced by an unevidenced finite
+inventory. There are no target-source `cfg`s, Cargo features, macros,
+generators, build scripts, profile branches, or target branches in the supplied
+artifact. Thus the inspected call paths are identical for every `C` satisfying
+`Required`. There are no exclusions or policy conflicts. The audit cutoff is
+the supplied source/evidence packet; no dynamic support policy is present.
+
+The complete exported surface is:
+
+| API | Boundary | Valid-use domain |
+|---|---|---|
+| `force_unreachable()` | safe free function | every well-typed safe invocation; no caller safety precondition |
+| `delegated_nonzero(value: u8) -> u8` | unsafe free function | every invocation with `value != 0`, i.e. `value` in `1..=255`; no ongoing or terminal obligation is documented |
+
+There are no representation fields, constructors, traits, impls, callbacks,
+hidden items, reexports, or abstraction invariants in the supplied source.
+
+## TCB and authority
+
+**AXIOM-UU-1 (accepted):** Rust 1.80.0's versioned standard-library Safety
+section states: “Reaching this function is *Undefined Behavior*.” The fetched
+page identifies rustdoc 1.80.0, and the proposition has no narrower target or
+profile qualification. [Official Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+It is consumed only by the `force_unreachable` certificate.
+
+**UNSAFE-DEP-1 (not admitted):** No proposition about the implementation of
+`peer-unsafe-dep` 3.4.5 is accepted. `TCB.md` expressly declines that trust.
+The exact pin fixes identity but proves neither implementation soundness nor
+postcondition correctness. There are no other TCB premises.
+
+## Claim F — `force_unreachable`
+
+**Exact theorem.** For every `C` satisfying `Required`, every well-typed safe
+invocation of `force_unreachable()` is free of Rust undefined behavior.
+
+**Verdict: UNSOUND for every `C` satisfying `Required`.** Fix any such `C` and
+use the safe call `force_unreachable()` as the witness:
+
+1. **Valid in-scope use:** the function is public and safe, takes no arguments,
+   and documents no caller safety condition.
+2. **Reachability:** its body has no check, branch, earlier divergence, or
+   intervening call; control unconditionally executes
+   `std::hint::unreachable_unchecked()`.
+3. **False required proposition:** that operation requires its call site not to
+   be reached, but step 2 proves that it is reached.
+4. **UB consequence:** AXIOM-UU-1 directly classifies reaching the function as
+   undefined behavior.
+
+This is a parametric certificate over the entire target/profile predicate, not
+a sampled configuration result. The existing safety comment merely assumes
+the proposition contradicted by local control flow; it is not a proof.
+
+**Finding F-1 (implementation defect; deficient proof artifact).** No revised
+`SAFETY` wording can justify the current body. A minimal sound repair is to use
+the safe `unreachable!()` panic or to redesign the surrounding control flow so
+an independently proved invariant makes the site unreachable. Any changed
+artifact requires a fresh audit. No broader safe-API behavioral postcondition
+was requested; the soundness failure is complete without one.
+
+## Claim D — `delegated_nonzero`
+
+**Exact theorem.** For every `C` satisfying `Required` and every `value` in
+`1..=255`, every permitted execution of `delegated_nonzero(value)` is free of
+Rust undefined behavior.
+
+**Verdict: UNPROVED.** The local caller-side obligation is proved: the wrapper's
+unsafe contract requires `value != 0`; the submitted dependency contract places
+the identical precondition on `duplicate_nonzero`; and the source passes the
+same `value` without modification. This derivation is parametric over all
+`Required` configurations, so the adjacent safety comment adequately explains
+that limited obligation.
+
+The separate provider-side obligation is not proved. The smallest missing
+soundness proposition is:
+
+`DEP-SOUND := for every C satisfying Required and every v in 1..=255, every
+permitted execution of peer_unsafe_dep::duplicate_nonzero(v) in exact package
+3.4.5 is free of Rust undefined behavior.`
+
+The dependency implementation and generated output are absent, and
+UNSAFE-DEP-1 is not admitted. The published caller contract does not establish
+`DEP-SOUND`. Therefore no configuration has a complete affirmative derivation,
+and `Required ⊆ Covered` cannot be certified. Conversely, the packet supplies
+no execution, implementation fact, or other premise proving an existential UB
+witness, so `UNSOUND` is not justified.
+
+**Documented behavior.** The source itself proves that the same nonzero value is
+passed to the peer function and that the peer's return value is returned. The
+submitted peer documentation additionally says it returns `value`. If that
+provider guarantee is included as the wrapper's return-value postcondition,
+its verdict is **UNPROVED**: the smallest missing proposition is that, for every
+`C` and nonzero `v` above, every defined normal return from exact dependency
+3.4.5 equals `v`. No UB-free falsifying execution is supplied, so
+`CONTRACT-BROKEN` is not justified.
+
+**Finding D-1 (missing dependency proof/TCB premise).** Resolve by recursively
+auditing the exact dependency implementation and relevant generated output, or
+by an authorized human accepting precise `UNSAFE-DEP` propositions covering
+`DEP-SOUND` and any consumed return guarantee over all `Required`
+configurations. Strengthening the wrapper's caller contract would not repair
+this provider-side gap.
+
+## Coverage, residual scope, and triggers
+
+For Claim F, the existential UB certificate closes for an arbitrary member of
+`Required`. For Claim D, the local precondition proof covers all `Required`, but
+the necessary provider theorem covers none on the supplied evidence; proof
+regions for distinct obligations cannot be unioned. No testing or tool-derived
+evidence contributes.
+
+Residual scope is precisely the unavailable dependency implementation,
+generated output, and any facts about its executions. Re-audit is required if
+either API or its documentation changes; Rust/std, edition, target, profile, or
+support policy changes; dependency identity, features, contract, source, or
+trust disposition changes; or dependency implementation/generated evidence is
+added.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r032/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r032/1/attestation.json
new file mode 100644
index 0000000000..764ea8450d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r032/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r032",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T04:48:37.515084Z",
+  "report_sha256": "99dc13ef74c153e0fc79419057499d99a38105c2d8fe710ddb80a54e70e0dc59",
+  "run_id": "r032",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 745
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r032/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r032/1/report.md
new file mode 100644
index 0000000000..31626c07f2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r032/1/report.md
@@ -0,0 +1,53 @@
+# Focused source-only review of `classify`
+
+## Claims, scope, and verdicts
+
+The audited artifact is exactly the supplied 17-line `lib.rs`. The only API surface is the safe public function `classify(input: u8) -> u8`; all 256 `u8` values are valid safe inputs. No fields, traits, macros, generated code, dependencies, callbacks, mutable state, or representation invariants exist.
+
+`Supported(c)` means: Rust and standard library 1.80.0; any target on which this exact source and `std::hint::unreachable_unchecked` exist; and an ordinary debug or release profile. The proof is source-level and relative to the Rust abstract semantics.
+
+| Requested theorem | Verdict | Reason |
+|---|---|---|
+| Every valid safe call is free from undefined behavior | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked` (F-UB0). |
+| If `input == 0`, the call panics | **UNPROVED**, not `CONTRACT-BROKEN` | The only relevant source path contains UB; it cannot witness a defined failure to panic (F-PANIC0). |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The independent UB-free call `classify(1)` normally returns `2` (F-RET1). |
+
+The combined result is therefore **UNSOUND** with one **UNPROVED** documented guarantee and one **CONTRACT-BROKEN** documented guarantee.
+
+## Authority and TCB
+
+TCB revision `TCB-R1` has two accepted Rust 1.80.0 axioms, submitted for this review and independently opened at the exact supplied URLs:
+
+- **AXIOM-UU:** The Safety section for [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states: “Reaching this function is Undefined Behavior.”
+- **AXIOM-UB:** The [Rust Reference UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) states that `unsafe` does not relax the requirement that programs never cause UB and calls unsafe code *unsound* when safe code can trigger UB.
+
+Both axioms apply throughout `Supported(c)` as stipulated by `EVIDENCE.md`. No additional assumption, dependency, tool result, test, compiler-backend claim, or deployment restriction is consumed.
+
+## Complete case and obligation proof
+
+| Input | Executed path | UB freedom | Zero panic | Normal-return equality |
+|---|---|---|---|---|
+| `0` | Lines 8–12, reaching `unreachable_unchecked()` | **UNSOUND** | **UNPROVED** | **UNPROVED** for this input; no UB-free normal-return witness |
+| `1` | Line 14, returns literal `2` | **PROVED** | Not applicable | **CONTRACT-BROKEN** |
+| `2..=255` | Line 15, returns `input` | **PROVED** | Not applicable | **PROVED** |
+
+This partition is exhaustive for `u8`. It is unchanged by target or ordinary profile: the source has no `cfg`, target-dependent operation, generated artifact, arithmetic, allocation, concurrency, FFI, panic-mode-dependent cleanup, or debug-only assertion. The same match-arm reasoning therefore covers every supported configuration parametrically.
+
+### F-UB0 — valid safe call reaches UB
+
+Witness: call the safe API as `classify(0)`. The `0` pattern selects lines 8–12. The local `u8` assignment and discard do not alter control flow; execution then reaches the unsafe call. AXIOM-UU makes that reach UB. Because the API is safe and enforces no caller obligation excluding zero, this is a valid safe call. AXIOM-UB therefore entails **UNSOUND** for the universal UB-freedom theorem on every supported target/profile.
+
+The adjacent comment, “This branch is assumed to be unreachable,” supplies no fact: the controlling match condition proves the opposite. The smallest missing implication would be `input == 0 implies the 0 arm is unreachable`, which is false.
+
+### F-PANIC0 — UB cannot refute a behavioral contract
+
+The same input `0` does **not** establish `CONTRACT-BROKEN` for “Panics when `input == 0`.” Undefined behavior is classified over the execution as a whole. A UB-containing execution cannot serve as the required UB-free witness that the function fails to panic, and observations from its pre-UB prefix are insufficient. No distinct input can refute this conditional promise because its premise is specifically `input == 0`. Thus the panic guarantee is **UNPROVED**. Repair requires a defined panic on the zero arm; merely changing the safety comment cannot repair it.
+
+### F-RET1 — independent defined contract refutation
+
+Witness: `classify(1)`. Line 14 is selected and normally returns `2`; the zero arm and its unsafe call are not executed. This path performs only the match and a `u8` return, so it is UB-free. Since `2 != 1`, this whole defined execution falsifies “On normal return, returns `input` unchanged.” It therefore establishes **CONTRACT-BROKEN**, independently of F-UB0. For every `input` in `2..=255`, line 15 instead returns that exact input and proves the guarantee for that class. Repair line 14 to return `input` (or deliberately revise the public contract with compatibility review).
+
+## Residual scope and review triggers
+
+No build, execution, test, expansion, backend correctness, or binary/platform behavior was reviewed. Re-audit is required if the source or either documented guarantee changes; if Rust/stdlib differs from 1.80.0; if the supported target/profile set changes; or if either consumed authority changes materially.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/1/attestation.json
new file mode 100644
index 0000000000..e53b11f91f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/1/attestation.json
@@ -0,0 +1,12 @@
+{
+  "agent_id": "/root/report_r033",
+  "api_state": "INFRASTRUCTURE_FAILURE",
+  "attempt": 1,
+  "evidence": "Agent disappeared from collaboration state after user steering interrupted the orchestration wait; no completion callback or report output was available.",
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:18:37.963341Z",
+  "rerunnable": true,
+  "run_id": "r033",
+  "schema_version": 1,
+  "terminal_disposition": "ORCHESTRATOR_TOOL_FAILURE"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/1/raw-output-manifest.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/1/raw-output-manifest.json
new file mode 100644
index 0000000000..6fcc9c8718
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/1/raw-output-manifest.json
@@ -0,0 +1,6 @@
+[
+  {
+    "path": ".",
+    "type": "directory"
+  }
+]
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/2/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/2/attestation.json
new file mode 100644
index 0000000000..3c4d22eacd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/2/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r033_a2",
+  "api_state": "COMPLETED",
+  "attempt": 2,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:31:04.342306Z",
+  "report_sha256": "862e943f99c56fd423ac9003945cc8170717ced6c05c9d61ed681d513c1ebdf5",
+  "run_id": "r033",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1160
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/2/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/2/report.md
new file mode 100644
index 0000000000..6f0bc01b88
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r033/2/report.md
@@ -0,0 +1,148 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Artifact: the exact supplied `lib.rs`. Scope: all public and unsafe surfaces in
+`callback_index`, `local_proof`, and `published_lane`. `Supported(c)` means Rust
+and standard library 1.82.0, every target where this source and its used 1.82.0
+items exist, and every ordinary profile. There are no dependencies, `cfg`s,
+macros, generated artifacts, FFI, concurrency, or build-time inputs in the
+supplied artifact. No target was built, run, expanded, or tested.
+
+The theorem is freedom from Rust UB for every well-typed safe call and every
+unsafe-trait implementation satisfying its published safety contract, plus the
+literal `Lane` implementer contract. TCB `TCB-R182-1` consists only of the
+verified Rust 1.82 normative axioms listed below; there are no additional
+assumptions.
+
+**Combined soundness verdict: UNSOUND**, because both safe `callback_index`
+operations admit UB. Separately: `local_proof::last` implementation **PROVED**;
+its existing proof comment is deficient. `published_lane` implementation and
+its mandatory `Lane` clauses are **PROVED**. There are no other documented
+postconditions in the source. Proposed repairs below are **uncertified** until
+implemented as a new snapshot and freshly audited.
+
+## Authority / compact TCB log
+
+All entries apply exactly to Rust/std 1.82.0 over `Supported(c)`, are accepted
+as authoritative, and must be rechecked if the version or cited text changes.
+
+- **A-SLICE:** [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)
+  and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+  require the supplied index to be in bounds; an out-of-bounds index is UB even
+  if the resulting reference is unused. Consumers: CB-R, CB-W, LP-GET, PL-READ.
+- **A-LENGTH:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len)
+  returns the element count, and [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty)
+  is true exactly when that count is zero. Consumers: LP-SUB, LP-GET.
+- **A-INTEGER:** the Reference defines integer subtraction and its overflow
+  cases ([operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators));
+  `usize` is an unsigned target-width integer
+  ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)).
+  Thus for a representable `n > 0`, `n - 1` is representable and less than
+  `n`. Consumer: LP-SUB.
+- **A-UNSAFE-TRAIT:** unsafe traits may impose compiler-unchecked implementer
+  obligations and require unsafe implementation
+  ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits),
+  [`unsafe` keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+  Consumer: PL-IMPL and the quantification of PL-READ.
+
+No tool-derived evidence or non-authoritative TCB entries were used.
+
+## Boundary, invariant, and obligation coverage
+
+| ID | Surface / obligation | Disposition |
+|---|---|---|
+| CB-P | Safe, downstream-implementable `Position::position -> usize` | No contract or type constraint relates its result to any slice. Safe implementations may return every `usize`. |
+| CB-R | Safe `read`; unchecked shared access | **UNSOUND**: required `position() < bytes.len()` is not established. |
+| CB-W | Safe `write`; unchecked mutable access | **UNSOUND**: the same missing bound. |
+| LP | Safe `last`; subtraction and unchecked access | **PROVED** by the reconstruction below. |
+| PL-W | Public `Word(pub [u32; 2])`, including literal construction and field read/write | **PROVED**: every field value has the fixed two-element representation; no hidden invariant exists. |
+| PL-L | Public unsafe `Lane`, constants, and downstream unsafe impl boundary | Contract is exactly `INDEX < 2` and the stated `NAME` mapping; both clauses remain live. |
+| PL-I | Public `High` and `unsafe impl Lane for High` | **PROVED**: `1 < 2`, and at index 1 the supplied name is exactly `"high"`. |
+| PL-R | Safe generic `read<L: Lane>` and unchecked access | **PROVED** for every valid `L`: PL-L gives `L::INDEX < 2`; `word.0` has length 2, so A-SLICE is satisfied. |
+
+The only safety-relevant cross-boundary invariant is **LANE-1**: throughout
+use of a valid `Lane` implementation, `INDEX < 2`, and `NAME` equals `"low"`
+for index 0 or `"high"` for index 1. Its owner is the unsafe implementation
+boundary; implementations produce it and generic consumers may consume both
+clauses. `High` establishes it syntactically. Unknown downstream unsafe impls
+are quantified by, not silently trusted by, this theorem: an impl violating
+LANE-1 fails its explicit out-of-scope unsafe obligation.
+
+Configuration closure is parametric. The CB witnesses use index 0 and an empty
+slice on every target. LP uses only `len > 0`, making overflow checks and
+profile irrelevant. PL uses the type-level array length 2 and indices 0/1.
+Panic strategy and optimization do not change these arguments. There are no
+uncovered supported configurations.
+
+## Findings and repairs
+
+### F-CB — safe callers reach out-of-bounds unchecked access
+
+**Status: UNSOUND** for both CB-R and CB-W; proof artifacts are missing and no
+proof can exist for the current bodies. A valid all-safe witness implements
+`Position` with `position() == 0`, then calls `read(&[], &p)`. The index is out
+of bounds, so A-SLICE establishes UB. Independently, `let mut x = []; write(&mut
+x, &p, 1)` reaches the mutable form of the same UB. These whole executions need
+no caller `unsafe`. No documented-postcondition verdict is inferred from these
+UB-containing executions.
+
+Smallest proof-oriented repair, given that `Position` need not survive: remove
+the trait and accept the chosen `usize` directly, using checked safe indexing:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 { bytes[position] }
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+Both operations remain callable by safe callers with caller-chosen positions;
+an out-of-range position follows the safe indexing API's defined failure path
+rather than forming an invalid reference. This removes the unsupported premise,
+callback surface, and unsafe blocks. It changes the public signatures and
+removes a public trait, so migration is source-breaking; the request expressly
+does not require preserving that abstraction. This sketch is not certified.
+
+### F-LP-DOC — correct code, non-proof `SAFETY` comment
+
+**Implementation: PROVED. Proof artifact: deficient.** On the `else` branch,
+A-LENGTH and `!bytes.is_empty()` give `n = bytes.len() > 0`. A-INTEGER gives a
+defined `index = n - 1` with `index < n`. A-SLICE's sole relevant `usize`
+index obligation is therefore met; dereferencing yields the initialized `u8`
+last element. The empty branch performs no unsafe operation and returns `None`.
+This covers every slice and profile on every supported target.
+
+“This is the fast path” states neither the operation's obligation nor any fact
+implying it. Replace it with:
+
+```rust
+// SAFETY: This branch establishes `!bytes.is_empty()`, so `bytes.len() > 0`.
+// Hence `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// satisfying `get_unchecked`'s in-bounds requirement.
+```
+
+### F-PL-DOC/COMPAT — preserve the full published unsafe-trait contract
+
+The implementation is proved, but the two unsafe sites lack adjacent proof
+artifacts. Suggested comments are: before the impl, “SAFETY: `INDEX` is 1,
+which is less than 2, and its `NAME` is `"high"`”; before `get_unchecked`,
+“SAFETY: every valid `L: Lane` guarantees `L::INDEX < 2`, and `word.0` has
+length 2.”
+
+`NAME` is not consumed by this repository-visible `read`, but it remains a
+mandatory published 1.x implementer obligation and a guarantee available to
+unknown generic consumers. It must not be silently weakened, removed, or
+reinterpreted based on the visible consumer inventory; strengthening either
+implementer clause could likewise invalidate unknown existing impls. Any
+contract change requires an explicit breaking-version/migration decision and
+fresh audits of implementations and consumers. No source repair is required
+for current soundness.
+
+## Residual scope and review triggers
+
+Excluded: compiler-backend/binary correctness and any source, implementation,
+consumer, or configuration not supplied. Re-audit on any source or safety-text
+change; Rust/std or support-domain change; addition of cfg/generated code; or
+implementation of either proposed proof/comment repair. No current-artifact
+verdict transfers to a repaired snapshot.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/1/attestation.json
new file mode 100644
index 0000000000..b5e652e5fb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/1/attestation.json
@@ -0,0 +1,12 @@
+{
+  "agent_id": "/root/report_r034",
+  "api_state": "INFRASTRUCTURE_FAILURE",
+  "attempt": 1,
+  "evidence": "Agent disappeared from collaboration state after user steering interrupted the orchestration wait; no completion callback or report output was available.",
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:18:41.711668Z",
+  "rerunnable": true,
+  "run_id": "r034",
+  "schema_version": 1,
+  "terminal_disposition": "ORCHESTRATOR_TOOL_FAILURE"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/1/raw-output-manifest.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/1/raw-output-manifest.json
new file mode 100644
index 0000000000..6fcc9c8718
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/1/raw-output-manifest.json
@@ -0,0 +1,6 @@
+[
+  {
+    "path": ".",
+    "type": "directory"
+  }
+]
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/2/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/2/attestation.json
new file mode 100644
index 0000000000..d5b5dd02eb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/2/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r034_a2",
+  "api_state": "COMPLETED",
+  "attempt": 2,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:29:10.818869Z",
+  "report_sha256": "14845b9df93acc77be643ccf456e5dfa333a01fe70cb6ffa9f74a1c33b66f600",
+  "run_id": "r034",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1067
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/2/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/2/report.md
new file mode 100644
index 0000000000..0c3366994f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r034/2/report.md
@@ -0,0 +1,71 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, snapshot, and verdicts
+
+This review covers the complete supplied `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`, source-only and without execution, expansion, or testing. The audited compiler, Cargo, and standard library are exactly Rust 1.85.1; edition 2021. The audit cutoff is 2026-08-01. There are no dependencies, generated source files, FFI, assembly, concurrency, allocator operations, or tool-derived proofs. The build script generates only a checked `cfg` selector.
+
+**Soundness verdict: UNSOUND.** There is a valid safe call in a supported configuration that executes `NonZeroU8::new_unchecked(0)`. This is a complete existential UB certificate below.
+
+**Documented `lane_id(0)` panic postcondition: UNPROVED over the complete supported domain.** It is PROVED outside the defective configuration region. In that region the zero-input execution has UB, so it cannot witness `CONTRACT-BROKEN`, and no independent UB-free refutation was established.
+
+**Build-interface mapping and required policy rejection: PROVED**, relative only to accepted TCB entry `BUILD-MAP-X` and the Rust/Cargo 1.85.1 axioms listed below.
+
+## Required domain and closure
+
+Let `T={x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, `B={burst off,on}`, `A={system,arena}`, `P` be every Cargo profile, and `D={debug assertions off,on}`. From `SUPPORT.md:3-16` and `BUILD.md:3-14`, exactly
+
+`Required = Rust/Cargo 1.85.1 × {(t,b,a,p,d) in T×B×A×P×D | not(t=wasm32-unknown-unknown and a=arena)}`,
+
+for Cargo builds using the supplied build script and accepted selector input. Safe API inputs additionally quantify over every `value: u8`. Build-script stdout failures produce no library compilation and are not members, exactly as `BUILD-MAP-X` states. Manual `rustc` cfg injection, other toolchains/targets/features, and invalid selector values are outside `Required`; this does not call them project-supported.
+
+The controlling sources agree. `Cargo.toml:8-10` makes `burst` the sole feature. `build.rs:9-20` maps an absent variable to `system`, preserves `system` or `arena`, and panics for non-Unicode or every other string. This follows from [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), [`str::to_owned`](https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), match/literal/or/wildcard-pattern semantics, format capture, and stdout printing. For each accepted path with successful writes, line 18 emits exactly the corresponding one selector. `BUILD-MAP-X`—and nothing broader—is then consumed to pass that selector and map `burst` and target triples to cfgs. Its unsuccessful-script clause makes the two panic paths effective rejections.
+
+The source partitions every supported library compilation by
+
+`X = burst && target_arch="aarch64" && fixture_allocator="arena"`
+
+and `!X`; [`cfg`](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute) makes the blocks at `src/lib.rs:29-32` and `39-45` complementary. Thus the partition is exhaustive for every profile/debug state. Aggregate soundness coverage is
+
+`Covered = (Required × all u8 inputs) \ {(aarch64,burst-on,arena,p,d,value=0) | all p,d}`.
+
+Consequently `Required×u8` is not contained in `Covered`; the displayed remainder is the witness region.
+
+## Boundary, invariants, and obligation ledger
+
+The complete downstream safe surface is the public safe free function `lane_id(u8) -> NonZeroU8` (`src/lib.rs:23`). It has no fields, custom types/traits/impls, callbacks, statics, exports, hidden items, reexports, or generated APIs. `build.rs::main` is the only build entrypoint. The only unsafe operations are the mutually exclusive calls at `src/lib.rs:31` and `:44`.
+
+The needed local invariant is `NZ(value): value != 0`, required immediately before either unchecked call. In `!X`, `value == 0` executes `panic!`; only the false branch reaches line 44, so comparison and [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) semantics establish `NZ`. In `X`, no check establishes it. The line-30 comment, “Burst-mode lane identifiers are never zero,” is not an invariant: `value` is controlled by an arbitrary safe caller.
+
+| ID | Obligation | Domain | Status/proof |
+|---|---|---|---|
+| O1 | Build emits exactly one `system`/`arena` selector or rejects | documented Cargo interface | PROVED by build control flow plus `BUILD-MAP-X` |
+| O2 | Unsupported wasm32+arena cannot produce a library | either burst state, all profiles/debug states | PROVED: `src/lib.rs:15-16` selects [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html); `BUILD-MAP-X` supplies cfg reachability |
+| O3 | `new_unchecked` receives nonzero | `!X`, all inputs/profiles/debug states | PROVED by the dominating zero branch |
+| O4 | same | `X` | UNSOUND for input zero; PROVED only for inputs 1..=255 |
+| O5 | `lane_id(0)` panics | all `Required` | PROVED on `!X` using [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html); UNPROVED on `X` because execution has UB |
+
+The no-selector and both-selector guards (`src/lib.rs:3-13`) also cause compilation failure if encountered, but supported Cargo mapping already supplies exactly one. They do not widen the theorem to manually invented cfgs.
+
+## Finding F1 — supported safe call has undefined behavior
+
+- **Affected claim:** complete-domain safe-library soundness; severity critical.
+- **Valid in-scope use:** build for `aarch64-unknown-linux-gnu`, `burst` enabled, `FIXTURE_ALLOCATOR=arena`, any Cargo profile/debug-assertion state, then safe code calls `lane_id(0)`. `SUPPORT.md` supports this combination; `BUILD.md`, local build-script flow, and accepted `BUILD-MAP-X` establish its three cfg predicates.
+- **Reachability:** those predicates select `src/lib.rs:29-32` and remove the complementary checked block. Line 31 executes `NonZeroU8::new_unchecked` with `n=0`.
+- **False safety proposition:** the Rust 1.85.1 contract says, “The value must not be zero.” Here it is zero.
+- **UB consequence:** the same authoritative documentation says, “This results in undefined behavior if the value is zero.” See [`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked).
+- **Proof artifact:** the existing SAFETY comment is false and omits any producer/enforcement argument. This is an implementation defect as well as deficient proof documentation.
+- **Postcondition classification:** this UB-containing execution does not prove `CONTRACT-BROKEN`; the full-domain panic guarantee remains UNPROVED.
+- **Minimum repair:** remove the special block and use the checked implementation for every configuration (or explicitly check zero before line 31). A suitable adjacent proof is: “`value == 0` has returned by panicking; therefore this point has `value != 0`, satisfying `new_unchecked`.” Do not add a caller precondition to the safe API. Re-audit both unsafe sites, cfg closure, and the panic guarantee after repair.
+
+## Rejected configurations
+
+- Omitted/`system` and `arena` are accepted as documented. Non-Unicode and every other Unicode value reach `panic!`; by `BUILD-MAP-X`, unsuccessful scripts halt before library compilation.
+- `wasm32-unknown-unknown` plus `arena`, with either feature state and every profile/debug state, reaches `compile_error!` at lines 15-16 and produces no supported library artifact. This is the one policy-mandated source rejection.
+- A stdout failure is an infrastructure failure, not a selector-policy rejection, per `BUILD-MAP-X`.
+- Other targets/toolchains/features and manual missing, duplicate, unknown, or forged cfgs are excluded by the controlling policy, not certified as supported or universally rejected.
+
+## TCB audit log
+
+`TCB.md/BUILD-MAP-X` is accepted exactly for Cargo 1.85.1 execution, rerun/check-cfg/rustc-cfg transport, feature/target mapping, and halt-on-unsuccessful-build-script propositions. Consumers are O1, O2, and F1 reachability. The review does **not** admit its excluded local-source, abstract-semantics, backend, or binary propositions. The remaining axioms are the linked Rust 1.85.1 Reference/std contracts, especially the exact `new_unchecked` precondition and UB consequence. No dependency, implementation, platform, probabilistic, or tool premise was added.
+
+Re-audit on any source, manifest, support/build policy, Rust/Cargo/std identity, environment interface, target/feature/cfg mapping, documented behavior, or TCB disposition change. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/1/attestation.json
new file mode 100644
index 0000000000..3f6d1a1a22
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/1/attestation.json
@@ -0,0 +1,12 @@
+{
+  "agent_id": "/root/report_r035",
+  "api_state": "INFRASTRUCTURE_FAILURE",
+  "attempt": 1,
+  "evidence": "Agent disappeared from collaboration state after user steering interrupted the orchestration wait; no completion callback or report output was available.",
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:18:46.798428Z",
+  "rerunnable": true,
+  "run_id": "r035",
+  "schema_version": 1,
+  "terminal_disposition": "ORCHESTRATOR_TOOL_FAILURE"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/1/raw-output-manifest.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/1/raw-output-manifest.json
new file mode 100644
index 0000000000..6fcc9c8718
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/1/raw-output-manifest.json
@@ -0,0 +1,6 @@
+[
+  {
+    "path": ".",
+    "type": "directory"
+  }
+]
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/2/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/2/attestation.json
new file mode 100644
index 0000000000..11e0af0889
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/2/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r035_a2",
+  "api_state": "COMPLETED",
+  "attempt": 2,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:28:24.748199Z",
+  "report_sha256": "d135ad89e2b402af49206d79186ad5f4454716f99c32debe93ff458ed07d086e",
+  "run_id": "r035",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 917
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/2/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/2/report.md
new file mode 100644
index 0000000000..3a76df465c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r035/2/report.md
@@ -0,0 +1,64 @@
+# Unsafe Rust audit: supplied `symbolic-domain-target` snapshot
+
+## Claims and verdicts
+
+**Soundness theorem.** For every well-typed safe call to `value_or_zero` in every supported configuration defined below, execution is free of Rust undefined behavior under the documented Rust abstract semantics.
+
+**Soundness verdict: PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** That qualification is material: the proof consumes both propositions preserved by that entry throughout the complete supported Rust/configuration domain.
+
+**Documented-behavior theorem.** In the same domain, `value_or_zero(None) == 0`, and for every `b: u8`, `value_or_zero(Some(b)) == b`.
+
+**Documented-behavior verdict: PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** Combined mandatory result: **PROVED relative to `COMPAT-OPTION-184-186`**. No conditional application or binary claim is made.
+
+## Snapshot and supported set
+
+Scope is the complete supplied source snapshot: package `symbolic-domain-target` 0.1.0, edition 2021, `rust-version = "1.84"`, `#![no_std]`, manifest, policy, CI, and TCB files. There are no dependencies, lockfile, build script, generated source, macros, FFI, assembly, allocator selection, concurrency, or prior audit.
+
+`Supported(c)` means: `c` uses a released stable Rust toolchain `r` with `1.84.0 <= r <= 1.86.0`; target is exactly `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `telemetry` is either disabled or enabled; Cargo profile is arbitrary; and debug assertions are either disabled or enabled. `SUPPORT.md`, including its upper cutoff, is controlling. `Cargo.toml` only supplies Cargo's lower acceptance bound. `CI.md` is sampling evidence and neither defines nor proves support.
+
+This audit uses the policy predicate parametrically; it need not guess or freeze the interval's patch-release membership. Source identity is the supplied files, with an audit cutoff of this review. Unlisted configurations are outside the claimed theorem by the explicit support commitment; no build-time rejection is claimed.
+
+## Boundary, surfaces, and invariant
+
+The sole crate API surface is safe public function `value_or_zero(Option<u8>) -> u8`. It has no public fields, constructors, traits/impls, associated items, reexports, hidden items, statics, callbacks, operators, custom destruction, or configuration-generated variants. The sole unsafe operation is the internal call to `Option::unwrap_unchecked`; there is no public unsafe API and therefore no caller safety obligation.
+
+`INV-BRANCH`: at the unsafe call, the unchanged local `value` is `Some(b)` for some `b`. Its owner is the function's straight-line control flow. The `is_none` check establishes it on the fallthrough edge; no mutation, callback, or other intervening operation can suspend it; `unwrap_unchecked` consumes it.
+
+## Obligation ledger and reconstructed proof
+
+| ID | Exact obligation and derivation | Domain | Status |
+|---|---|---|---|
+| OBL-1 | `value.is_none()` is true exactly when `value` is `None`. This is the base [`is_none` contract](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), whose relevant text is “Returns true if the option is a `None` value,” carried over the domain by `COMPAT-OPTION-184-186`. | All `Supported(c)` | PROVED relative to the TCB entry |
+| OBL-2 | On fallthrough, the check returned false. By OBL-1 and `Option`'s two variants, `value = Some(b)`. `is_none` only borrowed the by-value local, and no transition follows, establishing `INV-BRANCH`. | All inputs/configurations | PROVED relative to the TCB entry |
+| OBL-3 | [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) requires non-`None`; its safety text says calling it on `None` is undefined behavior. OBL-2 proves the precondition. `COMPAT-OPTION-184-186` additionally preserves that `unwrap_unchecked(Some(b))` returns `b`. | All fallthrough executions in `Supported(c)` | PROVED relative to the TCB entry |
+| OBL-4 | If the check is true, OBL-1 gives `None` and the explicit return yields 0 without unsafe execution. If false, OBL-2/3 give `Some(b)` and result `b`. These exhaustive paths prove the documented result. | All safe inputs/configurations | PROVED relative to the TCB entry |
+
+The derivation is uniform across targets, releases, features, profiles, and assertion states: the source contains no `cfg`, feature use, target branch, assertion, overflow, allocation, or profile-sensitive operation. The accepted TCB proposition expressly quantifies over every supported value of those axes, so their Cartesian product is closed by the same proof.
+
+## TCB audit log
+
+| ID | Disposition | Exact consumed proposition | Consumers / limitations |
+|---|---|---|---|
+| `COMPAT-OPTION-184-186` | Accepted by the authorized human reviewer | For every released stable `r` in 1.84.0–1.86.0 and all supported targets/profiles/feature/assertion states, Rust preserves: `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; calling it on `None` is UB. Base authority is the linked Rust 1.84.0 standard-library documentation. | OBL-1–4 and both verdicts only. It establishes no interval membership, Cargo fact, other API, backend, or binary property. |
+
+No other admitted premise is consumed. Source-level reasoning does not trust a particular compiler backend. Re-audit is required on any source, support-domain, base-contract, feature/target, or human-disposition change.
+
+## Finding DOC-1: adjacent proof is incomplete
+
+**Classification:** implementation obligation PROVED; proof artifact deficient; no UB witness and no defined postcondition refutation. The existing `SAFETY` comment states the branch conclusion and callee precondition, but does not identify the exact `is_none` fact, its domain/TCB basis, the absence of an intervening transition, or the result used for the public postcondition.
+
+Proposed replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 guarantees throughout the supported domain
+// that is_none is true exactly for None. This fallthrough is therefore
+// Some(b); value has not been mutated. The same entry guarantees that
+// unwrap_unchecked(Some(b)) is defined and returns b.
+unsafe { value.unwrap_unchecked() }
+```
+
+Minimal resolution is to install equivalent adjacent or canonical proof text. This is documentation debt, not an implementation or API-contract failure.
+
+## Residual scope and attestation
+
+No code was modified, expanded, built, run, or tested; there is no tool-derived proof. Compiler/backend correctness, emitted binaries, non-supported configurations, resource/security properties, and undocumented behavior are excluded. Every source/API, unsafe operation, invariant transition, documented result, and supported configuration class has a disposition. Re-audit on changes to source/contracts, support policy, Rust/std documentation, TCB disposition, generated/build inputs, or newly discovered obligations.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r036/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r036/1/attestation.json
new file mode 100644
index 0000000000..050feea290
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r036/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r036",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:37:03.963750Z",
+  "report_sha256": "f5b0a2be88ccf8436af7044f8a321be0582d57dacffa84012c994a705779dc77",
+  "run_id": "r036",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 895
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r036/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r036/1/report.md
new file mode 100644
index 0000000000..de72a5364a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r036/1/report.md
@@ -0,0 +1,52 @@
+# Unsafe Rust audit: `symbolic-domain-target` 0.1.0
+
+## Claim and verdict
+
+| Claim | Exact theorem | Verdict |
+|---|---|---|
+| SOUND | For the supplied source and every configuration in `Required`, every well-typed safe call `value_or_zero(value: Option<u8>)` is free of Rust undefined behavior. | **PROVED relative to accepted `COMPAT-OPTION-184-186`** |
+| RESULT | Under the same quantification, the function returns `0` for `None` and the contained byte for `Some(b)`. | **PROVED relative to accepted `COMPAT-OPTION-184-186`** |
+
+The combined mandatory result is **PROVED relative to `TCB.md` as supplied**, specifically its conspicuous human-accepted compatibility premise `COMPAT-OPTION-184-186`. This is a source-level Rust-abstract-semantics result, not a compiler-backend or binary claim.
+
+Snapshot: the complete supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`; edition 2021, `#![no_std]`, `rust-version = "1.84"`, no Cargo dependencies, build script, generator, or generated artifact. No prior audit or tool-derived evidence was used. Audit cutoff: 2026-08-01. Skill identity: supplied `unsafe-rust` package; no revision was provided.
+
+## Required domain and configuration closure
+
+Let `ReleasedStable(r)` retain its literal policy meaning, `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`, `F = {telemetry off, telemetry on}`, `D = {debug assertions off, debug assertions on}`, and `P` be the symbolic set of all Cargo profiles. `SUPPORT.md` states exactly:
+
+`Required(r,t,f,p,d) = ReleasedStable(r) ∧ 1.84.0 ≤ r ≤ 1.86.0 ∧ t∈T ∧ f∈F ∧ p∈P ∧ d∈D`.
+
+This is a literal normalization, hence equality in both directions; no release or profile enumeration is substituted. `Cargo.toml` supplies only Cargo's lower acceptance bound, while `SUPPORT.md` expressly controls the project promise including its upper cutoff. `CI.md` samples 1.84.0/x86_64/no-feature and 1.86.0/all targets/both features; it is not support-definition or semantic proof evidence.
+
+Actual source-selection axes are empty: neither `telemetry`, `cfg`, target, profile, nor `debug_assertions` occurs in `lib.rs`. There are no allocator, FFI, assembly, concurrency, macro, dependency, panic, arithmetic, generated-code, or linking obligations in the function. The derivation below is syntactically identical across `t,f,p,d`; accepted `COMPAT-OPTION-184-186` supplies the two consumed `Option` propositions parametrically for every `r,t,p,f,d` in `Required`. Therefore each obligation's `Covered = Required`, their pointwise intersection is `Required`, and `Required ⊆ Covered` follows by identity. The cutoff does not enumerate releases and is not used as continuity evidence.
+
+## Boundary, invariant, and obligation coverage
+
+The only language-reachable crate surface is the public safe free function `value_or_zero` (`src/lib.rs:3-12`). There are no public fields, constructors of an owned representation, methods, traits/impls, reexports, macros, hidden items, statics, callbacks, FFI entrypoints, or custom destruction. The sole unsafe operation is `Option::unwrap_unchecked` at line 11. No persistent representation invariant exists. The transient fact `INV-NONNONE` is: after the `if value.is_none() { return 0; }` fallthrough, `value` is not `None`; the branch produces it and line 11 consumes it.
+
+| ID | Obligation and proof | Domain | Status |
+|---|---|---|---|
+| O1 | `is_none` classifies `None` exactly. This is the accepted preserved base proposition; the true branch returns before line 11. | `Required` | PROVED, TCB-relative |
+| O2 | `unwrap_unchecked` is not called on `None`. Reaching line 11 means `is_none()` was false; O1 gives `INV-NONNONE`, exactly discharging the unsafe call's condition. | `Required` | PROVED, TCB-relative |
+| O3 | Result: on `None`, O1 takes the branch and returns `0`; on `Some(b)`, O1 falls through and the accepted `unwrap_unchecked(Some(b)) = b` proposition returns `b`. These cases exhaust `Option<u8>`. | `Required` | PROVED, TCB-relative |
+| O4 | Configuration closure. Source and control flow are independent of every non-release axis, and the accepted premise covers the complete symbolic release predicate and all stated axes. | `Required` | PROVED, TCB-relative |
+
+The adjacent `SAFETY` comment is adequate: it names the dominating `None` return, derives `Some` at the call, and identifies that fact as `unwrap_unchecked`'s precondition. The proof above exposes the otherwise project-level version/configuration premise. Every normal exit re-establishes the result contract; there is no mutation, unwind point, callback, aliasing, allocation, or retained capability.
+
+## TCB audit log
+
+Log identity: supplied `TCB.md`, reviewed for this audit; disposition **accepted by the authorized human reviewer**.
+
+| ID/category | Exact proposition, identity, scope, consumers | Disposition and limits |
+|---|---|---|
+| BASE-OPTION-184 / AXIOM | Rust 1.84.0 [`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) says it returns true for `None`; [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) returns the contained `Some` value and makes `None` undefined behavior. Base for O1-O3. | Version-matched authoritative base text inspected. |
+| COMPAT-OPTION-184-186 / accepted compatibility premise | Without weakening, qualification, or added precondition, preserves exactly: (1) `is_none` is true exactly for `None`; (2) `unwrap_unchecked(Some(v))` returns `v`, and calling it on `None` is UB; for every released stable `r` in the inclusive interval, all supported targets/profiles, either feature state, and either debug-assertion state. Consumers: only O1-O3 and the two verdicts. | **Accepted.** Establishes neither interval membership, Cargo facts, other APIs, backend correctness, nor emitted binaries. Re-audit on any source, interval, base-proposition, feature/target-scope, or disposition change. |
+
+No other compatibility, dependency, implementation, environment, probabilistic, or tool premise is consumed. The selected premise does not assume the in-scope implementation conclusion; it only transports two standard-library contracts across the exact symbolic domain.
+
+## Findings, residual scope, and triggers
+
+All in-scope obligations have complete derivations; there is no `UNPROVED`, `UNSOUND`, `CONTRACT-BROKEN`, proof-documentation, authoritative-documentation, or skill-guidance finding. Broader robustness, binary correctness, backend/linker behavior, and unsupported configurations were not claimed or audited. Re-audit is required if any supplied source or contract changes; `Required` expands or changes; the authoritative base text or accepted TCB disposition changes; generated code, dependencies, or configuration-sensitive code appears; or a new consumer relies on the premise.
+
+Auditor: source-review agent. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r037/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r037/1/attestation.json
new file mode 100644
index 0000000000..81ed8024ef
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r037/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r037",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:37:37.825495Z",
+  "report_sha256": "b9cfc956cc8580d2722d554a8e40b81f781aab75650f69efd833756f9b67b355",
+  "run_id": "r037",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 892
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r037/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r037/1/report.md
new file mode 100644
index 0000000000..dcb861f59f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r037/1/report.md
@@ -0,0 +1,109 @@
+# Multi-release unsafe API source audit
+
+## Claim, snapshot, and result
+
+This review covers exactly the four exported `unsafe fn`s in `lib.rs`, at the
+2026-07-31 cutoff. For each API independently, the soundness claim is: every
+call satisfying its documented caller obligations has defined source-level Rust
+evaluation. The postcondition claim is each behavioral promise stated in that
+API's documentation. `Required` is the API-specific finite release set in
+`SUPPORT.md`; it is not an interval. In every listed release the target domain
+is every target on which the item exists and every ordinary debug or release
+profile. There are no dependencies, generated artifacts, conditional source,
+or additional configuration axes in the submitted snapshot. Compiler/backend
+correctness and binary behavior are excluded.
+
+| API | Required | Covered by admissible evidence | Soundness | Documented postconditions | Strongest combined verdict over Required |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same as Required | **PROVED** throughout | No behavioral postcondition is documented; the signature-level return of `()` is also **PROVED** throughout | **PROVED** |
+| `store_word` | `{1.80.0, 1.81.0}` | same as Required | **PROVED** throughout | Stores `value` at `dst`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop the old `u16`: **PROVED**, all throughout | **PROVED** |
+| `copy_byte` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same as Required | **PROVED** throughout | Destination becomes the source byte: **PROVED**; source byte is preserved: **PROVED**, all throughout | **PROVED** |
+| `load_word` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | `{1.80.0, 1.82.0}` | **PROVED** on Covered; **UNPROVED** on `{1.80.1, 1.81.0}` | Returned `u32` equals the initialized source value: **PROVED** on Covered and **UNPROVED** on the remainder; source is unchanged: the same regional result | **UNPROVED** |
+
+No valid UB witness or UB-free postcondition refutation is established. Thus no
+regional result is `UNSOUND` or `CONTRACT-BROKEN`.
+
+## Obligation derivations
+
+### `acknowledge`
+
+The local body is exactly `{}`, with zero parameters and unit return, and the
+documentation imposes no additional safety requirement. Accepted
+`SEM-EMPTY-BLOCK-180-182` states, for every release, target, and profile in
+Required, that this exact form has defined evaluation and returns `()`; making
+the function unsafe changes only the static call obligation. The body/signature
+facts therefore instantiate that entry over all of Required. The TCB entry is
+not used by any other API.
+
+### `store_word`
+
+The only unsafe operation is `ptr::write(dst, value)`. For both required
+releases, the submitted version-matched [`write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html)
+and [`write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html)
+contracts require `dst` to be properly aligned and valid for writes; these are
+exactly the public caller obligations. The well-typed `value: u16` supplies the
+value being written. The same version-matched descriptions establish overwrite
+without reading or dropping the old value. Hence soundness and every listed
+effect are covered in both required releases without a compatibility premise.
+
+### `copy_byte`
+
+The source fixes `T = u8` and `count = 1`. Its caller contract supplies a
+readable initialized source `u8`, a writable destination `u8`, alignment of
+both, and nonoverlap of the one-byte regions. The submitted 1.80.0
+[`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html),
+[primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout),
+[`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8),
+and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)
+establish the base safety requirements, one-byte size, copying effect, and
+non-moving source preservation. Accepted `COMPAT-COPY-180-182` preserves those
+exact propositions across every release, target, and profile in Required.
+Together with the local fixed type/count and caller clauses, this proves both
+soundness and both postconditions throughout Required. The entry expressly
+cannot support `ptr::read`, `ptr::write`, or another API.
+
+### `load_word`
+
+At 1.80.0 and 1.82.0, the version-matched [`read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html)
+and [`read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html)
+contracts require a readable, aligned, properly initialized non-ZST source;
+the public caller contract supplies those facts for one `u32`. The respective
+[`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32)
+and [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html),
+and the corresponding [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32)
+and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html),
+combine with each `read` description to establish the returned value and
+unchanged source at those endpoints.
+
+For 1.80.1 and 1.81.0, the packet supplies neither version-applicable `read` and
+`Copy` authorities nor an accepted compatibility proposition. Later 1.82.0
+text cannot establish earlier semantics, and 1.80.0 text cannot be propagated
+forward without an admitted compatibility premise. `COMPAT-COPY-180-182` is
+operation-specific and explicitly excludes `ptr::read`. The smallest missing
+implication is that, in each uncovered release and full target/profile domain,
+the documented caller facts satisfy `ptr::read`'s safety contract and the call
+returns the source `u32` while leaving the source unchanged. Absence of that
+premise makes both regional claims `UNPROVED`; it is not evidence of UB.
+
+## TCB, proof artifacts, and maintenance
+
+The complete non-authoritative TCB is the two accepted entries in `TCB.md`:
+`SEM-EMPTY-BLOCK-180-182`, consumed only by `acknowledge`, and
+`COMPAT-COPY-180-182`, consumed only by `copy_byte`. All `write`, `read`, layout,
+and `Copy` facts above are claim- and release-specific submitted Rust authority;
+none is transferred to a different operation or release.
+
+The API safety contracts are sufficient for the proved regions. The terse
+`SAFETY` comments do not themselves record the material release-applicability
+derivations reconstructed above, especially the `copy_byte` compatibility
+bridge and the endpoint-only `load_word` proof. This is proof-documentation
+debt, not a contrary implementation verdict. A replacement comment should cite
+the exact local type/count and caller clauses plus the applicable authority/TCB
+entry; no comment can close `load_word`'s two missing release premises.
+
+Re-audit is required upon any source/signature/contract change, change to a
+Required set or target/profile policy, change or withdrawal of either accepted
+TCB entry, or material change to a consumed versioned authority. To obtain a
+full `load_word` verdict, submit applicable authority for 1.80.1 and 1.81.0 or
+an accepted narrowly scoped compatibility premise covering the exact missing
+propositions.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r038/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r038/1/attestation.json
new file mode 100644
index 0000000000..4d52dd93ec
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r038/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r038",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:38:56.365356Z",
+  "report_sha256": "33f7ad5b9d6de92126d674c4b964e5d7ce46a3752b8883e324ce257ea928854f",
+  "run_id": "r038",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 942
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r038/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r038/1/report.md
new file mode 100644
index 0000000000..c092e7d612
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r038/1/report.md
@@ -0,0 +1,126 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the supplied `lib.rs`, exactly as inspected; no expansion,
+execution, tests, dependencies, generated artifacts, features, or prior audit
+were used. Scope is Rust and standard library 1.82.0, every target on which this
+source and its used standard-library items exist, and every ordinary profile.
+
+Let `D` be exactly that configuration predicate. Valid use of each safe public
+API means every well-typed safe use, including caller-chosen implementations of
+the safe `Slot` trait. The source-level claims are:
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every safe use of the exposed API is free of Rust UB over `D`. | **UNSOUND** | `F-1` gives a valid safe use, reaches the unsafe operation, falsifies its bounds precondition, and reaches the documented UB consequence. |
+| For every `pair`, `increment::<Tail>` changes element 1 to its prior value plus 1 modulo `2^32` and leaves element 0 unchanged, over `D`. | **PROVED** | `P-TAIL` below; `D ⊆ CoveredTail = D`. |
+
+The overall current-artifact soundness verdict is **UNSOUND**. The redesign
+proposal below does not qualify or alter it. There is no separate
+`CONTRACT-BROKEN` finding: the requested `Tail` behavior holds, and the source
+contains no other documented postcondition.
+
+## Boundary and inventory
+
+The complete relevant public surface is: safe trait `Slot`; its safe required
+associated function `index`; the public unit struct/constructor `Tail`; its safe
+`Slot` implementation; and safe generic free function `increment`. A downstream
+crate may implement `Slot` without `unsafe`. There are no unsafe public APIs,
+fields, hidden items, macros, callbacks, FFI, dependencies, or persistent
+representation invariants. `increment` contains the sole unsafe operation,
+`get_unchecked_mut(S::index())`, with no adjacent `SAFETY` proof.
+
+The only local invariant-like fact is `ARRAY-2`: the borrowed array has exactly
+two elements, hence valid scalar indices are `0` and `1`. `Tail::index()`
+locally establishes `INDEX-TAIL = 1`. No type or boundary establishes
+`S::index() < 2` for arbitrary `S: Slot`.
+
+## Obligations and proofs
+
+The Rust 1.82 slice contract says that `get_unchecked_mut` returns a mutable
+reference without bounds checking and that calling it with an out-of-bounds
+index is UB, even if the reference is unused
+([slice documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)).
+Thus obligation `O-BOUNDS` is `S::index() < 2` at the call for every safe
+instantiation. The Rust 1.82 integer contract says `wrapping_add` performs
+modular addition, wrapping at the type boundary
+([u32 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)).
+
+**F-1 — open safe trait makes `increment` unsound.** A downstream safe program
+may write:
+
+```rust
+struct Outside;
+impl Slot for Outside { fn index() -> usize { 2 } }
+let mut pair = [0u32, 0u32];
+increment::<Outside>(&mut pair);
+```
+
+This uses no unsafe caller operation and violates no documented or
+compiler-enforced caller obligation. Dynamic dispatch is not involved:
+`Outside::index()` returns `2`, so the safe call reaches
+`pair.get_unchecked_mut(2)`. By `ARRAY-2`, `2` is out of bounds. The cited
+contract makes the call itself UB. The witness is parametric over `D`: the
+literal `2`, array length, trait implementation, and callee selection are
+profile- and target-independent wherever the source/items exist. This closes
+every link of the `UNSOUND` certificate. The missing safety comment is also a
+proof-artifact defect, but documentation cannot repair this safe boundary.
+
+**P-TAIL — requested behavior.** For `S = Tail`, inspected code gives
+`S::index() = 1`; `ARRAY-2` gives `1 < 2`, discharging `O-BOUNDS`. The cited
+slice contract therefore identifies the returned mutable reference with
+element 1. If its old value is `x`, the cited integer contract gives
+`x.wrapping_add(1) = (x + 1) mod 2^32`; assignment stores that result through
+the element-1 reference. No operation targets element 0. This one parametric
+case applies to every input and every configuration in `D`, including overflow
+and all ordinary profile settings.
+
+## Domain closure and TCB log
+
+`Required = D` comes verbatim from the request; no range normalization,
+enumeration, exclusion, or moving policy is used. Actual axes are target and
+ordinary profile. There is one handwritten implementation with no `cfg`; both
+proofs above are parametric over those axes. Therefore the unsound witness and
+`P-TAIL` each cover all of `D`. Audit cutoff is 2026-08-01 and only freezes the
+inspected source and fixed-version documentation.
+
+TCB `TCB-1` contains only two verified authoritative Rust 1.82 axioms: (A1) the
+quoted `get_unchecked_mut` contract, consumed by `F-1` and `P-TAIL`; and (A2) the
+quoted `wrapping_add` contract, consumed by `P-TAIL`. Both apply over `D` by its
+definition. No additional assumptions, safe/unsafe dependencies, compiler
+implementation claims, tools, external specifications, or deployment premises
+are admitted.
+
+## Preferred redesign
+
+Replace the generic abstraction with one concrete safe operation:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its contract is: for every input array, normal return leaves element 0 equal to
+its entry value and sets element 1 to its entry value plus 1 modulo `2^32`; it
+has no caller safety precondition. The fixed array type and safe indexing
+enforce selection of the required element, and `wrapping_add` supplies the
+arithmetic. There is no unsafe block, implementer contract, or representation
+invariant. `Slot` and `Tail` should be removed because nominal slot identity and
+extensibility supply no required capability.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)` and
+removes all `Slot` implementations and generic uses. This is an authorized
+source/API break: the request says the abstraction is unreleased and those
+surfaces need not be preserved. The required observable `Tail` behavior is
+unchanged.
+
+This is a design, not an implemented-artifact verdict. After implementation,
+fresh review must inspect the exact new snapshot; enumerate its complete public
+surface; prove safe index `1` is in bounds for `[u32; 2]`; prove the modular
+write and preservation of element 0 for every input; re-establish `D ⊆
+Covered`; and check that no conditional/generated alternative or remaining
+unsafe/generic surface exists. Re-audit is also required for any source,
+contract, Rust version, support-domain, or relevant standard-library contract
+change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r039/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r039/1/attestation.json
new file mode 100644
index 0000000000..43692f7ea1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r039/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r039",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:46:33.935981Z",
+  "report_sha256": "c250345e3ded76516cb26af1a80874ba305fb015d70c75b3a82ad5eb7c3821b9",
+  "run_id": "r039",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1246
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r039/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r039/1/report.md
new file mode 100644
index 0000000000..51b4b178b6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r039/1/report.md
@@ -0,0 +1,103 @@
+# Focused unsafe-Rust source audit
+
+## Claim, domain, and result
+
+Snapshot: the complete supplied `lib.rs`; no generated code, dependencies, `cfg`, macros, FFI, or build inputs are present. `Required` is exactly Rust/stdlib 1.82.0 × every target on which this source and the used 1.82.0 std items exist × every ordinary profile. The claim quantifies over every well-typed safe call, in a context satisfying any independently introduced unsafe-code obligations (notably, downstream `unsafe impl Lane`). It is a source-level claim under documented Rust abstract semantics, not a compiler-binary claim.
+
+| Scope | Soundness verdict | Proof-artifact verdict |
+|---|---|---|
+| `callback_index::read` | **UNSOUND** (CB-R) | missing and incapable of proving the current code |
+| `callback_index::write` | **UNSOUND** (CB-W) | missing and incapable of proving the current code |
+| `local_proof::last` | **PROVED** | **deficient**; material proof reconstructed below |
+| `published_lane` (`Word`, `Lane`, `High`, `read`) | **PROVED** | trait contract adequate; `High` and `read` local proofs missing |
+| All three modules, aggregate | **UNSOUND** | CB-R and CB-W |
+
+There are no explicit function postconditions to certify. The two normative clauses of `Lane`'s published safety contract are separately discharged for the in-scope `High` implementation. No UB-free documented-postcondition counterexample was established, so `CONTRACT-BROKEN` is not claimed.
+
+## Authoritative premises (TCB-1)
+
+No additional TCB assumptions are admitted. The only ground premises are these verified Rust 1.82 authorities:
+
+- AX-SLICE: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) require the index to be in bounds; “Calling this method with an out-of-bounds index is undefined behavior.” They return a reference to the selected element when their contract holds.
+- AX-LEN: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when length is zero.
+- AX-INT: [`usize` is an unsigned integer type](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types); the [binary-operator rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators) govern subtraction and overflow. The proofs below perform subtraction only from a positive value.
+- AX-TRAIT: Rust requires an unsafe implementation for an unsafe trait and assigns such implementations extra safety invariants: [trait rules](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe` trait rules](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait).
+
+These axioms apply exactly to 1.82.0 across `Required`; there is no cross-version compatibility premise.
+
+## Boundary and obligation inventory
+
+| Surface/obligation | Disposition |
+|---|---|
+| safe, downstream-implementable `Position` and safe `position()` | An implementation may return any `usize`; no bounds invariant exists. |
+| safe `callback_index::{read, write}` | Each passes that adversarial result to an unchecked operation; false obligation, CB-R/CB-W. |
+| safe `local_proof::last` | All inputs covered by the empty/nonempty branch proof LP. |
+| public `Word(pub [u32; 2])` and its tuple constructor | Safe construction cannot alter the type-enforced length of two; no stronger invariant is needed. |
+| public unsafe `Lane`, `INDEX`, and `NAME` | Valid implementations promise `INDEX < 2` and the exact index/name mapping. Both clauses remain live published obligations. |
+| public unit `High` constructor and `unsafe impl Lane for High` | `INDEX = 1 < 2`; because it is 1, `NAME = "high"` meets the second clause. |
+| safe `published_lane::read<L: Lane>` | PL proves its unchecked access for every valid implementation, including unknown downstream ones. |
+
+There are no other constructors, methods, fields, callbacks, hidden items, reexports, generated APIs, or configuration-specific surfaces in the supplied source.
+
+## CB-R and CB-W — complete UB certificates
+
+Define, entirely in safe caller code, `struct Bad; impl Position for Bad { fn position(&self) -> usize { 1 } }`.
+
+- **CB-R valid use:** `read(&[0u8], &Bad)` is well typed and invokes only safe APIs. No caller safety precondition exists.
+- **CB-R reachability/falsity/consequence:** `position()` returns 1; the slice length is 1, so index 1 is out of bounds. `get_unchecked(1)` executes. AX-SLICE classifies that call as UB.
+- **CB-W valid use:** with `let mut a = [0u8];`, `write(&mut a, &Bad, 7)` is likewise a well-typed safe call.
+- **CB-W reachability/falsity/consequence:** `get_unchecked_mut(1)` executes on length 1; the required in-bounds proposition is false, and AX-SLICE classifies the call as UB.
+
+The witnesses use values available on every `Required` target and do not depend on optimization, overflow checks, or panic strategy. Thus both scoped universal safe-API claims are refuted throughout `Required`; one witness would also suffice for the aggregate `UNSOUND` result.
+
+### Smallest required repair (proposal only)
+
+Delete `Position` and replace the functions with:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 {
+    bytes[position]
+}
+
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+This retains caller-chosen positions and callable read/write operations, removes the caller-implementable behavioral boundary and all unsafe operations, and gives out-of-range inputs the safe indexing behavior. Removing the public trait and changing parameter types is a source/API compatibility break; migrate callers from `&P` to a `usize`. This candidate is **not certified**: implement it as a new snapshot and freshly audit its exact behavior and full domain.
+
+## LP — implementation proof and proof-documentation defect
+
+On the `None` branch no unsafe operation executes. On the other branch, AX-LEN gives `n = bytes.len() != 0`. Since `n: usize` is unsigned, `n >= 1`; therefore `n - 1` neither underflows nor varies by overflow-check profile, and `0 <= n - 1 < n`. Hence `index` is in bounds, satisfying AX-SLICE. The returned shared reference designates the last initialized `u8`; copying it into `Some` adds no aliasing or lifetime obligation. This proof is parametric over `usize` width and every target/profile in `Required`.
+
+The existing comment, “This is the fast path,” identifies neither the operation nor any precondition or fact. Replace it with:
+
+```rust
+// SAFETY: `is_empty()` was false on this branch, so `bytes.len() != 0`.
+// Thus `bytes.len() >= 1`, subtraction cannot underflow, and
+// `index = bytes.len() - 1 < bytes.len()`. `index` is therefore in bounds,
+// as required by `slice::get_unchecked`.
+```
+
+## PL — unsafe-trait proof and published-contract constraints
+
+For any valid `L: Lane`, the published unsafe contract supplies `L::INDEX < 2`. `Word.0` has type `[u32; 2]`, hence that index is in bounds and AX-SLICE discharges `read`'s unchecked access. `NAME` is not consumed locally, but it is not ignored: `High` satisfies it syntactically, and every valid downstream implementation owes it. An incorrect downstream `unsafe impl` is a violation of an out-of-scope unsafe obligation, not a valid-use counterexample to this safe generic API.
+
+Add these local proofs:
+
+```rust
+// SAFETY: `INDEX` is 1, hence less than 2, and for index 1 `NAME` is "high".
+unsafe impl Lane for High { /* unchanged items */ }
+
+// SAFETY: every valid `Lane` implementation guarantees `L::INDEX < 2`;
+// `word.0` is a two-element array, so that index is in bounds.
+unsafe { *word.0.get_unchecked(L::INDEX) }
+```
+
+Because this is a published 1.x unsafe-trait contract with unknown implementations and consumers, a repository-only search cannot authorize evolution. Weakening/removing `INDEX < 2` breaks `read`; weakening/removing the `NAME` mapping can invalidate downstream unsafe consumers; strengthening either clause can invalidate existing downstream implementations. Making the trait safe would admit arbitrary indices unless every consumer validates them, and would also withdraw guarantees from unknown consumers. Preserve the contract in 1.x; any redesign needs an explicit compatibility/migration plan and a fresh whole-ecosystem-facing audit.
+
+## Configuration closure, residual scope, and triggers
+
+Source inspection finds no configuration-selecting construct. LP and PL are parametric over target `usize` width and profile behavior; their aggregate `Covered` equals `Required`, so `Required ⊆ Covered`. CB-R/CB-W witnesses apply to every member of `Required`. Nothing was built, tested, executed, or expanded; no tool evidence is claimed.
+
+Excluded: compiler/backend correctness, binary/platform behavior beyond Rust's abstract semantics, nonexistent downstream implementation auditing, and undocumented robustness properties. Re-audit on any source or safety-contract change, implementation of the repair, support-domain/Rust-version change, or material change to a consumed Rust 1.82 authority.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r040/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r040/1/attestation.json
new file mode 100644
index 0000000000..133cf5a189
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r040/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r040",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:48:47.942095Z",
+  "report_sha256": "034a581627624218f85a2e12af3590c9346c1227c7846bf28e3bacf75c8c7a5f",
+  "run_id": "r040",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 1067
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r040/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r040/1/report.md
new file mode 100644
index 0000000000..3dce4d872a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r040/1/report.md
@@ -0,0 +1,74 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot.** Exact supplied `lib.rs`; no expansion, execution, tests, dependencies, generated artifacts, or prior audit were used. Audit date: 2026-08-01. Scope is Rust and standard library 1.82.0, every target on which this exact source and its used standard-library items exist, and every ordinary profile. The source has no `cfg`, feature, target, generator, FFI, allocator, concurrency, or dependency branch. Profile-dependent overflow checks are immaterial because the code explicitly uses wrapping arithmetic.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces must be free of Rust undefined behavior, with no caller safety precondition, over that supported set.
+
+**Current-artifact soundness verdict: UNSOUND (F-1).** The result is universal across the supported set; a safe downstream trait implementation can select an out-of-bounds index.
+
+**Required `Tail` behavior: PROVED.** For every initial `pair == [a, b]`, `increment::<Tail>(&mut pair)` returns without UB with `pair == [a, b.wrapping_add(1)]`. This requested behavior is not a source-documented postcondition, so there is no separate `CONTRACT-BROKEN` result. The overall safe API remains `UNSOUND` despite this regional proof.
+
+**TCB:** `TCB-1` below. It contains only verified Rust 1.82.0 standard-library axioms and no additional admitted assumptions. Conditional application claims: none.
+
+## Boundary, invariants, and obligation ledger
+
+Public safe surfaces are: implementable trait `Slot`; safe associated function `Slot::index`; constructible unit struct `Tail`; its safe `Slot` implementation; and safe generic free function `increment<S: Slot>`. The sole unsafe operation is the internal `get_unchecked_mut` call. There are no unsafe public APIs, fields, macros, hidden items, or generated surfaces in the supplied source. Ordinary unit-struct construction and auto traits do not supply an index-range guarantee.
+
+No enforced invariant exists. The needed proposition, `S::index() < 2`, cannot be an invariant of all `S: Slot`: the safe public trait permits caller-controlled implementations and its method has neither a type-enforced restriction nor validation.
+
+| ID | Location | Exact obligation | Status |
+|---|---|---|---|
+| O-1 | `increment`, unchecked projection | The particular returned index is in bounds for the two-element slice before `get_unchecked_mut` is called. | **False** for general `S`; F-1. |
+| O-2 | `increment::<Tail>` | `Tail::index() == 1` and `1 < 2`. | **PROVED** directly from the implementation and array length. |
+| O-3 | mutation | On the Tail path, write the old second value plus one modulo the `u32` range, leaving element 0 unchanged. | **PROVED** from O-2, exclusive `&mut` access, A-1, and A-2. |
+| O-4 | configuration closure | O-1--O-3 cover every requested target/profile. | **PROVED** parametrically: the fixed length, constants, and cited 1.82 contracts do not vary across this source's supported set. |
+
+For the Tail derivation, method evaluation yields `1`; the receiver has length two, so A-1's only stated safety condition is met. The resulting mutable reference designates element 1 and is used within the exclusive borrow without intervening caller code. A-2 makes the computed value `(b + 1) mod 2^32`; assignment changes only that element. No material derivation is present in the source: the unsafe block has no adjacent `SAFETY` proof. More importantly, no comment could prove O-1 for arbitrary safe implementations.
+
+## F-1 — safe implementer reaches out-of-bounds unchecked access
+
+**Implementation classification:** `UNSOUND`. **Proof artifact:** missing and irreparable under the current safe generic contract.
+
+A downstream crate can use only safe Rust:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+`Bad` is caller-controlled and satisfies the complete declared bound. The array/slice length is 2, and `Bad::index()` returns that length. A-1 says this call itself has undefined behavior even if the reference is unused. Thus this valid safe use reaches UB on every supported configuration. This whole-execution witness establishes `UNSOUND`; it is not used as a defined postcondition refutation.
+
+Minimum resolution is to remove the unchecked operation or enforce bounds before it. Merely documenting that a safe `Slot` implementation should return 0 or 1 would leave a hidden safety precondition and would not repair soundness.
+
+## TCB-1 audit log
+
+| ID | Category and exact proposition | Identity, evidence, consumers, disposition |
+|---|---|---|
+| A-1 | AXIOM: `get_unchecked_mut` returns a mutable element/subslice reference without a bounds check; an out-of-bounds index makes the call UB. | Rust 1.82.0 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut), verified in context. Exact safety text: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumers O-1--O-3; accepted authoritative axiom. |
+| A-2 | AXIOM: `u32::wrapping_add(rhs)` computes modular addition at the type boundary. | Rust 1.82.0 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add), verified in context: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” Consumer O-3; accepted authoritative axiom. |
+
+There are no safe/unsafe dependency, implementation, tool, external, deployment, probabilistic, or out-of-band entries. No tool-derived evidence was used. Re-audit triggers are any source/API change, supported-set change, or material change to either cited Rust contract.
+
+## Preferred redesign (not a verdict on current source)
+
+The minimum capability is one fixed, safe mutation; neither type-level slot identity nor implementer extensibility is required. Delete `Slot`, `Tail`, the generic parameter, and all unsafe code:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed safe contract is: for every `[a, b]`, return normally as `[a, (b + 1) mod 2^32]`, with no caller safety obligations. Constant `1` is in bounds by the input type; safe indexing localizes enforcement, and A-2 supplies the arithmetic result. There is no representation invariant, unsafe surface, implementer promise, or extra TCB premise.
+
+This intentionally breaking migration replaces `increment::<Tail>(&mut pair)` with `increment(&mut pair)` and removes all `Slot` implementations, generic calls, and references to the marker type. Those losses are expressly authorized for this unreleased API; the required observable mutation is unchanged.
+
+The proposal is unimplemented and has no audit verdict. After implementation, freeze a new snapshot and audit its complete public/reexported and generated surface, confirm the exact fixed index and array type, prove safe indexing and A-2's postcondition over the full supported set, check every normal exit and call-site migration, and re-establish configuration closure. Any retained compatibility wrapper or newly introduced macro/configuration becomes additional audit scope.
+
+## Residual scope and attestation
+
+Only the supplied source and requested Tail behavior were audited; no broader crate or binary claim is made. Every discovered obligation has a status, both allowlisted citations were opened and checked at version 1.82.0, no test result substitutes for proof, and the redesign does not alter the current-artifact verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r041/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r041/1/attestation.json
new file mode 100644
index 0000000000..3606e62791
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r041/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r041",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:46:54.507655Z",
+  "report_sha256": "d6e6359967799119d7119d804bbeb26db216412f3baab76d2392102683dc4fe2",
+  "run_id": "r041",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 849
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r041/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r041/1/report.md
new file mode 100644
index 0000000000..d4d3354f83
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r041/1/report.md
@@ -0,0 +1,51 @@
+# Focused unsafe-Rust audit: `classify`
+
+## Claim, scope, and verdicts
+
+Snapshot: the exact submitted `lib.rs`, whose only public item is `pub fn classify(input: u8) -> u8`. This is a source-level review under the documented Rust abstract semantics. Let **S** be Rust compiler and standard library 1.80.0, every edition and target on which this exact source and `std::hint::unreachable_unchecked` exist, and every ordinary debug or release profile. The proof is parametric over S. A valid use is any well-typed safe call with any `u8`; there is no caller safety precondition.
+
+| Claim | Verdict over S | Decisive reason |
+|---|---|---|
+| Every valid safe call is free of UB | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked`. |
+| Every call with `input == 0` panics | **UNPROVED** | The only source path reaches UB. That execution cannot establish a defined behavioral refutation. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The separate UB-free call `classify(1)` normally returns `2`. |
+
+The combined mandatory result is therefore **UNSOUND**, **UNPROVED** for the zero-input panic guarantee, and **CONTRACT-BROKEN** for the normal-return result guarantee, relative to TCB `TCB-1` below.
+
+## Authority and TCB (`TCB-1`)
+
+`AXIOM-UB-1` (AXIOM, accepted): for Rust 1.80.0, the Safety section of [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states: “Reaching this function is Undefined Behavior.” The submitted evidence states that this proposition applies throughout S. The Rust 1.80.0 [undefined-behavior chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) is the controlling Reference context for the source-level classification. Consumer: obligation `O-UB-0`. Re-audit on source, Rust/stdlib version, supported-set, or cited-contract change.
+
+No dependency, external, deployment, compiler-backend, tool, probabilistic, or implementation premise is consumed. No tests or tool-derived evidence were used. This TCB supports only a source-level result, not correctness of a particular emitted binary.
+
+## Surface and configuration coverage
+
+The complete language-reachable surface in the supplied source is safe free function `classify`; it accepts every `u8`. Its sole unsafe site is the call to `unreachable_unchecked` in the `0` arm. There are no public fields, types, traits, callbacks, macros, FFI, generated artifacts, dependencies, invariants, concurrency, allocation, or target-conditioned items.
+
+The `match` partitions all `u8` values exhaustively into `0`, `1`, and `2..=255`. No `cfg`, arithmetic, debug assertion, layout, target feature, or profile-dependent operation affects selection or results. Thus the same control-flow proof covers every member of S: optimization cannot repair a source-level execution that reaches an operation whose contract declares that reach UB, and debug/release differences do not alter either defined return arm.
+
+## Obligation ledger and proofs
+
+### `O-UB-0` — safe-call soundness, `input = 0`: **UNSOUND**
+
+Local facts: `0` selects the first arm; the two `marker` statements complete without changing `input` or control flow; execution then reaches the unsafe call. By `AXIOM-UB-1`, that reach is UB. Hence the valid safe invocation `classify(0)` is an in-scope UB-containing execution on every S configuration and refutes the universal soundness theorem.
+
+The adjacent comment, “This branch is assumed to be unreachable,” is a false and circular proof artifact: the immediately enclosing match arm itself establishes reachability when `input == 0`. A safe caller is permitted to supply zero, and the documentation affirmatively specifies its behavior. No caller obligation can be inferred.
+
+### `O-PANIC-0` — zero-input panic: **UNPROVED**
+
+Witness considered: `classify(0)` follows the path above and reaches UB; no panic operation occurs before that point. This witness proves `O-UB-0`, but an execution containing UB cannot prove the existence of an UB-free execution falsifying a documented postcondition. Therefore it cannot establish **CONTRACT-BROKEN**. Conversely, source execution through `unreachable_unchecked` supplies no defined panic postcondition, so the panic guarantee is not proved. No independent UB-free zero-input witness or equivalent proof was established.
+
+### `O-RESULT-1` — normal return, `input = 1`: **CONTRACT-BROKEN**
+
+`1` selects the second arm, so the unsafe first arm is not executed. The arm evaluates the valid `u8` literal `2` and normally returns it. The complete execution is UB-free, while `2 != 1`; it is therefore the required defined witness falsifying “returns `input` unchanged.” This witness is independent of the zero-input UB witness.
+
+### `O-RESULT-REST` — normal return, `input = 2..=255`: **PROVED**
+
+Every such value selects `_ => input`, does not execute the unsafe arm, and normally returns the copied input unchanged. For `input = 0`, the normal-return guarantee remains **UNPROVED** because its only source path contains UB; that case supplies neither a defined return nor a contract-breaking witness. The input-zero panic condition is inapplicable to all nonzero inputs. Soundness is locally proved for `1..=255` because those paths contain only the inspected ordinary match/literal/copy/return operations and never reach the unsafe site; this regional result does not change the aggregate **UNSOUND** verdict.
+
+## Findings and required resolution
+
+`F-1` is an implementation soundness defect and a deficient safety comment. Replace the zero arm with an actual panic; no revised `SAFETY` comment can justify the current call while zero remains accepted by the safe signature. `F-2` is an independent behavioral defect: return `input` rather than `2` in the `1` arm. Removing the unsafe call and applying both changes requires a fresh audit of the new snapshot.
+
+Residual scope is limited to backend/binary correctness and configurations outside S. Re-audit is required if the source, public documentation, Rust/stdlib version, cited authority, item availability, or supported configuration predicate changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r042/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r042/1/attestation.json
new file mode 100644
index 0000000000..371a8179c3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r042/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r042",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:56:07.832856Z",
+  "report_sha256": "9452fc8cae9f25d64b09d17822a59fceb98e19a1a754e327d799e9a462c09d69",
+  "run_id": "r042",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1203
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r042/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r042/1/report.md
new file mode 100644
index 0000000000..95fc42fddf
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r042/1/report.md
@@ -0,0 +1,152 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, scope, and verdicts
+
+This audits the exact supplied `Cargo.toml`, `build.rs`, `src/lib.rs`,
+`SUPPORT.md`, `BUILD.md`, and `TCB.md`, source-only, at the 2026-08-01 audit
+cutoff. No build, execution, expansion, test, prior audit, or VCS identity is
+used.
+
+`Supported(c)` means: edition 2021 with Rust, std, and Cargo 1.85.1; target
+triple in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu,
+wasm32-unknown-unknown}`; `burst` either disabled or enabled; allocator selected
+through `BUILD.md` as `system` or `arena`; excluding `wasm32`+`arena`; every
+Cargo profile and either debug-assertion state. Thus there are ten supported
+target/feature/allocator tuples, each parametric over profiles and debug
+assertions.
+
+The soundness claim is: for every `Supported(c)`, every well-typed safe use of
+the public API, and every permitted source-level Rust execution, the supplied
+crate introduces no undefined behavior, relative only to the TCB below.
+
+- **Whole supported-domain soundness: UNSOUND (F-01).** One expressly supported
+  tuple, `aarch64-unknown-linux-gnu` + `arena` + `burst`, admits a safe call
+  `lane_id(0)` that violates `NonZeroU8::new_unchecked`'s safety precondition.
+- **Other nine supported tuples: PROVED** for source-level soundness and the
+  documented `lane_id` behavior, relative to the stated TCB.
+- **Documented zero-input panic:** PROVED in those nine tuples; **UNPROVED** in
+  the defective tuple. It is not `CONTRACT-BROKEN`: the known zero-input
+  execution contains UB, so it is not a UB-free postcondition witness.
+- **Rejected `wasm32`+`arena` tuples (both feature states): PROVED effectively
+  rejected** before a library artifact is produced, relative to BUILD-MAP-X.
+
+No binary/backend, deployment, security, probabilistic, or additional
+robustness theorem is claimed.
+
+## Snapshot, boundary, and configurations
+
+The manifest has no dependencies, an empty default feature set, and only the
+`burst` feature. The build script is the sole configuration producer; there is
+no generated source. Its finite successful selector output family is exactly
+`fixture_allocator="system"` and `fixture_allocator="arena"`:
+
+1. [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html) supplies a
+   Unicode `String`, `NotPresent`, or `NotUnicode`. Lines 9-15 preserve an
+   accepted Unicode value, map absence to `system`, and panic on non-Unicode.
+2. Lines 16-20 accept only the two literal strings and execute exactly one
+   selector `println!`; every other Unicode value panics. [`println!`](https://doc.rust-lang.org/1.85.1/std/macro.println.html)
+   writes one newline-terminated stdout record and panics on a write failure.
+3. BUILD-MAP-X supplies only the Cargo-to-library transmission and unsuccessful
+   build-script behavior. Therefore accepted runs set exactly one allocator
+   cfg; invalid selectors and stdout failures produce no library compilation.
+
+Under the [Reference `cfg` rules](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute),
+false-attributed forms are removed and true-attributed forms remain. Cargo's
+[feature contract](https://doc.rust-lang.org/1.85.1/cargo/reference/features.html)
+and BUILD-MAP-X map the boolean `burst` state; BUILD-MAP-X maps each supported
+target triple to its stated `target_arch`.
+
+`src/lib.rs:3-13` rejects neither or both allocator cfgs. On the supported Cargo
+interface exactly one is present, so those guards are inactive. For the listed
+Wasm target plus `arena`, lines 15-16 retain `compile_error!`, which
+[`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)
+documents as causing compilation to fail. This proves the policy exclusion.
+Unlisted targets and manual `rustc` cfg invention are outside the theorem and
+are not claimed generally rejected.
+
+The only language-reachable crate API is safe
+`lane_id(u8) -> NonZeroU8` (`src/lib.rs:23-46`). There are no crate-defined
+public fields/types, unsafe APIs/traits/impls, callbacks, FFI, statics,
+reexports, exported macros, or hidden APIs. The two unsafe consumers are lines
+31 and 44. There is no crate-owned temporal invariant; each call must locally
+establish that its particular argument is nonzero.
+
+Profiles, optimization, debug assertions, and panic strategy do not select code
+here. There is no arithmetic, debug assertion, mutable state, destructor-held
+invariant, concurrency, allocation-sensitive unsafe operation, or unwinding
+cleanup obligation, so the proofs are parametric over those axes.
+
+## TCB and authoritative premises
+
+**BUILD-MAP-X (accepted, not widened):** exactly the proposition and scope in
+supplied `TCB.md`: Cargo 1.85.1 executes this build script as required; honors
+its rerun directive; check-cfg declares without setting; transmits emitted
+allocator cfgs; maps enabled `burst` and the three target triples as stated; and
+performs no library compilation after unsuccessful build-script exit. It is
+consumed only for reachability and rejection. It does not establish the emitted
+string, source correctness, abstract semantics, backend correctness, or a
+binary theorem. Any named input, Cargo/toolchain, source, target-set, or human
+disposition change triggers review.
+
+**AXIOM-NZ (Rust/std 1.85.1):**
+[`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)
+requires that its value “must not be zero”; zero produces undefined behavior.
+Consumers: O-03/O-04.
+
+**AXIOM-FLOW (Rust 1.85.1):** equality compares the operands, and an
+[`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)
+executes its consequent when its Boolean condition is true. The
+[`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html) macro panics
+the current thread. Consumers: O-03/O-05.
+
+**AXIOM-CFG/BUILD:** the version-matched cfg, feature, environment, output, and
+compile-error pages cited above supply only the propositions used in the
+configuration derivation. There are no safe/unsafe third-party dependencies,
+tool-derived facts, implementation premises, or other admitted assumptions.
+
+## Obligation ledger and proofs
+
+| ID | Proposition and complete domain | Derivation | Status |
+|---|---|---|---|
+| O-01 | Accepted selector yields exactly one supported cfg; rejected values yield no library compilation | `build.rs:9-20`, AXIOM-CFG/BUILD, BUILD-MAP-X | PROVED |
+| O-02 | `wasm32`+`arena`, either feature state, cannot ship | `lib.rs:15-16`, AXIOM-CFG/BUILD, BUILD-MAP-X | PROVED |
+| O-03 | Line 44 receives nonzero in all nine ordinary tuples | Its cfg is the complement of the special conjunction. If `value == 0`, lines 40-42 panic and line 44 is not reached; normal reach therefore entails `value != 0`, satisfying AXIOM-NZ. For nonzero, `new_unchecked` returns the corresponding `NonZeroU8`. | PROVED |
+| O-04 | Line 31 receives nonzero for every safe call in the special tuple | The `u8` parameter is caller-controlled and unchecked. `value = 0` is well typed and falsifies the required premise. | UNSOUND |
+| O-05 | Zero input panics | In ordinary tuples O-03 reaches `panic!`. In the special tuple line 31 instead reaches UB; that execution cannot prove or refute a defined postcondition. | PROVED ordinary / UNPROVED special |
+
+This also proves build-script source soundness: it contains no unsafe operation,
+and all branches use safe std APIs; its documented rejection behavior is
+covered by O-01.
+
+## F-01 — supported safe call violates `NonZeroU8` validity
+
+- **Affected claim/configuration:** public safe `lane_id`, all profiles/debug
+  states under `aarch64-unknown-linux-gnu` + `arena` + enabled `burst`.
+- **Proof artifact:** `lib.rs:30` says burst-mode identifiers are never zero.
+  That is an unsupported assertion about an arbitrary safe caller's `u8`, not
+  an invariant, check, type fact, or postcondition. The smallest false
+  implication is “this cfg conjunction and caller input imply `value != 0`.”
+- **UB witness:** BUILD-MAP-X makes lines 24-32 active and lines 34-45 absent.
+  A safe caller invokes `lane_id(0)`; line 31 calls `new_unchecked(0)`, which
+  AXIOM-NZ classifies as UB. No caller-side safety obligation exists.
+- **Defined postcondition refutation:** not established; the witness contains
+  UB. Hence soundness is `UNSOUND` and the special-tuple panic postcondition is
+  `UNPROVED`.
+- **Minimum repair:** remove the special case and use the checked path, or make
+  a zero check dominate line 31 (prefer safe `NonZeroU8::new(value)` plus the
+  documented panic). A comment-only or documentation-only change cannot repair
+  a safe API with a hidden safety precondition. After a check, suitable proof
+  text is: “Reaching this call means the preceding zero branch panicked, so
+  `value != 0`, satisfying `new_unchecked`'s safety precondition.” Re-audit all
+  ten tuples; the repair restores rather than weakens the published panic
+  behavior.
+
+## Residual scope and review triggers
+
+Excluded: unlisted targets, Rust/Cargo/std versions other than 1.85.1, manual
+cfg injection, and compiler/backend/binary behavior. No tool evidence was used.
+Review is invalidated by any source, manifest, support/build policy, allocator
+mapping, feature/target set, relevant Rust documentation, or BUILD-MAP-X change.
+Every in-scope surface, unsafe site, supported tuple class, mandatory documented
+behavior, and enforced exclusion has a disposition above; independent review
+was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r043/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r043/1/attestation.json
new file mode 100644
index 0000000000..e53672b0a4
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r043/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r043",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:57:18.745089Z",
+  "report_sha256": "6d839af7da1f3cf8f5de096c33c36a103337baf53057022f7adf806aec6f1594",
+  "run_id": "r043",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 973
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r043/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r043/1/report.md
new file mode 100644
index 0000000000..0b2bb295ea
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r043/1/report.md
@@ -0,0 +1,75 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Artifact.** The exact supplied `Cargo.toml`, `src/lib.rs`, `POLICY-SCARLET.md`, `POLICY-INDIGO.md`, and `TCB.md`; source-only review, cutoff 2026-08-01. No generated code, dependencies, build script, FFI, assembly, allocator, concurrency, or prior audit exists in the supplied snapshot. Nothing was built, expanded, run, or tested.
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let `f`/`h` denote `turbo`/`hardened`. Define the **conservative audit domain**
+
+`D = { (v,t,f,h,profile,debug_assertions) | v in V, t in T, f,h Boolean, every Cargo profile and either debug-assertion state, and !(f && t=W) }`.
+
+`D` is an audit domain, not a newly selected support policy.
+
+- **Safe-library soundness: PROVED over D**, relative to TCB log below: every well-typed safe call to `value_or_zero` is free of Rust undefined behavior.
+- **Documented result: PROVED over D:** `Some(x)` returns `x`; `None` returns zero.
+- **Combined mandatory result: PROVED over D.** There is no public unsafe API or additional unsafe-API postcondition.
+- **Exact project support predicate: UNPROVED.** Scarlet and Indigo are simultaneously current, conflict, and have no authorized resolution. Nevertheless, every configuration supported by either policy lies in `D`, so this governance gap does not weaken the two code verdicts.
+
+This is a Rust abstract-semantics result, not a backend, binary, or deployment claim.
+
+## Authorities and TCB audit log
+
+The version-matched standard-library contract says `is_none` reports whether the option is `None`, `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB, and `unwrap_or` returns the contained value or supplied default: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+For each release, the Reference defines configuration-option truth, `all`/`not`, and a `cfg` attribute's inclusion/removal effect: [1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute); [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute); [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). The corresponding standard-library macro pages specify compilation failure for `compile_error!`: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+
+| ID | Category/disposition | Exact admitted proposition; scope; consumers |
+|---|---|---|
+| `AXIOM-OPT-{84,85,86}` | Rust authority, verified | The preceding three `Option` method contracts, only for the matching release; `OBL-N`, `OBL-T`. Recheck if those documents or supported releases change. |
+| `AXIOM-CFG-{84,85,86}` | Rust authority, verified | The preceding `cfg` and `compile_error!` semantics, only for the matching release; `OBL-C`. Same trigger. |
+| `BUILD-MAP-C` | **OUT-OF-BAND/IMPLEMENTATION, explicitly human-accepted** | Exactly the feature-to-`cfg(feature=...)` and named-target-to-`target_arch` mappings stated in `TCB.md`, for the bundled Cargo of the three releases and supplied manifest/source; consumed only by `OBL-C`. It admits no Rust semantics, branch correctness, other version, or backend correctness. Recheck on every trigger listed in `TCB.md`. |
+
+No other implementation or build-tool premise is consumed. No tool-derived evidence is used.
+
+## Configuration closure
+
+Scarlet and Indigo each allow all non-`turbo` cases and restrict `turbo` to `X` or `A`; hence each predicate is a subset of `D`. Their union need not be declared the policy to establish this containment. `hardened`, profile, and debug assertions select no source here, so the proof is parametric in them.
+
+By `BUILD-MAP-C` and `AXIOM-CFG`, `f && t=W` makes the crate-level `cfg(all(...))` true, retains `compile_error!`, and compilation fails; no library artifact from that combination can ship. For every member of `D`, that item is removed. Exactly one function body remains: `f=false` retains `cfg(not(feature="turbo"))`; `f=true` retains `cfg(feature="turbo")`. This is an exhaustive partition. The source-admitted `v=1.84.0,t=A,f=true,h=false` case is outside both policies but is deliberately covered by `D`; its compilation does not silently make it supported.
+
+## Boundary, invariant, and obligation coverage
+
+The sole language-reachable crate surface is safe `pub fn value_or_zero(Option<u8>)->u8`, with the two mutually exclusive bodies above. There are no public fields, other constructors or methods, traits/impls, statics, reexports, callbacks, exported/generated macros, hidden APIs, or custom destruction. No persistent invariant-bearing state exists.
+
+`INV-LOCAL`: in the `turbo` body, after the `is_none()` branch falls through and until `unwrap_unchecked`, `value` is not `None`. The owned local is not mutated and no call intervenes.
+
+| ID | Proposition and derivation | Domain | Status |
+|---|---|---|---|
+| `OBL-C` | The preceding `cfg` partition is exhaustive and `turbo+W` is effectively rejected. | `V,T,f,h`, all profiles/debug states | PROVED |
+| `OBL-N` | With `f=false`, version-matched `unwrap_or(0)` returns the contained `u8` or zero; it is a safe standard-library call. | `D && !f` | PROVED |
+| `OBL-T` | With `f=true`, `is_none()==true` returns zero. Fallthrough means not `None`, establishing `INV-LOCAL` and satisfying `unwrap_unchecked`; that method returns the contained byte. | `D && f` | PROVED |
+| `OBL-API` | `OBL-C` partitions `D`; `OBL-N` and `OBL-T` cover both parts with no caller safety precondition. | `D`, all safe inputs | PROVED |
+
+The result guarantee follows in both bodies. No panic/unwind, alias, lifetime, arithmetic, zero-sized, concurrency, target-layout, or allocator obligation remains.
+
+## Findings
+
+### `DOC-1` — adjacent proof is materially incomplete
+
+**Implementation: PROVED; proof artifact: deficient.** The existing comment says only that the `None` case returned. It omits the exact `is_none` proposition, the callee's UB condition, and the returned-value postcondition. A proof-grade replacement is:
+
+```rust
+// SAFETY: By AXIOM-OPT for this supported release, `is_none` reports `None`.
+// Reaching here therefore means `value` is not `None`, satisfying
+// `unwrap_unchecked`; that operation returns the contained byte.
+```
+
+No UB witness or defined postcondition refutation is established. Repair is documentation-only; re-audit the local proof if code or cited contracts change.
+
+### `POLICY-1` — exact support identity unresolved
+
+**Status: UNPROVED configuration-policy proposition, not an implementation defect.** The smallest missing fact is an authorized precedence, supersession, or reconciliation rule between Scarlet and Indigo. Publish one to define the exact supported set. Re-audit code only if the resolution admits configurations outside `D`; otherwise revisit the policy statement and containment proof.
+
+## Residual scope and triggers
+
+Configurations outside the three stated releases/targets and binary/backend correctness are excluded. Both-policy-unsupported but source-admitted configurations are not claimed supported, although the one within the stated axes is covered by `D`. Re-audit on source/manifest or public-contract changes; support-policy resolution/expansion; Cargo mapping/TCB disposition changes; Rust-document changes; or any new generated code, dependency, target, feature, or unsafe surface. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r044/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r044/1/attestation.json
new file mode 100644
index 0000000000..86ad9a75ef
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r044/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r044",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T06:57:26.519698Z",
+  "report_sha256": "a7f109ef70b6a8ac7b471cc4a3122f4b8e2f92b45305f0f419ead77cf670528e",
+  "run_id": "r044",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 981
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r044/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r044/1/report.md
new file mode 100644
index 0000000000..8a2dabc4db
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r044/1/report.md
@@ -0,0 +1,63 @@
+# Focused unsafe-Rust source review
+
+## Claims, scope, and verdicts
+
+**Snapshot.** The artifact is exactly the inspected `target/lib.rs`; `REQUEST.md` and `EVIDENCE.md` control scope and evidence. No repository, generated output, dependencies, manifests, expansions, or build artifacts were inspected or assumed. This was a source-only review: nothing was built, tested, executed, or edited. Audit date: 2026-08-01. Skill identity: the submitted `unsafe-rust` package, with no revision identifier supplied.
+
+Let `T` be every target on which this exact source and Rust 1.80.0's `std::hint::unreachable_unchecked` exist. The exact required configuration domain is
+
+`D = {exact lib.rs} × {Rust and std 1.80.0} × T × {ordinary debug, ordinary release}`,
+
+and inputs are all `u8` values. This preserves the request's symbolic target predicate; no finite target inventory is inferred. Valid use means every well-typed safe call to the public safe function, with no hidden caller obligation.
+
+| Claim | Exact theorem over `D` | Verdict |
+|---|---|---|
+| `SOUND` | For every input and every permitted execution of `classify(input)`, the execution is free from Rust undefined behavior. | **UNSOUND** (`F-UB-0`) |
+| `PANIC-0` | Every valid call `classify(0)` panics. | **UNPROVED** (`F-PANIC-0`) |
+| `RETURN` | Whenever `classify(input)` returns normally, its result equals `input`. | **CONTRACT-BROKEN** (`F-RETURN-1`) |
+
+The combined mandatory result is therefore not proved. These verdicts are source-level Rust results, not claims about a compiler backend or binary.
+
+## Boundary and obligation inventory
+
+The complete language-reachable API surface in the supplied source is the safe public free function `classify(u8) -> u8` (`lib.rs:6-17`) and its two documented guarantees (`lib.rs:3-5`). There are no exposed fields, constructors, types, traits or impls, macros, reexports, hidden items, callbacks, FFI, statics, operators, or generated APIs. The sole unsafe obligation site is `unreachable_unchecked` at line 12. The local `marker` assignments neither exit nor establish an invariant.
+
+The callee's exact safety requirement is that its site not be reached. No invariant owns or establishes that proposition. Instead, source control flow gives this exhaustive input partition:
+
+| Input | Soundness | Zero-panic guarantee | Normal-return guarantee |
+|---|---|---|---|
+| `0` | **UNSOUND**: reaches the unsafe call. | **UNPROVED**: the same UB-containing execution is not a contract-refutation witness. | **UNPROVED for this case**: UB prevents a postcondition certificate or UB-free refutation. |
+| `1` | **PROVED for this case**: branch returns the valid `u8` literal `2`; no unsafe site is reached. | Not applicable; antecedent `input == 0` is false. | **CONTRACT-BROKEN**: normal result `2 != 1`. |
+| `2..=255` | **PROVED for this case**: `_` returns the valid input and no unsafe site is reached. | Not applicable. | **PROVED for this case**: the returned expression is exactly `input`. |
+
+This partition is exhaustive because `u8` values are `0`, `1`, or `2..=255`. It is parametric over `T` and both profiles: the source has no `cfg`, profile-dependent assertion, arithmetic, allocation, panic-mode branch, target feature, generated code, or target-dependent operation. Thus the regional affirmative proofs cover all of `D` for their stated input regions. Claim-level `SOUND` is refuted by the `0` region; `PANIC-0` has no covered proof region; `RETURN` is independently refuted by the `1` region.
+
+## Proof certificates and findings
+
+### `F-UB-0` — reachable `unreachable_unchecked`
+
+- **Valid in-scope use:** `classify(0)` is a call to a safe public function with a valid `u8`; it has no caller safety precondition.
+- **Reachability:** matching `0` selects the first arm. The two `marker` statements complete, and evaluation reaches line 12 on every configuration in `D`.
+- **False safety proposition:** the call site must be unreachable, but the preceding derivation proves it reachable.
+- **UB consequence:** Rust 1.80.0 documents: “Reaching this function is Undefined Behavior.” ([standard-library Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)). The Rust 1.80.0 Reference explains that unsafe code triggerable by safe code to exhibit UB is unsound ([UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)).
+
+All existential links are established, so this witness proves `SOUND` **UNSOUND**. The existing comment merely assumes the negation of demonstrated control flow; its proof-artifact classification is deficient and its implementation classification is unsound. Minimum repair: make the zero arm perform a defined panic, not `unreachable_unchecked`.
+
+### `F-PANIC-0` — UB is not a panic-contract witness
+
+The exact candidate is `classify(0)`, but its execution reaches UB. A whole execution containing UB may establish unsoundness; it cannot establish `CONTRACT-BROKEN`, which requires a valid UB-free execution falsifying the postcondition. No independent UB-free zero-input execution or proof that zero input panics exists in the inspected source. Therefore the panic guarantee is **UNPROVED**, not `CONTRACT-BROKEN`. Replacing line 12 with a defined panic would establish it.
+
+### `F-RETURN-1` — wrong defined normal result
+
+`classify(1)` is a valid safe call. The `1 => 2` arm returns normally without reaching any unsafe operation, so the whole witness is UB-free. Its result is `2`, while the documented result is the unchanged input `1`. This complete witness proves `RETURN` **CONTRACT-BROKEN** over every configuration in `D`. It proves no unsoundness. Minimum repair: return `input` (or `1`) from this arm.
+
+## TCB audit log (`TCB-1`)
+
+| ID | Category and exact proposition | Identity/scope | Disposition; consumers |
+|---|---|---|---|
+| `AX-UU` | Rust axiom: reaching `unreachable_unchecked` is UB. | Linked Rust 1.80.0 std page; all `D` per supplied applicability statement. | Accepted after direct verification; `F-UB-0`. |
+| `AX-SOUND` | Rust axiom: unsafe code that safe code can trigger to exhibit UB is unsound. | Linked Rust 1.80.0 Reference; all `D` per supplied applicability statement. | Accepted after direct verification; `SOUND`. |
+
+No dependency, implementation, tool, environment, probabilistic, or compiler-backend premise is consumed. The exact supplied proposition that both pages apply throughout `D` is accepted as the task's scope premise. Re-audit is required if source/docs, Rust or std version, target/item-existence predicate, profile set, or either consumed authority changes. Binary behavior, other toolchains/profiles, and targets outside `T` remain excluded. No authoritative-documentation or skill-guidance gap blocked these conclusions.
+
+**Attestation:** every in-scope surface, input case, unsafe obligation, requested postcondition, configuration axis, premise, negative certificate, and residual exclusion has a disposition above. No test result or absence of a counterexample is used.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r045/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r045/1/attestation.json
new file mode 100644
index 0000000000..39c3932c25
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r045/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r045",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:05:56.310388Z",
+  "report_sha256": "759b413defb47d8ad4c15c08233757841f374762b686d51515a8eddcd5ac1989",
+  "run_id": "r045",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 822
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r045/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r045/1/report.md
new file mode 100644
index 0000000000..6b32e1d398
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r045/1/report.md
@@ -0,0 +1,110 @@
+# Focused source-only unsafe Rust review
+
+## Claim frame and snapshot
+
+Scope is exactly the two exported functions in the supplied `lib.rs`. The
+source snapshot consists of the submitted `lib.rs` and manifest, with edition
+2021 and the exact requirement `peer-unsafe-dep = "=3.4.5"`. The submitted
+dependency record identifies the resolved package as `peer-unsafe-dep` 3.4.5
+and supplies its declaration and public contract, but no implementation,
+generated output, binary, or prior audit.
+
+Let `C` be: Rust compiler and standard library 1.80.0; every target on which
+this exact source and exact dependency resolve; and every ordinary debug or
+release profile. There are no source `cfg`s, features, generated artifacts, or
+profile-dependent branches in the submitted crate. The source arguments below
+are therefore parametric over target and profile. Dependency-side target or
+generated variation is inaccessible and is not assumed away.
+
+The only public surfaces are the safe free function `force_unreachable` and
+the unsafe free function `delegated_nonzero`; there are no public fields,
+constructors, methods, traits, macros, callbacks, or invariant-bearing state.
+No build, test, execution, expansion, or tool-derived evidence was used.
+
+Combined result: **UNSOUND** for `force_unreachable`; **UNPROVED** for
+`delegated_nonzero`. There is no whole-scope `PROVED` result.
+
+## Claim 1: `force_unreachable`
+
+**Exact claim.** For every configuration in `C`, every well-typed safe
+invocation, with no caller-side safety precondition, has no Rust undefined
+behavior.
+
+**Verdict: UNSOUND**, throughout `C`.
+
+**Complete refutation.** `lib.rs:4` exports an ordinary safe function with no
+arguments or checked branch. Every invocation reaches `lib.rs:6`, which
+unconditionally calls `std::hint::unreachable_unchecked`. The independently
+opened Rust 1.80.0 standard-library Safety section states: “Reaching this
+function is Undefined Behavior.”
+([versioned authority](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+Thus a safe program that calls `force_unreachable()` is a valid in-domain use
+whose execution reaches undefined behavior. The same source-level derivation
+applies on every target/profile in `C`; optimization behavior is irrelevant.
+
+The adjacent comment, “This site is assumed to be unreachable,” proves no
+dominating fact and is contradicted by the public safe entry path. This is both
+an implementation defect and a missing/false proof artifact. A minimum repair
+must remove the reachable `unreachable_unchecked` operation (for example, use a
+defined diverging behavior); merely strengthening the comment cannot repair a
+safe API. Because the witness contains UB, it does not establish a separate
+UB-free documented-postcondition refutation.
+
+## Claim 2: `delegated_nonzero`
+
+**Exact valid-use claim.** For every configuration in `C`, every invocation of
+`delegated_nonzero(value)` for which the unsafe caller establishes the complete
+documented obligation `value != 0` is free of Rust undefined behavior. No
+ongoing or terminal caller obligation is documented.
+
+**Verdict: UNPROVED**, throughout `C`; neither `UNSOUND` nor `PROVED` is
+justified by this packet.
+
+**Local derivation and precise gap.** At `lib.rs:14`, valid use gives the local
+fact `value != 0`. At `lib.rs:17`, that identical `u8` value is passed directly
+to `peer_unsafe_dep::duplicate_nonzero`. The submitted dependency contract's
+sole caller-side safety clause is also `value != 0`. Therefore the wrapper's
+call-site precondition is completely discharged for every nonzero `u8`, target,
+and profile in `C`; the local SAFETY comment accurately records this step.
+
+That step is not a proof of the unsafe dependency implementation. Full
+soundness additionally requires the following smallest missing proposition:
+
+> **DEP-IMPL.** For `peer-unsafe-dep` 3.4.5 as exactly resolved, on every target
+> and ordinary debug/release profile in `C`, every execution of
+> `duplicate_nonzero(v)` with `v != 0` is free of Rust undefined behavior.
+
+No supplied source or universal evidence proves DEP-IMPL, and the human trust
+decision expressly declines an `UNSAFE-DEP` assumption for it. The exact pin
+fixes package version but does not establish undocumented implementation
+correctness. The published unsafe caller contract establishes what this crate
+must pass; it does not establish that the unavailable body fulfills its
+promise. No valid UB witness is supplied either, so the fail-closed result is
+`UNPROVED`, not `UNSOUND`.
+
+The wrapper's Safety section states a precondition, not a result
+postcondition. Its summary's “delegates” description is realized syntactically
+by the direct call. The dependency separately promises “Returns `value`.” If
+same-value return behavior is consumed as a wrapper guarantee, it is also
+**UNPROVED**: DEP-IMPL must be strengthened to say that every such call returns
+`v` on normal return. There is no independent UB-free refutation, so
+`CONTRACT-BROKEN` is not established.
+
+## TCB and coverage ledger
+
+| ID | Proposition and scope | Disposition | Consumers |
+|---|---|---|---|
+| AXIOM-UR-1 | The quoted Rust 1.80.0 `unreachable_unchecked` Safety proposition, all targets/profiles in `C` | Accepted after direct citation verification | Claim 1 |
+| DEP-IMPL | Exact dependency proposition stated above | Expressly not accepted; no implementation evidence | Claim 2 |
+
+Obligation coverage: Claim 1's only unsafe-operation precondition fails on its
+public entry path. Claim 2's dependency call precondition is proved, while
+dependency implementation soundness remains open. No other local unsafe sites,
+state transitions, mandatory unsafe-API postconditions, or configuration
+branches appear in the submitted crate.
+
+Residual scope is the unavailable dependency implementation and any of its
+target/generated variants. Re-audit is required if either function or its
+documentation changes, Rust or the supported domain changes, dependency
+identity/contract/features/generated output changes, dependency source or an
+accepted audit becomes available, or the TCB trust decision changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r046/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r046/1/attestation.json
new file mode 100644
index 0000000000..76e1bdd710
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r046/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r046",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:07:23.366359Z",
+  "report_sha256": "1409aa1649cd9e0950368deb23ade05351c03b9ab89a32e637514b9d43293e22",
+  "run_id": "r046",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 930
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r046/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r046/1/report.md
new file mode 100644
index 0000000000..4cbfc96a7a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r046/1/report.md
@@ -0,0 +1,141 @@
+# Unsafe Rust source audit
+
+## Claim and verdicts
+
+The audited artifact is exactly the supplied `Cargo.toml`, `src/lib.rs`, two
+published policies, and `TCB.md`; no repository identity is asserted. For every
+well-typed safe call to `value_or_zero` in every configuration in `Required`
+below, under Rust's documented source semantics and relative only to the TCB
+listed below:
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Freedom from Rust undefined behavior | **PROVED** | OBL-1--4 and `Required ⊆ Covered` |
+| Documented result: contained byte for `Some`, zero for `None` | **PROVED** | OBL-2--4 |
+| One resolved project support predicate | **UNPROVED** | Scarlet and Indigo conflict and no resolution is authorized |
+
+The strongest non-policy-selecting conclusion is therefore source soundness
+and the stated behavior over the conservative union of both commitments. This
+does not resolve or redefine the project's support promise. No backend,
+binary, compiler-implementation, performance, or other robustness claim is
+made.
+
+## Snapshot, boundary, and inventory
+
+The crate is edition 2021, `no_std`, has no dependencies or generators, and
+declares independent `turbo` and `hardened` features. Rust/stdlib versions are
+exactly 1.84.0, 1.85.0, and 1.86.0. The complete language-reachable crate-owned
+surface is one safe public free function, with mutually exclusive
+`#[cfg(not(feature = "turbo"))]` and `#[cfg(feature = "turbo")]` definitions.
+There are no fields, constructors, traits/impls, callbacks, FFI, statics,
+reexports, hidden items, exported macros, generated APIs, or owned invariants.
+The only unsafe operation is the turbo definition's
+`Option<u8>::unwrap_unchecked`. The `compile_error!` invocation is an internal
+configuration-rejection site.
+
+## Required-domain recovery and effective rejection
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}`, and let `f,h` have the meanings in
+the policies. Preserve the controlling predicates:
+
+```text
+I = !f or (f and t=X and (h or v>=1.86.0))
+         or (f and t=A and !h and v>=1.85.0)
+S = !f or (f and t=X and (!h or v>=1.85.0))
+         or (f and t=A and h)
+```
+
+With the shared `v∈V`, `t∈T`, Boolean `f,h`, all profiles, and both debug-
+assertion states, choose only the conservative audit predicate
+`Required = I ∪ S`. Exact normalization gives:
+
+```text
+Required = !f or (f and t=X)
+              or (f and t=A and (h or v>=1.85.0)).
+```
+
+Proof of equality: `!f` is common; neither policy admits `f∧t=W`; for `f∧t=X`,
+Indigo admits `h` at 1.84 while Scarlet admits `!h`, Scarlet admits both states
+from 1.85, and both admit both at 1.86; for `f∧t=A`, Scarlet admits `h` at every
+version and Indigo adds `!h` exactly from 1.85. Thus both `I⊆Required` and
+`S⊆Required`, without selecting either policy.
+
+BUILD-MAP-C establishes, only for the three versions, named targets, features,
+and profiles, that Cargo features and `target_arch` set the corresponding cfgs.
+The version-matched Reference says a true cfg predicate includes its item and a
+false one removes it ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute));
+`compile_error!` causes compilation to fail when encountered
+([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+[1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+[1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). Therefore
+every `f∧t=W` case is effectively rejected before a library artifact can ship,
+in every profile/debug-assertion state. Both policies already exclude those
+cases; the proof does not silently enlarge either promise. No other policy
+exclusion is source-enforced, nor is enforcement needed for this union proof.
+
+## Obligation ledger and derivations
+
+| ID | Proposition and proof | Domain | Status |
+|---|---|---|---|
+| OBL-1 | cfg selection/rejection has the behavior above, from version-matched cfg and macro axioms plus BUILD-MAP-C | all policy axes | PROVED |
+| OBL-2 | Non-turbo `unwrap_or(0)` returns the `Some` byte or `0` for `None` | `Required∧!f` | PROVED |
+| OBL-3 | At `unwrap_unchecked`, `value` is not `None`; the dominating `is_none()` true branch returned, and `Option` has only `None` and `Some` | `Required∧f` | PROVED |
+| OBL-4 | The unchecked call returns the contained byte; combining OBL-2/3 proves the public postcondition | all `Required` | PROVED |
+
+For each exact release, `is_none` “returns true” for `None`,
+`unwrap_unchecked` returns the contained `Some` value and calling it on `None`
+is undefined behavior, and `unwrap_or` returns the contained value or supplied
+default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or);
+[1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or);
+[1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+These are an exhaustive release partition, not compatibility extrapolation.
+
+For `f=false`, OBL-2 applies parametrically to every target, `h`, profile, and
+assertion state. For `f=true`, OBL-3/4 do likewise wherever `Required` admits
+X or A. The source has no arithmetic, assertions, target-dependent unsafe
+semantics, or other branches affected by remaining axes. Hence aggregate
+`Covered = Required`, proving `Required ⊆ Covered`.
+
+## TCB audit log
+
+- **BUILD-MAP-C — IMPLEMENTATION/build-tool mapping, accepted.** Exact
+  proposition, identities, consumers, exclusions, and triggers are those in
+  supplied `TCB.md`. It is consumed only by OBL-1 and domain reachability. It
+  supplies no Rust semantic or branch-correctness fact.
+- **AX-OPT-184/185/186 and AX-CFG-184/185/186 — AXIOM.** Exact propositions are
+  the narrow versioned Rust documentation statements cited above; consumers
+  are OBL-1--4. Applicability is one named release each.
+
+No other trust, dependency, tool result, test, or execution evidence is used.
+
+## Findings and residual scope
+
+**DOC-1 — deficient adjacent proof, implementation still proved.** The current
+comment states the crucial control-flow fact but does not name the unchecked
+operation's exact precondition. Suggested replacement:
+
+```rust
+// SAFETY: `unwrap_unchecked` requires `value` not be `None`.
+// `is_none()` is true exactly for `None`; that branch returned, so here
+// `value` is `Some(_)`.
+```
+
+**POLICY-1 — unresolved support identity.** The smallest missing proposition is
+an authorized rule selecting, superseding, or reconciling Scarlet and Indigo.
+This blocks a claim about the one true project promise, but not the proved
+conservative-union source theorem.
+
+No target was built, run, tested, or macro-expanded. Custom targets, other Rust
+versions, backend/binary correctness, and configurations outside both policies
+are excluded. Re-audit on any source, manifest, policy/resolution, TCB
+disposition/mapping, supported version/target/feature/profile, or cited Rust
+contract change. Every in-scope surface, obligation, postcondition, premise,
+and unresolved claim has a disposition above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r047/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r047/1/attestation.json
new file mode 100644
index 0000000000..9071798a66
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r047/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r047",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:07:29.049036Z",
+  "report_sha256": "6a4721ff173210588f9720b233d83c613ca6e460b15e46c52b311793b090f9d2",
+  "run_id": "r047",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 1000
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r047/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r047/1/report.md
new file mode 100644
index 0000000000..08828c4235
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r047/1/report.md
@@ -0,0 +1,124 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and aggregate result
+
+This is a source-level review of the supplied `lib.rs` snapshot, at the
+2026-07-31 support cutoff, relative only to `EVIDENCE.md` and accepted TCB
+entries `SEM-EMPTY-BLOCK-180-182` and `COMPAT-COPY-180-182`. It covers all four
+exported unsafe functions, their caller contracts, UB freedom for every valid
+call, and every stated result. It makes no compiler-backend, binary, deployment,
+or broader robustness claim. There are no dependencies, generated artifacts,
+features, conditional source paths, stateful invariants, safe wrappers, fields,
+traits, macros, or other exported surfaces in the supplied source.
+
+Let `T_f(v)` mean every target on which item `f` exists, and let
+`P={ordinary-debug, ordinary-release}`. For each API,
+`Required_f={(v,t,p) | v in V_f, t in T_f(v), p in P}`. `SUPPORT.md` directly
+defines each `V_f` as an exact finite set, so no interval interpolation or
+enumeration inference is used. Target and profile are semantic parameters: the
+source has no branch on either, and every cited authority or consumed TCB entry
+applies to all such cases in its stated release region.
+
+| API | `V_f` | Exact aggregate `Covered` release region | Soundness | Documented results | Strongest API verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `V_f` | **PROVED** | return `()`: **PROVED** | **PROVED** |
+| `store_word` | `{1.80.0,1.81.0}` | all `V_f` | **PROVED** | stores `value`: **PROVED**; old `u16` is neither read nor dropped: **PROVED** | **PROVED** |
+| `copy_byte` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `V_f` | **PROVED** | destination receives the source byte: **PROVED**; source is preserved: **PROVED** | **PROVED**, relative to `COMPAT-COPY-180-182` |
+| `load_word` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | `{1.80.0,1.82.0}` | **UNPROVED** over `Required`; **PROVED** on `Covered` | returned value and unchanged source: each **UNPROVED** over `Required`, **PROVED** on `Covered` | **UNPROVED** |
+
+Thus the combined four-API mandatory claim is **UNPROVED**, solely because
+`Required_load` is not contained in `Covered_load`. No submitted fact proves a
+valid UB witness or a UB-free postcondition counterexample, so neither
+`UNSOUND` nor `CONTRACT-BROKEN` is certified.
+
+## Obligation ledger and proofs
+
+**ACK-S/Q.** The caller contract imposes no additional safety requirement, and
+the exact body is `{}`. `SEM-EMPTY-BLOCK-180-182` applies to precisely all four
+releases, all item-bearing targets, and both profiles; the checked empty body
+connects the source to its admitted proposition that evaluation is defined and
+returns `()`. Hence `Required_ack = Covered_ack` for soundness and return.
+
+**STORE-S.** The only operation is `ptr::write::<u16>(dst,value)`. The public
+contract supplies its two documented safety clauses: `dst` is properly aligned
+and valid for one `u16` write. The 1.80.0 and 1.81.0 `ptr::write` authorities
+apply separately to the two members of `V_store`; their exhaustive union is
+`Covered_store=V_store`. A typed `u16` supplies the value passed to the exact
+call. Soundness is therefore proved.
+
+**STORE-Q1/Q2.** Those same two release-specific pages state that `write`
+overwrites the destination with the given value without reading or dropping
+the old value. The direct call has no later transition, proving both documented
+results over the same exhaustive union.
+
+**COPY-S.** Locally, `T=u8` and `count=1`; the caller contract establishes
+initialized readable source, writable destination, alignment, and non-overlap
+for the one-byte regions. The 1.80.0 `copy_nonoverlapping` contract, primitive
+layout, `u8: Copy`, and `Copy` semantics establish the base case.
+`COMPAT-COPY-180-182` explicitly preserves those exact propositions for every
+member of `V_copy`, target, and profile, and is authorized only for this call.
+Thus `Covered_copy=V_copy` and soundness is proved.
+
+**COPY-Q1/Q2.** The same accepted entry expressly guarantees that this exact
+call copies exactly one byte to `dst`, leaves the source byte unchanged, and
+does not move ownership from it. These propositions directly establish both
+documented results throughout `Required_copy`.
+
+**LOAD-S/Q.** The only operation is `ptr::read::<u32>(src)`. The caller contract
+provides readable validity, alignment, and initialization. At 1.80.0, that
+release's `read`, `u32: Copy`, and `Copy` pages prove a defined read returning
+the source value while leaving source memory unchanged. The parallel 1.82.0
+pages prove the same case at 1.82.0. Therefore each soundness and result
+obligation has `Covered={1.80.0,1.82.0}` (with all corresponding targets and
+profiles). No authority applies at 1.80.1 or 1.81.0, and `TCB.md` explicitly has
+no `read` compatibility entry. Endpoint facts do not cover the interior.
+
+## Evidence and TCB audit log
+
+All authority entries are accepted versioned Rust standard-library/Reference
+premises with exactly the claim-specific applicability stated in `EVIDENCE.md`:
+[write 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and
+[write 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html);
+[copy_nonoverlapping 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html),
+[primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout),
+[u8: Copy](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8),
+and [Copy semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html);
+and `read`, `u32: Copy`, and `Copy` semantics at
+[1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html), with the
+corresponding versioned primitive/trait pages identified in `EVIDENCE.md`. No
+entry is transferred between operations.
+
+| TCB ID | Disposition and exact use | Limit / trigger |
+|---|---|---|
+| `SEM-EMPTY-BLOCK-180-182` | accepted; defined evaluation and `()` return of an exact empty-body unsafe function over `V_ack` | only `ACK-S/Q`; any signature, body, contract, release-set, or disposition change |
+| `COMPAT-COPY-180-182` | accepted; preserves the enumerated 1.80 copy/layout/Copy propositions over all `V_copy` | only `COPY-S/Q`; any call/type/count/base proposition/release-set/disposition change |
+
+No tool-derived evidence, test result, sampled configuration, or unlisted
+assumption contributes to a verdict.
+
+## Findings, proof artifacts, and residual scope
+
+**F-LOAD-COVERAGE — UNPROVED.** The smallest missing proposition is: for each
+`v in {1.80.1,1.81.0}`, `ptr::read::<u32>` under the documented caller clauses
+is defined, returns the read value, leaves the source unchanged, and the needed
+`u32: Copy` semantics apply, for every supported target/profile. Resolution
+requires applicable versioned authorities or an accepted, exact compatibility
+premise; testing or endpoint interpolation is insufficient. Re-audit all
+`load_word` claims after resolution.
+
+The three local `SAFETY` comments identify their callees but omit the material
+release-applicability and, for copy/read, layout/`Copy` bridges and TCB route.
+Implementation status remains as above, but the proof artifacts are deficient.
+Minimum documentation repair is to cite stable canonical proofs containing the
+corresponding ledger derivation; this cannot repair `F-LOAD-COVERAGE` without
+new evidence.
+
+Residual scope is exactly nonlisted Rust releases, nonordinary profiles,
+targets where an item does not exist, backend/binary correctness, and behavior
+beyond the stated results. Re-audit on source or contract changes, support-set
+changes, material authority changes, or either TCB entry's trigger.
+
+**Attestation:** every in-scope surface, safety obligation, documented result,
+release case, and consumed premise has a disposition; affirmative claims have
+`Required subseteq Covered`, and the unresolved remainder remains explicit.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r048/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r048/1/attestation.json
new file mode 100644
index 0000000000..62b851dd00
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r048/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r048",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:15:39.128346Z",
+  "report_sha256": "36c357bebb8df0544f587b00a99169a56e62e1d1386c18984697ae62001ef573",
+  "run_id": "r048",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 910
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r048/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r048/1/report.md
new file mode 100644
index 0000000000..bcdc7d4fa2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r048/1/report.md
@@ -0,0 +1,111 @@
+# Focused unsafe-Rust source audit
+
+## Snapshot, scope, and domain
+
+Audited artifact: the submitted `lib.rs` for `quantifier-target` 0.1.0
+(edition 2021), its submitted manifest, dependency contract, evidence packet,
+and trust decision. The manifest selects exactly `peer-unsafe-dep` 3.4.5. No
+dependency implementation, generated output, lockfile, prior audit, binary, or
+tool result was supplied or inspected. Review cutoff: 2026-08-01. This is a
+source-level Rust-abstract-semantics review only.
+
+Let
+
+`C = {Rust 1.80.0} × Tresolve × {ordinary debug, ordinary release}`,
+
+where `Tresolve` is exactly the set of targets on which this submitted source
+and the submitted exact dependency resolution resolve. This preserves the
+request's symbolic target predicate; it is not replaced by an unevidenced
+inventory. There are no `cfg`, feature, target, profile, macro, build-script, or
+generated-source branches in `lib.rs`. The arguments below are parametric in
+every `c ∈ C`: neither source reachability nor the value passed to the peer call
+depends on target or profile. Thus those arguments cover all of `C` without
+sampling.
+
+The complete exported surface is the two free functions below. There are no
+exported fields, types, traits, methods, statics, macros, hidden items, FFI
+entrypoints, callbacks, or generated APIs in the submitted source.
+
+## Claims and verdicts
+
+| Claim | Exact valid uses and theorem | Verdict |
+|---|---|---|
+| `force_unreachable` (`lib.rs:4-7`) | For every `c ∈ C` and every well-typed safe call to this safe, argument-free function (there is no caller safety precondition), the execution is free of Rust UB. | **UNSOUND**, throughout `C`. |
+| `delegated_nonzero` (`lib.rs:14-18`) | For every `c ∈ C` and every unsafe call with `value: u8` satisfying the complete documented safety precondition `value != 0`, the execution is free of Rust UB. There are no stated ongoing or terminal caller obligations. | **UNPROVED**, throughout `C`. |
+
+No broader safe-API robustness property was requested. If the peer contract's
+“Returns `value`” is treated as a mandatory consumed provider postcondition,
+that postcondition is also **UNPROVED**; no UB-free counterexample establishes
+`CONTRACT-BROKEN`.
+
+## Proof certificates and obligation ledger
+
+### `force_unreachable`: complete existential UB certificate
+
+1. **Valid in-scope use.** For arbitrary `c ∈ C`, a safe program may call
+   `force_unreachable()`; the item is `pub fn`, takes no argument, and exposes
+   no unsafe obligation. Such a call is therefore a valid well-typed safe use.
+2. **Reachability.** Entry executes the body, whose only statement is the
+   unconditional call to `std::hint::unreachable_unchecked()` at `lib.rs:6`.
+   There is no branch, return, panic, callback, or dependency operation before
+   it. The unsafe operation is reached.
+3. **False required proposition.** The call requires that its site not be
+   reached. Step 2 proves the opposite. The comment “This site is assumed to be
+   unreachable” supplies no fact and is false for every invocation.
+4. **UB consequence.** The verified Rust 1.80.0 standard-library Safety text
+   states: “Reaching this function is Undefined Behavior.” Therefore the valid
+   call reaches UB. The reasoning is source-, target-, and profile-parametric,
+   so every member of `C` has this witness.
+
+This satisfies every link required for `UNSOUND`; it is not merely a failed
+universal proof. The minimal correction is to remove the unchecked-unreachable
+operation (for example, use a defined panic) or move a sufficient, enforced
+unreachability obligation to an unsafe API. Rewording the current safety
+comment cannot repair the safe implementation.
+
+### `delegated_nonzero`: exact closed and open obligations
+
+- **D1—peer caller precondition: PROVED locally over `C`.** A valid wrapper call
+  has `value != 0` by `lib.rs:11-13`. The exact submitted peer contract requires
+  precisely `value != 0`. `lib.rs:17` passes the same `u8` without mutation or
+  intervening code. Hence the wrapper satisfies the peer call's documented
+  caller-side safety precondition. The adjacent comment adequately records
+  this local implication.
+- **D2—peer provider soundness: UNPROVED over all `C`.** Calling a third-party
+  unsafe API also requires establishing that its exact implementation fulfills
+  its promise for valid calls. The smallest missing proposition is:
+  `for every c ∈ C and every v: u8 with v != 0, peer-unsafe-dep 3.4.5's exact
+  duplicate_nonzero(v) implementation executes without Rust UB`.
+  Neither declaration nor caller contract proves that implementation theorem.
+  The body and prior audit are unavailable, and the submitted human decision
+  expressly declines an `UNSAFE-DEP` assumption. Consequently aggregate
+  `Covered` for this claim contains no configuration under the admitted
+  premises, so `Required = C × {v | v != 0}` is not contained in `Covered`.
+- **D3—return guarantee: UNPROVED if in scope.** The wrapper returns the peer
+  result unchanged, so the peer implementation's promised `result == value`
+  would entail the same result. The missing provider theorem must additionally
+  establish that equality. No UB-free falsifying execution was supplied, so
+  absence of proof is not `CONTRACT-BROKEN` or `UNSOUND`.
+
+Accepting a precisely scoped `UNSAFE-DEP` entry for D2/D3, recursively auditing
+the exact dependency implementation, or replacing the call with a proved
+implementation is necessary to close this claim. The local safety comment
+cannot establish provider correctness.
+
+## TCB and evidence disposition
+
+- **AXIOM-UU-1 — accepted.** Rust 1.80.0 `std::hint::unreachable_unchecked`
+  Safety documentation, independently opened at the exact supplied URL:
+  https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety.
+  Exact consumed proposition: reaching the function is UB. Scope supplied and
+  admitted by `EVIDENCE.md`/`TCB.md`: Rust 1.80.0, all targets and ordinary
+  profiles. Consumer: the `force_unreachable` certificate.
+- **UNSAFE-DEP-PEER-345 — rejected/not admitted.** Proposed proposition would
+  be D2 (and D3 if return behavior is claimed) for exact package 3.4.5 over
+  `C`. `TCB.md` expressly declines it; it supports no affirmative verdict.
+- No implementation, compatibility, tool, environment, deployment, or
+  probabilistic premise is admitted. No test or tool evidence contributes.
+
+Re-audit is required if either function or its documentation changes, the Rust
+version/domain changes, the peer version/contracts/features/implementation or
+trust disposition changes, or generated/configuration-dependent code is added.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r049/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r049/1/attestation.json
new file mode 100644
index 0000000000..1a5d3ca047
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r049/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r049",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:24:22.997302Z",
+  "report_sha256": "c9ca30c994fb58edbe9566764dbe3b28fac599dbda40a1d6603a7862e4a5620e",
+  "run_id": "r049",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1097
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r049/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r049/1/report.md
new file mode 100644
index 0000000000..af86a361c9
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r049/1/report.md
@@ -0,0 +1,62 @@
+# Unsafe Rust Audit: `cross-axis-target` 0.1.0
+
+## Claim and verdict
+
+This is a source-level audit of the complete supplied crate (`Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`) under Rust/Cargo/stdlib 1.85.1 and the Rust abstract semantics. For every well-typed safe call to `lane_id` in every supported configuration, the soundness claim is absence of Rust undefined behavior; documented behavior is also in scope.
+
+**Overall soundness: UNSOUND (F-1).** The supported region `B = {target=aarch64-unknown-linux-gnu, feature burst enabled, allocator=arena}` is `UNSOUND` in every Cargo profile and either debug-assertion state. The supported complement is `PROVED` relative to TCB-1 and the Rust axioms below.
+
+**Documented behavior:** `PROVED` on the supported complement. In `B`, the documented “Panics when value is zero” postcondition is `UNPROVED`, not `CONTRACT-BROKEN`: the only established zero-input witness contains UB, so it cannot establish a UB-free behavioral refutation. For nonzero inputs in `B`, construction is proved.
+
+**Combined mandatory result: UNSOUND; zero-input panic postcondition UNPROVED in B.** No binary/backend claim is made.
+
+## Snapshot, supported set, and configuration closure
+
+`Required(t,f,a,p,d)` means: the supplied source; edition 2021; Rust, Cargo, and std 1.85.1; `t` in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`; `f` is either state of `burst`; `a` is `system` or `arena` selected through `FIXTURE_ALLOCATOR` and Cargo/build.rs; `p` is any Cargo profile; and `d` is either debug-assertion state; except `(t=wasm32-unknown-unknown, a=arena)`. `SUPPORT.md` and `BUILD.md` control this predicate. No dependencies or generated source exist; the build script generates only cfg options.
+
+Local build-script dataflow maps an absent selector to `system`, accepts exactly `system|arena`, emits one matching `fixture_allocator` cfg, and panics for non-Unicode or other values. TCB-1 supplies only Cargo’s execution/directive, feature, and target-cfg mappings and the rule that unsuccessful build scripts produce no library compilation. Thus invalid selectors are effectively rejected. A stdout infrastructure failure likewise yields no library compilation, but TCB.md expressly says it is not a successful policy rejection.
+
+For successful accepted builds, the source predicates form the exhaustive partition `B` versus `not(B)`. Profiles and debug assertions affect no source selection or proof fact. The wasm32/arena pair activates `compile_error!`, which [causes compilation to fail](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html); it is effectively rejected for both feature states, every profile, and either debug-assertion state. The earlier selector checks are inactive under TCB-1’s exactly-one mapping but reject absent, unknown, or simultaneous manually injected selector cfgs. Such direct-rustc builds, all other targets/toolchains, and invented cfgs are outside `Required`.
+
+## Boundary and invariant inventory
+
+The sole downstream surface is safe public `lane_id(u8) -> NonZeroU8`. There are no public fields, unsafe APIs/traits/impls, callbacks, macros, hidden items, mutable state, FFI, concurrency, allocators actually called, or destruction invariants. The only invariant is local: **INV-NZ:** immediately before either `NonZeroU8::new_unchecked(value)`, `value != 0` must hold. Std’s exact contract says [“The value must not be zero” and zero causes UB](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked).
+
+## Obligation ledger and proofs
+
+| ID | Scope | Obligation and derivation | Status |
+|---|---|---|---|
+| O-1 | build/config | Accepted environment values emit exactly one allocator selector; TCB-1 transfers it and the feature/target cfgs. Invalid environment values panic and TCB-1 prevents library compilation. | PROVED |
+| O-2 | excluded wasm32/arena | Accepted `arena` plus wasm32 target makes the cfg predicate true; `#[cfg]` includes the `compile_error!`, so no library artifact is produced. | PROVED |
+| O-3 | `not(B)`, `lane_id(0)` | For primitive `u8`, `==` means equality ([Reference](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)). The true consequent executes and later code is skipped ([if expressions](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)); `panic!` [panics the current thread](https://doc.rust-lang.org/1.85.1/std/macro.panic.html). No unsafe call is reached. | PROVED |
+| O-4 | `not(B)`, `lane_id(value != 0)` | The zero branch is skipped; the dominating comparison establishes INV-NZ, satisfying `new_unchecked`. The return is a valid `NonZeroU8` constructed from `value`. | PROVED |
+| O-5 | `B`, nonzero input | The cfg-selected early branch calls `new_unchecked(value)`; the call-site input fact satisfies INV-NZ. | PROVED |
+| O-6 | `B`, all safe inputs | The same branch performs no check. Safe callers may pass every `u8`, including zero; INV-NZ is not established. | UNSOUND (F-1) |
+
+The fallback safety comment is a correct concise local proof: reaching its call after the zero branch entails nonzero. The special-branch comment is not a proof; neither the type nor any constructor/boundary establishes its assertion.
+
+## Finding F-1 — supported safe call violates `new_unchecked`
+
+- **Status/severity:** critical, `UNSOUND`; proof artifact deficient.
+- **Configuration:** `aarch64-unknown-linux-gnu`, `burst`, `arena`, every supported profile/debug-assertion state.
+- **Valid witness:** choose `FIXTURE_ALLOCATOR=arena`, enable `burst`, select the supported aarch64 target, then safe code calls `lane_id(0)`. TCB-1 and local build logic select the early cfg block. It executes `unsafe { NonZeroU8::new_unchecked(0) }`; the version-matched std contract explicitly classifies zero as UB.
+- **Defect:** “Burst-mode lane identifiers are never zero” reverses no producer contract and is false for the unconstrained safe parameter. A safe API cannot impose this hidden caller obligation.
+- **Postcondition classification:** this UB-containing execution proves soundness `UNSOUND` but does not prove the panic guarantee `CONTRACT-BROKEN`; that guarantee remains `UNPROVED` in `B`.
+- **Minimum repair:** remove the special path and use the checked constructor, e.g. `NonZeroU8::new(value).expect("lane identifier must be nonzero")`, or add the same unconditional zero check before the unsafe call. After a check, suitable proof text is: “The dominating `value == 0` branch panics; therefore reaching this call establishes `value != 0`, exactly `new_unchecked`’s precondition.” Re-audit the changed snapshot and all cfg regions. This restores the published safe contract; it does not legitimize the old hidden obligation.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact proposition and scope | Consumers / trigger |
+|---|---|---|---|
+| TCB-1 (`BUILD-MAP-X`) | IMPLEMENTATION, human-accepted | Exactly the Cargo 1.85.1 directive/rerun, unsuccessful-script, `burst`, and three named target-cfg mappings stated in supplied `TCB.md`; successful stdout scope only. It does **not** trust local source correctness, emitted string choice, Rust semantics, backend, or binary. | O-1, O-2, O-6; re-audit on any identity/interface/source/cfg/target/disposition change listed there. |
+| AXIOM-NZ | Rust std 1.85.1, authoritative | `NonZero::new_unchecked(n)` requires nonzero and zero causes UB. | O-4–O-6; documentation/toolchain change. |
+| AXIOM-CONTROL | Rust Reference 1.85.1, authoritative | Primitive equality and `if` control flow used above; cfg selects attributed source by its predicate. | O-2–O-4, O-6; Reference/toolchain change. |
+| AXIOM-PANIC | Rust std 1.85.1, authoritative | Invoked `panic!` panics the current thread. | O-3; documentation/toolchain change. |
+
+No premise widens TCB-1. No selected safe/unsafe dependency or tool-derived evidence is consumed. No tests, builds, execution, expansion, or prior audit were used.
+
+## Residual scope and re-audit triggers
+
+Excluded are unsupported configurations, direct rustc/invented cfg builds, compiler/backend correctness, binaries, deployment behavior, and infrastructure-failed attempts. There is no authoritative-documentation or skill-guidance gap material to the verdict. Re-audit on any source, contract, support policy, Cargo/Rust/std, build environment/interface, target/feature/allocator set, cfg generation, or TCB disposition change.
+
+**Audit date:** 2026-08-01. **Independent review:** not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r050/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r050/1/attestation.json
new file mode 100644
index 0000000000..94ad01f710
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r050/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r050",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:23:28.265270Z",
+  "report_sha256": "77862cfc78b4998dd4c0f05da7a160bf578f1f069da9ef7ca577bfaf19836aa6",
+  "run_id": "r050",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 898
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r050/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r050/1/report.md
new file mode 100644
index 0000000000..6bfb32900b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r050/1/report.md
@@ -0,0 +1,103 @@
+# Focused source-only audit of `lib.rs`
+
+## Claim, snapshot, and verdicts
+
+The audited artifact is exactly `lib.rs` SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is its sole public safe API, `classify(u8) -> u8`. `Supported(C)` means:
+this exact source; Rust compiler and standard library 1.80.0; every target on
+which this source and `std::hint::unreachable_unchecked` exist; and every
+ordinary debug or release profile. This is a Rust source-level result, not a
+compiler-backend or binary theorem. TCB identity is embedded log `TCB-R1` below.
+
+1. **Freedom from UB: UNSOUND in every supported configuration.** The claimed
+   theorem is that every well-typed safe call, for every `u8` input, is free
+   from Rust UB. The valid safe call `classify(0)` refutes it.
+2. **Input-zero panic guarantee: UNPROVED in every supported configuration.**
+   The claim is that every call with `input == 0` panics. Its only source path
+   reaches UB. That UB-containing execution proves unsoundness, but cannot be a
+   UB-free witness that the panic postcondition is false; therefore it does
+   **not** establish `CONTRACT-BROKEN`.
+3. **Normal-return result guarantee: CONTRACT-BROKEN in every supported
+   configuration.** The UB-free witness `classify(1)` normally returns `2`, and
+   `2 != 1`.
+
+The combined mandatory result is `UNSOUND` + panic guarantee `UNPROVED` +
+normal-return guarantee `CONTRACT-BROKEN`.
+
+## Boundary, configuration, and obligation coverage
+
+The complete language-reachable surface is the safe free function `classify`.
+There are no public fields, constructors, user-defined types or traits, hidden
+items, callbacks, FFI, macros, generated artifacts, dependencies other than
+`std`, conditional compilation, features, concurrency, allocation, or
+invariant-bearing state. The `allow(dead_code)` attribute and `marker` local do
+not affect control flow or safety. The only unsafe site is
+`unreachable_unchecked()` at `lib.rs:12`.
+
+The input partition is exhaustive for `u8` and supplies the obligation ledger:
+
+| Input | Source derivation | UB status | Applicable postcondition result |
+|---|---|---|---|
+| `0` | The `0` arm is selected; the two inert `marker` statements complete; execution reaches `unreachable_unchecked()` unconditionally. | UB by `AXIOM-UU`; this is the exact safe-call witness for `UNSOUND`. | It cannot establish either a defined failure to panic or a defined normal return. The panic claim remains `UNPROVED`. |
+| `1` | The distinct `1 => 2` arm normally returns `2`; it executes no unsafe operation and no panic. | UB-free relative to an otherwise defined safe calling context. | Exact UB-free witness for `CONTRACT-BROKEN`: normal result `2` differs from input `1`. |
+| `2..=255` | The `_ => input` arm normally returns that input and executes no unsafe operation. | UB-free relative to an otherwise defined safe calling context. | The normal-return guarantee is satisfied for each of these inputs. |
+
+`OBL-UU` is the intrinsic's requirement that its call site not be reached.
+`classify(0)` proves the required proposition false. The adjacent comment,
+“This branch is assumed to be unreachable,” is not a proof and directly
+contradicts the enclosing match arm. `OBL-SOUND` therefore fails. `OBL-PANIC`
+cannot be proved from an execution after UB. `OBL-RETURN` is independently
+refuted by the defined input-`1` execution.
+
+This partition is parametric over every supported target and profile: the
+source has no configuration selection, and optimization/debug settings do not
+alter the Rust 1.80.0 abstract contract that reaching the intrinsic is UB or
+the source-level selection of the `0`, `1`, and catch-all arms. Thus the union
+of the three cases closes the requested configuration domain without sampling.
+
+## TCB-R1 and authority
+
+| ID | Accepted Rust 1.80.0 proposition | Scope and consumers | Disposition |
+|---|---|---|---|
+| `AXIOM-UU` | The standard-library Safety section states: “Reaching this function is *Undefined Behavior*.” ([Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)) | Every supported target/profile where the item exists; `OBL-UU`, `OBL-SOUND`, `OBL-PANIC`. | Accepted: exact request-selected authority independently opened and verified. |
+| `AXIOM-REF` | The Reference says unsafe code is unsound when safe code can trigger UB, and lists “Invoking undefined behavior via compiler intrinsics.” ([Rust 1.80.0 Reference](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)) | Rust 1.80.0 source semantics; aggregation of `OBL-SOUND`. | Accepted: exact request-selected authority independently opened and verified. |
+
+No external, implementation, dependency, tool, deployment, probabilistic, or
+out-of-band premise is consumed. No tests, execution, compilation, expansion,
+or tool-derived proof was used. The TCB must be revisited if either cited
+contract or the supported Rust/target/profile predicate changes.
+
+## Findings and minimum resolution
+
+### F-01 — reachable `unreachable_unchecked`
+
+- **Status:** `UNSOUND`; proof artifact deficient.
+- **Witness:** the well-typed safe call `classify(0)`, in every supported
+  configuration.
+- **Defect:** the required implication `input == 0 implies this arm is
+  unreachable` is false; the condition instead selects the arm.
+- **Resolution:** replace the UB path with a defined panic. Remove the false
+  `SAFETY` comment and unsafe call.
+
+### F-02 — input-zero panic is not established
+
+- **Status:** `UNPROVED`, not `CONTRACT-BROKEN`.
+- **Evidence classification:** `classify(0)` reaches UB before any panic. As an
+  execution containing UB, it establishes F-01 but cannot establish the
+  required UB-free existential refutation of this behavioral contract.
+- **Resolution:** implement a defined panic in the zero arm, then re-audit.
+
+### F-03 — normal return changes input one
+
+- **Status:** `CONTRACT-BROKEN`; implementation behavior is defined on this
+  witness and the documentation is unambiguous.
+- **Witness:** `classify(1)` selects `1 => 2` and normally returns `2` without
+  executing unsafe code; hence it is an independent UB-free refutation.
+- **Resolution:** return `input` in the `1` arm (or remove that special arm).
+
+There is no authoritative-documentation gap in the propositions needed for
+these conclusions. Excluded residual scope is compiler/backend correctness and
+binary behavior. Re-audit on any source, contract, Rust version, supported-set,
+or cited-authority change. Every in-scope surface, input, obligation, and
+requested postcondition has the status recorded above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r051/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r051/1/attestation.json
new file mode 100644
index 0000000000..69bdbf0ebe
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r051/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r051",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:25:26.233425Z",
+  "report_sha256": "2eacff962730a259104f7a8cddafad623a47a519182a5e9e441f49e77fd0bdef",
+  "run_id": "r051",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 918
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r051/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r051/1/report.md
new file mode 100644
index 0000000000..39d6355a06
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r051/1/report.md
@@ -0,0 +1,128 @@
+# Unsafe Rust source audit: conflicting-policy snapshot
+
+## Claim and verdict
+
+For the exact supplied `Cargo.toml`, policies, `TCB.md`, and `src/lib.rs`, let
+`V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let
+`f`/`h` denote `turbo`/`hardened`. Define the conservative **audit envelope**
+
+```text
+E(v,t,f,h) = v in V and t in T and not(f and t=W).
+```
+
+`E` includes both feature states, every Cargo profile, and both debug-assertion
+states. It is an audit domain, not a newly selected support policy.
+
+- **Rust soundness: PROVED over E**, relative to the TCB below: every well-typed
+  safe call of the selected `value_or_zero` is free of Rust undefined behavior.
+- **Documented postcondition: PROVED over E**: the result is the contained byte
+  for `Some(byte)`, and zero for `None`.
+- **Effective rejection: PROVED** for every `(v,W,true,h)` in the common axes:
+  compilation fails, so no library artifact from that configuration enters the
+  execution theorem.
+- **Combined mandatory result: PROVED over E, relative to BUILD-MAP-C and the
+  version-matched Rust axioms below.** No `UNSOUND` or `CONTRACT-BROKEN` witness
+  is established.
+- **Exact project support predicate: UNPROVED.** Scarlet and Indigo each says
+  “exactly” but selects a different set, and no resolution is authorized. This
+  governance ambiguity does not block the stronger source theorem: both
+  Scarlet and Indigo are subsets of `E` because both exclude `turbo` on `W`.
+
+This is a source-level Rust-abstract-semantics result, not a compiler-backend,
+binary, platform, or security claim.
+
+## Snapshot, boundaries, and coverage
+
+The crate is edition 2021, `#![no_std]`, declares Rust 1.84 as `rust-version`,
+has no dependencies, and has only the two named empty features. No generated
+artifacts, build scripts, FFI, assembly, concurrency, allocation, traits,
+fields, representation invariants, hidden items, or macros generating public
+API exist in the supplied target.
+
+The complete language-reachable API surface is one safe public free function,
+`value_or_zero(Option<u8>) -> u8`, with mutually exclusive non-`turbo`
+(`src/lib.rs:7-10`) and `turbo` (`:13-21`) definitions and the same documented
+contract. The sole unsafe operation is `Option::unwrap_unchecked` at line 20.
+The crate-level `compile_error!` at lines 3-4 is the only target-dependent
+obligation. There is no unsafe caller-facing contract and no persistent state
+or invariant inventory.
+
+No build, execution, test, or macro expansion was used. Profiles, debug
+assertions, and `hardened` do not occur in source selection or computation, so
+the proof is parametric over them.
+
+## Authoritative premises and TCB audit log
+
+The following version-matched pages were opened and checked; no compatibility
+extrapolation is used.
+
+- **AXIOM-OPTION-{184,185,186}.** For each exact version, `is_none` “Returns
+  `true` if the option is a `None` value”; `unwrap_unchecked` returns the
+  contained `Some` value and calling it on `None` is undefined behavior;
+  `unwrap_or` returns the contained `Some` value or its provided default:
+  [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or);
+  [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or);
+  [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+- **AXIOM-CFG-{184,185,186}.** A configuration option is true exactly when set;
+  `all` is true when all operands are true; `not` negates; a false `cfg`
+  predicate removes its item and a true predicate includes it:
+  [1.84 predicates](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute);
+  [1.85 predicates](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute);
+  [1.86 predicates](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute).
+- **AXIOM-COMPILE-{184,185,186}.** `compile_error!` “Causes compilation to fail
+  with the given error message when encountered”: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+  [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+  [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+- **BUILD-MAP-C — ACCEPTED HUMAN TRUST DECISION, CONSPICUOUS TCB.** For exactly
+  the bundled Cargo releases for Rust 1.84.0/1.85.0/1.86.0, the supplied
+  manifest/source, every supported Cargo profile, the two named features, and
+  targets X/A/W, Cargo maps feature enablement and target triples to the source
+  `cfg` predicates exactly as stated in `TCB.md`. It is consumed only by branch
+  reachability and rejection proofs. It supplies no Rust semantic,
+  implementation, compatibility, backend, or binary-correctness premise.
+
+The Rust entries are authoritative axioms requested for this audit;
+BUILD-MAP-C is the only additional admitted premise. Re-audit is required on
+any identity, source, cfg, feature, target, version, disposition, or consumed
+documentation change.
+
+## Obligation ledger and derivations
+
+| ID | Obligation and complete derivation | Status |
+|---|---|---|
+| CFG-1 | If `f` and `t=W`, BUILD-MAP-C makes both operands of line 3's `all` true; AXIOM-CFG includes `compile_error!`; AXIOM-COMPILE makes compilation fail. Otherwise that item is removed. | PROVED |
+| CFG-2 | BUILD-MAP-C plus AXIOM-CFG makes exactly one function definition present: `not(feature="turbo")` when `!f`, and `feature="turbo"` when `f`. | PROVED |
+| SAFE-1 | With `!f`, `unwrap_or(0)` is safe and AXIOM-OPTION returns the contained byte or the supplied zero. | PROVED |
+| UNSAFE-1 | With `f`, `is_none()==true` returns zero. Reaching line 20 means the immediately preceding result was false. AXIOM-OPTION says `None` implies true, so contraposition gives “not `None`.” No operation intervenes or mutates the owned `Option<u8>`. Thus the call is not in `unwrap_unchecked`'s documented UB case, and its postcondition yields the contained byte. | PROVED |
+| API-1 | `None` and non-`None` paths exhaust every safe `Option<u8>` input; SAFE-1/UNSAFE-1 cover the cfg partition, all three exact version axioms agree, and other supported axes are computation-independent. | PROVED |
+
+## Findings and residual scope
+
+**F-1 — support-policy identity (`UNPROVED`, governance only).** The two exact
+predicates conflict. Minimum resolution: an authorized precedence,
+supersession, or replacement policy. A resolution contained in `E` needs no
+new implementation proof; expanding beyond `E` requires fresh coverage.
+
+**F-2 — local proof comment deficient; implementation proved.** Line 19 does
+not name `is_none`'s contract, the contraposition, preservation of `value`, or
+the exact unsafe precondition. Proposed replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`. Reaching here means that result
+// was false; by contraposition `value` is not `None`, and no mutation intervened.
+// Therefore `unwrap_unchecked` is not called on its documented UB case and
+// returns the contained byte.
+```
+
+No authoritative-documentation gap, tool-derived evidence, prior audit, or
+additional robustness claim is in scope. Unsupported versions, other targets,
+custom toolchains, and binary/backend correctness remain excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r052/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r052/1/attestation.json
new file mode 100644
index 0000000000..37a471ae1a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r052/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r052",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:31:31.699808Z",
+  "report_sha256": "8a4870792d2b539f3f1adb115796eea44f36fc3c49d9c36d39996133f51502ad",
+  "run_id": "r052",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 1117
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r052/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r052/1/report.md
new file mode 100644
index 0000000000..bd10f0e665
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r052/1/report.md
@@ -0,0 +1,90 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: `lib.rs`, SHA-256 `b2d9d02f117745925aa24c5b09461c200c3f36f1d1e026c1f289f971711dc122`; request SHA-256 `2d044b4aa4dca16c51aeedd3bd9db58d182a0929e6b73a98478fdc2710094b8f`. Scope is exactly this source, under documented Rust abstract semantics. No source was executed or expanded; no generated artifacts, dependencies, `cfg`s, features, FFI, concurrency, or allocator behavior occur in the supplied artifact.
+
+`DOMAIN-R1` is preserved directly from the request:
+
+> Rust and standard library exactly 1.82.0; every target on which this exact source and its used 1.82.0 standard-library items exist; every ordinary profile.
+
+Other Rust releases, targets where those conditions fail, nonordinary profiles, compiler/backend correctness, and any wider crate are excluded. Audit cutoff: 2026-08-01; it does not broaden the fixed version.
+
+- **CLAIM-SOUND — UNSOUND.** The public safe generic `increment<S: Slot>` is not sound for all well-typed safe uses. `F-1` below supplies a valid safe witness, reachability, a false unsafe precondition, and the authoritative UB consequence. The witness is parametric over every configuration in `DOMAIN-R1`.
+- **CLAIM-TAIL — PROVED.** For every initial `[a, b]: [u32; 2]` and every configuration in `DOMAIN-R1`, `increment::<Tail>` is UB-free and returns with `[a, b.wrapping_add(1)]`. `P-TAIL` below proves this requested behavior independently of the redesign.
+- **Combined current-artifact result: UNSOUND.** There is no source-authored documented generic postcondition. The UB-containing witness is not used to claim `CONTRACT-BROKEN`.
+
+TCB log `TCB-R1` contains only the two accepted Rust 1.82 authoritative axioms below; there are no additional admitted assumptions, dependency facts, implementation claims, or tool results.
+
+## Boundary, invariants, and obligation ledger
+
+The complete relevant language-reachable surface is: public safe trait `Slot` and its safe implementer-provided static method `index`; public constructible unit struct `Tail` and its safe `Slot` impl; and public safe generic function `increment`. There are no fields, unsafe declarations/impls, macros, hidden items, callbacks other than `S::index`, or generated APIs in the supplied source. Downstream code may implement `Slot` for a downstream type because the trait is public and unsealed.
+
+No enforced invariant connects `Slot` to the two-element array. The tempting proposition `S::index() < 2` is neither type-enforced, checked, nor module-owned. Its producer is adversarial safe code (`S::index`); its consumer is `get_unchecked_mut`.
+
+| ID | Obligation | Status |
+|---|---|---|
+| O-1 | Every safe `increment::<S>` call avoids UB without a hidden caller/implementer safety condition. | **Refuted: F-1** |
+| O-2 | At the unsafe call, `S::index()` is in bounds for the length-2 slice. | **False generically; proved for `Tail`** |
+| O-3 | The returned reference denotes the selected element and is used within the exclusive `&mut` borrow. | **Proved when O-2 holds, by the method contract and types** |
+| O-4 | The stored value is old value plus one modulo the `u32` range. | **Proved by AX-WRAP** |
+| O-5 | Element 0 is unchanged for `Tail`. | **Proved: only the reference to element 1 is written** |
+
+The unsafe block has no adjacent `SAFETY` proof. This is a missing proof artifact, but documentation alone cannot repair O-1: prose on a safe trait cannot impose a soundness precondition on safe implementers.
+
+## Authoritative premises (`TCB-R1`)
+
+- **AX-SLICE (accepted AXIOM).** Rust 1.82 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) returns a mutable reference to the indexed element/subslice without checking bounds and states: “Calling this method with an out-of-bounds index is undefined behavior.” Scope: every `DOMAIN-R1` use of this item. Consumers: O-2, O-3, F-1, P-TAIL.
+- **AX-WRAP (accepted AXIOM).** Rust 1.82 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add) specifies wrapping modular addition at the type boundary. Scope: every `DOMAIN-R1` use of this item. Consumers: O-4, P-TAIL.
+
+Both citations were opened at the exact version and fragment. Re-audit either entry if that exact documentation, source, or supported domain changes.
+
+## F-1 — complete UB certificate
+
+Downstream safe code can write:
+
+```rust
+struct Oob;
+impl Slot for Oob {
+    fn index() -> usize { 2 }
+}
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+**Valid use.** The trait and method are safe and public; the implementation and call are well-typed and contain no caller-written unsafe operation or violated documented obligation.
+
+**Reachability.** `Oob::index()` returns `2`; `increment` then executes `pair.get_unchecked_mut(2)` on the two-element array viewed as a slice of length 2.
+
+**False safety proposition.** Its valid element indices are 0 and 1, so index 2 is out of bounds.
+
+**Consequence.** AX-SLICE says that this call itself has undefined behavior, even independently of later reference use. Thus one valid safe use reaches an executed operation whose required proposition is false and whose applicable contract entails UB. The same construction uses no target- or profile-dependent fact, so it witnesses every member of `DOMAIN-R1`.
+
+Minimum repair requires enforcing the bound before the unsafe call, making an implementer obligation compiler-enforced, or removing the unnecessary extensibility. The last is preferred below.
+
+## P-TAIL — requested-behavior proof and configuration closure
+
+`Tail::index()` is locally and unconditionally `1`. The input type fixes length at 2, hence 1 is in bounds. AX-SLICE therefore supplies a mutable reference to element 1. The subsequent assignment reads that element, applies AX-WRAP with operand 1, and writes only through that reference; element 0 is untouched. This proves UB freedom and the exact `[a, b] -> [a, b.wrapping_add(1)]` postcondition for all `u32` values.
+
+The source has no conditional compilation or profile-sensitive arithmetic: unchecked indexing's contract and modular addition apply parametrically across the request's target/profile predicate. Thus `Covered(CLAIM-TAIL) = DOMAIN-R1`, proving `Required ⊆ Covered`. For CLAIM-SOUND, F-1 applies parametrically across the same domain; no configuration remainder can weaken its `UNSOUND` verdict.
+
+## Preferred redesign
+
+Replace the trait, marker, generic dispatch, and unsafe operation with one specialized safe function:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    let tail = &mut pair[1];
+    *tail = tail.wrapping_add(1);
+}
+```
+
+Its proposed public contract has no safety precondition: on normal return, element 0 equals its entry value and element 1 equals its entry value plus one modulo `u32`. It has no invariant-bearing representation, downstream implementer contract, generic capability, or unsafe proof site. Fixed index 1 is valid by the array's type; `wrapping_add` supplies the requested arithmetic. This is the minimum capability actually required.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. `Slot`, downstream `Slot` implementations, generic calls, and the nominal `Tail` marker disappear. Those are breaking source/contract changes, explicitly authorized because the abstraction is unreleased and none must be preserved. No caller safety obligation is transferred.
+
+This is a design, not a verdict for a new artifact. After implementation, freeze and audit that exact snapshot anew: re-inventory every exposed/reexported/generated surface; verify the fixed-index operation for `[u32; 2]`, borrow/dataflow, AX-WRAP postcondition, both elements' outcomes and every exit; confirm no unsafe or hidden extensibility remains; and re-establish parametric `DOMAIN-R1` closure. Any changed signature, documentation, configuration, generated code, standard-library contract, or Rust version triggers re-audit.
+
+## Residual attestation
+
+Every in-scope surface and unsafe obligation has a disposition above. No test or absence of counterexamples supports either verdict. No independent second review was performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r053/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r053/1/attestation.json
new file mode 100644
index 0000000000..9ae1a8fcba
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r053/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r053",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:33:21.542452Z",
+  "report_sha256": "97b483500c362b67ec5966a089ea6c9d0c039bbfe454e5b05d854edc693bf982",
+  "run_id": "r053",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 948
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r053/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r053/1/report.md
new file mode 100644
index 0000000000..c11ba5ce1a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r053/1/report.md
@@ -0,0 +1,102 @@
+# Focused source-only unsafe Rust audit
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is solely the public safe function `classify` in lines 6–17. No generated
+artifacts, dependencies, macros, callbacks, traits, fields, or other public
+surfaces exist in the submitted source. This review did not build, execute,
+test, or expand the target.
+
+Let `Required(t,p,i)` mean: the exact source above; Rust compiler and standard
+library 1.80.0; a target `t` on which this source and the used 1.80.0
+`std::hint::unreachable_unchecked` item exist; ordinary debug or ordinary
+release profile `p`; and a well-typed safe call `classify(i)` for `i: u8`.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call in `Required` is free from Rust undefined behavior | **UNSOUND** | For every required `t,p`, the valid safe call `classify(0)` reaches `unreachable_unchecked`; AX-1 says reaching it is UB. |
+| When `input == 0`, the call panics | **UNPROVED**, not `CONTRACT-BROKEN` | The source reaches UB before establishing a panic. That execution proves unsoundness, but an execution containing UB cannot certify a broken behavioral contract. No independent UB-free zero-input witness was supplied or derivable. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | For every required `t,p`, `classify(1)` takes line 14 and normally returns the valid `u8` value `2`; `2 != 1`. This path never enters the unsafe block and consists only of the matched safe return, so the whole witness is UB-free. |
+
+The combined requested result is therefore not proved: it has the component
+statuses `UNSOUND`, `UNPROVED`, and `CONTRACT-BROKEN` above.
+
+## Authority and TCB (`TCB-R1`)
+
+Both entries were opened at their exact versioned URLs and checked in context.
+They are accepted Rust-authority premises for this source-level review, with the
+target/profile applicability expressly supplied by `EVIDENCE.md`.
+
+* **AX-1 (Rust 1.80.0 std):** The Safety section for
+  [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)
+  states: “Reaching this function is Undefined Behavior.” Consumer: OBL-UB.
+* **AX-2 (Rust 1.80.0 Reference):** The
+  [undefined-behavior chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)
+  says unsafe code that safe code can misuse to exhibit UB is unsound, and that
+  `unsafe` does not permit Rust programs to cause UB. Consumer: the safe-wrapper
+  soundness classification.
+
+No compiler-backend correctness, tested behavior, platform implementation, or
+tool result is assumed: these are source-level conclusions under documented
+Rust 1.80.0 abstract semantics. The Reference warns that its general UB list is
+not exhaustive; the UB certificate does not rely on that list being exhaustive,
+because AX-1 directly classifies the reached operation.
+
+## Boundary, cases, and obligation ledger
+
+The sole safe boundary is `pub fn classify(input: u8) -> u8`. Its documentation
+supplies the two behavioral contracts at lines 3 and 5. The sole unsafe
+consumer is the call at line 12. It requires that control never reach it. The
+comment at line 11 merely assumes that proposition and does not prove it.
+
+The input partition is exhaustive by equality: `i = 0`, `i = 1`, or
+`i != 0 && i != 1`.
+
+| Case | Control/data-flow proof | Disposition |
+|---|---|---|
+| `i = 0` | The `match` selects lines 8–13; the harmless `marker` statements do not alter `input` or control flow; line 12 is reached. | OBL-UB false by AX-1; safe-call soundness is `UNSOUND`. The panic theorem remains `UNPROVED`. This case supplies no UB-free normal return and therefore does not refute the conditional result theorem. |
+| `i = 1` | The `match` selects `1 => 2`; it reaches no unsafe operation and normally returns `2`. | Sound for this execution; panic contract inapplicable; exact UB-free witness for `CONTRACT-BROKEN` result guarantee. |
+| `i != 0 && i != 1` | The wildcard arm normally returns `input` and reaches no unsafe operation. | Sound for these executions and the normal-return result guarantee holds. Panic contract inapplicable. |
+
+The local invariant suggested by the safety comment—“the zero arm is
+unreachable”—has no enforcing owner or producer and is directly falsified by
+`i = 0`. The implementation defect and proof-comment defect are therefore
+separate: reconstruction cannot repair the false premise.
+
+## Configuration closure
+
+`REQUEST.md` directly defines the symbolic target set, exact Rust version, and
+two profiles; no target enumeration or widening is used. The source contains
+no `cfg`, feature gate, target-specific operation, arithmetic, debug assertion,
+generated code, allocation, concurrency, FFI, or profile-dependent branch.
+Branch selection depends only on `i`. AX-1's applicability over the declared
+target/profile domain is supplied by `EVIDENCE.md`. Consequently each case
+derivation is parametric in `t,p`, and the three input predicates exhaust every
+`i: u8`. The zero and one witnesses therefore exist on every member of the
+required configuration domain; optimization cannot turn their source-level UB
+or defined `1 => 2` return into the opposite theorem.
+
+Because the two universal claims have complete existential refutations (UB for
+soundness, a UB-free wrong result for normal return), they do not require a
+positive `Required ⊆ Covered` certificate. The zero-input panic claim lacks
+the UB-free evidence required for either a proof or a `CONTRACT-BROKEN`
+certificate and is intentionally left `UNPROVED`.
+
+## Findings and remediation
+
+1. **F-UB0 — critical, `UNSOUND`:** a caller needs no unsafe act or undocumented
+   precondition to call `classify(0)`. The selected arm executes line 12, whose
+   exact safety proposition (“must not be reached”) is false; AX-1 supplies the
+   UB consequence. Replace that arm with a real panic (for example `panic!` or
+   `unreachable!`) and remove the false safety proof.
+2. **F-RESULT1 — `CONTRACT-BROKEN`:** the independent UB-free call
+   `classify(1)` normally returns `2`, falsifying line 5. Return `input` in this
+   arm or remove the special arm.
+
+Residual scope is exactly what the request excludes: other Rust releases,
+targets where the source/item do not exist, nonordinary profiles, binaries,
+backend correctness, and any source other than the submitted file. Re-audit on
+source or contract changes, Rust/stdlib version changes, target/profile-domain
+changes, or material changes to either cited authority.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r054/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r054/1/attestation.json
new file mode 100644
index 0000000000..f0ad9c43e1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r054/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r054",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:32:42.633467Z",
+  "report_sha256": "aaf0fe262d82d837f4f011b5707956852b8db0df9830d91ec927d0ce16fcbd8a",
+  "run_id": "r054",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 898
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r054/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r054/1/report.md
new file mode 100644
index 0000000000..f83b5b1563
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r054/1/report.md
@@ -0,0 +1,60 @@
+# Unsafe Rust Audit: complete supplied snapshot
+
+## Claims and verdicts
+
+| Claim | Exact theorem | Verdict | Certificate and qualification |
+|---|---|---|---|
+| SOUND | For every well-typed safe call to `value_or_zero` in `Required`, execution is free of Rust undefined behavior under documented Rust abstract semantics. | **PROVED** | OBL-1 and configuration closure below, **relative to accepted TCB entry `COMPAT-OPTION-184-186`**. |
+| RESULT | For every such call, `None` returns `0` and `Some(v)` returns `v`. | **PROVED** | OBL-2 below, **relative to accepted TCB entry `COMPAT-OPTION-184-186`**. |
+
+**Combined mandatory result: PROVED**, relative to `target/TCB.md` as supplied. This is a source-level result, not a compiler-backend or binary theorem.
+
+## Snapshot, scope, and contracts
+
+The audited artifact is the exact supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, and `src/lib.rs`; `REQUEST.md` controls this review. It is a Rust-2021 `#![no_std]` library, has no declared dependencies, build script, generated source, macros, FFI, allocator use, concurrency, or mutable state. No prior audit or tool result was reused; the target was not built, run, tested, modified, or expanded.
+
+The complete language-reachable public surface is the safe free function `value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4`). There are no public fields, constructors, traits/impls, methods, hidden items, reexports, unsafe APIs, or configuration-specific APIs. Its documentation is normative: “Returns the contained byte, or zero when `value` is `None`.” Safe callers have no safety precondition. There is no abstraction invariant: the function owns its input and retains no state.
+
+## Required domain and closure
+
+`SUPPORT.md`, expressly identified there as the support commitment, defines
+
+`Required = R × T × F × P × D`, where:
+
+- `R = { released stable r | 1.84.0 <= r <= 1.86.0 }`;
+- `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`;
+- `F = {telemetry disabled, telemetry enabled}`;
+- `P = every Cargo profile`; and
+- `D = {debug assertions disabled, debug assertions enabled}`.
+
+Edition 2021 and the standard library bundled with `r` are fixed additional coordinates. The official version history through 1.86.0 gives the exhaustive release inventory `R = {1.84.0, 1.84.1, 1.85.0, 1.85.1, 1.86.0}` ([1.84.1 section](https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30), [1.85.1 section](https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18)). Thus the inventory equals the symbolic interval; it is not inferred from endpoints. `Cargo.toml`'s `rust-version = "1.84"` supplies only the stated Cargo minimum and does not erase the upper bound. `CI.md` is sampling evidence only and does not narrow or prove support.
+
+There is no `cfg`, profile-sensitive operation, debug assertion, or use of `telemetry`; every required tuple selects the same function body. The accepted TCB entry explicitly covers both required `Option` propositions for every `r`, target, feature state, profile, and debug-assertion state in `Required`. Therefore each obligation below has `Covered = Required`, their pointwise intersection is `Required`, and `Required ⊆ Covered`. Panic strategy, optimization, overflow checks, target layout, and allocator choice do not enter the derivation.
+
+## Obligation ledger and proof
+
+| ID | Site and exact obligation | Derivation | Status |
+|---|---|---|---|
+| OBL-1 | `src/lib.rs:5-11`: `unwrap_unchecked` is reached only on `Some`. | If `is_none()` is true, line 6 returns before the unsafe call. If false, AXIOM-OPTION-184 plus COMPAT says the input is not `None`; exhaustive `Option<u8>` variants make it `Some(v)`. COMPAT then permits `unwrap_unchecked(Some(v))` and says it returns `v`. | **PROVED throughout `Required`, relative to COMPAT**. |
+| OBL-2 | Documented result for all inputs. | `None`: COMPAT's exact `is_none` proposition selects line 6, returning `0`. `Some(v)`: it selects the fallthrough, and COMPAT's exact unwrap proposition returns `v`. These exhaustive cases also include `Some(0)`. | **PROVED throughout `Required`, relative to COMPAT**. |
+
+The adjacent `SAFETY` comment identifies the dominating `None` return, derives `Some`, and names the callee precondition. Its implementation proof is adequate; the report-level TCB citation supplies the version/configuration applicability. No panic, unwind, destructor, alias, provenance, initialization, or arithmetic obligation remains.
+
+## TCB audit log
+
+**Log identity:** supplied `target/TCB.md`, entry `COMPAT-OPTION-184-186`; human disposition accepted. **Trust policy:** consume only versioned Rust documentation and that exact accepted proposition; no dependency, implementation, backend, platform, or binary premise is admitted.
+
+| ID | Category and exact proposition | Scope/consumer/disposition |
+|---|---|---|
+| AXIOM-OPTION-184 | Rust 1.84.0 docs state that `is_none` returns true for `None` ([source](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)); `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB ([source](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). | Rust 1.84.0 base propositions; verified authoritative basis for COMPAT. |
+| COMPAT-OPTION-184-186 | Preserves, without weakening or added precondition, “`is_none` iff `None`” and “unwrap `Some(v)` to `v`; `None` is UB.” | Exactly `Required`; only OBL-1/2; **accepted by authorized human**. No interval-membership, Cargo, backend, or binary fact is consumed. |
+
+The entry is minimal, non-vacuous, and used only by its named consumers. Re-audit is required on any source, support interval, base proposition, target/feature/profile/debug scope, or disposition change. There are no dependencies or unresolved/rejected premises.
+
+## Findings, residual scope, and attestation
+
+No soundness, contract, proof-documentation, authoritative-documentation, or skill-guidance finding remains. No additional robustness property was requested, and no tool-derived evidence was used.
+
+Excluded from the theorem are unreleased, pre-1.84.0, post-1.86.0, nightly/beta/custom toolchains; other targets or feature names; compiler/backend correctness; emitted binaries; and behavior beyond the documented return value. These are theorem boundaries, not inferred project exclusions. Review must recur if source/API documentation, support policy, Cargo configuration, generated inputs, authoritative pages, or the TCB entry changes.
+
+Attestation: every safe/unsafe surface, obligation, documented result, controlling domain expression, TCB consumer, and required configuration class in the supplied snapshot has a disposition. The verdict follows the required universal coverage certificate, not tests or absence of a counterexample. Audit date: 2026-08-01; independent second review not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r055/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r055/1/attestation.json
new file mode 100644
index 0000000000..188182c2c7
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r055/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r055",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:40:05.179787Z",
+  "report_sha256": "c29cf094b7026bbde11940bb1784b6393918115d74c5eec57207772ba46f0012",
+  "run_id": "r055",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 955
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r055/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r055/1/report.md
new file mode 100644
index 0000000000..acc42fb5b5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r055/1/report.md
@@ -0,0 +1,83 @@
+# Focused literal audit and redesign
+
+## Claim, scope, and verdict
+
+**Snapshot:** the supplied `lib.rs`, reviewed as source without execution or expansion. **Supported set:** Rust 1.82.0; every Rust 1.82 edition, target on which this source and the used standard-library items exist, and ordinary profile. The proof is parametric over target, edition, and profile: the file has no `cfg`, features, generated code, dependencies, FFI, concurrency, target features, allocation, panic-mode-sensitive checks, or profile-sensitive arithmetic.
+
+The current-artifact claim is that every well-typed safe use of its public safe surfaces is free of Rust undefined behavior. The separately requested behavior is: for input `[a, b]`, `increment::<Tail>` returns normally with `[a, b.wrapping_add(1)]`.
+
+- **Current safe-API soundness: UNSOUND** (`F-1`).
+- **Required `Tail` behavior: PROVED** throughout the supported set, relative only to the cited Rust 1.82 standard-library semantics.
+- **Documented-postcondition result:** the source contains no API documentation. The user-specified `Tail` postcondition is proved; there is no current documented postcondition to classify as `CONTRACT-BROKEN`.
+- **Combined current-artifact result: UNSOUND.** The successful `Tail` proof does not qualify the public generic function's universal safe-use claim.
+- **Additional TCB assumptions:** none. No dependency, implementation, environmental, compatibility, or tool-result premise is admitted.
+
+## Authority and exact contracts
+
+`AXIOM-INDEX`, Rust 1.82 slice documentation: `get_unchecked_mut` returns a mutable reference without bounds checking, and “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82 `get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut).
+
+`AXIOM-WRAP`, Rust 1.82 `u32` documentation: `wrapping_add` is “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82 `wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add).
+
+These are version-matched Rust axioms, not additional TCB assumptions. No tool-derived evidence was used.
+
+## Boundary and obligation coverage
+
+The complete language-reachable source surface is:
+
+| Surface | Kind | Disposition |
+|---|---|---|
+| `Slot` and safe `Slot::index` (`lib.rs:3-5`) | public safe, downstream-implementable trait | Supplies an arbitrary `usize`; no contract or enforcement makes it less than 2. |
+| `Tail`, its public unit constructor, and `impl Slot` (`lib.rs:7-13`) | public safe type/implementation | `Tail::index()` is locally fixed at 1. No fields or state invariants exist. |
+| `increment<S: Slot>` (`lib.rs:15-18`) | public safe generic function containing the sole unsafe operation | Unsound for arbitrary valid `S`; proved for `S = Tail`. |
+
+There are no manual trait implementations other than `Slot for Tail`, macros, hidden APIs, restricted-visible fields, reexports, callbacks, custom destruction, or configuration-specific surfaces in the supplied source. Compiler-provided behavior of the fieldless `Tail` is irrelevant to the unsafe call.
+
+The sole safety invariant consumed at `lib.rs:16` is `INV-BOUND: S::index() < pair.len() = 2` at the instant `get_unchecked_mut` is called. The array-reference type fixes the length at 2. `Tail::index()` establishes `1`, so `INV-BOUND` holds for `Tail`. The public safe trait boundary neither checks nor promises it for arbitrary `S`.
+
+Obligation ledger:
+
+| ID | Proposition | Status |
+|---|---|---|
+| `OBL-1` | At `lib.rs:16`, `S::index() < 2` for every safe-callable `S`. | **Refuted** by `F-1`; hence **UNSOUND**. |
+| `OBL-2` | For `S = Tail`, the unchecked access produces a mutable reference to element 1. | **PROVED:** local constant 1 is in the type-fixed length 2; `AXIOM-INDEX` supplies the operation contract. |
+| `OBL-3` | The `Tail` call leaves element 0 unchanged and replaces element 1 by its old value plus 1 modulo `2^32`. | **PROVED:** `OBL-2` identifies the only assignment target; `AXIOM-WRAP` gives the assigned value. |
+
+No existing `SAFETY` comment states any of these obligations. The reconstructed `Tail` derivation is material, but it cannot repair the generic case.
+
+## F-1 — safe downstream implementation reaches UB
+
+**Status:** `UNSOUND`; implementation defective and local proof missing.
+
+This is a valid, entirely safe downstream use:
+
+```rust
+struct Bad;
+impl Slot for Bad {
+    fn index() -> usize { 2 }
+}
+
+let mut pair = [0u32, 0u32];
+increment::<Bad>(&mut pair);
+```
+
+The public trait is safe and unsealed, its method has no precondition, and the downstream type is local to its implementing crate. The call therefore satisfies every current caller obligation. It passes index 2 to a length-2 array. By `AXIOM-INDEX`, the call at `lib.rs:16` itself has undefined behavior, whether or not the returned reference is later used. This witness and reasoning are independent of target and profile.
+
+The smallest false implication is `S: Slot => S::index() < 2`. Neither the type system, validation, privacy, nor a trait contract supplies it. A comment cannot impose a safety precondition on this safe trait or safe function. Because the witness execution contains UB, it does not establish a defined postcondition refutation.
+
+## Preferred design
+
+Delete `Slot`, `Tail`, the type parameter, and the unsafe operation. Expose exactly the required capability:
+
+```rust
+/// Increments the second element modulo 2^32.
+pub fn increment(pair: &mut [u32; 2]) {
+    let [_, tail] = pair;
+    *tail = tail.wrapping_add(1);
+}
+```
+
+This is the most parsimonious boundary because no runtime-selected slot or nominal marker is required. The two-element pattern structurally obtains the second element; no index validity proposition is delegated to a caller or implementer. All operations are safe, and `AXIOM-WRAP` directly supplies the behavioral postcondition. There is no representation invariant, unsafe surface, sealing argument, or additional TCB entry.
+
+**Contract and migration delta:** `increment::<Tail>(&mut pair)` becomes `increment(&mut pair)`. `Slot`, downstream implementations, generic dispatch, and the `Tail` marker disappear. Those are source-breaking changes, expressly authorized because the abstraction is unreleased and none of those capabilities must be preserved. The new public contract should state normal return with element 0 unchanged and element 1 incremented modulo `2^32`.
+
+This is a proposal, not a verdict for an unimplemented artifact. After implementation, audit the fresh source snapshot: confirm the exact public surface and documentation; re-prove element selection and modular arithmetic on Rust 1.82.0 across the requested target/edition/profile set; and recheck any newly introduced configuration, generated code, dependency, or caller surface. Re-audit on source, contract, supported-set, or relevant Rust-documentation change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r056/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r056/1/attestation.json
new file mode 100644
index 0000000000..7a9fbb9ff6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r056/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r056",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:40:58.503488Z",
+  "report_sha256": "7545ffde31d113e2377bb3eb1304b7711101e88f6f29b168d2483ae2210177a4",
+  "run_id": "r056",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 1006
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r056/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r056/1/report.md
new file mode 100644
index 0000000000..ffd528c46d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r056/1/report.md
@@ -0,0 +1,59 @@
+# Focused unsafe-Rust source review
+
+## Claims and verdicts
+
+Audit cutoff: 2026-08-01. `C` is the exact submitted source packet, compiled with Rust/rustc/stdlib 1.80.0 and edition 2021, for every target on which this source and the exact resolved `peer-unsafe-dep` 3.4.5 package resolve, under every ordinary debug or release profile. There are no crate features, `cfg` branches, generators, build scripts, or generated artifacts in the packet.
+
+| Claim | Exact valid use | Soundness verdict |
+|---|---|---|
+| `force_unreachable` | Every well-typed safe invocation in `C`; there is no caller-side safety precondition. | **UNSOUND** (`F-1`) |
+| `delegated_nonzero` | Every invocation in `C` for which the unsafe caller establishes `value != 0` (equivalently, `value` is in `1..=255`); there are no documented ongoing or terminal obligations. | **UNPROVED** (`F-2`) |
+
+These are separate source-level Rust abstract-semantics claims. The first verdict does not imply the second. No binary-, backend-, deployment-, security-, or probabilistic claim is made.
+
+The dependency contract also documents `duplicate_nonzero(value)`'s postcondition “Returns `value`.” Any corresponding claim that `delegated_nonzero(value)` returns its input is **UNPROVED** for the same missing proposition as `F-2`; no UB-free refutation is established, so `CONTRACT-BROKEN` is not justified. No additional robustness property was requested.
+
+## Snapshot, boundary, and configuration coverage
+
+The audited packet comprises `REQUEST.md`, `Cargo.toml`, `lib.rs`, `DEPENDENCY-API.md`, `TCB.md`, and `EVIDENCE.md`. Key SHA-256 identities are `lib.rs` `778d644359b84bc0e519ed7220bfcadfbba578e2c9fd4c474ce742c4b0021ceb`, `Cargo.toml` `57b66359b9447d371fa68a2cfdc04f49176b1a3ce815bb96027b2f76d917d0a7`, `DEPENDENCY-API.md` `6f29bb01be852cc9cf2861d0447ef0b2001350f090ab947866d1495d68a27fc2`, and TCB revision `TCB.md` `86796b85804436595c0f6ffbfa773dac4fce5cbfe28e02223c802a055037d0f4`. The dependency is exactly pinned by `=3.4.5`; that fixes package/version identity but does not prove its unsafe implementation.
+
+The only exported surfaces in the submitted source are the safe free function `force_unreachable` and unsafe free function `delegated_nonzero`. There are no submitted fields, types, constructors, traits/impls, methods, statics, callbacks, macros, reexports, hidden items, FFI surfaces, or state invariants. The dependency is called but not reexported. Its implementation, generated output, prior audit, and binary are inaccessible and excluded from inspection, not silently assumed correct.
+
+The proofs below are parametric over target and profile. The source selects the same statements in every member of `C`; no debug assertion, overflow-dependent expression, target fact, panic mode, allocator, concurrency, or generated-code premise is used. `AXIOM-UU-1` expressly covers all targets/profiles in `C`. The local nonzero dataflow proof is likewise configuration-independent. The unresolved dependency-implementation obligation remains unresolved throughout `C`. No configuration was sampled or tested.
+
+## TCB audit log
+
+TCB ID is the `TCB.md` digest above. Trust policy admits the verified versioned Rust authority but expressly rejects trust in the unavailable third-party unsafe implementation.
+
+| ID | Category/disposition | Exact proposition, scope, and consumer |
+|---|---|---|
+| `AXIOM-UU-1` | AXIOM / accepted | Rust 1.80.0 `std::hint::unreachable_unchecked`: [“Reaching this function is Undefined Behavior.”](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) Verified at the exact versioned page; it states no narrower target/profile condition. Applies throughout `C`; consumed by `O-F1`. Re-review if Rust scope or cited contract changes. |
+| `UNSAFE-DEP-1` | UNSAFE-DEP / rejected, not consumable | For exact `peer-unsafe-dep` 3.4.5 throughout `C`, every execution of `duplicate_nonzero(v)` with `v != 0` is UB-free and returns `v`. No implementation/audit is supplied, and the human trust decision expressly declines admission. Blocks `O-D2` and the return postcondition. Resolve by recursive source audit or explicit human acceptance of this exact proposition; re-review on dependency identity, contract, feature, target, or profile change. |
+
+There are no SAFE-DEP, tool, implementation, external, environment, or compatibility entries. No tool-derived evidence was supplied or consumed.
+
+## Obligation ledger and proofs
+
+### `O-F1` — `force_unreachable` must be sound for every safe call
+
+At `lib.rs:4`, any caller may enter through a safe, argument-free public function. Control then unconditionally reaches the sole statement, the unsafe call at `lib.rs:6`; there is no branch, check, input, or invariant that can make this site unreachable. By `AXIOM-UU-1`, reaching that call is UB. Thus the well-typed safe invocation `force_unreachable()` is a valid in-scope use whose execution reaches UB, uniformly over `C`. This proves **UNSOUND**.
+
+The line-5 comment, “This site is assumed to be unreachable,” supplies no fact and is circular: the public function entry makes the site reachable. It is therefore a deficient proof artifact as well as an implementation defect.
+
+### `O-D1` — satisfy the dependency's caller precondition
+
+For a valid call of `delegated_nonzero`, its published safety contract at `lib.rs:11-13` gives `value != 0`. Line 17 passes that same, unmodified `u8` to `duplicate_nonzero`. The submitted dependency contract requires exactly `value != 0`. Identity plus the caller fact entails that precondition for every valid wrapper call throughout `C`. **PROVED.** The adjacent comment adequately explains this caller-side step.
+
+### `O-D2` — establish provider implementation soundness
+
+The wrapper's soundness additionally requires every permitted execution of the dependency call, after `O-D1` is satisfied, to be UB-free. A declaration and caller contract constrain valid callers; they do not prove that an unavailable unsafe implementation honors its promise. `UNSAFE-DEP-1` is rejected, and no recursive implementation proof exists. The smallest missing proposition is: “For every `v: u8` with `v != 0` and every configuration in `C`, every execution of exact `peer-unsafe-dep` 3.4.5 `duplicate_nonzero(v)` is free of Rust UB.” Therefore `O-D2`, and hence `delegated_nonzero` soundness, is **UNPROVED**. No valid UB witness is established, so `UNSOUND` is not justified.
+
+The return-equality guarantee separately needs the additional conjunct that every such UB-free execution returns `v`; it is also absent. No proof-comment rewrite alone can close either provider obligation.
+
+## Findings and required resolutions
+
+`F-1` (**UNSOUND**, all of `C`): remove the unconditional unsafe call or replace it with defined behavior such as a safe panic. Merely changing the comment cannot repair the proof. Making a formerly safe API unsafe or changing documented behavior requires compatibility review. Re-audit all uses and all of `force_unreachable` after remediation.
+
+`F-2` (**UNPROVED**, all of `C`): recursively audit the exact dependency implementation over `C`, or obtain authorized acceptance of `UNSAFE-DEP-1` with exact identity and configuration scope. An exact version pin and published unsafe contract are insufficient. Re-audit both soundness and return behavior after resolution.
+
+Residual scope is limited to the unavailable dependency implementation and its omitted artifacts. Review is also triggered by any source/API contract change, Rust version or support-domain change, dependency resolution/contract change, or TCB disposition change. There is no authoritative Rust-documentation gap and no skill-guidance gap identified.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r057/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r057/1/attestation.json
new file mode 100644
index 0000000000..b0769a45c2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r057/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r057",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:40:58.749087Z",
+  "report_sha256": "46a2e9a7de676f0249b9a248e2d2d18a0894fb0379999bc3721cb31e84c4db9d",
+  "run_id": "r057",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 852
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r057/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r057/1/report.md
new file mode 100644
index 0000000000..28fcb1744f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r057/1/report.md
@@ -0,0 +1,48 @@
+# Multi-release source-only unsafe Rust audit
+
+## Claim, snapshot, and boundary
+
+Artifact: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; audit cutoff 2026-07-31. For each exported unsafe function independently, the claim is: for every listed Rust release, every target on which the item exists, every ordinary debug/release profile, and every call satisfying its documented safety contract, evaluating the exact body is free of Rust undefined behavior and establishes each stated postcondition, relative only to the accepted TCB below.
+
+The complete reachable surface is four stateless exported unsafe functions: `acknowledge`, `store_word`, `copy_byte`, and `load_word`. There are no exported safe wrappers, fields, constructors, traits/impls, macros, generated artifacts, `cfg` branches, dependencies, callbacks, or invariant-bearing state in the submitted source. Thus target and profile are parametric axes: the source operation does not vary, and each proof below covers every such case to which its cited premise applies. This is a Rust source-semantics result, not a compiler-backend or binary theorem.
+
+`SUPPORT.md` directly defines explicit finite sets, so no interval normalization is used:
+
+- `V_ack = V_copy = V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`.
+- `V_store = {1.80.0, 1.81.0}`.
+
+For each claim, `Required = V_api × targets-where-item-exists × {ordinary-debug, ordinary-release}`. No release may be inferred between submitted evidence points.
+
+## Verdict summary
+
+| API | Soundness | Documented postconditions, separately | Aggregate `Covered` | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | **PROVED** on `V_ack` | returns `()`: **PROVED** on `V_ack` (there is no additional prose postcondition) | `Required_ack` | **PROVED**, relative to `SEM-EMPTY-BLOCK-180-182` |
+| `store_word` | **PROVED** on `V_store` | stores `value` at `dst`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop the old `u16`: **PROVED**, each on `V_store` | `Required_store` | **PROVED** |
+| `copy_byte` | **PROVED** on `V_copy` | copies exactly the source byte to `dst`: **PROVED**; leaves the source byte unchanged: **PROVED**, each on `V_copy` | `Required_copy` | **PROVED**, relative to `COMPAT-COPY-180-182` |
+| `load_word` | **PROVED** on `{1.80.0,1.82.0}`; **UNPROVED** on `{1.80.1,1.81.0}` | returns the initialized source `u32`: same regional result; leaves source unchanged: same regional result | `{1.80.0,1.82.0} × targets × profiles` | **UNPROVED** over `Required_load` |
+
+The combined mandatory result for all four APIs is **UNPROVED**, solely because `Required_load ⊄ Covered_load`. No submitted fact proves an in-scope UB execution or a UB-free postcondition counterexample, so neither `UNSOUND` nor `CONTRACT-BROKEN` is certified.
+
+## Obligation proofs
+
+**`acknowledge`.** Its contract imposes no additional caller condition; inspection establishes a zero-parameter, unit-returning function with body exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` states parametrically over every `v ∈ V_ack`, relevant target, and ordinary profile that such a well-typed call has defined callee evaluation and returns `()`, and that `unsafe` changes only the static caller obligation. These facts prove both obligations and `Required_ack ⊆ Covered_ack`.
+
+**`store_word`.** At each member of `V_store`, the applicable [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) contracts require `dst` to be valid for writes and aligned and say that the given value overwrites the location without reading or dropping the old value. The API contract supplies validity for one `u16` and alignment; `value: u16` is supplied by value; the body performs exactly `write(dst, value)`. Therefore soundness and all three postconditions hold in each release case. The two singleton cases exhaust `V_store`, hence their union is `Covered_store = Required_store`.
+
+**`copy_byte`.** The body instantiates `copy_nonoverlapping` with `T=u8,count=1`. The contract supplies readable initialized source, writable destination, both alignments, and non-overlap of the one-byte regions. The accepted compatibility entry imports, for every case in `V_copy`, the exact relevant propositions from [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html): these conditions satisfy the operation contract, one byte is copied to `dst`, and the source is unchanged. Thus every obligation has `Covered = Required_copy`.
+
+**`load_word`.** For 1.80.0, [`ptr::read`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html), [`u32: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) apply. The corresponding [1.82.0 `read`](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html), [`u32: Copy`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) apply at 1.82.0. At each endpoint, the caller supplies readable, aligned, initialized `u32` storage; `read(src)` therefore is defined, returns its value, and leaves the source unchanged, with copying rather than ownership-moving semantics. No authority or accepted compatibility premise applies those propositions to 1.80.1 or 1.81.0. Endpoint agreement cannot cover the interior. The smallest missing propositions are the same `ptr::read`, `u32: Copy`, and Copy-semantic guarantees for both middle releases.
+
+## TCB, findings, and maintenance
+
+TCB identity: submitted `TCB.md`. Both entries are human-accepted and narrowly consumed:
+
+- `SEM-EMPTY-BLOCK-180-182`: only the empty-body evaluation and unit return used by `acknowledge`.
+- `COMPAT-COPY-180-182`: only the enumerated one-byte `copy_nonoverlapping` safety and postcondition propositions used by `copy_byte`.
+
+They are not transferred to `store_word` or `load_word`. There is no tool-derived or test evidence and no other admitted premise.
+
+**Finding F-LOAD-COVERAGE (UNPROVED; evidence/domain closure).** Affects soundness and both postconditions of `load_word` on 1.80.1 and 1.81.0. This is not an established implementation defect: the packet lacks the applicability bridge required for those releases. Resolution requires exact applicable authorities for both releases or an accepted proposition-preserving compatibility entry covering precisely the missing operations and release region. Re-audit on any source/contract/support-set change, either TCB disposition change, or material change to a consumed versioned authority.
+
+Residual scope: compiler implementation, code generation, binaries, nonordinary profiles, targets where an item does not exist, and Rust releases outside the explicit finite sets are excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r058/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r058/1/attestation.json
new file mode 100644
index 0000000000..96a78ea931
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r058/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r058",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:48:58.711366Z",
+  "report_sha256": "0e2fc947abce81854d0af02b955fbfa0b36f0bbcdaa8b7027f450a6b3c3e2d7e",
+  "run_id": "r058",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1018
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r058/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r058/1/report.md
new file mode 100644
index 0000000000..ebc686c112
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r058/1/report.md
@@ -0,0 +1,84 @@
+# Unsafe Rust source review
+
+## Claim and verdict
+
+Snapshot: the supplied `lib.rs`, source-reviewed without execution, expansion, tests, dependencies, or generated artifacts. `Supported(c)` means Rust/stdlib exactly 1.82.0, every target where this source and the used items exist, and every ordinary profile. The claim is source-level freedom from Rust UB for every well-typed safe use, in a context satisfying any explicitly published out-of-scope unsafe obligations.
+
+**Combined soundness verdict: UNSOUND** (`CBI-READ`, `CBI-WRITE`). Separately: `local_proof` implementation **PROVED**, with a deficient proof comment; `published_lane` **PROVED** for every valid `Lane` implementation. `High`'s complete published implementer contract is **PROVED**. There are no other documented postconditions. No conditional application claim is made.
+
+TCB log `R058-TCB-1`: no additional assumptions or dependencies. The accepted Rust 1.82.0 axioms are:
+
+- A1: slice `len` “Returns the number of elements in the slice”; `is_empty` “Returns `true` if the slice has a length of 0.” ([`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len), [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty)).
+- A2: `get_unchecked` and `get_unchecked_mut` return references without bounds checking, and calling either with an out-of-bounds index is UB even if the reference is unused. ([shared](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked), [mutable](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)).
+- A3: `usize` is unsigned (minimum zero), and binary `-` is subtraction; representable subtraction does not overflow. ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types), [operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)).
+- A4: an unsafe trait may impose conditions the compiler cannot verify; implementations must be unsafe and uphold its documented conditions. ([unsafe traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe trait`](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+
+These propositions apply throughout `Supported(c)`. Re-audit on source/contract changes, any Rust/stdlib or support-set change, or a change to these cited contracts.
+
+## Boundary, invariant, and obligation coverage
+
+All language-reachable surfaces were covered: `Position` and its safe caller implementations; safe `read`/`write`; safe `last`; public `Word` tuple construction/field access; unit construction of `High`; unsafe `Lane`, its associated constants and downstream unsafe impl boundary; the in-scope `unsafe impl` for `High`; and safe generic `published_lane::read`. There are no macros, hidden items, dependencies, FFI, generated APIs, or relevant custom drop/auto-trait behavior.
+
+| ID | Exact obligation | Status |
+|---|---|---|
+| CBI-READ | Every safe `Position::position()` result used by shared `get_unchecked` is `< bytes.len()` | **UNSOUND** |
+| CBI-WRITE | Every safe result used by mutable `get_unchecked_mut` is `< bytes.len()` | **UNSOUND** |
+| LOCAL | On the nonempty branch, `bytes.len() - 1` is representable and in bounds | **PROVED**; comment deficient |
+| LANE-IMPL | `High::INDEX < 2`; if index is 0/1, `NAME` is respectively `"low"`/`"high"` | **PROVED** |
+| LANE-READ | Every valid `L: Lane` has an index in the two-element `Word::0` array | **PROVED** |
+
+The only invariant consumed by `published_lane::read` is `LANE-INDEX`: every valid `Lane` implementation has `INDEX < 2`. It is owned by the unsafe trait boundary. `Word(pub [u32; 2])` needs no value invariant: arbitrary safe field replacement preserves the type-enforced length two.
+
+Configuration closure is parametric. There is no conditional source selection. A1–A4 and the type/constant facts cover all targets in scope. Profile overflow behavior is irrelevant: LOCAL proves no underflow; the callback witnesses and lane proof use 0, 1, and length 2. No configurations were sampled.
+
+## Findings
+
+### CBI-READ / CBI-WRITE — safe callbacks do not establish bounds
+
+Implementation and safe-surface classification: **UNSOUND**; proof artifacts are missing. `Position` is safe and caller-implementable, so its method may return any `usize`. No type, check, privacy boundary, or contract establishes either required inequality.
+
+Two independent entirely safe witnesses are:
+
+```rust
+struct P;
+impl callback_index::Position for P { fn position(&self) -> usize { 0 } }
+let _ = callback_index::read(&[], &P); // shared out-of-bounds call
+```
+
+and an implementation returning `1` passed to `write(&mut [0], ..., 7)`. A2 makes each whole execution UB at its respective unchecked call. These UB executions do not establish any defined postcondition refutation.
+
+Smallest requested repair: remove `Position`, accept `position: usize`, and use checked safe indexing while retaining both callable APIs:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 { bytes[position] }
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+Safe callers still choose every position; out-of-range input panics rather than causing UB. Removing the public trait and changing generic signatures is source-breaking, but the request authorizes abandoning that abstraction. This candidate is **not implemented and not certified**; freshly audit its exact implemented snapshot and specified panic/return behavior.
+
+### LOCAL — correct operation, materially inadequate comment
+
+The existing “This is the fast path” neither states A2's bounds obligation nor supplies a fact. Reconstruction: reaching `else` means `is_empty()` returned false. By A1's implication, contraposition gives `len != 0`. A3 then gives `len >= 1`, so `len - 1` is representable and strictly less than `len`. No call or mutation intervenes. A1 identifies that same `len` as the slice's element count; therefore the index is in bounds and A2 permits the shared unchecked access. Empty slices take the branch with no unsafe operation.
+
+Proposed replacement:
+
+```rust
+// SAFETY: This branch establishes `bytes.len() != 0`. Because `len()` is a
+// `usize`, `index = bytes.len() - 1` is representable and `index < bytes.len()`.
+// No mutation intervenes, so `index` is in bounds for this same slice, as
+// `get_unchecked` requires.
+```
+
+The current implementation obligation is **PROVED**; the current adjacent proof artifact remains **deficient**.
+
+### LANE — current contract closes; evolution is constrained
+
+`High` sets `(INDEX, NAME)` to `(1, "high")`, satisfying every literal conjunct. For arbitrary downstream `L`, validity of its unsafe impl supplies `INDEX < 2`; the array type supplies length exactly two, so A2's bound holds. `NAME` is not consumed by this function. An incorrect downstream `unsafe impl` violates an out-of-scope unsafe obligation and is not a safe-use counterexample.
+
+Unknown downstream impls are covered parametrically, not presumed absent. Unknown consumers may rely on the published 1.x `NAME` relation, so deleting or weakening it can invalidate their reasoning; strengthening either obligation can invalidate existing impls. Do not “clean up” that clause based only on this repository-visible consumer. Any contract change needs the applicable breaking-change process and a fresh audit; no change is proposed or certified here.
+
+## Residual scope and attestation
+
+Compiler/backend binary correctness and contexts already violating an unsafe obligation are outside the source theorem. No documentation or skill gap was needed. Every in-scope obligation and safe surface has a disposition; no test result or absence of a counterexample supports any verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r059/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r059/1/attestation.json
new file mode 100644
index 0000000000..f4370d0b4b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r059/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r059",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:49:11.297855Z",
+  "report_sha256": "2ce56cb39ecd21ba188269290a81702a5f56f4eb84cf09a916a019a850d4436a",
+  "run_id": "r059",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 888
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r059/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r059/1/report.md
new file mode 100644
index 0000000000..1f9c0998f6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r059/1/report.md
@@ -0,0 +1,74 @@
+# Unsafe Rust audit — `symbolic-domain-target`
+
+## Claim and verdicts
+
+For the exact supplied snapshot, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior and returns the contained byte for `Some(v)`, or zero for `None`, throughout supported set **S**, relative to accepted TCB entry **COMPAT-OPTION-184-186**.
+
+- **Soundness: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- **Documented result: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- **Combined mandatory result: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- No binary/backend, deployment, security, probabilistic, or extra robustness claim is made.
+
+These are source-level Rust-abstract-semantics results. The accepted compatibility premise is indispensable and is not a claim that any compiler binary is correct.
+
+## Snapshot and supported domain
+
+The audited snapshot comprises all six supplied target files. SHA-256 identities:
+
+| File | SHA-256 |
+|---|---|
+| `CI.md` | `d3ff0564c4f96fcf7e9ff2784dbafcf1baa446c4d44cf3f55371e45b1687e46e` |
+| `Cargo.toml` | `7e25c6b1489e215d6e4ecdc8b7beea11fc35237b3207fb01e836e6c7b4e818f6` |
+| `REQUEST.md` | `161fad09885c67715d35859f24a1c41bd12bcba58c2cd7e1f933670bdda71d21` |
+| `SUPPORT.md` | `45ee272e31a71fe28da355624691db55439d234c92ae8be5ce1af460aed4069c` |
+| `TCB.md` | `db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413` |
+| `src/lib.rs` | `6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8` |
+
+At the 2026-08-01 audit cutoff, **S** is exactly: edition 2021; any released stable Rust `r` with `1.84.0 <= r <= 1.86.0`; target `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; either `telemetry` state; every Cargo profile; and either debug-assertion state. `SUPPORT.md` controls. `Cargo.toml` agrees on the lower bound and edition; its lack of an upper bound is expressly only Cargo admission, not a support conflict. `CI.md` is sample evidence and proves no semantic obligation.
+
+There are no dependencies, build script, generated/expanded artifacts, macros, `cfg` branches, target-specific operations, FFI, assembly, allocation, concurrency, or panic path. The feature is unused. One source implementation therefore applies parametrically to every axis; COMPAT-OPTION-184-186 expressly covers every member of S. No supported combination is uncovered. Releases entering the closed version interval after the cutoff require re-audit.
+
+## Boundary, contracts, and invariants
+
+The complete language-reachable crate surface is the safe public free function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields, types, constructors, methods, traits/impls, statics, reexports, hidden items, callbacks, macros, or destruction behavior defined by this crate. The sole unsafe surface is the internal call `value.unwrap_unchecked()`; callers have no safety obligation beyond passing a well-typed `Option<u8>`.
+
+**RESULT-1:** for every input, return `0` if it is `None`; return `v` if it is `Some(v)`. No persistent abstraction invariant exists. The only transient fact is **BRANCH-SOME**: on the fallthrough edge after `is_none()` returned false, the unchanged `value` is `Some(v)` for some `v`.
+
+## Authorities and TCB audit log
+
+The Rust 1.84.0 standard-library page declares `Option<T>` with only `None` and `Some(T)`. Its `is_none` contract says: “Returns `true` if the option is a `None` value.” ([1.84.0 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). Its unsafe method says it returns the contained `Some` value and: “Calling this method on `None` is undefined behavior.” ([1.84.0 `unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+
+**COMPAT-OPTION-184-186** is an accepted, authorized human compatibility premise from `TCB.md`. Exact admitted proposition: for every configuration in S, the 1.84.0 base propositions remain unweakened—`is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; calling it on `None` is UB. Category: out-of-band compatibility premise. Consumers: only SOUND-1 and RESULT-1 below. Limitations: it proves neither S's membership nor Cargo, backend, binary, or other-API facts. Disposition: accepted. Re-audit on any source, interval, base-proposition, target/feature, or disposition change. No other assumption, dependency trust, or tool result is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Obligation | Proof and applicability | Status |
+|---|---|---|---|
+| SOUND-1 | Every safe input avoids calling `unwrap_unchecked` on `None`. | Complete case split below; local control flow plus COMPAT-OPTION-184-186 over all S. | **PROVED relative to COMPAT-OPTION-184-186** |
+| RESULT-1 | Return zero for `None`, contained byte for `Some(v)`. | Same split plus the admitted return proposition, over all S. | **PROVED relative to COMPAT-OPTION-184-186** |
+
+Case `value = None`: COMPAT-OPTION-184-186 makes `is_none()` true. The dominating branch returns literal `0`; the unsafe call is not executed. This proves soundness and the `None` result.
+
+Case `value = Some(v)`: the same premise makes `is_none()` false. `is_none` only borrows the same value, so fallthrough establishes BRANCH-SOME. COMPAT-OPTION-184-186 then supplies both permission and result for `unwrap_unchecked(Some(v))`: the execution has no UB from that call and returns `v`. The two exhaustive `Option` cases prove both universal claims. There is no intervening mutation, callback, unwind, or alternative exit.
+
+## Finding DOC-1 — local proof omits its material authority
+
+- **Classification:** implementation obligations PROVED; proof artifact deficient; maintenance/documentation severity.
+- The adjacent `SAFETY` comment identifies the branch conclusion but does not name the exact `is_none` proposition or the accepted compatibility premise needed across S. This does not change the source verdict because the complete reconstruction appears above.
+- Proposed replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 states, over the complete supported
+// domain, that is_none is true exactly for None and that
+// unwrap_unchecked(Some(v)) returns v. The false branch above, which only
+// borrowed this unchanged value, therefore establishes value = Some(v).
+unsafe { value.unwrap_unchecked() }
+```
+
+No UB witness, UB-free postcondition refutation, authoritative-documentation gap, or skill-guidance gap was established.
+
+## Residual scope and review triggers
+
+Excluded: compiler/backend correctness, emitted binaries, unsupported configurations, and properties not requested. No build, execution, test, macro expansion, or tool-derived proof was used. Re-audit on any source/API/documentation change; support-axis or post-cutoff release change; material change to the cited pages; or weakening, rejection, or broader use of COMPAT-OPTION-184-186.
+
+All in-scope surfaces and obligations have a status; every supported configuration is covered; both mandatory claims expose their accepted TCB dependence. Independent second review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r060/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r060/1/attestation.json
new file mode 100644
index 0000000000..48360da0c6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r060/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r060",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:49:45.753080Z",
+  "report_sha256": "199d71241d40542bdfcb5dff45e6e3f2384eacfe6f21f69747a7eaab44f200d4",
+  "run_id": "r060",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 914
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r060/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r060/1/report.md
new file mode 100644
index 0000000000..2a15e68799
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r060/1/report.md
@@ -0,0 +1,65 @@
+# Focused unsafe Rust source audit
+
+## Claim, snapshot, and domain
+
+The audited snapshot is the submitted `quantifier-target` 0.1.0 package: `lib.rs`, `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, and `TCB.md`. The two exported surfaces are the safe function `force_unreachable()` and the unsafe function `delegated_nonzero(u8) -> u8`. No fields, traits, macros, generated artifacts, `cfg`s, features, build scripts, FFI, concurrency, or other public surfaces are supplied. No build or dynamic evidence is used.
+
+Let
+
+`D = { (Rust 1.80.0, target t, profile p) | this exact source and peer-unsafe-dep 3.4.5 resolve on t, and p is an ordinary debug or ordinary release profile }`.
+
+This is exactly the support expression in `REQUEST.md`; it is retained symbolically rather than replaced by a sampled target inventory. `Cargo.toml` fixes edition 2021 and declares `peer-unsafe-dep = "=3.4.5"`; `DEPENDENCY-API.md` confirms that exact resolution. There are no other submitted configuration axes. Thus `Required = D`. The arguments below are parametric in `t` and `p`, so no target enumeration or profile sampling is used.
+
+The TCB for this report is the submitted `TCB.md` (“TCB-SUBMITTED”). Its sole accepted entry is:
+
+- **AXIOM-UU-1 (Rust authority):** for Rust 1.80.0 throughout `D`, reaching `std::hint::unreachable_unchecked` is undefined behavior. The exact official page was opened and independently verified; its Safety section says, “Reaching this function is *Undefined Behavior*.” ([Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety))
+
+The dependency declaration and submitted documentation establish identity and contract text, not implementation correctness. The human reviewer expressly declined an `UNSAFE-DEP` admission for `peer-unsafe-dep` 3.4.5. There are no compatibility, implementation, tool, or deployment assumptions.
+
+## CLAIM-FORCE — `force_unreachable`
+
+**Exact theorem.** For every configuration in `D` and every well-typed safe invocation of `force_unreachable()`, every permitted execution is free of Rust undefined behavior. Valid use has no input, state, temporal, or caller-side safety precondition because this is a safe API.
+
+**Verdict: UNSOUND throughout `D`, relative to TCB-SUBMITTED.**
+
+Complete existential certificate:
+
+1. **Valid in-scope use:** ordinary safe Rust invokes the exported safe function `force_unreachable()` in any configuration in `D`. The API imposes no precondition, so this invocation is valid.
+2. **Reachability:** the function body has no condition or earlier exit; its sole expression evaluates `unsafe { std::hint::unreachable_unchecked() }`. Therefore that invocation reaches the unsafe operation.
+3. **False safety proposition:** the operation requires that it not be reached. Step 2 proves the negation for the witness.
+4. **UB consequence:** AXIOM-UU-1 directly entails undefined behavior upon reaching it.
+
+The same source-local argument and target/profile-wide axiom cover every member of `D`; optimization level is irrelevant to the source-level UB event. The comment “This site is assumed to be unreachable” supplies no fact and is contradicted by every call. This is both an implementation defect and a deficient proof comment, not merely missing documentation. Because the witness execution contains UB, it establishes no separate UB-free postcondition refutation.
+
+Minimal repair: remove this safe path to `unreachable_unchecked`; for an intentionally callable safe API, use defined behavior such as a panic. Any changed artifact requires a fresh audit.
+
+## CLAIM-DELEGATED — `delegated_nonzero`
+
+**Exact theorem.** For every configuration in `D`, every `value: u8` with `value != 0`, and every unsafe invocation satisfying that sole documented precondition, every permitted execution of `delegated_nonzero(value)` is free of Rust undefined behavior. There are no documented ongoing or terminal caller obligations.
+
+**Verdict: UNPROVED throughout `D`, relative to TCB-SUBMITTED.**
+
+The complete available derivation is:
+
+1. The wrapper contract requires `value != 0`.
+2. The submitted contract of exact dependency API `peer_unsafe_dep::duplicate_nonzero` 3.4.5 has the identical caller-side safety precondition.
+3. At the only unsafe call, the argument is the unchanged `value`. Therefore every valid wrapper invocation satisfies the dependency call’s caller-side obligation. The adjacent SAFETY comment adequately records this local implication.
+4. The wrapper immediately returns the dependency call’s result and contains no other operation that can close the provider-side obligation.
+
+The smallest missing soundness proposition is:
+
+> **DEP-SOUND-1:** For every configuration in `D` and every nonzero `v: u8`, every execution of the exact `peer-unsafe-dep` 3.4.5 implementation of `duplicate_nonzero(v)` is free of Rust undefined behavior.
+
+Neither an exact pin nor the submitted unsafe API declaration proves DEP-SOUND-1. The implementation, generated output, prior audit, and binary are absent, and TCB-SUBMITTED expressly refuses to trust them. Consequently the caller-side obligation has coverage `D`, but the required provider-side obligation has no established covered region; their pointwise conjunction does not establish `Required ⊆ Covered`.
+
+No `UNSOUND` certificate exists: the unavailable body supplies no proved valid execution reaching a false safety proposition. Failure of the universal proof therefore yields `UNPROVED`, not `UNSOUND`.
+
+The dependency documentation also promises “Returns `value`.” If that provider guarantee is treated as a mandatory postcondition of this delegation, the wrapper’s `result == value` postcondition is likewise **UNPROVED**: the additional smallest missing proposition is that every valid, UB-free call to this exact implementation returns its input. There is no UB-free counterexample, so `CONTRACT-BROKEN` is not established.
+
+Minimal resolution: supply and recursively audit the exact dependency implementation and all generated/configuration-specific artifacts, or obtain explicit human acceptance of narrowly stated `UNSAFE-DEP` propositions covering DEP-SOUND-1 (and the return guarantee if consumed) over all of `D`.
+
+## Closure, residual scope, and triggers
+
+For CLAIM-FORCE, the certificate is target- and profile-parametric over `D`. For CLAIM-DELEGATED, the unresolved dependency proposition affects all of `D`; no tested subset can repair it. There is no tool-derived evidence. Binary/backend correctness and targets where the exact package does not resolve are outside this source-level theorem.
+
+Re-audit is required if either exported contract or body changes; Rust/standard-library version or cited semantics changes; the supported target/profile predicate changes; dependency identity, features, documentation, implementation, generated output, or trust disposition changes; or new public/generated surfaces appear.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r061/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r061/1/attestation.json
new file mode 100644
index 0000000000..6e95f8e970
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r061/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r061",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:57:28.007098Z",
+  "report_sha256": "18c6702f1987cf50f6511f0e1d09f515dd468abed2ad03af5d8af962d7e5c27a",
+  "run_id": "r061",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1140
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r061/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r061/1/report.md
new file mode 100644
index 0000000000..7c024640bb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r061/1/report.md
@@ -0,0 +1,97 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Audited snapshot: the supplied `target/lib.rs` in full, reviewed 2026-08-01 using the supplied unsafe-Rust skill snapshot. No generated code, dependencies, features, `cfg`, FFI, assembly, allocator, concurrency, or macro surfaces exist in the supplied target. No code was built, tested, executed, expanded, or modified.
+
+`Required(c) := c uses Rust/stdlib 1.82.0, is a target on which this exact source and the used standard-library items exist, and uses any ordinary profile.` The claim is source-level freedom from Rust undefined behavior for every well-typed safe use, while unsafe-trait implementations satisfy their published safety obligations, plus the requested behavior checks.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All three modules, aggregate soundness | **UNSOUND** | CB-READ and CB-WRITE are distinct valid safe executions reaching UB. |
+| `callback_index::read` | **UNSOUND** | CB-READ. |
+| `callback_index::write` | **UNSOUND** | CB-WRITE. |
+| `local_proof::last` implementation and requested return behavior | **PROVED** | LP below, for all `Required`. Existing proof comment is deficient. |
+| `published_lane::High` contract and `read` soundness | **PROVED** | PL below, for all `Required` and every contract-valid `Lane` implementation. Local proof artifacts are missing. |
+
+There is no `CONTRACT-BROKEN` result. The callback witnesses contain UB and therefore cannot prove a defined-behavior postcondition violation; no independent UB-free refutation was found. The combined mandatory result remains `UNSOUND`, not diluted by the independently proved modules.
+
+## Authority and TCB (`R061-TCB-1`)
+
+There are no additional assumptions. These verified Rust 1.82 axioms are the complete consumed authority:
+
+- AX-SLICE-INDEX: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) require an in-bounds index. Their common safety text states: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.”
+- AX-SLICE-SIZE: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns the element count; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when that count is zero.
+- AX-INTEGER: the Reference identifies `-` as integer subtraction and describes overflow/profile behavior; [`usize` is unsigned](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types). Thus for a nonzero `usize` value `n`, `n - 1` is representable and less than `n`, independently of overflow-check settings. See [binary arithmetic](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators).
+- AX-TRAIT: Rust says correctly implemented unsafe traits are safe to use and implementations must be `unsafe`; the unsafe keyword marks extra conditions implementations must uphold. See [unsafe traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits) and [unsafe-trait obligations](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait).
+
+Disposition: accepted as the governing versioned Rust semantics; no dependency, tool, implementation, external, deployment, probabilistic, or out-of-band entry is consumed.
+
+## Boundary and configuration closure
+
+The safe/caller-reachable inventory is complete: public safe trait `Position` and its caller-supplied method; safe `callback_index::{read, write}`; safe `local_proof::last`; public tuple constructor and field of `Word`; public unsafe trait `Lane` and associated constants; public unit constructor `High`; its `unsafe impl`; and safe `published_lane::read`. There are no hidden or configuration-generated surfaces. Ordinary compiler-supplied move/drop/auto-trait behavior creates no invariant used by an unsafe operation.
+
+The exact source is configuration-invariant. CB-READ/CB-WRITE work on every `Required` target. LP is parametric over every target's `usize` width and does not rely on profile-dependent overflow behavior. PL uses the target-independent array length 2. Therefore each proved obligation has `Covered = Required`, and `Required ⊆ Covered`; no sampled configuration or version-compatibility premise is used.
+
+## Findings and obligation proofs
+
+### CB-READ — safe callback can select an out-of-bounds index
+
+`Position` is a safe, public, downstream-implementable trait with no bound contract. Safe code may define:
+
+```rust
+struct Bad;
+impl callback_index::Position for Bad {
+    fn position(&self) -> usize { 0 }
+}
+let _ = callback_index::read(&[], &Bad);
+```
+
+This is a well-typed safe use. `read` calls `position()` once, then executes `get_unchecked(0)` on a length-zero slice. `0` is out of bounds, so AX-SLICE-INDEX entails UB at the call, before dereference relevance. This closes the full `UNSOUND` certificate: valid use, reachability, false in-bounds proposition, and authoritative UB consequence. The unsafe block has no proof comment, but the implementation defect is independently established.
+
+### CB-WRITE — independent mutable out-of-bounds witness
+
+Using the same safe `Bad` implementation:
+
+```rust
+let mut bytes: [u8; 0] = [];
+callback_index::write(&mut bytes, &Bad, 7);
+```
+
+This safe execution reaches `get_unchecked_mut(0)` on length zero. Its in-bounds condition is false, and AX-SLICE-INDEX entails UB. This is a separate certificate for `write`; exclusive borrowing does not establish bounds.
+
+Documentation cannot add a safety precondition to either safe API. Making or sealing `Position` unsafe would also fail the stated requirement that safe callers choose positions.
+
+**Smallest repair (proposal only):** retain signatures and `Position`, but replace the bodies with `bytes[position.position()]` and `bytes[position.position()] = value`. In-range behavior is retained; arbitrary safe caller-selected positions remain accepted; out-of-range positions panic rather than cause UB; and both unsafe blocks disappear. Changing the parameter to `usize` is an optional, larger API simplification, not needed for soundness. This proposal is **uncertified** until implemented and freshly audited.
+
+### LP — implementation correct; existing comment inadequate
+
+Let `n = bytes.len()`. The empty branch executes no unsafe operation and returns `None`. In the other branch, the dominating `!bytes.is_empty()` and AX-SLICE-SIZE give `n != 0`. AX-INTEGER gives representable `index = n - 1` and `index < n`; AX-SLICE-INDEX therefore permits `get_unchecked(index)`. The returned shared reference designates the final initialized `u8` in the input slice, and copying it yields `Some(bytes[n-1])`. This covers both exhaustive branches and every `Required` profile/target.
+
+The existing `SAFETY: This is the fast path` states neither the operation's precondition nor any fact or derivation. Replace it with:
+
+```rust
+// SAFETY: `bytes.is_empty()` was false, so `bytes.len() != 0`.
+// Therefore `index = bytes.len() - 1` is representable and
+// `index < bytes.len()`, satisfying `get_unchecked`'s bounds condition.
+```
+
+### PL — published contract closes the proof
+
+The published unsafe contract is literal: every valid `Lane` implementation has `INDEX < 2`, and `NAME` is `"low"` for index 0 and `"high"` for index 1. `High` establishes both clauses with `(1, "high")`. For any contract-valid downstream `L`, `Word::0` has exactly two elements and `L::INDEX < 2`; hence AX-SLICE-INDEX permits `get_unchecked`, and `read` returns `word.0[L::INDEX]`. Unknown invalid unsafe impls violate an out-of-scope implementer obligation; they are not hidden premises or valid uses.
+
+Proof artifacts are nevertheless missing. Add adjacent comments equivalent to:
+
+```rust
+// SAFETY: `INDEX` is 1 (< 2), and the required name for index 1 is "high".
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: `Lane`'s published contract gives `L::INDEX < 2`, while
+// `Word::0` has length 2, satisfying `get_unchecked`'s bounds condition.
+```
+
+Because this is a published 1.x unsafe-trait contract, repository-visible users are not exhaustive. Do not strengthen implementer obligations (unknown impls may cease to comply), weaken/remove the `NAME` guarantee (unknown consumers may rely on it), or seal/remove the trait without explicit breaking-change handling. No contract change is needed for the current proof.
+
+## Residual scope and re-audit triggers
+
+No source outside the supplied target, non-ordinary configuration, other Rust release, downstream implementation body, or downstream consumer body was audited. Re-audit after any source or safety-documentation change, repair implementation, support-domain expansion, Rust/stdlib authority change, or change to the published `Lane` contract. All current-artifact verdicts above are independent of the unimplemented proposal.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r062/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r062/1/attestation.json
new file mode 100644
index 0000000000..1360289c3c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r062/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r062",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:58:50.254908Z",
+  "report_sha256": "787f990b31be3392ae20e4b16e9c1f20785006bf90464beb7a352a0b395956ad",
+  "run_id": "r062",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 881
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r062/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r062/1/report.md
new file mode 100644
index 0000000000..be6a79c52c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r062/1/report.md
@@ -0,0 +1,137 @@
+# Unsafe Rust source audit: supplied `conflicting-domain-target` snapshot
+
+## Claim and verdict
+
+**Combined mandatory result: PROVED.** For every well-typed safe call to
+`value_or_zero` in every configuration in `Required` below, the supplied source
+is free of Rust undefined behavior and returns the contained byte for `Some(b)`
+and zero for `None`. This is a source-level theorem for Rust/stdlib 1.84.0,
+1.85.0, and 1.86.0, relative only to accepted `BUILD-MAP-C`; it is not a
+backend/binary theorem. The soundness claim and the documented postcondition
+are each **PROVED**. No `UNSOUND`, `CONTRACT-BROKEN`, or unresolved mandatory
+obligation was found.
+
+Snapshot: the supplied `Cargo.toml`, `src/lib.rs`, two policies, `TCB.md`, and
+request; edition 2021, `#![no_std]`, no dependencies, build scripts, generated
+code, or prior audit. No build, execution, expansion, or test evidence was used.
+Audit cutoff: this supplied snapshot and its three exact releases.
+
+## Domain recovery and closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and
+`f,h` range over Booleans. Preserve the controlling expressions literally:
+
+```text
+S = v∈V ∧ t∈T ∧ [¬f ∨ (f∧t=X∧(¬h∨v≥1.85.0)) ∨ (f∧t=A∧h)]
+I = v∈V ∧ t∈T ∧ [¬f ∨ (f∧t=X∧(h∨v≥1.86.0))
+                  ∨ (f∧t=A∧¬h∧v≥1.85.0)]
+Required = (S ∨ I) ∧ p∈CargoProfiles ∧ d∈{false,true}
+```
+
+`S` and `I` are Scarlet and Indigo respectively. Because both are current and
+no precedence is authorized, `S ∪ I` is used only as a conservative audit
+domain: `S⊆S∪I` and `I⊆S∪I` by union introduction. This does **not** resolve or
+restate the project's support promise.
+
+Define
+`Covered = v∈V ∧ t∈T ∧ f,h∈Bool ∧ p∈CargoProfiles ∧ d∈Bool ∧ ¬(f∧t=W)`.
+Each `f` clause of both policies names only `X` or `A`, while each `¬f` clause
+has `f=false`; hence `Required⊆Covered`. The implementation proof below is
+parametric over all of `Covered`, so policy overlap and disagreement need not
+be enumerated. `h`, profile, and debug-assertion state select no source and
+affect no proof premise.
+
+For all three releases, the Reference says `cfg` conditionally includes its
+attached construct according to its predicate and defines `all` as conjunction
+([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation);
+[cfg attribute 1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute)).
+The versioned macro docs state that `compile_error!` causes compilation to fail
+with its message when encountered ([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+[1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+[1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). With
+`BUILD-MAP-C`, `f∧t=W` therefore includes lines 3–4 and cannot produce a library
+artifact. This is effective rejection, not an audit-only exclusion. Both
+policies already exclude that region. On every remaining case, the complementary
+`cfg(feature="turbo")`/`cfg(not(...))` attributes include exactly one function.
+
+## Boundary, invariant, and obligation ledger
+
+The complete crate-owned reachable surface is one safe free function,
+`value_or_zero(Option<u8>) -> u8`, with two configuration-selected bodies.
+There are no public fields/types, unsafe APIs/traits/impls, callbacks, statics,
+FFI, macros exported by the crate, hidden APIs, custom drop behavior, or
+invariant-bearing representation.
+
+The only local invariant is `INV-SOME`: after the `is_none()` branch falls
+through at lines 15–17, `value` is not `None`, and this remains true until it is
+immediately consumed at line 20. The check/branch produces it; there is no
+intervening mutation, call, callback, unwind point, or alias; `unwrap_unchecked`
+consumes it.
+
+Version-matched std contracts are identical here: `is_none` “Returns `true` if
+the option is a `None` value” ([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none));
+`unwrap_unchecked` returns the contained `Some` value and calling it on `None`
+is undefined behavior ([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked));
+and `unwrap_or` returns the contained `Some` value or the supplied default
+([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or)).
+
+- **OBL-CFG — PROVED:** the partition and rejection are established above.
+- **OBL-NORMAL — PROVED:** for `¬f`, `unwrap_or(0)` is a safe call and its
+  contract gives `Some(b)→b`, `None→0`.
+- **OBL-UNSAFE — PROVED:** for `f`, `is_none()==true` returns zero. Fallthrough
+  means the same value is not `None`, establishing the exact precondition at
+  `unwrap_unchecked`; the call returns the contained byte.
+- **OBL-API/POST — PROVED:** the two input cases and two exhaustive feature
+  cases establish safe-API soundness with no caller precondition and establish
+  the documented result. Their proof is independent of every remaining axis,
+  giving aggregate `Covered` and the closure `Required⊆Covered`.
+
+## TCB audit log
+
+**`BUILD-MAP-C` (accepted human premise, conspicuous and sole additional
+assumption):** for the three exact bundled Cargo releases, supplied manifest,
+named targets, all supported profiles, and this library compilation, feature
+enablement maps exactly to the corresponding feature `cfg`, and `X/A/W` map to
+`target_arch=x86_64/aarch64/wasm32`. It is consumed only by OBL-CFG. It admits no
+Rust semantics, branch correctness, other versions, or backend correctness.
+Re-audit on any identity, manifest/source-cfg, feature/target, or disposition
+change. The versioned Reference/std propositions quoted above are authoritative
+Rust axioms, not expanded build-tool trust. No other TCB entry is consumed.
+
+## Finding: deficient adjacent proof artifact
+
+Implementation status remains **PROVED**, but the line 19 comment compresses
+the material bridge from the exact `is_none` result through fallthrough to the
+unsafe precondition and supplies no contract citation. Suggested replacement:
+
+```rust
+// SAFETY: `Option::is_none` returns true exactly for `None`. Reaching this
+// point means that check returned false for this unchanged `value`, so this
+// `unwrap_unchecked` call is not on `None` and returns its contained byte.
+```
+
+This is a proof-documentation repair only, not a hidden caller condition or a
+current implementation defect.
+
+## Residual scope and triggers
+
+Excluded: compiler/backend/linker/binary correctness, toolchains outside `V`,
+targets outside `T`, unstable/custom-toolchain behavior, and behavior of the
+intentionally rejected `f∧t=W` non-artifact. Re-audit on source, manifest,
+policy or conflict-resolution changes; expansion of versions/targets/features;
+changes to any cited contract or `BUILD-MAP-C`; or introduction of generated
+code, dependencies, unsafe operations, or new public surfaces.
+
+No independent reviewer participated. All in-scope surfaces, obligations,
+postconditions, domain transformations, exclusions, and consumed premises have
+the dispositions above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r063/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r063/1/attestation.json
new file mode 100644
index 0000000000..31d160b882
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r063/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r063",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T07:58:05.669379Z",
+  "report_sha256": "cfa8049918cc9eb89660940173c43c86bda06e974d3ef134b3f82fb21dbcb3af",
+  "run_id": "r063",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 1036
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r063/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r063/1/report.md
new file mode 100644
index 0000000000..d387539998
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r063/1/report.md
@@ -0,0 +1,59 @@
+# Multi-release unsafe Rust source review
+
+## Claim, snapshot, and verdicts
+
+This review covers exactly the four exported `unsafe` free functions in the submitted `lib.rs`, with `SUPPORT.md` (cutoff 2026-07-31), `EVIDENCE.md`, and `TCB.md` controlling. A valid call is a well-typed call satisfying the function's documented `# Safety` obligations. For each API and each required release/target/profile, the soundness claim is that every valid call has defined Rust-abstract-semantics evaluation. Each stated result/post-state guarantee is a separate mandatory postcondition. This is source-level only; no compiler-binary, deployment, security, or extra robustness claim is made.
+
+Let:
+
+- `A = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `S = {1.80.0, 1.81.0}`;
+- `C = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `L = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`, `E = {1.80.0, 1.82.0}`, and `M = {1.80.1, 1.81.0}`.
+
+Every set also quantifies over every target on which the item exists and every ordinary debug or release profile.
+
+| API / independent claim | `Required` | Exact `Covered` | Regional and strongest verdict |
+|---|---:|---:|---|
+| `acknowledge` soundness | `A` | `A` | `PROVED` |
+| `acknowledge` returns `()` | `A` | `A` | `PROVED` |
+| `store_word` soundness | `S` | `S` | `PROVED` |
+| destination receives `value` | `S` | `S` | `PROVED` |
+| old `u16` is not read | `S` | `S` | `PROVED` |
+| old `u16` is not dropped | `S` | `S` | `PROVED` |
+| `copy_byte` soundness | `C` | `C` | `PROVED` |
+| destination receives the pre-call source byte | `C` | `C` | `PROVED` |
+| source byte remains unchanged | `C` | `C` | `PROVED` |
+| `load_word` soundness | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+| returned `u32` equals the pre-call source value | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+| source `u32` remains unchanged | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+
+Thus the strongest combined mandatory verdict is `PROVED` independently for `acknowledge`, `store_word`, and `copy_byte`, and `UNPROVED` for `load_word`. No `UNSOUND` execution or UB-free `CONTRACT-BROKEN` witness is established.
+
+## Derivations and obligation coverage
+
+**`acknowledge`.** The inspected signature has no parameters and returns unit; its body is exactly `{}`. Accepted TCB entry `SEM-EMPTY-BLOCK-180-182`, restricted to this consumer, says exactly that across `A` such a body has defined evaluation and returns `()`, and that `unsafe` changes only the caller obligation. The published contract imposes no additional obligation. These facts entail both rows over all of `A`.
+
+**`store_word`.** For each member of `S`, the corresponding versioned [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) or [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) authority requires `dst` to be write-valid and properly aligned. The API's caller contract supplies both for one `u16`; the source fixes `T = u16` and calls `write(dst, value)` once. The same authorities state that `write` overwrites with the given value “without reading or dropping the old value.” Therefore the call is permitted and establishes each of the three postconditions. The two exact authority regions exhaust `S`.
+
+**`copy_byte`.** The source fixes `T = u8`, `count = 1`. Its caller contract supplies initialized one-byte source readability, destination writability, alignment of both pointers, and non-overlap. The submitted [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) authorities establish permission, one-byte extent, copying rather than moving, destination equality, and source preservation at 1.80.0. Accepted consumer-specific `COMPAT-COPY-180-182` preserves exactly those propositions, without added preconditions, throughout `C` and all required targets/profiles. Hence all three rows are proved on `C`.
+
+**`load_word`.** At each endpoint in `E`, the matching [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) or [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) authority requires a non-ZST source to be read-valid, aligned, and initialized; the caller contract supplies those facts for the source-fixed `T = u32`. The matching endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32) and [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), or [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32) and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html), combine with `read`'s “without moving” and source-unchanged guarantees to prove both postconditions.
+
+For `M`, no submitted authority applies and no accepted TCB entry transfers either endpoint's `ptr::read`, `u32: Copy`, or `Copy` propositions. Similar source and endpoint documentation cannot propagate guarantees forward or backward. The smallest missing premise is the same safety and behavior contract, including applicable `u32` copy semantics, for each release in `M`, or an accepted compatibility proposition covering precisely those releases. All three `load_word` claims therefore remain `UNPROVED` there.
+
+## Boundary, configuration, and evidence closure
+
+The complete submitted source has four public unsafe free-function surfaces and no public safe functions, fields, constructors, traits/impls, macros, hidden/reexported APIs, invariant-bearing state, dependencies, generated artifacts, conditional compilation, callbacks, FFI, assembly, allocation, or concurrency. Each call is its own unsafe boundary; there are no cross-call invariants or transitions.
+
+Configuration coverage is parametric over target and ordinary profile because the source has no configuration branch and every consumed authority/TCB proposition carries the stated target/profile applicability. Release coverage is the explicit finite partition above, not a numeric interval. No builds or tool-derived evidence were used. Regions outside each API's `Required`, nonordinary profiles/flags, binaries/backends, and releases after the cutoff are excluded rather than inferred unsupported by the project.
+
+## TCB audit log and findings
+
+TCB identity is the exact submitted `TCB.md`. Trust policy admits only versioned Rust authorities listed in `EVIDENCE.md` and the two human-accepted `OUT-OF-BAND` entries. `SEM-EMPTY-BLOCK-180-182` is consumed only by `acknowledge`; `COMPAT-COPY-180-182` only by `copy_byte`. Their quantification, exclusions, consumers, and source/support-change re-audit triggers were checked. No entry is transferred to `store_word` or `load_word`; no new premise is admitted.
+
+`F-LOAD-MIDDLE` (`UNPROVED`) is the only verdict-affecting finding: it affects soundness and both postconditions for `load_word` on `M`; there is no admissible release-applicable semantic bridge. Resolution requires the missing versioned authorities or authorized narrowly scoped compatibility entry, followed by re-review.
+
+`F-PROOF-DOC` is non-verdict documentation debt: the three pointer-operation `SAFETY` comments assert “exactly”/“every” precondition but omit the versioned contract clauses and resulting postconditions reconstructed above. A replacement should name the concrete type/count, enumerate the locally inherited caller facts, cite the applicable authority/TCB entry, and state the established post-state. No wording can close `load_word` on `M` without new evidence.
+
+Re-audit on any source/signature/contract change, support-set or cutoff change, material authority change, or change to either TCB entry/disposition. Final attestation: every in-scope surface, soundness obligation, documented postcondition, release region, and consumed premise has a status; `PROVED` is asserted only on the exact covered regions relative to the stated TCB.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r064/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r064/1/attestation.json
new file mode 100644
index 0000000000..910b1a6e55
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r064/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r064",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:05:23.312233Z",
+  "report_sha256": "53cf56027a48090998b1ca7fca43ec1200e98e1e8fe386339909fe1a840ffce4",
+  "run_id": "r064",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1004
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r064/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r064/1/report.md
new file mode 100644
index 0000000000..b40a037b77
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r064/1/report.md
@@ -0,0 +1,146 @@
+# Unsafe Rust source audit: supplied crate snapshot
+
+## Claim and verdicts
+
+Audit cutoff: 2026-08-01. The artifact is exactly the supplied `Cargo.toml`,
+`build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`;
+no expansion, build, execution, test, prior audit, dependency resolution, or
+generated file was used.
+
+**SOUND — UNSOUND.** For Rust/standard library 1.85.1, the complete crate is
+not free of Rust undefined behavior for every well-typed safe use over
+`Required` below, relative only to accepted TCB entry `BUILD-MAP-X` and the
+version-matched Rust axiom `AXIOM-NZ`. Finding F-1 is a complete existential
+certificate.
+
+**POST-PANIC — UNPROVED over `Required`; PROVED over `Required ∧ ¬Bad`.** The
+documented safe-API guarantee “Panics when `value` is zero” holds outside
+`Bad`. In `Bad`, the zero call has UB, so it cannot be a UB-free
+`CONTRACT-BROKEN` witness. No independent UB-free refutation is established.
+
+Thus the strongest combined result over the complete supported domain is
+**UNSOUND**, with the documented zero-input behavior additionally **UNPROVED**.
+
+## Snapshot, domain, and closure
+
+The manifest fixes edition 2021, Rust 1.85.1, no dependencies, feature set
+`{burst}`, and this build script/library. Let
+
+```text
+T = {x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu,
+     wasm32-unknown-unknown}
+A = {system, arena}
+Required(t,b,a,p,d) = t∈T ∧ b∈{off,on} ∧ a∈A
+                      ∧ ¬(t=wasm32-unknown-unknown ∧ a=arena)
+                      ∧ p is any Cargo profile ∧ d∈{off,on}.
+Bad = Required ∧ t=aarch64-unknown-linux-gnu ∧ b=on ∧ a=arena.
+Good = Required ∧ ¬Bad.
+```
+
+This is an equality normalization of `SUPPORT.md:3-16`: the three listed
+targets, both feature states, both BUILD-selected allocators, the single
+wasm/arena exclusion, every profile, and either debug-assertion state.
+`BUILD.md:3-14` restricts supported selection to Cargo plus `build.rs`:
+missing/`system` selects system, `arena` selects arena, and other values are
+rejected. Invented cfgs and manual rustc are outside `Required`.
+
+`build.rs:9-21` exhaustively maps `env::var`: absence creates `system`; the two
+exact accepted strings emit one allocator cfg; non-Unicode or any other string
+panics. `BUILD-MAP-X` establishes Cargo's exact propagation of emitted
+allocator cfg, `burst`, and each target architecture, and establishes that a
+failed script/output write yields no library compilation. The `rustc-check-cfg`
+line declares but does not set values. Therefore accepted builds reach exactly
+one allocator selector. This uses the version-matched [`env::var`
+contract](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html).
+
+The only unsafe-code selector is `Bad` (`src/lib.rs:24-38`). No profile,
+debug-assertion, optimization, panic-strategy, allocator implementation, or
+other target property affects either unsafe operation. Hence the proofs below
+are parametric in those axes: `Covered(SOUND)=Good`, while F-1 refutes SOUND on
+`Bad`; `Good ∪ Bad = Required`.
+
+## Boundary, API, and invariant inventory
+
+The complete language-reachable project surface is build entrypoint `main`
+with `FIXTURE_ALLOCATOR`, compile-time cfg gates, and the one public safe
+function `lane_id(u8) -> NonZeroU8`. There are no public fields, project types,
+unsafe APIs/traits/impls, macros, callbacks, statics, FFI, assembly, generated
+source, or hidden APIs. The only unsafe operations are
+`NonZeroU8::new_unchecked` at `src/lib.rs:31` and `:44`.
+
+Invariant `INV-NZ`: immediately before either unsafe constructor, its argument
+must be nonzero. It is local to `lane_id`; there is no persistent
+invariant-bearing representation. The Rust 1.85.1 contract says “The value must
+not be zero” and that zero produces UB
+([`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)).
+
+## Obligation ledger
+
+| ID | Site/domain | Required proposition | Derivation/status |
+|---|---|---|---|
+| O-CFG | build/configuration | Exact supported reachability and exclusions | Source mapping plus accepted `BUILD-MAP-X`; proved. |
+| O-31 | `lib.rs:31`, `Bad` | `value != 0` | False for safe input 0; **UNSOUND**, F-1. |
+| O-44 | `lib.rs:44`, `Good` | `value != 0` | The active branch executes `panic!` when `value == 0`; reaching line 44 therefore entails nonzero ([comparison](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators), [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)). Proved for every `Good` case. |
+| O-PANIC | `lane_id(0)` | Panic | `Good`: explicit [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html), proved. `Bad`: UB witness, postcondition unproved. |
+
+Line 43's adjacent proof is sufficient: the dominating zero branch and
+control flow establish the exact constructor precondition. Line 30's comment
+is deficient and false: neither the `u8` type nor any check constrains the safe
+argument in burst mode.
+
+## F-1 — supported safe call invokes `new_unchecked(0)`
+
+- **Status:** UNSOUND implementation; missing/invalid proof artifact; affects
+  SOUND and POST-PANIC.
+- **Configuration:** Rust 1.85.1,
+  `aarch64-unknown-linux-gnu`, `burst=on`, allocator `arena`, any Cargo profile
+  and either debug-assertion state. `SUPPORT.md` includes it, `BUILD.md` permits
+  `FIXTURE_ALLOCATOR=arena`, and `BUILD-MAP-X` proves the cfg mapping. It is not
+  the excluded wasm/arena pair.
+- **Valid use:** downstream safe Rust calls public safe `lane_id(0)`; the API
+  has no safety precondition.
+- **Reachability:** the configuration includes `lib.rs:24-32` and excludes
+  `:34-45`; line 31 is executed before return, without testing `value`.
+- **False proposition:** the argument to `new_unchecked` is exactly zero,
+  contradicting `AXIOM-NZ`'s safety requirement.
+- **UB consequence:** the same authoritative Rust 1.85.1 documentation states
+  that zero “results in undefined behavior.” This completes the existential
+  certificate; it does not depend on backend behavior or testing.
+- **Postcondition:** that execution is not UB-free, so it establishes no
+  `CONTRACT-BROKEN` verdict.
+- **Minimal repair:** remove the special unchecked branch and use the checked
+  path in every configuration (or `NonZeroU8::new(value).expect(...)`). Replace
+  line 30 with the actual dominating-check derivation. Re-audit both unsafe
+  sites and the panic guarantee after the change.
+
+## Rejected and residual configurations
+
+For accepted `arena` plus `wasm32-unknown-unknown`, `BUILD-MAP-X` makes both cfg
+predicates true and `lib.rs:15-16` activates `compile_error!`; this exactly
+enforces SUPPORT's sole supported-set exclusion
+([cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute),
+[`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)).
+Invalid Unicode/other allocator values fail in `build.rs`, and `BUILD-MAP-X`
+ensures no library compilation. Neither/both allocator cfgs are also rejected
+by `lib.rs:3-13`, but can arise only through out-of-scope invented cfgs under
+the documented interface. Unlisted targets, manual rustc, future Rust/Cargo,
+and invented flags are unsupported, not claimed rejected, and outside the
+theorem.
+
+## TCB audit log and evidence
+
+- **BUILD-MAP-X (accepted OUT-OF-BAND/IMPLEMENTATION premise):** exactly the
+  Cargo 1.85.1 proposition and scope in supplied `TCB.md:3-32`; consumed only
+  by O-CFG and F-1 reachability/rejection. It admits no script behavior, Rust
+  semantics, backend, or binary claim and is not widened here. Re-audit on any
+  listed identity/source/interface/target/disposition change.
+- **AXIOM-NZ (Rust axiom):** exact Rust 1.85.1 `new_unchecked` nonzero
+  precondition and zero-UB consequence; consumed by O-31/O-44/F-1. Re-audit if
+  the supported Rust or authoritative contract changes.
+
+No dependency, tool-derived, test, generated-artifact, external ABI,
+deployment, probabilistic, or binary premise is consumed. Source-level Rust
+semantics only. Review must recur on source/docs, support/build interface,
+feature/target/profile scope, Cargo/Rust identity, generated cfg mapping, TCB
+disposition, or `NonZero` contract changes. Every discovered obligation and
+documented behavior has a disposition above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r065/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r065/1/attestation.json
new file mode 100644
index 0000000000..c5f1406406
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r065/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r065",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:13:43.767347Z",
+  "report_sha256": "a6eb34fd1d3c89310961cd76a7f61566e7226a18edb237f3540b96bf915b40e2",
+  "run_id": "r065",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 863
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r065/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r065/1/report.md
new file mode 100644
index 0000000000..2394ba2c43
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r065/1/report.md
@@ -0,0 +1,123 @@
+# Focused unsafe-Rust source review
+
+## Claim frame, snapshot, and domain
+
+Reviewed on 2026-08-01: the supplied `Cargo.toml`, `lib.rs`,
+`DEPENDENCY-API.md`, `EVIDENCE.md`, and `TCB.md` for `quantifier-target` 0.1.0.
+The dependency implementation, generated output, binary, and prior audit are
+absent. The complete exported surface in `lib.rs` is the safe free function
+`force_unreachable` and unsafe free function `delegated_nonzero`; there are no
+exported fields, types, traits, impls, macros, statics, reexports, or
+configuration-specific items in the submitted source.
+
+Let
+
+`D = {(Rust 1.80.0, t, p) | this exact source and peer-unsafe-dep 3.4.5 resolve
+for target t, and p is an ordinary debug or ordinary release profile}`.
+
+This is the request's controlling expression, retained symbolically: the
+packet does not justify enumerating its target projection. `Cargo.toml` pins
+`peer-unsafe-dep = "=3.4.5"`, and `DEPENDENCY-API.md` confirms that exact
+resolution. The reviewed crate has no `cfg`, features, generated code, build
+script, profile branch, target branch, or input-dependent control-flow branch.
+Thus the local source arguments below are parametric over `t` and `p`.
+Dependency-side variation is not available for inspection and is addressed as
+trust, not silently excluded.
+
+## Evidence and TCB
+
+`AXIOM-UU-1.80` is accepted exactly as authorized by `TCB.md`. The opened Rust
+1.80.0 standard-library Safety section states: “Reaching this function is
+Undefined Behavior.” ([versioned source](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+The page identifies rustdoc 1.80.0 and gives no target- or profile-specific
+qualification. It therefore covers all of `D` under the submitted evidence
+policy.
+
+There is no accepted `UNSAFE-DEP` proposition for `peer-unsafe-dep` 3.4.5;
+`TCB.md` expressly declines that trust. The selected-safe-dependency exception
+does not apply to correctness of a third-party **unsafe** API. No tool,
+implementation, compatibility, or deployment premise is admitted.
+
+## Claim 1 — `force_unreachable`: **UNSOUND**
+
+**Exact claim.** For every configuration in `D`, every well-typed safe call to
+`force_unreachable()` is free of Rust undefined behavior. Because the API is
+safe, valid use has no caller-side safety precondition.
+
+**Existential UB certificate (parametric over `D`).**
+
+1. **Valid use:** in any `d in D`, safe code may call the public safe function
+   `force_unreachable()` with no arguments (`lib.rs:4`).
+2. **Reachability:** after entry, its sole, unconditional expression directly
+   calls `std::hint::unreachable_unchecked()` (`lib.rs:6`). There is no guard,
+   earlier divergence, callback, or alternate path.
+3. **False required proposition:** the call site is therefore reached; the
+   required proposition that it be unreachable is false.
+4. **UB consequence:** `AXIOM-UU-1.80` says reaching that function is undefined
+   behavior.
+
+This supplies a valid in-scope UB execution for every member of `D`, so the
+strongest soundness verdict is `UNSOUND`, not merely `UNPROVED`. The local
+comment “This site is assumed to be unreachable” (`lib.rs:5`) is circular and
+false for the witness; it supplies no derivation. No UB-free whole execution is
+claimed as a postcondition witness.
+
+**Required resolution:** remove the unsafe operation (for example, use a
+defined diverging/panicking path), or expose and document a sufficient unsafe
+caller obligation and re-audit the resulting new API. Changing the comment
+alone cannot repair this safe API.
+
+## Claim 2 — `delegated_nonzero`: **UNPROVED**
+
+**Exact valid-use claim.** For every `d in D` and every `value: u8` with
+`value != 0`, every execution of the unsafe call
+`delegated_nonzero(value)` is free of Rust undefined behavior. The inequality
+is the complete documented caller safety obligation (`lib.rs:11-14`); no
+ongoing or terminal obligation is stated. The supplied peer contract also says
+that, on return, `duplicate_nonzero(value)` returns `value`.
+
+**Proved local portion (all of `D`).** The wrapper passes the unchanged
+`value` directly to `peer_unsafe_dep::duplicate_nonzero` (`lib.rs:17`). For
+every valid wrapper call, `value != 0`; this is exactly the dependency's
+documented caller-side precondition. The adjacent safety comment correctly
+proves this call-site obligation. There are no intervening transitions or
+other local unsafe operations.
+
+**Smallest missing propositions.** For the exact implementation selected as
+`peer-unsafe-dep` 3.4.5, over every target/profile in `D`:
+
+- for every `u8 v != 0`, every permitted execution of
+  `duplicate_nonzero(v)` is free of undefined behavior; and
+- on normal return, its result equals `v` (the submitted dependency
+  postcondition).
+
+The declaration and caller contract do not prove that an unavailable unsafe
+implementation fulfills its promise. `DEPENDENCY-API.md` expressly supplies
+no body-execution assertion, implementation artifact, generated output, or
+prior audit, and the only possible implementation premise is rejected by the
+TCB. Consequently the local precondition coverage is `D`, but aggregate
+soundness/postcondition coverage cannot be established for any part of `D`.
+`Required subset Covered` is therefore not certified.
+
+No existential refutation is available either: the packet contains no fact
+showing what the dependency body executes for any valid value. Thus `UNSOUND`
+would be unjustified, and the strongest verdict is `UNPROVED`. The peer's
+return-equals-input guarantee is likewise `UNPROVED`; it cannot be promoted
+from documentation to an implementation fact for this unsafe dependency.
+
+**Required resolution:** recursively audit the exact resolved 3.4.5
+implementation (including relevant generated/configuration-dependent code) and
+prove both propositions throughout `D`. Alternatively, an authorized reviewer
+could accept a precise `UNSAFE-DEP` entry, but the governing trust decision for
+this review expressly refuses that route.
+
+## Closure and residual scope
+
+For Claim 1, the witness proof is target/profile-parametric and the Rust axiom
+covers `D`; no configuration is omitted. For Claim 2, every wrapper-owned
+obligation is proved parametrically, while the dependency-implementation
+obligation remains missing over the entire symbolic target/profile domain.
+No builds, executions, tests, downloads, macro expansions, or dependency-source
+claims contribute evidence. Re-audit on source/API changes, Rust-version or
+support-domain changes, dependency identity/contract changes, or provision or
+acceptance of dependency implementation evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r066/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r066/1/attestation.json
new file mode 100644
index 0000000000..1daaaddff2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r066/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r066",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:14:32.817004Z",
+  "report_sha256": "86d896a590d75d6ab764037f04ed282c3a6fc822d7278bd68929a8b8f9de97d5",
+  "run_id": "r066",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1136
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r066/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r066/1/report.md
new file mode 100644
index 0000000000..32a16cb9e3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r066/1/report.md
@@ -0,0 +1,64 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, scope, and verdicts
+
+Audit date/cutoff: 2026-08-01. The audited snapshot is exactly the supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, and `src/lib.rs`. No build, execution, test, expansion, or implementation/backend claim is used. The source-level theorem quantifies over every well-typed safe use of the complete crate under Rust/Cargo/stdlib 1.85.1 and every supported configuration below, relative only to TCB revision `BUILD-MAP-X` and the cited Rust 1.85.1 semantics.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Freedom from Rust UB over the complete supported domain | **UNSOUND** | `F-UB-1`: a valid safe `lane_id(0)` call in a supported reachable configuration executes `new_unchecked(0)`, which its exact std contract declares UB. |
+| The documented behavior “Panics when `value` is zero” over the complete supported domain | **UNPROVED** | It is proved on the non-defective supported region. In the defective region the available zero-input witness contains UB, so it cannot certify `CONTRACT-BROKEN`; no independent UB-free refutation was established. |
+| Both claims on supported configurations other than `aarch64 + burst + arena` | **PROVED** | Case proof `P-GOOD` and closure below. |
+
+Combined mandatory result: **UNSOUND** for soundness and **UNPROVED** for the zero-input panic guarantee; therefore the complete-crate claim is not `PROVED`.
+
+## Exact domain and configuration closure
+
+Let `T` range over `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, `B` over both `burst` states, `A` over `{system, arena}`, `P` over every Cargo profile, and `D` over both debug-assertion states. For successful build-script stdout writes,
+
+`Required = Rust/Cargo/stdlib 1.85.1 ∧ T in the listed set ∧ B∈{off,on} ∧ A∈{system,arena} ∧ P arbitrary ∧ D∈{off,on} ∧ ¬(T=wasm32-unknown-unknown ∧ A=arena)`.
+
+This is an exact normalization of `SUPPORT.md`; `Cargo.toml` fixes the package, edition 2021, toolchain floor/equality supplied by policy, library path, build script, and the two feature states. `BUILD.md` and `build.rs` map an absent variable or `system` to `A=system`, and `arena` to `A=arena`. `std::env::var` returns the process value, `NotPresent` for an unset variable, and `NotUnicode` for a non-Unicode value ([Rust 1.85.1 `env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html)). Local match arms emit exactly one accepted selector or panic. `BUILD-MAP-X` then admits only that Cargo 1.85.1 passes each emitted selector, maps the feature and the three triples to their named cfgs, reruns as stated, and produces no library compilation after an unsuccessful script. This does not trust what the script emits.
+
+The source cfgs form the exhaustive partition
+
+`BAD = Required ∧ T=aarch64-unknown-linux-gnu ∧ B=on ∧ A=arena`
+
+and `GOOD = Required ∧ ¬BAD`. Profiles and debug assertions do not select or alter either implementation, so both proofs are parametric over `P` and `D`. For `GOOD`, the specialized block is absent and the other block is present. Primitive `u8` equality decides `value == 0` ([comparison operators](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)); when true, Rust executes the consequent block ([`if` semantics](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)), whose `panic!` “Panics the current thread” ([`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html)). When false, reaching the unsafe call proves `value != 0`. Thus `P-GOOD` covers every `u8`, target, feature, allocator, profile, and assertion state in `GOOD`; `GOOD ⊆ Covered(P-GOOD)`.
+
+Rejected cases are outside `Required` and do not conceal UB:
+
+- `wasm32-unknown-unknown + arena`, with either feature state, selects the unconditional-in-that-case `compile_error!` before a library artifact can be produced. This exactly enforces the sole support-policy exclusion.
+- Any Unicode allocator value other than `system` or `arena`, and any non-Unicode value, reaches `panic!` in `build.rs`; by `BUILD-MAP-X`, an unsuccessful script yields no library compilation. A missing value is accepted as `system`.
+- Build-script stdout failure is explicitly excluded by `BUILD-MAP-X` and also yields no compilation. Manually invented missing or simultaneous allocator cfgs are outside `BUILD.md`'s theorem; the first two `compile_error!` guards reject them nonetheless.
+
+## Boundary, invariants, and obligation ledger
+
+The complete downstream safe API surface is the public free function `lane_id(u8) -> NonZeroU8`. There are no crate-owned public fields, constructors, traits/impls, callbacks, statics, FFI, reexports, hidden APIs, or exported/generated macros. `burst` and the allocator environment interface are configuration surfaces. The only unsafe operations are the two cfg-complementary `NonZeroU8::new_unchecked(value)` calls.
+
+There is no enforceable abstraction invariant establishing that arguments are nonzero. The sentence “Burst-mode lane identifiers are never zero” is merely a false assertion about an unconstrained safe argument. On `GOOD`, a per-call dominating check establishes the needed fact; it is not a type-wide invariant.
+
+| ID | Obligation and domain | Proof/status |
+|---|---|---|
+| O-CFG | Recover accepted selectors, cfg reachability, and rejection | Source control flow plus `BUILD-MAP-X`; **PROVED** as above. |
+| O-NZ-GOOD | `new_unchecked(value)` requires `value != 0`, on `GOOD` | Zero panics; false branch implies nonzero; **PROVED**. |
+| O-NZ-BAD | Same requirement on `BAD` | False for safe input zero; **UNSOUND**, `F-UB-1`. |
+| O-PANIC | Zero input panics | **PROVED** on `GOOD`; **UNPROVED** on `BAD` because the execution has UB. |
+| O-CLOSE | Aggregate supported-domain coverage | `GOOD` and `BAD` exhaust `Required`; the existential certificate on `BAD` establishes the strongest full-domain verdict. |
+
+## F-UB-1 — supported safe call violates `NonZero`'s contract
+
+- **Status/severity:** **UNSOUND**, implementation defect; adjacent proof comment deficient.
+- **Valid in-scope use:** Choose Rust/Cargo 1.85.1, target `aarch64-unknown-linux-gnu`, `burst` enabled, `FIXTURE_ALLOCATOR=arena`, any supported profile/assertion state, and call public safe `lane_id(0)`. `SUPPORT.md` includes this configuration (only wasm+arena is excluded); safe callers have no precondition.
+- **Reachability:** `build.rs` emits `fixture_allocator="arena"`; `BUILD-MAP-X` supplies that cfg, `feature="burst"`, and `target_arch="aarch64"`. Therefore the first cfg block is compiled and its unconditional return executes `NonZeroU8::new_unchecked(value)` with zero; the checked complementary block is absent.
+- **False safety proposition and UB consequence:** Rust 1.85.1 documents that `new_unchecked` creates without checking, that a zero value “results in undefined behavior,” and requires “The value must not be zero” ([exact `NonZero::new_unchecked` contract](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). The reached argument is exactly zero. This closes every existential `UNSOUND` link.
+- **Postcondition classification:** this same execution cannot prove `CONTRACT-BROKEN`, because it is not UB-free as a whole.
+- **Minimum repair:** perform the zero check in every configuration, then retain only the checked unsafe call (or use safe `NonZeroU8::new` and handle `None`). Suitable adjacent proof: `The preceding value == 0 branch panics, so reaching this call proves value != 0, exactly satisfying new_unchecked's safety requirement.` Re-audit all cfg cases after the change.
+
+## TCB audit log and residual scope
+
+`BUILD-MAP-X` is **accepted** exactly as written in supplied `TCB.md`: Cargo 1.85.1, this manifest/build script/environment/library, all supported profiles, successful-write scope, selector/feature/target propagation, rerun behavior, and halt-on-script-failure. Consumers are only O-CFG and reachability in `F-UB-1`. It admits no build-script source correctness, emitted string, Rust semantics, backend, or binary proposition; none was widened. Re-audit triggers are exactly its listed identity/interface/source/target/disposition changes.
+
+The Rust axioms consumed are the versioned pages cited above, especially the exact `new_unchecked` precondition and UB consequence. There are no third-party dependencies, tool-derived facts, prior reports, tests, external specifications, deployment assumptions, or binary claims. Unsupported/manual cfgs and failed build attempts have only the rejection accounting stated above. Re-audit on any supplied source, support/build contract, Rust/Cargo/stdlib version, cfg/feature/target/profile domain, cited semantic contract, or TCB disposition change.
+
+Auditor: source-review agent. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r067/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r067/1/attestation.json
new file mode 100644
index 0000000000..35af4d6624
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r067/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r067",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:15:14.095838Z",
+  "report_sha256": "06e79bd6b8b63d837b56c80f95a012f301f5b47ab10d2112882ae72c41f0ea7f",
+  "run_id": "r067",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 904
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r067/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r067/1/report.md
new file mode 100644
index 0000000000..145cd3c312
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r067/1/report.md
@@ -0,0 +1,45 @@
+# Source-only audit of four exported unsafe APIs
+
+## Claim, snapshot, and domain
+
+Snapshot: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`, audited at the support cutoff 2026-07-31. Scope is source-level Rust abstract-semantics soundness plus every documented postcondition of `acknowledge`, `store_word`, `copy_byte`, and `load_word`. A valid use satisfies the API's documented safety clauses. No backend/binary claim is made. No build, execution, expansion, generated artifact, dependency, or prior result is used.
+
+Let `D={ordinary-debug, ordinary-release}` and `C_A(V)={(v,t,p) | v in V, A exists on target t, p in D}`. `SUPPORT.md` explicitly defines finite sets, so no interval inference is involved:
+
+- `Required_ack=C_ack({1.80.0,1.80.1,1.81.0,1.82.0})`.
+- `Required_store=C_store({1.80.0,1.81.0})`.
+- `Required_copy=C_copy({1.80.0,1.80.1,1.81.0,1.82.0})`.
+- `Required_load=C_load({1.80.0,1.80.1,1.81.0,1.82.0})`.
+
+This is an exact normalization of each controlling expression: membership is listed explicitly and `SUPPORT.md` excludes every other release. The source has no `cfg`, feature, profile branch, macro, FFI, concurrency, allocator, or generated code. Thus target/profile coverage is parametric wherever the cited source-level contract or accepted TCB entry covers a release; only release applicability partitions the claims.
+
+## Results
+
+| API | Soundness | Documented postconditions, separately | Aggregate `Covered` | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | **PROVED** on `Required_ack` | returns `()`: **PROVED** on `Required_ack` | `Required_ack` | **PROVED** relative to `SEM-EMPTY-BLOCK-180-182` |
+| `store_word` | **PROVED** on `Required_store` | (1) stores `value` at `dst`; (2) does not read the old `u16`; (3) does not drop it: each **PROVED** on `Required_store` | `Required_store` | **PROVED** |
+| `copy_byte` | **PROVED** on `Required_copy` | (1) destination receives the pre-call source byte; (2) source byte remains unchanged: each **PROVED** on `Required_copy` | `Required_copy` | **PROVED** relative to `COMPAT-COPY-180-182` |
+| `load_word` | **PROVED** on `C_load({1.80.0,1.82.0})`; **UNPROVED** on `C_load({1.80.1,1.81.0})` | (1) returns the pre-call initialized `u32`; (2) source remains unchanged: each has the same regional split | `C_load({1.80.0,1.82.0})` | **UNPROVED** over `Required_load` |
+
+The strongest combined packet verdict is **UNPROVED** because `Required_load` is not contained in its aggregate `Covered`. No existential UB or UB-free postcondition counterexample is established, so neither `UNSOUND` nor `CONTRACT-BROKEN` applies.
+
+## Obligation ledger and derivations
+
+**ACK-S/P.** The body is syntactically exactly `{}` and the signature has no parameters and unit return. Accepted entry `SEM-EMPTY-BLOCK-180-182` states, for every required release/target/profile case, that such a body has defined evaluation and returns `()`, and that `unsafe` changes only the caller obligation. The documentation imposes no additional caller requirement. This proves soundness and the unit result; full-set closure is immediate.
+
+**STORE-S.** At both required releases the call is exactly `ptr::write::<u16>(dst,value)`. The caller contract supplies `dst` valid for writes of one `u16` and properly aligned, exactly the two safety clauses on the [1.80.0 contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and independently on the [1.81.0 contract](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html): “valid for writes” and “properly aligned.” Therefore each executed unsafe operation meets its applicable contract. **STORE-P1/P2/P3.** Each page says the operation overwrites with the given value “without reading or dropping the old value.” This directly entails all three postconditions. The exhaustive release partition `{1.80.0} union {1.81.0}` equals `V_store`.
+
+**COPY-S.** The local facts are `T=u8`, `count=1`, and exactly the documented source/destination alignment, access, initialization, and non-overlap obligations. The [1.80.0 operation contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) requires read/write validity, alignment, and non-overlap for `count*size_of::<T>()`; [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>()=1`. The stronger initialized-source clause is sufficient. This closes 1.80.0. Accepted `COMPAT-COPY-180-182` preserves these exact premises and the operation's satisfaction for every required release/target/profile case. **COPY-P1/P2.** The operation copies the one byte. [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and the [Copy contract](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)—“always a simple bit-wise copy”—permit both resulting values; the accepted entry explicitly preserves destination equality and unchanged source throughout `V_copy`. Hence each obligation covers all `Required_copy`.
+
+**LOAD-S.** For release 1.80.0, the exact `ptr::read::<u32>` call receives the three facts required by the [1.80.0 contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html): readable, aligned, and properly initialized. The same derivation independently uses the [1.82.0 contract](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) at 1.82.0. **LOAD-P1/P2.** Both pages state that `read` reads without moving and leaves source memory unchanged. The endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [Copy 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [Copy 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish safe coexistence and value preservation at those endpoints. No authority or accepted TCB proposition covers 1.80.1 or 1.81.0. Endpoint samples do not cover the intervening members, and `COMPAT-COPY-180-182` expressly excludes `ptr::read`. The smallest missing proposition is preservation, at 1.80.1 and 1.81.0, of the cited `ptr::read` safety and return/source guarantees plus `u32: Copy` semantics.
+
+## Boundary, TCB, findings, and maintenance
+
+The complete public surface in `lib.rs` is the four unsafe free functions; there are no safe wrappers, public fields, traits/impls, callbacks, hidden items, reexports, macros, representation invariants, or later unsafe consumers. Each caller-facing safety contract is sufficient for the covered regions. The short local `SAFETY` comments correctly identify the callee-contract handoff; release applicability is supplied by this evidence packet.
+
+TCB revision is the submitted `TCB.md`: `SEM-EMPTY-BLOCK-180-182` (accepted OUT-OF-BAND semantics; consumer only ACK-S/P) and `COMPAT-COPY-180-182` (accepted OUT-OF-BAND compatibility; consumers only COPY-S/P). Their exact identities, scope, exclusions, disposition, and triggers were checked; neither is transferred to another operation. All other consumed premises are the exact versioned official pages cited above. No tool-derived evidence or dependency trust is consumed.
+
+**Finding LOAD-COVERAGE (UNPROVED):** affects soundness and both postconditions only for `load_word` on releases 1.80.1 and 1.81.0, across every required target/profile. Resolution requires exact applicable authorities for those releases or a newly authorized, narrowly scoped compatibility premise proving the missing propositions. Re-audit all four claims if source/contracts or support sets change; re-audit consumers if either accepted entry or cited authority changes. Overall closure remains unavailable until `Required_load subseteq Covered_load` is established.
+
+All in-scope obligations have a disposition; every affirmative result above is relative only to the stated authorities and accepted TCB entries.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r068/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r068/1/attestation.json
new file mode 100644
index 0000000000..349a07d6ca
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r068/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r068",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:19:54.215006Z",
+  "report_sha256": "a596f12e22efee1d14c1f64eea7c3a10da7c32d779c496b890874fd4ef2be972",
+  "run_id": "r068",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 921
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r068/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r068/1/report.md
new file mode 100644
index 0000000000..6c068e7472
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r068/1/report.md
@@ -0,0 +1,53 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+The audited snapshot is the supplied `Cargo.toml`, `lib.rs`, `DEPENDENCY-API.md`, `TCB.md`, `EVIDENCE.md`, and `REQUEST.md`. Scope is exactly the two exported functions in `lib.rs`; no dependency implementation, generated dependency output, binary, or prior audit was supplied.
+
+Let `C` be: Rust compiler and standard library 1.80.0, edition 2021; exact resolved package `peer-unsafe-dep` 3.4.5; every target on which this source and that exact dependency resolve; and every ordinary debug or release profile. The submitted source has no `cfg`, features, generated source, build script, profile-dependent assertion, arithmetic, allocation, panic-mode-sensitive cleanup, or target-specific operation. Thus the first result is parametric over `C`; for the second, both the proved local argument fact and the dependency gap are parametric over `C`.
+
+The sole admitted authority is `AXIOM-UU-1`: the verified Rust 1.80.0 standard-library page for [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states, “Reaching this function is Undefined Behavior.” The page identifies version 1.80.0 and places no target/profile qualification on that Safety clause. `TCB.md` accepts this proposition throughout `C`. There is no accepted `UNSAFE-DEP`, implementation, tool, compatibility, or deployment premise.
+
+## Claims and verdicts
+
+| API | Exact valid-use theorem over `C` | Soundness verdict |
+|---|---|---|
+| `pub fn force_unreachable()` | Every well-typed safe invocation, with no caller-side safety precondition, must have every permitted execution free of Rust UB. | **UNSOUND** |
+| `pub unsafe fn delegated_nonzero(value: u8) -> u8` | For every invocation whose caller ensures `value != 0`, every permitted execution must be free of Rust UB. No other caller obligation is documented. | **UNPROVED** |
+
+No additional caller-facing return-value postcondition is documented for `delegated_nonzero`; its sentence says that it delegates the value, not that the result equals it. The dependency's distinct provider contract says “Returns `value`.” If equality of the wrapper's result is intended to consume that contract, it is also **UNPROVED** because the provider implementation proposition below is neither proved nor admitted. No UB-free postcondition refutation is established.
+
+## Complete derivation: `force_unreachable`
+
+1. This is a safe free function. Therefore any well-typed safe call is valid; its prose cannot impose a hidden safety precondition.
+2. Its body has no branch or prior diverging operation. Every execution entering the body evaluates `std::hint::unreachable_unchecked()`.
+3. By `AXIOM-UU-1`, reaching that operation is UB throughout `C`.
+4. Consequently, a safe program that invokes `force_unreachable()` once is a valid in-scope execution that reaches UB. This witnesses **UNSOUND** uniformly for every configuration in `C`.
+
+The adjacent comment, “This site is assumed to be unreachable,” asserts the required conclusion but supplies no fact implying it. It is circular as a proof and cannot move the obligation across a safe API boundary. There is no separate mandatory unsafe-API postcondition for this safe function. Minimum repair would be to avoid `unreachable_unchecked` (for example, use a defined panic/divergence), or arrange that a locally proved impossible branch dominates the unsafe call; merely changing the comment is insufficient.
+
+## Derivation and smallest gap: `delegated_nonzero`
+
+1. The wrapper's controlling Safety contract requires exactly `value != 0`. A valid invocation therefore supplies that fact.
+2. The body passes the same `u8` value, unchanged, to `peer_unsafe_dep::duplicate_nonzero`.
+3. The submitted dependency contract requires exactly that its argument not equal zero. Steps 1–2 completely discharge this caller-side precondition for every valid wrapper call throughout `C`.
+4. Soundness of the wrapper also requires the selected unsafe dependency implementation to uphold its side of the contract. An unsafe function's caller documentation does not prove that its body avoids UB. The exact pin fixes identity but does not establish implementation correctness.
+5. The implementation and prior audit are absent, and `TCB.md` expressly declines any `UNSAFE-DEP` admission. Therefore the smallest missing soundness proposition is:
+
+   **DEP-SND-1:** For exact `peer-unsafe-dep` 3.4.5, every configuration in `C`, and every `v: u8` with `v != 0`, every permitted execution of `duplicate_nonzero(v)` is free of Rust UB.
+
+No supplied premise entails `DEP-SND-1`, so the verdict is **UNPROVED**, not **UNSOUND**: no valid UB witness for the unavailable implementation is established. To rely on the dependency's return promise as well, the additional missing proposition is:
+
+   **DEP-RET-1:** Under the same quantification, every normal UB-free return from `duplicate_nonzero(v)` equals `v`.
+
+The local `SAFETY` comment correctly proves the argument precondition but is not a complete end-to-end proof of provider correctness. Resolution requires either a recursive audit of the exact dependency implementation over all of `C`, or explicit human acceptance of precise `UNSAFE-DEP` entries for `DEP-SND-1` and, if consumed, `DEP-RET-1`.
+
+## Coverage, TCB, and residual scope
+
+The complete exported surface is the safe free function and unsafe free function above; there are no types, fields, constructors, methods, traits/impls, macros, callbacks, statics, FFI items, or reexports in the submitted `lib.rs`. There is no persistent invariant: `delegated_nonzero` transfers a per-call nonzero obligation directly to the dependency.
+
+Obligation status is complete: `force_unreachable` reachability is refuted by the unconditional control flow; the wrapper-to-dependency precondition is proved; dependency provider soundness is unproved; and the dependency return promise is unproved if treated as consumed. No tool-derived evidence was submitted or used. Tests or compilation could not establish the missing universal implementation theorem in any event.
+
+Residual scope consists of the dependency implementation, its generated artifacts, transitive unsafe behavior, prior audits, and binaries. They are not silently excluded from the wrapper theorem: their absence is exactly why it remains unproved. Re-audit is required if either function or contract changes, the supported set changes, the Rust authority changes, dependency identity/implementation/evidence changes, or a `DEP-SND-1`/`DEP-RET-1` trust decision is proposed.
+
+Combined result for the two requested claims: **UNSOUND** for `force_unreachable`; **UNPROVED** for `delegated_nonzero`, relative to the accepted `AXIOM-UU-1` and the explicit rejection of unsafe-dependency trust.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r069/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r069/1/attestation.json
new file mode 100644
index 0000000000..12181a15dd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r069/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r069",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:22:05.239419Z",
+  "report_sha256": "dac13c86e54c024ce799a6b3184e7c6d0e72cb9fdb3ce113aa7ef189c9b65630",
+  "run_id": "r069",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 965
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r069/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r069/1/report.md
new file mode 100644
index 0000000000..2b619ac2f5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r069/1/report.md
@@ -0,0 +1,72 @@
+# Focused unsafe-Rust audit: `lib.rs`
+
+## Claim, snapshot, and verdict
+
+**Snapshot.** Exactly the supplied `lib.rs` (19 lines), with no expansion or generated artifact. The audit covers Rust and standard library 1.82.0, every target on which this source and the two used standard-library items exist, and every ordinary profile. The supplied source has no `cfg`, feature, dependency, FFI, allocator, concurrency, macro, or build-time branch. No prior audit or tool-derived evidence was used.
+
+**Soundness theorem.** Every well-typed safe use of the public items `Slot`, `Tail`, and `increment`, including caller-provided safe `Slot` implementations, must be free of Rust undefined behavior under the documented Rust 1.82 abstract semantics.
+
+**Verdict: UNSOUND.** `increment` is safe but its unchecked access requires a property that the open safe trait does not enforce. This holds throughout the supported set; profiles and targets do not alter the source, array length, index, or applicable Rust 1.82 contract.
+
+**Requested `Tail` behavior: PROVED.** Independently of the whole-surface verdict, for every input `pair`, `increment::<Tail>` returns with element 0 unchanged and element 1 equal to its prior value plus one modulo `2^32`.
+
+There are no source-documented postconditions. Consequently no `CONTRACT-BROKEN` verdict applies. The user-stated `Tail` requirement is reported separately as an explicit robustness requirement. The UB witness below is not used as a defined behavioral witness.
+
+## Boundary and obligation coverage
+
+| ID | Safe surface / proof site | Disposition |
+|---|---|---|
+| API-1 | Public safe trait `Slot` and safe required method `index() -> usize` | Downstream code may implement it; no bound or behavioral contract constrains the result. |
+| API-2 | Public unit struct/constructor `Tail`; crate impl of `Slot` | `index()` always returns `1`; adequate for the requested path only. |
+| API-3 | Public safe generic `increment<S: Slot>` | Accepts every valid `S: Slot`, then consumes `S::index()` in unsafe code; UNSOUND. |
+| OBL-1 | `pair.get_unchecked_mut(S::index())` | Requires the returned index to be in bounds. No check, type fact, sealed boundary, or trait contract establishes this for arbitrary `S`; refuted by WITNESS-1. |
+| OBL-2 | Same call for `S = Tail` | `Tail::index() = 1`, and `[u32; 2]` has indices 0 and 1; PROVED. |
+| OBL-3 | Tail update | The call returns a mutable reference to element 1; `wrapping_add(1)` computes modular addition; assignment writes that result to element 1. Element 0 is not selected; PROVED. |
+
+There is no owned invariant. The proposition `S::index() < 2` would be needed at API-3, but neither `Slot` nor module privacy establishes it. Proving it for the crate-owned producer `Tail` cannot be reversed into a fact about every implementation of the public trait.
+
+No public fields, unsafe declarations, hidden APIs, reexports, callbacks, custom `Drop`, or generated surfaces occur in the supplied source. The unsafe block has no adjacent `SAFETY` proof. Its proof artifact is therefore missing; more importantly, its general implementation obligation is false, so a comment alone cannot repair it.
+
+## Finding F-1 — safe downstream implementation reaches UB
+
+A valid safe caller can write:
+
+```rust
+struct Oob;
+impl Slot for Oob {
+    fn index() -> usize { 2 }
+}
+
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+The caller contains no unsafe operation and violates no contract: `Slot` is a public safe trait and specifies no restriction. `pair` has length 2, hence index 2 is out of bounds. AX-1 states that calling `get_unchecked_mut` with such an index is UB even if its returned reference is unused. The UB occurs at the unchecked call, before wrapping arithmetic. This is a concrete valid-use witness on every in-scope configuration.
+
+**Minimum current-API repair:** enforce the bound before unsafe use, or change the implementer boundary to a sufficient compiler-enforced unsafe/sealed contract and audit every implementation and consumer. Given the authorized requirements, both retain unnecessary machinery; the specialization below is preferable.
+
+## TCB log TCB-R1
+
+Trust policy: only exact authoritative Rust 1.82 standard-library propositions may be consumed. There are no additional assumptions, dependencies, external specifications, compiler-implementation premises, or tools.
+
+- **AX-1 (accepted, Rust axiom):** Rust 1.82 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut), all in-scope targets/profiles: it “Returns a mutable reference to an element or subslice, without doing bounds checking,” and “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumers: OBL-1, OBL-2, F-1.
+- **AX-2 (accepted, Rust axiom):** Rust 1.82 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add), all in-scope targets/profiles: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” Consumer: OBL-3 and the redesign contract.
+
+Both pages were opened at their exact versioned URLs and checked in context. Re-audit their consumers if those contracts or the Rust version changes.
+
+## Preferred redesign
+
+Remove the unused generic capability and all unsafe code:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    let value = &mut pair[1];
+    *value = value.wrapping_add(1);
+}
+```
+
+**Contract.** This is a safe function with no caller safety precondition. It returns normally with `pair[0]` unchanged and `pair[1] = old(pair[1]).wrapping_add(1)`, equivalently addition modulo `2^32`. The fixed array type makes index 1 locally in bounds; ordinary checked indexing removes the unchecked-operation obligation. AX-2 supplies the arithmetic postcondition. There is no representation invariant, implementer promise, unsafe surface, or additional TCB premise.
+
+**Migration delta.** Delete public `Slot`, `Tail`, the type parameter, and the unsafe block. Change `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Downstream `Slot` implementations and generic calls cease to compile, exactly as authorized; the abstraction is unreleased, so no compatibility commitment is retained. The required observable `Tail` behavior is unchanged.
+
+This is a design proposal, not a verdict for a new artifact. After implementation, freshly audit the exact new source: confirm the old trait/type/generic and all reexports or generated copies are absent; verify Rust 1.82 checked access and AX-2 over the full target/profile set; prove both-element postconditions and all exits; and inventory any surrounding code introduced with the change. Source, API, support-set, or cited-contract changes trigger re-audit.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r070/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r070/1/attestation.json
new file mode 100644
index 0000000000..635ad15f4b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r070/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r070",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:22:05.495365Z",
+  "report_sha256": "79e602e9a2317fa845b12fb497a3d895697a4ccdf81598750451850f95fce1fc",
+  "run_id": "r070",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 882
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r070/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r070/1/report.md
new file mode 100644
index 0000000000..a0ed00a644
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r070/1/report.md
@@ -0,0 +1,51 @@
+# Focused unsafe-Rust audit: `classify`
+
+## Claims and verdicts
+
+This review covers the exact `lib.rs` identified below, compiled with Rust and standard library 1.80.0, on every target where that source and `std::hint::unreachable_unchecked` exist, in every ordinary debug or release profile. A valid use is any well-typed safe call `classify(input)` for a valid `u8`; there is no caller safety precondition.
+
+1. **Freedom from undefined behavior for every valid safe call: `UNSOUND`.** The valid safe call `classify(0u8)` reaches `unreachable_unchecked`, which Rust 1.80.0 defines as UB.
+2. **If `input == 0`, the call panics: `UNPROVED`.** The only source path for zero contains UB. That UB-containing execution proves unsoundness, but cannot establish a UB-free nonpanic witness and therefore cannot establish `CONTRACT-BROKEN`.
+3. **On normal return, the result equals `input`: `CONTRACT-BROKEN`.** The independent, UB-free call `classify(1u8)` normally returns `2u8`, not `1u8`.
+
+The combined mandatory claim is not proved: it has the component results `UNSOUND`, `UNPROVED`, and `CONTRACT-BROKEN` above. These results hold throughout the supported configuration set, relative to TCB `TCB-R1`.
+
+## Snapshot, boundary, and configuration closure
+
+- Source: `target/lib.rs`, SHA-256 `705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+- Scope: the sole language-reachable safe surface, public safe free function `pub fn classify(u8) -> u8`, and its sole unsafe obligation site, the zero arm's call to `unreachable_unchecked`.
+- No fields, constructors, traits/impls, callbacks, macros, generated artifacts, FFI, dependencies other than the named standard-library item, concurrency, allocation, or configuration attributes appear in the supplied source.
+- Supported predicate: exactly Rust/stdlib 1.80.0; any target on which the exact source and item exist; ordinary debug or release. Target and profile do not select different source. The submitted authority states that both axioms below cover this domain. The proof partitions all valid `u8` inputs into `0`, `1`, and `2..=255`; the same control flow and contracts apply parametrically on every supported target/profile. No build or test evidence was used.
+
+## TCB-R1 audit log
+
+Both entries are `AXIOM`s, accepted for this review because `EVIDENCE.md` selected these exact versioned Rust authorities and their wording and applicability were directly verified. They have no dependency, implementation, tool, external-specification, deployment, or probabilistic trust extension.
+
+- **AXIOM-UU.** Rust 1.80.0 documents: “Reaching this function is *Undefined Behavior*.” [Standard-library Safety contract](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). Scope: the submitted supported predicate. Consumer: `OBL-UU`. Re-audit on source, version, supported-domain, item-contract, or applicability change.
+- **AXIOM-SOUND.** Rust 1.80.0 says unsafe code that safe code can misuse to exhibit UB “is *unsound*,” and that unsafe does not permit UB. [Reference UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html). Scope: Rust 1.80.0 source semantics. Consumer: `OBL-SOUND`. Same re-audit triggers.
+
+TCB disposition: accepted and complete for the propositions consumed here. This is a source-level result, not a theorem about any compiler backend or produced binary.
+
+## Invariant and obligation ledger
+
+| ID | Exact proposition and derivation | Status |
+|---|---|---|
+| `INV-UNREACHABLE` | The safety comment claims the zero branch is unreachable. It has no producer or enforcement boundary; `match input` selects that branch exactly when the safe caller supplies zero. | **REFUTED** |
+| `OBL-UU` | Calling `unreachable_unchecked` requires that execution not reach it. For `input = 0`, evaluation selects the first arm, evaluates the harmless local assignments, then reaches the call. By `AXIOM-UU`, that execution has UB. | **UNSOUND** |
+| `OBL-SOUND` | Every valid safe call must be UB-free. The in-scope witness `classify(0u8)` satisfies all safe-API conditions and reaches the UB in `OBL-UU`; by `AXIOM-SOUND`, it refutes the universal theorem. | **UNSOUND** |
+| `OBL-PANIC-0` | For zero, the documented outcome is panic. The source instead reaches UB. Because the execution as a whole contains UB, it supplies no defined behavioral observation and cannot be the required UB-free postcondition refutation. No independent UB-free zero execution is established. | **UNPROVED** |
+| `OBL-RETURN` | For `1`, the second arm normally returns literal `2`; it executes no unsafe operation. Thus `classify(1u8) == 2u8 != 1u8` is a valid UB-free witness. For every `2..=255`, `_ => input` normally returns the input and executes no unsafe operation. For zero, UB prevents a behavioral conclusion. | Overall **CONTRACT-BROKEN**; regional results: `1` **CONTRACT-BROKEN**, `2..=255` **PROVED**, `0` **UNPROVED** |
+
+The three input regions are disjoint and exhaustive, so this ledger covers every valid safe call. The zero-only panic condition is inapplicable for the other two regions.
+
+## Findings and minimum resolutions
+
+**F-1 — reachable `unreachable_unchecked` (`UNSOUND`).** The existing comment merely assumes the exact fact it must prove, and source control flow falsifies it. The zero witness establishes only unsoundness; it does not also establish a broken panic guarantee. Minimum resolution: replace the unsafe call with an actual panic-producing safe path and replace the false safety comment; then audit the changed snapshot.
+
+**F-2 — wrong normal result for one (`CONTRACT-BROKEN`).** `classify(1u8)` is the separate UB-free witness establishing this theorem. Minimum resolution: make the `1` arm return `1`/`input`, or deliberately change the public contract with compatibility analysis, then re-audit.
+
+## Residual scope and attestation
+
+Excluded: binary/backend correctness and behavior outside the supplied file and three requested claims. No design change was implemented, and no target was built, tested, executed, or expanded. There are no authoritative-documentation or skill-guidance gaps needed to decide these claims. Re-audit on changes to source or documentation, Rust/stdlib version, supported targets/profiles, generated inputs, dependencies, or either consumed authority.
+
+Every in-scope API, unsafe site, input region, requested postcondition, configuration class, and consumed TCB proposition has a stated disposition. Auditor: source-review agent; date: 2026-08-01. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r071/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r071/1/attestation.json
new file mode 100644
index 0000000000..ac70d8cff5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r071/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r071",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:29:10.815390Z",
+  "report_sha256": "acbc1ad06963f179d034a1daec025f797ff8576dcda40718197ed2dbdd639acc",
+  "run_id": "r071",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 907
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r071/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r071/1/report.md
new file mode 100644
index 0000000000..f8da4bed52
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r071/1/report.md
@@ -0,0 +1,53 @@
+# Multi-release unsafe Rust source review
+
+## Claim and result
+
+Snapshot: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; audit cutoff 2026-07-31. For each exported unsafe function, the independent claim is: every call satisfying its documented caller obligations is free of Rust undefined behavior and establishes each documented postcondition, for every required release, every target on which the item exists, and ordinary debug/release profiles, relative only to the accepted TCB below.
+
+Let:
+
+- `A = C = L = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `S = {1.80.0, 1.81.0}`;
+- `E = {1.80.0, 1.82.0}` and `M = {1.80.1, 1.81.0}`.
+
+`Covered` is the exact release region on which all premises consumed by a derivation apply.
+
+| API | Required | Covered | Soundness | Documented postconditions | Strongest combined verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `A` | `A` | `PROVED` on `A` | Normal return is `()` (`Q-A`): `PROVED` on `A`; no other postcondition is documented. | **PROVED** on Required, relative to `SEM-EMPTY-BLOCK-180-182`. |
+| `store_word` | `S` | `S` | `PROVED` on `S` | `Q-S1`: stores `value`; `Q-S2`: does not read the old `u16`; `Q-S3`: does not drop it. Each is `PROVED` on `S`. | **PROVED** on Required. |
+| `copy_byte` | `C` | `C` | `PROVED` on `C` | `Q-C1`: destination becomes the source byte; `Q-C2`: source byte is preserved. Each is `PROVED` on `C`. | **PROVED** on Required, relative to `COMPAT-COPY-180-182`. |
+| `load_word` | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M` | `Q-L1`: return equals the initialized source `u32`; `Q-L2`: source remains unchanged. Each is `PROVED` on `E`, `UNPROVED` on `M`. | **UNPROVED** on Required; endpoint region `E` is **PROVED**. |
+
+Thus the combined result for all four requested claims is **UNPROVED** solely because `load_word` is uncovered on `M`. No `UNSOUND` or `CONTRACT-BROKEN` witness is established.
+
+## Boundary and configuration closure
+
+The complete exported surface is four public unsafe free functions; there are no public fields, constructors, safe wrappers or methods, traits, callbacks, macros, hidden items, dependencies, generated artifacts, `cfg` branches, or invariant-bearing state in the submitted source. The only unsafe operations are one `ptr::write`, one `copy_nonoverlapping`, and one `ptr::read`; the empty function has none. Target/profile axes are proof-parametric: source selection and arguments do not vary, the versioned standard-library contracts apply wherever each item exists, and both admitted entries expressly quantify over the stated target/profile domain. No tests or tool-derived evidence were used.
+
+## Obligation ledger and derivations
+
+**A — `acknowledge`.** Local inspection establishes a zero-parameter, unit-returning function whose body is exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies exactly to that fact over `A`, entails defined callee evaluation and `()`, and therefore proves soundness and `Q-A`. “Has no additional safety requirements” leaves no hidden caller premise.
+
+**S — `store_word`.** At both required releases, the submitted [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) pages say it overwrites with the given value “without reading or dropping the old value”; each requires `dst` to be valid for writes and properly aligned. The function's Safety clauses supply those exact requirements for `T = u16`. The single call therefore satisfies its callee contract and the description entails `Q-S1`–`Q-S3` on each member of `S`.
+
+**C — `copy_byte`.** The [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) contract requires readable/writable `count * size_of::<T>()` regions, alignment, and non-overlap, and says it copies that many bytes. The [1.80.0 layout table](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>() = 1`; [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and the [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) establish bit-copy rather than move semantics. Locally, `T = u8` and `count = 1`, so the documented caller clauses entail every callee clause. Accepted `COMPAT-COPY-180-182` preserves precisely these propositions, including `Q-C1` and `Q-C2`, over all `C`; no cross-operation transfer occurs.
+
+**L — `load_word`.** Both submitted [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) pages require readable, aligned, properly initialized storage and say the value is read without moving it while source memory remains unchanged. The caller contract supplies the three requirements. At each endpoint, [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish copy semantics, closing soundness and both postconditions on `E`.
+
+## TCB audit
+
+| Entry | Exact admitted proposition/domain | Consumer | Disposition |
+|---|---|---|---|
+| `SEM-EMPTY-BLOCK-180-182` | Defined evaluation and unit return for the exact empty-function shape, all `A` targets/profiles. | `acknowledge` only | Accepted; local shape verified. |
+| `COMPAT-COPY-180-182` | Preserves the enumerated 1.80.0 one-`u8` copy contract, safety, size, Copy semantics, and both results over `C`. | `copy_byte` only | Accepted; base pages and local type/count verified. |
+
+There are no other admitted premises, pending entries, or dependencies. Re-audit each entry on its stated source, contract, domain, or disposition trigger.
+
+## Findings
+
+**F-L-COVERAGE — `UNPROVED`.** On `M`, the smallest missing proposition is: `ptr::read::<u32>` has the stated three safety requirements and read/unchanged postconditions, and `u32` has the required Copy semantics. Endpoint documentation does not propagate inward or backward, and neither accepted entry applies to `ptr::read`. No UB witness and no UB-free postcondition refutation is established. Resolution requires admissible release-specific authorities or an accepted compatibility proposition covering exactly `M`; then re-audit all `load_word` obligations.
+
+**F-C-PROOF-DOC — proof artifact deficient; implementation proved.** The adjacent `copy_byte` comment omits the material `T = u8`, `count = 1`, `size = 1`, Copy/source-preservation, and compatibility derivation reconstructed above. Suitable replacement: “For `T=u8,count=1`, the caller's one-byte read/write, alignment, and non-overlap clauses satisfy the callee contract; `COMPAT-COPY-180-182` supplies the applicable one-byte copy and source-preservation result.” This does not change the implementation verdict.
+
+Residual scope excludes releases outside Required and binary/backend correctness. Re-audit on source or contract changes, support-set expansion, relevant Rust-documentation changes, or either TCB trigger.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r072/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r072/1/attestation.json
new file mode 100644
index 0000000000..ccbd151e00
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r072/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r072",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:29:11.069262Z",
+  "report_sha256": "c9e2ad98c41d88e0c379eff9f0c5b74f545076ca97483f05bbac2f1c46d1a1a4",
+  "run_id": "r072",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 899
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r072/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r072/1/report.md
new file mode 100644
index 0000000000..5b2adf44bb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r072/1/report.md
@@ -0,0 +1,65 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the exact supplied `lib.rs`, lines 1–18. `REQUEST.md` is the controlling scope. No generated code, dependencies, features, `cfg`, FFI, allocator, concurrency, or build-time inputs appear in the artifact.
+
+Let `Required` be: Rust and standard library 1.82.0, every target on which this exact source and the two used standard-library items exist, and every ordinary profile. The source is identical over that domain; target and profile do not affect the array length, either index value below, or the selected methods. The audit cutoff is this supplied snapshot. TCB-R1 contains only the two verified Rust 1.82.0 standard-library axioms below; it admits no additional assumptions, dependency implementations, tools, compiler backend, or environment.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe use of the public API is free of Rust UB over `Required` | **UNSOUND** | U1 below |
+| For every input `[a, b]`, `increment::<Tail>` returns with `[a, b.wrapping_add(1)]` | **PROVED** | OBL-2–3; `Covered_tail = Required`, hence `Required ⊆ Covered_tail` |
+
+There are no source-documented unsafe-API postconditions. The second claim is the user-required behavior, not a repair or narrowing of the first claim. The combined current-artifact result is **UNSOUND**.
+
+## Authority and TCB-R1
+
+- **AXIOM-SLICE-1 (accepted):** Rust 1.82.0 documents that `get_unchecked_mut` returns a mutable reference to the indexed element or subslice without bounds checking, and: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82.0 slice documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut). Applies to every `Required` case where that item exists; consumed by U1 and P2.
+- **AXIOM-U32-1 (accepted):** `wrapping_add` performs “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82.0 `u32` documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add). Applies throughout `Required`; consumed by P3.
+
+Re-audit these entries if Rust/stdlib version or either cited contract changes. This is a source-level result relative to documented Rust semantics, not a binary/backend claim.
+
+## Boundary and obligation coverage
+
+| ID | Safe surface / proof site | Disposition |
+|---|---|---|
+| API-1 | Public safe trait `Slot` and safe required method `index() -> usize` (lines 3–5) | Downstream safe code may implement it and return any `usize`; no contract or type restriction enforces bounds. |
+| API-2 | Public constructible unit struct `Tail` and its safe `Slot` impl (lines 7–13) | `index()` is locally fixed to `1`. |
+| API-3 | Public safe generic `increment<S: Slot>` (lines 15–18) | Must be sound for every well-typed safe `S`; it invokes caller-controlled safe code, then consumes its result in unsafe code. |
+| OBL-1 | `get_unchecked_mut(S::index())` (line 16) | For the `usize` index, the required proposition is `S::index() < pair.len() = 2`. **False in a valid safe use; U1.** |
+| OBL-2 | `increment::<Tail>` at line 16 | **Proved:** `Tail::index() = 1`, and `1 < 2`; AXIOM-SLICE-1 therefore supplies a mutable reference to element 1. |
+| OBL-3 | Assignment at line 17 | **Proved for `Tail`:** the only write is through that element-1 reference; AXIOM-U32-1 gives the new value `b + 1 mod 2^32`, while element 0 is untouched. |
+
+There are no fields, other constructors, methods, macros, hidden items, reexports, callbacks other than the trait implementation dispatch, or invariant-bearing state in the supplied source. No tool-derived evidence was used.
+
+## U1 — complete UB certificate
+
+A downstream crate can write entirely safe Rust:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0u32, 0u32];
+increment::<Bad>(&mut pair);
+```
+
+This is a valid in-scope use: `Slot` is safe and public, `Bad` is downstream-owned, and `increment` is safe. Dispatch reaches line 16 with index `2`. The borrowed array has exactly two elements, so valid indices are `0` and `1`; `2` is out of bounds. AXIOM-SLICE-1 makes the call itself UB, independently of later dereference. The witness is parametric over every `Required` target/profile because the same source path and constants apply. Thus the universal safe-API claim is **UNSOUND**, not merely unproved.
+
+The unsafe block also has no adjacent `SAFETY` proof. More importantly, no truthful proof comment can close OBL-1: the needed implication `S: Slot => S::index() < 2` is unenforced and refuted above. Behavioral prose on a safe trait would not fix that.
+
+## Preferred redesign (not a verdict on implemented code)
+
+Remove `Slot`, `Tail`, the type parameter, and the unsafe operation. Specialize the sole required capability:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Proposed safe contract: for every input whose old value is `[a, b]`, normal return produces `[a, b + 1 mod 2^32]`; callers have no safety precondition beyond supplying the typed mutable reference. Fixed safe indexing enforces the only projection needed. There is no representation invariant, implementer obligation, generic capability, or unsafe surface to trust. This is more parsimonious than sealing or making `Slot` unsafe because no required consumer needs generic selection.
+
+Migration is intentionally breaking but authorized for this unreleased abstraction: delete downstream `Slot` implementations and change `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls cease to exist; the required element-1 behavior and wrapping arithmetic remain.
+
+The proposal is unimplemented and has no audit verdict. After implementation, audit the new exact snapshot independently: verify its public contract, safe indexing of `1` into `[u32; 2]`, the wrapping result and preservation of element 0, panic/profile independence, configuration closure, and absence of generated or alternate paths. Re-audit on source/API changes, support-domain expansion, or relevant Rust documentation changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r073/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r073/1/attestation.json
new file mode 100644
index 0000000000..7d39737034
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r073/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r073",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:32:09.037982Z",
+  "report_sha256": "40a82f89628eb8235ce387a5caaf04ff4ecfae417bd0404d05f8f307d826509b",
+  "run_id": "r073",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1129
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r073/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r073/1/report.md
new file mode 100644
index 0000000000..6723038b06
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r073/1/report.md
@@ -0,0 +1,162 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Snapshot: the supplied 53-line `target/lib.rs`, including `callback_index`,
+`local_proof`, and `published_lane`. No generated code, dependencies, build
+scripts, FFI, assembly, allocators, concurrency, or prior audit is present.
+Review was source-only; nothing was built, executed, expanded, or modified.
+
+Claim: under Rust/stdlib 1.82.0, on every target where this source and the used
+stdlib items exist, in every ordinary profile, every well-typed safe use and
+every unsafe-trait use satisfying its published safety contract is free of
+Rust UB; additionally, every in-scope unsafe contract clause holds.
+
+**Combined verdict: UNSOUND (F-1).** Component results:
+
+- `callback_index::{read,write}`: **UNSOUND**, independently.
+- `local_proof::last`: implementation **PROVED**; existing `SAFETY` comment
+  deficient (F-2).
+- `published_lane::High`'s unsafe impl and `published_lane::read`:
+  implementation **PROVED** for every valid `Lane` implementation; local proof
+  artifacts deficient (F-3).
+- Documented contract clauses: **PROVED** for the in-scope `High` impl. There
+  are no documented unsafe-function postconditions. No
+  `CONTRACT-BROKEN` witness is claimed.
+
+The TCB is `TCB-R1`: only the Rust 1.82 authoritative axioms cited below; there
+are no additional assumptions, dependencies, tool theorems, or conditional
+application claims.
+
+## Boundary, contracts, and configuration closure
+
+Safe surfaces exhaustively covered: the caller-implementable `Position` trait
+and its safe `position` method; safe `read` and `write`; safe `last`; `Word`'s
+public tuple constructor/field; `High`'s unit constructor; `Lane`'s associated
+constants as exposed through an unsafe implementation boundary; and safe
+`published_lane::read`. Unsafe surfaces are `Lane`, downstream `unsafe impl
+Lane` declarations, and the in-scope `unsafe impl Lane for High`. There are no
+macros, reexports, hidden APIs, custom trait behavior, or invariant-relevant
+drop operations.
+
+`Position` carries no bounds invariant. `Word` needs no abstraction invariant:
+its public field always has type `[u32; 2]`. Contract `LANE-1`, owned by the
+unsafe trait boundary, requires for every valid impl: `INDEX < 2`, plus
+`NAME == "low"` when index 0 and `NAME == "high"` when index 1. Each generic
+consumer may rely on that published contract.
+
+Configuration coverage is parametric. The counterexamples use an empty slice
+and index zero and therefore apply on every included target/profile. The proved
+paths use only slice length, a fixed two-element array, and representable
+`usize` subtraction after proving non-emptiness; pointer width, optimization,
+overflow checks, and panic strategy do not alter the arguments. There is no
+conditional compilation or generated artifact to partition.
+
+## Obligation ledger and proofs
+
+| ID | Site | Required proposition | Result |
+|---|---|---|---|
+| O-1 | callback `read` | callback result is in bounds before `get_unchecked` | false; F-1 |
+| O-2 | callback `write` | callback result is in bounds before `get_unchecked_mut` | false; F-1 |
+| O-3 | `last` | `len - 1 < len` and subtraction is representable | proved; F-2 |
+| O-4 | `High` impl | both clauses of `LANE-1` | proved: `1 < 2`, name is `"high"` |
+| O-5 | lane `read` | `L::INDEX < word.0.len()` | proved from `LANE-1` and array length 2; F-3 |
+
+Rust 1.82 documents that an out-of-bounds call to
+[`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)
+or
+[`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+is UB even if the resulting reference is unused. The remaining authoritative
+premises are: [`len` returns the number of slice elements](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len),
+[`is_empty` means length zero](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty),
+the Rust 1.82 [unsigned-integer domain](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)
+and [integer arithmetic rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators),
+and the rule that an unsafe trait may impose obligations which an
+[`unsafe impl` must uphold](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits).
+These are accepted AXIOM entries in `TCB-R1`, consumed by O-1 through O-5;
+changing Rust version or any cited contract triggers re-audit.
+
+For O-3, the `else` branch establishes `!bytes.is_empty()`, hence
+`bytes.len() > 0`. Because length has type `usize`, subtracting one is
+representable; `index = len - 1` therefore satisfies `index < len`. No call or
+state transition intervenes. This exactly discharges `get_unchecked(index)`'s
+bounds condition; the shared borrow keeps the initialized `u8` element alive
+through the dereference. Thus empty input returns `None`, and nonempty input
+returns its last element without UB.
+
+For O-5, a valid `L: Lane` supplies `L::INDEX < 2`; `word.0` has exactly two
+initialized `u32` elements by its type. Therefore the index is in bounds for
+`get_unchecked`. `&Word` keeps the element alive and shared through the read.
+O-4 establishes that the selected in-scope provider `High` is valid. Unknown
+downstream implementations are not assumed correct: an implementation that
+breaks `LANE-1` violates its caller-side unsafe obligation. The generic proof
+covers every downstream implementation that does satisfy it.
+
+## Findings and repairs
+
+### F-1 — Safe caller controls an unchecked index (UNSOUND)
+
+Safe code can define `struct P; impl Position for P { fn position(&self) ->
+usize { 0 } }`. Calling `read(&[], &P)` is well-typed safe use and invokes
+`get_unchecked(0)` on a length-zero slice. Independently, passing a mutable
+empty slice to `write(..., &P, value)` invokes `get_unchecked_mut(0)`. Each
+complete execution reaches the documented UB; no hidden caller obligation can
+be added to a safe API.
+
+Smallest repair: replace both unchecked expressions with checked slice
+indexing, preserving signatures and caller-selected positions:
+
+```rust
+bytes[position.position()]
+bytes[position.position()] = value;
+```
+
+Out-of-range positions then panic rather than cause UB. Since `Position` need
+not be preserved, a later cleanup may accept `usize` directly, but that is a
+larger, source-breaking change and is unnecessary for soundness. Neither
+proposal is certified: implement it, document panic behavior as desired, and
+freshly audit the new snapshot.
+
+### F-2 — `last` proof comment is materially inadequate
+
+“This is the fast path” states neither the unsafe operation's precondition nor
+the derivation above. Implementation correctness is nevertheless proved by
+O-3. Proposed adjacent replacement:
+
+```rust
+// SAFETY: This branch establishes that `bytes.len() > 0`. Therefore
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// exactly the bound required by `get_unchecked`.
+```
+
+### F-3 — Lane implementation proofs are absent
+
+The published contract is sufficient and the code satisfies it, but neither
+the unsafe impl nor unchecked call records the proof. Add, without changing the
+contract, comments equivalent to:
+
+```rust
+// SAFETY: INDEX is 1 (< 2), and NAME is "high" as required for index 1.
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: Every valid Lane impl guarantees L::INDEX < 2, and word.0 is
+// [u32; 2], so the index is in bounds for get_unchecked.
+```
+
+Because this is a published 1.x unsafe-trait contract with unknown impls and
+consumers, do not strengthen implementer obligations or weaken/remove the
+`NAME` guarantee merely because the visible consumer uses only `INDEX`; either
+change can break downstream safety reasoning. Comment-only proof repair leaves
+the contract unchanged. Any contract change requires compatibility handling
+and a fresh audit.
+
+## Residual scope and attestation
+
+Downstream `Lane` implementations and consumers are not individually audited;
+the result is deliberately parametric over contract-satisfying impls, and no
+repository-visible inventory is treated as exhaustive. No tool-derived or test
+evidence was used. Every in-scope unsafe operation, provider, safe boundary,
+contract clause, target/profile class, and material reconstructed proof has a
+disposition above. Re-audit on source or contract edits, Rust/stdlib or support
+changes, new generated/configured code, or discovery of another consumer
+obligation.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r074/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r074/1/attestation.json
new file mode 100644
index 0000000000..48073b84f7
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r074/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r074",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:36:55.943556Z",
+  "report_sha256": "a4e4c1ea234c10cd9830139d9c8c2d59a1da533003609c68cb81cb4a22a366d9",
+  "run_id": "r074",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 920
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r074/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r074/1/report.md
new file mode 100644
index 0000000000..0bf1a4a5b6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r074/1/report.md
@@ -0,0 +1,56 @@
+# Unsafe Rust Audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Soundness — PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` under `Supported(c)` is free of Rust undefined behavior under the documented Rust abstract semantics.
+
+**Documented behavior — PROVED, relative to the same accepted TCB entry.** In that domain, `value_or_zero(None) == 0` and `value_or_zero(Some(v)) == v` for every `v: u8`.
+
+**Combined mandatory result — PROVED, relative to accepted `COMPAT-OPTION-184-186`.** There is no conditional binary, deployment, security, or probabilistic claim.
+
+`Supported(c)` means: edition 2021; `c.r` is any released stable Rust toolchain satisfying `1.84.0 <= c.r <= 1.86.0`; target is exactly `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `telemetry` is disabled or enabled; and any Cargo profile and either debug-assertion state are used. This is the literal commitment in `SUPPORT.md`; `Cargo.toml`'s `rust-version = "1.84"` is only the Cargo minimum. The sources do not conflict. Audit cutoff: 2026-08-01.
+
+## Snapshot and scope
+
+The artifact is the exact supplied contents of `Cargo.toml`, `src/lib.rs`, `SUPPORT.md`, `CI.md`, `TCB.md`, and `REQUEST.md`; no repository revision or digest was supplied. The crate is `no_std`, has no dependencies or build script, and contains no generated source. Scope is the complete library and its documented safe behavior. No build, execution, test, expansion, or binary/backend claim was used. Skill identity: supplied `unsafe-rust` package, revision unspecified.
+
+The sole language-reachable public surface is safe function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields, types, constructors, trait implementations, macros, reexports, statics, callbacks, FFI items, hidden items, or destruction behavior owned by this crate. The only unsafe operation is `Option::unwrap_unchecked` at `src/lib.rs:11`. There is no persistent representation invariant; the only proof state is the local branch fact.
+
+## Authorities and TCB audit log
+
+The Rust 1.84.0 standard-library page says `is_none` “Returns `true` if the option is a `None` value” and declares `Option`'s `None` and `Some(T)` variants ([1.84.0 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). The version-matched `unwrap_unchecked` contract says it returns the contained `Some` value and is the controlling unsafe operation ([1.84.0 `unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+
+`TCB.md` is the canonical log. Its sole entry, `COMPAT-OPTION-184-186`, is **accepted by the authorized human reviewer**. It admits, for every `Supported(c)`, exactly: (1) `is_none` is true iff the value is `None`; and (2) `unwrap_unchecked(Some(v))` returns `v`, while calling it on `None` is UB. Category: accepted compatibility/out-of-band semantic premise; base identity: the two Rust 1.84.0 pages above. Consumers: only obligations O1–O3 below. It admits neither release membership nor Cargo/backend/other-API facts. No release enumeration is needed: the proof is universal over whichever released stable `r` satisfies the policy predicate. Trigger: any source, interval, base proposition, target/feature/profile/debug scope, or human-disposition change. The entry is precise, non-circular, within its authorized scope, and accepted; no other dependency, implementation, tool, or environmental premise is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Proposition and proof | Domain | Status |
+|---|---|---|---|
+| O1 | If line 11 is reached, `value` is `Some(v)`. On `None`, accepted `COMPAT-OPTION-184-186` makes `is_none()` true, so lines 5–6 return. If line 11 is reached, the test was false; the accepted iff proposition excludes `None`, and `Option`'s exhaustive remaining variant is `Some`. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O2 | The unsafe call never receives `None`; by O1 it receives `Some(v)`. Accepted `COMPAT-OPTION-184-186` therefore gives a defined return of `v`, discharging the exact unsafe precondition. The `None` branch executes no unsafe operation. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O3 | For `None`, accepted `is_none` semantics select line 6, yielding zero. For `Some(v)`, they select line 11, and accepted `unwrap_unchecked` semantics yield `v`. These cases exhaust `Option<u8>`. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O4 | Configuration closure: source has no `cfg`; `telemetry` is declared but unused; target, profile, and debug assertions select no path; there are no allocation, panic, arithmetic, concurrency, FFI, or generated-code obligations. O1–O3 are parametric, and the accepted TCB explicitly has the same configuration quantification. | Entire `Supported(c)` | PROVED relative to accepted TCB |
+
+`CI.md` describes only samples (1.84.0 on one target/feature state and 1.86.0 across targets/feature states). It neither defines support nor contributes proof evidence. No tool-derived evidence was used.
+
+## Finding D1 — deficient adjacent proof artifact
+
+**Implementation classification:** PROVED relative to accepted `COMPAT-OPTION-184-186`. **Proof-artifact classification:** deficient. Lines 9–10 state the correct branch idea, but omit the material `is_none` iff premise, exhaustive-variant step, applicability, accepted TCB bridge, and `unwrap_unchecked(Some(v))` postcondition. This is not an implementation defect, UB witness, or defined postcondition refutation.
+
+Proposed replacement:
+
+```rust
+// SAFETY: Under accepted COMPAT-OPTION-184-186 throughout Supported(c),
+// is_none is true iff value is None. Reaching here means it returned false;
+// Option has only None and Some variants, so value is Some(v). Under the same
+// entry, unwrap_unchecked(Some(v)) is defined and returns v.
+unsafe { value.unwrap_unchecked() }
+```
+
+Minimum resolution: add an adjacent proof with a stable local link to the canonical TCB entry and authoritative contracts. This is documentation maintenance, not a change to the caller contract.
+
+## Residual scope and attestation
+
+Excluded: configurations outside `Supported(c)`, compiler/backend and emitted-binary correctness, non-Rust environments, and undocumented robustness properties. No supported source configuration is uncovered. Re-audit on any source/API/documentation change; support/edition/target/feature/profile/debug change; material change to the cited Rust contracts; TCB disposition or proposition change; dependency/build-generation introduction; or a newly discovered obligation.
+
+Every public surface, unsafe site, mandatory postcondition, supported configuration class, citation, and consumed TCB premise has a disposition above. Every `PROVED` result is expressly relative to the accepted TCB; no absence-of-counterexample or test inference is used. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r075/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r075/1/attestation.json
new file mode 100644
index 0000000000..f08d1aa521
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r075/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r075",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:37:20.047922Z",
+  "report_sha256": "44941853a2458104b934dfa73aa5411c39c4e5c0ac33730d7bd754757f96e176",
+  "run_id": "r075",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 842
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r075/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r075/1/report.md
new file mode 100644
index 0000000000..0173722cae
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r075/1/report.md
@@ -0,0 +1,63 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Soundness — PROVED relative to `TCB.md` / `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior in every configuration in `Required` below.
+
+**Documented result — PROVED relative to the same TCB entry.** Every such call returns `0` for `None` and returns `v` for `Some(v)`.
+
+The combined mandatory result is **PROVED**. This is a source-level Rust-abstract-semantics result, not a claim about a compiler backend or emitted binary.
+
+## Snapshot, scope, and boundary
+
+The audited snapshot is the complete supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`. It is a Rust-2021 `#![no_std]` library with no dependencies, build script, generated source, or prior audit reused.
+
+The complete language-reachable crate-defined API surface is the safe free function `pub fn value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4-13`). There are no public fields, constructors, types, traits or impls, statics, reexports, macros, hidden items, callbacks, FFI, assembly, allocator operations, or concurrency surfaces. The sole unsafe site is the internal `Option::unwrap_unchecked` call at line 12. There is no persistent representation invariant; the only safety fact is the control-flow-local proposition `value != None` at that call.
+
+## Exact supported domain and closure
+
+Let
+
+* `R = { r | r is a released stable Rust toolchain and 1.84.0 <= r <= 1.86.0 }`;
+* `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`;
+* `F = {telemetry disabled, telemetry enabled}`;
+* `P` be every Cargo profile; and
+* `A = {debug assertions disabled, debug assertions enabled}`.
+
+Then `Required = R × T × F × P × A`, for this source and its version-matched standard library. `SUPPORT.md` is controlling: it says the release predicate is exact and expressly supports every cross-product member. `Cargo.toml`'s `rust-version = "1.84"` is only Cargo's minimum-admission statement, as `SUPPORT.md` itself explains; it agrees with the lower bound and does not erase the upper bound. `default = []` and the sole declared feature establish the two feature states. `CI.md` supplies samples only and neither defines nor proves support.
+
+This preserves `R` symbolically. No finite release inventory is substituted, so no unproved “there were no other patch releases” premise is needed. `COMPAT-OPTION-184-186` quantifies over exactly the same released-stable predicate.
+
+`Covered = Required`. The source contains no `cfg`, feature read, target branch, assertion, arithmetic, panic, profile-sensitive operation, generator, or external component. Thus its control-flow proof is parametric over `T × F × P × A`. The accepted compatibility premise is parametric over `R` and all those axes. Their conjunction covers every cross-product member, establishing `Required ⊆ Covered`. CI endpoints are not used in this certificate.
+
+## Authorities, TCB, and proof ledger
+
+The Rust 1.84.0 documentation says `is_none` “[r]eturns `true` if the option is a `None` value” ([versioned page](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). It says `unwrap_unchecked` returns the contained `Some` value and that calling it on `None` is undefined behavior ([versioned page](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). Both exact pages and their version were checked.
+
+`COMPAT-OPTION-184-186` is an accepted human compatibility premise. Its exact consumed proposition is: throughout `Required`, `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; and calling it on `None` is UB. Its only consumers here are the following obligations, matching `TCB.md`. It establishes no release inventory, Cargo fact, backend, or binary fact. No other assumption is consumed.
+
+| ID | Obligation and derivation | Status |
+|---|---|---|
+| O1 | At line 12, `unwrap_unchecked` must receive `Some(v)`. If `is_none()` were true, line 6 returned. On the continuing path it is false; by `COMPAT-OPTION-184-186`, `value` is `Some(v)`. | PROVED over `Required` |
+| O2 | Every safe input is covered. `None` takes the first return and executes no unsafe operation. `Some(v)` reaches line 12 with O1 true, and the TCB premise supplies a defined return of `v`. | PROVED over `Required` |
+| O3 | The same exhaustive cases return respectively `0` and `v`, exactly the documented behavior. Both executions are UB-free as established by O2. | PROVED over `Required` |
+| O4 | Configuration/version closure is the parametric argument above; applicability of every consumed premise contains `Required`. | PROVED |
+
+No test, build, execution, or tool-derived evidence was used.
+
+## Proof-documentation finding
+
+**DOC-01 — local `SAFETY` proof is incomplete as a persistent proof artifact; implementation remains proved.** The comment identifies the branch and callee precondition, but does not identify the semantic premise establishing that `is_none() == false` means `Some`, nor its supported-release applicability. Suggested replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 guarantees throughout the supported domain
+// that is_none() is true exactly for None. The true case returned above, so
+// value is Some(v); the same premise guarantees unwrap_unchecked(Some(v))
+// is defined and returns v.
+```
+
+This is documentation debt, not an implementation, soundness, or behavioral defect.
+
+## Residual scope and triggers
+
+Excluded are configurations outside `Required`, backend/binary correctness, and undocumented robustness properties. Re-audit is required for any source or documentation change; support-domain expansion or reinterpretation; change to either cited standard-library proposition; change or withdrawal of `COMPAT-OPTION-184-186`; or addition of dependencies, generated code, configuration-sensitive code, or API surfaces. Every in-scope obligation and mandatory postcondition has a disposition; there is no unresolved domain or proof remainder.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r076/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r076/1/attestation.json
new file mode 100644
index 0000000000..13e25916bb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r076/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r076",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:41:07.533574Z",
+  "report_sha256": "cc9fd179a072064534dd9b337b68629aa110ba586546632b898c0d96532d449b",
+  "run_id": "r076",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 921
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r076/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r076/1/report.md
new file mode 100644
index 0000000000..36b316ac32
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r076/1/report.md
@@ -0,0 +1,115 @@
+# Focused source-only review of `classify`
+
+## Claims and verdicts
+
+Audited artifact: `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+The only language-reachable API surface is the safe public function
+`classify(u8) -> u8` (`lib.rs:6`). There are no fields, traits, macros,
+callbacks, dependencies, generated artifacts, mutable invariants, or other
+source files contributing code.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call is free from Rust undefined behavior | **UNSOUND** | The valid safe call `classify(0)` reaches `unreachable_unchecked` at line 12. Its required proposition—this site is unreachable—is false, and Rust 1.80.0 documents reaching it as UB. |
+| When `input == 0`, the function panics | **UNPROVED**, not `CONTRACT-BROKEN` | The exact obstructing case is `classify(0)`, but its execution contains UB. It therefore cannot be an UB-free witness that the panic postcondition is false. No independent UB-free zero-input execution or equivalent existence proof is available. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The valid call `classify(1)` takes line 14 and normally returns `2`; this path never enters the unsafe block, is UB-free as a whole, and `2 != 1`. |
+
+Combined mandatory result: **UNSOUND** for safe-API soundness, **UNPROVED**
+for the zero-input panic guarantee, and **CONTRACT-BROKEN** for the
+normal-return result guarantee.
+
+## Exact domain and configuration closure
+
+Let `T` be exactly the targets on which this source and the Rust 1.80.0
+standard-library item exist, and let `P = {ordinary-debug,
+ordinary-release}`. The request defines
+
+`Required = {0..=255} × T × P`.
+
+This is preserved symbolically; no target inventory is inferred. The source
+contains no `cfg`, target feature, arithmetic whose overflow checks differ,
+debug assertion, allocation, FFI, concurrency, panic-mode selection, or
+generated code. Thus the source case split and all local facts below are
+parametric in every `(target, profile) in T × P`. `EVIDENCE.md` expressly
+supplies applicability of both Rust 1.80.0 authority pages throughout that
+same target/profile domain. Accordingly:
+
+- positive soundness coverage is `{1..=255} × T × P`; `{0} × T × P` has the
+  parametric UB witness;
+- panic coverage has the unresolved region `{0} × T × P`;
+- positive result coverage is `{2..=255} × T × P`, the broken region is
+  `{1} × T × P`, and the UB-containing zero case remains unproved for that
+  postcondition.
+
+These regions exhaust `Required` because `{0}`, `{1}`, and `{2..=255}` are an
+exact partition of `u8`. Profile optimization cannot rescue an abstract
+execution that reaches documented UB. This is a source-level conclusion; no
+compiler-backend or binary-correctness claim is made.
+
+## Case proof and obligation ledger
+
+### `input = 0`
+
+The safe signature imposes no caller safety precondition, and `0` is a valid
+`u8`. The match selects line 8; the local `marker` operations do not alter
+control flow; execution reaches line 12. The safety comment at line 11 merely
+assumes unreachability, while the dominating match arm proves reachability for
+this input. Rust 1.80.0's standard-library Safety section states: “Reaching
+this function is Undefined Behavior.” Therefore the exact unsafe-call
+precondition is false and this valid safe call reaches UB. The Rust Reference
+classifies unsafe code that safe code can use to exhibit UB as unsound. This
+closes every link of the `UNSOUND` certificate for every `(target, profile)`.
+
+The same execution cannot certify `CONTRACT-BROKEN` for “panics”: the execution
+as a whole contains UB. It also supplies no proof that a panic occurs. The
+smallest missing proposition is an UB-free theorem that every zero-input call
+panics; none follows from this source. For the conditional normal-return
+guarantee, the zero case likewise supplies neither a defined normal return nor
+an UB-free refutation, so its regional status is `UNPROVED`.
+
+### `input = 1`
+
+The match selects line 14 and returns the literal `2`; it executes no unsafe
+operation. This establishes UB freedom for this case and, independently, the
+UB-free witness `classify(1) == 2 != 1`. Thus it proves
+`CONTRACT-BROKEN` for the normal-return guarantee. The zero-only panic contract
+is inapplicable.
+
+### `input in 2..=255`
+
+The wildcard arm at line 15 returns the bound value `input` and executes no
+unsafe operation. Hence these calls are UB-free and satisfy the normal-return
+result guarantee. The zero-only panic contract is inapplicable.
+
+## TCB audit log
+
+TCB ID: `TCB-source-review-v1`; all entries are accepted because the request
+submitted and authorized these exact versioned official sources.
+
+| ID | Category | Exact proposition and scope | Consumer |
+|---|---|---|---|
+| A1 | AXIOM | On Rust 1.80.0, reaching `std::hint::unreachable_unchecked` is UB, throughout `T × P`. [Rust 1.80.0 std Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) | zero-input UB certificate |
+| A2 | AXIOM | Rust code must not cause UB; unsafe code triggerable by a safe client to exhibit UB is unsound. [Rust 1.80.0 Reference](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) | soundness classification |
+| D1 | submitted domain premise | `EVIDENCE.md` states A1 and A2 apply to every requested target and ordinary profile. | configuration closure |
+
+Both pages were opened and their quoted/consumed propositions verified. No
+test, tool result, compiler implementation, dependency, external specification,
+or deployment assumption is consumed.
+
+## Findings and remediation
+
+`F-UB-0`: line 11's proof artifact is false and deficient; line 12's
+implementation is unsound behind a safe API. Replace the zero arm with a real
+panic (for example, an explicit panic or a safe unreachable panic) and remove
+the unsupported safety claim.
+
+`F-RESULT-1`: line 14 violates the documented normal-return result. Return
+`input` (or otherwise return `1`) if the existing contract is retained.
+Neither proposed repair changes the current-snapshot verdict; repaired source
+requires a fresh audit.
+
+Residual scope is limited to backend/binary correctness and configurations
+outside the exact request. Re-audit on any source, contract, Rust version,
+target/profile domain, standard-library documentation, or TCB-applicability
+change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r077/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r077/1/attestation.json
new file mode 100644
index 0000000000..d88881f462
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r077/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r077",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:45:09.723166Z",
+  "report_sha256": "5c927aebfbdd7b0c2213525642f94b9b2d634ddbe371c2de93761a8799809093",
+  "run_id": "r077",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 1000
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r077/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r077/1/report.md
new file mode 100644
index 0000000000..8e48eb09d5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r077/1/report.md
@@ -0,0 +1,68 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Combined result: PROVED.** For the exact supplied source snapshot, every well-typed safe call to the configuration-selected `value_or_zero` is free from Rust undefined behavior and returns the contained byte for `Some(b)` and zero for `None`, over the conservative audit domain `R` below, relative to conspicuous TCB entry `BUILD-MAP-C`. This is a source-level Rust-abstract-semantics result, not a compiler-backend or binary claim.
+
+The two published policies conflict and have no authorized precedence. This audit does **not** resolve that conflict or call `R` the project promise. Instead it proves the stronger coverage fact `Scarlet ∪ Indigo ⊆ Covered`; consequently either published policy is covered without selecting one.
+
+## Snapshot, scope, and surfaces
+
+Audited at 2026-08-01: all supplied target files; crate `conflicting-domain-target` 0.1.0, edition 2021, `rust-version = 1.84`, `no_std`, Rust/stdlib releases exactly `{1.84.0,1.85.0,1.86.0}`. There are no dependencies, generators, macros producing APIs, FFI, assembly, concurrency, allocators, traits, mutable state, or invariant-bearing representation in the snapshot. No build, test, execution, expansion, or prior result was used.
+
+The complete language-reachable crate API is one safe free function, `pub fn value_or_zero(Option<u8>) -> u8`, with mutually exclusive implementations: the safe `unwrap_or(0)` body when `turbo` is disabled (`src/lib.rs:7-10`), and the checked `unwrap_unchecked` body when enabled (`src/lib.rs:13-22`). There are no unsafe public APIs or caller safety obligations. The only unsafe operation is `Option::unwrap_unchecked` at line 22. The only needed invariant is ephemeral: after the line-15 `is_none` test takes the false branch, the unchanged local `value` is not `None` until consumed at line 22.
+
+## Configuration-domain recovery
+
+Let `V={1.84.0,1.85.0,1.86.0}`, targets `T={X,A,W}` as defined by the policies, and Boolean `f=turbo`, `h=hardened`. Profiles and debug-assertion states are universally quantified.
+
+Preserving the published predicates verbatim:
+
+```text
+S = !f || (f && t=X && (!h || v>=1.85.0)) || (f && t=A && h)
+I = !f || (f && t=X && (h || v>=1.86.0)) ||
+           (f && t=A && !h && v>=1.85.0)
+```
+
+With `v∈V,t∈T`, define the conservative audit domain:
+
+```text
+R = S ∪ I
+  = !f || (f && t=X) || (f && t=A && (h || v>=1.85.0)).
+```
+
+Equality follows by exhaustive symbolic target cases. For `W`, both policies permit exactly `!f`. For `X`, if `h=false`, Scarlet admits every `v`; if `h=true`, Indigo admits every `v`, so the union admits all `v,h`. For `A`, Scarlet admits all `h=true`, while Indigo admits `h=false` exactly at `v>=1.85.0`. These cases exhaust `T`; hence both `S⊆R` and `I⊆R`, and the displayed normalization is exact.
+
+Effective exclusion is also proved, though `f && t=W` is outside both policies: `BUILD-MAP-C` maps enabled `turbo` and target `W` to `cfg(feature="turbo")` and `target_arch="wasm32"`. Thus `all(...)` is true, the `cfg` attribute includes `compile_error!` (`src/lib.rs:3-4`), and compilation fails. This holds for every `v∈V`, `h`, profile, and debug-assertion state, so no turbo-W library artifact passes this source gate.
+
+## Versioned axioms and TCB
+
+For each exact release, the standard-library pages say `is_none` returns true when the option is `None`; `unwrap_unchecked` returns the contained `Some` value and calling it on `None` “is undefined behavior”; and `unwrap_or` returns the contained `Some` value or its supplied default:
+
+| Release | `is_none` | `unwrap_unchecked` | `unwrap_or` |
+|---|---|---|---|
+| 1.84.0 | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or) |
+| 1.85.0 | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or) |
+| 1.86.0 | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or) |
+
+For each release, configuration options are true exactly when set, `all` requires all operands, and `cfg` includes its item when true and removes it when false: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). `compile_error!` “causes compilation to fail ... when encountered”: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Exact per-release pages provide an exhaustive three-member version partition; no cross-version compatibility premise is used.
+
+**Accepted human trust decision — BUILD-MAP-C (`TCB.md`).** Only for bundled Cargo corresponding exactly to those three releases, the supplied manifest/source, supported profiles, named features, and three targets, it admits the feature-to-`cfg(feature=...)` and target-to-`target_arch` mappings. Consumers are solely branch reachability and rejection. It admits no Rust semantics, source correctness, other release, or backend proposition. Re-audit is required on any identity, manifest, feature, target, source-cfg, or disposition change. No other implementation premise is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Required proposition | Proof and covered cases | Status |
+|---|---|---|---|
+| O1 | Exactly the applicable body is included | Versioned `cfg` rules plus `BUILD-MAP-C`; `not(f)` and `f` are complementary. | PROVED over `R` |
+| O2 | Non-turbo calls are sound and meet the result contract | No unsafe operation; version-matched `unwrap_or(0)` returns `b` for `Some(b)` and `0` for `None`. Independent of `v,t,h`, profile, assertions. | PROVED for `R∧!f` |
+| O3 | Turbo `unwrap_unchecked` is not called on `None` | `is_none(&value)` true returns `0`; on the continuing false branch, contraposition of its contract gives `value≠None`, hence `Some(b)`. No intervening mutation/call occurs before `unwrap_unchecked(value)`. Its exact safety precondition holds. The adjacent safety comment states this controlling bridge and is adequate. | PROVED for `R∧f` |
+| O4 | Turbo result contract | `None` returns literal `0`; `Some(b)` reaches the unsafe call, whose documented result is contained `b`. | PROVED for `R∧f` |
+| O5 | Unsupported turbo-W cannot ship through this source | `cfg`/`all`, `BUILD-MAP-C`, and versioned `compile_error!` contract as derived above. | PROVED |
+
+For each required obligation, the `!f` and `f` cases cover `R`; O2 covers the former and O3/O4 the latter. O1 supplies selection for both. Thus aggregate `Covered=R`, proving `Required=R⊆Covered`. `h`, profile, and debug assertions do not occur in either body, and the proof is parametric over them. No sampled evidence is substituted for this closure.
+
+## Findings, residual scope, and triggers
+
+No `UNPROVED`, `UNSOUND`, `CONTRACT-BROKEN`, proof-documentation, authoritative-documentation, or skill-guidance finding remains in scope. There is no tool-derived evidence. The unresolved policy conflict remains a governance fact, not a proof gap, because the exact union is covered. Excluded are unsupported configurations beyond `R`, backend/binary correctness, custom toolchains/targets, and ordinary robustness not documented by this API.
+
+Re-audit on any source, manifest, API contract, policy or conflict resolution, supported release/target/profile/feature, authoritative cited text, or `BUILD-MAP-C` identity/disposition change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r078/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r078/1/attestation.json
new file mode 100644
index 0000000000..a01cd02ea6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r078/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r078",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:46:12.813637Z",
+  "report_sha256": "558ebe232a4e3fade4ffed4c1a4b61dc9c294c9ad3df86bcb8956dae957d2395",
+  "run_id": "r078",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2400,
+  "word_count": 1230
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r078/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r078/1/report.md
new file mode 100644
index 0000000000..4e6ee6a1dd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r078/1/report.md
@@ -0,0 +1,75 @@
+# Unsafe Rust source audit: `cross-axis-target`
+
+## Claim and verdict
+
+This review covers the complete supplied crate: `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`, on the exact supplied source snapshot. The source-level claim is: every well-typed safe use of the public library API is free from Rust undefined behavior for every supported build, relative only to the TCB below.
+
+`Supported(C)` means Rust, Cargo, and standard library 1.85.1; edition 2021; a target in {`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, `wasm32-unknown-unknown`}; either state of feature `burst`; allocator selector `system` or `arena` obtained through `build.rs` as specified by `BUILD.md`; any Cargo profile and either debug-assertion state; excluding `wasm32-unknown-unknown` + `arena`. Build-script stdout writes must succeed for an accepted-selector library compilation. This predicate is fixed by the manifest, `SUPPORT.md`, `BUILD.md`, and accepted `BUILD-MAP-X`; they do not conflict.
+
+- **Complete supported-domain soundness: UNSOUND** (`F-01`).
+- **Region `Rbad`: UNSOUND.** `Rbad = Supported(C) && target=aarch64-unknown-linux-gnu && allocator=arena && burst=enabled`, in every profile/debug-assertion state.
+- **Region `Supported \\ Rbad`: PROVED** source-sound relative to the stated TCB and Rust 1.85.1 axioms below.
+- **Documented `lane_id(0)` panic, complete supported domain: UNPROVED** (`F-01`). It is proved on `Supported \\ Rbad`; the only established contrary execution in `Rbad` contains UB, so it cannot establish `CONTRACT-BROKEN`.
+- **Documented build selection/rejection behavior and the required wasm/arena exclusion: PROVED** relative to `BUILD-MAP-X`.
+
+No binary/backend, future-toolchain, security, resource, or manually-invoked-`rustc` claim is made.
+
+## Snapshot, surfaces, and trust boundary
+
+There are no third-party dependencies, generated Rust files, FFI, assembly, unsafe declarations/traits/impls, public fields, macros exported by the crate, callbacks, or invariant-bearing project types. The build script generates only a `fixture_allocator` configuration option. No prior audit or tool-derived evidence was used; the target was not built, run, tested, or expanded.
+
+API/operation inventory:
+
+| ID | Surface/site | Domain | Status |
+|---|---|---|---|
+| API-01 | safe public `lane_id(u8) -> NonZeroU8`, `src/lib.rs:23` | every compiled supported library | `UNSOUND` via OBL-03 |
+| UNSAFE-01 | `NonZeroU8::new_unchecked(value)`, line 31 | exactly `Rbad` | violated for `value=0` |
+| UNSAFE-02 | same operation, line 44 | `Supported \\ Rbad` | proved |
+| BUILD-01 | environment parsing and cfg emission, `build.rs:3-21` | Cargo builds through documented interface | proved |
+| REJECT-01 | three `compile_error!` guards, `src/lib.rs:3-16` | selected cfg combinations | proved as detailed below |
+
+The sole local invariant consumed is **INV-NZ**: at either unsafe call, the argument must be nonzero. It is owned by the immediately dominating control-flow proof; no type-wide or allocator-wide invariant supplies it.
+
+### TCB log (revision: supplied `TCB.md`)
+
+| ID | Category/disposition | Exact consumed proposition | Scope/consumer |
+|---|---|---|---|
+| BUILD-MAP-X | accepted human build-tool premise | Exactly the Cargo/target/feature/cfg mapping, rebuild behavior, and unsuccessful-build behavior stated in `TCB.md:5-32` | configuration reachability and rejection only |
+| AXIOM-NZ-1.85.1 | versioned std axiom | `NonZero::new_unchecked` “results in undefined behavior if the value is zero”; its safety requirement is that the value not be zero | UNSAFE-01/02; [Rust 1.85.1 std](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked) |
+| AXIOM-CFG/FLOW/PANIC | versioned Reference/std axioms | `cfg` selects attached source by its predicate; `if` selects its consequent on true; `u8 == 0` tests equality; encountered `compile_error!` prevents compilation; `panic!` panics the current thread | case partition and rejection; [cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), [if](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html), [comparison](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators), [compile_error](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), [panic](https://doc.rust-lang.org/1.85.1/std/macro.panic.html) |
+
+`BUILD-MAP-X` is not widened to assert which string this source emits, source correctness, abstract Rust semantics, or backend correctness. Changes to any identity or input named in that entry trigger re-audit.
+
+## Configuration closure and obligation ledger
+
+`build.rs` first emits the rebuild and expected-value declarations. `env::var` then partitions inputs: absence constructs exactly `system`; Unicode `system` and `arena` retain those exact strings; non-Unicode input panics. The following literal/or/wildcard match emits exactly one quoted selector only for `system` or `arena`, and panics for every other Unicode value. Because formatting occurs only after that exact match, no arbitrary value can enter the directive. `BUILD-MAP-X` transfers the emitted selector to the library and makes an unsuccessful script/stdout write produce no library compilation.
+
+For every accepted build, exactly one supported allocator cfg is therefore set. The first two library guards are inactive. On `wasm32` + `arena`, the third guard is active and `compile_error!` prevents a library artifact, satisfying the sole support-policy exclusion. Invalid or non-Unicode environment values are rejected earlier by the script. A stdout infrastructure failure also yields no compilation, but per `TCB.md` is not classified as a successful policy rejection. No/dual/invented selectors from manual `rustc` are outside the theorem; the no/dual cases are nevertheless guarded.
+
+The unsafe implementation has an exhaustive cfg partition:
+
+| Obligation | Exact proposition | Derivation/status |
+|---|---|---|
+| OBL-01 | supported configuration coverage | `BUILD-MAP-X` plus the three literal cfg axes gives `Rbad` or its exact complement; profile/debug assertions do not occur in source. Proved. |
+| OBL-02 | excluded wasm/arena cannot ship | accepted selector reaches the third guard, which causes compilation failure. Proved. |
+| OBL-03 | UNSAFE-01 argument is nonzero for every safe call | No check, type restriction, privacy boundary, or caller contract establishes this. False for `value=0`; `UNSOUND`. |
+| OBL-04 | UNSAFE-02 argument is nonzero | If `value == 0`, `panic!` executes before the unsafe call. Reaching line 44 therefore entails `value != 0`, satisfying AXIOM-NZ. Proved over the exact complement of `Rbad`. |
+| OBL-05 | safe API is sound for all `u8` | OBL-04 proves the complement, but OBL-03 refutes the universal claim. `UNSOUND`. |
+| OBL-06 | `lane_id(0)` panics | The dominating zero branch proves it outside `Rbad`. In `Rbad`, the established execution has UB at UNSAFE-01; complete-domain postcondition remains `UNPROVED`, not `CONTRACT-BROKEN`. |
+
+For nonzero inputs in either region, AXIOM-NZ is satisfied. There are no later unsafe consumers or state transitions. This proof is parametric over all profiles, debug-assertion states, and supported targets sharing each cfg case.
+
+## F-01 — unchecked zero in a safe API
+
+- **Status:** `UNSOUND`; implementation defect and deficient local proof comment.
+- **Affected claim/configuration:** API-01 in every `Rbad` build.
+- **Valid witness:** Build through Cargo 1.85.1 for `aarch64-unknown-linux-gnu`, set `FIXTURE_ALLOCATOR=arena`, enable `burst`, and let stdout writes succeed. These choices are supported, and `BUILD-MAP-X` makes all three cfg predicates at lines 25-27 true. Well-typed safe code calls `lane_id(0)`. The selected block reaches line 31 with `value == 0`; AXIOM-NZ says this is undefined behavior.
+- **Defect:** The comment “Burst-mode lane identifiers are never zero” reverses no producer contract and cites no enforced invariant. `value` is the safe caller's unconstrained `u8`; the function documentation actually promises to panic on zero.
+- **Postcondition classification:** This UB-containing witness cannot prove an UB-free failure to panic. No independent UB-free refutation is established, so the documented panic is `UNPROVED` in `Rbad`.
+- **Minimum repair:** Make the zero check dominate the unsafe call in every configuration (the existing complement branch is sufficient), or use a checked safe constructor with explicit zero-to-panic handling. Replace the comment with the line-identified dominating-check derivation used for OBL-04. Re-audit the changed snapshot across the full cfg partition.
+
+## Residual scope and review triggers
+
+Unsupported combinations are limited to invalid/non-Unicode allocator input, wasm/arena, and manual/invented rustc cfg use as described above; each enforcement or theorem exclusion is explicit. Future Rust/Cargo versions, custom targets, backend/binary behavior, and environmental behavior beyond `BUILD-MAP-X` are excluded.
+
+Re-audit on any source, manifest, support/build documentation, public contract, Rust/Cargo identity, target set, feature, environment interface, emitted cfg, TCB disposition, or relevant authoritative-documentation change. Every in-scope site has a disposition; the complete supported-domain result remains **UNSOUND** until F-01 is repaired and the new snapshot is audited.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r079/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r079/1/attestation.json
new file mode 100644
index 0000000000..1acf61e78d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r079/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r079",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:50:25.669036Z",
+  "report_sha256": "4e7c92b788756b1cdcf631f88281b74ffe439e5d5a47358f69c2cb84978d35c2",
+  "run_id": "r079",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 1800,
+  "word_count": 913
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r079/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r079/1/report.md
new file mode 100644
index 0000000000..827c0761a1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r079/1/report.md
@@ -0,0 +1,54 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Soundness: PROVED. Documented behavior: PROVED. Combined mandatory result: PROVED.** For the exact supplied crate source, every well-typed safe call to the configuration-selected `value_or_zero` is free from Rust undefined behavior and returns the contained byte for `Some(byte)` and `0` for `None`, for every configuration supported by **either** current policy, relative only to the TCB stated below.
+
+This is a source-level Rust-abstract-semantics result, not a compiler/backend or binary-correctness claim. It does not choose between Scarlet and Indigo or declare their union to be project policy. Rather, one proof covers the conservative union, so each candidate policy's complete domain is covered despite the unresolved governance conflict.
+
+## Snapshot, scope, and surfaces
+
+Audited material is the supplied `Cargo.toml`, `src/lib.rs`, both policy files, and `TCB.md`; package `conflicting-domain-target` 0.1.0, edition 2021, Rust/standard-library versions exactly 1.84.0, 1.85.0, and 1.86.0. There are no dependencies, build scripts, supplied generated artifacts, FFI, assembly, concurrency, allocator code, invariant-bearing representation, unsafe declarations/traits/impls/fields, callbacks, or hidden/macro-generated public APIs. No prior audit, expansion, build, test, or tool result was used.
+
+The complete crate-owned API surface is one safe public free function, represented by two mutually exclusive `cfg(feature = "turbo")` definitions with the same signature and documented result. The complete unsafe surface is the turbo definition's single call to `Option::unwrap_unchecked`. The only other macro site is the configuration-rejection `compile_error!`.
+
+## Configuration closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, targets `X`, `A`, and `W` have the policy meanings, and `f`/`h` denote `turbo`/`hardened`. Without resolving policy precedence, the conservative candidate domain is `U = Indigo ∪ Scarlet`, equivalently (under the common version/target universe):
+
+```text
+!f or (f and t = X) or (f and t = A and (h or v >= 1.85.0))
+```
+
+Both `h` states, all policy-supported Cargo profiles, and both debug-assertion states are included. `h`, profile, and debug assertions do not occur in either function body, so the proofs are parametric over them. Target and version affect no body; version-matched Option contracts below cover each version. The cases `!f` and `f` exhaust `U`.
+
+The versioned References define `all` by conjunction and say `cfg` “conditionally includes the thing it is attached to based on a configuration predicate”: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute); [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute); [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Each version's `compile_error!` contract says it causes compilation to fail with the given message when encountered: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+
+Therefore, using `BUILD-MAP-C`, `f && t=W` includes and encounters `compile_error!`, so it produces no shippable library artifact. Both policies already expressly exclude that region. When `f` is false exactly the non-turbo definition is included; when true exactly the turbo definition is included.
+
+## Authoritative Option premises
+
+For each exact version, the standard-library page says `is_none` “Returns `true` if the option is a `None` value”; `unwrap_unchecked` returns the contained `Some` value and its Safety section says calling it on `None` is undefined behavior; `unwrap_or` returns the contained value or supplied default: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+## Obligation ledger and derivations
+
+- **O-NORMAL (all `U` with `!f`): PROVED.** `unwrap_or(0)` is safe and, by its exact version's contract, returns the byte for `Some(byte)` and `0` for `None`. Thus both soundness and the function's documented result hold.
+- **O-TURBO-NONE (all `U` with `f`, input `None`): PROVED.** `is_none()` returns true, so the dominating branch returns `0`; the unsafe call is not executed.
+- **O-TURBO-SOME (all `U` with `f`, input `Some(byte)`): PROVED.** Reaching the unsafe call means `is_none()` returned false. By contraposition of its `None => true` contract, `value` is not `None`; because `Option` has only `None` and `Some`, it is `Some(byte)`. `is_none` only immutably borrows this owned local, and no operation intervenes, so the fact persists. This discharges `unwrap_unchecked`'s exact safety obligation; its postcondition yields `byte`.
+- **O-COVERAGE: PROVED.** `f` partitions `U`; the two `Option` variants partition every input; the four cases above cover all configurations and safe inputs. Target, `h`, profile, and debug-assertion axes do not alter the selected body or derivation.
+
+The adjacent `SAFETY` comment identifies the dominating `None` exit and exact resulting `Some` fact required by `unwrap_unchecked`; for this immediate control-flow/type derivation it is adequate. No caller-side safety condition is hidden.
+
+## TCB audit log
+
+**The only accepted non-Rust premise consumed is `BUILD-MAP-C` from the supplied `TCB.md`.** It admits, only for bundled Cargo corresponding exactly to Rust 1.84.0/1.85.0/1.86.0, the stated mapping from enabled `turbo`/`hardened` features to their `cfg` predicates and from the three exact target triples to `target_arch`. It is consumed only by branch reachability and effective rejection. It admits no Rust semantics, branch correctness, compatibility, backend, or binary proposition. Human disposition: accepted. Re-audit on any listed Cargo/toolchain identity, feature, target, manifest, source-`cfg`, or disposition change.
+
+The versioned Reference/std propositions cited above are authoritative Rust axioms, not extra implementation assumptions. No safe/unsafe dependency, compatibility, tool, external, deployment, or probabilistic premise is consumed.
+
+## Findings, residual scope, and triggers
+
+No implementation, soundness, postcondition, proof-documentation, Rust-documentation, or skill-guidance defect was established. The sole governance issue is that no unique exact project support predicate can be reported until Scarlet/Indigo precedence or supersession is authorized; it does not block the proved conservative-union theorem.
+
+Excluded from the verdict: toolchains or standard libraries outside `V`, targets outside `{X,A,W}`, custom build-tool mappings, configurations outside either policy, compiler/backend/binary correctness, and the rejected `f && W` region (which emits no library). Re-audit on source/manifest changes, policy resolution or scope changes, any consumed Rust-documentation semantic change, or any `BUILD-MAP-C` trigger.
+
+All in-scope unsafe, safe-boundary, behavior, configuration, citation, and TCB obligations have the dispositions above; no tests substitute for proof.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r080/1/attestation.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r080/1/attestation.json
new file mode 100644
index 0000000000..51b2701e18
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r080/1/attestation.json
@@ -0,0 +1,19 @@
+{
+  "agent_id": "/root/report_r080",
+  "api_state": "COMPLETED",
+  "attempt": 1,
+  "canonical_for_scoring": true,
+  "operational_scope_deviation": false,
+  "recorded_utc": "2026-08-01T08:55:38.874980Z",
+  "report_sha256": "c5f1e887706023c4ef50e285bbe0640c6b73f461ceda3bbeca8a63e143618042",
+  "run_id": "r080",
+  "schema_version": 1,
+  "scope_evidence": "No known operational source-scope deviation.",
+  "semantic_noncompletion": false,
+  "source_isolation": "procedural",
+  "terminal_disposition": "COMPLETE",
+  "utf8": true,
+  "within_word_cap": true,
+  "word_cap": 2200,
+  "word_count": 1253
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r080/1/report.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r080/1/report.md
new file mode 100644
index 0000000000..076c452f97
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/attempts/r080/1/report.md
@@ -0,0 +1,90 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the supplied `lib.rs`, all three modules, with no generated code, dependencies, prior result, execution, or tool-derived evidence. The source-level claim is: for every well-typed safe use (and every unsafe-trait implementation satisfying its published contract), execution is free of Rust undefined behavior under Rust 1.82.0 abstract semantics. Mandatory unsafe-contract clauses are also in scope.
+
+`Required = {exact supplied source} × {Rust and std 1.82.0} × {every target on which this source and the used 1.82.0 std items exist} × {every ordinary profile}`. The audit cutoff is 2026-08-01. There are no `cfg`s, features, macros, generators, FFI, dependencies, or enforced exclusions.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All three modules, combined soundness | **UNSOUND** | CB-R and CB-W independently establish UB from valid safe uses. |
+| `callback_index::read` | **UNSOUND** | CB-R. |
+| `callback_index::write` | **UNSOUND** | CB-W. |
+| `local_proof::last` implementation | **PROVED** | LP below; `Required ⊆ Covered`. |
+| `local_proof::last` existing `SAFETY` comment | **Deficient** | It states no obligation or derivation. |
+| `published_lane::{Lane, High, read}` | **PROVED** | PL below, for all valid `Lane` implementations; `Required ⊆ Covered`. |
+| `published_lane` proof artifacts | **Deficient** | The unsafe impl and unchecked access lack adjacent proofs. |
+
+No broader undocumented safe-API behavior (including panic freedom) is claimed. CB-R/CB-W apply on every required target/profile, so the aggregate result is not diluted by configuration uncertainty.
+
+## Authority and TCB log R080-TCB-1
+
+There are no additional TCB assumptions. These accepted Rust-1.82-only axioms are the complete trust boundary:
+
+- AX-SLICE: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) each state that an out-of-bounds call is undefined behavior, even if the reference is unused. They return shared/mutable references without bounds checking.
+- AX-LENGTH: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when length is zero.
+- AX-INTEGER: the Reference defines binary `-` as subtraction and overflow as producing a value outside the integer type's range ([operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)); `usize` is unsigned and has pointer width ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)).
+- AX-TRAIT: implementing an unsafe trait may be unsafe, while using a correctly implemented one is safe ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)); an unsafe impl asserts discharge of the trait's extra safety conditions ([unsafe keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+
+Each entry applies to all `Required` cases and is consumed below. Re-audit on source, contract, Rust version, support-domain, or cited-document change.
+
+## Boundary and obligation inventory
+
+| ID | Surface/obligation | Disposition |
+|---|---|---|
+| CB-P | Public safe `Position` trait and safe `position`; downstream safe implementations are adversarial. | No invariant enforces an in-bounds result. |
+| CB-R | Public safe `read`; unchecked shared indexing at line 9. | **UNSOUND**. |
+| CB-W | Public safe `write`; unchecked mutable indexing at line 13. | **UNSOUND**. |
+| LP | Public safe `last`; nonempty branch, subtraction, unchecked indexing at lines 19–24. | Implementation **PROVED**; comment deficient. |
+| PL-W | Public `Word(pub [u32; 2])`, including tuple construction/field access/move/drop. | The field's type enforces exactly two initialized `u32` lanes; no hidden invariant. |
+| PL-T | Public unsafe `Lane`, constants `INDEX` and `NAME`, and unknown downstream impls. | Valid impls owe both literal clauses at lines 36–37. |
+| PL-H | Safe unit construction of `High`; its unsafe `Lane` impl. | Contract **PROVED**; proof comment missing. |
+| PL-R | Public safe generic `read`; unchecked indexing at line 51. | **PROVED** for every valid impl; proof comment missing. |
+
+No other constructors, methods, callbacks, hidden items, macros, reexports, operators, or semantically relevant custom trait behavior occur in the supplied source.
+
+## Findings and proofs
+
+### CB-R — safe `read` reaches UB
+
+Let safe downstream code define `struct P; impl Position for P { fn position(&self) -> usize { 0 } }` and call `read(&[], &P)`. This is well-typed and uses no unsafe operation or undocumented precondition. Line 9 executes `get_unchecked(0)` on a slice of length zero. Index 0 is out of bounds; AX-SLICE makes the call itself UB. This proves every existential link: valid in-scope use, reachability, false bounds proposition, and authoritative UB consequence.
+
+### CB-W — safe `write` independently reaches UB
+
+With the same safe `P`, call `write(&mut [], &P, 1)`. Line 13 executes `get_unchecked_mut(0)` on length zero. The use is valid safe Rust, index 0 is out of bounds, and AX-SLICE makes that call UB before assignment. This is a second complete certificate, not merely fallout from CB-R. No UB-free documented-postcondition refutation is needed or established.
+
+**Smallest repair:** retain the public signatures and `Position`, but implement `read` as `bytes[position.position()]` and `write` as `bytes[position.position()] = value`. Safe callers still choose positions for reads and writes; out-of-range positions panic rather than violate a hidden safety condition. No caller-implementable abstraction was required to be preserved, but retaining it minimizes API and source change. This proposal is **not certified**: implement it, then freshly audit the new snapshot and its documented panic behavior if promised.
+
+### LP — correct implementation, inadequate comment
+
+On the else branch, AX-LENGTH gives `len != 0`; because `len: usize` is unsigned, `len > 0`. Therefore mathematical `len - 1` is representable, so AX-INTEGER's overflow condition is false in every overflow-check profile, and `0 ≤ index = len - 1 < len`. AX-LENGTH identifies `len` as the element count, hence `index` is in bounds. AX-SLICE discharges `get_unchecked(index)`; dereferencing the returned shared reference copies the selected valid `u8`. The empty branch performs no unsafe operation. These exhaustive branches prove soundness on `Required` and the evident result (`None` exactly for empty input; otherwise the final element).
+
+“This is the fast path” supplies none of that material derivation. Replacement:
+
+```rust
+// SAFETY: The else branch establishes `bytes.len() > 0`, so `len - 1`
+// cannot underflow and is strictly less than `bytes.len()`; `index` is in bounds.
+```
+
+### PL — current contract and unknown downstream code
+
+The published contract is a conjunction: (1) `INDEX < 2`; (2) at index 0, `NAME == "low"`; (3) at index 1, `NAME == "high"`. `High` sets index 1 and name `"high"`, discharging all applicable clauses. For any valid downstream `L`, clause (1) and `word.0: [u32; 2]` imply `L::INDEX` is in bounds, so AX-SLICE proves line 51. `read` consumes no stronger fact. Clauses (2)–(3) remain binding even though this file does not consume `NAME`: unknown published 1.x consumers may rely on them in their own unsafe proofs. Removing/weakening the mapping can invalidate consumers; strengthening it can invalidate existing impls. Either is a compatibility change requiring downstream analysis, not a documentation cleanup.
+
+Proposed adjacent proofs:
+
+```rust
+// SAFETY: `1 < 2`, and the contract requires `NAME == "high"` at index 1.
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: Every valid `Lane` impl guarantees `L::INDEX < 2`, and `word.0`
+// is `[u32; 2]`; therefore the index is in bounds.
+```
+
+These documentation proposals do not alter the current implementation verdict and remain unaudited until applied.
+
+## Configuration closure and residual scope
+
+The relevant axes are target pointer width, optimization, overflow checks/debug assertions, and panic strategy. The proofs are parametric: CB uses index zero on length zero; LP proves subtraction representable before profile-dependent overflow behavior matters; PL uses a type-level array length. Thus each stated positive proof covers all `Required`, and the witnesses refute soundness throughout it. No configuration was sampled or tested. Binary/compiler-correctness, security, and any source outside the two supplied target files are excluded.
+
+Final attestation: every supplied surface and unsafe obligation has a disposition; all citations were checked at Rust 1.82.0; no result relies on testing, a missing counterexample, hidden caller obligations, repository-visible consumer completeness, or a proposed repair.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r001.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r001.json
new file mode 100644
index 0000000000..4d567a2439
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r001.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "0fea6fbdfedb1e8f9c1c331f5a47fa16",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:21:23.023794Z",
+  "report_prompt_sha256": "368a3362fd35ed9fe5fec48850434c4ef5f8283e4df25155921a6c0fb7f34c1f",
+  "run_id": "r001",
+  "runtime_root": "/tmp/ur-eval/0fea6fbdfedb1e8f9c1c331f5a47fa16",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r002.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r002.json
new file mode 100644
index 0000000000..2f0fcf1202
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r002.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "4886a308ee81e3c948ea133df9661771",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:21:59.110280Z",
+  "report_prompt_sha256": "c59fb9702091fc027bf050370843f9ef7d26c93878311fcf3ce011398fbf5e95",
+  "run_id": "r002",
+  "runtime_root": "/tmp/ur-eval/4886a308ee81e3c948ea133df9661771",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r003.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r003.json
new file mode 100644
index 0000000000..f85557b990
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r003.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "fd82077e8d40fcaf1f5a51da67a9bc70",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:22:28.882534Z",
+  "report_prompt_sha256": "c4bc31cc142c2e258279e86ea9c3c74db79a5e5c62ed3aa3a950b460db53640c",
+  "run_id": "r003",
+  "runtime_root": "/tmp/ur-eval/fd82077e8d40fcaf1f5a51da67a9bc70",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r004.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r004.json
new file mode 100644
index 0000000000..40fbce9912
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r004.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "a01a89ac57f92484e62f719916fabcde",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:26:41.074277Z",
+  "report_prompt_sha256": "5385b01b6f599c109bc64b89f4ab2576564f69fd286cbf8f156ef3e3a0a409e0",
+  "run_id": "r004",
+  "runtime_root": "/tmp/ur-eval/a01a89ac57f92484e62f719916fabcde",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r005.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r005.json
new file mode 100644
index 0000000000..3183bbd140
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r005.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "c51d935dd66af61d6ae7370471dd270b",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:28:51.325554Z",
+  "report_prompt_sha256": "e04afbc5db1b297db89ca21e502b30d126d2d3f951025477a603a72582f03154",
+  "run_id": "r005",
+  "runtime_root": "/tmp/ur-eval/c51d935dd66af61d6ae7370471dd270b",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r006.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r006.json
new file mode 100644
index 0000000000..ff7826d14b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r006.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "237314e935a671dda9f0b729a9164e42",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:29:28.780346Z",
+  "report_prompt_sha256": "16b9e1cacef97966baf0765f034a38a31b1e206974832f6d1c6b968ca42e1565",
+  "run_id": "r006",
+  "runtime_root": "/tmp/ur-eval/237314e935a671dda9f0b729a9164e42",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r007.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r007.json
new file mode 100644
index 0000000000..65e71f2243
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r007.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "2d557eebd147400908963542447f78d8",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:35:08.142012Z",
+  "report_prompt_sha256": "918c65189f108db4844419983053dc4813adf3cb1f093a03a0006c6f50b23541",
+  "run_id": "r007",
+  "runtime_root": "/tmp/ur-eval/2d557eebd147400908963542447f78d8",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r008.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r008.json
new file mode 100644
index 0000000000..4d44c5df3e
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r008.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "b7d49044025495a68243c59ea223d392",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:36:36.293745Z",
+  "report_prompt_sha256": "2adf0af6e67b1c807cdb6dab48b8e56ee549f3197de982b32686ab73d6e9cb70",
+  "run_id": "r008",
+  "runtime_root": "/tmp/ur-eval/b7d49044025495a68243c59ea223d392",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r009.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r009.json
new file mode 100644
index 0000000000..d6eb0203b4
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r009.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "4a591e9e7f2b1706efec55c9b809b15e",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:37:19.668101Z",
+  "report_prompt_sha256": "eb53b75cf4eb9c858be59ed64272ca094c925b3e32cd68b11949bd67f4f19775",
+  "run_id": "r009",
+  "runtime_root": "/tmp/ur-eval/4a591e9e7f2b1706efec55c9b809b15e",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r010.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r010.json
new file mode 100644
index 0000000000..2a768825b6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r010.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "b4c7cb4a6c9a884747af60df5bbe135e",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:41:43.226296Z",
+  "report_prompt_sha256": "36f4d8c7202793181e69a5e16849b202259aa42eaf99fae112eb2805a682a345",
+  "run_id": "r010",
+  "runtime_root": "/tmp/ur-eval/b4c7cb4a6c9a884747af60df5bbe135e",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r011.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r011.json
new file mode 100644
index 0000000000..da9150b3ce
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r011.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "df3cf01648593724319ee30d40e53694",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:42:34.586417Z",
+  "report_prompt_sha256": "a2c6278e32c333e3ffb1bcd2135492bd0094ff2ecb4106fffd1ee6f53286d159",
+  "run_id": "r011",
+  "runtime_root": "/tmp/ur-eval/df3cf01648593724319ee30d40e53694",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r012.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r012.json
new file mode 100644
index 0000000000..1aabc374b2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r012.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "b9449281466536eb625d875c9a1b52c6",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:43:00.572512Z",
+  "report_prompt_sha256": "c25694b6aac8b9d209ece0fd250b5356f373ea742e9c685d0ae6086b23d273f1",
+  "run_id": "r012",
+  "runtime_root": "/tmp/ur-eval/b9449281466536eb625d875c9a1b52c6",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r013.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r013.json
new file mode 100644
index 0000000000..eaeccced55
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r013.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "c08c9cbec10b09416dedb07222a8fa89",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:49:02.809059Z",
+  "report_prompt_sha256": "c0d344fb4651bb13e96092181deec271c12480fdef0a21cbd664817fef8799c7",
+  "run_id": "r013",
+  "runtime_root": "/tmp/ur-eval/c08c9cbec10b09416dedb07222a8fa89",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r014.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r014.json
new file mode 100644
index 0000000000..b873299c3d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r014.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "225c7b447026b9d4fb60d0953329f336",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T03:50:14.901841Z",
+  "report_prompt_sha256": "8c68590fa7bb38c56d48431686611656ef8910d737c6cc2ed4ebcaf4a7eb16d9",
+  "run_id": "r014",
+  "runtime_root": "/tmp/ur-eval/225c7b447026b9d4fb60d0953329f336",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r015.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r015.json
new file mode 100644
index 0000000000..b5c5d53f13
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r015.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "4dfb61f35f3ba9347c43f9c7390941ba",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:50:49.692660Z",
+  "report_prompt_sha256": "02a87a4a6e65b0f33fb6553120503aad6f9d86355ae2c5bbcfede77d21becf36",
+  "run_id": "r015",
+  "runtime_root": "/tmp/ur-eval/4dfb61f35f3ba9347c43f9c7390941ba",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r016.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r016.json
new file mode 100644
index 0000000000..9e2196d980
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r016.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "0ddb17b601260a6fa49fd03e146c8bf4",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T03:56:44.772397Z",
+  "report_prompt_sha256": "f19c24f4fa674223c1fe0167f52dd654f042bae49053409f9a9d1622dcb47106",
+  "run_id": "r016",
+  "runtime_root": "/tmp/ur-eval/0ddb17b601260a6fa49fd03e146c8bf4",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r017.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r017.json
new file mode 100644
index 0000000000..3e70a9b420
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r017.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "c0867a2b7f8ca30ce79eaf94a8c2813b",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:04:35.530243Z",
+  "report_prompt_sha256": "38ff28dc9060121449712589b3c6af669d04daab30de9a30394ca021cce4df19",
+  "run_id": "r017",
+  "runtime_root": "/tmp/ur-eval/c0867a2b7f8ca30ce79eaf94a8c2813b",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r018.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r018.json
new file mode 100644
index 0000000000..4eba7e4be8
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r018.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "ef1a0677a6ed30a4b2ccf4bf2c4fa075",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:05:13.387566Z",
+  "report_prompt_sha256": "09d77fc4551aeac84987e86819cf7b3a8964885dfc6492b595a1ceafe0e36ddf",
+  "run_id": "r018",
+  "runtime_root": "/tmp/ur-eval/ef1a0677a6ed30a4b2ccf4bf2c4fa075",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r019.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r019.json
new file mode 100644
index 0000000000..04f07ee8e7
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r019.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "07041e4c7851c15fbd8ca3b5b89a649c",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:06:01.273262Z",
+  "report_prompt_sha256": "f8bc4979827285f8cdb6cf88a856784d00b0c29b3f11b7d274452bd8001fd253",
+  "run_id": "r019",
+  "runtime_root": "/tmp/ur-eval/07041e4c7851c15fbd8ca3b5b89a649c",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r020.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r020.json
new file mode 100644
index 0000000000..7a63969e2d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r020.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "0a93b4a0423042598341734b5b80aea2",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:12:39.369509Z",
+  "report_prompt_sha256": "ad75481d8f2eb81db6d1b2f48938ca148ead3476c0ee16594535d8469b0d72ab",
+  "run_id": "r020",
+  "runtime_root": "/tmp/ur-eval/0a93b4a0423042598341734b5b80aea2",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r021.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r021.json
new file mode 100644
index 0000000000..2642520b0b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r021.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "45d746368e63763aae22c259c646af5e",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:13:24.169784Z",
+  "report_prompt_sha256": "4cdbf370afcdaa8d3cdcc21649e1992108002bb64fc375e64432e9274c682e0d",
+  "run_id": "r021",
+  "runtime_root": "/tmp/ur-eval/45d746368e63763aae22c259c646af5e",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r022.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r022.json
new file mode 100644
index 0000000000..64ea6aab45
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r022.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "cf391d64b44517b85ca71858bb6d8e52",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:16:34.517829Z",
+  "report_prompt_sha256": "e743edb6b03f996e9a73af3159d1cf717151c296733c63b0be190004c7c44336",
+  "run_id": "r022",
+  "runtime_root": "/tmp/ur-eval/cf391d64b44517b85ca71858bb6d8e52",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r023.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r023.json
new file mode 100644
index 0000000000..4bafe42cda
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r023.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "136b2c4efefe0bab1417f14b38a57793",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:21:00.845490Z",
+  "report_prompt_sha256": "2f7d5b811b0476967e0fd4b75864ee6a3696a22f614c7339ee1244686fd725de",
+  "run_id": "r023",
+  "runtime_root": "/tmp/ur-eval/136b2c4efefe0bab1417f14b38a57793",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r024.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r024.json
new file mode 100644
index 0000000000..31105a5544
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r024.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "aea81024b16085dc0bc078cab31e9b6d",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:21:43.746881Z",
+  "report_prompt_sha256": "016954e4ae479d191c8e1781eaaaf36091a5245847e5d0d6c8b4294d8a81981a",
+  "run_id": "r024",
+  "runtime_root": "/tmp/ur-eval/aea81024b16085dc0bc078cab31e9b6d",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r025.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r025.json
new file mode 100644
index 0000000000..991de2f977
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r025.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "83498ad4b1212eaea7b615f0292a1ce3",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:23:38.101683Z",
+  "report_prompt_sha256": "c00abf6af2e732702e9019ed06a3262b61e9695172b3dd97d6b4c80b3166115d",
+  "run_id": "r025",
+  "runtime_root": "/tmp/ur-eval/83498ad4b1212eaea7b615f0292a1ce3",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r026.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r026.json
new file mode 100644
index 0000000000..dbab89d1cf
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r026.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "b9a35f06e08e96ce9b0b093da1de80da",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:26:55.999090Z",
+  "report_prompt_sha256": "19b5c4c0d34973e6d806e47b9550feda2a135674330ea3e90019d94645095123",
+  "run_id": "r026",
+  "runtime_root": "/tmp/ur-eval/b9a35f06e08e96ce9b0b093da1de80da",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r027.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r027.json
new file mode 100644
index 0000000000..e144502581
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r027.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "a29afd5bf972ec132f78543ba750e93f",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:29:26.237375Z",
+  "report_prompt_sha256": "8f6bbbcff48065d83c7de78b1682471f925d1d1d223898a67d1a577168a04974",
+  "run_id": "r027",
+  "runtime_root": "/tmp/ur-eval/a29afd5bf972ec132f78543ba750e93f",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r028.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r028.json
new file mode 100644
index 0000000000..54d6904285
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r028.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "8beb0474c46f57c79e68aa2f12dfd6a6",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:31:01.325829Z",
+  "report_prompt_sha256": "604a2c07c2ec9e4734dde7665856b75bddbd2ef6e9c2319cb657cb118ffb7f38",
+  "run_id": "r028",
+  "runtime_root": "/tmp/ur-eval/8beb0474c46f57c79e68aa2f12dfd6a6",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r029.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r029.json
new file mode 100644
index 0000000000..71d64fa739
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r029.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "a3f969c74a0d22bd838ad11dd92aa415",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:34:00.733135Z",
+  "report_prompt_sha256": "bf9153f12cec171c1ad7faeefcb624468e29d940a3eea4b4d631fde2dd990888",
+  "run_id": "r029",
+  "runtime_root": "/tmp/ur-eval/a3f969c74a0d22bd838ad11dd92aa415",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r030.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r030.json
new file mode 100644
index 0000000000..ece86f0d59
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r030.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "919322be3592430d06791a08b1aa8cea",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:36:54.833900Z",
+  "report_prompt_sha256": "cfded1802a525889528c5a997577bde5d67539e951a21147320a4f10d05e38f2",
+  "run_id": "r030",
+  "runtime_root": "/tmp/ur-eval/919322be3592430d06791a08b1aa8cea",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r031.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r031.json
new file mode 100644
index 0000000000..85c1dabd6b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r031.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "c42948b54a7eab85fd103b78c835c7ac",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:38:37.603507Z",
+  "report_prompt_sha256": "5c39d89188df5bab701a3667ac1c4ae50f5dfcc3b2913f292b6c4f4884344974",
+  "run_id": "r031",
+  "runtime_root": "/tmp/ur-eval/c42948b54a7eab85fd103b78c835c7ac",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r032.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r032.json
new file mode 100644
index 0000000000..ad52c960db
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r032.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "418a4bcde6dda1a6187bae8547d85a93",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:41:07.468893Z",
+  "report_prompt_sha256": "b2003d48ef6d61f1a60658490b2b6995369f3a42dc2105558d9ce9d39a4143e0",
+  "run_id": "r032",
+  "runtime_root": "/tmp/ur-eval/418a4bcde6dda1a6187bae8547d85a93",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r033.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r033.json
new file mode 100644
index 0000000000..2360a193ad
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r033.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "ca8819a9835763564d3e5c7b365393d8",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:49:11.962113Z",
+  "report_prompt_sha256": "161503a0c64a754f3eeab2ac40f23bf478258ba600c86493aa401c15793b1a50",
+  "run_id": "r033",
+  "runtime_root": "/tmp/ur-eval/ca8819a9835763564d3e5c7b365393d8",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r034.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r034.json
new file mode 100644
index 0000000000..67bb90af89
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r034.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "1ff38d28876c4cdd6329bfeaa1385e6f",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T04:49:46.097090Z",
+  "report_prompt_sha256": "253a3851bf6d014ab6d51e500e1ac6dbeeb3bf99c52e2a0967382c4e2148b84a",
+  "run_id": "r034",
+  "runtime_root": "/tmp/ur-eval/1ff38d28876c4cdd6329bfeaa1385e6f",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r035.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r035.json
new file mode 100644
index 0000000000..3128ff5f2b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r035.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "07fde893dca23f5e7b0b0e576c212375",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T04:50:21.206132Z",
+  "report_prompt_sha256": "a5603287fa3e6506de63e13e234137a1f36a17ca74b2641d02b74d1aff534de1",
+  "run_id": "r035",
+  "runtime_root": "/tmp/ur-eval/07fde893dca23f5e7b0b0e576c212375",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r036.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r036.json
new file mode 100644
index 0000000000..9aabe2b5b2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r036.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "bebc72c4981368d1bffe7e85d5e68357",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T06:28:34.326480Z",
+  "report_prompt_sha256": "c73f0921c734430e89d60e7cb84e3f573c340be9ad923f03dc39da9e57b4ffed",
+  "run_id": "r036",
+  "runtime_root": "/tmp/ur-eval/bebc72c4981368d1bffe7e85d5e68357",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r037.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r037.json
new file mode 100644
index 0000000000..53e5cee996
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r037.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "eef95e01264a728a7c6eabe725507b5a",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T06:29:21.812373Z",
+  "report_prompt_sha256": "2ea7af576b816ddbf09ea46901cbd09f606e057216eeae364edc68b7310a93a2",
+  "run_id": "r037",
+  "runtime_root": "/tmp/ur-eval/eef95e01264a728a7c6eabe725507b5a",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r038.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r038.json
new file mode 100644
index 0000000000..1aef8b44c9
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r038.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "628efb38e96428481f2598bd5207472d",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T06:31:14.944984Z",
+  "report_prompt_sha256": "eefa548944ef655a88ad74bc74cded61ee9ef56e9974ccb37ab653ca8d64da54",
+  "run_id": "r038",
+  "runtime_root": "/tmp/ur-eval/628efb38e96428481f2598bd5207472d",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r039.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r039.json
new file mode 100644
index 0000000000..c1572b1fb1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r039.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "ba7abe98e80c53f75aa8f8238c7ffe03",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T06:37:15.575352Z",
+  "report_prompt_sha256": "cddc9ff91ab470a9f2903072e3a5c4df0a784718ca7cce96cec8943005114292",
+  "run_id": "r039",
+  "runtime_root": "/tmp/ur-eval/ba7abe98e80c53f75aa8f8238c7ffe03",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r040.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r040.json
new file mode 100644
index 0000000000..4f0c8c29d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r040.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "de3c340e44bf752186e73da5cdbc05bd",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T06:38:08.081015Z",
+  "report_prompt_sha256": "eb3462ebddfda8f6e164b3aa6184176e13a58b8e5e49a305213ac11862c69e4c",
+  "run_id": "r040",
+  "runtime_root": "/tmp/ur-eval/de3c340e44bf752186e73da5cdbc05bd",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r041.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r041.json
new file mode 100644
index 0000000000..a1c01187b2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r041.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "1ec17f7769c0078f9fcbed12eb0be0f7",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T06:39:07.700374Z",
+  "report_prompt_sha256": "fa48d06b1eab27b6e1a3a3915ff8beea3b78692090bc3da08a1226236540d341",
+  "run_id": "r041",
+  "runtime_root": "/tmp/ur-eval/1ec17f7769c0078f9fcbed12eb0be0f7",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r042.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r042.json
new file mode 100644
index 0000000000..d366e74f56
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r042.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "5edc22ffe7b0779af2a68e40283db476",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T06:46:42.711191Z",
+  "report_prompt_sha256": "4b56de572bddb373d9e64cf705d0171393f4601e144bc635171e06f90ce6ac65",
+  "run_id": "r042",
+  "runtime_root": "/tmp/ur-eval/5edc22ffe7b0779af2a68e40283db476",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r043.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r043.json
new file mode 100644
index 0000000000..44d0bcf2c2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r043.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "9fed5500b2156c7c3cb16aff89a5a89f",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T06:47:32.909411Z",
+  "report_prompt_sha256": "2eec26adb323a4adbd951b78308cdda657f164f11c9b8383aa7d966540195d80",
+  "run_id": "r043",
+  "runtime_root": "/tmp/ur-eval/9fed5500b2156c7c3cb16aff89a5a89f",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r044.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r044.json
new file mode 100644
index 0000000000..f46bc447c7
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r044.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "32e9f759f85e81477aeb318b0e0497c2",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T06:48:57.665247Z",
+  "report_prompt_sha256": "1fbb8abb0f4e3e43671e21ceb6f7a5e412a06e6983794e0bf44d2c91b3a988cc",
+  "run_id": "r044",
+  "runtime_root": "/tmp/ur-eval/32e9f759f85e81477aeb318b0e0497c2",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r045.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r045.json
new file mode 100644
index 0000000000..9dd7bec1ce
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r045.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "434b916b4f0630b6e6aa447c4048f8d6",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T06:56:21.483726Z",
+  "report_prompt_sha256": "37ac402ec37128bb995e3876e68f5cdce4eadcfdd43ed50874fd1ab7e295a4c0",
+  "run_id": "r045",
+  "runtime_root": "/tmp/ur-eval/434b916b4f0630b6e6aa447c4048f8d6",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r046.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r046.json
new file mode 100644
index 0000000000..ff4030d983
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r046.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "8a37e9f35d221302948bb0526f432b98",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T06:57:42.892811Z",
+  "report_prompt_sha256": "82acc9e1478b78b48ef666a0171a44116279895c8e85717daf772a84f7903e9a",
+  "run_id": "r046",
+  "runtime_root": "/tmp/ur-eval/8a37e9f35d221302948bb0526f432b98",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r047.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r047.json
new file mode 100644
index 0000000000..14fc4ee657
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r047.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "86e15f99caa5c1efc10a11768832390e",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T06:58:27.941698Z",
+  "report_prompt_sha256": "ed4026ee40d2dec0cca8deba56abc03cc5dc75d4b7bbfbc126fbcf21b2ad3b7a",
+  "run_id": "r047",
+  "runtime_root": "/tmp/ur-eval/86e15f99caa5c1efc10a11768832390e",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r048.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r048.json
new file mode 100644
index 0000000000..c946760ab5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r048.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "aeea1b0c5420db0d4c06d58b2708366e",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:06:07.360784Z",
+  "report_prompt_sha256": "91863398d85f910626ffed60ba5d314bd2869293dc804139f1b8462ee6a0d3c4",
+  "run_id": "r048",
+  "runtime_root": "/tmp/ur-eval/aeea1b0c5420db0d4c06d58b2708366e",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r049.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r049.json
new file mode 100644
index 0000000000..78a2170bed
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r049.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "16cb821ea568942a5847dc01ce421b41",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:16:09.916427Z",
+  "report_prompt_sha256": "4c7f8fac08de6f6f69f5af697f81d925a1b231c456922e52daf30bf42ffe29cd",
+  "run_id": "r049",
+  "runtime_root": "/tmp/ur-eval/16cb821ea568942a5847dc01ce421b41",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r050.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r050.json
new file mode 100644
index 0000000000..c328dc378a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r050.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "ada6c44a0f72bc924d6b9f094cad0ff0",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:16:35.562826Z",
+  "report_prompt_sha256": "450faf801a18bccd7a9d8e16605f7f67b6b1568ab1843f93e5ab2d1fee11cd77",
+  "run_id": "r050",
+  "runtime_root": "/tmp/ur-eval/ada6c44a0f72bc924d6b9f094cad0ff0",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r051.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r051.json
new file mode 100644
index 0000000000..4fa771c73b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r051.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "d1bfa4935ce8286684864898b004f962",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:17:04.470061Z",
+  "report_prompt_sha256": "197d2f6797f137ef341d6ca363138ea6b73b9f71af690fe6a360c4bb98df5212",
+  "run_id": "r051",
+  "runtime_root": "/tmp/ur-eval/d1bfa4935ce8286684864898b004f962",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r052.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r052.json
new file mode 100644
index 0000000000..9bb71a10e4
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r052.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "f0309a354f74b08a1a0972b62fac6ccd",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:23:33.375064Z",
+  "report_prompt_sha256": "4a4e57e0eea04d864bb81ba81ba1617d94e76841318f2b616671a6ef91978308",
+  "run_id": "r052",
+  "runtime_root": "/tmp/ur-eval/f0309a354f74b08a1a0972b62fac6ccd",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r053.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r053.json
new file mode 100644
index 0000000000..7dbb20831a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r053.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "296be450c238efd67a62d38623894010",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:24:31.328570Z",
+  "report_prompt_sha256": "c59046812480177fbda0aa4ebebcc8d6716cf3f102342124a08d0bd34f044f0d",
+  "run_id": "r053",
+  "runtime_root": "/tmp/ur-eval/296be450c238efd67a62d38623894010",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r054.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r054.json
new file mode 100644
index 0000000000..abf453a6d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r054.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "7da22994e57951eb951e0e387d852650",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:25:32.981897Z",
+  "report_prompt_sha256": "44e92e32f4263ab2cf77f4e93a26325cf4fbf0d8c6da6e68d308b36059c91b7f",
+  "run_id": "r054",
+  "runtime_root": "/tmp/ur-eval/7da22994e57951eb951e0e387d852650",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r055.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r055.json
new file mode 100644
index 0000000000..65b53b3636
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r055.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "4612a4154bf19ccc48a84d507fe9b05b",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:31:41.254081Z",
+  "report_prompt_sha256": "7b72026efc5a2f0bf76d9b67ec1c61031d31a5b09107b0c4fd86d564cee1d853",
+  "run_id": "r055",
+  "runtime_root": "/tmp/ur-eval/4612a4154bf19ccc48a84d507fe9b05b",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r056.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r056.json
new file mode 100644
index 0000000000..2c71ee7ddd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r056.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "e6632dafee22c0cfb734d7911d78769f",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:32:50.717007Z",
+  "report_prompt_sha256": "396110b615430cc22e0326f9264da26f866ec96421686348b57bc9a891268912",
+  "run_id": "r056",
+  "runtime_root": "/tmp/ur-eval/e6632dafee22c0cfb734d7911d78769f",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r057.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r057.json
new file mode 100644
index 0000000000..853ff0b67f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r057.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "1ab98c2830b91afc592e74e6e6c5b9be",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:33:26.873865Z",
+  "report_prompt_sha256": "2ef41528ecb9fe1df217092bf1b387fe1065c3e723d206c2b6016da667e8f3a3",
+  "run_id": "r057",
+  "runtime_root": "/tmp/ur-eval/1ab98c2830b91afc592e74e6e6c5b9be",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r058.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r058.json
new file mode 100644
index 0000000000..61442fb5d8
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r058.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "bf0abeb5157d3eed578e8bc0edde0d47",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:40:13.516524Z",
+  "report_prompt_sha256": "45d3100ee32fd049132cb7aa7b9f316407efab09fcbc74c417dead360b694b61",
+  "run_id": "r058",
+  "runtime_root": "/tmp/ur-eval/bf0abeb5157d3eed578e8bc0edde0d47",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r059.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r059.json
new file mode 100644
index 0000000000..9cd2fa2370
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r059.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "91104a670ad522d0fe606ac8e15dc1f5",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:41:07.495549Z",
+  "report_prompt_sha256": "93e55773acfa53c17da0307b8da3b5b8987d3e54392a78a817bdf23e28c30700",
+  "run_id": "r059",
+  "runtime_root": "/tmp/ur-eval/91104a670ad522d0fe606ac8e15dc1f5",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r060.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r060.json
new file mode 100644
index 0000000000..d406917a3e
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r060.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "02038086e3c763683e357ad7d23a8005",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:41:37.829797Z",
+  "report_prompt_sha256": "4ab61a3dfddf4a50d46cf6179999c7674a042eda6f6baad8f1a14b775cdd5234",
+  "run_id": "r060",
+  "runtime_root": "/tmp/ur-eval/02038086e3c763683e357ad7d23a8005",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r061.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r061.json
new file mode 100644
index 0000000000..358254c7a9
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r061.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "b0f33b6db364346c2523b34bcc8a0ecd",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:49:06.116864Z",
+  "report_prompt_sha256": "5beb323490892c365c871141f291fc792b05718991279f8e00e2f3246de7e527",
+  "run_id": "r061",
+  "runtime_root": "/tmp/ur-eval/b0f33b6db364346c2523b34bcc8a0ecd",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r062.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r062.json
new file mode 100644
index 0000000000..4fb3223c55
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r062.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "359c5fe574e54bea738b01822c7104f6",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:49:54.100314Z",
+  "report_prompt_sha256": "902dc243891235b5971a402abdcb47ffba3cfc50bfebb38d02557d37c5c2aaed",
+  "run_id": "r062",
+  "runtime_root": "/tmp/ur-eval/359c5fe574e54bea738b01822c7104f6",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r063.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r063.json
new file mode 100644
index 0000000000..27d72d4a0d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r063.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "812bd420e5eba308dc68e07047e583c1",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T07:50:28.852499Z",
+  "report_prompt_sha256": "44f5152f85c59c488239df0b8d2cff985d1ec52757eb79186c1c4daa7b521ef4",
+  "run_id": "r063",
+  "runtime_root": "/tmp/ur-eval/812bd420e5eba308dc68e07047e583c1",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r064.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r064.json
new file mode 100644
index 0000000000..5689af6d7b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r064.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "5f63b439ef17bd4c9938d31e4445e847",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T07:57:33.023193Z",
+  "report_prompt_sha256": "b5faf109a36a5a9b624ff7db8e1e4f2c02b0d30080c198b4263b547ef4c20d77",
+  "run_id": "r064",
+  "runtime_root": "/tmp/ur-eval/5f63b439ef17bd4c9938d31e4445e847",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r065.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r065.json
new file mode 100644
index 0000000000..4dbf9c0598
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r065.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "2505caff3f06d70966adcc385f251627",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:05:48.982276Z",
+  "report_prompt_sha256": "1d42b33596d89ee65efccbbb6b90e77384d1c90377c3a2c407231d1cc55e8675",
+  "run_id": "r065",
+  "runtime_root": "/tmp/ur-eval/2505caff3f06d70966adcc385f251627",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r066.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r066.json
new file mode 100644
index 0000000000..a56aacc785
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r066.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "da357b62c59f84a5e9f0f0a11214900a",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:06:20.445886Z",
+  "report_prompt_sha256": "d0b21bbb97121ac8b76c37c563d6cae1c021b2e93893ff8500c0182b06544b9f",
+  "run_id": "r066",
+  "runtime_root": "/tmp/ur-eval/da357b62c59f84a5e9f0f0a11214900a",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r067.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r067.json
new file mode 100644
index 0000000000..cc26ab8251
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r067.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "ae051f5093ea311894002930e26944f6",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:06:50.509745Z",
+  "report_prompt_sha256": "40898c70fad70db602f0bcd8b860af157aaaf77c45949247d46071bd3becc755",
+  "run_id": "r067",
+  "runtime_root": "/tmp/ur-eval/ae051f5093ea311894002930e26944f6",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r068.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r068.json
new file mode 100644
index 0000000000..d099bdc5c4
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r068.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "cell_id": "6a4a5f007b65de786b2391d09453d5e7",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:13:50.271420Z",
+  "report_prompt_sha256": "0f84ecbaeb96364506a8e1533f1bf7db2a750cfae822f5e9536c0c2987e80c33",
+  "run_id": "r068",
+  "runtime_root": "/tmp/ur-eval/6a4a5f007b65de786b2391d09453d5e7",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r069.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r069.json
new file mode 100644
index 0000000000..d8ea6831e0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r069.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "40e593bb6d93cf7b49e1fb35342ff99a",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:14:42.210252Z",
+  "report_prompt_sha256": "5b708a5d7c2c380d1c60d88ac7103cb01a66ccebe7542a5440b0fa2684b87f5a",
+  "run_id": "r069",
+  "runtime_root": "/tmp/ur-eval/40e593bb6d93cf7b49e1fb35342ff99a",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r070.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r070.json
new file mode 100644
index 0000000000..8d9bec0b04
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r070.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "1769a58b00a1db740e39dbd7cba09c6e",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:15:19.396511Z",
+  "report_prompt_sha256": "76e1010a76bdd7daa9c9e14f8f69760f8e69c9d5dd918323394ccc617148df36",
+  "run_id": "r070",
+  "runtime_root": "/tmp/ur-eval/1769a58b00a1db740e39dbd7cba09c6e",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r071.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r071.json
new file mode 100644
index 0000000000..063567a6cf
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r071.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "cell_id": "4cec2104444a8240d06ee311657dc0f3",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:20:00.637767Z",
+  "report_prompt_sha256": "0a8cd9a63a8cdd4e61cca6989037dd2ad59e4911c876819152c5bad0c90e3ed8",
+  "run_id": "r071",
+  "runtime_root": "/tmp/ur-eval/4cec2104444a8240d06ee311657dc0f3",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r072.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r072.json
new file mode 100644
index 0000000000..5ea8a0cfc6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r072.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "cell_id": "843cbdc69d6a93ba2d97c2ef54f74264",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:22:11.324915Z",
+  "report_prompt_sha256": "080821b8aafa8326c223b37f452177766a1edc1b587525583f40fc6810ecda20",
+  "run_id": "r072",
+  "runtime_root": "/tmp/ur-eval/843cbdc69d6a93ba2d97c2ef54f74264",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r073.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r073.json
new file mode 100644
index 0000000000..6043cc9e05
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r073.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "59206a03a32ed8ca983f8665c26fcacc",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:22:45.681970Z",
+  "report_prompt_sha256": "d245bd465d213b1affc66f704489d70e7ab86b1f25412514bb1a698d04320370",
+  "run_id": "r073",
+  "runtime_root": "/tmp/ur-eval/59206a03a32ed8ca983f8665c26fcacc",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r074.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r074.json
new file mode 100644
index 0000000000..c3fa2ccaf2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r074.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "6367c11d5940c2dbeeb37e422d2b79c8",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:29:20.306173Z",
+  "report_prompt_sha256": "dfe3ff9cc6ec8c7a8f481f75409cad1d10d87d3bc276bd399908636d25baf35a",
+  "run_id": "r074",
+  "runtime_root": "/tmp/ur-eval/6367c11d5940c2dbeeb37e422d2b79c8",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r075.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r075.json
new file mode 100644
index 0000000000..007ec367e1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r075.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "cell_id": "02d88d35c49cd6779edc8578e7d89bdb",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:29:49.033494Z",
+  "report_prompt_sha256": "1cecfc6af5ddcefbe813e0fcb7aaf837b53c4be85dfe88cfab39f23cdd4cc65e",
+  "run_id": "r075",
+  "runtime_root": "/tmp/ur-eval/02d88d35c49cd6779edc8578e7d89bdb",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r076.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r076.json
new file mode 100644
index 0000000000..4f1bc9f046
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r076.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "cell_id": "ecf25044b6f65e28e446370bea636c89",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:32:14.083326Z",
+  "report_prompt_sha256": "1486c39f6d59133931a108c9b9fd23cb23d399d5bdac035c1baca3b26e78b164",
+  "run_id": "r076",
+  "runtime_root": "/tmp/ur-eval/ecf25044b6f65e28e446370bea636c89",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r077.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r077.json
new file mode 100644
index 0000000000..cdafeb05b9
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r077.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "886d6d32ed0e40aa1f82f3f94cfcbcaf",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:37:09.557520Z",
+  "report_prompt_sha256": "e3889389869cf04a8a8f735711b401a03a6aed29f63e9082b6112436cb3be22d",
+  "run_id": "r077",
+  "runtime_root": "/tmp/ur-eval/886d6d32ed0e40aa1f82f3f94cfcbcaf",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r078.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r078.json
new file mode 100644
index 0000000000..daf54872c5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r078.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "cell_id": "2a9b5392e246efa52195b90613899322",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:37:56.937529Z",
+  "report_prompt_sha256": "2f647dd051e0b2d6bfbe7b3be13e04d0c1b120dd6de784c3ac4ab2a454cf1f9d",
+  "run_id": "r078",
+  "runtime_root": "/tmp/ur-eval/2a9b5392e246efa52195b90613899322",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r079.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r079.json
new file mode 100644
index 0000000000..fe8a7f7efd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r079.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "cell_id": "c8dd0a199fe8db9173fe43372c47e05b",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "18545738dde5af5c130e801528a1c04d6f0c443fa5120521a4b5403e5c5f0fa2",
+  "prepared_utc": "2026-08-01T08:41:13.486627Z",
+  "report_prompt_sha256": "cbffeab05a98594d8c47cc07571d85f0f8767422d4396fc46bc06dc23392dcb1",
+  "run_id": "r079",
+  "runtime_root": "/tmp/ur-eval/c8dd0a199fe8db9173fe43372c47e05b",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r080.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r080.json
new file mode 100644
index 0000000000..8192a80cb6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/setups/r080.json
@@ -0,0 +1,12 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "cell_id": "aaf0db751da7393ff60ded2b6d179fb7",
+  "output_initially_empty": true,
+  "package_byte_tree_sha256": "fc486dedde1f82ba232b4492808af85a12b27fa2aa27b1a35a3847b2b89f72e0",
+  "prepared_utc": "2026-08-01T08:45:18.171941Z",
+  "report_prompt_sha256": "1098ad460083cd96b2934f88661383788dbc995e07f3bc1a700e8efd01219a5f",
+  "run_id": "r080",
+  "runtime_root": "/tmp/ur-eval/aaf0db751da7393ff60ded2b6d179fb7",
+  "schema_version": 1,
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/valid-index.jsonl b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/valid-index.jsonl
new file mode 100644
index 0000000000..4775bc03bc
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/collection/valid-index.jsonl
@@ -0,0 +1,80 @@
+{"agent_id": "/root/report_r001", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:26:35.837282Z", "report_sha256": "4a8554d2840bc21e1a1da10ff8c50dc52fb362117b24e0d30e3359864a3db4b9", "run_id": "r001", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 766}
+{"agent_id": "/root/report_r002", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:28:46.424312Z", "report_sha256": "d91ac2821d69b57dd7bd98303059093769e6e2b6b99226936b2bf4edc90cdd32", "run_id": "r002", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 872}
+{"agent_id": "/root/report_r003", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:28:56.151974Z", "report_sha256": "52351c5c0755e56dc544a5814cc0bfaeb51f1cf6000e4db4a24ab2699e927812", "run_id": "r003", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 921}
+{"agent_id": "/root/report_r004", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:35:01.732214Z", "report_sha256": "fa577430bed94ddb3e38f175a233a7494c016b6a63a3b3ce5113fe5c433140df", "run_id": "r004", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 972}
+{"agent_id": "/root/report_r006", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:36:30.454412Z", "report_sha256": "dc42456b7c1205f0bfb4134d4928bd38b7804f990e4dfb1559639e4efd31d933", "run_id": "r006", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1131}
+{"agent_id": "/root/report_r005", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:37:10.686501Z", "report_sha256": "57b8763022b39ffe547decc694003c7ce27f6f5e9caec5020f8c3174c53935f5", "run_id": "r005", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1155}
+{"agent_id": "/root/report_r007", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:41:27.761337Z", "report_sha256": "98fe0f05b276a3cd41156e7d3568f698c2232410faed435a32f8b27626172091", "run_id": "r007", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 962}
+{"agent_id": "/root/report_r009", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:42:15.551566Z", "report_sha256": "4bde4f56c31f9d422f72c61118fc884593ad0e9c897b3de60d37c1f1d7a2534d", "run_id": "r009", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 890}
+{"agent_id": "/root/report_r008", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:42:22.792644Z", "report_sha256": "6ff6a7e4a093b5a955df9709844c232c585146e16d159b1c5a51e93e53dee468", "run_id": "r008", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 895}
+{"agent_id": "/root/report_r012", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:48:57.604312Z", "report_sha256": "f8c5a10d8f94f043be587dfcb073640526162160b8a5f33384c243d98ffc9e59", "run_id": "r012", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 835}
+{"agent_id": "/root/report_r010", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:49:55.218905Z", "report_sha256": "78953c2a86ff27a79669c044278b47b0cb996b7bf6a47ca72e92fd5ec643ee43", "run_id": "r010", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 814}
+{"agent_id": "/root/report_r011", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:50:08.459921Z", "report_sha256": "745c8a81613a865eb7c42cf2f0b0d3c14f6e28b3aae745881d3a322e1fa409a3", "run_id": "r011", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 982}
+{"agent_id": "/root/report_r014", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:56:39.664876Z", "report_sha256": "63ff5fdf0f56585dca05bde1ea6b36f118c19ad66ef40b0a10ff43349399c0ad", "run_id": "r014", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 826}
+{"agent_id": "/root/report_r013", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:57:24.668789Z", "report_sha256": "e963c7770bfa0ee351fff523e1a2e992ade90c82028c9b017731d53e2319c647", "run_id": "r013", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 937}
+{"agent_id": "/root/report_r015", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T03:59:00.564276Z", "report_sha256": "257b8bf9d452140b305849ae4e33edca5d395c7a878ed7ed5f0ab1b394b22ddb", "run_id": "r015", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1153}
+{"agent_id": "/root/report_r016", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:03:57.882861Z", "report_sha256": "beda1907cffd4ca75cd8ecb5dc9fb5526c52b20aa0e683109815e6526d752499", "run_id": "r016", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1069}
+{"agent_id": "/root/report_r017", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:12:33.928099Z", "report_sha256": "900af7df55266fc2bb71f705014f9c2bb396adddfebb0bf70f6d3926d9939f51", "run_id": "r017", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1145}
+{"agent_id": "/root/report_r018", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:13:18.877453Z", "report_sha256": "6810e706f4b3974f0c1ef770bc1c8a4eb31bc902a454ca762c9f9491147e9917", "run_id": "r018", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1217}
+{"agent_id": "/root/report_r019", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:16:28.629865Z", "report_sha256": "3e728c8ae2e5aea7eecfd5af8aab61c637c06478e3182e6f7dccdaa569a170c2", "run_id": "r019", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 902}
+{"agent_id": "/root/report_r020", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:20:54.106697Z", "report_sha256": "afa2159eb13ec9ede81adee124835d0ab9c5e0468202378356654636f23d1e66", "run_id": "r020", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1090}
+{"agent_id": "/root/report_r021", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:21:32.961201Z", "report_sha256": "f171bae3f575098cdab781093b1dc9e5455f576fc232bf6c0eadf70ce1a634fe", "run_id": "r021", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 837}
+{"agent_id": "/root/report_r022", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:23:31.288699Z", "report_sha256": "47f498ee490b32d33140eba16ddf4fa3ea10df4bd2c24d2275499fa30fd9de24", "run_id": "r022", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1161}
+{"agent_id": "/root/report_r024", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:26:47.741082Z", "report_sha256": "89b14c495f9833e34e5cf92aa27d75aec62ad353d1b06393998fb1bcc57577ca", "run_id": "r024", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 936}
+{"agent_id": "/root/report_r023", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:29:20.212400Z", "report_sha256": "4d0cdd801e8141b99cc8248d4bdfa4e04db33b09bfd7984cb5d780318e5d2edd", "run_id": "r023", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 895}
+{"agent_id": "/root/report_r025", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:30:48.780502Z", "report_sha256": "cae33ebb10f593bbebe9722ae1b12d2a8e1ebbeaa477704ed16d61296c964bae", "run_id": "r025", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 724}
+{"agent_id": "/root/report_r026", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:33:54.989666Z", "report_sha256": "0ff6cb9b958a530a041aa729635ab67524b6fbcc772a8cf5856d861bbe23fb17", "run_id": "r026", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 816}
+{"agent_id": "/root/report_r027", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:36:48.944273Z", "report_sha256": "4661ad891ae68f808fefc57a29a5b2d1ee36364508329ddb3163e18761d0b9ad", "run_id": "r027", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 910}
+{"agent_id": "/root/report_r028", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:38:30.277206Z", "report_sha256": "130367c76a139f7075e90837340f67fbb8411604f57a468cb3a30499bfc9a585", "run_id": "r028", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 995}
+{"agent_id": "/root/report_r029", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:41:01.437615Z", "report_sha256": "ff506100d0e272b8bd653caab454d10845a938aee535aa0cb927869bc553b883", "run_id": "r029", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 1093}
+{"agent_id": "/root/report_r030", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:44:50.440857Z", "report_sha256": "3a3fe93cf06b9c2158f5159a07f1f3703e2d6b9c8a30e34fbc523636f1e911b1", "run_id": "r030", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 904}
+{"agent_id": "/root/report_r031", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:45:15.031408Z", "report_sha256": "741de41033e7f4a9d25be1cf0231aee79363e384a8b71070b43a4b7f053baa67", "run_id": "r031", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 962}
+{"agent_id": "/root/report_r032", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T04:48:37.515084Z", "report_sha256": "99dc13ef74c153e0fc79419057499d99a38105c2d8fe710ddb80a54e70e0dc59", "run_id": "r032", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 745}
+{"agent_id": "/root/report_r035_a2", "api_state": "COMPLETED", "attempt": 2, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:28:24.748199Z", "report_sha256": "d135ad89e2b402af49206d79186ad5f4454716f99c32debe93ff458ed07d086e", "run_id": "r035", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 917}
+{"agent_id": "/root/report_r034_a2", "api_state": "COMPLETED", "attempt": 2, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:29:10.818869Z", "report_sha256": "14845b9df93acc77be643ccf456e5dfa333a01fe70cb6ffa9f74a1c33b66f600", "run_id": "r034", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1067}
+{"agent_id": "/root/report_r033_a2", "api_state": "COMPLETED", "attempt": 2, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:31:04.342306Z", "report_sha256": "862e943f99c56fd423ac9003945cc8170717ced6c05c9d61ed681d513c1ebdf5", "run_id": "r033", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1160}
+{"agent_id": "/root/report_r036", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:37:03.963750Z", "report_sha256": "f5b0a2be88ccf8436af7044f8a321be0582d57dacffa84012c994a705779dc77", "run_id": "r036", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 895}
+{"agent_id": "/root/report_r037", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:37:37.825495Z", "report_sha256": "b9cfc956cc8580d2722d554a8e40b81f781aab75650f69efd833756f9b67b355", "run_id": "r037", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 892}
+{"agent_id": "/root/report_r038", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:38:56.365356Z", "report_sha256": "33f7ad5b9d6de92126d674c4b964e5d7ce46a3752b8883e324ce257ea928854f", "run_id": "r038", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 942}
+{"agent_id": "/root/report_r039", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:46:33.935981Z", "report_sha256": "c250345e3ded76516cb26af1a80874ba305fb015d70c75b3a82ad5eb7c3821b9", "run_id": "r039", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1246}
+{"agent_id": "/root/report_r041", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:46:54.507655Z", "report_sha256": "d6e6359967799119d7119d804bbeb26db216412f3baab76d2392102683dc4fe2", "run_id": "r041", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 849}
+{"agent_id": "/root/report_r040", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:48:47.942095Z", "report_sha256": "034a581627624218f85a2e12af3590c9346c1227c7846bf28e3bacf75c8c7a5f", "run_id": "r040", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 1067}
+{"agent_id": "/root/report_r042", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:56:07.832856Z", "report_sha256": "9452fc8cae9f25d64b09d17822a59fceb98e19a1a754e327d799e9a462c09d69", "run_id": "r042", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1203}
+{"agent_id": "/root/report_r043", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:57:18.745089Z", "report_sha256": "6d839af7da1f3cf8f5de096c33c36a103337baf53057022f7adf806aec6f1594", "run_id": "r043", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 973}
+{"agent_id": "/root/report_r044", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T06:57:26.519698Z", "report_sha256": "a7f109ef70b6a8ac7b471cc4a3122f4b8e2f92b45305f0f419ead77cf670528e", "run_id": "r044", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 981}
+{"agent_id": "/root/report_r045", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:05:56.310388Z", "report_sha256": "759b413defb47d8ad4c15c08233757841f374762b686d51515a8eddcd5ac1989", "run_id": "r045", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 822}
+{"agent_id": "/root/report_r046", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:07:23.366359Z", "report_sha256": "1409aa1649cd9e0950368deb23ade05351c03b9ab89a32e637514b9d43293e22", "run_id": "r046", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 930}
+{"agent_id": "/root/report_r047", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:07:29.049036Z", "report_sha256": "6a4721ff173210588f9720b233d83c613ca6e460b15e46c52b311793b090f9d2", "run_id": "r047", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 1000}
+{"agent_id": "/root/report_r048", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:15:39.128346Z", "report_sha256": "36c357bebb8df0544f587b00a99169a56e62e1d1386c18984697ae62001ef573", "run_id": "r048", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 910}
+{"agent_id": "/root/report_r050", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:23:28.265270Z", "report_sha256": "77862cfc78b4998dd4c0f05da7a160bf578f1f069da9ef7ca577bfaf19836aa6", "run_id": "r050", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 898}
+{"agent_id": "/root/report_r049", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:24:22.997302Z", "report_sha256": "c9ca30c994fb58edbe9566764dbe3b28fac599dbda40a1d6603a7862e4a5620e", "run_id": "r049", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1097}
+{"agent_id": "/root/report_r051", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:25:26.233425Z", "report_sha256": "2eacff962730a259104f7a8cddafad623a47a519182a5e9e441f49e77fd0bdef", "run_id": "r051", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 918}
+{"agent_id": "/root/report_r052", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:31:31.699808Z", "report_sha256": "8a4870792d2b539f3f1adb115796eea44f36fc3c49d9c36d39996133f51502ad", "run_id": "r052", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 1117}
+{"agent_id": "/root/report_r054", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:32:42.633467Z", "report_sha256": "aaf0fe262d82d837f4f011b5707956852b8db0df9830d91ec927d0ce16fcbd8a", "run_id": "r054", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 898}
+{"agent_id": "/root/report_r053", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:33:21.542452Z", "report_sha256": "97b483500c362b67ec5966a089ea6c9d0c039bbfe454e5b05d854edc693bf982", "run_id": "r053", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 948}
+{"agent_id": "/root/report_r055", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:40:05.179787Z", "report_sha256": "c29cf094b7026bbde11940bb1784b6393918115d74c5eec57207772ba46f0012", "run_id": "r055", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 955}
+{"agent_id": "/root/report_r056", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:40:58.503488Z", "report_sha256": "7545ffde31d113e2377bb3eb1304b7711101e88f6f29b168d2483ae2210177a4", "run_id": "r056", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 1006}
+{"agent_id": "/root/report_r057", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:40:58.749087Z", "report_sha256": "46a2e9a7de676f0249b9a248e2d2d18a0894fb0379999bc3721cb31e84c4db9d", "run_id": "r057", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 852}
+{"agent_id": "/root/report_r058", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:48:58.711366Z", "report_sha256": "0e2fc947abce81854d0af02b955fbfa0b36f0bbcdaa8b7027f450a6b3c3e2d7e", "run_id": "r058", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1018}
+{"agent_id": "/root/report_r059", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:49:11.297855Z", "report_sha256": "2ce56cb39ecd21ba188269290a81702a5f56f4eb84cf09a916a019a850d4436a", "run_id": "r059", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 888}
+{"agent_id": "/root/report_r060", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:49:45.753080Z", "report_sha256": "199d71241d40542bdfcb5dff45e6e3f2384eacfe6f21f69747a7eaab44f200d4", "run_id": "r060", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 914}
+{"agent_id": "/root/report_r061", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:57:28.007098Z", "report_sha256": "18c6702f1987cf50f6511f0e1d09f515dd468abed2ad03af5d8af962d7e5c27a", "run_id": "r061", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1140}
+{"agent_id": "/root/report_r063", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:58:05.669379Z", "report_sha256": "cfa8049918cc9eb89660940173c43c86bda06e974d3ef134b3f82fb21dbcb3af", "run_id": "r063", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 1036}
+{"agent_id": "/root/report_r062", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T07:58:50.254908Z", "report_sha256": "787f990b31be3392ae20e4b16e9c1f20785006bf90464beb7a352a0b395956ad", "run_id": "r062", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 881}
+{"agent_id": "/root/report_r064", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:05:23.312233Z", "report_sha256": "53cf56027a48090998b1ca7fca43ec1200e98e1e8fe386339909fe1a840ffce4", "run_id": "r064", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1004}
+{"agent_id": "/root/report_r065", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:13:43.767347Z", "report_sha256": "a6eb34fd1d3c89310961cd76a7f61566e7226a18edb237f3540b96bf915b40e2", "run_id": "r065", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 863}
+{"agent_id": "/root/report_r066", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:14:32.817004Z", "report_sha256": "86d896a590d75d6ab764037f04ed282c3a6fc822d7278bd68929a8b8f9de97d5", "run_id": "r066", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1136}
+{"agent_id": "/root/report_r067", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:15:14.095838Z", "report_sha256": "06e79bd6b8b63d837b56c80f95a012f301f5b47ab10d2112882ae72c41f0ea7f", "run_id": "r067", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 904}
+{"agent_id": "/root/report_r068", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:19:54.215006Z", "report_sha256": "a596f12e22efee1d14c1f64eea7c3a10da7c32d779c496b890874fd4ef2be972", "run_id": "r068", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 921}
+{"agent_id": "/root/report_r069", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:22:05.239419Z", "report_sha256": "dac13c86e54c024ce799a6b3184e7c6d0e72cb9fdb3ce113aa7ef189c9b65630", "run_id": "r069", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 965}
+{"agent_id": "/root/report_r070", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:22:05.495365Z", "report_sha256": "79e602e9a2317fa845b12fb497a3d895697a4ccdf81598750451850f95fce1fc", "run_id": "r070", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 882}
+{"agent_id": "/root/report_r071", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:29:10.815390Z", "report_sha256": "acbc1ad06963f179d034a1daec025f797ff8576dcda40718197ed2dbdd639acc", "run_id": "r071", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 907}
+{"agent_id": "/root/report_r072", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:29:11.069262Z", "report_sha256": "c9e2ad98c41d88e0c379eff9f0c5b74f545076ca97483f05bbac2f1c46d1a1a4", "run_id": "r072", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 899}
+{"agent_id": "/root/report_r073", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:32:09.037982Z", "report_sha256": "40a82f89628eb8235ce387a5caaf04ff4ecfae417bd0404d05f8f307d826509b", "run_id": "r073", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1129}
+{"agent_id": "/root/report_r074", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:36:55.943556Z", "report_sha256": "a4e4c1ea234c10cd9830139d9c8c2d59a1da533003609c68cb81cb4a22a366d9", "run_id": "r074", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 920}
+{"agent_id": "/root/report_r075", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:37:20.047922Z", "report_sha256": "44941853a2458104b934dfa73aa5411c39c4e5c0ac33730d7bd754757f96e176", "run_id": "r075", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 842}
+{"agent_id": "/root/report_r076", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:41:07.533574Z", "report_sha256": "cc9fd179a072064534dd9b337b68629aa110ba586546632b898c0d96532d449b", "run_id": "r076", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 921}
+{"agent_id": "/root/report_r077", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:45:09.723166Z", "report_sha256": "5c927aebfbdd7b0c2213525642f94b9b2d634ddbe371c2de93761a8799809093", "run_id": "r077", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 1000}
+{"agent_id": "/root/report_r078", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:46:12.813637Z", "report_sha256": "558ebe232a4e3fade4ffed4c1a4b61dc9c294c9ad3df86bcb8956dae957d2395", "run_id": "r078", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2400, "word_count": 1230}
+{"agent_id": "/root/report_r079", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:50:25.669036Z", "report_sha256": "4e7c92b788756b1cdcf631f88281b74ffe439e5d5a47358f69c2cb84978d35c2", "run_id": "r079", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 1800, "word_count": 913}
+{"agent_id": "/root/report_r080", "api_state": "COMPLETED", "attempt": 1, "canonical_for_scoring": true, "operational_scope_deviation": false, "recorded_utc": "2026-08-01T08:55:38.874980Z", "report_sha256": "c5f1e887706023c4ef50e285bbe0640c6b73f461ceda3bbeca8a63e143618042", "run_id": "r080", "schema_version": 1, "scope_evidence": "No known operational source-scope deviation.", "semantic_noncompletion": false, "source_isolation": "procedural", "terminal_disposition": "COMPLETE", "utf8": true, "within_word_cap": true, "word_cap": 2200, "word_count": 1253}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/events.jsonl b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/events.jsonl
index 5956a40e03..f036b6c401 100644
--- a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/events.jsonl
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/events.jsonl
@@ -1 +1,519 @@
 {"details": {"lock_sha256": "9aeeaa4987227f5ac4761349d0979ef6b425cb724fb54d1fe21b89f9cb62e678"}, "event": "freeze_locked", "phase": "freeze", "previous_event_sha256": null, "schema_version": 1, "sequence": 1, "sha256": "2a036052cd3def40582bbe6c3fa7f81ff0bb4afbc82b86f249885076ae7974b3", "time_utc": "2026-08-01T03:19:38.915424Z"}
+{"details": {"entries": 76, "wave": 1}, "event": "authority_verified", "phase": "collection", "previous_event_sha256": "92baa77b86b1499cf274a3b6fe254132984ee795b6628156c71e9074186144d0", "schema_version": 1, "sequence": 2, "sha256": "329634ba9421a9a65b2802b4ba5b07667fae194411904cbbfc7f002da84c0f97", "time_utc": "2026-08-01T03:21:04.008135Z"}
+{"details": {"cell_id": "0fea6fbdfedb1e8f9c1c331f5a47fa16"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "217d8663a31e40ca84e021d52a34a9d80e39267bbc2005b4c042e4b8a9bbbca3", "run_id": "r001", "schema_version": 1, "sequence": 3, "sha256": "75d6a59edd6ec680864d13f0a62d3e5a50f1c41487568dfcf1f7acbb9b12add3", "time_utc": "2026-08-01T03:21:23.026968Z"}
+{"agent_id": "/root/report_r001", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "368a3362fd35ed9fe5fec48850434c4ef5f8283e4df25155921a6c0fb7f34c1f", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "9a84d87b9feee8e95ab535b84d21d79c69a1ed5e9106192b17da0d39c66a7ee9", "run_id": "r001", "schema_version": 1, "sequence": 4, "time_utc": "2026-08-01T03:21:50.221649Z"}
+{"details": {"cell_id": "4886a308ee81e3c948ea133df9661771"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "16bcb1af9fbd6ebbfe6c9bb71f19d93bbd448a91f5f311e6c61b316d14f613b5", "run_id": "r002", "schema_version": 1, "sequence": 5, "sha256": "0ee7b7cef6e467b78553d10a819e7421c1bcabac713b36e8e9c435e357ba1c20", "time_utc": "2026-08-01T03:21:59.113608Z"}
+{"agent_id": "/root/report_r002", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "c59fb9702091fc027bf050370843f9ef7d26c93878311fcf3ce011398fbf5e95", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "ec32e96dd775f1e8328ba09150262a24f285e0abde904f3ba5619a655f0bb0b7", "run_id": "r002", "schema_version": 1, "sequence": 6, "time_utc": "2026-08-01T03:22:23.542016Z"}
+{"details": {"cell_id": "fd82077e8d40fcaf1f5a51da67a9bc70"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "68da087128ed31eaefec95f1d2a57d8929bf8ec51053a95fe58b6d4572365e2b", "run_id": "r003", "schema_version": 1, "sequence": 7, "sha256": "ebe31d06aa045f2331eaaaff7ecb8c19f5f0d0c2dcf85e95375d0e7592867e22", "time_utc": "2026-08-01T03:22:28.886266Z"}
+{"agent_id": "/root/report_r003", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "c4bc31cc142c2e258279e86ea9c3c74db79a5e5c62ed3aa3a950b460db53640c", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "c3670ca236849be0a6585e44e5b180d21e4c7285c397f70c85190347b48e83d4", "run_id": "r003", "schema_version": 1, "sequence": 8, "time_utc": "2026-08-01T03:22:48.830618Z"}
+{"agent_id": "/root/report_r001", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "6a3baf9b3980383bc59bd79c82530095112561ddbab1fe24b9e617a43c35e04c", "run_id": "r001", "schema_version": 1, "sequence": 9, "time_utc": "2026-08-01T03:25:54.436108Z"}
+{"agent_id": "/root/report_r002", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "ee0cb89688c1779e533c72f9df471d3e68e8a901ed14077d7c4f7822ae7d67c8", "run_id": "r002", "schema_version": 1, "sequence": 10, "time_utc": "2026-08-01T03:26:02.762409Z"}
+{"agent_id": "/root/report_r003", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "6f4d577755d892ff74740193345bba7d118164292a3a55fa830da089688a4cc1", "run_id": "r003", "schema_version": 1, "sequence": 11, "time_utc": "2026-08-01T03:26:13.129684Z"}
+{"agent_id": "/root/report_r001", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "e7301e7871fb934a9f4a46acf9edb478284b3533a88ff9fe29fcc9c79d1afa3b", "run_id": "r001", "schema_version": 1, "sequence": 12, "sha256": "0d6513dc1dd5c1b0abf5282655fb0f31060c1bb224e89c451b2e49bb897aff7e", "time_utc": "2026-08-01T03:26:35.841626Z"}
+{"agent_id": "/root/report_r001", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "0e7881f880c0637855a9049d48ca01909d8b9135ac8faeed4e2da505d17369d8", "run_id": "r001", "schema_version": 1, "sequence": 13, "time_utc": "2026-08-01T03:26:35.843142Z"}
+{"agent_id": "/root/report_r001", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 766}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "e7f1daa536e8ea7956d82faace82ae5d9a5cf48065d279ad2e857913eceb6b15", "run_id": "r001", "schema_version": 1, "sequence": 14, "sha256": "4a8554d2840bc21e1a1da10ff8c50dc52fb362117b24e0d30e3359864a3db4b9", "time_utc": "2026-08-01T03:26:35.844631Z"}
+{"details": {"cell_id": "a01a89ac57f92484e62f719916fabcde"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "999490a291866fed49ca56a2d3b1791ab27df74db029af79229cb0865bd96069", "run_id": "r004", "schema_version": 1, "sequence": 15, "sha256": "25fd50d566fdd4b5787d29fff742fc975ab079808034f561bc54fbf1d8b61d59", "time_utc": "2026-08-01T03:26:41.077507Z"}
+{"agent_id": "/root/report_r004", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "5385b01b6f599c109bc64b89f4ab2576564f69fd286cbf8f156ef3e3a0a409e0", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "f76c32e7e55e24258fd42fafba677001fe632395909d2c984125f37907bfb39d", "run_id": "r004", "schema_version": 1, "sequence": 16, "time_utc": "2026-08-01T03:27:09.537493Z"}
+{"agent_id": "/root/report_r002", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "8e97d1df1b7e5551b712e07d4ac3823333885581ad6d1a45652ffa826d6eb8b4", "run_id": "r002", "schema_version": 1, "sequence": 17, "sha256": "406396800e7c9067e158acfd40c82b02a5966d4f50320a2ef6e8685d2c92ff0d", "time_utc": "2026-08-01T03:28:46.428319Z"}
+{"agent_id": "/root/report_r002", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "6a74d22144b31974be4fd8beae76b89ff05ebe4ef9e78d83fd7cdb6c0a7b8b63", "run_id": "r002", "schema_version": 1, "sequence": 18, "time_utc": "2026-08-01T03:28:46.430229Z"}
+{"agent_id": "/root/report_r002", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 872}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "587654649bae492886defbbb0581b831f5ae86597b62b6a15e1215991b5a7fc4", "run_id": "r002", "schema_version": 1, "sequence": 19, "sha256": "d91ac2821d69b57dd7bd98303059093769e6e2b6b99226936b2bf4edc90cdd32", "time_utc": "2026-08-01T03:28:46.431778Z"}
+{"details": {"cell_id": "c51d935dd66af61d6ae7370471dd270b"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "7c3c59bcb9f0232bcadeae7d78274ed2e2554f711a996c33aebbcb3e77fc90a1", "run_id": "r005", "schema_version": 1, "sequence": 20, "sha256": "766cc8d4ac2f248c5c19eb6d476e4839b892d25a62a7fe7c741165e5a1cb41ce", "time_utc": "2026-08-01T03:28:51.329042Z"}
+{"agent_id": "/root/report_r003", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "1d426773b4c203896c13b49f7ee3310f674cd3be46bb316e0826bae4d0c2ac37", "run_id": "r003", "schema_version": 1, "sequence": 21, "sha256": "ab37e380c351f943f7d041aba90bed9ae9b2faed22660805fc1a89698c0368ea", "time_utc": "2026-08-01T03:28:56.155835Z"}
+{"agent_id": "/root/report_r003", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "a9c96da3fa44f2c9897c1c8c1807e994a061ccc0fa5e061e0d6bb8ba9c8c9c9c", "run_id": "r003", "schema_version": 1, "sequence": 22, "time_utc": "2026-08-01T03:28:56.157372Z"}
+{"agent_id": "/root/report_r003", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 921}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "de7ccac39e9bf230ed267117cdfbe67961f17e2ebee60866de6766730e14959d", "run_id": "r003", "schema_version": 1, "sequence": 23, "sha256": "52351c5c0755e56dc544a5814cc0bfaeb51f1cf6000e4db4a24ab2699e927812", "time_utc": "2026-08-01T03:28:56.158869Z"}
+{"agent_id": "/root/report_r005", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "e04afbc5db1b297db89ca21e502b30d126d2d3f951025477a603a72582f03154", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "a7f3b052809e61fbdbfcf6dc69e48bc8bf59a19e9accf7694d939313895e5892", "run_id": "r005", "schema_version": 1, "sequence": 24, "time_utc": "2026-08-01T03:29:20.809653Z"}
+{"details": {"cell_id": "237314e935a671dda9f0b729a9164e42"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "56282131700b5709e847b08e228be25d9beb6d9bff18eb56b5532b2d2c1159aa", "run_id": "r006", "schema_version": 1, "sequence": 25, "sha256": "ac12178b96eb0859dff829244a39a2631ef7023b6ac309a27abc33130b80654a", "time_utc": "2026-08-01T03:29:28.783749Z"}
+{"agent_id": "/root/report_r006", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "16b9e1cacef97966baf0765f034a38a31b1e206974832f6d1c6b968ca42e1565", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "d6053587614df34aa6a5c6ef2ffaf894158e2049005e404017f2bce434b5b4d0", "run_id": "r006", "schema_version": 1, "sequence": 26, "time_utc": "2026-08-01T03:29:52.087677Z"}
+{"agent_id": "/root/report_r004", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "f501ef4af7dba4d04c276ddfbb4837069d5d257ac63a43a1d98f9ca810362122", "run_id": "r004", "schema_version": 1, "sequence": 27, "time_utc": "2026-08-01T03:30:38.403976Z"}
+{"agent_id": "/root/report_r005", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "82f5d687486ad213607c17646b6d661808c4a2d6d839952171df0a2288eea61a", "run_id": "r005", "schema_version": 1, "sequence": 28, "time_utc": "2026-08-01T03:32:37.963243Z"}
+{"agent_id": "/root/report_r006", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "f6d4942fe114de635ac14533219f1c65c1b9f863507b93bcc2672d893dbc7778", "run_id": "r006", "schema_version": 1, "sequence": 29, "time_utc": "2026-08-01T03:33:15.758566Z"}
+{"agent_id": "/root/report_r004", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "ff4422974a7b2395f82784873702ba641416410fcedcb627ffcfdf3accbe6591", "run_id": "r004", "schema_version": 1, "sequence": 30, "sha256": "e983f577a6cdb194f1f8ea286e8511304b4ee3292b9e446bde2d8f020a66c66f", "time_utc": "2026-08-01T03:35:01.736654Z"}
+{"agent_id": "/root/report_r004", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "5be5e30cb36e36965d4e9522bbd71dd0f286278d0ea5fec04be89c2ae10fcb9d", "run_id": "r004", "schema_version": 1, "sequence": 31, "time_utc": "2026-08-01T03:35:01.738527Z"}
+{"agent_id": "/root/report_r004", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 972}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "b1fac964bd502648484c96a52f6ace437eb0ef445ae93fcc34134e33a6600135", "run_id": "r004", "schema_version": 1, "sequence": 32, "sha256": "fa577430bed94ddb3e38f175a233a7494c016b6a63a3b3ce5113fe5c433140df", "time_utc": "2026-08-01T03:35:01.740486Z"}
+{"details": {"cell_id": "2d557eebd147400908963542447f78d8"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "b52730f08a10dcc4801c8e988275cecd812568b86d76850a52870ac6e9044bdd", "run_id": "r007", "schema_version": 1, "sequence": 33, "sha256": "3bffd0185d16b9956483ec4a7a8feda1c9b890656315df4e0879c2e6a5b16c44", "time_utc": "2026-08-01T03:35:08.145141Z"}
+{"agent_id": "/root/report_r007", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "918c65189f108db4844419983053dc4813adf3cb1f093a03a0006c6f50b23541", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "2f549e8d6c55085391b0ce833146744eb08edf1477dc67044c5f63646bbe9381", "run_id": "r007", "schema_version": 1, "sequence": 34, "time_utc": "2026-08-01T03:35:37.121593Z"}
+{"agent_id": "/root/report_r006", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "bed55b2ae4afe90e878d7ca0cd848fc957a9a4c8586825b5dd0eeb015a29e447", "run_id": "r006", "schema_version": 1, "sequence": 35, "sha256": "8377239eeb6d68737316d2bbe19175e848998c009b5abeea089cfd76d2e023a7", "time_utc": "2026-08-01T03:36:30.458689Z"}
+{"agent_id": "/root/report_r006", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "7cf49c106a4b3945d612ef6ec97e33340f1214e27ce3eba936b7c0cd2cfc09e3", "run_id": "r006", "schema_version": 1, "sequence": 36, "time_utc": "2026-08-01T03:36:30.460441Z"}
+{"agent_id": "/root/report_r006", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1131}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "0c1b6929b659fb7acf4e29708c74e39883f5f4f5a3cbfeb54f9a36e8d81b8ba0", "run_id": "r006", "schema_version": 1, "sequence": 37, "sha256": "dc42456b7c1205f0bfb4134d4928bd38b7804f990e4dfb1559639e4efd31d933", "time_utc": "2026-08-01T03:36:30.462163Z"}
+{"details": {"cell_id": "b7d49044025495a68243c59ea223d392"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "b6d2265ef2f4f8e62ed2594a05497ab94c888d5cb5d4a70172560b70200f8c8b", "run_id": "r008", "schema_version": 1, "sequence": 38, "sha256": "bc669499f41208c115b3f6abb7cf2fed2ae65ea66db3eb34716193b5f2219154", "time_utc": "2026-08-01T03:36:36.296867Z"}
+{"agent_id": "/root/report_r008", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "2adf0af6e67b1c807cdb6dab48b8e56ee549f3197de982b32686ab73d6e9cb70", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "888f3e5ffa9c229d36f0a23e44b760cc1201f7151dcb8f08f4b947bec6ca0599", "run_id": "r008", "schema_version": 1, "sequence": 39, "time_utc": "2026-08-01T03:37:05.232067Z"}
+{"agent_id": "/root/report_r005", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "779e77f7eefa27458ab1c110c4d132a8f52a9e11f78446da458fd30fb7d50151", "run_id": "r005", "schema_version": 1, "sequence": 40, "sha256": "48d2e49b959a09efd763ca7e50aac48cde5201c352bd337234afc37b88f74b47", "time_utc": "2026-08-01T03:37:10.690419Z"}
+{"agent_id": "/root/report_r005", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "b1fa8fa1c5bfada8e34711d4a871c70fb23c17da9d2659229b363b30215ba7c6", "run_id": "r005", "schema_version": 1, "sequence": 41, "time_utc": "2026-08-01T03:37:10.692032Z"}
+{"agent_id": "/root/report_r005", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1155}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "4ca27761c8c047420a62b16f2b74a31f3be8352d393cc5d5d1952913186def45", "run_id": "r005", "schema_version": 1, "sequence": 42, "sha256": "57b8763022b39ffe547decc694003c7ce27f6f5e9caec5020f8c3174c53935f5", "time_utc": "2026-08-01T03:37:10.694233Z"}
+{"details": {"cell_id": "4a591e9e7f2b1706efec55c9b809b15e"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "cac3aa494face6f42f7b89fde0969edfeee85e66356c9927bc25f4f67f0dee37", "run_id": "r009", "schema_version": 1, "sequence": 43, "sha256": "5856575bf4c0c7135e94c0e4b88dd8d6dd45d81ebcd5624f3f21850d4f26e0bc", "time_utc": "2026-08-01T03:37:19.671578Z"}
+{"agent_id": "/root/report_r009", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "eb53b75cf4eb9c858be59ed64272ca094c925b3e32cd68b11949bd67f4f19775", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "8b155bac9d6f7ec1176797000803401847a50a6864d28915d03111cb0d2bdc25", "run_id": "r009", "schema_version": 1, "sequence": 44, "time_utc": "2026-08-01T03:37:46.151785Z"}
+{"agent_id": "/root/report_r007", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "2250a70c39e404ef892b66e5a9c954520c8830ade467c1b28085c8e79f82d260", "run_id": "r007", "schema_version": 1, "sequence": 45, "time_utc": "2026-08-01T03:39:43.928753Z"}
+{"agent_id": "/root/report_r008", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "59102e41ced7ec6904af0490a63103f4070e39e3e559432bcece033def69fc85", "run_id": "r008", "schema_version": 1, "sequence": 46, "time_utc": "2026-08-01T03:40:34.146321Z"}
+{"agent_id": "/root/report_r007", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "2c3d67a52635e4add8ace947029dc815fed9f486bd8f8a062641d20e48f97316", "run_id": "r007", "schema_version": 1, "sequence": 47, "sha256": "72e10b0724b0934a19175a5968e19102a68634e9d3f652651c721f6a1def5520", "time_utc": "2026-08-01T03:41:27.765207Z"}
+{"agent_id": "/root/report_r007", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "ac3f7e1058f174750344092ebe7b1fd86f2a204dde3bfb71b62d18c4a20ba525", "run_id": "r007", "schema_version": 1, "sequence": 48, "time_utc": "2026-08-01T03:41:27.766699Z"}
+{"agent_id": "/root/report_r007", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 962}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "bd2b192f1da8459e7f7c480a17a65bef966855f0a4f6d1aeb6c2986ddc05c4bf", "run_id": "r007", "schema_version": 1, "sequence": 49, "sha256": "98fe0f05b276a3cd41156e7d3568f698c2232410faed435a32f8b27626172091", "time_utc": "2026-08-01T03:41:27.768216Z"}
+{"agent_id": "/root/report_r009", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "139fb67db19dccc9fbf93715545b232fc07bb511f133e171fb3382f22222ed46", "run_id": "r009", "schema_version": 1, "sequence": 50, "time_utc": "2026-08-01T03:41:32.802332Z"}
+{"details": {"cell_id": "b4c7cb4a6c9a884747af60df5bbe135e"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "087cc1ccb5d21d873cbb76cd5a9c3cad101e827ffd7efd58e192fc1d7a7ae6e6", "run_id": "r010", "schema_version": 1, "sequence": 51, "sha256": "65108dd73ff978d387b4c017e32b6ccd4182c781ffb03d14af4c60515b6385ca", "time_utc": "2026-08-01T03:41:43.229150Z"}
+{"agent_id": "/root/report_r010", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "36f4d8c7202793181e69a5e16849b202259aa42eaf99fae112eb2805a682a345", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "bb1451180d794bce6f48f9b7cba7ba5a9379ef6559f3f15f6ec7e5f8fd84a82b", "run_id": "r010", "schema_version": 1, "sequence": 52, "time_utc": "2026-08-01T03:42:07.649397Z"}
+{"agent_id": "/root/report_r009", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "bbc18200f14a542f79402077fd8ffb92db4260713f7dd1e82dd5bac14b95c35e", "run_id": "r009", "schema_version": 1, "sequence": 53, "sha256": "47c3200067ea3848c7b67893e32ff7326b43f0940f052c30673a02322b4a15ef", "time_utc": "2026-08-01T03:42:15.558075Z"}
+{"agent_id": "/root/report_r009", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "5e45b38bc4c3e09da40305f735c98f1642ea9ee8bbfc675f15a12b7285e57722", "run_id": "r009", "schema_version": 1, "sequence": 54, "time_utc": "2026-08-01T03:42:15.559487Z"}
+{"agent_id": "/root/report_r009", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 890}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "a1e15ec54108d766a9c17d1b2a49f04fb3c632fbf87f5385f700901be53383a9", "run_id": "r009", "schema_version": 1, "sequence": 55, "sha256": "4bde4f56c31f9d422f72c61118fc884593ad0e9c897b3de60d37c1f1d7a2534d", "time_utc": "2026-08-01T03:42:15.560898Z"}
+{"agent_id": "/root/report_r008", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "b546986c26ee71e75ce6554aa9bdfa97742b8a3dee1a1a41f3e6335a162549f9", "run_id": "r008", "schema_version": 1, "sequence": 56, "sha256": "5a2877e4be990bc3c5b85333ae8a1ce80c10a9c3124b20e8eaaa01d9d571d70d", "time_utc": "2026-08-01T03:42:22.796590Z"}
+{"agent_id": "/root/report_r008", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "68e77c58cd0e0bef5b5765acf60d0d995732fc10d17d2b21b58cce8d865c5c6a", "run_id": "r008", "schema_version": 1, "sequence": 57, "time_utc": "2026-08-01T03:42:22.798001Z"}
+{"agent_id": "/root/report_r008", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 895}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "6713511b511e9b0a001fd5f57ae19d2fadf0de89d3e61f58e623bb084e904d81", "run_id": "r008", "schema_version": 1, "sequence": 58, "sha256": "6ff6a7e4a093b5a955df9709844c232c585146e16d159b1c5a51e93e53dee468", "time_utc": "2026-08-01T03:42:22.799446Z"}
+{"details": {"cell_id": "df3cf01648593724319ee30d40e53694"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "6b494806ddadf4ddbdd3de617543841f1a6a8e9e3a0ed200eccb4c253c0301a6", "run_id": "r011", "schema_version": 1, "sequence": 59, "sha256": "1d66c56767ebf56364dd1d31ecc4d3755a4a0ab5bb00029ef5c47b1daa075986", "time_utc": "2026-08-01T03:42:34.589650Z"}
+{"agent_id": "/root/report_r011", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "a2c6278e32c333e3ffb1bcd2135492bd0094ff2ecb4106fffd1ee6f53286d159", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "9d3657c05ca68920c20e18472da9214f9ff0909afb7a82cabf54fc68b4594a31", "run_id": "r011", "schema_version": 1, "sequence": 60, "time_utc": "2026-08-01T03:42:55.785703Z"}
+{"details": {"cell_id": "b9449281466536eb625d875c9a1b52c6"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "939f9d69843653482bd4f8010ec1f54ec50bac668bf8c5171a7faa9e0f91b85c", "run_id": "r012", "schema_version": 1, "sequence": 61, "sha256": "bf49de702a3495c270edbb1b56ebc11fdcc278e607a788645bbd7cd5183697ca", "time_utc": "2026-08-01T03:43:00.575746Z"}
+{"agent_id": "/root/report_r012", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "c25694b6aac8b9d209ece0fd250b5356f373ea742e9c685d0ae6086b23d273f1", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "cb794550f6f7290861d914028edb90c592acc4e500a86add95f93089d218ce2b", "run_id": "r012", "schema_version": 1, "sequence": 62, "time_utc": "2026-08-01T03:43:22.177649Z"}
+{"agent_id": "/root/report_r010", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "79485572bb4290cf0288a604034a743bfd1b8c335686019721593ed8179fed79", "run_id": "r010", "schema_version": 1, "sequence": 63, "time_utc": "2026-08-01T03:45:19.618057Z"}
+{"agent_id": "/root/report_r011", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "3e0a741a524245eb6a33218a44717863c39fe738913419f73490ec80ae1b743b", "run_id": "r011", "schema_version": 1, "sequence": 64, "time_utc": "2026-08-01T03:46:29.484297Z"}
+{"agent_id": "/root/report_r012", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "19fee68aa64d2833bebcac51e4d886c20ade9425bcdd3e42df98ac52862d626a", "run_id": "r012", "schema_version": 1, "sequence": 65, "time_utc": "2026-08-01T03:47:04.733691Z"}
+{"agent_id": "/root/report_r012", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "91a2c673f954c62bb739ff3c575bbe39e3138c3343883436a48362c056fc3f55", "run_id": "r012", "schema_version": 1, "sequence": 66, "sha256": "cfbe226066db89a060b8eb2dad604ed5815f704a5eb10fb7992854362608ce21", "time_utc": "2026-08-01T03:48:57.607781Z"}
+{"agent_id": "/root/report_r012", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "2d0fd617f41a7e9a966d7b2078275e3d7fd33f1d3f689f31a45a9f95a0e8c34f", "run_id": "r012", "schema_version": 1, "sequence": 67, "time_utc": "2026-08-01T03:48:57.609396Z"}
+{"agent_id": "/root/report_r012", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 835}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "237ea4ab9fee444b85aa9294a20c7e2b40a5b58b733e1e722d4f700ea63b7554", "run_id": "r012", "schema_version": 1, "sequence": 68, "sha256": "f8c5a10d8f94f043be587dfcb073640526162160b8a5f33384c243d98ffc9e59", "time_utc": "2026-08-01T03:48:57.610774Z"}
+{"details": {"cell_id": "c08c9cbec10b09416dedb07222a8fa89"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "d901c03992433ec3f31ecd41b0d8bfbf81a55a17717546b689abd57dedf002bb", "run_id": "r013", "schema_version": 1, "sequence": 69, "sha256": "f1d41e4379d4c4ede16e9ec9a992728db491de7bdc2bf46b7a5f1f5dfe052ceb", "time_utc": "2026-08-01T03:49:02.812622Z"}
+{"agent_id": "/root/report_r013", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "c0d344fb4651bb13e96092181deec271c12480fdef0a21cbd664817fef8799c7", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "e82e96f8d827087279e4318c1d9e50e1d632dc812e7ed12667f5de6627c040fd", "run_id": "r013", "schema_version": 1, "sequence": 70, "time_utc": "2026-08-01T03:49:26.463860Z"}
+{"agent_id": "/root/report_r010", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "d360c69ce5f941855d39ecfba819ca9d3f4dea26bc80c0244db88589517a27eb", "run_id": "r010", "schema_version": 1, "sequence": 71, "sha256": "3c5f0125e2e721b079689a0a2783bce4be925c6ba5320b84320bbf93b57e7f58", "time_utc": "2026-08-01T03:49:55.222691Z"}
+{"agent_id": "/root/report_r010", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "1a4059486d698ce74984222fdb55148661ac28a7905a0f94da2a59b0426d23ce", "run_id": "r010", "schema_version": 1, "sequence": 72, "time_utc": "2026-08-01T03:49:55.224398Z"}
+{"agent_id": "/root/report_r010", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 814}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "5123d0e3c3fa164de02d7bbe6b8af172fe6b77b59a79bbcb998429bb369624e7", "run_id": "r010", "schema_version": 1, "sequence": 73, "sha256": "78953c2a86ff27a79669c044278b47b0cb996b7bf6a47ca72e92fd5ec643ee43", "time_utc": "2026-08-01T03:49:55.225958Z"}
+{"agent_id": "/root/report_r011", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f66f140c8e130498bd73d2819d753af8894d1cc3d16e0c0f3e79f58ce3cd8ea5", "run_id": "r011", "schema_version": 1, "sequence": 74, "sha256": "43c4e27c1eb893329b6364819681efdd47ef5a5afaac1804ffb3bd832bf7a7b4", "time_utc": "2026-08-01T03:50:08.463721Z"}
+{"agent_id": "/root/report_r011", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "6cf3c05064cfb4184cebafeaad1c1ad38cca7e452767b8cb873d49f704f4d44c", "run_id": "r011", "schema_version": 1, "sequence": 75, "time_utc": "2026-08-01T03:50:08.465401Z"}
+{"agent_id": "/root/report_r011", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 982}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "e2ce936520fc6f5b8a707f0b1675959a5fd74537d2c4183b46d97f4ef954d493", "run_id": "r011", "schema_version": 1, "sequence": 76, "sha256": "745c8a81613a865eb7c42cf2f0b0d3c14f6e28b3aae745881d3a322e1fa409a3", "time_utc": "2026-08-01T03:50:08.466906Z"}
+{"details": {"cell_id": "225c7b447026b9d4fb60d0953329f336"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "9fa1dd75b14006d7cccd98f0aedc1f5155f012fde42e4ba6f6d4a32000736f08", "run_id": "r014", "schema_version": 1, "sequence": 77, "sha256": "0b5a6c435c57954029ebbd2074d8d240902e6955be3dfb253a2cfb33d6d20a9d", "time_utc": "2026-08-01T03:50:14.905025Z"}
+{"agent_id": "/root/report_r014", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "8c68590fa7bb38c56d48431686611656ef8910d737c6cc2ed4ebcaf4a7eb16d9", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "a799dd32efdc6633359827bc39b9762013de39c03f0fbce1993de62e5dcb1856", "run_id": "r014", "schema_version": 1, "sequence": 78, "time_utc": "2026-08-01T03:50:38.903559Z"}
+{"details": {"cell_id": "4dfb61f35f3ba9347c43f9c7390941ba"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "421229f9773c1ba9eb4b7849b4644c24b299cdfa3b8ee013d322c938f83e48cb", "run_id": "r015", "schema_version": 1, "sequence": 79, "sha256": "0b46d44fdea78e8c2b08f6b5dd0ec51c6769bdf34b33ea179be3d38960e71f26", "time_utc": "2026-08-01T03:50:49.696095Z"}
+{"agent_id": "/root/report_r015", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "02a87a4a6e65b0f33fb6553120503aad6f9d86355ae2c5bbcfede77d21becf36", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "d5f0571c8c2554cf6d36c665f90f3ad0e3b67683d754c556c34e74d1b4fda6e9", "run_id": "r015", "schema_version": 1, "sequence": 80, "time_utc": "2026-08-01T03:51:13.208062Z"}
+{"agent_id": "/root/report_r013", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "1058fbd4afb1acfa3b36cd07ba1f765f593c18f98e7350cd599cd5d6fb0741ea", "run_id": "r013", "schema_version": 1, "sequence": 81, "time_utc": "2026-08-01T03:53:08.761235Z"}
+{"agent_id": "/root/report_r014", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "05049269cf941affef9c7375efd46b1fbee28558aad5845cd22687e7daf390d0", "run_id": "r014", "schema_version": 1, "sequence": 82, "time_utc": "2026-08-01T03:54:08.160540Z"}
+{"agent_id": "/root/report_r015", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "737103f8e68481e0a00a86b9bf846ee8685522c88dd812960492d737648ff32b", "run_id": "r015", "schema_version": 1, "sequence": 83, "time_utc": "2026-08-01T03:54:52.703406Z"}
+{"agent_id": "/root/report_r014", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "a721fccc5992c5c0edcbdd2e1e64d074e68e5b314694ab11cdd9722aad37361f", "run_id": "r014", "schema_version": 1, "sequence": 84, "sha256": "c3b9dc4a6321597e61f140e0c7cbd094eb25e2ffd6205e08755a69f0417fb01e", "time_utc": "2026-08-01T03:56:39.668725Z"}
+{"agent_id": "/root/report_r014", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "02adac01fdf86dc3e486c3d22381fdb1af5c3860b44292a26b384e323d00033a", "run_id": "r014", "schema_version": 1, "sequence": 85, "time_utc": "2026-08-01T03:56:39.672094Z"}
+{"agent_id": "/root/report_r014", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 826}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "4e306682ebf8433d88c16bd8f3e0be0dfc27da196bf21bc80d2701370d7a0682", "run_id": "r014", "schema_version": 1, "sequence": 86, "sha256": "63ff5fdf0f56585dca05bde1ea6b36f118c19ad66ef40b0a10ff43349399c0ad", "time_utc": "2026-08-01T03:56:39.673794Z"}
+{"details": {"cell_id": "0ddb17b601260a6fa49fd03e146c8bf4"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "d9339eb45e0e0dcd362c2956d2cd13cf52d85e98bfc312081e6b6eab1232eb70", "run_id": "r016", "schema_version": 1, "sequence": 87, "sha256": "44433c6bb2046c8784071e6d25c690d7f8d045ca7a1063c276454a2b59d032da", "time_utc": "2026-08-01T03:56:44.775425Z"}
+{"agent_id": "/root/report_r016", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "f19c24f4fa674223c1fe0167f52dd654f042bae49053409f9a9d1622dcb47106", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "bb82d0c48828ddc522c7a0fd7de56bfca9d32665c83e771c734bde4d3fbc30ae", "run_id": "r016", "schema_version": 1, "sequence": 88, "time_utc": "2026-08-01T03:57:10.708480Z"}
+{"agent_id": "/root/report_r013", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f0ed7bcbd911e24e1e5b4916058c5ffb12c5f31ca0d95bf6cdc26cdd70262f37", "run_id": "r013", "schema_version": 1, "sequence": 89, "sha256": "8be918643b66c5fbdfa054a6865db27a1d0c55f99da7d4a95745756ed2b21c9d", "time_utc": "2026-08-01T03:57:24.672672Z"}
+{"agent_id": "/root/report_r013", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "45edd212610ef35d7938f62a6436228fe4afa57e987433896847d5cf572591b4", "run_id": "r013", "schema_version": 1, "sequence": 90, "time_utc": "2026-08-01T03:57:24.674540Z"}
+{"agent_id": "/root/report_r013", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 937}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "f1f3d541bf8f1299be4257c68963531553df806d0b798ea080bc9f1d8ce80f68", "run_id": "r013", "schema_version": 1, "sequence": 91, "sha256": "e963c7770bfa0ee351fff523e1a2e992ade90c82028c9b017731d53e2319c647", "time_utc": "2026-08-01T03:57:24.675954Z"}
+{"agent_id": "/root/report_r015", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f8d995c05e1654c1d0e1e2fe1a53c3ffdcbfc568fa9be15295cc8735cea4b3f9", "run_id": "r015", "schema_version": 1, "sequence": 92, "sha256": "b744f498da084017e0363f2046dc41d5f20e23768f2b4bde90468096e85d1a1d", "time_utc": "2026-08-01T03:59:00.568572Z"}
+{"agent_id": "/root/report_r015", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "2e50aa0d665337b712a9c02961491c194b7cc55a16de6cdd0f82118c4144020e", "run_id": "r015", "schema_version": 1, "sequence": 93, "time_utc": "2026-08-01T03:59:00.570064Z"}
+{"agent_id": "/root/report_r015", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1153}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "4b31e7d7ddc9589d9b9dc0d6ccd4fd0031c3fdebf6224de70b620ecfc0c6994c", "run_id": "r015", "schema_version": 1, "sequence": 94, "sha256": "257b8bf9d452140b305849ae4e33edca5d395c7a878ed7ed5f0ab1b394b22ddb", "time_utc": "2026-08-01T03:59:00.571642Z"}
+{"agent_id": "/root/report_r016", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "39ccf83658c0f3bcb2bdadcc3ff9458b4c0bc282c9328362620c82e8a38e833f", "run_id": "r016", "schema_version": 1, "sequence": 95, "time_utc": "2026-08-01T04:00:18.074872Z"}
+{"agent_id": "/root/report_r016", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "63cb76c3d4722ad90d7db9b7752f723dd1c2f021c668605344dc3b70a173cd84", "run_id": "r016", "schema_version": 1, "sequence": 96, "sha256": "2eb5244f4504e906e90c128c1399d1dc8be7b8e185e5b7bc5e363f6372050121", "time_utc": "2026-08-01T04:03:57.887149Z"}
+{"agent_id": "/root/report_r016", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "3df392fe5c6b642618c7c0ecbb16e5891d800e61af5394d01e092d49c9a2065c", "run_id": "r016", "schema_version": 1, "sequence": 97, "time_utc": "2026-08-01T04:03:57.888687Z"}
+{"agent_id": "/root/report_r016", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1069}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "48597ef61151be48d36ec8588c8d196b69839d433992bb0de75bc7bfc78af3b6", "run_id": "r016", "schema_version": 1, "sequence": 98, "sha256": "beda1907cffd4ca75cd8ecb5dc9fb5526c52b20aa0e683109815e6526d752499", "time_utc": "2026-08-01T04:03:57.890168Z"}
+{"details": {"entries": 76, "wave": 2}, "event": "authority_verified", "phase": "collection", "previous_event_sha256": "98398d8492b39ac77db1e3565fd22d781dafff39239e718a79965eef2a0ab10c", "schema_version": 1, "sequence": 99, "sha256": "329634ba9421a9a65b2802b4ba5b07667fae194411904cbbfc7f002da84c0f97", "time_utc": "2026-08-01T04:04:20.601089Z"}
+{"details": {"cell_id": "c0867a2b7f8ca30ce79eaf94a8c2813b"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "e5ddab26c37ade9b0ef1cc0d4c4fea765bd101aee8f884ae3ac8ea53288c9158", "run_id": "r017", "schema_version": 1, "sequence": 100, "sha256": "f11da82728a5da7b5551c0606640e84d9dd17e205852841fd853ab77c81fd31c", "time_utc": "2026-08-01T04:04:35.533251Z"}
+{"agent_id": "/root/report_r017", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "38ff28dc9060121449712589b3c6af669d04daab30de9a30394ca021cce4df19", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "de75ad20d38a6c436884de347f681cd4392b058a1d981a7dd42c2b26022f0f2b", "run_id": "r017", "schema_version": 1, "sequence": 101, "time_utc": "2026-08-01T04:05:06.105978Z"}
+{"details": {"cell_id": "ef1a0677a6ed30a4b2ccf4bf2c4fa075"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "013dfa864bbc52302953ad37c7a65fa7d126272dddf926bf36277a1c9177d21a", "run_id": "r018", "schema_version": 1, "sequence": 102, "sha256": "137535cf8f0cd5a60e4cd8136583ed7bf3613e759a9945830e3f4934f6a8efc0", "time_utc": "2026-08-01T04:05:13.390661Z"}
+{"agent_id": "/root/report_r018", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "09d77fc4551aeac84987e86819cf7b3a8964885dfc6492b595a1ceafe0e36ddf", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "a5729d6790c03617dff4f398698997255d9cf681d08d0ead37fd853da97ce076", "run_id": "r018", "schema_version": 1, "sequence": 103, "time_utc": "2026-08-01T04:05:51.314239Z"}
+{"details": {"cell_id": "07041e4c7851c15fbd8ca3b5b89a649c"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "6580059ad81d0849c0bc3245a2330d3381818dbea8bb75c0dc046a390dc91dd7", "run_id": "r019", "schema_version": 1, "sequence": 104, "sha256": "47cff72c4e3d50b634f7b22a97900a8dfb4a75f557d6be25b3736e2c3ad98689", "time_utc": "2026-08-01T04:06:01.279533Z"}
+{"agent_id": "/root/report_r019", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "f8bc4979827285f8cdb6cf88a856784d00b0c29b3f11b7d274452bd8001fd253", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "7d2baf3d9594c52b0b9d646862af033c472e58c6803fb2d01b0df9be8a6f4270", "run_id": "r019", "schema_version": 1, "sequence": 105, "time_utc": "2026-08-01T04:06:35.191323Z"}
+{"agent_id": "/root/report_r017", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "481f987608b9b9d677a29b50ba9d0fcd7b9a674ad0d162f3ffd8b51b63aefc9a", "run_id": "r017", "schema_version": 1, "sequence": 106, "time_utc": "2026-08-01T04:08:36.418628Z"}
+{"agent_id": "/root/report_r018", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "d24dcf26215114ccaa9c440ab845822dc524052666302239651b4be1c848365c", "run_id": "r018", "schema_version": 1, "sequence": 107, "time_utc": "2026-08-01T04:09:16.530507Z"}
+{"agent_id": "/root/report_r019", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "32cbcfd8c169ea135997c32b152b989b8de560c2ddf56a7bf1e7dd2c3793b704", "run_id": "r019", "schema_version": 1, "sequence": 108, "time_utc": "2026-08-01T04:10:24.012387Z"}
+{"agent_id": "/root/report_r017", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "7a9dd368c3d89294620dd15c97314302595c59a1fd983e73f7f3326d67b272ec", "run_id": "r017", "schema_version": 1, "sequence": 109, "sha256": "5698bf531c44baaf8859facaf0f8764768c2ea8441e36db7d7776b753e8a91b2", "time_utc": "2026-08-01T04:12:33.932136Z"}
+{"agent_id": "/root/report_r017", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "a7c34810899ac0aa4f0ad826b155640263d9d105e55d81a317070edb6209d454", "run_id": "r017", "schema_version": 1, "sequence": 110, "time_utc": "2026-08-01T04:12:33.933802Z"}
+{"agent_id": "/root/report_r017", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1145}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "298a4ca8149f6fb820bff4e3a67eac9123383991589c5d3d1f2a4a127c3fdaba", "run_id": "r017", "schema_version": 1, "sequence": 111, "sha256": "900af7df55266fc2bb71f705014f9c2bb396adddfebb0bf70f6d3926d9939f51", "time_utc": "2026-08-01T04:12:33.935461Z"}
+{"details": {"cell_id": "0a93b4a0423042598341734b5b80aea2"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "a3188474b872f1aa5a195ec71b6db05eeda107b460a18352da2aa9b4e9e34bcb", "run_id": "r020", "schema_version": 1, "sequence": 112, "sha256": "3c55a8c29754ba59212a8a3b8108cc7d41284db5a4f7feea03c6bef29894b20b", "time_utc": "2026-08-01T04:12:39.373284Z"}
+{"agent_id": "/root/report_r020", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "ad75481d8f2eb81db6d1b2f48938ca148ead3476c0ee16594535d8469b0d72ab", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "4a7bb7ba745b26122709862b5ac942c43a29e789e215a5267dcfc5bbe6146b9a", "run_id": "r020", "schema_version": 1, "sequence": 113, "time_utc": "2026-08-01T04:13:02.079342Z"}
+{"agent_id": "/root/report_r018", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "fc4d9f41601c983de4c8f1f6555e5d779e583d188891ec1bdec10c10dee11304", "run_id": "r018", "schema_version": 1, "sequence": 114, "sha256": "fb3702706a5402f72bb71ada4b32928a85f12fd35a0b15cb76943fab591c6857", "time_utc": "2026-08-01T04:13:18.882087Z"}
+{"agent_id": "/root/report_r018", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "5b2644c305dc0fdfd26517dbd29760b04af692d73e399bc29d9ea40b871f3dbf", "run_id": "r018", "schema_version": 1, "sequence": 115, "time_utc": "2026-08-01T04:13:18.883744Z"}
+{"agent_id": "/root/report_r018", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1217}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "819acb95342b9c0f594d4d2076f8c1f915e6419c2d918ec436913d0112f86a67", "run_id": "r018", "schema_version": 1, "sequence": 116, "sha256": "6810e706f4b3974f0c1ef770bc1c8a4eb31bc902a454ca762c9f9491147e9917", "time_utc": "2026-08-01T04:13:18.885126Z"}
+{"details": {"cell_id": "45d746368e63763aae22c259c646af5e"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "0c78d56d89067944dad4d921db9b8b94d4842357feb130653d5d7fa8e765d8b4", "run_id": "r021", "schema_version": 1, "sequence": 117, "sha256": "5daa4afb2736152dd62075c4f6b2d462a94abae278d993714db4d6a2687b8aca", "time_utc": "2026-08-01T04:13:24.175443Z"}
+{"agent_id": "/root/report_r021", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "4cdbf370afcdaa8d3cdcc21649e1992108002bb64fc375e64432e9274c682e0d", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "76b860083588a2d9403333330355091fef251e050707153f8f0769069d956448", "run_id": "r021", "schema_version": 1, "sequence": 118, "time_utc": "2026-08-01T04:13:48.485776Z"}
+{"agent_id": "/root/report_r019", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "5ec48b3f539959e86576261d5e6e6fcd39b00af737c61585d13a580993ec60fc", "run_id": "r019", "schema_version": 1, "sequence": 119, "sha256": "b5befbdd1fd3c9b883427a54f3d5a91d6acd5b9d495d40b25a89b8f45915d53f", "time_utc": "2026-08-01T04:16:28.633946Z"}
+{"agent_id": "/root/report_r019", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "bca02b260eaad37f7af125e05c52e0139e22b20b1b072809a4abfdb9cfe3b448", "run_id": "r019", "schema_version": 1, "sequence": 120, "time_utc": "2026-08-01T04:16:28.635500Z"}
+{"agent_id": "/root/report_r019", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 902}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "09f059fd4675f9daa630c21729884c58fb814e052b31b9d1012f6beba8094de0", "run_id": "r019", "schema_version": 1, "sequence": 121, "sha256": "3e728c8ae2e5aea7eecfd5af8aab61c637c06478e3182e6f7dccdaa569a170c2", "time_utc": "2026-08-01T04:16:28.637160Z"}
+{"details": {"cell_id": "cf391d64b44517b85ca71858bb6d8e52"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "963a733abbb0da742c2a97d7c995ef265ef1bf0b9d121c5d83285970a74dc707", "run_id": "r022", "schema_version": 1, "sequence": 122, "sha256": "bcd4975f9d394e539499afd20a6234eafdbd55019d9a95c28050d81278ee2870", "time_utc": "2026-08-01T04:16:34.521280Z"}
+{"agent_id": "/root/report_r022", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "e743edb6b03f996e9a73af3159d1cf717151c296733c63b0be190004c7c44336", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "11486e57ee2d4c25a9de251b036c39b074e8d158a486836694bf2387e4d90819", "run_id": "r022", "schema_version": 1, "sequence": 123, "time_utc": "2026-08-01T04:17:04.733416Z"}
+{"agent_id": "/root/report_r020", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "6708eec2c35375847967a6081c77253c14b5e1df18a7fdb98516cb775b8f9f36", "run_id": "r020", "schema_version": 1, "sequence": 124, "time_utc": "2026-08-01T04:17:15.776843Z"}
+{"agent_id": "/root/report_r021", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "dfde7d44cbc4decdd32ad445c97909714e17733c2267c51f4cdabd9b68c56313", "run_id": "r021", "schema_version": 1, "sequence": 125, "time_utc": "2026-08-01T04:17:26.644866Z"}
+{"agent_id": "/root/report_r022", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "30e4603523d406f3e8ca3eed05c8fc404b380788ed75d560eb37428e3554048d", "run_id": "r022", "schema_version": 1, "sequence": 126, "time_utc": "2026-08-01T04:20:40.697745Z"}
+{"agent_id": "/root/report_r020", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "a757cc465e40e229738a6dc1f076265940c835fe68f630aa9c12dfb555739c03", "run_id": "r020", "schema_version": 1, "sequence": 127, "sha256": "783e7abd03e2d035ef71631507ee892543258c51153ab6cb1f6a935e2252a603", "time_utc": "2026-08-01T04:20:54.110478Z"}
+{"agent_id": "/root/report_r020", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "3d553cfeddd731fe9b467ffdfe519536d3e0b242b5bf8767442552dc5d03927b", "run_id": "r020", "schema_version": 1, "sequence": 128, "time_utc": "2026-08-01T04:20:54.112279Z"}
+{"agent_id": "/root/report_r020", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1090}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "a4d02b539f70e2d8a2f1788889876130d6e3a55d5281103ca42fe2c4f90eeb4f", "run_id": "r020", "schema_version": 1, "sequence": 129, "sha256": "afa2159eb13ec9ede81adee124835d0ab9c5e0468202378356654636f23d1e66", "time_utc": "2026-08-01T04:20:54.113712Z"}
+{"details": {"cell_id": "136b2c4efefe0bab1417f14b38a57793"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "5b3af0cb8e04e10260fb85c46db14496172f7477680ee2ef47882140f7f1c71c", "run_id": "r023", "schema_version": 1, "sequence": 130, "sha256": "eafa8ea607124e007b2ddd206e39dbe4f282fe9d7e59d365606cf7d2df3c3a11", "time_utc": "2026-08-01T04:21:00.848699Z"}
+{"agent_id": "/root/report_r023", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "2f7d5b811b0476967e0fd4b75864ee6a3696a22f614c7339ee1244686fd725de", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "8d684bcb2cffade9a2f76af7d130d75b7fd6b8088d739c0a270c659ff420361f", "run_id": "r023", "schema_version": 1, "sequence": 131, "time_utc": "2026-08-01T04:21:27.058120Z"}
+{"agent_id": "/root/report_r021", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "1a5422c2376a22038de4a694647bdf0455124361740085d7de73b04c11bfd87d", "run_id": "r021", "schema_version": 1, "sequence": 132, "sha256": "9f66c9b44bb7e33d17110ce78651c2b89480ac21403c70fabe985265e9026fb7", "time_utc": "2026-08-01T04:21:32.965788Z"}
+{"agent_id": "/root/report_r021", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "930a2f87cf8ee63f79e2093a0ac96b3965d5c13e8da7b0b5f90e6b3095099705", "run_id": "r021", "schema_version": 1, "sequence": 133, "time_utc": "2026-08-01T04:21:32.967436Z"}
+{"agent_id": "/root/report_r021", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 837}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "e7aef724cfe4520940cefcd28149e1d64f19c819b799ff16bcee75a5ce12d09a", "run_id": "r021", "schema_version": 1, "sequence": 134, "sha256": "f171bae3f575098cdab781093b1dc9e5455f576fc232bf6c0eadf70ce1a634fe", "time_utc": "2026-08-01T04:21:32.968890Z"}
+{"details": {"cell_id": "aea81024b16085dc0bc078cab31e9b6d"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "edda6565f440f40dfed1c8d1ddecc56df5dad5e30818e87abf9b2beba2501c68", "run_id": "r024", "schema_version": 1, "sequence": 135, "sha256": "e1dd39f580e8f46644c365edac09d5ece9f7bc3c238e19247a8232ca920f5f10", "time_utc": "2026-08-01T04:21:43.749846Z"}
+{"agent_id": "/root/report_r024", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "016954e4ae479d191c8e1781eaaaf36091a5245847e5d0d6c8b4294d8a81981a", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "030c3913d4d7235885dfbc88f15d38e7a167092c3ca04121ef3f324414f443bf", "run_id": "r024", "schema_version": 1, "sequence": 136, "time_utc": "2026-08-01T04:22:10.266778Z"}
+{"agent_id": "/root/report_r022", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "eea0bb499d60bfeb2ce6711fccd6b5fb0f8bc8bbec92725585c55260103fb70c", "run_id": "r022", "schema_version": 1, "sequence": 137, "sha256": "aae7a2666341935ab061c06b86cf96f2ae64188268090c20f1a2a9bf42ca699b", "time_utc": "2026-08-01T04:23:31.292716Z"}
+{"agent_id": "/root/report_r022", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "298051059afb2103a50311b9250c91f1ae120fd370e4dc1c194c119dcd41b41e", "run_id": "r022", "schema_version": 1, "sequence": 138, "time_utc": "2026-08-01T04:23:31.294251Z"}
+{"agent_id": "/root/report_r022", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1161}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "979a919b88f1dd67ca8d87266cd9926acd35b47680112f50c0c90520a47342fe", "run_id": "r022", "schema_version": 1, "sequence": 139, "sha256": "47f498ee490b32d33140eba16ddf4fa3ea10df4bd2c24d2275499fa30fd9de24", "time_utc": "2026-08-01T04:23:31.295594Z"}
+{"details": {"cell_id": "83498ad4b1212eaea7b615f0292a1ce3"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "214051f3cc36ea8edf5c9018d0eb12426f2d88feece3cc90f7dbd1e412ac7361", "run_id": "r025", "schema_version": 1, "sequence": 140, "sha256": "50c867f047fde22527ebcd8de0fac035ff0b2243d4630159e4a5e962f0806678", "time_utc": "2026-08-01T04:23:38.104850Z"}
+{"agent_id": "/root/report_r025", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "c00abf6af2e732702e9019ed06a3262b61e9695172b3dd97d6b4c80b3166115d", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "8cee724ed748a69186ebdc4112a0a16f22f246150c6044118db2aba92795494a", "run_id": "r025", "schema_version": 1, "sequence": 141, "time_utc": "2026-08-01T04:24:07.782868Z"}
+{"agent_id": "/root/report_r023", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "d239730cd4a22f84298f67865e5169ed16d0373047df842a32e7f88f12ea74ec", "run_id": "r023", "schema_version": 1, "sequence": 142, "time_utc": "2026-08-01T04:24:39.256639Z"}
+{"agent_id": "/root/report_r024", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b808923e2ac7fe1e4e546d9a86c9de597ddcf36d4fb081a3dcd5eb4c280972b0", "run_id": "r024", "schema_version": 1, "sequence": 143, "time_utc": "2026-08-01T04:25:37.393352Z"}
+{"agent_id": "/root/report_r024", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "b7898f6c8a0ef961b5303f2511395721c3996ccb60bc70fe68fb6e3533fed0de", "run_id": "r024", "schema_version": 1, "sequence": 144, "sha256": "5d4fc845007b0792f73641af01930ba1a53236f0f37734fe9d547104e78cd7cc", "time_utc": "2026-08-01T04:26:47.745226Z"}
+{"agent_id": "/root/report_r024", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "b2e73fd8511529209a84c49cd511af2d7fdd416b9c9d20b54f993e7350f9689b", "run_id": "r024", "schema_version": 1, "sequence": 145, "time_utc": "2026-08-01T04:26:47.746917Z"}
+{"agent_id": "/root/report_r024", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 936}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "d1f6daff596d92a4a5adce4eabebbd85b6155ce9d9ad13266ca1a10b10f5339e", "run_id": "r024", "schema_version": 1, "sequence": 146, "sha256": "89b14c495f9833e34e5cf92aa27d75aec62ad353d1b06393998fb1bcc57577ca", "time_utc": "2026-08-01T04:26:47.748666Z"}
+{"details": {"cell_id": "b9a35f06e08e96ce9b0b093da1de80da"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "63498e070f7af0c3a61c1bb7cd70a6bf66e7fe90e8e7f2a41a516a3953a5c5c8", "run_id": "r026", "schema_version": 1, "sequence": 147, "sha256": "0929ea683da68ba9e6509f0dbcab126c1d778a61abf7009bb771099f18f92d1c", "time_utc": "2026-08-01T04:26:56.003830Z"}
+{"agent_id": "/root/report_r026", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "19b5c4c0d34973e6d806e47b9550feda2a135674330ea3e90019d94645095123", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "ec6247ee7b86cb0c51cf01686f34b8763f82563690d4067d63f407a0668e49b9", "run_id": "r026", "schema_version": 1, "sequence": 148, "time_utc": "2026-08-01T04:27:22.134147Z"}
+{"agent_id": "/root/report_r025", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "9956732cfd15466e298e0dc6a9e253a427e39bd918b493fcb3040f64bff0b705", "run_id": "r025", "schema_version": 1, "sequence": 149, "time_utc": "2026-08-01T04:27:39.391490Z"}
+{"agent_id": "/root/report_r023", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "e2c2c579e78f3ad728a01a6c7b23bc877a75c9344b1e89ae6888f3c9dfb7b4fd", "run_id": "r023", "schema_version": 1, "sequence": 150, "sha256": "8264c2204e75d09fe5cf45b55a634a4c21ec7c6679f47f112f2182dd14520e50", "time_utc": "2026-08-01T04:29:20.216023Z"}
+{"agent_id": "/root/report_r023", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "eb53f33cdf983bef6df20f710445041ea89fab8c879f99025aa98987f2bf721e", "run_id": "r023", "schema_version": 1, "sequence": 151, "time_utc": "2026-08-01T04:29:20.217581Z"}
+{"agent_id": "/root/report_r023", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 895}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "adc6822866f2b61429a4889c20ab45c0e7eb6e1973b930bf12cb921ed0fef1db", "run_id": "r023", "schema_version": 1, "sequence": 152, "sha256": "4d0cdd801e8141b99cc8248d4bdfa4e04db33b09bfd7984cb5d780318e5d2edd", "time_utc": "2026-08-01T04:29:20.219082Z"}
+{"details": {"cell_id": "a29afd5bf972ec132f78543ba750e93f"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "e8ae2473d50ed9a4284fe50afed355df8f16979ea4b6763b4649b7a2c8101de2", "run_id": "r027", "schema_version": 1, "sequence": 153, "sha256": "497395a29640fa808f49ac4ba8fccbeb8497fcb44d0d870985253d1805a2add5", "time_utc": "2026-08-01T04:29:26.240909Z"}
+{"agent_id": "/root/report_r027", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "8f6bbbcff48065d83c7de78b1682471f925d1d1d223898a67d1a577168a04974", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "6d6f7e887ab7fb548be4c8ef146eacd41476634db8c69f539cefc3e3a808dc07", "run_id": "r027", "schema_version": 1, "sequence": 154, "time_utc": "2026-08-01T04:29:54.182099Z"}
+{"agent_id": "/root/report_r026", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "a3635bd435d2e1e498f0646109edd24af6c78e5f2f41c9d4019713efef79e806", "run_id": "r026", "schema_version": 1, "sequence": 155, "time_utc": "2026-08-01T04:30:29.581390Z"}
+{"agent_id": "/root/report_r025", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "13ff426eae9555f61fb16e86ae331fbb339278e0d997bcef60015f2c302d7338", "run_id": "r025", "schema_version": 1, "sequence": 156, "sha256": "7e2af2467578e7c8af1c826fa091fda0a17845a6050fd2f9a8e3ef2af89ebea1", "time_utc": "2026-08-01T04:30:48.784910Z"}
+{"agent_id": "/root/report_r025", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "846a848d5ad5070e668e975518a72495fe247b72ff6ab9da6014cd2fb71e6e94", "run_id": "r025", "schema_version": 1, "sequence": 157, "time_utc": "2026-08-01T04:30:48.786642Z"}
+{"agent_id": "/root/report_r025", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 724}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "ee2b31524be11890ee027c57873ef28f511c1ef51302ba74817c4289b63d07c0", "run_id": "r025", "schema_version": 1, "sequence": 158, "sha256": "cae33ebb10f593bbebe9722ae1b12d2a8e1ebbeaa477704ed16d61296c964bae", "time_utc": "2026-08-01T04:30:48.788078Z"}
+{"details": {"cell_id": "8beb0474c46f57c79e68aa2f12dfd6a6"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "6408eb60cf2a08860dcc8604aae12677ed24b4cf3b4ac6bdad58422e7ecec49b", "run_id": "r028", "schema_version": 1, "sequence": 159, "sha256": "3366d07f2472380d74590090e180787a036a63f8f536e42f0fb2344d6f4d1ee8", "time_utc": "2026-08-01T04:31:01.329366Z"}
+{"agent_id": "/root/report_r028", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "604a2c07c2ec9e4734dde7665856b75bddbd2ef6e9c2319cb657cb118ffb7f38", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "6ff9ce43b5a5d2aa5aae09389b33f6d12439c5198781742ade69291313e62930", "run_id": "r028", "schema_version": 1, "sequence": 160, "time_utc": "2026-08-01T04:31:30.631569Z"}
+{"agent_id": "/root/report_r027", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "0e2ba16a76d45ceef58e8474323e7d70f72961bde95c5b13b06be61a3aad9f9f", "run_id": "r027", "schema_version": 1, "sequence": 161, "time_utc": "2026-08-01T04:33:33.780520Z"}
+{"agent_id": "/root/report_r026", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "e2da3ff58a5b8e447efe119b41299ec955e40b94d52a197e7864041afd4f6474", "run_id": "r026", "schema_version": 1, "sequence": 162, "sha256": "52f71f956e63c6ab77fa990401725103c78b2163030cf5b5925672989b60b5df", "time_utc": "2026-08-01T04:33:54.993720Z"}
+{"agent_id": "/root/report_r026", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "0691e28e1ff465b9bda722f1e0a01b77fb733db0bae0ea3e2c74480ddb9605e7", "run_id": "r026", "schema_version": 1, "sequence": 163, "time_utc": "2026-08-01T04:33:54.995293Z"}
+{"agent_id": "/root/report_r026", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 816}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "64c9c2cb8d15268db312d78b15b3cfaed94924865fc0ad21ed838d1bc857910f", "run_id": "r026", "schema_version": 1, "sequence": 164, "sha256": "0ff6cb9b958a530a041aa729635ab67524b6fbcc772a8cf5856d861bbe23fb17", "time_utc": "2026-08-01T04:33:54.996834Z"}
+{"details": {"cell_id": "a3f969c74a0d22bd838ad11dd92aa415"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "dec7adafbf28f508a17ec24917cab6fc997a5cb8788630f7b89d62714d3eddbc", "run_id": "r029", "schema_version": 1, "sequence": 165, "sha256": "2de687061dd9cb178a6c9fc1cbda4f08bb9e1da85d9b8fbb580d62aec03ddf15", "time_utc": "2026-08-01T04:34:00.736557Z"}
+{"agent_id": "/root/report_r029", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "bf9153f12cec171c1ad7faeefcb624468e29d940a3eea4b4d631fde2dd990888", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "2a93f2e1ef9b52e9201d1098a054bec6295be3500f98a786fc9f33bd5f258577", "run_id": "r029", "schema_version": 1, "sequence": 166, "time_utc": "2026-08-01T04:34:27.931958Z"}
+{"agent_id": "/root/report_r028", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "08c65b6b6ec4c8b8cb66b7c06a51ecc7cd40f1a7e4a5ba5b9731c22f8b707ad1", "run_id": "r028", "schema_version": 1, "sequence": 167, "time_utc": "2026-08-01T04:34:39.268875Z"}
+{"agent_id": "/root/report_r027", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "83cd923eaf73654282b0deeff9acefea34243cb3f602c5b4296dc0253414a21f", "run_id": "r027", "schema_version": 1, "sequence": 168, "sha256": "cf987153e4b4cd8f2698b918c6259521e48937824a336ec0233df51bab9db57a", "time_utc": "2026-08-01T04:36:48.948071Z"}
+{"agent_id": "/root/report_r027", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "aab33623a2dcbc7b371a6d2acc211a9df864b4cfcae434c40535b4a5a8e1b938", "run_id": "r027", "schema_version": 1, "sequence": 169, "time_utc": "2026-08-01T04:36:48.949561Z"}
+{"agent_id": "/root/report_r027", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 910}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "4969c2ef3a290a823f6241b156ac138026a726406214b59f35428f3cee6624d3", "run_id": "r027", "schema_version": 1, "sequence": 170, "sha256": "4661ad891ae68f808fefc57a29a5b2d1ee36364508329ddb3163e18761d0b9ad", "time_utc": "2026-08-01T04:36:48.951026Z"}
+{"details": {"cell_id": "919322be3592430d06791a08b1aa8cea"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "3a37d4bba5471e0c06ace7df0d0f36f80018e284ead1aa133b9d20346d0c2bc3", "run_id": "r030", "schema_version": 1, "sequence": 171, "sha256": "8166befc3e1ebdb7e3978c951090090b50b4b28a636324dc951125ba0b858558", "time_utc": "2026-08-01T04:36:54.837327Z"}
+{"agent_id": "/root/report_r030", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "cfded1802a525889528c5a997577bde5d67539e951a21147320a4f10d05e38f2", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "fa05f1efd06d8e67ab115a0ca1a33e94b699459794fa3982542a8a643f0c5aa1", "run_id": "r030", "schema_version": 1, "sequence": 172, "time_utc": "2026-08-01T04:37:25.697113Z"}
+{"agent_id": "/root/report_r029", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "f5c7eb0a414c3687171dc85e5c882776be7d93b0571e14de7f9969da21d5da9e", "run_id": "r029", "schema_version": 1, "sequence": 173, "time_utc": "2026-08-01T04:37:48.921728Z"}
+{"agent_id": "/root/report_r028", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "358ba64681011932d027a2936352bcccf8f9d741fd8874a52c5d4c2197c4543a", "run_id": "r028", "schema_version": 1, "sequence": 174, "sha256": "b14a67869367f0bd1e2d4371a708c3d36cc9838d94ab2d03588b20571fed6e69", "time_utc": "2026-08-01T04:38:30.281434Z"}
+{"agent_id": "/root/report_r028", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "e9f634815074b8ed317fc2e816d682cb3608a20d433e7fa0e7193953657a3839", "run_id": "r028", "schema_version": 1, "sequence": 175, "time_utc": "2026-08-01T04:38:30.283134Z"}
+{"agent_id": "/root/report_r028", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 995}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "c6783b25fbfae75fea07e45c030579c5716df915399da9824b0d36fefa9b380f", "run_id": "r028", "schema_version": 1, "sequence": 176, "sha256": "130367c76a139f7075e90837340f67fbb8411604f57a468cb3a30499bfc9a585", "time_utc": "2026-08-01T04:38:30.284624Z"}
+{"details": {"cell_id": "c42948b54a7eab85fd103b78c835c7ac"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "4a31e6e8237b63e1d4575f2c9f07271584efcd9de058b2d907fbcdf86b14a326", "run_id": "r031", "schema_version": 1, "sequence": 177, "sha256": "6be25072bb831a1eab89323925b7019d8bf10fd01d415701bf4486a1b93c0aa2", "time_utc": "2026-08-01T04:38:37.606859Z"}
+{"agent_id": "/root/report_r031", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "5c39d89188df5bab701a3667ac1c4ae50f5dfcc3b2913f292b6c4f4884344974", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "5ad82a350eacc515ca346466afb0ce435295ebe0e40b706300012db9c0249d2c", "run_id": "r031", "schema_version": 1, "sequence": 178, "time_utc": "2026-08-01T04:39:03.029513Z"}
+{"agent_id": "/root/report_r030", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "266376b130d8e4e274e52e9dbde30ecf2a6aec65fe30171fb710f9326dbdc163", "run_id": "r030", "schema_version": 1, "sequence": 179, "time_utc": "2026-08-01T04:40:44.470313Z"}
+{"agent_id": "/root/report_r029", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "2598af7ea77cd8419b0aac09ecef4c2568f6ea2151c2ae1897ae23f010889e27", "run_id": "r029", "schema_version": 1, "sequence": 180, "sha256": "34c7646301788f58a987e37f441e706098dbc4ddd5f18489906c73198a2988df", "time_utc": "2026-08-01T04:41:01.441588Z"}
+{"agent_id": "/root/report_r029", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "74f64964ce6e3fac842d1f79e8d4924e43ef8334ebbabebbde67129fc2f5f4c5", "run_id": "r029", "schema_version": 1, "sequence": 181, "time_utc": "2026-08-01T04:41:01.443176Z"}
+{"agent_id": "/root/report_r029", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1093}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "73fdb500a0a30c2244e2a0ad7e159d57830e880443b90baf76928fb2b03df993", "run_id": "r029", "schema_version": 1, "sequence": 182, "sha256": "ff506100d0e272b8bd653caab454d10845a938aee535aa0cb927869bc553b883", "time_utc": "2026-08-01T04:41:01.444967Z"}
+{"details": {"cell_id": "418a4bcde6dda1a6187bae8547d85a93"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "3503d2336c8f86edd108b969c2b25797e6880b05fbdac1c0464b418e0e740ddc", "run_id": "r032", "schema_version": 1, "sequence": 183, "sha256": "b8a8a2f94e58cef25a78d263a23cef3f464f40607305dc3c2ad2bd6495cf81bc", "time_utc": "2026-08-01T04:41:07.471971Z"}
+{"agent_id": "/root/report_r032", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "b2003d48ef6d61f1a60658490b2b6995369f3a42dc2105558d9ce9d39a4143e0", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "f54d610a2eb07e1d93e9dbc2670bd0bd3be45644bfabe25006645ee551dbf3b9", "run_id": "r032", "schema_version": 1, "sequence": 184, "time_utc": "2026-08-01T04:41:39.956840Z"}
+{"agent_id": "/root/report_r031", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "514f31768ee6ac8f2af47ad02c22656242576e2eeac4b363532b695cf75c8b20", "run_id": "r031", "schema_version": 1, "sequence": 185, "time_utc": "2026-08-01T04:42:24.971861Z"}
+{"agent_id": "/root/report_r030", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "edde214ce3816d0e8a2a0e81f6340c8f94438dbe1ade874177d15c4ef7ab2292", "run_id": "r030", "schema_version": 1, "sequence": 186, "sha256": "be494a4e46dc869e60f38144409ce0ef20591df6c844d4f5cd136965927e4f67", "time_utc": "2026-08-01T04:44:50.444890Z"}
+{"agent_id": "/root/report_r030", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "89adb980ee14dbfb7594a66ec10cfa5f50d9d07902632ea116f9dac30049c68b", "run_id": "r030", "schema_version": 1, "sequence": 187, "time_utc": "2026-08-01T04:44:50.446481Z"}
+{"agent_id": "/root/report_r030", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 904}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "1ce6ee5edcb85ac9aa8c37a8cfe468fb4de424305713bf91e73145efe78d73a3", "run_id": "r030", "schema_version": 1, "sequence": 188, "sha256": "3a3fe93cf06b9c2158f5159a07f1f3703e2d6b9c8a30e34fbc523636f1e911b1", "time_utc": "2026-08-01T04:44:50.448058Z"}
+{"agent_id": "/root/report_r031", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "b165b81b80041a1f9f3b1b723abf3c9ee79cf42e444a2bdc6b4ca016aba7c09c", "run_id": "r031", "schema_version": 1, "sequence": 189, "sha256": "cc4ca4dab1fdd95b225c66c388e185cee7ca47b8dbedef3ea20f0abbc25d24ec", "time_utc": "2026-08-01T04:45:15.035728Z"}
+{"agent_id": "/root/report_r031", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "1a220ab71013ccc119e86c4ff021811e2811acb7abc4783a81835fda4dd48bf0", "run_id": "r031", "schema_version": 1, "sequence": 190, "time_utc": "2026-08-01T04:45:15.037485Z"}
+{"agent_id": "/root/report_r031", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 962}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "376b552ba349e9a9222a4b57deadee93f5b64bf1bbe89f3b9a7288f6729d30f4", "run_id": "r031", "schema_version": 1, "sequence": 191, "sha256": "741de41033e7f4a9d25be1cf0231aee79363e384a8b71070b43a4b7f053baa67", "time_utc": "2026-08-01T04:45:15.039174Z"}
+{"agent_id": "/root/report_r032", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "cd5345078e58a1681c3264d71b56473f0a55d13f6df4058c8795237104c75de0", "run_id": "r032", "schema_version": 1, "sequence": 192, "time_utc": "2026-08-01T04:45:21.553647Z"}
+{"agent_id": "/root/report_r032", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "336512cb37573ae4f62608665e5049d047d20172bcf51a7cc8f59f58af563416", "run_id": "r032", "schema_version": 1, "sequence": 193, "sha256": "0bf5976a9b62eae2e5870b489161b65eacdf8a6c6c76cbbc379e4e12a54d4167", "time_utc": "2026-08-01T04:48:37.518879Z"}
+{"agent_id": "/root/report_r032", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "40bbd1f0b9548eade29794a1cb4f72d3bc5898bad45746414546e492e5b76f7c", "run_id": "r032", "schema_version": 1, "sequence": 194, "time_utc": "2026-08-01T04:48:37.520314Z"}
+{"agent_id": "/root/report_r032", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 745}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "593037b4d1fe171b449294296e677a5f07f243733c7527c71227d9fa9a92e0cd", "run_id": "r032", "schema_version": 1, "sequence": 195, "sha256": "99dc13ef74c153e0fc79419057499d99a38105c2d8fe710ddb80a54e70e0dc59", "time_utc": "2026-08-01T04:48:37.521745Z"}
+{"details": {"entries": 76, "wave": 3}, "event": "authority_verified", "phase": "collection", "previous_event_sha256": "1b79b14eb574a4038cf26c49f9da90318464fc2d43b94b9e86aad51d350bc0bf", "schema_version": 1, "sequence": 196, "sha256": "329634ba9421a9a65b2802b4ba5b07667fae194411904cbbfc7f002da84c0f97", "time_utc": "2026-08-01T04:48:53.978863Z"}
+{"details": {"cell_id": "ca8819a9835763564d3e5c7b365393d8"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "c2064e1f000737d743b02fe08661c73c31599306cc18b2f22bea79d0884dd6b5", "run_id": "r033", "schema_version": 1, "sequence": 197, "sha256": "b1c03738e83b44d8a267f6eb111230311bafcff9f0a885d32aea1238f056308d", "time_utc": "2026-08-01T04:49:11.965372Z"}
+{"agent_id": "/root/report_r033", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "161503a0c64a754f3eeab2ac40f23bf478258ba600c86493aa401c15793b1a50", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "ab9f33d792cb131f6ee86789de810e30c8f7aa48a48ffea89faf29d9d352841c", "run_id": "r033", "schema_version": 1, "sequence": 198, "time_utc": "2026-08-01T04:49:40.211722Z"}
+{"details": {"cell_id": "1ff38d28876c4cdd6329bfeaa1385e6f"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "d6061f6317c03e2a4c4d09faf61e4e0f79c8ecd780169e58c524c748852de9cc", "run_id": "r034", "schema_version": 1, "sequence": 199, "sha256": "0a52bfadfea165f32af3a21c8cdd211dc0772c7b08809fd284d4d163f1e86a6d", "time_utc": "2026-08-01T04:49:46.100394Z"}
+{"agent_id": "/root/report_r034", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "253a3851bf6d014ab6d51e500e1ac6dbeeb3bf99c52e2a0967382c4e2148b84a", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "0b9f5cc900d94380a7dcf1e731a069f261d709265c63c432321203b98524feae", "run_id": "r034", "schema_version": 1, "sequence": 200, "time_utc": "2026-08-01T04:50:12.220162Z"}
+{"details": {"cell_id": "07fde893dca23f5e7b0b0e576c212375"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "d247100fdefae2181fad2ccfbfb088c98cba5adc56439b90deb30a346f488649", "run_id": "r035", "schema_version": 1, "sequence": 201, "sha256": "ee68ee07045e040ea4046760ae31d0b44cb70fdeea16480e336345dfb6038e91", "time_utc": "2026-08-01T04:50:21.209615Z"}
+{"agent_id": "/root/report_r035", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "a5603287fa3e6506de63e13e234137a1f36a17ca74b2641d02b74d1aff534de1", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "0debeb30c8713565bf6697ad9a5a1da6d331a1122d10a83e83f637065fa5a9c5", "run_id": "r035", "schema_version": 1, "sequence": 202, "time_utc": "2026-08-01T04:50:48.452813Z"}
+{"agent_id": "/root/report_r033", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "65eb2905445fb95fc9c60793c35ad2a7139b3272e0baf7625ad217a7e6c98203", "run_id": "r033", "schema_version": 1, "sequence": 203, "time_utc": "2026-08-01T04:52:57.145830Z"}
+{"agent_id": "/root/report_r034", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "c1fdc173ae88b049958544b342fdd700b951df3384caab321b9494a78e613b4b", "run_id": "r034", "schema_version": 1, "sequence": 204, "time_utc": "2026-08-01T04:53:42.195819Z"}
+{"agent_id": "/root/report_r035", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "75e47bad862dfd148deb0f57af442d4ee48f3e88addba97c4f1eadd7719699a7", "run_id": "r035", "schema_version": 1, "sequence": 205, "time_utc": "2026-08-01T04:54:40.862278Z"}
+{"agent_id": "/root/report_r033", "attempt": 1, "details": {"disposition": "ORCHESTRATOR_TOOL_FAILURE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "34b3b522c53630bd8cb3f52dea9ef26a688af0b85d713f00b8141873b7d101b0", "run_id": "r033", "schema_version": 1, "sequence": 206, "sha256": "98e10505aa5e5632cb7883d7463b92a392ab77ed1ca795b39a86d85b7912f4d9", "time_utc": "2026-08-01T06:18:37.965835Z"}
+{"agent_id": "/root/report_r033", "attempt": 1, "details": {"api_state": "INFRASTRUCTURE_FAILURE"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "0660fe1db085b2ceb1def0a303990a8faa8100a6c430693f35cb829f1792d5f6", "run_id": "r033", "schema_version": 1, "sequence": 207, "time_utc": "2026-08-01T06:18:38.562259Z"}
+{"agent_id": "/root/report_r033", "attempt": 1, "details": {"disposition": "ORCHESTRATOR_TOOL_FAILURE", "evidence": "Agent disappeared from collaboration state after user steering interrupted the orchestration wait; no completion callback or report output was available."}, "event": "infrastructure_failure", "phase": "collection", "previous_event_sha256": "d8ff47fbec01fc4c0b98af4cfa26d36cbbb28c4bdeddd57d2aa2a919f69255cc", "run_id": "r033", "schema_version": 1, "sequence": 208, "time_utc": "2026-08-01T06:18:38.564336Z"}
+{"agent_id": "/root/report_r034", "attempt": 1, "details": {"disposition": "ORCHESTRATOR_TOOL_FAILURE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "bc48696f16da74a93467a620c563374cb144e2ce3a211a2df5c55702d7e98ffb", "run_id": "r034", "schema_version": 1, "sequence": 209, "sha256": "410c0e870c25e4b4e839a0c011417f6e73656ac2cb4175ecdd764f86e42d7116", "time_utc": "2026-08-01T06:18:41.714226Z"}
+{"agent_id": "/root/report_r034", "attempt": 1, "details": {"api_state": "INFRASTRUCTURE_FAILURE"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "5d8a7ee9262ad4fa788e7383061af87c80797efa03579ef9f85295d1fad20aab", "run_id": "r034", "schema_version": 1, "sequence": 210, "time_utc": "2026-08-01T06:18:41.912771Z"}
+{"agent_id": "/root/report_r034", "attempt": 1, "details": {"disposition": "ORCHESTRATOR_TOOL_FAILURE", "evidence": "Agent disappeared from collaboration state after user steering interrupted the orchestration wait; no completion callback or report output was available."}, "event": "infrastructure_failure", "phase": "collection", "previous_event_sha256": "66a4173ea71a9dbad7ce3b4f63fed3d9d073107a667493946eeb5c87e26f182c", "run_id": "r034", "schema_version": 1, "sequence": 211, "time_utc": "2026-08-01T06:18:41.914459Z"}
+{"agent_id": "/root/report_r035", "attempt": 1, "details": {"disposition": "ORCHESTRATOR_TOOL_FAILURE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "cbaf55a72ab9b59bbd9d03c09008e6732b1c5f8119afc425140bb03e68327934", "run_id": "r035", "schema_version": 1, "sequence": 212, "sha256": "53e65de33376013b7c01ea8f1bb426a9bf8f30341bd1a5f35662a66eea0a04e6", "time_utc": "2026-08-01T06:18:46.800983Z"}
+{"agent_id": "/root/report_r035", "attempt": 1, "details": {"api_state": "INFRASTRUCTURE_FAILURE"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "bcfaf2cc8380ea969c8ad4233936f1b1ac7cb3b9d043c3f1b94a11b727aee38f", "run_id": "r035", "schema_version": 1, "sequence": 213, "time_utc": "2026-08-01T06:18:47.366500Z"}
+{"agent_id": "/root/report_r035", "attempt": 1, "details": {"disposition": "ORCHESTRATOR_TOOL_FAILURE", "evidence": "Agent disappeared from collaboration state after user steering interrupted the orchestration wait; no completion callback or report output was available."}, "event": "infrastructure_failure", "phase": "collection", "previous_event_sha256": "e83747de493e177c6ed4cda5fa8fa52398788783397be36911ff184dfebd7270", "run_id": "r035", "schema_version": 1, "sequence": 214, "time_utc": "2026-08-01T06:18:47.368788Z"}
+{"agent_id": "/root/report_r033_a2", "attempt": 2, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "161503a0c64a754f3eeab2ac40f23bf478258ba600c86493aa401c15793b1a50", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "9463e00489a0f5a91dfdc127582c57a5389c3836ca1598184d3668a86c442e77", "run_id": "r033", "schema_version": 1, "sequence": 215, "time_utc": "2026-08-01T06:19:51.652955Z"}
+{"agent_id": "/root/report_r034_a2", "attempt": 2, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "253a3851bf6d014ab6d51e500e1ac6dbeeb3bf99c52e2a0967382c4e2148b84a", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "87728da354ef72a9ee6376e4b1c8612f3c36fdcc1d1685bb331e20cdcd7048df", "run_id": "r034", "schema_version": 1, "sequence": 216, "time_utc": "2026-08-01T06:20:25.547478Z"}
+{"agent_id": "/root/report_r035_a2", "attempt": 2, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "a5603287fa3e6506de63e13e234137a1f36a17ca74b2641d02b74d1aff534de1", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "e523a22d7a7929ab92325dbe22588d0814732580aedeef9da710ef2dc76da459", "run_id": "r035", "schema_version": 1, "sequence": 217, "time_utc": "2026-08-01T06:21:02.795694Z"}
+{"agent_id": "/root/report_r033_a2", "attempt": 2, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "c526da94543c3ca6b7226fd3fcc913b2d0d825ba1351655ad9bf79c0eaec09cb", "run_id": "r033", "schema_version": 1, "sequence": 218, "time_utc": "2026-08-01T06:24:33.926123Z"}
+{"agent_id": "/root/report_r034_a2", "attempt": 2, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b85d2970c03f9da68e6e548497a286a13f6d14c52dd4341f9d4348f37d30f4d6", "run_id": "r034", "schema_version": 1, "sequence": 219, "time_utc": "2026-08-01T06:24:47.576534Z"}
+{"agent_id": "/root/report_r035_a2", "attempt": 2, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "be784cd30474b7b904877e655ddb55b85afee5e977470fac1c0b0a9d1bbe3e94", "run_id": "r035", "schema_version": 1, "sequence": 220, "time_utc": "2026-08-01T06:25:03.971318Z"}
+{"agent_id": "/root/report_r035_a2", "attempt": 2, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "69781a34247c1315294afdd1cd218c902264112068411ffbe99a1adf42cb8963", "run_id": "r035", "schema_version": 1, "sequence": 221, "sha256": "6c63ca67f489e9783bf8f7c8e3289ba870e0c707f90319397ab6c78f77cba17c", "time_utc": "2026-08-01T06:28:25.711403Z"}
+{"agent_id": "/root/report_r035_a2", "attempt": 2, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "b4290429fa97cc35f4e13576f0ea24f8257918d3f9d8b37ecb9a0d7a7d245c7e", "run_id": "r035", "schema_version": 1, "sequence": 222, "time_utc": "2026-08-01T06:28:25.715310Z"}
+{"agent_id": "/root/report_r035_a2", "attempt": 2, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 917}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "0c00e443bd61a7024d6bdff8cb76855e3780de60c4fa0aa87f00bfc7802d0d49", "run_id": "r035", "schema_version": 1, "sequence": 223, "sha256": "d135ad89e2b402af49206d79186ad5f4454716f99c32debe93ff458ed07d086e", "time_utc": "2026-08-01T06:28:25.717043Z"}
+{"details": {"cell_id": "bebc72c4981368d1bffe7e85d5e68357"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "3c64a6f7593022144401b0470b7f499dd487ef728ae0961996efe6ef02f3441e", "run_id": "r036", "schema_version": 1, "sequence": 224, "sha256": "d7e5321fa87f6db479373dcb66c1d1082ff6d00dd3a1983a6ace1dd81e8d79ba", "time_utc": "2026-08-01T06:28:34.329856Z"}
+{"agent_id": "/root/report_r036", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "c73f0921c734430e89d60e7cb84e3f573c340be9ad923f03dc39da9e57b4ffed", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "7846bb882a7dbfe5d2ddb3139c17707f325131d60ab3d1b28c430516e1e5627d", "run_id": "r036", "schema_version": 1, "sequence": 225, "time_utc": "2026-08-01T06:29:03.059397Z"}
+{"agent_id": "/root/report_r034_a2", "attempt": 2, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "0f6d53bd7b49f9523c6c1e059f77d82e4d03b228233229c41e1391434b923b49", "run_id": "r034", "schema_version": 1, "sequence": 226, "sha256": "46e9b4b29cacdc324bdba799c15689cc010d485db6f6206dde399de9361f5ae4", "time_utc": "2026-08-01T06:29:12.064736Z"}
+{"agent_id": "/root/report_r034_a2", "attempt": 2, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "14ec4423a3bbbb37a9395567727330c955a9b73a74533a43023612295240ee74", "run_id": "r034", "schema_version": 1, "sequence": 227, "time_utc": "2026-08-01T06:29:12.066958Z"}
+{"agent_id": "/root/report_r034_a2", "attempt": 2, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1067}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "af3499a14eecfab95348fe5324e0244ed921b64fd0ddeb194c9ca925d65a0131", "run_id": "r034", "schema_version": 1, "sequence": 228, "sha256": "14845b9df93acc77be643ccf456e5dfa333a01fe70cb6ffa9f74a1c33b66f600", "time_utc": "2026-08-01T06:29:12.068792Z"}
+{"details": {"cell_id": "eef95e01264a728a7c6eabe725507b5a"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "61fdd0c71b9cdc06b59efc339652b087e7c5b5667762b6e1345efb2b99df72eb", "run_id": "r037", "schema_version": 1, "sequence": 229, "sha256": "1f042a5169640993c4b4d6fa99174a1deca21b1f5e7e2a9ea9f4ba378e88d4b3", "time_utc": "2026-08-01T06:29:21.821948Z"}
+{"agent_id": "/root/report_r037", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "2ea7af576b816ddbf09ea46901cbd09f606e057216eeae364edc68b7310a93a2", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "a0b0e55334b74b2531cb335de8f7e2d8b8dedde5ee87ff5aca554cf2bf03cedf", "run_id": "r037", "schema_version": 1, "sequence": 230, "time_utc": "2026-08-01T06:29:54.950838Z"}
+{"agent_id": "/root/report_r033_a2", "attempt": 2, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f4fc26d2bd1b517d11fc19d8131d0bb19d94d174ec3465ce0a16f6fea27ae9b8", "run_id": "r033", "schema_version": 1, "sequence": 231, "sha256": "bb23c23e508eab6302e1038b18d3be518329ddfc7815606aec05e6801d0d22a5", "time_utc": "2026-08-01T06:31:05.738655Z"}
+{"agent_id": "/root/report_r033_a2", "attempt": 2, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "402050447678f85df131b3699b4e17710cd65c3084023179d261705b640eb136", "run_id": "r033", "schema_version": 1, "sequence": 232, "time_utc": "2026-08-01T06:31:05.741227Z"}
+{"agent_id": "/root/report_r033_a2", "attempt": 2, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1160}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "599c529fce1fd31adcdc5f1487edfc4aa07faf5f7661a399a502367c4b925767", "run_id": "r033", "schema_version": 1, "sequence": 233, "sha256": "862e943f99c56fd423ac9003945cc8170717ced6c05c9d61ed681d513c1ebdf5", "time_utc": "2026-08-01T06:31:05.743311Z"}
+{"details": {"cell_id": "628efb38e96428481f2598bd5207472d"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "ee127114bf32f728d2d06d0cc9c080ff6e334c50d46f6d672485d357744f72e9", "run_id": "r038", "schema_version": 1, "sequence": 234, "sha256": "f046e4773c5ee4a0c029e40f9f2a7f0a57bf846d701a3455c3319bfa8bf6ff3a", "time_utc": "2026-08-01T06:31:14.947955Z"}
+{"agent_id": "/root/report_r038", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "eefa548944ef655a88ad74bc74cded61ee9ef56e9974ccb37ab653ca8d64da54", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "952793ef17f1aa35b0801101dc9aa47b74be91368a9a3976b968ca5a7653afa6", "run_id": "r038", "schema_version": 1, "sequence": 235, "time_utc": "2026-08-01T06:31:45.269425Z"}
+{"agent_id": "/root/report_r036", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "a68d9120bccbe7b7ab2dd21bece443b9af2403b31c40edd0fba0faf632c2de00", "run_id": "r036", "schema_version": 1, "sequence": 236, "time_utc": "2026-08-01T06:32:55.029917Z"}
+{"agent_id": "/root/report_r037", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "4a2dd710342493aa8b896bc11f03cc901522426f3601c0ccc97a78cbc76e5ee1", "run_id": "r037", "schema_version": 1, "sequence": 237, "time_utc": "2026-08-01T06:33:09.322678Z"}
+{"agent_id": "/root/report_r038", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "ce367201825ee01cc9e8cbc36c17ae5db0ee12f0fccd26b6bebd6a32b919ec2a", "run_id": "r038", "schema_version": 1, "sequence": 238, "time_utc": "2026-08-01T06:34:58.508873Z"}
+{"agent_id": "/root/report_r036", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "1348431034305b8219c849e9302947fdf97be103fc276f20e401e92f9894810a", "run_id": "r036", "schema_version": 1, "sequence": 239, "sha256": "57155dd83ef117539cd38e6afac76c2f89b97c2489d4fc9d5905835b7f8e27c9", "time_utc": "2026-08-01T06:37:04.963230Z"}
+{"agent_id": "/root/report_r036", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "83926a6863ed8f0885bf1bf5af6e8a1a9e25b99c9d6a38d64cb84d39ad30da46", "run_id": "r036", "schema_version": 1, "sequence": 240, "time_utc": "2026-08-01T06:37:04.965270Z"}
+{"agent_id": "/root/report_r036", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 895}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "f312f85e1d005cb3a6246433b76190a2b25e5dff5588d94524f4f37689b00564", "run_id": "r036", "schema_version": 1, "sequence": 241, "sha256": "f5b0a2be88ccf8436af7044f8a321be0582d57dacffa84012c994a705779dc77", "time_utc": "2026-08-01T06:37:04.966987Z"}
+{"details": {"cell_id": "ba7abe98e80c53f75aa8f8238c7ffe03"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "33affc0af36384f08ec3a28679b5c077d5a6f320412e2d5e08b7046dac1058f6", "run_id": "r039", "schema_version": 1, "sequence": 242, "sha256": "16180955a69d45786aa167b5c8369812d4935e1db64814f4ec04605f52e9c775", "time_utc": "2026-08-01T06:37:15.578434Z"}
+{"agent_id": "/root/report_r037", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "3a87e925fc2210b879546e6d7d4c57a2d24eb60dc20be48d3f20786b94f87e55", "run_id": "r037", "schema_version": 1, "sequence": 243, "sha256": "0f465412670a5a43d04dd2aff1fbf17ea1e780733b9cdc325829fe22d57d6151", "time_utc": "2026-08-01T06:37:38.386730Z"}
+{"agent_id": "/root/report_r037", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "efacf62fabae83f103dc500421ab9696f602f13ce7601a9511e1b2a2a161d8a1", "run_id": "r037", "schema_version": 1, "sequence": 244, "time_utc": "2026-08-01T06:37:38.751467Z"}
+{"agent_id": "/root/report_r037", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 892}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "1850c3e87ca7633b30e66a23e4d409672929d9bb1f436b36532f1f401a6216e4", "run_id": "r037", "schema_version": 1, "sequence": 245, "sha256": "b9cfc956cc8580d2722d554a8e40b81f781aab75650f69efd833756f9b67b355", "time_utc": "2026-08-01T06:37:38.753135Z"}
+{"agent_id": "/root/report_r039", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "cddc9ff91ab470a9f2903072e3a5c4df0a784718ca7cce96cec8943005114292", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "efa98cf28a7ff1b2550f38f6dccf559fcce1c8e47ef2ec52d2e2a98b9fafba4f", "run_id": "r039", "schema_version": 1, "sequence": 246, "time_utc": "2026-08-01T06:37:56.941432Z"}
+{"details": {"cell_id": "de3c340e44bf752186e73da5cdbc05bd"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "23ee8910993ea5852f076716241c962b356b9b4d4b2667a2ef3dd9fb0f5affca", "run_id": "r040", "schema_version": 1, "sequence": 247, "sha256": "435d997ca49218f558452958ee48e8be2ef7a66163cd7b45b07a6db2d49b3aae", "time_utc": "2026-08-01T06:38:08.084432Z"}
+{"agent_id": "/root/report_r040", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "eb3462ebddfda8f6e164b3aa6184176e13a58b8e5e49a305213ac11862c69e4c", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "79f16fdde4cb70d488fdb7089107654620f2ea4096ffa63e7508cd965a58c68c", "run_id": "r040", "schema_version": 1, "sequence": 248, "time_utc": "2026-08-01T06:38:44.608933Z"}
+{"agent_id": "/root/report_r038", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "6b3016fdd126263a6bc4c3f06df6fecaf8962493c736bf26890f20c9ec441352", "run_id": "r038", "schema_version": 1, "sequence": 249, "sha256": "053657ff9cb382dc4b7b87b6ec23d6923839a60008a7b2c8b44b239a66fd9492", "time_utc": "2026-08-01T06:38:57.537921Z"}
+{"agent_id": "/root/report_r038", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "ec9a2d6efa1df6a6ec3cf393931fb347d9b8a77ff6fabc4846cd92bac0d0ba43", "run_id": "r038", "schema_version": 1, "sequence": 250, "time_utc": "2026-08-01T06:38:57.539971Z"}
+{"agent_id": "/root/report_r038", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 942}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "c2b75115a81771d97eba8692f842a57a75e0a69d6655e9eeac0cf635af63fac0", "run_id": "r038", "schema_version": 1, "sequence": 251, "sha256": "33f7ad5b9d6de92126d674c4b964e5d7ce46a3752b8883e324ce257ea928854f", "time_utc": "2026-08-01T06:38:57.541718Z"}
+{"details": {"cell_id": "1ec17f7769c0078f9fcbed12eb0be0f7"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "8cbacf520bd5411b4602151d6098ebc967c57b13781789afaf3182f4e5c99a9f", "run_id": "r041", "schema_version": 1, "sequence": 252, "sha256": "94b506ab6c5d44a0194752501205016352203e5640274b36a6a7ab64669542b2", "time_utc": "2026-08-01T06:39:07.703814Z"}
+{"agent_id": "/root/report_r041", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "fa48d06b1eab27b6e1a3a3915ff8beea3b78692090bc3da08a1226236540d341", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "26f2df0df874dcc880a8ba232e1ccab995030ad8926521bdf22be2795dd9f295", "run_id": "r041", "schema_version": 1, "sequence": 253, "time_utc": "2026-08-01T06:39:43.511977Z"}
+{"agent_id": "/root/report_r039", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b0681d7b81565309a7b058707a43ea5dd6ee695a3d7c005ff762aea9c6e695c8", "run_id": "r039", "schema_version": 1, "sequence": 254, "time_utc": "2026-08-01T06:42:24.762238Z"}
+{"agent_id": "/root/report_r040", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "512e1fd2c2384fac43cff7fd3f03c20b25a1227ad8206257a53d26404de928d7", "run_id": "r040", "schema_version": 1, "sequence": 255, "time_utc": "2026-08-01T06:42:35.953703Z"}
+{"agent_id": "/root/report_r041", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b87fe8197ee5d0482ee0c54cfe531072a70c184a6b546a21efcfbe6c32fb6799", "run_id": "r041", "schema_version": 1, "sequence": 256, "time_utc": "2026-08-01T06:42:49.290626Z"}
+{"agent_id": "/root/report_r039", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "9a9b7d9d01955b9b2a076c48f2523484e44c3699a8857b8b60dbd0d7646d1acb", "run_id": "r039", "schema_version": 1, "sequence": 257, "sha256": "c17c40db2947c6e25c8e8c25aceae18d4427801b68724c7caf7c68b295ae8257", "time_utc": "2026-08-01T06:46:34.607790Z"}
+{"agent_id": "/root/report_r039", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "9d6e24a83cf2753c23ebf7e850af9db5119847134d682bd711754196ee5647cd", "run_id": "r039", "schema_version": 1, "sequence": 258, "time_utc": "2026-08-01T06:46:34.609825Z"}
+{"agent_id": "/root/report_r039", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1246}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "c61fc8e769ca969d55d658a05bd385685720752589d9435b653392cc36a0bba1", "run_id": "r039", "schema_version": 1, "sequence": 259, "sha256": "c250345e3ded76516cb26af1a80874ba305fb015d70c75b3a82ad5eb7c3821b9", "time_utc": "2026-08-01T06:46:34.611627Z"}
+{"details": {"cell_id": "5edc22ffe7b0779af2a68e40283db476"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "a2a011e21d1e1d687ec7d661680fdc1de988813fdd6092a957352ab327d7b641", "run_id": "r042", "schema_version": 1, "sequence": 260, "sha256": "e2cf3991cfe4da5cc40c42b4b5ae29feeae633fd5180d77fd2765ab58a32dc75", "time_utc": "2026-08-01T06:46:42.714960Z"}
+{"agent_id": "/root/report_r041", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f7e3120d2714d802c3f19a3fca0782859a7a882b5cb65830ea899eb0e995aca1", "run_id": "r041", "schema_version": 1, "sequence": 261, "sha256": "6e09ce3e6582d803a1927ffc87c87527cfd7d7af4a68a8f45135f44b69c36849", "time_utc": "2026-08-01T06:46:55.263796Z"}
+{"agent_id": "/root/report_r041", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "cf3a8fd34e1341971fca092837751524a5f768eccedebd40fd31ed534a06fec5", "run_id": "r041", "schema_version": 1, "sequence": 262, "time_utc": "2026-08-01T06:46:55.266123Z"}
+{"agent_id": "/root/report_r041", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 849}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "fc7aa99063654431cf5d4a705a4333852a4c67af86a9056f124b85f636e37157", "run_id": "r041", "schema_version": 1, "sequence": 263, "sha256": "d6e6359967799119d7119d804bbeb26db216412f3baab76d2392102683dc4fe2", "time_utc": "2026-08-01T06:46:55.268131Z"}
+{"agent_id": "/root/report_r042", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "4b56de572bddb373d9e64cf705d0171393f4601e144bc635171e06f90ce6ac65", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "81eca60a5080c130daa24e83dc1b030e2464a1d36a66c250e8baa218eb5046d6", "run_id": "r042", "schema_version": 1, "sequence": 264, "time_utc": "2026-08-01T06:47:23.389277Z"}
+{"details": {"cell_id": "9fed5500b2156c7c3cb16aff89a5a89f"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "00ade01eba5d68fd51c2c6b9fadf9ea85ea30b18ce5113653495da3fbbc5b430", "run_id": "r043", "schema_version": 1, "sequence": 265, "sha256": "ebab47b232a947c9a9b10a205d5ec82e25ab0e119eb462b37d3a186634be2778", "time_utc": "2026-08-01T06:47:32.913120Z"}
+{"agent_id": "/root/report_r043", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "2eec26adb323a4adbd951b78308cdda657f164f11c9b8383aa7d966540195d80", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "b935a53576258fdc5d73976b3f37dca5030c2114f87f8745afc351faa3884ea2", "run_id": "r043", "schema_version": 1, "sequence": 266, "time_utc": "2026-08-01T06:48:05.996460Z"}
+{"agent_id": "/root/report_r040", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "e13d729db5d25d9783ed7ccc40cba815162a98c42ad96b3d8558e5c75086c810", "run_id": "r040", "schema_version": 1, "sequence": 267, "sha256": "09cf4586becb52f4b33e346ebad2550ddb591d0ca65e3a47da6ff5443440aaa9", "time_utc": "2026-08-01T06:48:48.234140Z"}
+{"agent_id": "/root/report_r040", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "f670e4d2df0278b6f9d25474e03a04ab5cadba0362562f4d85c67fab8bcf07c4", "run_id": "r040", "schema_version": 1, "sequence": 268, "time_utc": "2026-08-01T06:48:48.235983Z"}
+{"agent_id": "/root/report_r040", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1067}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "4dc6bfbac7a85f8ba0c5eea5cae18fd01653630f990c2ff02398b5bb8566cc5c", "run_id": "r040", "schema_version": 1, "sequence": 269, "sha256": "034a581627624218f85a2e12af3590c9346c1227c7846bf28e3bacf75c8c7a5f", "time_utc": "2026-08-01T06:48:48.237662Z"}
+{"details": {"cell_id": "32e9f759f85e81477aeb318b0e0497c2"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "41226e62811709c4f95a4528168f44eb658cd13f731e0b04d4d19f05b4862c79", "run_id": "r044", "schema_version": 1, "sequence": 270, "sha256": "7ad172a7618e39f1dda2efe3f7b858dce1c58286f8870824c74373d6ece62330", "time_utc": "2026-08-01T06:48:57.668855Z"}
+{"agent_id": "/root/report_r044", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "1fbb8abb0f4e3e43671e21ceb6f7a5e412a06e6983794e0bf44d2c91b3a988cc", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "1ae3532186520859c86accda1fb803cdf5776fba3e5c24165a4fd6b99718aa61", "run_id": "r044", "schema_version": 1, "sequence": 271, "time_utc": "2026-08-01T06:49:29.765079Z"}
+{"agent_id": "/root/report_r042", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "2caf32107fc257e4fe70d729f4a87909d28056b97a0a0d512f3139613f5fb31d", "run_id": "r042", "schema_version": 1, "sequence": 272, "time_utc": "2026-08-01T06:51:30.353456Z"}
+{"agent_id": "/root/report_r043", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "0c3237ba0c9d4f391f4d7c7addba16d349258dcced3fe9ea220a195a48a86799", "run_id": "r043", "schema_version": 1, "sequence": 273, "time_utc": "2026-08-01T06:51:45.470050Z"}
+{"agent_id": "/root/report_r044", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "3c92088e47aee6927dfd8e9676c1b69ef7b949d96e8f6b21262722d1922818af", "run_id": "r044", "schema_version": 1, "sequence": 274, "time_utc": "2026-08-01T06:52:36.312401Z"}
+{"agent_id": "/root/report_r042", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "32a226ac2e96255e990ee6210b69f4bbc6e83144cb85705c154ea4e44efd3ae6", "run_id": "r042", "schema_version": 1, "sequence": 275, "sha256": "aa4cb34c2e4ac4b47e2979e2c7f64a99e4435bc8ef496071a9e6124de526c209", "time_utc": "2026-08-01T06:56:09.293414Z"}
+{"agent_id": "/root/report_r042", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "9b9c8eb5645aed7b9974842d3f5611b47a1596f5575f24a3682a4ada16662d24", "run_id": "r042", "schema_version": 1, "sequence": 276, "time_utc": "2026-08-01T06:56:09.295423Z"}
+{"agent_id": "/root/report_r042", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1203}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "b536b8dae9be8c3b96af16ee71ff04f32c1631412b8a2f9c84b2782412387294", "run_id": "r042", "schema_version": 1, "sequence": 277, "sha256": "9452fc8cae9f25d64b09d17822a59fceb98e19a1a754e327d799e9a462c09d69", "time_utc": "2026-08-01T06:56:09.297097Z"}
+{"details": {"cell_id": "434b916b4f0630b6e6aa447c4048f8d6"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "1574b5ad3b9f2d0e9d3690579c92ad759e57e0e184d0d45e548039142d9618ff", "run_id": "r045", "schema_version": 1, "sequence": 278, "sha256": "73453944bf20a505fcd5a3f17330455db8794a0c98cac2832d0dc458979954b9", "time_utc": "2026-08-01T06:56:21.486835Z"}
+{"agent_id": "/root/report_r045", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "37ac402ec37128bb995e3876e68f5cdce4eadcfdd43ed50874fd1ab7e295a4c0", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "1df7a4cfb9075d79039f467ccd3e7bce76499518bf0aa3066b2df65d387dafc8", "run_id": "r045", "schema_version": 1, "sequence": 279, "time_utc": "2026-08-01T06:57:06.481146Z"}
+{"agent_id": "/root/report_r043", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "ce9e1378027bb84a0e036af95cae764a311fa5f18be90f1f7b67d69cc1d1468a", "run_id": "r043", "schema_version": 1, "sequence": 280, "sha256": "91a6a4658a0ef0c0eb1c84c64b53bde626ac41e457e2efe0d3f02989df56b5ad", "time_utc": "2026-08-01T06:57:20.555214Z"}
+{"agent_id": "/root/report_r043", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "c129db0515a0928ce56d81f1f85103c5dcd78a1c48da46a182b2b10b3c8b009f", "run_id": "r043", "schema_version": 1, "sequence": 281, "time_utc": "2026-08-01T06:57:21.351494Z"}
+{"agent_id": "/root/report_r043", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 973}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "15f7534122a2e3eebd54b28565f50604ed7ff9a989dde1cdbb2c57cabac35ec7", "run_id": "r043", "schema_version": 1, "sequence": 282, "sha256": "6d839af7da1f3cf8f5de096c33c36a103337baf53057022f7adf806aec6f1594", "time_utc": "2026-08-01T06:57:21.747360Z"}
+{"agent_id": "/root/report_r044", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "adec5d4da330a6abda9f17f9ed3662ccc264970bcbe639f2dc91e27443f00bf8", "run_id": "r044", "schema_version": 1, "sequence": 283, "sha256": "d8b00714273453c81f70c6d96420a168cacc8777cc536654db8564d7654066f8", "time_utc": "2026-08-01T06:57:26.523623Z"}
+{"agent_id": "/root/report_r044", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "dde1fcfc7d6a15834327f5889a0fe08ed350f8c172fc95fffd33566f242f95b2", "run_id": "r044", "schema_version": 1, "sequence": 284, "time_utc": "2026-08-01T06:57:26.525351Z"}
+{"agent_id": "/root/report_r044", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 981}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "62395547a6882d16763b39df4d16fe82d5092a13884aec59e0492f23ffeb45a3", "run_id": "r044", "schema_version": 1, "sequence": 285, "sha256": "a7f109ef70b6a8ac7b471cc4a3122f4b8e2f92b45305f0f419ead77cf670528e", "time_utc": "2026-08-01T06:57:26.526797Z"}
+{"details": {"cell_id": "8a37e9f35d221302948bb0526f432b98"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "0f90e4654626f8c7d5631bdb1eca348c4a886f6173d5886f3b54931c953ef2cd", "run_id": "r046", "schema_version": 1, "sequence": 286, "sha256": "f11aa809f5b52eab052e09c4f421ef57a8188c557a3e5c0c03092842070645fb", "time_utc": "2026-08-01T06:57:42.896326Z"}
+{"agent_id": "/root/report_r046", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "82acc9e1478b78b48ef666a0171a44116279895c8e85717daf772a84f7903e9a", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "637a8f5ab1c99604d980de7ca8c83fd351e043d6086251c3770bd20053317d16", "run_id": "r046", "schema_version": 1, "sequence": 287, "time_utc": "2026-08-01T06:58:15.546401Z"}
+{"details": {"cell_id": "86e15f99caa5c1efc10a11768832390e"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "f13f46492aaaee9aea9a1874c52515af28aec3b6d3e182501fd4a420834cddb0", "run_id": "r047", "schema_version": 1, "sequence": 288, "sha256": "184ad7f54189f6f3d9b8d1c1d36ce3da0f22d237eafd95b3716d4c2e94ac84f8", "time_utc": "2026-08-01T06:58:27.945300Z"}
+{"agent_id": "/root/report_r047", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "ed4026ee40d2dec0cca8deba56abc03cc5dc75d4b7bbfbc126fbcf21b2ad3b7a", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "350cc0a6179989794fa0935c99361e8c7eebbb9550ab9d21a4ed688869fe13f0", "run_id": "r047", "schema_version": 1, "sequence": 289, "time_utc": "2026-08-01T06:58:59.335304Z"}
+{"agent_id": "/root/report_r045", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "6be0c21f196ca2b6b19fc4dfc44e3d90a6ddf421ed166955632af152b0aa12d9", "run_id": "r045", "schema_version": 1, "sequence": 290, "time_utc": "2026-08-01T07:01:54.241362Z"}
+{"agent_id": "/root/report_r046", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "168941781269c97c46606c66e68fba554d0c1e32a2bb555d3f239d09f73b9e02", "run_id": "r046", "schema_version": 1, "sequence": 291, "time_utc": "2026-08-01T07:02:11.902534Z"}
+{"agent_id": "/root/report_r047", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b91394554889f6d7e9ce3e9e58c954cf68fe538bdc17bd7fe03307b396618432", "run_id": "r047", "schema_version": 1, "sequence": 292, "time_utc": "2026-08-01T07:02:25.871079Z"}
+{"agent_id": "/root/report_r045", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "c836552d8e0941b05676be776ad0fd129854fa294e946f2db32cc8218e1a1963", "run_id": "r045", "schema_version": 1, "sequence": 293, "sha256": "46628a7249b34dd466628c8f6af08cb72ee7b00a507727b0b29f1c7feda2f3d8", "time_utc": "2026-08-01T07:05:56.623995Z"}
+{"agent_id": "/root/report_r045", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "dd56e2f11eb3aaff5435489dc75dccac164767274bf71de690bd10c2267a6e46", "run_id": "r045", "schema_version": 1, "sequence": 294, "time_utc": "2026-08-01T07:05:57.030418Z"}
+{"agent_id": "/root/report_r045", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 822}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "a39b08fee40743421235f5a01e921e300f25921b46b11d0b567d0717417e2298", "run_id": "r045", "schema_version": 1, "sequence": 295, "sha256": "759b413defb47d8ad4c15c08233757841f374762b686d51515a8eddcd5ac1989", "time_utc": "2026-08-01T07:05:57.849717Z"}
+{"details": {"cell_id": "aeea1b0c5420db0d4c06d58b2708366e"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "6ed96da43055ab8a1e288233c3b9d68cfad3febb55b70ad9ec47a20b35574b4c", "run_id": "r048", "schema_version": 1, "sequence": 296, "sha256": "c367be340cd1573aa01bde7b4393819bf023e1b3373bebb5f27d0b525de0c18c", "time_utc": "2026-08-01T07:06:07.364632Z"}
+{"agent_id": "/root/report_r048", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "91863398d85f910626ffed60ba5d314bd2869293dc804139f1b8462ee6a0d3c4", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "0346c06a556740bd8dbff62855aff59d53a82537e56eb60dafb1b8edb2a092e6", "run_id": "r048", "schema_version": 1, "sequence": 297, "time_utc": "2026-08-01T07:06:42.269544Z"}
+{"agent_id": "/root/report_r046", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "9395d7fb959b09eab2935c36089b3e88733e2119aa1c02889b8e45d6320a7aa3", "run_id": "r046", "schema_version": 1, "sequence": 298, "sha256": "7b320efac10a81a0c0b5613597a65d822e20515ecc3f0882d95984d2f0868cea", "time_utc": "2026-08-01T07:07:24.912844Z"}
+{"agent_id": "/root/report_r046", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "44d7b5241a3667112c4af36ccd9f186af607cf8ac189cf6821856f1e0e8e8dc4", "run_id": "r046", "schema_version": 1, "sequence": 299, "time_utc": "2026-08-01T07:07:24.914611Z"}
+{"agent_id": "/root/report_r046", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 930}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "e3f06f64880e07fe4e4df27e1719d7040ce2b557dc3125090b17693960b0be47", "run_id": "r046", "schema_version": 1, "sequence": 300, "sha256": "1409aa1649cd9e0950368deb23ade05351c03b9ab89a32e637514b9d43293e22", "time_utc": "2026-08-01T07:07:24.916254Z"}
+{"agent_id": "/root/report_r047", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "55f9fd8c4f47cfea1778055fc6219272dce6147c598dad0e871181a2634369ee", "run_id": "r047", "schema_version": 1, "sequence": 301, "sha256": "6983458cd2682e0d2faa642200cf3b25764dbad56f8f75eb30119c2258e2c389", "time_utc": "2026-08-01T07:07:29.856392Z"}
+{"agent_id": "/root/report_r047", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "a638a4d2b36d2e4d5da934189b67260d05be51449fe8d52ea55cfa2756eef6cc", "run_id": "r047", "schema_version": 1, "sequence": 302, "time_utc": "2026-08-01T07:07:29.858372Z"}
+{"agent_id": "/root/report_r047", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1000}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "7c5bf871a7099ff13ef7474ceaba33f2ba92e76979978ba475aff69623697814", "run_id": "r047", "schema_version": 1, "sequence": 303, "sha256": "6a4721ff173210588f9720b233d83c613ca6e460b15e46c52b311793b090f9d2", "time_utc": "2026-08-01T07:07:29.860098Z"}
+{"agent_id": "/root/report_r048", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b49e5b64e6dec9826077ca87e5ca85cc7d4836f627e30f2f9230996d4c0324ee", "run_id": "r048", "schema_version": 1, "sequence": 304, "time_utc": "2026-08-01T07:10:45.289788Z"}
+{"agent_id": "/root/report_r048", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "ba2fe3132e53739b7447e905f6f7de11640dd1b499739c6b21ab15d0642d412f", "run_id": "r048", "schema_version": 1, "sequence": 305, "sha256": "669757a3a809e71bc6cc193c16d4fc89e01c7cff3ec8b516c415734b9be5a67c", "time_utc": "2026-08-01T07:15:39.135000Z"}
+{"agent_id": "/root/report_r048", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "3698931b4c1009c14d186266471486904983f9acac0941889aaf00499e76a687", "run_id": "r048", "schema_version": 1, "sequence": 306, "time_utc": "2026-08-01T07:15:39.136748Z"}
+{"agent_id": "/root/report_r048", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 910}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "97150d99f80d336ed2d2539e391858ae597090fc92c8bbb2efb34b3158a24a43", "run_id": "r048", "schema_version": 1, "sequence": 307, "sha256": "36c357bebb8df0544f587b00a99169a56e62e1d1386c18984697ae62001ef573", "time_utc": "2026-08-01T07:15:39.138331Z"}
+{"details": {"entries": 76, "wave": 4}, "event": "authority_verified", "phase": "collection", "previous_event_sha256": "d749ace32ff988fd6c47bc7273bbf79c2a02b56de3b3a1cc1a6935ce721af592", "schema_version": 1, "sequence": 308, "sha256": "329634ba9421a9a65b2802b4ba5b07667fae194411904cbbfc7f002da84c0f97", "time_utc": "2026-08-01T07:15:55.750290Z"}
+{"details": {"cell_id": "16cb821ea568942a5847dc01ce421b41"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "bdaece119290c0d5c94daeabcb6e6263fd7e59029c9734ce97d2a787e2fcd286", "run_id": "r049", "schema_version": 1, "sequence": 309, "sha256": "6bd274a834e1aa1e1bc5c1bf943ad927831ef1db259b1325c7f3270a74027214", "time_utc": "2026-08-01T07:16:09.919792Z"}
+{"agent_id": "/root/report_r049", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "4c7f8fac08de6f6f69f5af697f81d925a1b231c456922e52daf30bf42ffe29cd", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "75061d680ed3684e27e318b34062fbfa5f451dec6b993532c6ac0cfe3d767628", "run_id": "r049", "schema_version": 1, "sequence": 310, "time_utc": "2026-08-01T07:16:30.953078Z"}
+{"details": {"cell_id": "ada6c44a0f72bc924d6b9f094cad0ff0"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "575dacbd6a2bf8856021cf6896c51e5651d737e0be9d3a12c1061e2a49a1a993", "run_id": "r050", "schema_version": 1, "sequence": 311, "sha256": "94fe6ed80f23d6324e030c61eb35034e2a41c97a69692fb4933334c4c85c5238", "time_utc": "2026-08-01T07:16:35.566687Z"}
+{"agent_id": "/root/report_r050", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "450faf801a18bccd7a9d8e16605f7f67b6b1568ab1843f93e5ab2d1fee11cd77", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "40f47ef5e16de874aec2592ed35b25c68d19b4cca14f44d69966014bb3d65b4d", "run_id": "r050", "schema_version": 1, "sequence": 312, "time_utc": "2026-08-01T07:16:59.182334Z"}
+{"details": {"cell_id": "d1bfa4935ce8286684864898b004f962"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "e12921cba603ddd386d2414e667e81dd7068c6cfe77a49a85dcfa330d666635e", "run_id": "r051", "schema_version": 1, "sequence": 313, "sha256": "0040ad9b268534f44993e5a817975e5d2035b60149ecc04c75cc64108b94e789", "time_utc": "2026-08-01T07:17:04.473461Z"}
+{"agent_id": "/root/report_r051", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "197d2f6797f137ef341d6ca363138ea6b73b9f71af690fe6a360c4bb98df5212", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "506ce08a9c4dc2c6605636a806ff1e727c0e5b11623e2defa39b8e60364511b2", "run_id": "r051", "schema_version": 1, "sequence": 314, "time_utc": "2026-08-01T07:17:25.884006Z"}
+{"agent_id": "/root/report_r049", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "5644596dfde1fc665b7f2ad5baea920810bea0cc54f52f5db357bc93c6fccb99", "run_id": "r049", "schema_version": 1, "sequence": 315, "time_utc": "2026-08-01T07:20:52.082480Z"}
+{"agent_id": "/root/report_r050", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "e3d96f21ab427bd8322e31dd2de45381bafda0747516fa4982b0c56b4382a7df", "run_id": "r050", "schema_version": 1, "sequence": 316, "time_utc": "2026-08-01T07:21:01.349619Z"}
+{"agent_id": "/root/report_r051", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "770ce2bc71d786f5a6a3cab2364614b3e26fdf2b825d1145a5bacc19433f0d73", "run_id": "r051", "schema_version": 1, "sequence": 317, "time_utc": "2026-08-01T07:21:10.121277Z"}
+{"agent_id": "/root/report_r050", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "ce905e9f334a0bf750addf5c68a8459e7b1a90f22eee57a0ce6a93e9ddb61c79", "run_id": "r050", "schema_version": 1, "sequence": 318, "sha256": "e2bbd6ae6053fb689b74db2c1c213c6d0447925df23380af9db9fdcc6e17825f", "time_utc": "2026-08-01T07:23:28.269325Z"}
+{"agent_id": "/root/report_r050", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "114be42ee4e4322ae575cfb6b9421d06bcc212ec8e8f14a003c5a7d1aedc94bd", "run_id": "r050", "schema_version": 1, "sequence": 319, "time_utc": "2026-08-01T07:23:28.274141Z"}
+{"agent_id": "/root/report_r050", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 898}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "2b2a9277aac648384ba3fff9054e6b63e36d1921f5bfa2f4d011cd41d1eb3654", "run_id": "r050", "schema_version": 1, "sequence": 320, "sha256": "77862cfc78b4998dd4c0f05da7a160bf578f1f069da9ef7ca577bfaf19836aa6", "time_utc": "2026-08-01T07:23:28.275981Z"}
+{"details": {"cell_id": "f0309a354f74b08a1a0972b62fac6ccd"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "ffc4f07097051eb4864cdf7e428d602a096ba5b1e5cda576cf70f7619a55eb5a", "run_id": "r052", "schema_version": 1, "sequence": 321, "sha256": "8ef3d9f84bf12acdf4002402b459d456d33c5e06cc81ed3d78f7bb0e337f3213", "time_utc": "2026-08-01T07:23:33.381226Z"}
+{"agent_id": "/root/report_r052", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "4a4e57e0eea04d864bb81ba81ba1617d94e76841318f2b616671a6ef91978308", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "400dacd28f1a06a9c4032eab4958ce81c70f1b712b81cac1c8c7f2fa14f18b1a", "run_id": "r052", "schema_version": 1, "sequence": 322, "time_utc": "2026-08-01T07:23:56.958674Z"}
+{"agent_id": "/root/report_r049", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "4d68ce9b69107d3cc58a61271779ce5837c64fc0d38b02a9be47bf21302ad08b", "run_id": "r049", "schema_version": 1, "sequence": 323, "sha256": "ec7edf43608e4a43b3409150a1967b2ba716dbac963fbd0848625f19c58330ba", "time_utc": "2026-08-01T07:24:23.002296Z"}
+{"agent_id": "/root/report_r049", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "45e1bf1900ae43b74d8002de352bac6d0ac7bc6c731d6b42da6e5d164ec82f8c", "run_id": "r049", "schema_version": 1, "sequence": 324, "time_utc": "2026-08-01T07:24:23.004985Z"}
+{"agent_id": "/root/report_r049", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1097}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "c609f589ae9fa2e8139647c81e0b154648260bbe0fe74ce910bf08358ad0fdc0", "run_id": "r049", "schema_version": 1, "sequence": 325, "sha256": "c9ca30c994fb58edbe9566764dbe3b28fac599dbda40a1d6603a7862e4a5620e", "time_utc": "2026-08-01T07:24:23.006985Z"}
+{"details": {"cell_id": "296be450c238efd67a62d38623894010"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "25a51f2726b9f77d90a941600349fdf5ccac2d11b1e71d090cd7a0ac83eee64e", "run_id": "r053", "schema_version": 1, "sequence": 326, "sha256": "a51d33401b90aa3d018517a4f5e9d1a0a801d809015dcfe3b8047e17e9e1461d", "time_utc": "2026-08-01T07:24:31.332031Z"}
+{"agent_id": "/root/report_r053", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "c59046812480177fbda0aa4ebebcc8d6716cf3f102342124a08d0bd34f044f0d", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "4673acecd48fbd114d0efd618f14f5124764e75af0d545efd13613632223bab1", "run_id": "r053", "schema_version": 1, "sequence": 327, "time_utc": "2026-08-01T07:24:51.780896Z"}
+{"agent_id": "/root/report_r051", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "81b0051cb98bdd0b9672f62a725a4a94be43ccf715f093ddb90b20fc3176b55c", "run_id": "r051", "schema_version": 1, "sequence": 328, "sha256": "705d5a357dee21294771b63aa1d823592a15e9b850a94a775d3092b81358bdfd", "time_utc": "2026-08-01T07:25:26.237451Z"}
+{"agent_id": "/root/report_r051", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "af74bbdfaf39fceba03938694477e79f8f275347a4ddb731902c546a43eaa531", "run_id": "r051", "schema_version": 1, "sequence": 329, "time_utc": "2026-08-01T07:25:26.239319Z"}
+{"agent_id": "/root/report_r051", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 918}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "42b5ed54d176ef805fcdbb3e7f9458bc25fa2e98f8c1d8a6defbb86543e184af", "run_id": "r051", "schema_version": 1, "sequence": 330, "sha256": "2eacff962730a259104f7a8cddafad623a47a519182a5e9e441f49e77fd0bdef", "time_utc": "2026-08-01T07:25:26.241351Z"}
+{"details": {"cell_id": "7da22994e57951eb951e0e387d852650"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "3eb1e2f8c877a09ee009d49bc1318ef0f27c6b0d3f27a8fcfdbab998e6815601", "run_id": "r054", "schema_version": 1, "sequence": 331, "sha256": "e528df40f77dc615ba6974fa57c243fd85af4e238753f4a5926005b6d0d5621f", "time_utc": "2026-08-01T07:25:32.985350Z"}
+{"agent_id": "/root/report_r054", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "44e92e32f4263ab2cf77f4e93a26325cf4fbf0d8c6da6e68d308b36059c91b7f", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "b6e6de3e035c2a2aa31d77fc7e22504899e5fd3607772b0c9f210ace142c6138", "run_id": "r054", "schema_version": 1, "sequence": 332, "time_utc": "2026-08-01T07:26:03.317617Z"}
+{"agent_id": "/root/report_r052", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "271087d9f4ba805d4aab1cd49c1c83315cd83450cd744794631154aa74ee7613", "run_id": "r052", "schema_version": 1, "sequence": 333, "time_utc": "2026-08-01T07:28:53.275427Z"}
+{"agent_id": "/root/report_r053", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "1941b27f4bf87d4953a19645d0176e9202039f6ff71be47539a55d763d99555c", "run_id": "r053", "schema_version": 1, "sequence": 334, "time_utc": "2026-08-01T07:29:01.076481Z"}
+{"agent_id": "/root/report_r054", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "d070128efc7d307704126a1cda0da275874c56f56d6f9288ce4c3167149dfe74", "run_id": "r054", "schema_version": 1, "sequence": 335, "time_utc": "2026-08-01T07:29:14.702961Z"}
+{"agent_id": "/root/report_r052", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f6efe032faa4194d78f21c48373c9366746b96cc58ee0c6717d9a44fcfa98d32", "run_id": "r052", "schema_version": 1, "sequence": 336, "sha256": "3519f8baf5f5a1477e4cfaf26bb1e2126907c2c304bd0dd950ab775d7af5c3cc", "time_utc": "2026-08-01T07:31:31.704079Z"}
+{"agent_id": "/root/report_r052", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "ac2173c0b588eedef9fb30b9b1086d364624fd3bb7273136a82320de3c8c7248", "run_id": "r052", "schema_version": 1, "sequence": 337, "time_utc": "2026-08-01T07:31:31.705969Z"}
+{"agent_id": "/root/report_r052", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1117}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "f347db8cbcbf0aefe275cf1bfdcb0027693dd8916e978a636f892c4c09e105ad", "run_id": "r052", "schema_version": 1, "sequence": 338, "sha256": "8a4870792d2b539f3f1adb115796eea44f36fc3c49d9c36d39996133f51502ad", "time_utc": "2026-08-01T07:31:31.707678Z"}
+{"details": {"cell_id": "4612a4154bf19ccc48a84d507fe9b05b"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "0b4a0c4f6f845d2f372481a91ae7752e39fdeef9b283be2a4693e805d6476694", "run_id": "r055", "schema_version": 1, "sequence": 339, "sha256": "6021789568c6bad432a977323b0996c888f5269c60b875731ea9583032ca818f", "time_utc": "2026-08-01T07:31:41.257279Z"}
+{"agent_id": "/root/report_r055", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "7b72026efc5a2f0bf76d9b67ec1c61031d31a5b09107b0c4fd86d564cee1d853", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "ae5a4419ac6e77a931ca0ab83be61f4a6483676a077338069654f0d10b7a6334", "run_id": "r055", "schema_version": 1, "sequence": 340, "time_utc": "2026-08-01T07:32:02.610879Z"}
+{"agent_id": "/root/report_r054", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f34ff361afada3a273cb6b985bed5e40b272f56ba4e1814f6938e8170a1fef84", "run_id": "r054", "schema_version": 1, "sequence": 341, "sha256": "67d745893669f9259ca557925a06581d832a1736b1460f95598a3d8cb08f7e12", "time_utc": "2026-08-01T07:32:42.637929Z"}
+{"agent_id": "/root/report_r054", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "f9e75b8587e508928e293f7f8b2ce10ce5f8cbc673296112b47c815b5717a347", "run_id": "r054", "schema_version": 1, "sequence": 342, "time_utc": "2026-08-01T07:32:42.639798Z"}
+{"agent_id": "/root/report_r054", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 898}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "d6bd7a14dd64ba5f2570f530480dd7057a3cef601f053f6aa0a61ab007589cd1", "run_id": "r054", "schema_version": 1, "sequence": 343, "sha256": "aaf0fe262d82d837f4f011b5707956852b8db0df9830d91ec927d0ce16fcbd8a", "time_utc": "2026-08-01T07:32:42.641476Z"}
+{"details": {"cell_id": "e6632dafee22c0cfb734d7911d78769f"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "f7df575d2570c89dc069951ae10b668bc2b2ab1d89ec505550679c6f05c7905a", "run_id": "r056", "schema_version": 1, "sequence": 344, "sha256": "b943b330ec16b105dedc769cc3a0da78ad97c0b11e1f5ccf8cbb49ec85f3e999", "time_utc": "2026-08-01T07:32:50.720368Z"}
+{"agent_id": "/root/report_r056", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "396110b615430cc22e0326f9264da26f866ec96421686348b57bc9a891268912", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "f141afc8979a20755152de24a17f4828ea78b298dbf9870629ebfe87e94fe399", "run_id": "r056", "schema_version": 1, "sequence": 345, "time_utc": "2026-08-01T07:33:15.148889Z"}
+{"agent_id": "/root/report_r053", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "cb5a2a1df95739772ef038cf3e9f5cfede24c2a075e7e092bee00ed2f32956a7", "run_id": "r053", "schema_version": 1, "sequence": 346, "sha256": "10fb97bfe630322ee6551a293be3f9ecefaabfc16979693f7c13a657a8645a84", "time_utc": "2026-08-01T07:33:21.547463Z"}
+{"agent_id": "/root/report_r053", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "1d0b7ceef40c27bfd43df7dfc08a194ce9913241cea73da59dd63bfa5fb96bd5", "run_id": "r053", "schema_version": 1, "sequence": 347, "time_utc": "2026-08-01T07:33:21.549255Z"}
+{"agent_id": "/root/report_r053", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 948}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "6422cd860ad765ec046a2060cb13f8542acd93eaccf203f140104319b645a3f4", "run_id": "r053", "schema_version": 1, "sequence": 348, "sha256": "97b483500c362b67ec5966a089ea6c9d0c039bbfe454e5b05d854edc693bf982", "time_utc": "2026-08-01T07:33:21.550926Z"}
+{"details": {"cell_id": "1ab98c2830b91afc592e74e6e6c5b9be"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "44104d1e12274d81c1551194b2cb8158d5f10f79f8da816e0c124069040fb7a2", "run_id": "r057", "schema_version": 1, "sequence": 349, "sha256": "913bf6426125593e0802e72e6c0cd890d6166d39cb0b505babd0ecf58098e244", "time_utc": "2026-08-01T07:33:26.877655Z"}
+{"agent_id": "/root/report_r057", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "2ef41528ecb9fe1df217092bf1b387fe1065c3e723d206c2b6016da667e8f3a3", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "bab190cb54360161f91bdccab769ebfea91b135ad102f3c3b9bc1e2d06d387b2", "run_id": "r057", "schema_version": 1, "sequence": 350, "time_utc": "2026-08-01T07:33:56.355510Z"}
+{"agent_id": "/root/report_r055", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "06862d6fc5decd11aa0df930f1df1469f62ce45e1bccc6dbdc9099217d95c3f1", "run_id": "r055", "schema_version": 1, "sequence": 351, "time_utc": "2026-08-01T07:36:41.550581Z"}
+{"agent_id": "/root/report_r056", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "ec128f8493b9dee503cc7c945b2155c15a58660429d159da51716b6d8de29e38", "run_id": "r056", "schema_version": 1, "sequence": 352, "time_utc": "2026-08-01T07:36:52.550679Z"}
+{"agent_id": "/root/report_r057", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "0d5d4bf725c8ab415716c89910a537282cc7f25e12734ef9636ad6639de20f6a", "run_id": "r057", "schema_version": 1, "sequence": 353, "time_utc": "2026-08-01T07:37:01.717301Z"}
+{"agent_id": "/root/report_r055", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "e684a5a22cf9f65fc26bd40e5549e1bd89fe88ea67200e7236ea0d2f3bf8339c", "run_id": "r055", "schema_version": 1, "sequence": 354, "sha256": "d240dcc33a9f64583a19fd38ca75c74f2967e0db06a1822771071e49e600a4c3", "time_utc": "2026-08-01T07:40:05.183971Z"}
+{"agent_id": "/root/report_r055", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "48748bb19eb9de99d67bbcfbb31fc0a7deace435a811c4c5c9d4866d2bd9e69c", "run_id": "r055", "schema_version": 1, "sequence": 355, "time_utc": "2026-08-01T07:40:05.185666Z"}
+{"agent_id": "/root/report_r055", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 955}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "b075ad581855bbbe615c37b4565509e5c885ac3a83d26ff68fd3696680826078", "run_id": "r055", "schema_version": 1, "sequence": 356, "sha256": "c29cf094b7026bbde11940bb1784b6393918115d74c5eec57207772ba46f0012", "time_utc": "2026-08-01T07:40:05.187330Z"}
+{"details": {"cell_id": "bf0abeb5157d3eed578e8bc0edde0d47"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "80c57f0c4388820ec72a28e0a390a8ec2ff73534236413f2c5d00cfa83f66aa3", "run_id": "r058", "schema_version": 1, "sequence": 357, "sha256": "8bcd3f674e58042322060c9378e3f2f7692024bfe4b30164173b03f123aeee7d", "time_utc": "2026-08-01T07:40:13.524502Z"}
+{"agent_id": "/root/report_r058", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "45d3100ee32fd049132cb7aa7b9f316407efab09fcbc74c417dead360b694b61", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "6cd6c0d44583f152298ae62e6c69417ab9ead4267ead22074cd20859d27a3a18", "run_id": "r058", "schema_version": 1, "sequence": 358, "time_utc": "2026-08-01T07:40:36.015271Z"}
+{"agent_id": "/root/report_r056", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "faa683c53fa5ae8eda53ac42118ab3634c55d7d4eea54166ee20c3f774a2bba0", "run_id": "r056", "schema_version": 1, "sequence": 359, "sha256": "f674444714768decf1eaf01a809499a270b9386a3953a8fa655e19dc14525ea8", "time_utc": "2026-08-01T07:40:58.507812Z"}
+{"agent_id": "/root/report_r056", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "d47a3d29c688be6665752f0298a79a573d743a36fc230cca56ca64835ab4b7df", "run_id": "r056", "schema_version": 1, "sequence": 360, "time_utc": "2026-08-01T07:40:58.509527Z"}
+{"agent_id": "/root/report_r056", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1006}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "a50638b61403c307e70f7f47322a511607410acd74323648d081b99521c41bdd", "run_id": "r056", "schema_version": 1, "sequence": 361, "sha256": "7545ffde31d113e2377bb3eb1304b7711101e88f6f29b168d2483ae2210177a4", "time_utc": "2026-08-01T07:40:58.511215Z"}
+{"agent_id": "/root/report_r057", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "b427e6a5bb806e04922563a20a21bb5b9355e7dcb949b2f7a9dd7c18fb1236e7", "run_id": "r057", "schema_version": 1, "sequence": 362, "sha256": "cf93ebed914a153d88cacc4ef6b3de465afaaad62c19076c47078f3a9126e3aa", "time_utc": "2026-08-01T07:40:58.753050Z"}
+{"agent_id": "/root/report_r057", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "70047e99391b86e151671c993fbdb55ec49917490cea80c53a47d9fe7e468585", "run_id": "r057", "schema_version": 1, "sequence": 363, "time_utc": "2026-08-01T07:40:58.754652Z"}
+{"agent_id": "/root/report_r057", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 852}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "0153411cdc69e7777afe38a436cec51d3b4f1c7090389c7195615f45ff81237f", "run_id": "r057", "schema_version": 1, "sequence": 364, "sha256": "46a2e9a7de676f0249b9a248e2d2d18a0894fb0379999bc3721cb31e84c4db9d", "time_utc": "2026-08-01T07:40:58.756276Z"}
+{"details": {"cell_id": "91104a670ad522d0fe606ac8e15dc1f5"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "a4f23461100c4a014412b929576045e70b4d0786a0ae2252b5ac3910e86e7453", "run_id": "r059", "schema_version": 1, "sequence": 365, "sha256": "6f10082095ffd0bae9492ab1667e9ec1f434afb26e74b773f627fbb54802be6d", "time_utc": "2026-08-01T07:41:07.498879Z"}
+{"agent_id": "/root/report_r059", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "93e55773acfa53c17da0307b8da3b5b8987d3e54392a78a817bdf23e28c30700", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "f83a8ccfb50e649a083389a77321e0d86ef1ab968142e14d129839423f7bcb13", "run_id": "r059", "schema_version": 1, "sequence": 366, "time_utc": "2026-08-01T07:41:31.925009Z"}
+{"details": {"cell_id": "02038086e3c763683e357ad7d23a8005"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "8d21082949f06d5c384d305bc63b26aecb98838b74038b06df24267a24db6206", "run_id": "r060", "schema_version": 1, "sequence": 367, "sha256": "7ceaee4dda39a2685ef05c03acd0f7792d67011f4ae7bb84021e5fb2edf80edd", "time_utc": "2026-08-01T07:41:37.833201Z"}
+{"agent_id": "/root/report_r060", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "4ab61a3dfddf4a50d46cf6179999c7674a042eda6f6baad8f1a14b775cdd5234", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "5c7252b893b849d69db561cd28d3d4c01b9276f58b8ec72f84c15ba853cf5322", "run_id": "r060", "schema_version": 1, "sequence": 368, "time_utc": "2026-08-01T07:42:02.688069Z"}
+{"agent_id": "/root/report_r058", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "434eb61149b9a6b4ca9ec6a4d571c987bb5f58e0fefe4ab007e2b535fa67106e", "run_id": "r058", "schema_version": 1, "sequence": 369, "time_utc": "2026-08-01T07:44:54.399046Z"}
+{"agent_id": "/root/report_r059", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "2f34d94a8fbbecd853b2cbd8e56b02b7750210d1a901fcc953cb7ef70a86a656", "run_id": "r059", "schema_version": 1, "sequence": 370, "time_utc": "2026-08-01T07:45:04.730748Z"}
+{"agent_id": "/root/report_r060", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b70b9a556bbbb8eaede598a7bb4b989997c847a89d9cec9e77a6bbda365e6db3", "run_id": "r060", "schema_version": 1, "sequence": 371, "time_utc": "2026-08-01T07:45:12.687864Z"}
+{"agent_id": "/root/report_r058", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "83e81f73091497bd30457b77447bb830e8e92323452b37a5cc45ebeb123418d6", "run_id": "r058", "schema_version": 1, "sequence": 372, "sha256": "333dc40d27a4f3efe71ffcba63b0e662a21c81d77cbed8eef46b6b80c780619f", "time_utc": "2026-08-01T07:48:58.715903Z"}
+{"agent_id": "/root/report_r058", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "8640ac6effcf9fc84587fb1ea50510760f85362be984a136b00f0127a2ba9aca", "run_id": "r058", "schema_version": 1, "sequence": 373, "time_utc": "2026-08-01T07:48:58.717719Z"}
+{"agent_id": "/root/report_r058", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1018}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "b2c6167490dcefe658640535e0bd39898fc72fad3f8f26ffb2addee9025df588", "run_id": "r058", "schema_version": 1, "sequence": 374, "sha256": "0e2fc947abce81854d0af02b955fbfa0b36f0bbcdaa8b7027f450a6b3c3e2d7e", "time_utc": "2026-08-01T07:48:58.719525Z"}
+{"details": {"cell_id": "b0f33b6db364346c2523b34bcc8a0ecd"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "b84558f54ba162282f5ac476bff08ce02e016e9088d8f572cb46259a82754568", "run_id": "r061", "schema_version": 1, "sequence": 375, "sha256": "07628927e0fa313aba8c95a65483be5d1782bbebf16d10adc87c3fc956bb7b75", "time_utc": "2026-08-01T07:49:06.120202Z"}
+{"agent_id": "/root/report_r059", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "72a543477b53f602579ade36892901aa3edcca5b2e3b2905bc4bfc6604c0d842", "run_id": "r059", "schema_version": 1, "sequence": 376, "sha256": "633b1cda324a8766438253468df72291c0b2040f5b29dec307140612a161c91c", "time_utc": "2026-08-01T07:49:11.302242Z"}
+{"agent_id": "/root/report_r059", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "b7fda571e146b99082c2b8fd48bec401dc41fea48e2eee5a952433f0cad77c01", "run_id": "r059", "schema_version": 1, "sequence": 377, "time_utc": "2026-08-01T07:49:11.304004Z"}
+{"agent_id": "/root/report_r059", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 888}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "9acff7871f7d862586461edf55304cd6c9d89bb1635f88a56a312d1718ff06fe", "run_id": "r059", "schema_version": 1, "sequence": 378, "sha256": "2ce56cb39ecd21ba188269290a81702a5f56f4eb84cf09a916a019a850d4436a", "time_utc": "2026-08-01T07:49:11.305879Z"}
+{"agent_id": "/root/report_r061", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "5beb323490892c365c871141f291fc792b05718991279f8e00e2f3246de7e527", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "ecb04e54ad1b87d574b40ee57283e25e67d2dfb3f7ed985852884c000a73a2d5", "run_id": "r061", "schema_version": 1, "sequence": 379, "time_utc": "2026-08-01T07:49:38.046625Z"}
+{"agent_id": "/root/report_r060", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "4860325d489f34320413a495e6ed54770a3dcc6b0e4fba6029f79a370cf505ba", "run_id": "r060", "schema_version": 1, "sequence": 380, "sha256": "7571c1c5ad8bf41eaa9ff43b8d7cd476f337d3b81a09a44d28530c2878b7dcea", "time_utc": "2026-08-01T07:49:45.757408Z"}
+{"agent_id": "/root/report_r060", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "d512b5106b9de9a11cf969da63250b3f71bd90d5cee8dc985a5d2d0956b54cfa", "run_id": "r060", "schema_version": 1, "sequence": 381, "time_utc": "2026-08-01T07:49:45.759376Z"}
+{"agent_id": "/root/report_r060", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 914}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "93bc182b0b3c5e6b7d063f1ef7466c4447a57109c414f23e9dbdb4edf6b26c28", "run_id": "r060", "schema_version": 1, "sequence": 382, "sha256": "199d71241d40542bdfcb5dff45e6e3f2384eacfe6f21f69747a7eaab44f200d4", "time_utc": "2026-08-01T07:49:45.761016Z"}
+{"details": {"cell_id": "359c5fe574e54bea738b01822c7104f6"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "9cf5d9d4102b710f1e1b2b7dc49784912abf6f7c1affc5269a73b1e7340e713c", "run_id": "r062", "schema_version": 1, "sequence": 383, "sha256": "6b81c2599ecbff7bfe9e9dc0c9f69675bae3c41ae9788e6b99fb10dc601db2ac", "time_utc": "2026-08-01T07:49:54.104183Z"}
+{"agent_id": "/root/report_r062", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "902dc243891235b5971a402abdcb47ffba3cfc50bfebb38d02557d37c5c2aaed", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "29bca54acb29a8348c2b2574e339c06114dc2a2f1273f1da5d43098fa22d159c", "run_id": "r062", "schema_version": 1, "sequence": 384, "time_utc": "2026-08-01T07:50:22.107238Z"}
+{"details": {"cell_id": "812bd420e5eba308dc68e07047e583c1"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "762e720c58c9634618b3579b93e2af236a51fb7a2fd0919236a7d30555f48e0f", "run_id": "r063", "schema_version": 1, "sequence": 385, "sha256": "3889ba2867e774281a8631ad558533830e944f1ada2021b06ed0ef0dde56d745", "time_utc": "2026-08-01T07:50:28.856303Z"}
+{"agent_id": "/root/report_r063", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "44f5152f85c59c488239df0b8d2cff985d1ec52757eb79186c1c4daa7b521ef4", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "7cca14d56471056dd9ed8510157807634badaefef3e2efe79b3b9f09d5d856b0", "run_id": "r063", "schema_version": 1, "sequence": 386, "time_utc": "2026-08-01T07:50:54.798069Z"}
+{"agent_id": "/root/report_r061", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "8b56c053ef80333eb3daccb5bed27c2b54f567912e9b947a1947057b349c2a96", "run_id": "r061", "schema_version": 1, "sequence": 387, "time_utc": "2026-08-01T07:53:40.435845Z"}
+{"agent_id": "/root/report_r062", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "9b155a32250b02a0beb240979ad3eb6401049361e7fd16fafe3f533bf7993978", "run_id": "r062", "schema_version": 1, "sequence": 388, "time_utc": "2026-08-01T07:53:53.775416Z"}
+{"agent_id": "/root/report_r063", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "5e27bd20a96450b896620ee4776a34aa9c5e01b87776dbef68b1966a0de6a854", "run_id": "r063", "schema_version": 1, "sequence": 389, "time_utc": "2026-08-01T07:54:02.228609Z"}
+{"agent_id": "/root/report_r061", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "ac59fa18b12f6461575e50157c344069de5cbf8f3e8b782512f048e1f6c0d6a8", "run_id": "r061", "schema_version": 1, "sequence": 390, "sha256": "23e80273eafad57da2e18dc1343d9d58ba3312ba88a062145fbb011af7b3c5b7", "time_utc": "2026-08-01T07:57:28.011887Z"}
+{"agent_id": "/root/report_r061", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "0b2e547df878a566a11eeb1ae79c37ba00fa3e663256d1d7d016ca21ca8f6cf9", "run_id": "r061", "schema_version": 1, "sequence": 391, "time_utc": "2026-08-01T07:57:28.013647Z"}
+{"agent_id": "/root/report_r061", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1140}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "da4308f48b23045c4814a07195353906cf504be73f5955296c31c5a6cba37437", "run_id": "r061", "schema_version": 1, "sequence": 392, "sha256": "18c6702f1987cf50f6511f0e1d09f515dd468abed2ad03af5d8af962d7e5c27a", "time_utc": "2026-08-01T07:57:28.015486Z"}
+{"details": {"cell_id": "5f63b439ef17bd4c9938d31e4445e847"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "a4025abba18c495498efca691d4ed2c3cf3475e1d8f2ca7fd7aa2892f1f0f045", "run_id": "r064", "schema_version": 1, "sequence": 393, "sha256": "eec74c03da591cb5046adc22e189d34a801faba43c69d04a1c32d7447f6bae83", "time_utc": "2026-08-01T07:57:33.027129Z"}
+{"agent_id": "/root/report_r064", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "b5faf109a36a5a9b624ff7db8e1e4f2c02b0d30080c198b4263b547ef4c20d77", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "ed7021bf21b4c21550bf5a83926656fe6ce8f62c92d88104c857b5bbf720956a", "run_id": "r064", "schema_version": 1, "sequence": 394, "time_utc": "2026-08-01T07:58:00.636933Z"}
+{"agent_id": "/root/report_r063", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "4c5672da686b70249e73fecb29bd4512964f4ad2e6c7ce8ebd63f3227dc5e3f9", "run_id": "r063", "schema_version": 1, "sequence": 395, "sha256": "5eeb6bd51de78717ebaa55e7d0fcccc90ee93f6be0024d43dd636e6fe6a004a5", "time_utc": "2026-08-01T07:58:05.676428Z"}
+{"agent_id": "/root/report_r063", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "0c3fed10d7a78dc4fe2a8ff692a079ef4c39036ed6ed284c157033214f792b52", "run_id": "r063", "schema_version": 1, "sequence": 396, "time_utc": "2026-08-01T07:58:05.678098Z"}
+{"agent_id": "/root/report_r063", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1036}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "5262f572fcdc729359d3e09955700608b04d71e8a6070ec54c3bdaf69a9e9b85", "run_id": "r063", "schema_version": 1, "sequence": 397, "sha256": "cfa8049918cc9eb89660940173c43c86bda06e974d3ef134b3f82fb21dbcb3af", "time_utc": "2026-08-01T07:58:05.679620Z"}
+{"agent_id": "/root/report_r062", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "5d716633b3856cf2b4410b1ab9d14ab0adc4aea7ce76f40f9ae11d3cb45fd955", "run_id": "r062", "schema_version": 1, "sequence": 398, "sha256": "f385ef4582fb0e5a0cd0c6ffd6e6dc57cb3ca43790f2c05a78462d87f5173d9c", "time_utc": "2026-08-01T07:58:50.259525Z"}
+{"agent_id": "/root/report_r062", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "c5a41741f84ecb8c3d8e56f60796e01f831e375d01de2c14b318d3629233c21b", "run_id": "r062", "schema_version": 1, "sequence": 399, "time_utc": "2026-08-01T07:58:50.261406Z"}
+{"agent_id": "/root/report_r062", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 881}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "149bc0ec7bd5f7a6a85972a7cd3b2321b76ac4a9b7ba2f46788e8c48dc159345", "run_id": "r062", "schema_version": 1, "sequence": 400, "sha256": "787f990b31be3392ae20e4b16e9c1f20785006bf90464beb7a352a0b395956ad", "time_utc": "2026-08-01T07:58:50.263102Z"}
+{"agent_id": "/root/report_r064", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "8f80b6d7d402c5bf683df0cdf2fd7749b37e10bc0b4c6565952f5233c0ca9b22", "run_id": "r064", "schema_version": 1, "sequence": 401, "time_utc": "2026-08-01T08:02:13.335415Z"}
+{"agent_id": "/root/report_r064", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "9bab477e02c1de7042bfefadf459821a0dd1fdcd5382c7916bef982fc1345191", "run_id": "r064", "schema_version": 1, "sequence": 402, "sha256": "a690ca4a3e41859fc9c827ce78740a195d9d8a06dd18b54919f75988c8517c53", "time_utc": "2026-08-01T08:05:23.318795Z"}
+{"agent_id": "/root/report_r064", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "a3daaf9394454cf859280264c99cf3f0cc7a7a3d82d1f4918cbb217320114ea4", "run_id": "r064", "schema_version": 1, "sequence": 403, "time_utc": "2026-08-01T08:05:23.320614Z"}
+{"agent_id": "/root/report_r064", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1004}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "c63f7362a9444e645ba0d57e2993b472459e7eb21f9027d147a9c084154216ea", "run_id": "r064", "schema_version": 1, "sequence": 404, "sha256": "53cf56027a48090998b1ca7fca43ec1200e98e1e8fe386339909fe1a840ffce4", "time_utc": "2026-08-01T08:05:23.322319Z"}
+{"details": {"entries": 76, "wave": 5}, "event": "authority_verified", "phase": "collection", "previous_event_sha256": "3885044e809722ad5ebc157134eb90094e3c44abc55fd39aea77ab0db5241eef", "schema_version": 1, "sequence": 405, "sha256": "329634ba9421a9a65b2802b4ba5b07667fae194411904cbbfc7f002da84c0f97", "time_utc": "2026-08-01T08:05:37.994306Z"}
+{"details": {"cell_id": "2505caff3f06d70966adcc385f251627"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "d8cb961763c9612f27d45754dbeba5dece697c2b6e5d0fcacb7bb279578696c5", "run_id": "r065", "schema_version": 1, "sequence": 406, "sha256": "3f73c34258b5876817f8f315b83414735ebd8ad44d8beace450e3452fcfad924", "time_utc": "2026-08-01T08:05:48.985700Z"}
+{"agent_id": "/root/report_r065", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "1d42b33596d89ee65efccbbb6b90e77384d1c90377c3a2c407231d1cc55e8675", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "60232864e254485327f32c24fcc008595f07348eb1e70aae682c25452c9095bf", "run_id": "r065", "schema_version": 1, "sequence": 407, "time_utc": "2026-08-01T08:06:14.404698Z"}
+{"details": {"cell_id": "da357b62c59f84a5e9f0f0a11214900a"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "15b35631f94520af461d252a2d9620b974ed55915f070163d82bc11acc9a0381", "run_id": "r066", "schema_version": 1, "sequence": 408, "sha256": "6cfc5a30524c3403fa7e15c72c93e7f17840e4adb6aeefaec2514d30898074f4", "time_utc": "2026-08-01T08:06:20.449199Z"}
+{"agent_id": "/root/report_r066", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "d0b21bbb97121ac8b76c37c563d6cae1c021b2e93893ff8500c0182b06544b9f", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "7b5e1617b63572dd649fb6518f8140d0ff15fc7f6109c6ca94be4bc2665cc2fe", "run_id": "r066", "schema_version": 1, "sequence": 409, "time_utc": "2026-08-01T08:06:44.773674Z"}
+{"details": {"cell_id": "ae051f5093ea311894002930e26944f6"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "918376d29629b76a0024b316cca4c5fd1cf476f22add017209cc5c67f65eb8b5", "run_id": "r067", "schema_version": 1, "sequence": 410, "sha256": "1bb171910fa044805a023c242a0e1577a56dc907d518bd94521ea691f20b69c9", "time_utc": "2026-08-01T08:06:50.513235Z"}
+{"agent_id": "/root/report_r067", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "40898c70fad70db602f0bcd8b860af157aaaf77c45949247d46071bd3becc755", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "b8ac7ae7d6bca0d0ef482b14c1b7e75ff9d33101a00ed5db98d763bed7e643f1", "run_id": "r067", "schema_version": 1, "sequence": 411, "time_utc": "2026-08-01T08:07:19.530400Z"}
+{"agent_id": "/root/report_r065", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "8b87487f2f5972bc14304b5a94c1e16847427402569f221e7a22c1b901ad6f5e", "run_id": "r065", "schema_version": 1, "sequence": 412, "time_utc": "2026-08-01T08:10:40.035280Z"}
+{"agent_id": "/root/report_r066", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "a18b44e6aa6b35dbb8f95cef7085fe80a372b1cb1a1c6a6bcadc705cfcce6266", "run_id": "r066", "schema_version": 1, "sequence": 413, "time_utc": "2026-08-01T08:10:49.178801Z"}
+{"agent_id": "/root/report_r067", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "62cca8705cd0561815758a9a9962577b45a5401c363bb8705d3dd727e2277923", "run_id": "r067", "schema_version": 1, "sequence": 414, "time_utc": "2026-08-01T08:10:59.353992Z"}
+{"agent_id": "/root/report_r065", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "af500f6f7357f94953b701246eabdb0821650852c9b443f7a5488fc5f1b9e6e3", "run_id": "r065", "schema_version": 1, "sequence": 415, "sha256": "846837ff853929d2d1b78b2c4fa8d090ef69d10409cbc721fb86484e38d61597", "time_utc": "2026-08-01T08:13:43.771748Z"}
+{"agent_id": "/root/report_r065", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "ded36671c533c3cbf1375392173b5d1f8ba2c76803d162a07c235cd9707973d5", "run_id": "r065", "schema_version": 1, "sequence": 416, "time_utc": "2026-08-01T08:13:43.773420Z"}
+{"agent_id": "/root/report_r065", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 863}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "e49206a9500bd8eef8341da3a3bf43dbed9b2e6d5e306b5c50b8382e2a2cd7f3", "run_id": "r065", "schema_version": 1, "sequence": 417, "sha256": "a6eb34fd1d3c89310961cd76a7f61566e7226a18edb237f3540b96bf915b40e2", "time_utc": "2026-08-01T08:13:43.775151Z"}
+{"details": {"cell_id": "6a4a5f007b65de786b2391d09453d5e7"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "57dcf48b797fc645d3f8603e4cd94b2866dbeaea742db5327d17b4b6754f5e50", "run_id": "r068", "schema_version": 1, "sequence": 418, "sha256": "792fdbd9fb8798a654e2691a07976a520246f6062f8f7540cee2c9b1d961ccee", "time_utc": "2026-08-01T08:13:50.274751Z"}
+{"agent_id": "/root/report_r068", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "0f84ecbaeb96364506a8e1533f1bf7db2a750cfae822f5e9536c0c2987e80c33", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "0622d43c05e764095fd4167defd7733d137a0f59b658e9d769a968129398859a", "run_id": "r068", "schema_version": 1, "sequence": 419, "time_utc": "2026-08-01T08:14:15.590801Z"}
+{"agent_id": "/root/report_r066", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "f67f92f7588b0e92f0536f631b26a77f5045c043f3f2772be25bad16f69b87d1", "run_id": "r066", "schema_version": 1, "sequence": 420, "sha256": "367ade91dedb5f71e4563fe5769efbc33253551ae8934af8694b94256805973b", "time_utc": "2026-08-01T08:14:32.822204Z"}
+{"agent_id": "/root/report_r066", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "950b0f9a116d432c99f754ca0ce23e1898341a3ab79fa67400f8feaedaa7b110", "run_id": "r066", "schema_version": 1, "sequence": 421, "time_utc": "2026-08-01T08:14:32.823886Z"}
+{"agent_id": "/root/report_r066", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1136}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "f0df3956bc22a7a6925e4b2b76445f16e9a18aaa3993977162f0d1252573772c", "run_id": "r066", "schema_version": 1, "sequence": 422, "sha256": "86d896a590d75d6ab764037f04ed282c3a6fc822d7278bd68929a8b8f9de97d5", "time_utc": "2026-08-01T08:14:32.825684Z"}
+{"details": {"cell_id": "40e593bb6d93cf7b49e1fb35342ff99a"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "7724f0d2ec736d713fe1519a15de1d3e43526d18d2a6b922d4ab39cf1769b333", "run_id": "r069", "schema_version": 1, "sequence": 423, "sha256": "0ea277a192774db8a4828adbcb9398aeb4c66f511bc3bf5300dd71765b2f9286", "time_utc": "2026-08-01T08:14:42.213781Z"}
+{"agent_id": "/root/report_r069", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "5b708a5d7c2c380d1c60d88ac7103cb01a66ccebe7542a5440b0fa2684b87f5a", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "e9b526495484dd307f2d2c3a370de924c12a6861ec6282b10216aa6f6878883a", "run_id": "r069", "schema_version": 1, "sequence": 424, "time_utc": "2026-08-01T08:15:04.496129Z"}
+{"agent_id": "/root/report_r067", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "09126b4687d7c6a946480776018e1f3683d7c7dae62d554810e1dcbec6d7e620", "run_id": "r067", "schema_version": 1, "sequence": 425, "sha256": "cf577039cdf4b2b264277cc970c73af71d3f5f53b10e8d87e30d55dc49228d52", "time_utc": "2026-08-01T08:15:14.100173Z"}
+{"agent_id": "/root/report_r067", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "05c11c066746cb4916af803f2cbe9214b3d2df5f2b9ccc70f4de2202e62a54b7", "run_id": "r067", "schema_version": 1, "sequence": 426, "time_utc": "2026-08-01T08:15:14.102228Z"}
+{"agent_id": "/root/report_r067", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 904}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "66dede63ab6d952dbdd0178b9600f0570add4442953ac368cf697a6047750968", "run_id": "r067", "schema_version": 1, "sequence": 427, "sha256": "06e79bd6b8b63d837b56c80f95a012f301f5b47ab10d2112882ae72c41f0ea7f", "time_utc": "2026-08-01T08:15:14.103864Z"}
+{"details": {"cell_id": "1769a58b00a1db740e39dbd7cba09c6e"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "c7004fc578c7fd24d7ed55ce8a6a42b252865bdfd5bd59a8becf5d3f65cceced", "run_id": "r070", "schema_version": 1, "sequence": 428, "sha256": "426989e866f3391c0c653e544c5adfa34ed0e364b8b12388f51ab12c40bd14c4", "time_utc": "2026-08-01T08:15:19.400185Z"}
+{"agent_id": "/root/report_r070", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "76e1010a76bdd7daa9c9e14f8f69760f8e69c9d5dd918323394ccc617148df36", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "b9cef5a2b6835e129c260b5f8701da8e31ee797d280736057ce3ccf622c01de1", "run_id": "r070", "schema_version": 1, "sequence": 429, "time_utc": "2026-08-01T08:15:43.341479Z"}
+{"agent_id": "/root/report_r068", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "d575d2baabb1f84fa76fa3cc6f765282c63110daf2f054342c0178917c9128ed", "run_id": "r068", "schema_version": 1, "sequence": 430, "time_utc": "2026-08-01T08:19:07.856509Z"}
+{"agent_id": "/root/report_r069", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "db690fcb82eab3b29ee09578eb9ef3c151855714e47e7ea4bc07d6516beb267a", "run_id": "r069", "schema_version": 1, "sequence": 431, "time_utc": "2026-08-01T08:19:18.851591Z"}
+{"agent_id": "/root/report_r070", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "da1cdb7088618864a3ce0ccbb17cdc7287c3a1d35078027e09f233e5ee0b9af1", "run_id": "r070", "schema_version": 1, "sequence": 432, "time_utc": "2026-08-01T08:19:31.538676Z"}
+{"agent_id": "/root/report_r068", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "d31612a3a0ec3cdd840fec3782bda31fb3db304ba9259050cb54e2ca96c71951", "run_id": "r068", "schema_version": 1, "sequence": 433, "sha256": "f45522def4c3078a8d79c7e383a72fd231ee60f132ca054a9afc9c4a3c14aea5", "time_utc": "2026-08-01T08:19:54.219215Z"}
+{"agent_id": "/root/report_r068", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "6152b29e31b9c83b272e21bb9b252b1e0e6f6dd6eb3ca76dc6c498b99edaf67c", "run_id": "r068", "schema_version": 1, "sequence": 434, "time_utc": "2026-08-01T08:19:54.220898Z"}
+{"agent_id": "/root/report_r068", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 921}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "4054afef5c2e4f967dedcdb336fab87573255957f8853009a4c750d3c09c79fb", "run_id": "r068", "schema_version": 1, "sequence": 435, "sha256": "a596f12e22efee1d14c1f64eea7c3a10da7c32d779c496b890874fd4ef2be972", "time_utc": "2026-08-01T08:19:54.222427Z"}
+{"details": {"cell_id": "4cec2104444a8240d06ee311657dc0f3"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "1233554229f58c4a8dd55f991d9707c289f6f40204c6db0f2d69ed46c8e253b2", "run_id": "r071", "schema_version": 1, "sequence": 436, "sha256": "2860f3810fb6307d93b1e7fceb177dd61b9b7d7119c99fde71a5cb1b9d7f4dad", "time_utc": "2026-08-01T08:20:00.641031Z"}
+{"agent_id": "/root/report_r071", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "0a8cd9a63a8cdd4e61cca6989037dd2ad59e4911c876819152c5bad0c90e3ed8", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "c9690f0f18400829288a94d474a7a8d3b416111c6f82c5bdd91971f43b6732d8", "run_id": "r071", "schema_version": 1, "sequence": 437, "time_utc": "2026-08-01T08:20:26.118732Z"}
+{"agent_id": "/root/report_r069", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "bc12e73630071897ca66f716c5a68e3d396537879fa28ef016a3c78b81f164e3", "run_id": "r069", "schema_version": 1, "sequence": 438, "sha256": "0da4bc22e70d9b3fc502287875c81ed865cde51c50fd8b37c7217f627eaf398e", "time_utc": "2026-08-01T08:22:05.246368Z"}
+{"agent_id": "/root/report_r069", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "eadcb20ffe6d602e6b4576b01ae4a3c5b0acb2196e76686b91fd4c373a438c69", "run_id": "r069", "schema_version": 1, "sequence": 439, "time_utc": "2026-08-01T08:22:05.248240Z"}
+{"agent_id": "/root/report_r069", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 965}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "555624768e6f1803f3ba1222fe9ba2d4ab204cc52793753524b0256dee8bd179", "run_id": "r069", "schema_version": 1, "sequence": 440, "sha256": "dac13c86e54c024ce799a6b3184e7c6d0e72cb9fdb3ce113aa7ef189c9b65630", "time_utc": "2026-08-01T08:22:05.249856Z"}
+{"agent_id": "/root/report_r070", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "d948b5cef2caccbdd9a68a08b8f1510aee6a7a77a03ab2bb457162c3d808a4da", "run_id": "r070", "schema_version": 1, "sequence": 441, "sha256": "802fbf1702110d121ed448349d1fcce5dd50cb4187c429aa8b538ffc83b51996", "time_utc": "2026-08-01T08:22:05.499624Z"}
+{"agent_id": "/root/report_r070", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "93d59f304dc5239f41a7350bf71acce008c7cf307e749cca44355cabcff77188", "run_id": "r070", "schema_version": 1, "sequence": 442, "time_utc": "2026-08-01T08:22:05.501385Z"}
+{"agent_id": "/root/report_r070", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 882}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "037700abac2c3d3ac7047abec5c7f18c52369ce7e7f6ea4f70ee08e173212b86", "run_id": "r070", "schema_version": 1, "sequence": 443, "sha256": "79e602e9a2317fa845b12fb497a3d895697a4ccdf81598750451850f95fce1fc", "time_utc": "2026-08-01T08:22:05.502959Z"}
+{"details": {"cell_id": "843cbdc69d6a93ba2d97c2ef54f74264"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "ace4dc6fe2bdaf9689f825645ae771765ba5bd33482085a1166e0ade9012c84e", "run_id": "r072", "schema_version": 1, "sequence": 444, "sha256": "905456a7d64c6e67f7ac4b71a86a491a1d0e55d2d7be47ff14b71a6d6eaebb9b", "time_utc": "2026-08-01T08:22:11.327949Z"}
+{"agent_id": "/root/report_r072", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "080821b8aafa8326c223b37f452177766a1edc1b587525583f40fc6810ecda20", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "ea52b886d43a6654cfa42ca3c5414008b8086afd300f33595bf18edd0fb7004f", "run_id": "r072", "schema_version": 1, "sequence": 445, "time_utc": "2026-08-01T08:22:39.944970Z"}
+{"details": {"cell_id": "59206a03a32ed8ca983f8665c26fcacc"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "8abb97135f7a3c72f3cee5ecebee6c86b5f9c2c7d6912a82693e74d6a0b44275", "run_id": "r073", "schema_version": 1, "sequence": 446, "sha256": "7d7c9f16db90cc2d0a73366f16709fd66a215f635a983c1ac5c1497c617ab315", "time_utc": "2026-08-01T08:22:45.685083Z"}
+{"agent_id": "/root/report_r073", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "d245bd465d213b1affc66f704489d70e7ab86b1f25412514bb1a698d04320370", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "dbee4b4939ad07fd2786e3eb0fb2859f5062b41b8e17d6146157a8c358d74c48", "run_id": "r073", "schema_version": 1, "sequence": 447, "time_utc": "2026-08-01T08:23:11.038357Z"}
+{"agent_id": "/root/report_r071", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "b2b73c633eed94509de3d83c61cd0e81b992db2d9533f39ae7c97ce6e96b21ae", "run_id": "r071", "schema_version": 1, "sequence": 448, "time_utc": "2026-08-01T08:25:59.774194Z"}
+{"agent_id": "/root/report_r072", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "f451e2ae53df5010cb15bf9ec2751c1de542bc11661e4056113bdb3728874742", "run_id": "r072", "schema_version": 1, "sequence": 449, "time_utc": "2026-08-01T08:26:08.586074Z"}
+{"agent_id": "/root/report_r073", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "a920f78e153e2959f437345f2c665cd96ded78c2a7ca5026a05923e226ef113d", "run_id": "r073", "schema_version": 1, "sequence": 450, "time_utc": "2026-08-01T08:26:19.889110Z"}
+{"agent_id": "/root/report_r071", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "2caf67d1052c791bd4b66f544eea221dc3d4422adeb060a23bf4674d028edd9e", "run_id": "r071", "schema_version": 1, "sequence": 451, "sha256": "db5ce90d1975d92736f9a6e1a03c46d9f2843d4c0f9a20031592566ee9cf203a", "time_utc": "2026-08-01T08:29:10.819888Z"}
+{"agent_id": "/root/report_r071", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "ab0eb2761115004150eace53ea0b280465d9914cf9314336f573554235919500", "run_id": "r071", "schema_version": 1, "sequence": 452, "time_utc": "2026-08-01T08:29:10.821796Z"}
+{"agent_id": "/root/report_r071", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 907}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "b5e8ebd493f2e0738d0723e8da42b1691052f680544c5df84a7a6656be0be491", "run_id": "r071", "schema_version": 1, "sequence": 453, "sha256": "acbc1ad06963f179d034a1daec025f797ff8576dcda40718197ed2dbdd639acc", "time_utc": "2026-08-01T08:29:10.823562Z"}
+{"agent_id": "/root/report_r072", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "88075d13f833b7ae123002df471fb16e697831f744b42188716a712139c72fac", "run_id": "r072", "schema_version": 1, "sequence": 454, "sha256": "5f990fa3656084d35c803ed06cbffe499382ae1b9094fb205936141f8430e270", "time_utc": "2026-08-01T08:29:11.073984Z"}
+{"agent_id": "/root/report_r072", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "67b681e31238c6bfc2a0fe687bee9ab4d2b794735c25359b999a2b2431d568d0", "run_id": "r072", "schema_version": 1, "sequence": 455, "time_utc": "2026-08-01T08:29:11.075815Z"}
+{"agent_id": "/root/report_r072", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 899}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "79c9c71b69342375ca6793e30a7ce03de3d52f3da59c5ec256e517e049500f99", "run_id": "r072", "schema_version": 1, "sequence": 456, "sha256": "c9e2ad98c41d88e0c379eff9f0c5b74f545076ca97483f05bbac2f1c46d1a1a4", "time_utc": "2026-08-01T08:29:11.077313Z"}
+{"details": {"cell_id": "6367c11d5940c2dbeeb37e422d2b79c8"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "db3010154913025e5e2b047c0eba72148e53b1a2e6b363680ec4aa274fe4a6ef", "run_id": "r074", "schema_version": 1, "sequence": 457, "sha256": "31769360aa8ce5e943bc2fdab8861a73858bfc6f8c472f0ae28170f1123a027c", "time_utc": "2026-08-01T08:29:20.309289Z"}
+{"agent_id": "/root/report_r074", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "dfe3ff9cc6ec8c7a8f481f75409cad1d10d87d3bc276bd399908636d25baf35a", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "382c229b243c811d4eb58dd8025aaf16c19d437caf987746d79683bb6c8257e9", "run_id": "r074", "schema_version": 1, "sequence": 458, "time_utc": "2026-08-01T08:29:41.204841Z"}
+{"details": {"cell_id": "02d88d35c49cd6779edc8578e7d89bdb"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "bfa5f10f2d1821c9dbbc92b0597682945e0ac5938bf3e4ac20e8ec34c2e0769f", "run_id": "r075", "schema_version": 1, "sequence": 459, "sha256": "605f355edfc361d43fb3b76012f371406f99d324dfffabb27fc204fe299e57b9", "time_utc": "2026-08-01T08:29:49.037058Z"}
+{"agent_id": "/root/report_r075", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "1cecfc6af5ddcefbe813e0fcb7aaf837b53c4be85dfe88cfab39f23cdd4cc65e", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "4538c59ad2706dbf75966c67b6d1a5f2f9e44c6b8fd3176e6de96bad5e104758", "run_id": "r075", "schema_version": 1, "sequence": 460, "time_utc": "2026-08-01T08:30:17.852867Z"}
+{"agent_id": "/root/report_r073", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "35fa0a31637b39b807811bf66674808a1e2ea4b29350a1995405f59c8b430370", "run_id": "r073", "schema_version": 1, "sequence": 461, "sha256": "6c5c6329291f470725e5eae1d5ea6ab4a341fa0b563791c14b873c0a53be213a", "time_utc": "2026-08-01T08:32:09.042389Z"}
+{"agent_id": "/root/report_r073", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "cbca2f2dfdd597c0b707a2dda95c7ca25fa54892c4c48c089c7f283e26ecb0eb", "run_id": "r073", "schema_version": 1, "sequence": 462, "time_utc": "2026-08-01T08:32:09.044384Z"}
+{"agent_id": "/root/report_r073", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1129}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "99bd432bc4065d8500306ae54791c2e78c378b281891c6b19bc414413371f135", "run_id": "r073", "schema_version": 1, "sequence": 463, "sha256": "40a82f89628eb8235ce387a5caaf04ff4ecfae417bd0404d05f8f307d826509b", "time_utc": "2026-08-01T08:32:09.046535Z"}
+{"details": {"cell_id": "ecf25044b6f65e28e446370bea636c89"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "21d219dbf7124d766319a5b3a58dc89c4616bafca44045cea08c9acf6db11537", "run_id": "r076", "schema_version": 1, "sequence": 464, "sha256": "4dcb5d78680fa3d4f79a2cfb9c9e033f1d252f81b122ab1c8c9325d0efc7d4a4", "time_utc": "2026-08-01T08:32:14.086635Z"}
+{"agent_id": "/root/report_r076", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "1486c39f6d59133931a108c9b9fd23cb23d399d5bdac035c1baca3b26e78b164", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "71527af12ac83da2eb72e0d0b2b58624a585b14ce64b09d0744e5a8564028184", "run_id": "r076", "schema_version": 1, "sequence": 465, "time_utc": "2026-08-01T08:32:39.619799Z"}
+{"agent_id": "/root/report_r074", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "aa45c577932bee64523246f5f224e400471bcb3fb7698cdb46385611d5592ffc", "run_id": "r074", "schema_version": 1, "sequence": 466, "time_utc": "2026-08-01T08:32:46.343563Z"}
+{"agent_id": "/root/report_r075", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "22a7ac7b3f2b3b5a6732f95a6d6c83741a0c6702b2eaa1a4418dfeaab6e7b675", "run_id": "r075", "schema_version": 1, "sequence": 467, "time_utc": "2026-08-01T08:33:28.172601Z"}
+{"agent_id": "/root/report_r076", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "ff0e5afa0c48a119cc0850f9453c25ee5a934726f67666a3efec7ebe0e9c5f0f", "run_id": "r076", "schema_version": 1, "sequence": 468, "time_utc": "2026-08-01T08:36:25.643325Z"}
+{"agent_id": "/root/report_r074", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "23e3dce0dffb33dcc09ee41759a08554072d3cd6e3e92b7df158e5a36e4b4616", "run_id": "r074", "schema_version": 1, "sequence": 469, "sha256": "e5f93eb48534cc7a51630771956517243a41cdc19bc944ff9583a8316b190cf3", "time_utc": "2026-08-01T08:36:55.947925Z"}
+{"agent_id": "/root/report_r074", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "c4c64197aa77ad84deab4303895b4cc65753a9bff46135cf93001edbb89b6934", "run_id": "r074", "schema_version": 1, "sequence": 470, "time_utc": "2026-08-01T08:36:55.949711Z"}
+{"agent_id": "/root/report_r074", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 920}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "4d9719aedd56c946be38812c7111a8cc01e9271c3bedbc00a478dbc8cb750be7", "run_id": "r074", "schema_version": 1, "sequence": 471, "sha256": "a4e4c1ea234c10cd9830139d9c8c2d59a1da533003609c68cb81cb4a22a366d9", "time_utc": "2026-08-01T08:36:55.951531Z"}
+{"details": {"cell_id": "886d6d32ed0e40aa1f82f3f94cfcbcaf"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "672c2aba0715fb358a529f17336f52f7adbce4b7978203545d53a189fb836311", "run_id": "r077", "schema_version": 1, "sequence": 472, "sha256": "2edf5727b08bc4c0421d1ae3c50928ebb6c2f102da8c2b0f603514289e5a0c19", "time_utc": "2026-08-01T08:37:09.560802Z"}
+{"agent_id": "/root/report_r075", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "581f3182b38b25eadbb25335ec2e29e61d3714679f0e5ff39ae574a75a42cfd9", "run_id": "r075", "schema_version": 1, "sequence": 473, "sha256": "cb4d78d032738faae963aa2a6f0feb5c56f5d15fa4a954be6a5a655090456b34", "time_utc": "2026-08-01T08:37:20.052688Z"}
+{"agent_id": "/root/report_r075", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "6a57a169c0ffa5315d996fc0c62d41e3360d17195cf28d488ff4c84edded4b42", "run_id": "r075", "schema_version": 1, "sequence": 474, "time_utc": "2026-08-01T08:37:20.054604Z"}
+{"agent_id": "/root/report_r075", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 842}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "484337c6f1639a5b3bca2db3f03f4f5420af18c70f03b435207a9619a7f06a22", "run_id": "r075", "schema_version": 1, "sequence": 475, "sha256": "44941853a2458104b934dfa73aa5411c39c4e5c0ac33730d7bd754757f96e176", "time_utc": "2026-08-01T08:37:20.056330Z"}
+{"agent_id": "/root/report_r077", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "e3889389869cf04a8a8f735711b401a03a6aed29f63e9082b6112436cb3be22d", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "2eba33419bd3f53cdecab3c29425d83b18de866a980c078dbe77b40be904da94", "run_id": "r077", "schema_version": 1, "sequence": 476, "time_utc": "2026-08-01T08:37:48.785984Z"}
+{"details": {"cell_id": "2a9b5392e246efa52195b90613899322"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "842c8aff3e86aeae2eb192b5d2e09ce26e3d4be3ec700da66850726718d1bc7e", "run_id": "r078", "schema_version": 1, "sequence": 477, "sha256": "1ea0cfcc3b3009a05f009fd02bbcd566d577170cca61633ca44c1d491898dd07", "time_utc": "2026-08-01T08:37:56.941313Z"}
+{"agent_id": "/root/report_r078", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "2f647dd051e0b2d6bfbe7b3be13e04d0c1b120dd6de784c3ac4ab2a454cf1f9d", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "f0416332f29216e36236e8fe1157c558f6e3f43a7720ed5cd55e25ccecbaca31", "run_id": "r078", "schema_version": 1, "sequence": 478, "time_utc": "2026-08-01T08:38:26.906712Z"}
+{"agent_id": "/root/report_r076", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "e86f67de1b317df5e1487c97b34953f2cd8ecbacfbdd5b3b14caccd9515f4c05", "run_id": "r076", "schema_version": 1, "sequence": 479, "sha256": "7e9b5ca6c7d2d95c42d1261d29f12a87b5166fba8f315de3ed683777182c1308", "time_utc": "2026-08-01T08:41:07.537877Z"}
+{"agent_id": "/root/report_r076", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "0cd1064a05a716cb98ab58ed9b793e6a71f367b6de9556798141754bdc0aa84d", "run_id": "r076", "schema_version": 1, "sequence": 480, "time_utc": "2026-08-01T08:41:07.539580Z"}
+{"agent_id": "/root/report_r076", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 921}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "2748b0d77604e7995d160e934f5e8522cfe84b415ac0fd4cbf1506953043dc37", "run_id": "r076", "schema_version": 1, "sequence": 481, "sha256": "cc9fd179a072064534dd9b337b68629aa110ba586546632b898c0d96532d449b", "time_utc": "2026-08-01T08:41:07.541298Z"}
+{"details": {"cell_id": "c8dd0a199fe8db9173fe43372c47e05b"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "ee031b2dc764b16ed42c90c34071b7a8c0121d213e2908d47e0f5b7f9e7f05b4", "run_id": "r079", "schema_version": 1, "sequence": 482, "sha256": "dd06e4994e6e9e75489d52f089bdad6b0efd9dea6687f53b811775f3cb7afa58", "time_utc": "2026-08-01T08:41:13.492903Z"}
+{"agent_id": "/root/report_r079", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "cbffeab05a98594d8c47cc07571d85f0f8767422d4396fc46bc06dc23392dcb1", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "42fb3549cd3a8b5469b3e1056312313d35a24b5162d0014ac72fb9e06e5c9883", "run_id": "r079", "schema_version": 1, "sequence": 483, "time_utc": "2026-08-01T08:41:42.754476Z"}
+{"agent_id": "/root/report_r077", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "de753cb773934cacd2c5f1c226f86041573a89ec5e004753e04252fa45a8c527", "run_id": "r077", "schema_version": 1, "sequence": 484, "time_utc": "2026-08-01T08:41:51.778939Z"}
+{"agent_id": "/root/report_r078", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "bf8f9a0cc3488f34c92615a5f6a5d1101b9c8be73fe146b00bf5423b756f8d62", "run_id": "r078", "schema_version": 1, "sequence": 485, "time_utc": "2026-08-01T08:42:00.869140Z"}
+{"agent_id": "/root/report_r077", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "99ae882e62ceb0795589e25f0471f6ba05b2c64379885f41b29d66e36fb4395f", "run_id": "r077", "schema_version": 1, "sequence": 486, "sha256": "97da47a4e35549f44b87ac49af91ea0e278d3722330f6f5106dd4ea5662f93b5", "time_utc": "2026-08-01T08:45:09.727753Z"}
+{"agent_id": "/root/report_r077", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "c1902328b8fe6b1d0998afe6d7ffe2ec1bba0dd77fae58c61c7f99b7c089e8db", "run_id": "r077", "schema_version": 1, "sequence": 487, "time_utc": "2026-08-01T08:45:09.729562Z"}
+{"agent_id": "/root/report_r077", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1000}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "d520ca83a167bf3acf704f662946d733f205edb4a9aac1c8d94754fe06d6c24e", "run_id": "r077", "schema_version": 1, "sequence": 488, "sha256": "5c927aebfbdd7b0c2213525642f94b9b2d634ddbe371c2de93761a8799809093", "time_utc": "2026-08-01T08:45:09.731358Z"}
+{"details": {"cell_id": "aaf0db751da7393ff60ded2b6d179fb7"}, "event": "cell_prepared", "phase": "collection", "previous_event_sha256": "0eec78aa85b7199979221c2a3c7985c41bbb9ed1d4e24040b5eb7e036c46cbeb", "run_id": "r080", "schema_version": 1, "sequence": 489, "sha256": "c38bec1ae14d5e4a1b4fca04400f2f3b1880a995870052b60549874378eb36a6", "time_utc": "2026-08-01T08:45:18.177368Z"}
+{"agent_id": "/root/report_r080", "attempt": 1, "details": {"fork_turns": "none", "model": "gpt-5.6-sol", "prompt_sha256": "1098ad460083cd96b2934f88661383788dbc995e07f3bc1a700e8efd01219a5f", "reasoning_effort": "ultra"}, "event": "agent_started", "phase": "collection", "previous_event_sha256": "488f5e7c892697fb1f95704c206f324916b391df269a1e81dd245b48bfefb650", "run_id": "r080", "schema_version": 1, "sequence": 490, "time_utc": "2026-08-01T08:45:49.503828Z"}
+{"agent_id": "/root/report_r079", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "cd8a1c9373172d938de677dcb30e9cbefb7d4b894f87561fa11520dd1731702a", "run_id": "r079", "schema_version": 1, "sequence": 491, "time_utc": "2026-08-01T08:45:56.342124Z"}
+{"agent_id": "/root/report_r078", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "fbdaabdf3d72dbee7cdf5b772b611cf8df827fe2a92c059464583d1ab84fb4d9", "run_id": "r078", "schema_version": 1, "sequence": 492, "sha256": "bdf344ee37b0f328d5c0d1bf7213aa67fa915434c400fa14151c8eabfb6abe8c", "time_utc": "2026-08-01T08:46:12.817578Z"}
+{"agent_id": "/root/report_r078", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "3bd5323b4582cac45bfdaedc0f1a6b71875ebc2fa7c8153a658df8c1f4fa5bb3", "run_id": "r078", "schema_version": 1, "sequence": 493, "time_utc": "2026-08-01T08:46:12.819461Z"}
+{"agent_id": "/root/report_r078", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1230}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "9155702c21bad81291bc916abaca8fcaf560bf9b3bceb8c2eef46d4171cb8aec", "run_id": "r078", "schema_version": 1, "sequence": 494, "sha256": "558ebe232a4e3fade4ffed4c1a4b61dc9c294c9ad3df86bcb8956dae957d2395", "time_utc": "2026-08-01T08:46:12.821561Z"}
+{"agent_id": "/root/report_r080", "attempt": 1, "details": {"text_sha256": "80ecb14005c4401b3db35f99feead6419a5337aed39f70cfb85987533f92847b"}, "event": "reminder_sent", "phase": "collection", "previous_event_sha256": "faf8ecb7f2fd757e20143cc405a2ce34317d5c2ecc9772aa7fe2d48e9cba48e8", "run_id": "r080", "schema_version": 1, "sequence": 495, "time_utc": "2026-08-01T08:49:05.111856Z"}
+{"agent_id": "/root/report_r079", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "5a462108fbd2619ca04e3d3d852660094cae769f5aae1717835e6d1ece26a09f", "run_id": "r079", "schema_version": 1, "sequence": 496, "sha256": "1d1050d8b8b6822c5d1dc90ab330bb2e02111cf2c8593fcbbc46f9e0f6a88e07", "time_utc": "2026-08-01T08:50:25.673007Z"}
+{"agent_id": "/root/report_r079", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "a7b741f735b39363933c80bfd97fe3f278ecc2ec0805ec01128543088d589ecd", "run_id": "r079", "schema_version": 1, "sequence": 497, "time_utc": "2026-08-01T08:50:25.674827Z"}
+{"agent_id": "/root/report_r079", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 913}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "fa365f9b0662384623240f825dcd0fa33ffd4cc66b979c873731997c2f6243b1", "run_id": "r079", "schema_version": 1, "sequence": 498, "sha256": "4e7c92b788756b1cdcf631f88281b74ffe439e5d5a47358f69c2cb84978d35c2", "time_utc": "2026-08-01T08:50:25.676451Z"}
+{"agent_id": "/root/report_r080", "attempt": 1, "details": {"disposition": "COMPLETE"}, "event": "attempt_preserved", "phase": "collection", "previous_event_sha256": "37b079f03692b7954cd5de2865445346b4fd35c1e8aa374bfdc2eefe1efe5723", "run_id": "r080", "schema_version": 1, "sequence": 499, "sha256": "68cd30e3597ca0d56d85323eb22512f71a56c417a685e7b21021292efd58dfb3", "time_utc": "2026-08-01T08:55:38.879546Z"}
+{"agent_id": "/root/report_r080", "attempt": 1, "details": {"api_state": "COMPLETED"}, "event": "agent_returned", "phase": "collection", "previous_event_sha256": "3790c6c24d6bba3a7696becb2b846dd146eeaaced390c028d64feefde4264201", "run_id": "r080", "schema_version": 1, "sequence": 500, "time_utc": "2026-08-01T08:55:38.881513Z"}
+{"agent_id": "/root/report_r080", "attempt": 1, "details": {"disposition": "COMPLETE", "operational_scope_deviation": false, "within_word_cap": true, "word_count": 1253}, "event": "report_preserved", "phase": "collection", "previous_event_sha256": "71e9da37f6ef594ccf80f04922909f9be76d388d8eddb282b43c35c335604c5d", "run_id": "r080", "schema_version": 1, "sequence": 501, "sha256": "c5f1e887706023c4ef50e285bbe0640c6b73f461ceda3bbeca8a63e143618042", "time_utc": "2026-08-01T08:55:38.883305Z"}
+{"details": {"report_count": 80}, "event": "collection_locked", "phase": "collection", "previous_event_sha256": "cfb591873437a1b1d68c9739e373a1a83ffc09d07e34e72e72709edeb9d55177", "schema_version": 1, "sequence": 502, "sha256": "4a4aa2ae5d8bbe98ca4e19a1d5cc1dc27a22b4d3a29900570327032767e41fb0", "time_utc": "2026-08-01T08:55:54.336517Z"}
+{"details": {"mode": "S", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "617080bb0e19fd536936e0b2a512bafb5f0a18e83c23514888c25ebdfd2340f7", "schema_version": 1, "sequence": 503, "sha256": "1fc3dc19c5117a863633a8765a518b34085d1cbedfa1f64d1d76be56f9d1c6fb", "time_utc": "2026-08-01T08:55:54.353736Z"}
+{"details": {"mode": "S", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "dbea9cdb91dcf89472d5b84556645ea1673ba8db972189cb3a0c56a8f14585a5", "schema_version": 1, "sequence": 504, "sha256": "c6134d6c46b60903fc78b0b8aa917ce6afedbb0a77e49df99c0e33eed71daaef", "time_utc": "2026-08-01T08:55:54.367321Z"}
+{"details": {"mode": "C", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "849284af8fec724a91c4654770037b467b8f8e5a4f8563aff02a1abb50147bae", "schema_version": 1, "sequence": 505, "sha256": "d62b94c908cf13f894b80f4308c7c2b836bd750cb59fd82916880b92ad92aec1", "time_utc": "2026-08-01T08:55:54.381186Z"}
+{"details": {"mode": "C", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "9cc59a9fb820321d700bfe9d52530a2a5ef3b8130eecde7a5cd67f9d574110ae", "schema_version": 1, "sequence": 506, "sha256": "6c234f3640a7089e254509dd3faa4c5b6682187771a7ddfaedae6c891f7cc529", "time_utc": "2026-08-01T08:55:54.394987Z"}
+{"details": {"mode": "X", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "86a7c7fff2710edb5359ab3a101d2f3d9564b6eee9ecb007e2900921758243aa", "schema_version": 1, "sequence": 507, "sha256": "4dc5b8859a57b4102344d6c4f189d3b3df075d1e695d4367ffb50b4cc4cfdf30", "time_utc": "2026-08-01T08:55:54.409147Z"}
+{"details": {"mode": "X", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "0be67ce1fca8692c153d73a4650ee0bd68efa37fe84fa2b65012236195e69381", "schema_version": 1, "sequence": 508, "sha256": "9e6a2a569eec510d53e30409640b78493aa07860b55fe3b8aa83286b5bd368e6", "time_utc": "2026-08-01T08:55:54.423432Z"}
+{"details": {"mode": "Q", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "7fd945e86f845898835196ca5b6fe7dfb43709fb37dc79a3d3c0829ad47c8a4a", "schema_version": 1, "sequence": 509, "sha256": "81be9bbbd81eb289ec3abb82d1a7c844dbc03418d163cb20851a132d06863370", "time_utc": "2026-08-01T08:55:54.436256Z"}
+{"details": {"mode": "Q", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "ec3121b4c013b55e6ddbc0da476acd4f03791a87aae0a34967d9858d978b3841", "schema_version": 1, "sequence": 510, "sha256": "709430b82141429812cb381ccdc0b837492e8954a813aeff7675756fcedd543f", "time_utc": "2026-08-01T08:55:54.449031Z"}
+{"details": {"mode": "W", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "b6ee65d00634998ec70bef60a9908e77deb0163a6eb867676c74d947b00af627", "schema_version": 1, "sequence": 511, "sha256": "e05121cd7ffb1c448e341e4c54409a670c9ef91ecb55c1716a0872bdaad41209", "time_utc": "2026-08-01T08:55:54.461212Z"}
+{"details": {"mode": "W", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "cf6c420f560016946c5b08dd0b1dafe3de19eed794e242e3bb95f5ff25637011", "schema_version": 1, "sequence": 512, "sha256": "6be0a1858e8d8e793f433e29d23077700610f544f1de6c688aacea100e5e0d50", "time_utc": "2026-08-01T08:55:54.473524Z"}
+{"details": {"mode": "M", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "9e6407c6be9d697d06f8cf5ee9c5ccc19533646f706a9f8972dae7cb8c63582b", "schema_version": 1, "sequence": 513, "sha256": "aa205731259f019006ead7b7805b70c1eebfe185bcd29abf0f7d8db9b3b063a2", "time_utc": "2026-08-01T08:55:54.486679Z"}
+{"details": {"mode": "M", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "4c90a55d57f8d5d05d3edcb956c6058db7837bc1eb410fb5d65d3fa57c5db4b0", "schema_version": 1, "sequence": 514, "sha256": "cc67019041bbcab78a884f17af70676a92a48286b48014f25a06b40b623fe73b", "time_utc": "2026-08-01T08:55:54.499922Z"}
+{"details": {"mode": "R", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "5d2124cb1e0325555787ff9d0dfc289200658e53a3d61f2efb14baf8845c284a", "schema_version": 1, "sequence": 515, "sha256": "91e06f36197e6786c17b7a35834afdeec5bfbbcf9b5bbce713915c08134dbd55", "time_utc": "2026-08-01T08:55:54.511796Z"}
+{"details": {"mode": "R", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "84a6160233e01550bf38725b16ee232722f289f29f0afae9d09ce8b830ccf4eb", "schema_version": 1, "sequence": 516, "sha256": "ca4bf78384d8e72d4ed23f456ba6d69a7f9ce6ce0b331bf57e1d4a49fbae1781", "time_utc": "2026-08-01T08:55:54.523754Z"}
+{"details": {"mode": "K", "scorer": "s1"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "528cca72b69251bcf82ce2f30ead33e4bcaf9945eaf76902154f2c57b87d1394", "schema_version": 1, "sequence": 517, "sha256": "44f5e13172a46d4187f81c10291b335ddcd926230d3aa0dc665c8c4de53784db", "time_utc": "2026-08-01T08:55:54.535455Z"}
+{"details": {"mode": "K", "scorer": "s2"}, "event": "blind_packet_preserved", "phase": "scoring", "previous_event_sha256": "2617dcf854d9707b44ea8fe6d48b1a651e8a4891a14a7fcbcb48d3ad9970a338", "schema_version": 1, "sequence": 518, "sha256": "2085a1b039e524372fdebb483fc62ea2256254692552a76725bc193bb8dd6234", "time_utc": "2026-08-01T08:55:54.547184Z"}
+{"details": {"packet_count": 16}, "event": "blind_packets_built", "phase": "scoring", "previous_event_sha256": "869807c1d75097ef187d61d234ce672ee90633080a255d39c2c1d276c1251f82", "schema_version": 1, "sequence": 519, "sha256": "aa702046b8997b2157abf187834564db1f3abc5a4d92d7c7da5760da173704e9", "time_utc": "2026-08-01T08:55:54.549191Z"}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/PACKET.json
new file mode 100644
index 0000000000..06ebd8896b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "C",
+  "presentation_order": [
+    "H",
+    "F",
+    "J",
+    "C",
+    "B",
+    "A",
+    "I",
+    "G",
+    "E",
+    "D"
+  ],
+  "report_sha256": {
+    "A": "3a3fe93cf06b9c2158f5159a07f1f3703e2d6b9c8a30e34fbc523636f1e911b1",
+    "B": "fa577430bed94ddb3e38f175a233a7494c016b6a63a3b3ce5113fe5c433140df",
+    "C": "1409aa1649cd9e0950368deb23ade05351c03b9ab89a32e637514b9d43293e22",
+    "D": "4e7c92b788756b1cdcf631f88281b74ffe439e5d5a47358f69c2cb84978d35c2",
+    "E": "5c927aebfbdd7b0c2213525642f94b9b2d634ddbe371c2de93761a8799809093",
+    "F": "4d0cdd801e8141b99cc8248d4bdfa4e04db33b09bfd7984cb5d780318e5d2edd",
+    "G": "78953c2a86ff27a79669c044278b47b0cb996b7bf6a47ca72e92fd5ec643ee43",
+    "H": "6d839af7da1f3cf8f5de096c33c36a103337baf53057022f7adf806aec6f1594",
+    "I": "2eacff962730a259104f7a8cddafad623a47a519182a5e9e441f49e77fd0bdef",
+    "J": "787f990b31be3392ae20e4b16e9c1f20785006bf90464beb7a352a0b395956ad"
+  },
+  "rubric_sha256": "3953c17ad001ee677061118952a5ac4fae44e21cc1ed1d64a0a0b2ae41c0049c",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/RUBRIC.md
new file mode 100644
index 0000000000..cb18a8c259
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/RUBRIC.md
@@ -0,0 +1,128 @@
+# Mode C Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## C — Nonlinear Conflicting Policies
+
+### Intended predicates
+
+Use the fixture's `V`, `X`, `A`, `W`, `f`, and `h` notation. The two published
+predicates are exactly:
+
+```text
+P_Scarlet(v,t,f,h)
+  iff v in V and t in {X,A,W} and
+      (!f
+       or (f and t = X and (!h or v >= 1.85.0))
+       or (f and t = A and h)).
+
+P_Indigo(v,t,f,h)
+  iff v in V and t in {X,A,W} and
+      (!f
+       or (f and t = X and (h or v >= 1.86.0))
+       or (f and t = A and !h and v >= 1.85.0)).
+```
+
+Neither predicate contains the other. Representative disputed cases include:
+
+- Scarlet-only: `(1.84.0, X, turbo, !hardened)` and
+  `(1.84.0, A, turbo, hardened)`;
+- Indigo-only: `(1.84.0, X, turbo, hardened)` and
+  `(1.85.0, A, turbo, !hardened)`.
+
+There is no authorized exact project predicate. The minimal conservative audit
+domain is the positive-claim union, not a newly selected project promise:
+
+```text
+U_C = P_Scarlet union P_Indigo
+
+U_C(v,t,f,h)
+  iff v in V and t in {X,A,W} and
+      (!f
+       or (f and t = X)
+       or (f and t = A and (h or v >= 1.85.0))).
+```
+
+Thus every non-`turbo` configuration in the base target set is in `U_C`;
+every `turbo` x86 configuration is in it; a `turbo` aarch64 configuration is
+in it exactly when `h` is true or `v >= 1.85.0`; and no `turbo` wasm32
+configuration is in it.
+
+For the conservative source theorem, include every valid `Option<u8>` input,
+every Cargo profile, and both debug-assertion states:
+
+```text
+Required_C = U_C cross O_S cross P cross D.
+```
+
+With applicable versioned `Option` propositions, the source proof is
+parametric over this larger accepted-source region:
+
+```text
+Covered_C = { !f on X/A/W, or f on X/A } cross O_S cross P cross D.
+```
+
+`h` and the exact version do not affect the source derivation. Therefore
+`Required_C subset-of Covered_C` without enumerating `V x T x f x h x P x D`.
+
+### Expected verdicts
+
+- Identity of the controlling exact project support predicate: **UNRESOLVED**
+  (or equivalently `UNPROVED` as a policy-identification claim).
+- Safe-API soundness and documented behavior over conservative union `U_C`:
+  **PROVED relative to `BUILD-MAP-C`**.
+- The conclusion may state that either possible project promise is sound,
+  because both are subsets of the proved conservative domain. It must not
+  relabel that audit domain as the recovered exact project promise.
+- `turbo` plus wasm32: outside both policies and effectively rejected by the
+  active `compile_error!` configuration, **PROVED relative to `BUILD-MAP-C`**.
+
+The non-`turbo` path uses the documented safe `unwrap_or`. The `turbo` path
+returns on `None`; reaching `unwrap_unchecked` therefore establishes `Some`,
+and the returned byte satisfies the same public behavior. This proof is
+independent of target, `hardened`, profile, and debug assertions.
+
+### Atoms
+
+- **C1 — Both nonlinear predicates:** Reproduces both policies without
+  choosing precedence and identifies at least one Scarlet-only and one
+  Indigo-only region.
+- **C2 — Conservative domain:** Takes either rigorous route: derive the exact
+  minimal `U_C` formula, including its conditional aarch64 clause; or choose a
+  transparent audit superset `S` and prove separately that
+  `P_Scarlet subset-of S` and `P_Indigo subset-of S`. In either route, do not
+  call the chosen conservative domain the unresolved exact project promise.
+- **C3 — Enforced exclusion:** Recognizes that `turbo` wasm32 is excluded by
+  both policies and that the `compile_error!` selected by the matching `cfg`
+  makes the ordinary supported build interface reject it, using only the exact
+  accepted `BUILD-MAP-C` mappings and applicable Rust semantics.
+- **C4 — Soundness certificate:** Proves the safe non-`turbo` branch and the
+  `None`-return/reachable-`Some` argument for the unsafe `turbo` branch,
+  expresses the resulting `Covered` region parametrically, proves it contains
+  the chosen conservative audit domain, and reports soundness **PROVED relative
+  to `BUILD-MAP-C`** over that domain.
+- **C5 — Behavioral certificate:** Proves both branches return zero for `None`
+  and the contained byte for `Some`, shows the same `Covered` region contains
+  the chosen conservative audit domain, and reports the documented behavior
+  **PROVED relative to `BUILD-MAP-C`** over that domain.
+- **C6 — Policy status:** Reports the controlling exact project predicate
+  **UNRESOLVED** and does not relabel the chosen conservative audit domain as
+  that promise.
+
+### Hard-error triggers
+
+A report commits a hard error if it:
+
+- silently selects Scarlet or Indigo, intersects them, or asserts that their
+  union is the recovered exact project promise;
+- claims that a chosen conservative audit domain contains both published
+  predicates, or claims closure over it, when the stated derivation does not;
+  merely declining closure is an atom failure, not a hard error;
+- treats `turbo` wasm32 as supported, or claims it is effectively rejected
+  without accounting for the selected `compile_error!`;
+- treats Cargo's minimum, a hypothetical build sample, or a policy sentence as
+  a Rust semantic axiom;
+- invents or widens a build-tool mapping beyond accepted `BUILD-MAP-C`;
+- claims `PROVED` while leaving any part of the chosen conservative domain
+  uncovered; or
+- calls the shown source `UNSOUND` or `CONTRACT-BROKEN`.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/allowlist.txt
new file mode 100644
index 0000000000..b65efda7ef
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/allowlist.txt
@@ -0,0 +1,18 @@
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or
+https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html
+https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html
+https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/A.md
new file mode 100644
index 0000000000..9f44f99ced
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/A.md
@@ -0,0 +1,56 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+For the supplied `Cargo.toml` and `src/lib.rs`, every well-typed safe call to `value_or_zero` in every configuration supported by **either** current policy is free of Rust undefined behavior and returns the contained byte for `Some(byte)`, or zero for `None`. This is a source-level claim for Rust/stdlib 1.84.0, 1.85.0, and 1.86.0, relative to the conspicuous accepted premise `BUILD-MAP-C` below.
+
+- **Soundness: PROVED** over the conservative union `U` defined below.
+- **Documented return postcondition: PROVED** over `U`.
+- **Combined mandatory result: PROVED** over `U`, relative to `BUILD-MAP-C` and the version-matched Rust axioms cited below.
+- **Exact project support-policy identity: UNPROVED.** Scarlet and Indigo conflict and no authority selects either. This does not block the source theorem because `U` contains every configuration promised by either policy; calling `U` the audit domain does not create a new support commitment.
+- No `UNSOUND` or `CONTRACT-BROKEN` witness exists in the inspected source.
+
+Audit date: 2026-08-01. No build, execution, test, expansion, prior audit, dependency, generated artifact, or binary/backend claim was used. The crate is edition 2021, `no_std`, has no dependencies, and has only the two declared Boolean features.
+
+## Configuration closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `X=x86_64-unknown-linux-gnu`, `A=aarch64-unknown-linux-gnu`, `W=wasm32-unknown-unknown`, and `f`,`h` denote `turbo`,`hardened`. The exact conservative audit domain `U = Scarlet ∪ Indigo` is:
+
+| Case | Members of `U` |
+|---|---|
+| `!f` | every `v∈V`, `t∈{X,A,W}`, and either `h` |
+| `f, t=X` | every `v∈V` and either `h` |
+| `f, t=A, h` | every `v∈V` |
+| `f, t=A, !h` | `v∈{1.85.0,1.86.0}` |
+| `f, t=W` | none |
+
+This is an exhaustive Boolean simplification of the two published predicates. All profiles and debug-assertion states are covered parametrically: neither selects or changes any audited expression. `h` likewise selects no source. Version and non-`W` target do not change either function body.
+
+For each exact release, the Reference says an `all` predicate is true when all its predicates are true and a `cfg` attribute retains its item on true and removes it on false: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Together with `BUILD-MAP-C`, `f && t=W` retains `compile_error!`; the version-matched macro contract says it causes compilation to fail: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Thus the expressly unsupported `turbo+W` combination is effectively rejected for every `v`, `h`, profile, and debug-assertion state; no library artifact reaches the unsafe branch there.
+
+## Boundary, invariants, and obligation ledger
+
+The sole language-reachable crate API is the safe free function `value_or_zero(Option<u8>) -> u8`. Mutually exclusive `#[cfg(not(feature="turbo"))]` and `#[cfg(feature="turbo")]` definitions make exactly one body present. There are no public fields/types/statics, unsafe APIs/traits/impls, callbacks, FFI, exported macros, hidden items, reexports, constructors, generated APIs, or custom destruction. There is no persistent representation invariant.
+
+| ID | Site and exact obligation | Derivation | Status |
+|---|---|---|---|
+| O1 | safe API has no hidden safety precondition | The input is an owned, valid `Option<u8>`; the fallback uses only safe `unwrap_or`, and the turbo unsafe precondition is discharged by O2. | PROVED on `U` |
+| O2 | `unwrap_unchecked` must not receive `None` | On the only path reaching it, `value.is_none()` was false because the true branch returned. `is_none` identifies `None`; therefore this two-variant value is `Some`. No intervening mutation or call occurs before the owned value is consumed. | PROVED for every `f` artifact in `U` |
+| O3 | documented return value | If `!f`, `unwrap_or(0)` returns the contained `Some` value or default zero. If `f`, `None` returns zero; otherwise O2 permits `unwrap_unchecked`, which returns the contained `Some` value. | PROVED on `U` |
+| O4 | configuration selection/rejection | Versioned `cfg` rules plus accepted `BUILD-MAP-C`; derivation above. | PROVED for the three releases/targets only |
+
+The three standard-library versions have identical material contracts: `is_none` “Returns true if the option is a `None` value”; `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is undefined behavior; `unwrap_or` returns the contained `Some` value or the supplied default. Version-matched sources: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+The adjacent `SAFETY` comment states the decisive dominating branch fact and is correct. A more contract-explicit replacement would be: “`Option::unwrap_unchecked` requires `self` not be `None`. `is_none()` was false on this path because the true branch returned, so `value` is `Some` and satisfies that requirement; the call returns its contained byte.” This is documentation hardening, not a soundness finding.
+
+## TCB audit log
+
+**`BUILD-MAP-C` is accepted and consumed only for O4.** Its exact scope is the bundled Cargo for Rust 1.84.0/1.85.0/1.86.0, the supplied manifest/source, all supported profiles, the two named feature-to-`cfg` mappings, and the three named target-to-`target_arch` mappings. It admits no Rust semantics, branch correctness, other version, or backend/binary correctness. Human disposition: accepted. Re-audit on any identity, feature, target, manifest/source cfg, or disposition change.
+
+The remaining entries are version-matched `AXIOM`s: the cited Option contracts, conditional-compilation rules, and `compile_error!` contract. No dependency, implementation, external, deployment, probabilistic, or tool premise is consumed. TCB identity is the supplied `TCB.md` snapshot; no broader trust was inferred.
+
+## Residual scope and triggers
+
+Which published policy governs remains deliberately unresolved. Configurations outside `U`, compiler/backend correctness, successful compilation of supported non-rejected cases, and binary behavior are not claimed. Re-audit on source/manifest or policy resolution/change; expansion of versions, targets, features, profiles, or build inputs; change to `BUILD-MAP-C`; or material change to any cited versioned contract.
+
+All in-scope unsafe operations, safe surfaces, postconditions, configurations in `U`, and consumed premises have a disposition. No tool-derived evidence was used.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/B.md
new file mode 100644
index 0000000000..734a88aacd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/B.md
@@ -0,0 +1,69 @@
+# Source-only unsafe-code audit
+
+## Claim and verdict
+
+**Snapshot.** The complete supplied target: `Cargo.toml`, `src/lib.rs`, both policy files, `TCB.md`, and `REQUEST.md`. It is a `no_std`, edition-2021 library with no dependencies, build script, generated code, macros exported by the crate, or prior audit. Review date: 2026-08-01. No build, execution, expansion, or test evidence was used.
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let `f,h` be the two feature states. Define the **conservative audit domain**, not a newly selected support policy:
+
+`C = V × T × {f=false,true} × {h=false,true} × all Cargo profiles × both debug-assertion states`, restricted by `!(f && t=W)`.
+
+`C` contains the union of Scarlet and Indigo. It additionally contains source-admitted cases neither policy promises (notably `(1.84.0,A,f=true,h=false)`), so proving `C` avoids choosing between the conflicting commitments.
+
+- **Source-level Rust soundness: PROVED** for every library artifact in `C` and every well-typed safe call to `value_or_zero`, relative to the TCB below.
+- **Documented postcondition: PROVED** throughout `C`: `Some(b)` returns `b`; `None` returns `0`.
+- **Combined mandatory result: PROVED** for every configuration supported by Scarlet **or** Indigo. Which policy is authoritative remains unresolved, but does not limit this theorem because both are subsets of `C`.
+- `f && t=W` is effectively rejected before an artifact is produced and is expressly unsupported by both policies. No verdict is asserted for a nonexistent library artifact.
+- No compiler-backend, binary, deployment, or future-Rust claim is made.
+
+## Boundary, configuration, and invariant coverage
+
+The sole crate-defined public surface is safe `pub fn value_or_zero(Option<u8>) -> u8`. Its two definitions are selected exclusively by `f`; there are no public fields/types, unsafe APIs/traits/impls, callbacks, FFI, concurrency, allocators, or destruction invariants. The only unsafe operation is the turbo definition's `Option::unwrap_unchecked` call.
+
+For each version, the Reference says a false `cfg` predicate removes the attributed thing; the true case removes the attribute. Its predicate rules give the ordinary `all`/`not` evaluation used here ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute)). With accepted `BUILD-MAP-C`, exactly one function body remains: non-turbo when `f=false`, turbo when `f=true`. When `f && t=W`, the `compile_error!` item remains; each matched standard-library page says it “Causes compilation to fail with the given error message when encountered” ([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). Thus all policy-excluded wasm-turbo combinations are rejected.
+
+`h`, profile, and debug assertions select no source and affect no arithmetic, panic, layout, or unsafe premise. Target affects only the rejection above. Consequently the body proofs are parametric over those axes and exhaustive over `C`.
+
+**INV-SOME.** In the turbo body, on reaching `unwrap_unchecked`, the unchanged local `value` is not `None`. Its owner is that function activation; `is_none` establishes the branch fact through a shared borrow, the early return discharges the `None` case, and `unwrap_unchecked` immediately consumes the fact.
+
+## Obligation ledger and proofs
+
+| ID | Obligation and derivation | Domain | Status |
+|---|---|---|---|
+| CFG-1 | Exclusive bodies and wasm rejection, derived above from version-matched cfg/compile-error rules plus `BUILD-MAP-C`. | `C` and rejected `f,W` cases | PROVED |
+| SAFE-1 | With `f=false`, `unwrap_or(0)` is safe and its documented behavior returns the contained `Some` value or the supplied default. | all non-turbo `C` | PROVED |
+| UNSAFE-1 | With `f=true`, `is_none()==true` returns `0`. Otherwise, `INV-SOME` holds. Version-matched docs state “Returns `true` if the option is a `None` value” and “Calling this method on `None` is undefined behavior”; contraposition of the first discharges the second operation's sole safety condition. `unwrap_unchecked` then returns the contained `Some` byte. | turbo `C` (therefore only `X,A`) | PROVED |
+| POST-1 | `None` reaches `0`; `Some(b)` reaches `b`, by `unwrap_or` or the checked turbo partition. These cases exhaust `Option<u8>`. | all `C` | PROVED |
+
+Version-matched Option contracts (including the `unwrap_or` and `unwrap_unchecked` result clauses): [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+## TCB audit log
+
+**TCB identity:** supplied `TCB.md` plus the versioned authoritative axioms listed here.
+
+| ID/category | Exact admitted proposition; scope; disposition | Consumer / trigger |
+|---|---|---|
+| `BUILD-MAP-C` / accepted build-tool premise | Only the exact Cargo-to-`feature` and target-to-`target_arch` mappings stated in `TCB.md`, for bundled 1.84/1.85/1.86 Cargo and the supplied manifest/source. **It admits no Rust semantics, branch correctness, other-version compatibility, or backend correctness.** | CFG-1; every trigger listed in `TCB.md` |
+| `AXIOM-OPT-{84,85,86}` / Rust std | Exact method propositions on the nine version-matched Option links above. Verified, authoritative. | SAFE-1, UNSAFE-1, POST-1; Rust version/docs change |
+| `AXIOM-CFG-{84,85,86}` / Rust Reference+std | Exact cfg effects/predicate semantics and `compile_error!` effect on the six version-matched links above. Verified, authoritative. | CFG-1; Rust version/docs or source cfg change |
+
+There are no dependency, implementation, external-specification, environment, probabilistic, or tool-result premises. `BUILD-MAP-C` is applied only to its authorized consumers. No rejected or pending premise is consumed.
+
+## Finding DOC-1 — local proof comment is deficient
+
+**Implementation:** PROVED; **proof artifact:** deficient. The comment says the `None` case returned and concludes `Some`, but omits the material links: `is_none`'s result contract, preservation of `value` across its shared borrow, the exact `unwrap_unchecked` safety clause, and its consumed result guarantee. No UB witness or defined postcondition refutation exists.
+
+Proposed adjacent replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`; that branch returned.
+// It only shared-borrowed `value`, so this unchanged value is not `None`.
+// This satisfies `unwrap_unchecked`'s safety condition; it returns the
+// contained `Some` byte, preserving this function's postcondition.
+```
+
+Minimum resolution is documentation-only; changing behavior or contracts would require a fresh audit.
+
+## Residual scope and re-audit triggers
+
+The unresolved policy precedence is residual governance scope, not uncovered soundness scope. Re-audit on any source/manifest/policy/TCB change; expansion of versions, targets, features, profiles with code-affecting behavior, or accepted configurations; material changes to cited Rust documentation; or addition of dependencies, generated code, FFI, concurrency, or other unsafe operations. Every in-scope operation, safe surface, configuration class, mandatory postcondition, citation, and consumed TCB entry has a disposition; no conclusion relies on testing or absence of a counterexample.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/C.md
new file mode 100644
index 0000000000..4cbfc96a7a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/C.md
@@ -0,0 +1,141 @@
+# Unsafe Rust source audit
+
+## Claim and verdicts
+
+The audited artifact is exactly the supplied `Cargo.toml`, `src/lib.rs`, two
+published policies, and `TCB.md`; no repository identity is asserted. For every
+well-typed safe call to `value_or_zero` in every configuration in `Required`
+below, under Rust's documented source semantics and relative only to the TCB
+listed below:
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Freedom from Rust undefined behavior | **PROVED** | OBL-1--4 and `Required ⊆ Covered` |
+| Documented result: contained byte for `Some`, zero for `None` | **PROVED** | OBL-2--4 |
+| One resolved project support predicate | **UNPROVED** | Scarlet and Indigo conflict and no resolution is authorized |
+
+The strongest non-policy-selecting conclusion is therefore source soundness
+and the stated behavior over the conservative union of both commitments. This
+does not resolve or redefine the project's support promise. No backend,
+binary, compiler-implementation, performance, or other robustness claim is
+made.
+
+## Snapshot, boundary, and inventory
+
+The crate is edition 2021, `no_std`, has no dependencies or generators, and
+declares independent `turbo` and `hardened` features. Rust/stdlib versions are
+exactly 1.84.0, 1.85.0, and 1.86.0. The complete language-reachable crate-owned
+surface is one safe public free function, with mutually exclusive
+`#[cfg(not(feature = "turbo"))]` and `#[cfg(feature = "turbo")]` definitions.
+There are no fields, constructors, traits/impls, callbacks, FFI, statics,
+reexports, hidden items, exported macros, generated APIs, or owned invariants.
+The only unsafe operation is the turbo definition's
+`Option<u8>::unwrap_unchecked`. The `compile_error!` invocation is an internal
+configuration-rejection site.
+
+## Required-domain recovery and effective rejection
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}`, and let `f,h` have the meanings in
+the policies. Preserve the controlling predicates:
+
+```text
+I = !f or (f and t=X and (h or v>=1.86.0))
+         or (f and t=A and !h and v>=1.85.0)
+S = !f or (f and t=X and (!h or v>=1.85.0))
+         or (f and t=A and h)
+```
+
+With the shared `v∈V`, `t∈T`, Boolean `f,h`, all profiles, and both debug-
+assertion states, choose only the conservative audit predicate
+`Required = I ∪ S`. Exact normalization gives:
+
+```text
+Required = !f or (f and t=X)
+              or (f and t=A and (h or v>=1.85.0)).
+```
+
+Proof of equality: `!f` is common; neither policy admits `f∧t=W`; for `f∧t=X`,
+Indigo admits `h` at 1.84 while Scarlet admits `!h`, Scarlet admits both states
+from 1.85, and both admit both at 1.86; for `f∧t=A`, Scarlet admits `h` at every
+version and Indigo adds `!h` exactly from 1.85. Thus both `I⊆Required` and
+`S⊆Required`, without selecting either policy.
+
+BUILD-MAP-C establishes, only for the three versions, named targets, features,
+and profiles, that Cargo features and `target_arch` set the corresponding cfgs.
+The version-matched Reference says a true cfg predicate includes its item and a
+false one removes it ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute));
+`compile_error!` causes compilation to fail when encountered
+([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+[1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+[1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). Therefore
+every `f∧t=W` case is effectively rejected before a library artifact can ship,
+in every profile/debug-assertion state. Both policies already exclude those
+cases; the proof does not silently enlarge either promise. No other policy
+exclusion is source-enforced, nor is enforcement needed for this union proof.
+
+## Obligation ledger and derivations
+
+| ID | Proposition and proof | Domain | Status |
+|---|---|---|---|
+| OBL-1 | cfg selection/rejection has the behavior above, from version-matched cfg and macro axioms plus BUILD-MAP-C | all policy axes | PROVED |
+| OBL-2 | Non-turbo `unwrap_or(0)` returns the `Some` byte or `0` for `None` | `Required∧!f` | PROVED |
+| OBL-3 | At `unwrap_unchecked`, `value` is not `None`; the dominating `is_none()` true branch returned, and `Option` has only `None` and `Some` | `Required∧f` | PROVED |
+| OBL-4 | The unchecked call returns the contained byte; combining OBL-2/3 proves the public postcondition | all `Required` | PROVED |
+
+For each exact release, `is_none` “returns true” for `None`,
+`unwrap_unchecked` returns the contained `Some` value and calling it on `None`
+is undefined behavior, and `unwrap_or` returns the contained value or supplied
+default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or);
+[1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or);
+[1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+These are an exhaustive release partition, not compatibility extrapolation.
+
+For `f=false`, OBL-2 applies parametrically to every target, `h`, profile, and
+assertion state. For `f=true`, OBL-3/4 do likewise wherever `Required` admits
+X or A. The source has no arithmetic, assertions, target-dependent unsafe
+semantics, or other branches affected by remaining axes. Hence aggregate
+`Covered = Required`, proving `Required ⊆ Covered`.
+
+## TCB audit log
+
+- **BUILD-MAP-C — IMPLEMENTATION/build-tool mapping, accepted.** Exact
+  proposition, identities, consumers, exclusions, and triggers are those in
+  supplied `TCB.md`. It is consumed only by OBL-1 and domain reachability. It
+  supplies no Rust semantic or branch-correctness fact.
+- **AX-OPT-184/185/186 and AX-CFG-184/185/186 — AXIOM.** Exact propositions are
+  the narrow versioned Rust documentation statements cited above; consumers
+  are OBL-1--4. Applicability is one named release each.
+
+No other trust, dependency, tool result, test, or execution evidence is used.
+
+## Findings and residual scope
+
+**DOC-1 — deficient adjacent proof, implementation still proved.** The current
+comment states the crucial control-flow fact but does not name the unchecked
+operation's exact precondition. Suggested replacement:
+
+```rust
+// SAFETY: `unwrap_unchecked` requires `value` not be `None`.
+// `is_none()` is true exactly for `None`; that branch returned, so here
+// `value` is `Some(_)`.
+```
+
+**POLICY-1 — unresolved support identity.** The smallest missing proposition is
+an authorized rule selecting, superseding, or reconciling Scarlet and Indigo.
+This blocks a claim about the one true project promise, but not the proved
+conservative-union source theorem.
+
+No target was built, run, tested, or macro-expanded. Custom targets, other Rust
+versions, backend/binary correctness, and configurations outside both policies
+are excluded. Re-audit on any source, manifest, policy/resolution, TCB
+disposition/mapping, supported version/target/feature/profile, or cited Rust
+contract change. Every in-scope surface, obligation, postcondition, premise,
+and unresolved claim has a disposition above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/D.md
new file mode 100644
index 0000000000..827c0761a1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/D.md
@@ -0,0 +1,54 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Soundness: PROVED. Documented behavior: PROVED. Combined mandatory result: PROVED.** For the exact supplied crate source, every well-typed safe call to the configuration-selected `value_or_zero` is free from Rust undefined behavior and returns the contained byte for `Some(byte)` and `0` for `None`, for every configuration supported by **either** current policy, relative only to the TCB stated below.
+
+This is a source-level Rust-abstract-semantics result, not a compiler/backend or binary-correctness claim. It does not choose between Scarlet and Indigo or declare their union to be project policy. Rather, one proof covers the conservative union, so each candidate policy's complete domain is covered despite the unresolved governance conflict.
+
+## Snapshot, scope, and surfaces
+
+Audited material is the supplied `Cargo.toml`, `src/lib.rs`, both policy files, and `TCB.md`; package `conflicting-domain-target` 0.1.0, edition 2021, Rust/standard-library versions exactly 1.84.0, 1.85.0, and 1.86.0. There are no dependencies, build scripts, supplied generated artifacts, FFI, assembly, concurrency, allocator code, invariant-bearing representation, unsafe declarations/traits/impls/fields, callbacks, or hidden/macro-generated public APIs. No prior audit, expansion, build, test, or tool result was used.
+
+The complete crate-owned API surface is one safe public free function, represented by two mutually exclusive `cfg(feature = "turbo")` definitions with the same signature and documented result. The complete unsafe surface is the turbo definition's single call to `Option::unwrap_unchecked`. The only other macro site is the configuration-rejection `compile_error!`.
+
+## Configuration closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, targets `X`, `A`, and `W` have the policy meanings, and `f`/`h` denote `turbo`/`hardened`. Without resolving policy precedence, the conservative candidate domain is `U = Indigo ∪ Scarlet`, equivalently (under the common version/target universe):
+
+```text
+!f or (f and t = X) or (f and t = A and (h or v >= 1.85.0))
+```
+
+Both `h` states, all policy-supported Cargo profiles, and both debug-assertion states are included. `h`, profile, and debug assertions do not occur in either function body, so the proofs are parametric over them. Target and version affect no body; version-matched Option contracts below cover each version. The cases `!f` and `f` exhaust `U`.
+
+The versioned References define `all` by conjunction and say `cfg` “conditionally includes the thing it is attached to based on a configuration predicate”: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute); [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute); [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Each version's `compile_error!` contract says it causes compilation to fail with the given message when encountered: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+
+Therefore, using `BUILD-MAP-C`, `f && t=W` includes and encounters `compile_error!`, so it produces no shippable library artifact. Both policies already expressly exclude that region. When `f` is false exactly the non-turbo definition is included; when true exactly the turbo definition is included.
+
+## Authoritative Option premises
+
+For each exact version, the standard-library page says `is_none` “Returns `true` if the option is a `None` value”; `unwrap_unchecked` returns the contained `Some` value and its Safety section says calling it on `None` is undefined behavior; `unwrap_or` returns the contained value or supplied default: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+## Obligation ledger and derivations
+
+- **O-NORMAL (all `U` with `!f`): PROVED.** `unwrap_or(0)` is safe and, by its exact version's contract, returns the byte for `Some(byte)` and `0` for `None`. Thus both soundness and the function's documented result hold.
+- **O-TURBO-NONE (all `U` with `f`, input `None`): PROVED.** `is_none()` returns true, so the dominating branch returns `0`; the unsafe call is not executed.
+- **O-TURBO-SOME (all `U` with `f`, input `Some(byte)`): PROVED.** Reaching the unsafe call means `is_none()` returned false. By contraposition of its `None => true` contract, `value` is not `None`; because `Option` has only `None` and `Some`, it is `Some(byte)`. `is_none` only immutably borrows this owned local, and no operation intervenes, so the fact persists. This discharges `unwrap_unchecked`'s exact safety obligation; its postcondition yields `byte`.
+- **O-COVERAGE: PROVED.** `f` partitions `U`; the two `Option` variants partition every input; the four cases above cover all configurations and safe inputs. Target, `h`, profile, and debug-assertion axes do not alter the selected body or derivation.
+
+The adjacent `SAFETY` comment identifies the dominating `None` exit and exact resulting `Some` fact required by `unwrap_unchecked`; for this immediate control-flow/type derivation it is adequate. No caller-side safety condition is hidden.
+
+## TCB audit log
+
+**The only accepted non-Rust premise consumed is `BUILD-MAP-C` from the supplied `TCB.md`.** It admits, only for bundled Cargo corresponding exactly to Rust 1.84.0/1.85.0/1.86.0, the stated mapping from enabled `turbo`/`hardened` features to their `cfg` predicates and from the three exact target triples to `target_arch`. It is consumed only by branch reachability and effective rejection. It admits no Rust semantics, branch correctness, compatibility, backend, or binary proposition. Human disposition: accepted. Re-audit on any listed Cargo/toolchain identity, feature, target, manifest, source-`cfg`, or disposition change.
+
+The versioned Reference/std propositions cited above are authoritative Rust axioms, not extra implementation assumptions. No safe/unsafe dependency, compatibility, tool, external, deployment, or probabilistic premise is consumed.
+
+## Findings, residual scope, and triggers
+
+No implementation, soundness, postcondition, proof-documentation, Rust-documentation, or skill-guidance defect was established. The sole governance issue is that no unique exact project support predicate can be reported until Scarlet/Indigo precedence or supersession is authorized; it does not block the proved conservative-union theorem.
+
+Excluded from the verdict: toolchains or standard libraries outside `V`, targets outside `{X,A,W}`, custom build-tool mappings, configurations outside either policy, compiler/backend/binary correctness, and the rejected `f && W` region (which emits no library). Re-audit on source/manifest changes, policy resolution or scope changes, any consumed Rust-documentation semantic change, or any `BUILD-MAP-C` trigger.
+
+All in-scope unsafe, safe-boundary, behavior, configuration, citation, and TCB obligations have the dispositions above; no tests substitute for proof.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/E.md
new file mode 100644
index 0000000000..8e48eb09d5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/E.md
@@ -0,0 +1,68 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Combined result: PROVED.** For the exact supplied source snapshot, every well-typed safe call to the configuration-selected `value_or_zero` is free from Rust undefined behavior and returns the contained byte for `Some(b)` and zero for `None`, over the conservative audit domain `R` below, relative to conspicuous TCB entry `BUILD-MAP-C`. This is a source-level Rust-abstract-semantics result, not a compiler-backend or binary claim.
+
+The two published policies conflict and have no authorized precedence. This audit does **not** resolve that conflict or call `R` the project promise. Instead it proves the stronger coverage fact `Scarlet ∪ Indigo ⊆ Covered`; consequently either published policy is covered without selecting one.
+
+## Snapshot, scope, and surfaces
+
+Audited at 2026-08-01: all supplied target files; crate `conflicting-domain-target` 0.1.0, edition 2021, `rust-version = 1.84`, `no_std`, Rust/stdlib releases exactly `{1.84.0,1.85.0,1.86.0}`. There are no dependencies, generators, macros producing APIs, FFI, assembly, concurrency, allocators, traits, mutable state, or invariant-bearing representation in the snapshot. No build, test, execution, expansion, or prior result was used.
+
+The complete language-reachable crate API is one safe free function, `pub fn value_or_zero(Option<u8>) -> u8`, with mutually exclusive implementations: the safe `unwrap_or(0)` body when `turbo` is disabled (`src/lib.rs:7-10`), and the checked `unwrap_unchecked` body when enabled (`src/lib.rs:13-22`). There are no unsafe public APIs or caller safety obligations. The only unsafe operation is `Option::unwrap_unchecked` at line 22. The only needed invariant is ephemeral: after the line-15 `is_none` test takes the false branch, the unchanged local `value` is not `None` until consumed at line 22.
+
+## Configuration-domain recovery
+
+Let `V={1.84.0,1.85.0,1.86.0}`, targets `T={X,A,W}` as defined by the policies, and Boolean `f=turbo`, `h=hardened`. Profiles and debug-assertion states are universally quantified.
+
+Preserving the published predicates verbatim:
+
+```text
+S = !f || (f && t=X && (!h || v>=1.85.0)) || (f && t=A && h)
+I = !f || (f && t=X && (h || v>=1.86.0)) ||
+           (f && t=A && !h && v>=1.85.0)
+```
+
+With `v∈V,t∈T`, define the conservative audit domain:
+
+```text
+R = S ∪ I
+  = !f || (f && t=X) || (f && t=A && (h || v>=1.85.0)).
+```
+
+Equality follows by exhaustive symbolic target cases. For `W`, both policies permit exactly `!f`. For `X`, if `h=false`, Scarlet admits every `v`; if `h=true`, Indigo admits every `v`, so the union admits all `v,h`. For `A`, Scarlet admits all `h=true`, while Indigo admits `h=false` exactly at `v>=1.85.0`. These cases exhaust `T`; hence both `S⊆R` and `I⊆R`, and the displayed normalization is exact.
+
+Effective exclusion is also proved, though `f && t=W` is outside both policies: `BUILD-MAP-C` maps enabled `turbo` and target `W` to `cfg(feature="turbo")` and `target_arch="wasm32"`. Thus `all(...)` is true, the `cfg` attribute includes `compile_error!` (`src/lib.rs:3-4`), and compilation fails. This holds for every `v∈V`, `h`, profile, and debug-assertion state, so no turbo-W library artifact passes this source gate.
+
+## Versioned axioms and TCB
+
+For each exact release, the standard-library pages say `is_none` returns true when the option is `None`; `unwrap_unchecked` returns the contained `Some` value and calling it on `None` “is undefined behavior”; and `unwrap_or` returns the contained `Some` value or its supplied default:
+
+| Release | `is_none` | `unwrap_unchecked` | `unwrap_or` |
+|---|---|---|---|
+| 1.84.0 | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or) |
+| 1.85.0 | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or) |
+| 1.86.0 | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or) |
+
+For each release, configuration options are true exactly when set, `all` requires all operands, and `cfg` includes its item when true and removes it when false: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). `compile_error!` “causes compilation to fail ... when encountered”: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Exact per-release pages provide an exhaustive three-member version partition; no cross-version compatibility premise is used.
+
+**Accepted human trust decision — BUILD-MAP-C (`TCB.md`).** Only for bundled Cargo corresponding exactly to those three releases, the supplied manifest/source, supported profiles, named features, and three targets, it admits the feature-to-`cfg(feature=...)` and target-to-`target_arch` mappings. Consumers are solely branch reachability and rejection. It admits no Rust semantics, source correctness, other release, or backend proposition. Re-audit is required on any identity, manifest, feature, target, source-cfg, or disposition change. No other implementation premise is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Required proposition | Proof and covered cases | Status |
+|---|---|---|---|
+| O1 | Exactly the applicable body is included | Versioned `cfg` rules plus `BUILD-MAP-C`; `not(f)` and `f` are complementary. | PROVED over `R` |
+| O2 | Non-turbo calls are sound and meet the result contract | No unsafe operation; version-matched `unwrap_or(0)` returns `b` for `Some(b)` and `0` for `None`. Independent of `v,t,h`, profile, assertions. | PROVED for `R∧!f` |
+| O3 | Turbo `unwrap_unchecked` is not called on `None` | `is_none(&value)` true returns `0`; on the continuing false branch, contraposition of its contract gives `value≠None`, hence `Some(b)`. No intervening mutation/call occurs before `unwrap_unchecked(value)`. Its exact safety precondition holds. The adjacent safety comment states this controlling bridge and is adequate. | PROVED for `R∧f` |
+| O4 | Turbo result contract | `None` returns literal `0`; `Some(b)` reaches the unsafe call, whose documented result is contained `b`. | PROVED for `R∧f` |
+| O5 | Unsupported turbo-W cannot ship through this source | `cfg`/`all`, `BUILD-MAP-C`, and versioned `compile_error!` contract as derived above. | PROVED |
+
+For each required obligation, the `!f` and `f` cases cover `R`; O2 covers the former and O3/O4 the latter. O1 supplies selection for both. Thus aggregate `Covered=R`, proving `Required=R⊆Covered`. `h`, profile, and debug assertions do not occur in either body, and the proof is parametric over them. No sampled evidence is substituted for this closure.
+
+## Findings, residual scope, and triggers
+
+No `UNPROVED`, `UNSOUND`, `CONTRACT-BROKEN`, proof-documentation, authoritative-documentation, or skill-guidance finding remains in scope. There is no tool-derived evidence. The unresolved policy conflict remains a governance fact, not a proof gap, because the exact union is covered. Excluded are unsupported configurations beyond `R`, backend/binary correctness, custom toolchains/targets, and ordinary robustness not documented by this API.
+
+Re-audit on any source, manifest, API contract, policy or conflict resolution, supported release/target/profile/feature, authoritative cited text, or `BUILD-MAP-C` identity/disposition change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/F.md
new file mode 100644
index 0000000000..d66a42caab
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/F.md
@@ -0,0 +1,65 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+Snapshot: the supplied Cargo.toml, src/lib.rs, POLICY-SCARLET.md, POLICY-INDIGO.md, TCB.md, and REQUEST.md, reviewed source-only on 2026-08-01. There are no dependencies, build scripts, generated artifacts, macros generating APIs, or prior audits in scope.
+
+| Claim | Exact theorem | Verdict |
+|---|---|---|
+| SOUND | For every configuration in Required and every well-typed safe call value_or_zero(value), execution is free of Rust undefined behavior. | PROVED relative to BUILD-MAP-C and the version-matched Rust axioms below. |
+| POST | For those calls, Some(b) returns b and None returns 0. | PROVED. |
+
+Combined mandatory result: PROVED. This is a Rust source-semantics result, not a compiler-backend, binary, or platform theorem.
+
+## Required domain and configuration closure
+
+Let V={1.84.0,1.85.0,1.86.0}, T={X,A,W} as defined by the policies, f=turbo, h=hardened, P=all Cargo profiles, and d∈{debug-assertions-off,on}. Preserve the published predicates:
+
+S = ¬f ∨ (f∧t=X∧(¬h∨v≥1.85.0)) ∨ (f∧t=A∧h).
+
+I = ¬f ∨ (f∧t=X∧(h∨v≥1.86.0)) ∨ (f∧t=A∧¬h∧v≥1.85.0).
+
+Because neither policy has precedence, Required is the conservative audit predicate S∨I, with v∈V, t∈T, both Boolean feature states, p∈P, and d in both states. This is not a resolution or a new support promise. Exact case normalization gives:
+
+Required = ¬f ∨ (f∧t=X) ∨ (f∧t=A∧(h∨v≥1.85.0)).
+
+Proof: on X, (¬h∨v≥1.85)∨(h∨v≥1.86) is true for every h; on A, h∨(¬h∧v≥1.85) equals h∨v≥1.85; neither predicate admits f∧t=W. Thus S⊆Required, I⊆Required, and the reverse inclusion follows by the same target cases.
+
+Effective rejection is separately proved. BUILD-MAP-C maps f and target W to the corresponding cfg predicates. In each exact release, cfg(all(...)) is true exactly when both options are set, and a false cfg removes its item; [1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Each compile_error! page states that encountering it causes compilation to fail: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Therefore f∧t=W cannot yield this library. Required already excludes it; ¬f on W remains admitted and selects the safe implementation.
+
+The only actual axes are v,t,f,h,p,d and edition 2021. Hardened, profiles, and debug assertions do not occur in executable expressions; there is no arithmetic, allocation, panic-dependent cleanup, FFI, concurrency, target layout, or target instruction. The proof is parametric over h,p,d and over X/A, and separately covers ¬f on W. Exact per-release axioms avoid any cross-version compatibility premise. Aggregate Covered equals Required, hence Required⊆Covered.
+
+## Boundary, invariant, and obligation coverage
+
+The sole language-reachable project API is the safe public function value_or_zero(Option<u8>)->u8. Mutually exclusive cfg attributes select exactly one definition. There are no public fields, constructors of project types, traits or impls, statics, callbacks, reexports, hidden items, FFI, or custom destruction. No persistent invariant-bearing representation exists.
+
+A transient local fact, INV-SOME, is owned by the turbo function: after value.is_none() evaluates false, value is Some until immediately consumed. It is produced by the branch, never suspended or mutated, and consumed only by unwrap_unchecked.
+
+| ID | Obligation and derivation | Domain | Status |
+|---|---|---|---|
+| O-CFG | Select exactly one implementation; reject f∧W. cfg axioms plus BUILD-MAP-C establish this. | all policy candidates | PROVED |
+| O-SAFE | With ¬f, unwrap_or returns the Some payload or supplied default 0. | Required∧¬f | PROVED |
+| O-GUARD | is_none returns true exactly for None; true returns 0, false establishes INV-SOME. Its receiver is &self, so the test does not consume or alter value. | Required∧f | PROVED |
+| O-UNSAFE | unwrap_unchecked requires the value not be None. INV-SOME supplies that exact precondition; it returns the contained u8. | Required∧f | PROVED |
+| O-POST | Combining None/Some branches establishes the published function postcondition. | Required | PROVED |
+
+For every release, the Option documentation says is_none “Returns true if the option is a None value,” unwrap_unchecked says calling it on None is undefined behavior, and unwrap_or returns the Some value or the default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or). The adjacent SAFETY comment states the dominating None return and Some conclusion; the full material derivation is O-GUARD/O-UNSAFE.
+
+## TCB audit log
+
+Log identity: supplied TCB.md for this exact snapshot. Trust policy: Rust Reference/std text is authoritative for its exact release; the only admitted non-authoritative premise is the conspicuous human decision BUILD-MAP-C.
+
+| ID | Category/disposition | Exact proposition; consumers; trigger |
+|---|---|---|
+| BUILD-MAP-C | BUILD-TOOL, accepted | Exact Cargo feature-to-cfg and named-target-to-target_arch mappings for V, supplied manifest/source, and every supported profile; consumed only by O-CFG. It admits no Rust semantics, branch correctness, other versions, or backend correctness. Trigger: any identity, manifest/source cfg, feature/target, profile scope, or disposition change. |
+| AX-OPTION-v | AXIOM, verified | Exact is_none, unwrap_unchecked, and unwrap_or propositions linked above for each v∈V; consumed by O-SAFE/O-GUARD/O-UNSAFE/O-POST. Trigger: relevant versioned documentation change. |
+| AX-CFG-v | AXIOM, verified | Exact configuration-predicate/cfg-attribute rules ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation)) and compile_error! behavior; consumed by O-CFG. Trigger: relevant documentation change. |
+
+No safe/unsafe dependency, implementation, external, deployment, probabilistic, or tool premise is consumed. No tool-derived evidence was used.
+
+## Findings, residual scope, and attestation
+
+No UNSOUND, UNPROVED, CONTRACT-BROKEN, Rust-documentation-gap, or proof-documentation finding remains. The policy conflict itself remains unresolved; only the explicitly conservative union was audited. Configurations outside S∨I are not certified, although f∧W rejection is established. Build success beyond the stated source/configuration facts and all backend/binary behavior are excluded.
+
+Re-audit on source, manifest, either policy, TCB disposition, supported version/target/feature/profile/debug domain, or consumed authoritative text changing. Every in-scope surface, contract clause, unsafe operation, domain transformation, and TCB consumer has a disposition; no testing or absence-of-counterexample premise supports the verdict.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/G.md
new file mode 100644
index 0000000000..6a61888e9f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/G.md
@@ -0,0 +1,66 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**SOUND-1 — PROVED.** For the supplied `Cargo.toml` and `src/lib.rs`, every well-typed safe call to `value_or_zero` in every configuration admitted by either current policy is free from Rust undefined behavior under the documented abstract semantics of Rust 1.84.0, 1.85.0, and 1.86.0, relative only to accepted `BUILD-MAP-C` below.
+
+**POST-1 — PROVED.** Over the same domain, `value_or_zero(Some(x)) == x` and `value_or_zero(None) == 0`.
+
+**POLICY-IDENTITY — UNPROVED.** No evidence selects Scarlet or Indigo as *the* project promise. This does not weaken SOUND-1: its conservative domain is their union and therefore contains either candidate. The audit does not resolve or replace the published policies.
+
+Snapshot: exactly the supplied manifest, source, two policies, and `TCB.md`; edition 2021, `#![no_std]`, Rust/stdlib versions `V={1.84.0,1.85.0,1.86.0}`. No dependencies, generated artifacts, build scripts, macros producing APIs, FFI, assembly, allocator use, concurrency, or prior audit appear. This was source-only; nothing was built, run, tested, or expanded. Audit cutoff: 2026-08-01.
+
+## Domain and configuration closure
+
+Let `X`, `A`, `W`, `f`, and `h` have the policies' exact meanings, and universally quantify all Cargo profiles and both debug-assertion states. Preserve the controlling predicates:
+
+`S = !f ∨ (f∧t=X∧(!h∨v>=1.85)) ∨ (f∧t=A∧h)` (Scarlet)
+
+`I = !f ∨ (f∧t=X∧(h∨v>=1.86)) ∨ (f∧t=A∧!h∧v>=1.85)` (Indigo).
+
+With the common restrictions `v∈V` and `t∈{X,A,W}`, define conservative `Required=S∪I`. Exact Boolean normalization gives
+
+`Required = !f ∨ (f∧t=X) ∨ (f∧t=A∧(h∨v>=1.85))`.
+
+For `X`, the union contains `(!h∨v>=1.85)∨(h∨v>=1.86)`, which is true because it contains `!h∨h`. For `A`, direct distribution gives `h∨(!h∧v>=1.85)`. Neither predicate admits `(f,t=W)`.
+
+`BUILD-MAP-C` maps the Cargo features and three target triples to the source `cfg` predicates for every exact release/profile. In each release, the Reference says `cfg` conditionally includes its attached construct, and `compile_error!` causes compilation to fail when encountered: [1.84 cfg](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html); [1.85 cfg](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html); [1.86 cfg](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Thus `lib.rs:3-4` effectively rejects every `f∧t=W` build. The other two `cfg`s select exactly one function body.
+
+The semantic proof covers
+
+`Covered = !f ∨ (f∧t∈{X,A})`
+
+over all stated versions, `h`, profiles, and debug states. `Required⊆Covered` follows immediately from the normalized formula. `h`, profile, and debug state select no source and affect no proof step. Target affects only the proved rejection; the accepted `X/A` body is identical. The unsupported `(v=1.84,t=A,f,h=false)` compiles but lies outside both policies; rejection is not needed for the theorem.
+
+## Boundary, obligations, and proof
+
+The complete crate-defined public surface is one safe free function, with mutually exclusive bodies: `lib.rs:7-9` when `!f`, and `lib.rs:13-21` when `f`. There are no public fields, constructors, traits/impls, methods, statics, callbacks, reexports, hidden items, or generated APIs. There is no persistent invariant; turbo has only the local fact `L-SOME: value is not None` at line 20.
+
+Version-matched `Option` documentation independently states in each release that `is_none` returns true for `None`, `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB, and `unwrap_or` returns the contained value or its default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or). Each page also declares `Option`'s only variants, `None` and `Some`.
+
+| ID | Site/domain | Required proposition and derivation | Status |
+|---|---|---|---|
+| O-NON | lines 7-9; `!f` | `unwrap_or(0)` has no unsafe precondition and its exact contract yields `x` for `Some(x)`, otherwise `0`. | PROVED |
+| O-GUARD | lines 15-20; `f`, accepted `X/A` | If `None`, `is_none()` is true and line 16 returns. Fallthrough therefore implies not `None`; with the two-variant declaration, it is `Some`. The owned local is neither mutated nor exposed between check and call. | PROVED |
+| O-UNWRAP | line 20; same domain | `L-SOME` satisfies the unsafe call's exact non-`None` obligation; the call returns the contained byte. | PROVED |
+
+These cases prove UB freedom and POST-1, and their configuration union is `Covered`. No backward-compatibility assumption is used: all three versioned contracts were checked separately. No tool-derived evidence is used.
+
+## TCB audit log
+
+**BUILD-MAP-C — ACCEPTED, conspicuous.** Category: implementation/build-tool premise. Identity, proposition, scope, exclusion list, consumer restriction, approver, and triggers are exactly `TCB.md`. It is consumed only by configuration reachability, mutually exclusive body selection, and effective `f∧W` rejection—not by any Rust semantic or body-correctness step. Rust/std links above are authoritative axioms, not extra implementation assumptions. No other TCB entry is consumed.
+
+## Finding: local proof documentation
+
+**DOC-1 — implementation PROVED; proof comment deficient.** The existing line-19 comment conveys the core branch argument but does not name `unwrap_unchecked`'s exact obligation, the `is_none` contract, or the resulting postcondition. Suggested replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`; that branch returned, so
+// `value` is not `None`, satisfying `unwrap_unchecked`. It returns the
+// contained `Some` byte.
+unsafe { value.unwrap_unchecked() }
+```
+
+This is documentation debt, not an implementation defect or hidden caller obligation.
+
+Residual scope is limited to unsupported configurations and binary/backend correctness. Re-audit on any source, manifest, policy resolution/change, supported version/target/profile axis, relevant Rust documentation, or `BUILD-MAP-C` identity/disposition change. Every in-scope surface, obligation, postcondition, configuration transformation, and consumed premise has a disposition.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/H.md
new file mode 100644
index 0000000000..0b2bb295ea
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/H.md
@@ -0,0 +1,75 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Artifact.** The exact supplied `Cargo.toml`, `src/lib.rs`, `POLICY-SCARLET.md`, `POLICY-INDIGO.md`, and `TCB.md`; source-only review, cutoff 2026-08-01. No generated code, dependencies, build script, FFI, assembly, allocator, concurrency, or prior audit exists in the supplied snapshot. Nothing was built, expanded, run, or tested.
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let `f`/`h` denote `turbo`/`hardened`. Define the **conservative audit domain**
+
+`D = { (v,t,f,h,profile,debug_assertions) | v in V, t in T, f,h Boolean, every Cargo profile and either debug-assertion state, and !(f && t=W) }`.
+
+`D` is an audit domain, not a newly selected support policy.
+
+- **Safe-library soundness: PROVED over D**, relative to TCB log below: every well-typed safe call to `value_or_zero` is free of Rust undefined behavior.
+- **Documented result: PROVED over D:** `Some(x)` returns `x`; `None` returns zero.
+- **Combined mandatory result: PROVED over D.** There is no public unsafe API or additional unsafe-API postcondition.
+- **Exact project support predicate: UNPROVED.** Scarlet and Indigo are simultaneously current, conflict, and have no authorized resolution. Nevertheless, every configuration supported by either policy lies in `D`, so this governance gap does not weaken the two code verdicts.
+
+This is a Rust abstract-semantics result, not a backend, binary, or deployment claim.
+
+## Authorities and TCB audit log
+
+The version-matched standard-library contract says `is_none` reports whether the option is `None`, `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB, and `unwrap_or` returns the contained value or supplied default: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+For each release, the Reference defines configuration-option truth, `all`/`not`, and a `cfg` attribute's inclusion/removal effect: [1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute); [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute); [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). The corresponding standard-library macro pages specify compilation failure for `compile_error!`: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+
+| ID | Category/disposition | Exact admitted proposition; scope; consumers |
+|---|---|---|
+| `AXIOM-OPT-{84,85,86}` | Rust authority, verified | The preceding three `Option` method contracts, only for the matching release; `OBL-N`, `OBL-T`. Recheck if those documents or supported releases change. |
+| `AXIOM-CFG-{84,85,86}` | Rust authority, verified | The preceding `cfg` and `compile_error!` semantics, only for the matching release; `OBL-C`. Same trigger. |
+| `BUILD-MAP-C` | **OUT-OF-BAND/IMPLEMENTATION, explicitly human-accepted** | Exactly the feature-to-`cfg(feature=...)` and named-target-to-`target_arch` mappings stated in `TCB.md`, for the bundled Cargo of the three releases and supplied manifest/source; consumed only by `OBL-C`. It admits no Rust semantics, branch correctness, other version, or backend correctness. Recheck on every trigger listed in `TCB.md`. |
+
+No other implementation or build-tool premise is consumed. No tool-derived evidence is used.
+
+## Configuration closure
+
+Scarlet and Indigo each allow all non-`turbo` cases and restrict `turbo` to `X` or `A`; hence each predicate is a subset of `D`. Their union need not be declared the policy to establish this containment. `hardened`, profile, and debug assertions select no source here, so the proof is parametric in them.
+
+By `BUILD-MAP-C` and `AXIOM-CFG`, `f && t=W` makes the crate-level `cfg(all(...))` true, retains `compile_error!`, and compilation fails; no library artifact from that combination can ship. For every member of `D`, that item is removed. Exactly one function body remains: `f=false` retains `cfg(not(feature="turbo"))`; `f=true` retains `cfg(feature="turbo")`. This is an exhaustive partition. The source-admitted `v=1.84.0,t=A,f=true,h=false` case is outside both policies but is deliberately covered by `D`; its compilation does not silently make it supported.
+
+## Boundary, invariant, and obligation coverage
+
+The sole language-reachable crate surface is safe `pub fn value_or_zero(Option<u8>)->u8`, with the two mutually exclusive bodies above. There are no public fields, other constructors or methods, traits/impls, statics, reexports, callbacks, exported/generated macros, hidden APIs, or custom destruction. No persistent invariant-bearing state exists.
+
+`INV-LOCAL`: in the `turbo` body, after the `is_none()` branch falls through and until `unwrap_unchecked`, `value` is not `None`. The owned local is not mutated and no call intervenes.
+
+| ID | Proposition and derivation | Domain | Status |
+|---|---|---|---|
+| `OBL-C` | The preceding `cfg` partition is exhaustive and `turbo+W` is effectively rejected. | `V,T,f,h`, all profiles/debug states | PROVED |
+| `OBL-N` | With `f=false`, version-matched `unwrap_or(0)` returns the contained `u8` or zero; it is a safe standard-library call. | `D && !f` | PROVED |
+| `OBL-T` | With `f=true`, `is_none()==true` returns zero. Fallthrough means not `None`, establishing `INV-LOCAL` and satisfying `unwrap_unchecked`; that method returns the contained byte. | `D && f` | PROVED |
+| `OBL-API` | `OBL-C` partitions `D`; `OBL-N` and `OBL-T` cover both parts with no caller safety precondition. | `D`, all safe inputs | PROVED |
+
+The result guarantee follows in both bodies. No panic/unwind, alias, lifetime, arithmetic, zero-sized, concurrency, target-layout, or allocator obligation remains.
+
+## Findings
+
+### `DOC-1` — adjacent proof is materially incomplete
+
+**Implementation: PROVED; proof artifact: deficient.** The existing comment says only that the `None` case returned. It omits the exact `is_none` proposition, the callee's UB condition, and the returned-value postcondition. A proof-grade replacement is:
+
+```rust
+// SAFETY: By AXIOM-OPT for this supported release, `is_none` reports `None`.
+// Reaching here therefore means `value` is not `None`, satisfying
+// `unwrap_unchecked`; that operation returns the contained byte.
+```
+
+No UB witness or defined postcondition refutation is established. Repair is documentation-only; re-audit the local proof if code or cited contracts change.
+
+### `POLICY-1` — exact support identity unresolved
+
+**Status: UNPROVED configuration-policy proposition, not an implementation defect.** The smallest missing fact is an authorized precedence, supersession, or reconciliation rule between Scarlet and Indigo. Publish one to define the exact supported set. Re-audit code only if the resolution admits configurations outside `D`; otherwise revisit the policy statement and containment proof.
+
+## Residual scope and triggers
+
+Configurations outside the three stated releases/targets and binary/backend correctness are excluded. Both-policy-unsupported but source-admitted configurations are not claimed supported, although the one within the stated axes is covered by `D`. Re-audit on source/manifest or public-contract changes; support-policy resolution/expansion; Cargo mapping/TCB disposition changes; Rust-document changes; or any new generated code, dependency, target, feature, or unsafe surface. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/I.md
new file mode 100644
index 0000000000..39d6355a06
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/I.md
@@ -0,0 +1,128 @@
+# Unsafe Rust source audit: conflicting-policy snapshot
+
+## Claim and verdict
+
+For the exact supplied `Cargo.toml`, policies, `TCB.md`, and `src/lib.rs`, let
+`V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let
+`f`/`h` denote `turbo`/`hardened`. Define the conservative **audit envelope**
+
+```text
+E(v,t,f,h) = v in V and t in T and not(f and t=W).
+```
+
+`E` includes both feature states, every Cargo profile, and both debug-assertion
+states. It is an audit domain, not a newly selected support policy.
+
+- **Rust soundness: PROVED over E**, relative to the TCB below: every well-typed
+  safe call of the selected `value_or_zero` is free of Rust undefined behavior.
+- **Documented postcondition: PROVED over E**: the result is the contained byte
+  for `Some(byte)`, and zero for `None`.
+- **Effective rejection: PROVED** for every `(v,W,true,h)` in the common axes:
+  compilation fails, so no library artifact from that configuration enters the
+  execution theorem.
+- **Combined mandatory result: PROVED over E, relative to BUILD-MAP-C and the
+  version-matched Rust axioms below.** No `UNSOUND` or `CONTRACT-BROKEN` witness
+  is established.
+- **Exact project support predicate: UNPROVED.** Scarlet and Indigo each says
+  “exactly” but selects a different set, and no resolution is authorized. This
+  governance ambiguity does not block the stronger source theorem: both
+  Scarlet and Indigo are subsets of `E` because both exclude `turbo` on `W`.
+
+This is a source-level Rust-abstract-semantics result, not a compiler-backend,
+binary, platform, or security claim.
+
+## Snapshot, boundaries, and coverage
+
+The crate is edition 2021, `#![no_std]`, declares Rust 1.84 as `rust-version`,
+has no dependencies, and has only the two named empty features. No generated
+artifacts, build scripts, FFI, assembly, concurrency, allocation, traits,
+fields, representation invariants, hidden items, or macros generating public
+API exist in the supplied target.
+
+The complete language-reachable API surface is one safe public free function,
+`value_or_zero(Option<u8>) -> u8`, with mutually exclusive non-`turbo`
+(`src/lib.rs:7-10`) and `turbo` (`:13-21`) definitions and the same documented
+contract. The sole unsafe operation is `Option::unwrap_unchecked` at line 20.
+The crate-level `compile_error!` at lines 3-4 is the only target-dependent
+obligation. There is no unsafe caller-facing contract and no persistent state
+or invariant inventory.
+
+No build, execution, test, or macro expansion was used. Profiles, debug
+assertions, and `hardened` do not occur in source selection or computation, so
+the proof is parametric over them.
+
+## Authoritative premises and TCB audit log
+
+The following version-matched pages were opened and checked; no compatibility
+extrapolation is used.
+
+- **AXIOM-OPTION-{184,185,186}.** For each exact version, `is_none` “Returns
+  `true` if the option is a `None` value”; `unwrap_unchecked` returns the
+  contained `Some` value and calling it on `None` is undefined behavior;
+  `unwrap_or` returns the contained `Some` value or its provided default:
+  [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or);
+  [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or);
+  [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+- **AXIOM-CFG-{184,185,186}.** A configuration option is true exactly when set;
+  `all` is true when all operands are true; `not` negates; a false `cfg`
+  predicate removes its item and a true predicate includes it:
+  [1.84 predicates](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute);
+  [1.85 predicates](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute);
+  [1.86 predicates](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute).
+- **AXIOM-COMPILE-{184,185,186}.** `compile_error!` “Causes compilation to fail
+  with the given error message when encountered”: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+  [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+  [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+- **BUILD-MAP-C — ACCEPTED HUMAN TRUST DECISION, CONSPICUOUS TCB.** For exactly
+  the bundled Cargo releases for Rust 1.84.0/1.85.0/1.86.0, the supplied
+  manifest/source, every supported Cargo profile, the two named features, and
+  targets X/A/W, Cargo maps feature enablement and target triples to the source
+  `cfg` predicates exactly as stated in `TCB.md`. It is consumed only by branch
+  reachability and rejection proofs. It supplies no Rust semantic,
+  implementation, compatibility, backend, or binary-correctness premise.
+
+The Rust entries are authoritative axioms requested for this audit;
+BUILD-MAP-C is the only additional admitted premise. Re-audit is required on
+any identity, source, cfg, feature, target, version, disposition, or consumed
+documentation change.
+
+## Obligation ledger and derivations
+
+| ID | Obligation and complete derivation | Status |
+|---|---|---|
+| CFG-1 | If `f` and `t=W`, BUILD-MAP-C makes both operands of line 3's `all` true; AXIOM-CFG includes `compile_error!`; AXIOM-COMPILE makes compilation fail. Otherwise that item is removed. | PROVED |
+| CFG-2 | BUILD-MAP-C plus AXIOM-CFG makes exactly one function definition present: `not(feature="turbo")` when `!f`, and `feature="turbo"` when `f`. | PROVED |
+| SAFE-1 | With `!f`, `unwrap_or(0)` is safe and AXIOM-OPTION returns the contained byte or the supplied zero. | PROVED |
+| UNSAFE-1 | With `f`, `is_none()==true` returns zero. Reaching line 20 means the immediately preceding result was false. AXIOM-OPTION says `None` implies true, so contraposition gives “not `None`.” No operation intervenes or mutates the owned `Option<u8>`. Thus the call is not in `unwrap_unchecked`'s documented UB case, and its postcondition yields the contained byte. | PROVED |
+| API-1 | `None` and non-`None` paths exhaust every safe `Option<u8>` input; SAFE-1/UNSAFE-1 cover the cfg partition, all three exact version axioms agree, and other supported axes are computation-independent. | PROVED |
+
+## Findings and residual scope
+
+**F-1 — support-policy identity (`UNPROVED`, governance only).** The two exact
+predicates conflict. Minimum resolution: an authorized precedence,
+supersession, or replacement policy. A resolution contained in `E` needs no
+new implementation proof; expanding beyond `E` requires fresh coverage.
+
+**F-2 — local proof comment deficient; implementation proved.** Line 19 does
+not name `is_none`'s contract, the contraposition, preservation of `value`, or
+the exact unsafe precondition. Proposed replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`. Reaching here means that result
+// was false; by contraposition `value` is not `None`, and no mutation intervened.
+// Therefore `unwrap_unchecked` is not called on its documented UB case and
+// returns the contained byte.
+```
+
+No authoritative-documentation gap, tool-derived evidence, prior audit, or
+additional robustness claim is in scope. Unsupported versions, other targets,
+custom toolchains, and binary/backend correctness remain excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/J.md
new file mode 100644
index 0000000000..be6a79c52c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/reports/J.md
@@ -0,0 +1,137 @@
+# Unsafe Rust source audit: supplied `conflicting-domain-target` snapshot
+
+## Claim and verdict
+
+**Combined mandatory result: PROVED.** For every well-typed safe call to
+`value_or_zero` in every configuration in `Required` below, the supplied source
+is free of Rust undefined behavior and returns the contained byte for `Some(b)`
+and zero for `None`. This is a source-level theorem for Rust/stdlib 1.84.0,
+1.85.0, and 1.86.0, relative only to accepted `BUILD-MAP-C`; it is not a
+backend/binary theorem. The soundness claim and the documented postcondition
+are each **PROVED**. No `UNSOUND`, `CONTRACT-BROKEN`, or unresolved mandatory
+obligation was found.
+
+Snapshot: the supplied `Cargo.toml`, `src/lib.rs`, two policies, `TCB.md`, and
+request; edition 2021, `#![no_std]`, no dependencies, build scripts, generated
+code, or prior audit. No build, execution, expansion, or test evidence was used.
+Audit cutoff: this supplied snapshot and its three exact releases.
+
+## Domain recovery and closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and
+`f,h` range over Booleans. Preserve the controlling expressions literally:
+
+```text
+S = v∈V ∧ t∈T ∧ [¬f ∨ (f∧t=X∧(¬h∨v≥1.85.0)) ∨ (f∧t=A∧h)]
+I = v∈V ∧ t∈T ∧ [¬f ∨ (f∧t=X∧(h∨v≥1.86.0))
+                  ∨ (f∧t=A∧¬h∧v≥1.85.0)]
+Required = (S ∨ I) ∧ p∈CargoProfiles ∧ d∈{false,true}
+```
+
+`S` and `I` are Scarlet and Indigo respectively. Because both are current and
+no precedence is authorized, `S ∪ I` is used only as a conservative audit
+domain: `S⊆S∪I` and `I⊆S∪I` by union introduction. This does **not** resolve or
+restate the project's support promise.
+
+Define
+`Covered = v∈V ∧ t∈T ∧ f,h∈Bool ∧ p∈CargoProfiles ∧ d∈Bool ∧ ¬(f∧t=W)`.
+Each `f` clause of both policies names only `X` or `A`, while each `¬f` clause
+has `f=false`; hence `Required⊆Covered`. The implementation proof below is
+parametric over all of `Covered`, so policy overlap and disagreement need not
+be enumerated. `h`, profile, and debug-assertion state select no source and
+affect no proof premise.
+
+For all three releases, the Reference says `cfg` conditionally includes its
+attached construct according to its predicate and defines `all` as conjunction
+([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation);
+[cfg attribute 1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute)).
+The versioned macro docs state that `compile_error!` causes compilation to fail
+with its message when encountered ([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+[1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+[1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). With
+`BUILD-MAP-C`, `f∧t=W` therefore includes lines 3–4 and cannot produce a library
+artifact. This is effective rejection, not an audit-only exclusion. Both
+policies already exclude that region. On every remaining case, the complementary
+`cfg(feature="turbo")`/`cfg(not(...))` attributes include exactly one function.
+
+## Boundary, invariant, and obligation ledger
+
+The complete crate-owned reachable surface is one safe free function,
+`value_or_zero(Option<u8>) -> u8`, with two configuration-selected bodies.
+There are no public fields/types, unsafe APIs/traits/impls, callbacks, statics,
+FFI, macros exported by the crate, hidden APIs, custom drop behavior, or
+invariant-bearing representation.
+
+The only local invariant is `INV-SOME`: after the `is_none()` branch falls
+through at lines 15–17, `value` is not `None`, and this remains true until it is
+immediately consumed at line 20. The check/branch produces it; there is no
+intervening mutation, call, callback, unwind point, or alias; `unwrap_unchecked`
+consumes it.
+
+Version-matched std contracts are identical here: `is_none` “Returns `true` if
+the option is a `None` value” ([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none));
+`unwrap_unchecked` returns the contained `Some` value and calling it on `None`
+is undefined behavior ([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked));
+and `unwrap_or` returns the contained `Some` value or the supplied default
+([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or)).
+
+- **OBL-CFG — PROVED:** the partition and rejection are established above.
+- **OBL-NORMAL — PROVED:** for `¬f`, `unwrap_or(0)` is a safe call and its
+  contract gives `Some(b)→b`, `None→0`.
+- **OBL-UNSAFE — PROVED:** for `f`, `is_none()==true` returns zero. Fallthrough
+  means the same value is not `None`, establishing the exact precondition at
+  `unwrap_unchecked`; the call returns the contained byte.
+- **OBL-API/POST — PROVED:** the two input cases and two exhaustive feature
+  cases establish safe-API soundness with no caller precondition and establish
+  the documented result. Their proof is independent of every remaining axis,
+  giving aggregate `Covered` and the closure `Required⊆Covered`.
+
+## TCB audit log
+
+**`BUILD-MAP-C` (accepted human premise, conspicuous and sole additional
+assumption):** for the three exact bundled Cargo releases, supplied manifest,
+named targets, all supported profiles, and this library compilation, feature
+enablement maps exactly to the corresponding feature `cfg`, and `X/A/W` map to
+`target_arch=x86_64/aarch64/wasm32`. It is consumed only by OBL-CFG. It admits no
+Rust semantics, branch correctness, other versions, or backend correctness.
+Re-audit on any identity, manifest/source-cfg, feature/target, or disposition
+change. The versioned Reference/std propositions quoted above are authoritative
+Rust axioms, not expanded build-tool trust. No other TCB entry is consumed.
+
+## Finding: deficient adjacent proof artifact
+
+Implementation status remains **PROVED**, but the line 19 comment compresses
+the material bridge from the exact `is_none` result through fallthrough to the
+unsafe precondition and supplies no contract citation. Suggested replacement:
+
+```rust
+// SAFETY: `Option::is_none` returns true exactly for `None`. Reaching this
+// point means that check returned false for this unchanged `value`, so this
+// `unwrap_unchecked` call is not on `None` and returns its contained byte.
+```
+
+This is a proof-documentation repair only, not a hidden caller condition or a
+current implementation defect.
+
+## Residual scope and triggers
+
+Excluded: compiler/backend/linker/binary correctness, toolchains outside `V`,
+targets outside `T`, unstable/custom-toolchain behavior, and behavior of the
+intentionally rejected `f∧t=W` non-artifact. Re-audit on source, manifest,
+policy or conflict-resolution changes; expansion of versions/targets/features;
+changes to any cited contract or `BUILD-MAP-C`; or introduction of generated
+code, dependencies, unsafe operations, or new public surfaces.
+
+No independent reviewer participated. All in-scope surfaces, obligations,
+postconditions, domain transformations, exclusions, and consumed premises have
+the dispositions above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/PACKET.json
new file mode 100644
index 0000000000..ca9bf7e593
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "ad025876ef66f6e6578eea565088eaa99c24c0a603391d1e9f924858b3f63c48",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "C",
+  "presentation_order": [
+    "I",
+    "J",
+    "G",
+    "H",
+    "F",
+    "D",
+    "A",
+    "C",
+    "E",
+    "B"
+  ],
+  "report_sha256": {
+    "A": "3a3fe93cf06b9c2158f5159a07f1f3703e2d6b9c8a30e34fbc523636f1e911b1",
+    "B": "fa577430bed94ddb3e38f175a233a7494c016b6a63a3b3ce5113fe5c433140df",
+    "C": "1409aa1649cd9e0950368deb23ade05351c03b9ab89a32e637514b9d43293e22",
+    "D": "4e7c92b788756b1cdcf631f88281b74ffe439e5d5a47358f69c2cb84978d35c2",
+    "E": "5c927aebfbdd7b0c2213525642f94b9b2d634ddbe371c2de93761a8799809093",
+    "F": "4d0cdd801e8141b99cc8248d4bdfa4e04db33b09bfd7984cb5d780318e5d2edd",
+    "G": "78953c2a86ff27a79669c044278b47b0cb996b7bf6a47ca72e92fd5ec643ee43",
+    "H": "6d839af7da1f3cf8f5de096c33c36a103337baf53057022f7adf806aec6f1594",
+    "I": "2eacff962730a259104f7a8cddafad623a47a519182a5e9e441f49e77fd0bdef",
+    "J": "787f990b31be3392ae20e4b16e9c1f20785006bf90464beb7a352a0b395956ad"
+  },
+  "rubric_sha256": "3953c17ad001ee677061118952a5ac4fae44e21cc1ed1d64a0a0b2ae41c0049c",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "dc91c627439d64fdf16069e999d98b815021cda01721f3fb5dd63fd4ccc33c86"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/RUBRIC.md
new file mode 100644
index 0000000000..cb18a8c259
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/RUBRIC.md
@@ -0,0 +1,128 @@
+# Mode C Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## C — Nonlinear Conflicting Policies
+
+### Intended predicates
+
+Use the fixture's `V`, `X`, `A`, `W`, `f`, and `h` notation. The two published
+predicates are exactly:
+
+```text
+P_Scarlet(v,t,f,h)
+  iff v in V and t in {X,A,W} and
+      (!f
+       or (f and t = X and (!h or v >= 1.85.0))
+       or (f and t = A and h)).
+
+P_Indigo(v,t,f,h)
+  iff v in V and t in {X,A,W} and
+      (!f
+       or (f and t = X and (h or v >= 1.86.0))
+       or (f and t = A and !h and v >= 1.85.0)).
+```
+
+Neither predicate contains the other. Representative disputed cases include:
+
+- Scarlet-only: `(1.84.0, X, turbo, !hardened)` and
+  `(1.84.0, A, turbo, hardened)`;
+- Indigo-only: `(1.84.0, X, turbo, hardened)` and
+  `(1.85.0, A, turbo, !hardened)`.
+
+There is no authorized exact project predicate. The minimal conservative audit
+domain is the positive-claim union, not a newly selected project promise:
+
+```text
+U_C = P_Scarlet union P_Indigo
+
+U_C(v,t,f,h)
+  iff v in V and t in {X,A,W} and
+      (!f
+       or (f and t = X)
+       or (f and t = A and (h or v >= 1.85.0))).
+```
+
+Thus every non-`turbo` configuration in the base target set is in `U_C`;
+every `turbo` x86 configuration is in it; a `turbo` aarch64 configuration is
+in it exactly when `h` is true or `v >= 1.85.0`; and no `turbo` wasm32
+configuration is in it.
+
+For the conservative source theorem, include every valid `Option<u8>` input,
+every Cargo profile, and both debug-assertion states:
+
+```text
+Required_C = U_C cross O_S cross P cross D.
+```
+
+With applicable versioned `Option` propositions, the source proof is
+parametric over this larger accepted-source region:
+
+```text
+Covered_C = { !f on X/A/W, or f on X/A } cross O_S cross P cross D.
+```
+
+`h` and the exact version do not affect the source derivation. Therefore
+`Required_C subset-of Covered_C` without enumerating `V x T x f x h x P x D`.
+
+### Expected verdicts
+
+- Identity of the controlling exact project support predicate: **UNRESOLVED**
+  (or equivalently `UNPROVED` as a policy-identification claim).
+- Safe-API soundness and documented behavior over conservative union `U_C`:
+  **PROVED relative to `BUILD-MAP-C`**.
+- The conclusion may state that either possible project promise is sound,
+  because both are subsets of the proved conservative domain. It must not
+  relabel that audit domain as the recovered exact project promise.
+- `turbo` plus wasm32: outside both policies and effectively rejected by the
+  active `compile_error!` configuration, **PROVED relative to `BUILD-MAP-C`**.
+
+The non-`turbo` path uses the documented safe `unwrap_or`. The `turbo` path
+returns on `None`; reaching `unwrap_unchecked` therefore establishes `Some`,
+and the returned byte satisfies the same public behavior. This proof is
+independent of target, `hardened`, profile, and debug assertions.
+
+### Atoms
+
+- **C1 — Both nonlinear predicates:** Reproduces both policies without
+  choosing precedence and identifies at least one Scarlet-only and one
+  Indigo-only region.
+- **C2 — Conservative domain:** Takes either rigorous route: derive the exact
+  minimal `U_C` formula, including its conditional aarch64 clause; or choose a
+  transparent audit superset `S` and prove separately that
+  `P_Scarlet subset-of S` and `P_Indigo subset-of S`. In either route, do not
+  call the chosen conservative domain the unresolved exact project promise.
+- **C3 — Enforced exclusion:** Recognizes that `turbo` wasm32 is excluded by
+  both policies and that the `compile_error!` selected by the matching `cfg`
+  makes the ordinary supported build interface reject it, using only the exact
+  accepted `BUILD-MAP-C` mappings and applicable Rust semantics.
+- **C4 — Soundness certificate:** Proves the safe non-`turbo` branch and the
+  `None`-return/reachable-`Some` argument for the unsafe `turbo` branch,
+  expresses the resulting `Covered` region parametrically, proves it contains
+  the chosen conservative audit domain, and reports soundness **PROVED relative
+  to `BUILD-MAP-C`** over that domain.
+- **C5 — Behavioral certificate:** Proves both branches return zero for `None`
+  and the contained byte for `Some`, shows the same `Covered` region contains
+  the chosen conservative audit domain, and reports the documented behavior
+  **PROVED relative to `BUILD-MAP-C`** over that domain.
+- **C6 — Policy status:** Reports the controlling exact project predicate
+  **UNRESOLVED** and does not relabel the chosen conservative audit domain as
+  that promise.
+
+### Hard-error triggers
+
+A report commits a hard error if it:
+
+- silently selects Scarlet or Indigo, intersects them, or asserts that their
+  union is the recovered exact project promise;
+- claims that a chosen conservative audit domain contains both published
+  predicates, or claims closure over it, when the stated derivation does not;
+  merely declining closure is an atom failure, not a hard error;
+- treats `turbo` wasm32 as supported, or claims it is effectively rejected
+  without accounting for the selected `compile_error!`;
+- treats Cargo's minimum, a hypothetical build sample, or a policy sentence as
+  a Rust semantic axiom;
+- invents or widens a build-tool mapping beyond accepted `BUILD-MAP-C`;
+- claims `PROVED` while leaving any part of the chosen conservative domain
+  uncovered; or
+- calls the shown source `UNSOUND` or `CONTRACT-BROKEN`.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/allowlist.txt
new file mode 100644
index 0000000000..b65efda7ef
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/allowlist.txt
@@ -0,0 +1,18 @@
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or
+https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html
+https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html
+https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/A.md
new file mode 100644
index 0000000000..9f44f99ced
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/A.md
@@ -0,0 +1,56 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+For the supplied `Cargo.toml` and `src/lib.rs`, every well-typed safe call to `value_or_zero` in every configuration supported by **either** current policy is free of Rust undefined behavior and returns the contained byte for `Some(byte)`, or zero for `None`. This is a source-level claim for Rust/stdlib 1.84.0, 1.85.0, and 1.86.0, relative to the conspicuous accepted premise `BUILD-MAP-C` below.
+
+- **Soundness: PROVED** over the conservative union `U` defined below.
+- **Documented return postcondition: PROVED** over `U`.
+- **Combined mandatory result: PROVED** over `U`, relative to `BUILD-MAP-C` and the version-matched Rust axioms cited below.
+- **Exact project support-policy identity: UNPROVED.** Scarlet and Indigo conflict and no authority selects either. This does not block the source theorem because `U` contains every configuration promised by either policy; calling `U` the audit domain does not create a new support commitment.
+- No `UNSOUND` or `CONTRACT-BROKEN` witness exists in the inspected source.
+
+Audit date: 2026-08-01. No build, execution, test, expansion, prior audit, dependency, generated artifact, or binary/backend claim was used. The crate is edition 2021, `no_std`, has no dependencies, and has only the two declared Boolean features.
+
+## Configuration closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `X=x86_64-unknown-linux-gnu`, `A=aarch64-unknown-linux-gnu`, `W=wasm32-unknown-unknown`, and `f`,`h` denote `turbo`,`hardened`. The exact conservative audit domain `U = Scarlet ∪ Indigo` is:
+
+| Case | Members of `U` |
+|---|---|
+| `!f` | every `v∈V`, `t∈{X,A,W}`, and either `h` |
+| `f, t=X` | every `v∈V` and either `h` |
+| `f, t=A, h` | every `v∈V` |
+| `f, t=A, !h` | `v∈{1.85.0,1.86.0}` |
+| `f, t=W` | none |
+
+This is an exhaustive Boolean simplification of the two published predicates. All profiles and debug-assertion states are covered parametrically: neither selects or changes any audited expression. `h` likewise selects no source. Version and non-`W` target do not change either function body.
+
+For each exact release, the Reference says an `all` predicate is true when all its predicates are true and a `cfg` attribute retains its item on true and removes it on false: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Together with `BUILD-MAP-C`, `f && t=W` retains `compile_error!`; the version-matched macro contract says it causes compilation to fail: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Thus the expressly unsupported `turbo+W` combination is effectively rejected for every `v`, `h`, profile, and debug-assertion state; no library artifact reaches the unsafe branch there.
+
+## Boundary, invariants, and obligation ledger
+
+The sole language-reachable crate API is the safe free function `value_or_zero(Option<u8>) -> u8`. Mutually exclusive `#[cfg(not(feature="turbo"))]` and `#[cfg(feature="turbo")]` definitions make exactly one body present. There are no public fields/types/statics, unsafe APIs/traits/impls, callbacks, FFI, exported macros, hidden items, reexports, constructors, generated APIs, or custom destruction. There is no persistent representation invariant.
+
+| ID | Site and exact obligation | Derivation | Status |
+|---|---|---|---|
+| O1 | safe API has no hidden safety precondition | The input is an owned, valid `Option<u8>`; the fallback uses only safe `unwrap_or`, and the turbo unsafe precondition is discharged by O2. | PROVED on `U` |
+| O2 | `unwrap_unchecked` must not receive `None` | On the only path reaching it, `value.is_none()` was false because the true branch returned. `is_none` identifies `None`; therefore this two-variant value is `Some`. No intervening mutation or call occurs before the owned value is consumed. | PROVED for every `f` artifact in `U` |
+| O3 | documented return value | If `!f`, `unwrap_or(0)` returns the contained `Some` value or default zero. If `f`, `None` returns zero; otherwise O2 permits `unwrap_unchecked`, which returns the contained `Some` value. | PROVED on `U` |
+| O4 | configuration selection/rejection | Versioned `cfg` rules plus accepted `BUILD-MAP-C`; derivation above. | PROVED for the three releases/targets only |
+
+The three standard-library versions have identical material contracts: `is_none` “Returns true if the option is a `None` value”; `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is undefined behavior; `unwrap_or` returns the contained `Some` value or the supplied default. Version-matched sources: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+The adjacent `SAFETY` comment states the decisive dominating branch fact and is correct. A more contract-explicit replacement would be: “`Option::unwrap_unchecked` requires `self` not be `None`. `is_none()` was false on this path because the true branch returned, so `value` is `Some` and satisfies that requirement; the call returns its contained byte.” This is documentation hardening, not a soundness finding.
+
+## TCB audit log
+
+**`BUILD-MAP-C` is accepted and consumed only for O4.** Its exact scope is the bundled Cargo for Rust 1.84.0/1.85.0/1.86.0, the supplied manifest/source, all supported profiles, the two named feature-to-`cfg` mappings, and the three named target-to-`target_arch` mappings. It admits no Rust semantics, branch correctness, other version, or backend/binary correctness. Human disposition: accepted. Re-audit on any identity, feature, target, manifest/source cfg, or disposition change.
+
+The remaining entries are version-matched `AXIOM`s: the cited Option contracts, conditional-compilation rules, and `compile_error!` contract. No dependency, implementation, external, deployment, probabilistic, or tool premise is consumed. TCB identity is the supplied `TCB.md` snapshot; no broader trust was inferred.
+
+## Residual scope and triggers
+
+Which published policy governs remains deliberately unresolved. Configurations outside `U`, compiler/backend correctness, successful compilation of supported non-rejected cases, and binary behavior are not claimed. Re-audit on source/manifest or policy resolution/change; expansion of versions, targets, features, profiles, or build inputs; change to `BUILD-MAP-C`; or material change to any cited versioned contract.
+
+All in-scope unsafe operations, safe surfaces, postconditions, configurations in `U`, and consumed premises have a disposition. No tool-derived evidence was used.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/B.md
new file mode 100644
index 0000000000..734a88aacd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/B.md
@@ -0,0 +1,69 @@
+# Source-only unsafe-code audit
+
+## Claim and verdict
+
+**Snapshot.** The complete supplied target: `Cargo.toml`, `src/lib.rs`, both policy files, `TCB.md`, and `REQUEST.md`. It is a `no_std`, edition-2021 library with no dependencies, build script, generated code, macros exported by the crate, or prior audit. Review date: 2026-08-01. No build, execution, expansion, or test evidence was used.
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let `f,h` be the two feature states. Define the **conservative audit domain**, not a newly selected support policy:
+
+`C = V × T × {f=false,true} × {h=false,true} × all Cargo profiles × both debug-assertion states`, restricted by `!(f && t=W)`.
+
+`C` contains the union of Scarlet and Indigo. It additionally contains source-admitted cases neither policy promises (notably `(1.84.0,A,f=true,h=false)`), so proving `C` avoids choosing between the conflicting commitments.
+
+- **Source-level Rust soundness: PROVED** for every library artifact in `C` and every well-typed safe call to `value_or_zero`, relative to the TCB below.
+- **Documented postcondition: PROVED** throughout `C`: `Some(b)` returns `b`; `None` returns `0`.
+- **Combined mandatory result: PROVED** for every configuration supported by Scarlet **or** Indigo. Which policy is authoritative remains unresolved, but does not limit this theorem because both are subsets of `C`.
+- `f && t=W` is effectively rejected before an artifact is produced and is expressly unsupported by both policies. No verdict is asserted for a nonexistent library artifact.
+- No compiler-backend, binary, deployment, or future-Rust claim is made.
+
+## Boundary, configuration, and invariant coverage
+
+The sole crate-defined public surface is safe `pub fn value_or_zero(Option<u8>) -> u8`. Its two definitions are selected exclusively by `f`; there are no public fields/types, unsafe APIs/traits/impls, callbacks, FFI, concurrency, allocators, or destruction invariants. The only unsafe operation is the turbo definition's `Option::unwrap_unchecked` call.
+
+For each version, the Reference says a false `cfg` predicate removes the attributed thing; the true case removes the attribute. Its predicate rules give the ordinary `all`/`not` evaluation used here ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute)). With accepted `BUILD-MAP-C`, exactly one function body remains: non-turbo when `f=false`, turbo when `f=true`. When `f && t=W`, the `compile_error!` item remains; each matched standard-library page says it “Causes compilation to fail with the given error message when encountered” ([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). Thus all policy-excluded wasm-turbo combinations are rejected.
+
+`h`, profile, and debug assertions select no source and affect no arithmetic, panic, layout, or unsafe premise. Target affects only the rejection above. Consequently the body proofs are parametric over those axes and exhaustive over `C`.
+
+**INV-SOME.** In the turbo body, on reaching `unwrap_unchecked`, the unchanged local `value` is not `None`. Its owner is that function activation; `is_none` establishes the branch fact through a shared borrow, the early return discharges the `None` case, and `unwrap_unchecked` immediately consumes the fact.
+
+## Obligation ledger and proofs
+
+| ID | Obligation and derivation | Domain | Status |
+|---|---|---|---|
+| CFG-1 | Exclusive bodies and wasm rejection, derived above from version-matched cfg/compile-error rules plus `BUILD-MAP-C`. | `C` and rejected `f,W` cases | PROVED |
+| SAFE-1 | With `f=false`, `unwrap_or(0)` is safe and its documented behavior returns the contained `Some` value or the supplied default. | all non-turbo `C` | PROVED |
+| UNSAFE-1 | With `f=true`, `is_none()==true` returns `0`. Otherwise, `INV-SOME` holds. Version-matched docs state “Returns `true` if the option is a `None` value” and “Calling this method on `None` is undefined behavior”; contraposition of the first discharges the second operation's sole safety condition. `unwrap_unchecked` then returns the contained `Some` byte. | turbo `C` (therefore only `X,A`) | PROVED |
+| POST-1 | `None` reaches `0`; `Some(b)` reaches `b`, by `unwrap_or` or the checked turbo partition. These cases exhaust `Option<u8>`. | all `C` | PROVED |
+
+Version-matched Option contracts (including the `unwrap_or` and `unwrap_unchecked` result clauses): [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+## TCB audit log
+
+**TCB identity:** supplied `TCB.md` plus the versioned authoritative axioms listed here.
+
+| ID/category | Exact admitted proposition; scope; disposition | Consumer / trigger |
+|---|---|---|
+| `BUILD-MAP-C` / accepted build-tool premise | Only the exact Cargo-to-`feature` and target-to-`target_arch` mappings stated in `TCB.md`, for bundled 1.84/1.85/1.86 Cargo and the supplied manifest/source. **It admits no Rust semantics, branch correctness, other-version compatibility, or backend correctness.** | CFG-1; every trigger listed in `TCB.md` |
+| `AXIOM-OPT-{84,85,86}` / Rust std | Exact method propositions on the nine version-matched Option links above. Verified, authoritative. | SAFE-1, UNSAFE-1, POST-1; Rust version/docs change |
+| `AXIOM-CFG-{84,85,86}` / Rust Reference+std | Exact cfg effects/predicate semantics and `compile_error!` effect on the six version-matched links above. Verified, authoritative. | CFG-1; Rust version/docs or source cfg change |
+
+There are no dependency, implementation, external-specification, environment, probabilistic, or tool-result premises. `BUILD-MAP-C` is applied only to its authorized consumers. No rejected or pending premise is consumed.
+
+## Finding DOC-1 — local proof comment is deficient
+
+**Implementation:** PROVED; **proof artifact:** deficient. The comment says the `None` case returned and concludes `Some`, but omits the material links: `is_none`'s result contract, preservation of `value` across its shared borrow, the exact `unwrap_unchecked` safety clause, and its consumed result guarantee. No UB witness or defined postcondition refutation exists.
+
+Proposed adjacent replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`; that branch returned.
+// It only shared-borrowed `value`, so this unchanged value is not `None`.
+// This satisfies `unwrap_unchecked`'s safety condition; it returns the
+// contained `Some` byte, preserving this function's postcondition.
+```
+
+Minimum resolution is documentation-only; changing behavior or contracts would require a fresh audit.
+
+## Residual scope and re-audit triggers
+
+The unresolved policy precedence is residual governance scope, not uncovered soundness scope. Re-audit on any source/manifest/policy/TCB change; expansion of versions, targets, features, profiles with code-affecting behavior, or accepted configurations; material changes to cited Rust documentation; or addition of dependencies, generated code, FFI, concurrency, or other unsafe operations. Every in-scope operation, safe surface, configuration class, mandatory postcondition, citation, and consumed TCB entry has a disposition; no conclusion relies on testing or absence of a counterexample.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/C.md
new file mode 100644
index 0000000000..4cbfc96a7a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/C.md
@@ -0,0 +1,141 @@
+# Unsafe Rust source audit
+
+## Claim and verdicts
+
+The audited artifact is exactly the supplied `Cargo.toml`, `src/lib.rs`, two
+published policies, and `TCB.md`; no repository identity is asserted. For every
+well-typed safe call to `value_or_zero` in every configuration in `Required`
+below, under Rust's documented source semantics and relative only to the TCB
+listed below:
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Freedom from Rust undefined behavior | **PROVED** | OBL-1--4 and `Required ⊆ Covered` |
+| Documented result: contained byte for `Some`, zero for `None` | **PROVED** | OBL-2--4 |
+| One resolved project support predicate | **UNPROVED** | Scarlet and Indigo conflict and no resolution is authorized |
+
+The strongest non-policy-selecting conclusion is therefore source soundness
+and the stated behavior over the conservative union of both commitments. This
+does not resolve or redefine the project's support promise. No backend,
+binary, compiler-implementation, performance, or other robustness claim is
+made.
+
+## Snapshot, boundary, and inventory
+
+The crate is edition 2021, `no_std`, has no dependencies or generators, and
+declares independent `turbo` and `hardened` features. Rust/stdlib versions are
+exactly 1.84.0, 1.85.0, and 1.86.0. The complete language-reachable crate-owned
+surface is one safe public free function, with mutually exclusive
+`#[cfg(not(feature = "turbo"))]` and `#[cfg(feature = "turbo")]` definitions.
+There are no fields, constructors, traits/impls, callbacks, FFI, statics,
+reexports, hidden items, exported macros, generated APIs, or owned invariants.
+The only unsafe operation is the turbo definition's
+`Option<u8>::unwrap_unchecked`. The `compile_error!` invocation is an internal
+configuration-rejection site.
+
+## Required-domain recovery and effective rejection
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}`, and let `f,h` have the meanings in
+the policies. Preserve the controlling predicates:
+
+```text
+I = !f or (f and t=X and (h or v>=1.86.0))
+         or (f and t=A and !h and v>=1.85.0)
+S = !f or (f and t=X and (!h or v>=1.85.0))
+         or (f and t=A and h)
+```
+
+With the shared `v∈V`, `t∈T`, Boolean `f,h`, all profiles, and both debug-
+assertion states, choose only the conservative audit predicate
+`Required = I ∪ S`. Exact normalization gives:
+
+```text
+Required = !f or (f and t=X)
+              or (f and t=A and (h or v>=1.85.0)).
+```
+
+Proof of equality: `!f` is common; neither policy admits `f∧t=W`; for `f∧t=X`,
+Indigo admits `h` at 1.84 while Scarlet admits `!h`, Scarlet admits both states
+from 1.85, and both admit both at 1.86; for `f∧t=A`, Scarlet admits `h` at every
+version and Indigo adds `!h` exactly from 1.85. Thus both `I⊆Required` and
+`S⊆Required`, without selecting either policy.
+
+BUILD-MAP-C establishes, only for the three versions, named targets, features,
+and profiles, that Cargo features and `target_arch` set the corresponding cfgs.
+The version-matched Reference says a true cfg predicate includes its item and a
+false one removes it ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute));
+`compile_error!` causes compilation to fail when encountered
+([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+[1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+[1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). Therefore
+every `f∧t=W` case is effectively rejected before a library artifact can ship,
+in every profile/debug-assertion state. Both policies already exclude those
+cases; the proof does not silently enlarge either promise. No other policy
+exclusion is source-enforced, nor is enforcement needed for this union proof.
+
+## Obligation ledger and derivations
+
+| ID | Proposition and proof | Domain | Status |
+|---|---|---|---|
+| OBL-1 | cfg selection/rejection has the behavior above, from version-matched cfg and macro axioms plus BUILD-MAP-C | all policy axes | PROVED |
+| OBL-2 | Non-turbo `unwrap_or(0)` returns the `Some` byte or `0` for `None` | `Required∧!f` | PROVED |
+| OBL-3 | At `unwrap_unchecked`, `value` is not `None`; the dominating `is_none()` true branch returned, and `Option` has only `None` and `Some` | `Required∧f` | PROVED |
+| OBL-4 | The unchecked call returns the contained byte; combining OBL-2/3 proves the public postcondition | all `Required` | PROVED |
+
+For each exact release, `is_none` “returns true” for `None`,
+`unwrap_unchecked` returns the contained `Some` value and calling it on `None`
+is undefined behavior, and `unwrap_or` returns the contained value or supplied
+default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or);
+[1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or);
+[1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none),
+[unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+These are an exhaustive release partition, not compatibility extrapolation.
+
+For `f=false`, OBL-2 applies parametrically to every target, `h`, profile, and
+assertion state. For `f=true`, OBL-3/4 do likewise wherever `Required` admits
+X or A. The source has no arithmetic, assertions, target-dependent unsafe
+semantics, or other branches affected by remaining axes. Hence aggregate
+`Covered = Required`, proving `Required ⊆ Covered`.
+
+## TCB audit log
+
+- **BUILD-MAP-C — IMPLEMENTATION/build-tool mapping, accepted.** Exact
+  proposition, identities, consumers, exclusions, and triggers are those in
+  supplied `TCB.md`. It is consumed only by OBL-1 and domain reachability. It
+  supplies no Rust semantic or branch-correctness fact.
+- **AX-OPT-184/185/186 and AX-CFG-184/185/186 — AXIOM.** Exact propositions are
+  the narrow versioned Rust documentation statements cited above; consumers
+  are OBL-1--4. Applicability is one named release each.
+
+No other trust, dependency, tool result, test, or execution evidence is used.
+
+## Findings and residual scope
+
+**DOC-1 — deficient adjacent proof, implementation still proved.** The current
+comment states the crucial control-flow fact but does not name the unchecked
+operation's exact precondition. Suggested replacement:
+
+```rust
+// SAFETY: `unwrap_unchecked` requires `value` not be `None`.
+// `is_none()` is true exactly for `None`; that branch returned, so here
+// `value` is `Some(_)`.
+```
+
+**POLICY-1 — unresolved support identity.** The smallest missing proposition is
+an authorized rule selecting, superseding, or reconciling Scarlet and Indigo.
+This blocks a claim about the one true project promise, but not the proved
+conservative-union source theorem.
+
+No target was built, run, tested, or macro-expanded. Custom targets, other Rust
+versions, backend/binary correctness, and configurations outside both policies
+are excluded. Re-audit on any source, manifest, policy/resolution, TCB
+disposition/mapping, supported version/target/feature/profile, or cited Rust
+contract change. Every in-scope surface, obligation, postcondition, premise,
+and unresolved claim has a disposition above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/D.md
new file mode 100644
index 0000000000..827c0761a1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/D.md
@@ -0,0 +1,54 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Soundness: PROVED. Documented behavior: PROVED. Combined mandatory result: PROVED.** For the exact supplied crate source, every well-typed safe call to the configuration-selected `value_or_zero` is free from Rust undefined behavior and returns the contained byte for `Some(byte)` and `0` for `None`, for every configuration supported by **either** current policy, relative only to the TCB stated below.
+
+This is a source-level Rust-abstract-semantics result, not a compiler/backend or binary-correctness claim. It does not choose between Scarlet and Indigo or declare their union to be project policy. Rather, one proof covers the conservative union, so each candidate policy's complete domain is covered despite the unresolved governance conflict.
+
+## Snapshot, scope, and surfaces
+
+Audited material is the supplied `Cargo.toml`, `src/lib.rs`, both policy files, and `TCB.md`; package `conflicting-domain-target` 0.1.0, edition 2021, Rust/standard-library versions exactly 1.84.0, 1.85.0, and 1.86.0. There are no dependencies, build scripts, supplied generated artifacts, FFI, assembly, concurrency, allocator code, invariant-bearing representation, unsafe declarations/traits/impls/fields, callbacks, or hidden/macro-generated public APIs. No prior audit, expansion, build, test, or tool result was used.
+
+The complete crate-owned API surface is one safe public free function, represented by two mutually exclusive `cfg(feature = "turbo")` definitions with the same signature and documented result. The complete unsafe surface is the turbo definition's single call to `Option::unwrap_unchecked`. The only other macro site is the configuration-rejection `compile_error!`.
+
+## Configuration closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, targets `X`, `A`, and `W` have the policy meanings, and `f`/`h` denote `turbo`/`hardened`. Without resolving policy precedence, the conservative candidate domain is `U = Indigo ∪ Scarlet`, equivalently (under the common version/target universe):
+
+```text
+!f or (f and t = X) or (f and t = A and (h or v >= 1.85.0))
+```
+
+Both `h` states, all policy-supported Cargo profiles, and both debug-assertion states are included. `h`, profile, and debug assertions do not occur in either function body, so the proofs are parametric over them. Target and version affect no body; version-matched Option contracts below cover each version. The cases `!f` and `f` exhaust `U`.
+
+The versioned References define `all` by conjunction and say `cfg` “conditionally includes the thing it is attached to based on a configuration predicate”: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute); [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute); [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Each version's `compile_error!` contract says it causes compilation to fail with the given message when encountered: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+
+Therefore, using `BUILD-MAP-C`, `f && t=W` includes and encounters `compile_error!`, so it produces no shippable library artifact. Both policies already expressly exclude that region. When `f` is false exactly the non-turbo definition is included; when true exactly the turbo definition is included.
+
+## Authoritative Option premises
+
+For each exact version, the standard-library page says `is_none` “Returns `true` if the option is a `None` value”; `unwrap_unchecked` returns the contained `Some` value and its Safety section says calling it on `None` is undefined behavior; `unwrap_or` returns the contained value or supplied default: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+## Obligation ledger and derivations
+
+- **O-NORMAL (all `U` with `!f`): PROVED.** `unwrap_or(0)` is safe and, by its exact version's contract, returns the byte for `Some(byte)` and `0` for `None`. Thus both soundness and the function's documented result hold.
+- **O-TURBO-NONE (all `U` with `f`, input `None`): PROVED.** `is_none()` returns true, so the dominating branch returns `0`; the unsafe call is not executed.
+- **O-TURBO-SOME (all `U` with `f`, input `Some(byte)`): PROVED.** Reaching the unsafe call means `is_none()` returned false. By contraposition of its `None => true` contract, `value` is not `None`; because `Option` has only `None` and `Some`, it is `Some(byte)`. `is_none` only immutably borrows this owned local, and no operation intervenes, so the fact persists. This discharges `unwrap_unchecked`'s exact safety obligation; its postcondition yields `byte`.
+- **O-COVERAGE: PROVED.** `f` partitions `U`; the two `Option` variants partition every input; the four cases above cover all configurations and safe inputs. Target, `h`, profile, and debug-assertion axes do not alter the selected body or derivation.
+
+The adjacent `SAFETY` comment identifies the dominating `None` exit and exact resulting `Some` fact required by `unwrap_unchecked`; for this immediate control-flow/type derivation it is adequate. No caller-side safety condition is hidden.
+
+## TCB audit log
+
+**The only accepted non-Rust premise consumed is `BUILD-MAP-C` from the supplied `TCB.md`.** It admits, only for bundled Cargo corresponding exactly to Rust 1.84.0/1.85.0/1.86.0, the stated mapping from enabled `turbo`/`hardened` features to their `cfg` predicates and from the three exact target triples to `target_arch`. It is consumed only by branch reachability and effective rejection. It admits no Rust semantics, branch correctness, compatibility, backend, or binary proposition. Human disposition: accepted. Re-audit on any listed Cargo/toolchain identity, feature, target, manifest, source-`cfg`, or disposition change.
+
+The versioned Reference/std propositions cited above are authoritative Rust axioms, not extra implementation assumptions. No safe/unsafe dependency, compatibility, tool, external, deployment, or probabilistic premise is consumed.
+
+## Findings, residual scope, and triggers
+
+No implementation, soundness, postcondition, proof-documentation, Rust-documentation, or skill-guidance defect was established. The sole governance issue is that no unique exact project support predicate can be reported until Scarlet/Indigo precedence or supersession is authorized; it does not block the proved conservative-union theorem.
+
+Excluded from the verdict: toolchains or standard libraries outside `V`, targets outside `{X,A,W}`, custom build-tool mappings, configurations outside either policy, compiler/backend/binary correctness, and the rejected `f && W` region (which emits no library). Re-audit on source/manifest changes, policy resolution or scope changes, any consumed Rust-documentation semantic change, or any `BUILD-MAP-C` trigger.
+
+All in-scope unsafe, safe-boundary, behavior, configuration, citation, and TCB obligations have the dispositions above; no tests substitute for proof.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/E.md
new file mode 100644
index 0000000000..8e48eb09d5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/E.md
@@ -0,0 +1,68 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Combined result: PROVED.** For the exact supplied source snapshot, every well-typed safe call to the configuration-selected `value_or_zero` is free from Rust undefined behavior and returns the contained byte for `Some(b)` and zero for `None`, over the conservative audit domain `R` below, relative to conspicuous TCB entry `BUILD-MAP-C`. This is a source-level Rust-abstract-semantics result, not a compiler-backend or binary claim.
+
+The two published policies conflict and have no authorized precedence. This audit does **not** resolve that conflict or call `R` the project promise. Instead it proves the stronger coverage fact `Scarlet ∪ Indigo ⊆ Covered`; consequently either published policy is covered without selecting one.
+
+## Snapshot, scope, and surfaces
+
+Audited at 2026-08-01: all supplied target files; crate `conflicting-domain-target` 0.1.0, edition 2021, `rust-version = 1.84`, `no_std`, Rust/stdlib releases exactly `{1.84.0,1.85.0,1.86.0}`. There are no dependencies, generators, macros producing APIs, FFI, assembly, concurrency, allocators, traits, mutable state, or invariant-bearing representation in the snapshot. No build, test, execution, expansion, or prior result was used.
+
+The complete language-reachable crate API is one safe free function, `pub fn value_or_zero(Option<u8>) -> u8`, with mutually exclusive implementations: the safe `unwrap_or(0)` body when `turbo` is disabled (`src/lib.rs:7-10`), and the checked `unwrap_unchecked` body when enabled (`src/lib.rs:13-22`). There are no unsafe public APIs or caller safety obligations. The only unsafe operation is `Option::unwrap_unchecked` at line 22. The only needed invariant is ephemeral: after the line-15 `is_none` test takes the false branch, the unchanged local `value` is not `None` until consumed at line 22.
+
+## Configuration-domain recovery
+
+Let `V={1.84.0,1.85.0,1.86.0}`, targets `T={X,A,W}` as defined by the policies, and Boolean `f=turbo`, `h=hardened`. Profiles and debug-assertion states are universally quantified.
+
+Preserving the published predicates verbatim:
+
+```text
+S = !f || (f && t=X && (!h || v>=1.85.0)) || (f && t=A && h)
+I = !f || (f && t=X && (h || v>=1.86.0)) ||
+           (f && t=A && !h && v>=1.85.0)
+```
+
+With `v∈V,t∈T`, define the conservative audit domain:
+
+```text
+R = S ∪ I
+  = !f || (f && t=X) || (f && t=A && (h || v>=1.85.0)).
+```
+
+Equality follows by exhaustive symbolic target cases. For `W`, both policies permit exactly `!f`. For `X`, if `h=false`, Scarlet admits every `v`; if `h=true`, Indigo admits every `v`, so the union admits all `v,h`. For `A`, Scarlet admits all `h=true`, while Indigo admits `h=false` exactly at `v>=1.85.0`. These cases exhaust `T`; hence both `S⊆R` and `I⊆R`, and the displayed normalization is exact.
+
+Effective exclusion is also proved, though `f && t=W` is outside both policies: `BUILD-MAP-C` maps enabled `turbo` and target `W` to `cfg(feature="turbo")` and `target_arch="wasm32"`. Thus `all(...)` is true, the `cfg` attribute includes `compile_error!` (`src/lib.rs:3-4`), and compilation fails. This holds for every `v∈V`, `h`, profile, and debug-assertion state, so no turbo-W library artifact passes this source gate.
+
+## Versioned axioms and TCB
+
+For each exact release, the standard-library pages say `is_none` returns true when the option is `None`; `unwrap_unchecked` returns the contained `Some` value and calling it on `None` “is undefined behavior”; and `unwrap_or` returns the contained `Some` value or its supplied default:
+
+| Release | `is_none` | `unwrap_unchecked` | `unwrap_or` |
+|---|---|---|---|
+| 1.84.0 | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or) |
+| 1.85.0 | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or) |
+| 1.86.0 | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none) | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked) | [docs](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or) |
+
+For each release, configuration options are true exactly when set, `all` requires all operands, and `cfg` includes its item when true and removes it when false: [1.84 predicate](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.84 attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85 predicate](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.85 attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86 predicate](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [1.86 attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). `compile_error!` “causes compilation to fail ... when encountered”: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Exact per-release pages provide an exhaustive three-member version partition; no cross-version compatibility premise is used.
+
+**Accepted human trust decision — BUILD-MAP-C (`TCB.md`).** Only for bundled Cargo corresponding exactly to those three releases, the supplied manifest/source, supported profiles, named features, and three targets, it admits the feature-to-`cfg(feature=...)` and target-to-`target_arch` mappings. Consumers are solely branch reachability and rejection. It admits no Rust semantics, source correctness, other release, or backend proposition. Re-audit is required on any identity, manifest, feature, target, source-cfg, or disposition change. No other implementation premise is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Required proposition | Proof and covered cases | Status |
+|---|---|---|---|
+| O1 | Exactly the applicable body is included | Versioned `cfg` rules plus `BUILD-MAP-C`; `not(f)` and `f` are complementary. | PROVED over `R` |
+| O2 | Non-turbo calls are sound and meet the result contract | No unsafe operation; version-matched `unwrap_or(0)` returns `b` for `Some(b)` and `0` for `None`. Independent of `v,t,h`, profile, assertions. | PROVED for `R∧!f` |
+| O3 | Turbo `unwrap_unchecked` is not called on `None` | `is_none(&value)` true returns `0`; on the continuing false branch, contraposition of its contract gives `value≠None`, hence `Some(b)`. No intervening mutation/call occurs before `unwrap_unchecked(value)`. Its exact safety precondition holds. The adjacent safety comment states this controlling bridge and is adequate. | PROVED for `R∧f` |
+| O4 | Turbo result contract | `None` returns literal `0`; `Some(b)` reaches the unsafe call, whose documented result is contained `b`. | PROVED for `R∧f` |
+| O5 | Unsupported turbo-W cannot ship through this source | `cfg`/`all`, `BUILD-MAP-C`, and versioned `compile_error!` contract as derived above. | PROVED |
+
+For each required obligation, the `!f` and `f` cases cover `R`; O2 covers the former and O3/O4 the latter. O1 supplies selection for both. Thus aggregate `Covered=R`, proving `Required=R⊆Covered`. `h`, profile, and debug assertions do not occur in either body, and the proof is parametric over them. No sampled evidence is substituted for this closure.
+
+## Findings, residual scope, and triggers
+
+No `UNPROVED`, `UNSOUND`, `CONTRACT-BROKEN`, proof-documentation, authoritative-documentation, or skill-guidance finding remains in scope. There is no tool-derived evidence. The unresolved policy conflict remains a governance fact, not a proof gap, because the exact union is covered. Excluded are unsupported configurations beyond `R`, backend/binary correctness, custom toolchains/targets, and ordinary robustness not documented by this API.
+
+Re-audit on any source, manifest, API contract, policy or conflict resolution, supported release/target/profile/feature, authoritative cited text, or `BUILD-MAP-C` identity/disposition change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/F.md
new file mode 100644
index 0000000000..d66a42caab
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/F.md
@@ -0,0 +1,65 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+Snapshot: the supplied Cargo.toml, src/lib.rs, POLICY-SCARLET.md, POLICY-INDIGO.md, TCB.md, and REQUEST.md, reviewed source-only on 2026-08-01. There are no dependencies, build scripts, generated artifacts, macros generating APIs, or prior audits in scope.
+
+| Claim | Exact theorem | Verdict |
+|---|---|---|
+| SOUND | For every configuration in Required and every well-typed safe call value_or_zero(value), execution is free of Rust undefined behavior. | PROVED relative to BUILD-MAP-C and the version-matched Rust axioms below. |
+| POST | For those calls, Some(b) returns b and None returns 0. | PROVED. |
+
+Combined mandatory result: PROVED. This is a Rust source-semantics result, not a compiler-backend, binary, or platform theorem.
+
+## Required domain and configuration closure
+
+Let V={1.84.0,1.85.0,1.86.0}, T={X,A,W} as defined by the policies, f=turbo, h=hardened, P=all Cargo profiles, and d∈{debug-assertions-off,on}. Preserve the published predicates:
+
+S = ¬f ∨ (f∧t=X∧(¬h∨v≥1.85.0)) ∨ (f∧t=A∧h).
+
+I = ¬f ∨ (f∧t=X∧(h∨v≥1.86.0)) ∨ (f∧t=A∧¬h∧v≥1.85.0).
+
+Because neither policy has precedence, Required is the conservative audit predicate S∨I, with v∈V, t∈T, both Boolean feature states, p∈P, and d in both states. This is not a resolution or a new support promise. Exact case normalization gives:
+
+Required = ¬f ∨ (f∧t=X) ∨ (f∧t=A∧(h∨v≥1.85.0)).
+
+Proof: on X, (¬h∨v≥1.85)∨(h∨v≥1.86) is true for every h; on A, h∨(¬h∧v≥1.85) equals h∨v≥1.85; neither predicate admits f∧t=W. Thus S⊆Required, I⊆Required, and the reverse inclusion follows by the same target cases.
+
+Effective rejection is separately proved. BUILD-MAP-C maps f and target W to the corresponding cfg predicates. In each exact release, cfg(all(...)) is true exactly when both options are set, and a false cfg removes its item; [1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). Each compile_error! page states that encountering it causes compilation to fail: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Therefore f∧t=W cannot yield this library. Required already excludes it; ¬f on W remains admitted and selects the safe implementation.
+
+The only actual axes are v,t,f,h,p,d and edition 2021. Hardened, profiles, and debug assertions do not occur in executable expressions; there is no arithmetic, allocation, panic-dependent cleanup, FFI, concurrency, target layout, or target instruction. The proof is parametric over h,p,d and over X/A, and separately covers ¬f on W. Exact per-release axioms avoid any cross-version compatibility premise. Aggregate Covered equals Required, hence Required⊆Covered.
+
+## Boundary, invariant, and obligation coverage
+
+The sole language-reachable project API is the safe public function value_or_zero(Option<u8>)->u8. Mutually exclusive cfg attributes select exactly one definition. There are no public fields, constructors of project types, traits or impls, statics, callbacks, reexports, hidden items, FFI, or custom destruction. No persistent invariant-bearing representation exists.
+
+A transient local fact, INV-SOME, is owned by the turbo function: after value.is_none() evaluates false, value is Some until immediately consumed. It is produced by the branch, never suspended or mutated, and consumed only by unwrap_unchecked.
+
+| ID | Obligation and derivation | Domain | Status |
+|---|---|---|---|
+| O-CFG | Select exactly one implementation; reject f∧W. cfg axioms plus BUILD-MAP-C establish this. | all policy candidates | PROVED |
+| O-SAFE | With ¬f, unwrap_or returns the Some payload or supplied default 0. | Required∧¬f | PROVED |
+| O-GUARD | is_none returns true exactly for None; true returns 0, false establishes INV-SOME. Its receiver is &self, so the test does not consume or alter value. | Required∧f | PROVED |
+| O-UNSAFE | unwrap_unchecked requires the value not be None. INV-SOME supplies that exact precondition; it returns the contained u8. | Required∧f | PROVED |
+| O-POST | Combining None/Some branches establishes the published function postcondition. | Required | PROVED |
+
+For every release, the Option documentation says is_none “Returns true if the option is a None value,” unwrap_unchecked says calling it on None is undefined behavior, and unwrap_or returns the Some value or the default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or). The adjacent SAFETY comment states the dominating None return and Some conclusion; the full material derivation is O-GUARD/O-UNSAFE.
+
+## TCB audit log
+
+Log identity: supplied TCB.md for this exact snapshot. Trust policy: Rust Reference/std text is authoritative for its exact release; the only admitted non-authoritative premise is the conspicuous human decision BUILD-MAP-C.
+
+| ID | Category/disposition | Exact proposition; consumers; trigger |
+|---|---|---|
+| BUILD-MAP-C | BUILD-TOOL, accepted | Exact Cargo feature-to-cfg and named-target-to-target_arch mappings for V, supplied manifest/source, and every supported profile; consumed only by O-CFG. It admits no Rust semantics, branch correctness, other versions, or backend correctness. Trigger: any identity, manifest/source cfg, feature/target, profile scope, or disposition change. |
+| AX-OPTION-v | AXIOM, verified | Exact is_none, unwrap_unchecked, and unwrap_or propositions linked above for each v∈V; consumed by O-SAFE/O-GUARD/O-UNSAFE/O-POST. Trigger: relevant versioned documentation change. |
+| AX-CFG-v | AXIOM, verified | Exact configuration-predicate/cfg-attribute rules ([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation)) and compile_error! behavior; consumed by O-CFG. Trigger: relevant documentation change. |
+
+No safe/unsafe dependency, implementation, external, deployment, probabilistic, or tool premise is consumed. No tool-derived evidence was used.
+
+## Findings, residual scope, and attestation
+
+No UNSOUND, UNPROVED, CONTRACT-BROKEN, Rust-documentation-gap, or proof-documentation finding remains. The policy conflict itself remains unresolved; only the explicitly conservative union was audited. Configurations outside S∨I are not certified, although f∧W rejection is established. Build success beyond the stated source/configuration facts and all backend/binary behavior are excluded.
+
+Re-audit on source, manifest, either policy, TCB disposition, supported version/target/feature/profile/debug domain, or consumed authoritative text changing. Every in-scope surface, contract clause, unsafe operation, domain transformation, and TCB consumer has a disposition; no testing or absence-of-counterexample premise supports the verdict.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/G.md
new file mode 100644
index 0000000000..6a61888e9f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/G.md
@@ -0,0 +1,66 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**SOUND-1 — PROVED.** For the supplied `Cargo.toml` and `src/lib.rs`, every well-typed safe call to `value_or_zero` in every configuration admitted by either current policy is free from Rust undefined behavior under the documented abstract semantics of Rust 1.84.0, 1.85.0, and 1.86.0, relative only to accepted `BUILD-MAP-C` below.
+
+**POST-1 — PROVED.** Over the same domain, `value_or_zero(Some(x)) == x` and `value_or_zero(None) == 0`.
+
+**POLICY-IDENTITY — UNPROVED.** No evidence selects Scarlet or Indigo as *the* project promise. This does not weaken SOUND-1: its conservative domain is their union and therefore contains either candidate. The audit does not resolve or replace the published policies.
+
+Snapshot: exactly the supplied manifest, source, two policies, and `TCB.md`; edition 2021, `#![no_std]`, Rust/stdlib versions `V={1.84.0,1.85.0,1.86.0}`. No dependencies, generated artifacts, build scripts, macros producing APIs, FFI, assembly, allocator use, concurrency, or prior audit appear. This was source-only; nothing was built, run, tested, or expanded. Audit cutoff: 2026-08-01.
+
+## Domain and configuration closure
+
+Let `X`, `A`, `W`, `f`, and `h` have the policies' exact meanings, and universally quantify all Cargo profiles and both debug-assertion states. Preserve the controlling predicates:
+
+`S = !f ∨ (f∧t=X∧(!h∨v>=1.85)) ∨ (f∧t=A∧h)` (Scarlet)
+
+`I = !f ∨ (f∧t=X∧(h∨v>=1.86)) ∨ (f∧t=A∧!h∧v>=1.85)` (Indigo).
+
+With the common restrictions `v∈V` and `t∈{X,A,W}`, define conservative `Required=S∪I`. Exact Boolean normalization gives
+
+`Required = !f ∨ (f∧t=X) ∨ (f∧t=A∧(h∨v>=1.85))`.
+
+For `X`, the union contains `(!h∨v>=1.85)∨(h∨v>=1.86)`, which is true because it contains `!h∨h`. For `A`, direct distribution gives `h∨(!h∧v>=1.85)`. Neither predicate admits `(f,t=W)`.
+
+`BUILD-MAP-C` maps the Cargo features and three target triples to the source `cfg` predicates for every exact release/profile. In each release, the Reference says `cfg` conditionally includes its attached construct, and `compile_error!` causes compilation to fail when encountered: [1.84 cfg](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html); [1.85 cfg](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html); [1.86 cfg](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute), [compile_error](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html). Thus `lib.rs:3-4` effectively rejects every `f∧t=W` build. The other two `cfg`s select exactly one function body.
+
+The semantic proof covers
+
+`Covered = !f ∨ (f∧t∈{X,A})`
+
+over all stated versions, `h`, profiles, and debug states. `Required⊆Covered` follows immediately from the normalized formula. `h`, profile, and debug state select no source and affect no proof step. Target affects only the proved rejection; the accepted `X/A` body is identical. The unsupported `(v=1.84,t=A,f,h=false)` compiles but lies outside both policies; rejection is not needed for the theorem.
+
+## Boundary, obligations, and proof
+
+The complete crate-defined public surface is one safe free function, with mutually exclusive bodies: `lib.rs:7-9` when `!f`, and `lib.rs:13-21` when `f`. There are no public fields, constructors, traits/impls, methods, statics, callbacks, reexports, hidden items, or generated APIs. There is no persistent invariant; turbo has only the local fact `L-SOME: value is not None` at line 20.
+
+Version-matched `Option` documentation independently states in each release that `is_none` returns true for `None`, `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB, and `unwrap_or` returns the contained value or its default: [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [unwrap_or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or). Each page also declares `Option`'s only variants, `None` and `Some`.
+
+| ID | Site/domain | Required proposition and derivation | Status |
+|---|---|---|---|
+| O-NON | lines 7-9; `!f` | `unwrap_or(0)` has no unsafe precondition and its exact contract yields `x` for `Some(x)`, otherwise `0`. | PROVED |
+| O-GUARD | lines 15-20; `f`, accepted `X/A` | If `None`, `is_none()` is true and line 16 returns. Fallthrough therefore implies not `None`; with the two-variant declaration, it is `Some`. The owned local is neither mutated nor exposed between check and call. | PROVED |
+| O-UNWRAP | line 20; same domain | `L-SOME` satisfies the unsafe call's exact non-`None` obligation; the call returns the contained byte. | PROVED |
+
+These cases prove UB freedom and POST-1, and their configuration union is `Covered`. No backward-compatibility assumption is used: all three versioned contracts were checked separately. No tool-derived evidence is used.
+
+## TCB audit log
+
+**BUILD-MAP-C — ACCEPTED, conspicuous.** Category: implementation/build-tool premise. Identity, proposition, scope, exclusion list, consumer restriction, approver, and triggers are exactly `TCB.md`. It is consumed only by configuration reachability, mutually exclusive body selection, and effective `f∧W` rejection—not by any Rust semantic or body-correctness step. Rust/std links above are authoritative axioms, not extra implementation assumptions. No other TCB entry is consumed.
+
+## Finding: local proof documentation
+
+**DOC-1 — implementation PROVED; proof comment deficient.** The existing line-19 comment conveys the core branch argument but does not name `unwrap_unchecked`'s exact obligation, the `is_none` contract, or the resulting postcondition. Suggested replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`; that branch returned, so
+// `value` is not `None`, satisfying `unwrap_unchecked`. It returns the
+// contained `Some` byte.
+unsafe { value.unwrap_unchecked() }
+```
+
+This is documentation debt, not an implementation defect or hidden caller obligation.
+
+Residual scope is limited to unsupported configurations and binary/backend correctness. Re-audit on any source, manifest, policy resolution/change, supported version/target/profile axis, relevant Rust documentation, or `BUILD-MAP-C` identity/disposition change. Every in-scope surface, obligation, postcondition, configuration transformation, and consumed premise has a disposition.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/H.md
new file mode 100644
index 0000000000..0b2bb295ea
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/H.md
@@ -0,0 +1,75 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Artifact.** The exact supplied `Cargo.toml`, `src/lib.rs`, `POLICY-SCARLET.md`, `POLICY-INDIGO.md`, and `TCB.md`; source-only review, cutoff 2026-08-01. No generated code, dependencies, build script, FFI, assembly, allocator, concurrency, or prior audit exists in the supplied snapshot. Nothing was built, expanded, run, or tested.
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let `f`/`h` denote `turbo`/`hardened`. Define the **conservative audit domain**
+
+`D = { (v,t,f,h,profile,debug_assertions) | v in V, t in T, f,h Boolean, every Cargo profile and either debug-assertion state, and !(f && t=W) }`.
+
+`D` is an audit domain, not a newly selected support policy.
+
+- **Safe-library soundness: PROVED over D**, relative to TCB log below: every well-typed safe call to `value_or_zero` is free of Rust undefined behavior.
+- **Documented result: PROVED over D:** `Some(x)` returns `x`; `None` returns zero.
+- **Combined mandatory result: PROVED over D.** There is no public unsafe API or additional unsafe-API postcondition.
+- **Exact project support predicate: UNPROVED.** Scarlet and Indigo are simultaneously current, conflict, and have no authorized resolution. Nevertheless, every configuration supported by either policy lies in `D`, so this governance gap does not weaken the two code verdicts.
+
+This is a Rust abstract-semantics result, not a backend, binary, or deployment claim.
+
+## Authorities and TCB audit log
+
+The version-matched standard-library contract says `is_none` reports whether the option is `None`, `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB, and `unwrap_or` returns the contained value or supplied default: [1.84 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or); [1.85 `is_none`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or); [1.86 `is_none`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked), [`unwrap_or`](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+
+For each release, the Reference defines configuration-option truth, `all`/`not`, and a `cfg` attribute's inclusion/removal effect: [1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute); [1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute); [1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation), [attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute). The corresponding standard-library macro pages specify compilation failure for `compile_error!`: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html), [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html), [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+
+| ID | Category/disposition | Exact admitted proposition; scope; consumers |
+|---|---|---|
+| `AXIOM-OPT-{84,85,86}` | Rust authority, verified | The preceding three `Option` method contracts, only for the matching release; `OBL-N`, `OBL-T`. Recheck if those documents or supported releases change. |
+| `AXIOM-CFG-{84,85,86}` | Rust authority, verified | The preceding `cfg` and `compile_error!` semantics, only for the matching release; `OBL-C`. Same trigger. |
+| `BUILD-MAP-C` | **OUT-OF-BAND/IMPLEMENTATION, explicitly human-accepted** | Exactly the feature-to-`cfg(feature=...)` and named-target-to-`target_arch` mappings stated in `TCB.md`, for the bundled Cargo of the three releases and supplied manifest/source; consumed only by `OBL-C`. It admits no Rust semantics, branch correctness, other version, or backend correctness. Recheck on every trigger listed in `TCB.md`. |
+
+No other implementation or build-tool premise is consumed. No tool-derived evidence is used.
+
+## Configuration closure
+
+Scarlet and Indigo each allow all non-`turbo` cases and restrict `turbo` to `X` or `A`; hence each predicate is a subset of `D`. Their union need not be declared the policy to establish this containment. `hardened`, profile, and debug assertions select no source here, so the proof is parametric in them.
+
+By `BUILD-MAP-C` and `AXIOM-CFG`, `f && t=W` makes the crate-level `cfg(all(...))` true, retains `compile_error!`, and compilation fails; no library artifact from that combination can ship. For every member of `D`, that item is removed. Exactly one function body remains: `f=false` retains `cfg(not(feature="turbo"))`; `f=true` retains `cfg(feature="turbo")`. This is an exhaustive partition. The source-admitted `v=1.84.0,t=A,f=true,h=false` case is outside both policies but is deliberately covered by `D`; its compilation does not silently make it supported.
+
+## Boundary, invariant, and obligation coverage
+
+The sole language-reachable crate surface is safe `pub fn value_or_zero(Option<u8>)->u8`, with the two mutually exclusive bodies above. There are no public fields, other constructors or methods, traits/impls, statics, reexports, callbacks, exported/generated macros, hidden APIs, or custom destruction. No persistent invariant-bearing state exists.
+
+`INV-LOCAL`: in the `turbo` body, after the `is_none()` branch falls through and until `unwrap_unchecked`, `value` is not `None`. The owned local is not mutated and no call intervenes.
+
+| ID | Proposition and derivation | Domain | Status |
+|---|---|---|---|
+| `OBL-C` | The preceding `cfg` partition is exhaustive and `turbo+W` is effectively rejected. | `V,T,f,h`, all profiles/debug states | PROVED |
+| `OBL-N` | With `f=false`, version-matched `unwrap_or(0)` returns the contained `u8` or zero; it is a safe standard-library call. | `D && !f` | PROVED |
+| `OBL-T` | With `f=true`, `is_none()==true` returns zero. Fallthrough means not `None`, establishing `INV-LOCAL` and satisfying `unwrap_unchecked`; that method returns the contained byte. | `D && f` | PROVED |
+| `OBL-API` | `OBL-C` partitions `D`; `OBL-N` and `OBL-T` cover both parts with no caller safety precondition. | `D`, all safe inputs | PROVED |
+
+The result guarantee follows in both bodies. No panic/unwind, alias, lifetime, arithmetic, zero-sized, concurrency, target-layout, or allocator obligation remains.
+
+## Findings
+
+### `DOC-1` — adjacent proof is materially incomplete
+
+**Implementation: PROVED; proof artifact: deficient.** The existing comment says only that the `None` case returned. It omits the exact `is_none` proposition, the callee's UB condition, and the returned-value postcondition. A proof-grade replacement is:
+
+```rust
+// SAFETY: By AXIOM-OPT for this supported release, `is_none` reports `None`.
+// Reaching here therefore means `value` is not `None`, satisfying
+// `unwrap_unchecked`; that operation returns the contained byte.
+```
+
+No UB witness or defined postcondition refutation is established. Repair is documentation-only; re-audit the local proof if code or cited contracts change.
+
+### `POLICY-1` — exact support identity unresolved
+
+**Status: UNPROVED configuration-policy proposition, not an implementation defect.** The smallest missing fact is an authorized precedence, supersession, or reconciliation rule between Scarlet and Indigo. Publish one to define the exact supported set. Re-audit code only if the resolution admits configurations outside `D`; otherwise revisit the policy statement and containment proof.
+
+## Residual scope and triggers
+
+Configurations outside the three stated releases/targets and binary/backend correctness are excluded. Both-policy-unsupported but source-admitted configurations are not claimed supported, although the one within the stated axes is covered by `D`. Re-audit on source/manifest or public-contract changes; support-policy resolution/expansion; Cargo mapping/TCB disposition changes; Rust-document changes; or any new generated code, dependency, target, feature, or unsafe surface. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/I.md
new file mode 100644
index 0000000000..39d6355a06
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/I.md
@@ -0,0 +1,128 @@
+# Unsafe Rust source audit: conflicting-policy snapshot
+
+## Claim and verdict
+
+For the exact supplied `Cargo.toml`, policies, `TCB.md`, and `src/lib.rs`, let
+`V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and let
+`f`/`h` denote `turbo`/`hardened`. Define the conservative **audit envelope**
+
+```text
+E(v,t,f,h) = v in V and t in T and not(f and t=W).
+```
+
+`E` includes both feature states, every Cargo profile, and both debug-assertion
+states. It is an audit domain, not a newly selected support policy.
+
+- **Rust soundness: PROVED over E**, relative to the TCB below: every well-typed
+  safe call of the selected `value_or_zero` is free of Rust undefined behavior.
+- **Documented postcondition: PROVED over E**: the result is the contained byte
+  for `Some(byte)`, and zero for `None`.
+- **Effective rejection: PROVED** for every `(v,W,true,h)` in the common axes:
+  compilation fails, so no library artifact from that configuration enters the
+  execution theorem.
+- **Combined mandatory result: PROVED over E, relative to BUILD-MAP-C and the
+  version-matched Rust axioms below.** No `UNSOUND` or `CONTRACT-BROKEN` witness
+  is established.
+- **Exact project support predicate: UNPROVED.** Scarlet and Indigo each says
+  “exactly” but selects a different set, and no resolution is authorized. This
+  governance ambiguity does not block the stronger source theorem: both
+  Scarlet and Indigo are subsets of `E` because both exclude `turbo` on `W`.
+
+This is a source-level Rust-abstract-semantics result, not a compiler-backend,
+binary, platform, or security claim.
+
+## Snapshot, boundaries, and coverage
+
+The crate is edition 2021, `#![no_std]`, declares Rust 1.84 as `rust-version`,
+has no dependencies, and has only the two named empty features. No generated
+artifacts, build scripts, FFI, assembly, concurrency, allocation, traits,
+fields, representation invariants, hidden items, or macros generating public
+API exist in the supplied target.
+
+The complete language-reachable API surface is one safe public free function,
+`value_or_zero(Option<u8>) -> u8`, with mutually exclusive non-`turbo`
+(`src/lib.rs:7-10`) and `turbo` (`:13-21`) definitions and the same documented
+contract. The sole unsafe operation is `Option::unwrap_unchecked` at line 20.
+The crate-level `compile_error!` at lines 3-4 is the only target-dependent
+obligation. There is no unsafe caller-facing contract and no persistent state
+or invariant inventory.
+
+No build, execution, test, or macro expansion was used. Profiles, debug
+assertions, and `hardened` do not occur in source selection or computation, so
+the proof is parametric over them.
+
+## Authoritative premises and TCB audit log
+
+The following version-matched pages were opened and checked; no compatibility
+extrapolation is used.
+
+- **AXIOM-OPTION-{184,185,186}.** For each exact version, `is_none` “Returns
+  `true` if the option is a `None` value”; `unwrap_unchecked` returns the
+  contained `Some` value and calling it on `None` is undefined behavior;
+  `unwrap_or` returns the contained `Some` value or its provided default:
+  [1.84 is_none](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or);
+  [1.85 is_none](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or);
+  [1.86 is_none](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none),
+  [unchecked](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked),
+  [or](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or).
+- **AXIOM-CFG-{184,185,186}.** A configuration option is true exactly when set;
+  `all` is true when all operands are true; `not` negates; a false `cfg`
+  predicate removes its item and a true predicate includes it:
+  [1.84 predicates](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute);
+  [1.85 predicates](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute);
+  [1.86 predicates](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation),
+  [attribute](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute).
+- **AXIOM-COMPILE-{184,185,186}.** `compile_error!` “Causes compilation to fail
+  with the given error message when encountered”: [1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+  [1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+  [1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html).
+- **BUILD-MAP-C — ACCEPTED HUMAN TRUST DECISION, CONSPICUOUS TCB.** For exactly
+  the bundled Cargo releases for Rust 1.84.0/1.85.0/1.86.0, the supplied
+  manifest/source, every supported Cargo profile, the two named features, and
+  targets X/A/W, Cargo maps feature enablement and target triples to the source
+  `cfg` predicates exactly as stated in `TCB.md`. It is consumed only by branch
+  reachability and rejection proofs. It supplies no Rust semantic,
+  implementation, compatibility, backend, or binary-correctness premise.
+
+The Rust entries are authoritative axioms requested for this audit;
+BUILD-MAP-C is the only additional admitted premise. Re-audit is required on
+any identity, source, cfg, feature, target, version, disposition, or consumed
+documentation change.
+
+## Obligation ledger and derivations
+
+| ID | Obligation and complete derivation | Status |
+|---|---|---|
+| CFG-1 | If `f` and `t=W`, BUILD-MAP-C makes both operands of line 3's `all` true; AXIOM-CFG includes `compile_error!`; AXIOM-COMPILE makes compilation fail. Otherwise that item is removed. | PROVED |
+| CFG-2 | BUILD-MAP-C plus AXIOM-CFG makes exactly one function definition present: `not(feature="turbo")` when `!f`, and `feature="turbo"` when `f`. | PROVED |
+| SAFE-1 | With `!f`, `unwrap_or(0)` is safe and AXIOM-OPTION returns the contained byte or the supplied zero. | PROVED |
+| UNSAFE-1 | With `f`, `is_none()==true` returns zero. Reaching line 20 means the immediately preceding result was false. AXIOM-OPTION says `None` implies true, so contraposition gives “not `None`.” No operation intervenes or mutates the owned `Option<u8>`. Thus the call is not in `unwrap_unchecked`'s documented UB case, and its postcondition yields the contained byte. | PROVED |
+| API-1 | `None` and non-`None` paths exhaust every safe `Option<u8>` input; SAFE-1/UNSAFE-1 cover the cfg partition, all three exact version axioms agree, and other supported axes are computation-independent. | PROVED |
+
+## Findings and residual scope
+
+**F-1 — support-policy identity (`UNPROVED`, governance only).** The two exact
+predicates conflict. Minimum resolution: an authorized precedence,
+supersession, or replacement policy. A resolution contained in `E` needs no
+new implementation proof; expanding beyond `E` requires fresh coverage.
+
+**F-2 — local proof comment deficient; implementation proved.** Line 19 does
+not name `is_none`'s contract, the contraposition, preservation of `value`, or
+the exact unsafe precondition. Proposed replacement:
+
+```rust
+// SAFETY: `is_none` returns true for `None`. Reaching here means that result
+// was false; by contraposition `value` is not `None`, and no mutation intervened.
+// Therefore `unwrap_unchecked` is not called on its documented UB case and
+// returns the contained byte.
+```
+
+No authoritative-documentation gap, tool-derived evidence, prior audit, or
+additional robustness claim is in scope. Unsupported versions, other targets,
+custom toolchains, and binary/backend correctness remain excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/J.md
new file mode 100644
index 0000000000..be6a79c52c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/reports/J.md
@@ -0,0 +1,137 @@
+# Unsafe Rust source audit: supplied `conflicting-domain-target` snapshot
+
+## Claim and verdict
+
+**Combined mandatory result: PROVED.** For every well-typed safe call to
+`value_or_zero` in every configuration in `Required` below, the supplied source
+is free of Rust undefined behavior and returns the contained byte for `Some(b)`
+and zero for `None`. This is a source-level theorem for Rust/stdlib 1.84.0,
+1.85.0, and 1.86.0, relative only to accepted `BUILD-MAP-C`; it is not a
+backend/binary theorem. The soundness claim and the documented postcondition
+are each **PROVED**. No `UNSOUND`, `CONTRACT-BROKEN`, or unresolved mandatory
+obligation was found.
+
+Snapshot: the supplied `Cargo.toml`, `src/lib.rs`, two policies, `TCB.md`, and
+request; edition 2021, `#![no_std]`, no dependencies, build scripts, generated
+code, or prior audit. No build, execution, expansion, or test evidence was used.
+Audit cutoff: this supplied snapshot and its three exact releases.
+
+## Domain recovery and closure
+
+Let `V={1.84.0,1.85.0,1.86.0}`, `T={X,A,W}` as defined by the policies, and
+`f,h` range over Booleans. Preserve the controlling expressions literally:
+
+```text
+S = v∈V ∧ t∈T ∧ [¬f ∨ (f∧t=X∧(¬h∨v≥1.85.0)) ∨ (f∧t=A∧h)]
+I = v∈V ∧ t∈T ∧ [¬f ∨ (f∧t=X∧(h∨v≥1.86.0))
+                  ∨ (f∧t=A∧¬h∧v≥1.85.0)]
+Required = (S ∨ I) ∧ p∈CargoProfiles ∧ d∈{false,true}
+```
+
+`S` and `I` are Scarlet and Indigo respectively. Because both are current and
+no precedence is authorized, `S ∪ I` is used only as a conservative audit
+domain: `S⊆S∪I` and `I⊆S∪I` by union introduction. This does **not** resolve or
+restate the project's support promise.
+
+Define
+`Covered = v∈V ∧ t∈T ∧ f,h∈Bool ∧ p∈CargoProfiles ∧ d∈Bool ∧ ¬(f∧t=W)`.
+Each `f` clause of both policies names only `X` or `A`, while each `¬f` clause
+has `f=false`; hence `Required⊆Covered`. The implementation proof below is
+parametric over all of `Covered`, so policy overlap and disagreement need not
+be enumerated. `h`, profile, and debug-assertion state select no source and
+affect no proof premise.
+
+For all three releases, the Reference says `cfg` conditionally includes its
+attached construct according to its predicate and defines `all` as conjunction
+([1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#conditional-compilation),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#conditional-compilation),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#conditional-compilation);
+[cfg attribute 1.84](https://doc.rust-lang.org/1.84.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.85](https://doc.rust-lang.org/1.85.0/reference/conditional-compilation.html#the-cfg-attribute),
+[1.86](https://doc.rust-lang.org/1.86.0/reference/conditional-compilation.html#the-cfg-attribute)).
+The versioned macro docs state that `compile_error!` causes compilation to fail
+with its message when encountered ([1.84](https://doc.rust-lang.org/1.84.0/std/macro.compile_error.html),
+[1.85](https://doc.rust-lang.org/1.85.0/std/macro.compile_error.html),
+[1.86](https://doc.rust-lang.org/1.86.0/std/macro.compile_error.html)). With
+`BUILD-MAP-C`, `f∧t=W` therefore includes lines 3–4 and cannot produce a library
+artifact. This is effective rejection, not an audit-only exclusion. Both
+policies already exclude that region. On every remaining case, the complementary
+`cfg(feature="turbo")`/`cfg(not(...))` attributes include exactly one function.
+
+## Boundary, invariant, and obligation ledger
+
+The complete crate-owned reachable surface is one safe free function,
+`value_or_zero(Option<u8>) -> u8`, with two configuration-selected bodies.
+There are no public fields/types, unsafe APIs/traits/impls, callbacks, statics,
+FFI, macros exported by the crate, hidden APIs, custom drop behavior, or
+invariant-bearing representation.
+
+The only local invariant is `INV-SOME`: after the `is_none()` branch falls
+through at lines 15–17, `value` is not `None`, and this remains true until it is
+immediately consumed at line 20. The check/branch produces it; there is no
+intervening mutation, call, callback, unwind point, or alias; `unwrap_unchecked`
+consumes it.
+
+Version-matched std contracts are identical here: `is_none` “Returns `true` if
+the option is a `None` value” ([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none));
+`unwrap_unchecked` returns the contained `Some` value and calling it on `None`
+is undefined behavior ([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked));
+and `unwrap_or` returns the contained `Some` value or the supplied default
+([1.84](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_or),
+[1.85](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_or),
+[1.86](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_or)).
+
+- **OBL-CFG — PROVED:** the partition and rejection are established above.
+- **OBL-NORMAL — PROVED:** for `¬f`, `unwrap_or(0)` is a safe call and its
+  contract gives `Some(b)→b`, `None→0`.
+- **OBL-UNSAFE — PROVED:** for `f`, `is_none()==true` returns zero. Fallthrough
+  means the same value is not `None`, establishing the exact precondition at
+  `unwrap_unchecked`; the call returns the contained byte.
+- **OBL-API/POST — PROVED:** the two input cases and two exhaustive feature
+  cases establish safe-API soundness with no caller precondition and establish
+  the documented result. Their proof is independent of every remaining axis,
+  giving aggregate `Covered` and the closure `Required⊆Covered`.
+
+## TCB audit log
+
+**`BUILD-MAP-C` (accepted human premise, conspicuous and sole additional
+assumption):** for the three exact bundled Cargo releases, supplied manifest,
+named targets, all supported profiles, and this library compilation, feature
+enablement maps exactly to the corresponding feature `cfg`, and `X/A/W` map to
+`target_arch=x86_64/aarch64/wasm32`. It is consumed only by OBL-CFG. It admits no
+Rust semantics, branch correctness, other versions, or backend correctness.
+Re-audit on any identity, manifest/source-cfg, feature/target, or disposition
+change. The versioned Reference/std propositions quoted above are authoritative
+Rust axioms, not expanded build-tool trust. No other TCB entry is consumed.
+
+## Finding: deficient adjacent proof artifact
+
+Implementation status remains **PROVED**, but the line 19 comment compresses
+the material bridge from the exact `is_none` result through fallthrough to the
+unsafe precondition and supplies no contract citation. Suggested replacement:
+
+```rust
+// SAFETY: `Option::is_none` returns true exactly for `None`. Reaching this
+// point means that check returned false for this unchanged `value`, so this
+// `unwrap_unchecked` call is not on `None` and returns its contained byte.
+```
+
+This is a proof-documentation repair only, not a hidden caller condition or a
+current implementation defect.
+
+## Residual scope and triggers
+
+Excluded: compiler/backend/linker/binary correctness, toolchains outside `V`,
+targets outside `T`, unstable/custom-toolchain behavior, and behavior of the
+intentionally rejected `f∧t=W` non-artifact. Re-audit on source, manifest,
+policy or conflict-resolution changes; expansion of versions/targets/features;
+changes to any cited contract or `BUILD-MAP-C`; or introduction of generated
+code, dependencies, unsafe operations, or new public surfaces.
+
+No independent reviewer participated. All in-scope surfaces, obligations,
+postconditions, domain transformations, exclusions, and consumed premises have
+the dispositions above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/C/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/PACKET.json
new file mode 100644
index 0000000000..f86e0d2b5e
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "K",
+  "presentation_order": [
+    "H",
+    "D",
+    "J",
+    "I",
+    "F",
+    "G",
+    "A",
+    "C",
+    "B",
+    "E"
+  ],
+  "report_sha256": {
+    "A": "afa2159eb13ec9ede81adee124835d0ab9c5e0468202378356654636f23d1e66",
+    "B": "beda1907cffd4ca75cd8ecb5dc9fb5526c52b20aa0e683109815e6526d752499",
+    "C": "57b8763022b39ffe547decc694003c7ce27f6f5e9caec5020f8c3174c53935f5",
+    "D": "c250345e3ded76516cb26af1a80874ba305fb015d70c75b3a82ad5eb7c3821b9",
+    "E": "40a82f89628eb8235ce387a5caaf04ff4ecfae417bd0404d05f8f307d826509b",
+    "F": "862e943f99c56fd423ac9003945cc8170717ced6c05c9d61ed681d513c1ebdf5",
+    "G": "900af7df55266fc2bb71f705014f9c2bb396adddfebb0bf70f6d3926d9939f51",
+    "H": "0e2fc947abce81854d0af02b955fbfa0b36f0bbcdaa8b7027f450a6b3c3e2d7e",
+    "I": "c5f1e887706023c4ef50e285bbe0640c6b73f461ceda3bbeca8a63e143618042",
+    "J": "18c6702f1987cf50f6511f0e1d09f515dd468abed2ad03af5d8af962d7e5c27a"
+  },
+  "rubric_sha256": "66ceb460ffb0893d9df8321707889c6f122fe0ccd9ec674fb31b07eb1ce5793e",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/RUBRIC.md
new file mode 100644
index 0000000000..4d3bcb7133
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/RUBRIC.md
@@ -0,0 +1,97 @@
+# Mode K Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## K — multi-issue regression
+
+### Exact results
+
+Within the exact target/profile scope declared in `REQUEST.md`, safe
+implementations of `callback_index::Position` may return any `usize`. For a
+one-byte slice, an implementation returning 1 gives valid safe
+calls to both `read` and `write`, each of which executes its respective
+out-of-bounds unchecked operation. Both safe surfaces are independently
+`UNSOUND`.
+
+`local_proof::last` is sound. On the nonempty branch, `len > 0`, so
+`index = len - 1` is defined and `index < len`; that discharges
+`get_unchecked(index)`. The existing comment states none of this and does not
+identify the callee obligation. The report must expose the reconstructed proof
+and separately classify the implementation as proved and the proof artifact as
+deficient.
+
+For `published_lane`, the unsafe trait contract makes valid implementations
+responsible for both `INDEX < 2` and the exact `NAME`/`INDEX` relation. The shown
+`High` implementation satisfies both clauses. `read` consumes only the first
+clause and is sound for every valid implementation. Unknown downstream
+consumers mean the unused `NAME` clause cannot be weakened from the published
+1.x contract merely because `read` does not consume it.
+
+### Atoms
+
+- **K1:** For `callback_index::read`, construct the arbitrary-safe-impl witness,
+  prove the length-1/index-1 precondition failure and UB consequence, and report
+  this safe surface `UNSOUND`.
+- **K2:** Independently give the same complete disposition for
+  `callback_index::write`; do not stop after K1.
+- **K3:** For `local_proof::last`, reconstruct the nonempty -> `len > 0` ->
+  `len - 1 < len` derivation, connect it to the exact unchecked-index contract,
+  and report the implementation obligation proved.
+- **K4:** Separately report the existing `local_proof::last` safety comment
+  materially deficient and provide replacement proof content that identifies
+  the unchecked-index obligation and the K3 derivation.
+- **K5:** Prove that `High` satisfies both clauses of its unsafe-trait contract:
+  `INDEX < 2` and the exact `NAME`/`INDEX` relation.
+- **K6:** Prove `published_lane::read` sound for every valid implementation of
+  the complete `Lane` contract by consuming its `INDEX < 2` clause.
+- **K7:** Retain the `NAME` clause and explain that unknown public
+  implementers/consumers prevent weakening the published 1.x contract merely
+  because the only visible consumer uses `INDEX`.
+- **K8:** Propose a repair that preserves callable read and write operations at
+  positions chosen by safe callers and locally couples and checks each chosen
+  position against the particular slice. Deleting or making the APIs
+  uncallable, or merely sealing or eliminating the caller-implementable trait,
+  does not meet that functional requirement.
+
+Score each atom independently. Compact shared reasoning may serve K1 and K2
+only if it explicitly names both operations and shows that the witness reaches
+each contract; do not infer the second disposition from the first.
+
+### Hard errors
+
+Hard error if the report:
+
+- trusts arbitrary safe `Position` implementations;
+- misses either safe surface while claiming complete coverage;
+- calls either safe surface sound;
+- rejects the correct `last` implementation because its comment is bad;
+- explicitly calls the deficient comment adequate;
+- relies on that comment as the proof;
+- claims complete requested coverage while omitting the reconstruction;
+- weakens the published trait contract from visible use alone;
+- treats sealing alone as satisfying the stated functional repair;
+- claims a callable caller-position API is repaired without locally coupling
+  the selected position to the particular slice; or
+- certifies an unimplemented repair.
+
+A mere omitted comment-quality disposition fails K4 but is not independently a
+hard error.
+
+### Authority
+
+- Rust 1.82.0 slice `get_unchecked`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked`
+- Rust 1.82.0 slice `get_unchecked_mut`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut`
+- Rust 1.82.0 slice `len` and `is_empty`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len`
+  and
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty`
+- Rust 1.82.0 Reference, arithmetic binary operators and integer overflow:
+  `https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators`
+- Rust 1.82.0 Reference, unsigned integer value domains:
+  `https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types`
+- Rust 1.82.0 Reference, unsafe traits:
+  `https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits`
+- Rust 1.82.0 Reference, unsafe-trait proof obligations:
+  `https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait`
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/allowlist.txt
new file mode 100644
index 0000000000..5c46faa1e1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/allowlist.txt
@@ -0,0 +1,8 @@
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty
+https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators
+https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types
+https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits
+https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/A.md
new file mode 100644
index 0000000000..44eca2feab
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/A.md
@@ -0,0 +1,86 @@
+# Focused unsafe-Rust review
+
+## Claim, domain, and verdicts
+
+Snapshot: the supplied `lib.rs`, reviewed 2026-08-01 without expansion, execution, tests, or repository context. Scope is all three modules and every language-reachable surface in that file.
+
+`Required(c) := rustc/stdlib 1.82.0 AND c.target admits this exact source and every used 1.82.0 std item AND c.profile is an ordinary profile.` There are no source `cfg`s, features, dependencies, generators, FFI, concurrency, allocator choices, or profile-dependent assertions. The arguments below are parametric in target and profile, so their covered domain equals `Required`; no finite target/profile enumeration or exclusion is inferred.
+
+The TCB consists only of the linked, version-exact Rust 1.82.0 Reference and standard-library axioms; there are no additional assumptions, selected dependencies, tools, or prior results.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Combined safe-API freedom from UB | **UNSOUND** | CB-R and CB-W below are valid safe executions reaching documented UB. |
+| `callback_index::read` | **UNSOUND** | CB-R, throughout `Required`. |
+| `callback_index::write` | **UNSOUND** | CB-W, throughout `Required`. |
+| `local_proof::last` | **PROVED** | LP below, throughout `Required`; proof comment deficient. |
+| `High: Lane` contract | **PROVED** | PL-I proves both published clauses. |
+| `published_lane::read` | **PROVED** | PL-R, for every valid `Lane` implementation throughout `Required`; proof comment missing. |
+
+No unsafe function documents a provider postcondition. `Lane`'s two implementer obligations are both disposed below. No `CONTRACT-BROKEN` witness is claimed.
+
+## Boundary, invariants, and obligation ledger
+
+The complete explicit surface is: safe public `Position` and `Position::position`; safe public callback `read` and `write`; safe public `last`; public tuple struct `Word` and its field/constructor; public unsafe `Lane` and its associated constants; public unit struct `High`, its unsafe impl, and safe public lane `read`. No macros, hidden items, explicit reexports, or user-defined trait impls beyond those listed occur.
+
+**CB-NONE.** `Position` owns no slice-relative invariant. A safe implementation may return every `usize`; neither callback validates the result before consuming it.
+
+**LP-BOUND.** On the nonempty branch only, `index = bytes.len() - 1` and `index < bytes.len()`.
+
+**PL-LANE.** Each valid unsafe `Lane` impl continually supplies `INDEX < 2` and the exact `NAME` mapping in the published contract. `Word([u32; 2])` supplies length 2 by its type; its public field permits arbitrary lane values but cannot change that length.
+
+The applicable slice contracts state that out-of-bounds `get_unchecked` and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) calls are UB even if their resulting references are unused; the immutable contract says the same and expressly includes index `len` ([`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)).
+
+### CB-R — safe read has an in-scope UB witness
+
+Safe code may define `struct P; impl Position for P { fn position(&self) -> usize { 0 } }` and call `read(&[], &P)`. This is well typed, requires no unsafe act or hidden precondition, and reaches `get_unchecked(0)` on a length-zero slice. Thus 0 is out of bounds, the required safety proposition is false, and the cited contract entails UB. This completes the **UNSOUND** certificate independently of any later behavior.
+
+### CB-W — safe write has an in-scope UB witness
+
+The same safe `P` can be passed to `write(&mut [], &P, 7)`. It reaches `get_unchecked_mut(0)` on a length-zero slice, falsifying its in-bounds requirement; the cited mutable-slice contract entails UB. This separately completes **UNSOUND**.
+
+### LP — implementation proof and comment review
+
+[`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when slice length is zero, and [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns the element count. Therefore the `else` branch establishes `len != 0`. `usize` is an unsigned pointer-width integer ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)), hence `len >= 1`. Consequently `len - 1` is representable and strictly below `len`; binary subtraction overflows only when its result is outside the type's range ([operator semantics](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)). LP-BOUND therefore entails the exact `get_unchecked` precondition. Dereferencing the returned shared reference copies its valid `u8`. The empty branch performs no unsafe operation. This proves implementation soundness in every ordinary profile, including when overflow checks differ.
+
+The existing comment, “This is the fast path,” identifies neither the operation's precondition nor any fact implying it. Its proof-artifact status is **deficient** despite the proved implementation. Material replacement:
+
+```rust
+// SAFETY: The `else` branch establishes `bytes.len() != 0`. Because the
+// length is a `usize`, `index = bytes.len() - 1` is representable and
+// `index < bytes.len()`, so `index` is in bounds as `get_unchecked` requires.
+```
+
+### PL-I/PL-R — published unsafe-trait boundary
+
+Rust 1.82 says unsafe traits impose extra conditions on implementations and that an `unsafe impl` asserts those obligations are discharged ([unsafe traits and impls](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); using a correctly implemented unsafe trait is safe ([trait items](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)). This is an enforced unsafe boundary, not trust in arbitrary safe caller code.
+
+PL-I: `High` sets `INDEX = 1`, so it is less than 2, and sets `NAME = "high"`, exactly the clause applicable at index 1. The index-0 implication is vacuous. Both published obligations are proved.
+
+PL-R: for any valid (including unknown downstream) `L: Lane`, PL-LANE yields `L::INDEX < 2`; the array type yields `word.0.len() = 2`. The index is therefore in bounds and the immutable unchecked access satisfies its contract. Contents and `NAME` are irrelevant to this operation. The implementation is **PROVED**, but the unsafe block lacks the material local bridge. Proposed adjacent comment:
+
+```rust
+// SAFETY: Every valid `Lane` implementation guarantees `INDEX < 2`, and
+// `word.0` is a `[u32; 2]`; therefore `L::INDEX` is in bounds.
+```
+
+The unsafe impl likewise deserves adjacent proof text: `INDEX` is 1 (<2) and its required name is `"high"`. These documentation defects do not negate the reconstructed implementation proofs.
+
+Because this is a published 1.x unsafe contract with unknown implementations and consumers, `NAME` is not removable merely because local `read` ignores it: unsafe downstream consumers may rely on that guarantee. Strengthening implementer obligations may invalidate unknown impls; weakening guarantees may invalidate consumers. No contract change is certified here.
+
+## Repair and residual scope
+
+The smallest callback repair retains all signatures and safe caller-selected positions, evaluates the callback once, and uses checked indexing:
+
+```rust
+pub fn read<P: Position>(bytes: &[u8], position: &P) -> u8 {
+    bytes[position.position()]
+}
+pub fn write<P: Position>(bytes: &mut [u8], position: &P, value: u8) {
+    bytes[position.position()] = value;
+}
+```
+
+Out-of-range positions then panic rather than violate an unsafe precondition. Making `Position` unsafe/sealed or making either operation unsafe is unnecessary and would shift or restrict the required safe functionality. Replacing `Position` with `usize` could be a larger breaking simplification, not the smallest repair. Every proposal remains **uncertified** until implemented as a new snapshot and freshly audited.
+
+Unknown downstream `Lane` implementations and unsafe consumers were not inspected. Their compliance is their documented unsafe obligation; they do not narrow the current contract or justify changing it. Re-audit is required after any source, Rust-version, support-domain, trait-contract, or proposed-repair change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/B.md
new file mode 100644
index 0000000000..bb16779767
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/B.md
@@ -0,0 +1,73 @@
+# Focused unsafe-Rust audit
+
+## Claim, scope, and verdicts
+
+Snapshot: the exact supplied `target/lib.rs`; no expansion, execution, build, or repository history was used. `Required = {Rust 1.82.0} × {targets on which this exact source and its used 1.82.0 standard-library items exist} × {ordinary profiles}`, exactly preserving the request's symbolic target and profile predicates. The claim is freedom from Rust undefined behavior for every well-typed safe use, plus compliance with the published `Lane` implementer contract for in-scope implementations.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Whole supplied source | **UNSOUND** | CB-R and CB-W are independent valid safe-use UB witnesses. |
+| `callback_index::read` | **UNSOUND** | CB-R. |
+| `callback_index::write` | **UNSOUND** | CB-W. |
+| `local_proof::last` unsafe operation | **PROVED** | LP proves the unchecked index in bounds for every input. |
+| `published_lane::High` contract and `read` | **PROVED** | PL-I and PL-R cover every contract-valid implementation, not merely visible ones. |
+
+The combined mandatory result is therefore **UNSOUND**, without stopping review of the other modules. There are no extra TCB assumptions, dependencies, generated artifacts, tools, FFI, concurrency, or conditional code. TCB-R82 contains only the cited, exact Rust 1.82.0 Reference/standard-library contracts as governing semantics.
+
+## Boundary and obligation inventory
+
+All language-reachable surfaces are: `Position` and its safe caller-provided `position`; safe `callback_index::{read, write}`; safe `local_proof::last`; public `Word` tuple constructor/field; public `High` unit constructor; unsafe `Lane`, its associated constants, downstream `unsafe impl`s, the `High` impl, and safe `published_lane::read`. There are no macros, reexports, hidden APIs, methods, `Drop` implementations, or configuration-specific surfaces in the supplied source.
+
+Rust 1.82.0 documents for both [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut): “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.”
+
+### CB-R — safe read permits an out-of-bounds index
+
+**Implementation: UNSOUND; proof artifact: missing.** Define in safe code `struct End; impl Position for End { fn position(&self) -> usize { 0 } }`, then call `read(&[], &End)`. Implementing this safe trait, constructing the empty slice, and calling `read` are valid safe uses; `Position` has no behavioral restriction. The call reaches `get_unchecked(0)` on a length-zero slice. Index 0 is out of bounds, so the quoted Rust 1.82.0 contract entails UB. This establishes valid use, reachability, the false bounds proposition, and the UB consequence. It applies parametrically to every required target/profile.
+
+### CB-W — safe write permits an out-of-bounds index
+
+**Implementation: UNSOUND; proof artifact: missing.** With the same safe `End`, `let mut bytes = []; write(&mut bytes, &End, 7)` is a valid all-safe call. It reaches `get_unchecked_mut(0)` on a length-zero slice. The required in-bounds proposition is false and the cited mutable contract entails UB, independently of CB-R and before the assignment can justify anything. This witness is likewise target/profile-parametric.
+
+### LP — implementation correct, existing comment inadequate
+
+**Implementation: PROVED; proof artifact: deficient.** Let `n = bytes.len()`. [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when the slice length is zero, and [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns its element count. The unsafe branch therefore has `n > 0`. Consequently `n - 1` is representable in unsigned `usize` (no underflow under the [integer arithmetic rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)) and yields `i = n - 1 < n`. Thus `i` is in bounds, satisfying `get_unchecked`; dereferencing the shared element reference copies a valid `u8`. The empty branch executes no unsafe operation. This also proves `None` for an empty slice and `Some` of the final element otherwise.
+
+“This is the fast path” supplies none of the required obligation, dominating fact, arithmetic step, or bound. Replace it with:
+
+```rust
+// SAFETY: `is_empty()` was false, so `bytes.len() > 0`. Thus
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// which is the bounds precondition of `get_unchecked`.
+```
+
+### PL-I/PL-R — published unsafe-trait boundary closes
+
+The Rust 1.82.0 Reference requires unsafe traits to be implemented through an unsafe implementation ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe` keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); the source's published `# Safety` text is the controlling implementer contract.
+
+**PL-I: PROVED; local proof missing.** `High` supplies `INDEX = 1`, hence `INDEX < 2`, and supplies `NAME = "high"`, exactly the clause required when `INDEX == 1`. Suggested adjacent proof: `// SAFETY: INDEX is 1 (< 2), and for INDEX == 1 the required NAME is "high".`
+
+**PL-R: PROVED; local proof missing.** For every valid `L: Lane`, including unknown downstream implementations, the unsafe-trait contract entails `L::INDEX < 2`. `word.0` is always `[u32; 2]`; its public field introduces no stronger invariant and has length 2. Therefore `L::INDEX` is in bounds and `get_unchecked` is permitted. Suggested comment: `// SAFETY: Every valid Lane impl guarantees L::INDEX < 2, and word.0 is [u32; 2].`
+
+An incorrect downstream `unsafe impl` is a violated out-of-scope implementer obligation, not a hidden precondition on safe callers. Conversely, repository-visible consumers are not exhaustive: `NAME` is a literal published guarantee even though this `read` does not consume it. Removing or weakening it in a 1.x release could invalidate downstream unsafe reasoning; strengthening either clause could invalidate existing implementations. No such contract change is justified by this audit.
+
+## Minimal repair for `callback_index` (proposal only)
+
+Keep the signatures and caller-selected positions, but replace the two bodies with checked indexing:
+
+```rust
+pub fn read<P: Position>(bytes: &[u8], position: &P) -> u8 {
+    bytes[position.position()]
+}
+
+pub fn write<P: Position>(bytes: &mut [u8], position: &P, value: u8) {
+    bytes[position.position()] = value;
+}
+```
+
+This is the smallest repair: in-range behavior and both callable APIs remain; an adversarial/out-of-range safe position now causes defined bounds-check failure rather than UB. The trait could instead be replaced by `usize`, since its preservation is not required, but that is a larger public API change. Making `Position` unsafe, sealing it without usable implementations, or deleting the functions would transfer/bypass the required safe-caller functionality and is not recommended. This proposal is **not certified**: it must be implemented as a new snapshot and freshly audited, including its panic behavior across the intended ordinary profiles.
+
+## Domain closure, residual scope, and triggers
+
+No finite target enumeration was inferred. LP and PL are parametric in the request's target/profile predicates: target-dependent `usize` width is irrelevant because LP proves subtraction non-overflowing and PL uses only 1 and a fixed length 2; overflow-check and optimization choices do not alter those facts. Thus `Covered_LP = Covered_PL = Required`, establishing `Required ⊆ Covered` for each proved claim. CB-R/CB-W refute universal soundness with witnesses available throughout `Required`.
+
+This is a Rust source-level result only, not a compiler-binary, platform, security, or downstream-implementation audit. Re-audit on any source or safety-contract change, implementation of the repair, Rust/support-domain change, added configuration/generation/dependency, or new downstream-facing contract evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/C.md
new file mode 100644
index 0000000000..35b8c6bab7
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/C.md
@@ -0,0 +1,76 @@
+# Focused unsafe-Rust audit
+
+## Claim and verdict
+
+**Snapshot:** the complete supplied `lib.rs`; no generated code, dependencies, macros, FFI, assembly, or prior audit. **Supported set:** Rust and standard library 1.82.0, every target on which this source and the used items exist, and every ordinary profile. **Claim:** every well-typed safe use of the safe surfaces is free of Rust undefined behavior, provided any out-of-scope unsafe-trait implementation satisfies its published contract; the in-scope `unsafe impl` must satisfy that contract. This is a source-level claim under documented Rust abstract semantics, not a compiler-binary claim.
+
+**Combined soundness verdict: UNSOUND (F-CB).** `callback_index::read` and `write` each admit a wholly safe call that violates `get_unchecked[_mut]`'s precondition. The review did not stop at that aggregate result:
+
+- `callback_index`: `Position` alone is sound, but `read` and `write` are each **UNSOUND**.
+- `local_proof::last`: implementation **PROVED**; existing `SAFETY` comment **deficient** (F-LP).
+- `published_lane`: `Lane`'s contract, `High`'s `unsafe impl`, and `read` are **PROVED** for valid implementations (P-PL). Unknown downstream implementations and consumers do not change that literal result.
+- Mandatory documented guarantee: `High` supplies both published `Lane` constant requirements, **PROVED**. No `CONTRACT-BROKEN` witness is established.
+
+**TCB:** TCB-1 below contains only Rust 1.82 authoritative axioms; there are no additional assumptions, dependency entries, tool-derived facts, or conditional application claims. No build, test, execution, or expansion was performed.
+
+## Boundary and obligation coverage
+
+| ID | Language-reachable surface | Status / obligation |
+|---|---|---|
+| C1 | safe public `Position` and caller implementation of `position` | A safe implementation may return every `usize`; no in-bounds invariant follows. |
+| C2 | safe public `read<P: Position>` | Must prove returned position `< bytes.len()`; false (F-CB-R). |
+| C3 | safe public `write<P: Position>` | Same obligation; false (F-CB-W). |
+| L1 | safe public `last` | Empty and nonempty paths covered; implementation P-LP, comment F-LP. |
+| P1 | public `Word` tuple constructor/field; public `High` constructor | `[u32; 2]` fixes field length at two; safe construction/access introduces no stronger invariant. |
+| P2 | public unsafe `Lane`, `INDEX`, `NAME`; `unsafe impl Lane for High` | Literal implementer contract and both `High` clauses covered by P-PL-I. |
+| P3 | safe public `published_lane::read<L: Lane>` | Requires `L::INDEX < word.0.len()`; P-PL-R derives it. |
+
+There are no hidden/configuration-specific items, callbacks other than `Position::position`, custom trait methods, custom destruction, or generated surfaces in this file. Built-in auto-trait/destruction behavior creates no additional unsafe consumer here.
+
+## TCB-1: authoritative premise log
+
+All entries are accepted as the request's governing Rust 1.82 authority, apply to the full supported set, and are rechecked if that version/scope changes.
+
+- **AX-SHARED:** [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) returns a reference without bounds checking and states: “Calling this method with an out-of-bounds index is undefined behavior”. Consumers: C2, L1, P3.
+- **AX-MUT:** [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) gives the same quoted rule for a mutable reference. Consumer: C3.
+- **AX-LENGTH:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when that length is zero. Consumers: L1, P1/P3.
+- **AX-INTEGER:** the [`usize` table](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types) gives minimum zero; the [binary-operator table and overflow rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators) define integer subtraction. Thus for a `usize n != 0`, `n - 1` is representable and strictly below `n`. Consumer: L1.
+- **AX-TRAIT:** the [unsafe-trait description](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait) says an unsafe trait has extra safety conditions “that must be upheld by implementations of the trait”; the [trait rules](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits) state that a correctly implemented unsafe trait is safe to use. Consumers: P2/P3.
+
+No rejected or pending premise is consumed.
+
+## Findings and proofs
+
+### F-CB — safe callback results reach unchecked indexing
+
+**Implementation: UNSOUND; proof artifact: missing.** `Position::position` has no contract or enforcement restricting its result. A safe caller may define `P::position` to return `0`. In one valid execution, `read(&[], &P)` calls `get_unchecked(0)`; in a separate valid execution, `write(&mut [], &P, value)` calls `get_unchecked_mut(0)`. Index zero is out of bounds for the empty slice, so AX-SHARED/AX-MUT proves UB even if the resulting reference were not used. These witnesses use only safe caller syntax and work throughout the supported set. They establish F-CB-R and F-CB-W independently. No UB-free postcondition refutation is claimed.
+
+**Smallest repair:** retain all public signatures and make the two accesses safe-indexing expressions: `bytes[position.position()]` and `bytes[position.position()] = value`. Then arbitrary safe callback results cause a bounds-check panic rather than forming an unchecked out-of-bounds reference, while safe callers still choose positions and both read/write remain callable. Removing `Position` in favor of `usize` is possible but is a larger, source-breaking change and is not needed for soundness. This proposal is **not implemented and not certified**; the resulting snapshot needs a fresh audit.
+
+### F-LP — correct implementation, inadequate local proof
+
+**P-LP reconstructed proof:** On the `None` branch there is no unsafe operation. On the other branch, AX-LENGTH turns `!bytes.is_empty()` into `n = bytes.len() != 0`. Since `n: usize`, AX-INTEGER gives `n >= 1`, makes `index = n - 1` non-overflowing in every profile, and gives `index < n`. AX-SHARED's bounds obligation is therefore satisfied; it returns the last element reference, and copying its valid `u8` yields `Some(last byte)`. This proves implementation soundness over every supported target/profile.
+
+The existing comment, “This is the fast path,” states none of the required facts or implication. Replace it with:
+
+```rust
+// SAFETY: The else branch means `bytes.len() != 0`. Therefore
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// which satisfies `get_unchecked`'s bounds requirement.
+```
+
+### P-PL — published unsafe-trait composition
+
+**P-PL-I:** `High::INDEX` is `1`, hence less than `2`; because it is `1`, the contract requires and the impl supplies `NAME == "high"`. The `INDEX == 0` implication is vacuously true. Thus the in-scope `unsafe impl` discharges every literal clause, including the clause unused locally.
+
+**P-PL-R:** for every valid `L: Lane`, its published contract supplies `L::INDEX < 2`. `word.0` has exactly two elements, so the index is in bounds and AX-SHARED discharges `get_unchecked`. `read` consumes no `NAME` proposition.
+
+An incorrect unknown downstream `unsafe impl` violates its out-of-scope obligation and is not a valid implementation; it does not add a hidden precondition to safe callers. Conversely, unknown downstream consumers may rely on both `INDEX` and `NAME`. Because this is a published 1.x contract, deleting/weakening either guarantee or strengthening implementer obligations requires compatibility handling; the absence of a repository-visible `NAME` consumer is not evidence that weakening is safe.
+
+## Configuration closure, residual scope, and triggers
+
+There are no source selection axes. The proofs are parametric in target and ordinary profile: slice/array lengths and the non-overflowing arithmetic relation are unchanged; both callback witnesses remain available. No generated artifact or enforced exclusion exists or is needed.
+
+Excluded from the source theorem are correctness of a particular compiler/backend binary and downstream unsafe implementations that breach `Lane`. Unknown downstream consumers were intentionally not treated as enumerable. The proposed repair remains outside the audited snapshot.
+
+Re-audit on any source or safety-contract change; Rust/standard-library version or supported-set change; addition of cfg, generation, dependencies, or new consumers; or any evolution of the published `Lane` guarantees. No authoritative-documentation or skill-guidance gap blocked this audit. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/D.md
new file mode 100644
index 0000000000..51b4b178b6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/D.md
@@ -0,0 +1,103 @@
+# Focused unsafe-Rust source audit
+
+## Claim, domain, and result
+
+Snapshot: the complete supplied `lib.rs`; no generated code, dependencies, `cfg`, macros, FFI, or build inputs are present. `Required` is exactly Rust/stdlib 1.82.0 × every target on which this source and the used 1.82.0 std items exist × every ordinary profile. The claim quantifies over every well-typed safe call, in a context satisfying any independently introduced unsafe-code obligations (notably, downstream `unsafe impl Lane`). It is a source-level claim under documented Rust abstract semantics, not a compiler-binary claim.
+
+| Scope | Soundness verdict | Proof-artifact verdict |
+|---|---|---|
+| `callback_index::read` | **UNSOUND** (CB-R) | missing and incapable of proving the current code |
+| `callback_index::write` | **UNSOUND** (CB-W) | missing and incapable of proving the current code |
+| `local_proof::last` | **PROVED** | **deficient**; material proof reconstructed below |
+| `published_lane` (`Word`, `Lane`, `High`, `read`) | **PROVED** | trait contract adequate; `High` and `read` local proofs missing |
+| All three modules, aggregate | **UNSOUND** | CB-R and CB-W |
+
+There are no explicit function postconditions to certify. The two normative clauses of `Lane`'s published safety contract are separately discharged for the in-scope `High` implementation. No UB-free documented-postcondition counterexample was established, so `CONTRACT-BROKEN` is not claimed.
+
+## Authoritative premises (TCB-1)
+
+No additional TCB assumptions are admitted. The only ground premises are these verified Rust 1.82 authorities:
+
+- AX-SLICE: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) require the index to be in bounds; “Calling this method with an out-of-bounds index is undefined behavior.” They return a reference to the selected element when their contract holds.
+- AX-LEN: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when length is zero.
+- AX-INT: [`usize` is an unsigned integer type](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types); the [binary-operator rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators) govern subtraction and overflow. The proofs below perform subtraction only from a positive value.
+- AX-TRAIT: Rust requires an unsafe implementation for an unsafe trait and assigns such implementations extra safety invariants: [trait rules](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe` trait rules](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait).
+
+These axioms apply exactly to 1.82.0 across `Required`; there is no cross-version compatibility premise.
+
+## Boundary and obligation inventory
+
+| Surface/obligation | Disposition |
+|---|---|
+| safe, downstream-implementable `Position` and safe `position()` | An implementation may return any `usize`; no bounds invariant exists. |
+| safe `callback_index::{read, write}` | Each passes that adversarial result to an unchecked operation; false obligation, CB-R/CB-W. |
+| safe `local_proof::last` | All inputs covered by the empty/nonempty branch proof LP. |
+| public `Word(pub [u32; 2])` and its tuple constructor | Safe construction cannot alter the type-enforced length of two; no stronger invariant is needed. |
+| public unsafe `Lane`, `INDEX`, and `NAME` | Valid implementations promise `INDEX < 2` and the exact index/name mapping. Both clauses remain live published obligations. |
+| public unit `High` constructor and `unsafe impl Lane for High` | `INDEX = 1 < 2`; because it is 1, `NAME = "high"` meets the second clause. |
+| safe `published_lane::read<L: Lane>` | PL proves its unchecked access for every valid implementation, including unknown downstream ones. |
+
+There are no other constructors, methods, fields, callbacks, hidden items, reexports, generated APIs, or configuration-specific surfaces in the supplied source.
+
+## CB-R and CB-W — complete UB certificates
+
+Define, entirely in safe caller code, `struct Bad; impl Position for Bad { fn position(&self) -> usize { 1 } }`.
+
+- **CB-R valid use:** `read(&[0u8], &Bad)` is well typed and invokes only safe APIs. No caller safety precondition exists.
+- **CB-R reachability/falsity/consequence:** `position()` returns 1; the slice length is 1, so index 1 is out of bounds. `get_unchecked(1)` executes. AX-SLICE classifies that call as UB.
+- **CB-W valid use:** with `let mut a = [0u8];`, `write(&mut a, &Bad, 7)` is likewise a well-typed safe call.
+- **CB-W reachability/falsity/consequence:** `get_unchecked_mut(1)` executes on length 1; the required in-bounds proposition is false, and AX-SLICE classifies the call as UB.
+
+The witnesses use values available on every `Required` target and do not depend on optimization, overflow checks, or panic strategy. Thus both scoped universal safe-API claims are refuted throughout `Required`; one witness would also suffice for the aggregate `UNSOUND` result.
+
+### Smallest required repair (proposal only)
+
+Delete `Position` and replace the functions with:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 {
+    bytes[position]
+}
+
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+This retains caller-chosen positions and callable read/write operations, removes the caller-implementable behavioral boundary and all unsafe operations, and gives out-of-range inputs the safe indexing behavior. Removing the public trait and changing parameter types is a source/API compatibility break; migrate callers from `&P` to a `usize`. This candidate is **not certified**: implement it as a new snapshot and freshly audit its exact behavior and full domain.
+
+## LP — implementation proof and proof-documentation defect
+
+On the `None` branch no unsafe operation executes. On the other branch, AX-LEN gives `n = bytes.len() != 0`. Since `n: usize` is unsigned, `n >= 1`; therefore `n - 1` neither underflows nor varies by overflow-check profile, and `0 <= n - 1 < n`. Hence `index` is in bounds, satisfying AX-SLICE. The returned shared reference designates the last initialized `u8`; copying it into `Some` adds no aliasing or lifetime obligation. This proof is parametric over `usize` width and every target/profile in `Required`.
+
+The existing comment, “This is the fast path,” identifies neither the operation nor any precondition or fact. Replace it with:
+
+```rust
+// SAFETY: `is_empty()` was false on this branch, so `bytes.len() != 0`.
+// Thus `bytes.len() >= 1`, subtraction cannot underflow, and
+// `index = bytes.len() - 1 < bytes.len()`. `index` is therefore in bounds,
+// as required by `slice::get_unchecked`.
+```
+
+## PL — unsafe-trait proof and published-contract constraints
+
+For any valid `L: Lane`, the published unsafe contract supplies `L::INDEX < 2`. `Word.0` has type `[u32; 2]`, hence that index is in bounds and AX-SLICE discharges `read`'s unchecked access. `NAME` is not consumed locally, but it is not ignored: `High` satisfies it syntactically, and every valid downstream implementation owes it. An incorrect downstream `unsafe impl` is a violation of an out-of-scope unsafe obligation, not a valid-use counterexample to this safe generic API.
+
+Add these local proofs:
+
+```rust
+// SAFETY: `INDEX` is 1, hence less than 2, and for index 1 `NAME` is "high".
+unsafe impl Lane for High { /* unchanged items */ }
+
+// SAFETY: every valid `Lane` implementation guarantees `L::INDEX < 2`;
+// `word.0` is a two-element array, so that index is in bounds.
+unsafe { *word.0.get_unchecked(L::INDEX) }
+```
+
+Because this is a published 1.x unsafe-trait contract with unknown implementations and consumers, a repository-only search cannot authorize evolution. Weakening/removing `INDEX < 2` breaks `read`; weakening/removing the `NAME` mapping can invalidate downstream unsafe consumers; strengthening either clause can invalidate existing downstream implementations. Making the trait safe would admit arbitrary indices unless every consumer validates them, and would also withdraw guarantees from unknown consumers. Preserve the contract in 1.x; any redesign needs an explicit compatibility/migration plan and a fresh whole-ecosystem-facing audit.
+
+## Configuration closure, residual scope, and triggers
+
+Source inspection finds no configuration-selecting construct. LP and PL are parametric over target `usize` width and profile behavior; their aggregate `Covered` equals `Required`, so `Required ⊆ Covered`. CB-R/CB-W witnesses apply to every member of `Required`. Nothing was built, tested, executed, or expanded; no tool evidence is claimed.
+
+Excluded: compiler/backend correctness, binary/platform behavior beyond Rust's abstract semantics, nonexistent downstream implementation auditing, and undocumented robustness properties. Re-audit on any source or safety-contract change, implementation of the repair, support-domain/Rust-version change, or material change to a consumed Rust 1.82 authority.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/E.md
new file mode 100644
index 0000000000..6723038b06
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/E.md
@@ -0,0 +1,162 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Snapshot: the supplied 53-line `target/lib.rs`, including `callback_index`,
+`local_proof`, and `published_lane`. No generated code, dependencies, build
+scripts, FFI, assembly, allocators, concurrency, or prior audit is present.
+Review was source-only; nothing was built, executed, expanded, or modified.
+
+Claim: under Rust/stdlib 1.82.0, on every target where this source and the used
+stdlib items exist, in every ordinary profile, every well-typed safe use and
+every unsafe-trait use satisfying its published safety contract is free of
+Rust UB; additionally, every in-scope unsafe contract clause holds.
+
+**Combined verdict: UNSOUND (F-1).** Component results:
+
+- `callback_index::{read,write}`: **UNSOUND**, independently.
+- `local_proof::last`: implementation **PROVED**; existing `SAFETY` comment
+  deficient (F-2).
+- `published_lane::High`'s unsafe impl and `published_lane::read`:
+  implementation **PROVED** for every valid `Lane` implementation; local proof
+  artifacts deficient (F-3).
+- Documented contract clauses: **PROVED** for the in-scope `High` impl. There
+  are no documented unsafe-function postconditions. No
+  `CONTRACT-BROKEN` witness is claimed.
+
+The TCB is `TCB-R1`: only the Rust 1.82 authoritative axioms cited below; there
+are no additional assumptions, dependencies, tool theorems, or conditional
+application claims.
+
+## Boundary, contracts, and configuration closure
+
+Safe surfaces exhaustively covered: the caller-implementable `Position` trait
+and its safe `position` method; safe `read` and `write`; safe `last`; `Word`'s
+public tuple constructor/field; `High`'s unit constructor; `Lane`'s associated
+constants as exposed through an unsafe implementation boundary; and safe
+`published_lane::read`. Unsafe surfaces are `Lane`, downstream `unsafe impl
+Lane` declarations, and the in-scope `unsafe impl Lane for High`. There are no
+macros, reexports, hidden APIs, custom trait behavior, or invariant-relevant
+drop operations.
+
+`Position` carries no bounds invariant. `Word` needs no abstraction invariant:
+its public field always has type `[u32; 2]`. Contract `LANE-1`, owned by the
+unsafe trait boundary, requires for every valid impl: `INDEX < 2`, plus
+`NAME == "low"` when index 0 and `NAME == "high"` when index 1. Each generic
+consumer may rely on that published contract.
+
+Configuration coverage is parametric. The counterexamples use an empty slice
+and index zero and therefore apply on every included target/profile. The proved
+paths use only slice length, a fixed two-element array, and representable
+`usize` subtraction after proving non-emptiness; pointer width, optimization,
+overflow checks, and panic strategy do not alter the arguments. There is no
+conditional compilation or generated artifact to partition.
+
+## Obligation ledger and proofs
+
+| ID | Site | Required proposition | Result |
+|---|---|---|---|
+| O-1 | callback `read` | callback result is in bounds before `get_unchecked` | false; F-1 |
+| O-2 | callback `write` | callback result is in bounds before `get_unchecked_mut` | false; F-1 |
+| O-3 | `last` | `len - 1 < len` and subtraction is representable | proved; F-2 |
+| O-4 | `High` impl | both clauses of `LANE-1` | proved: `1 < 2`, name is `"high"` |
+| O-5 | lane `read` | `L::INDEX < word.0.len()` | proved from `LANE-1` and array length 2; F-3 |
+
+Rust 1.82 documents that an out-of-bounds call to
+[`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)
+or
+[`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+is UB even if the resulting reference is unused. The remaining authoritative
+premises are: [`len` returns the number of slice elements](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len),
+[`is_empty` means length zero](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty),
+the Rust 1.82 [unsigned-integer domain](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)
+and [integer arithmetic rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators),
+and the rule that an unsafe trait may impose obligations which an
+[`unsafe impl` must uphold](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits).
+These are accepted AXIOM entries in `TCB-R1`, consumed by O-1 through O-5;
+changing Rust version or any cited contract triggers re-audit.
+
+For O-3, the `else` branch establishes `!bytes.is_empty()`, hence
+`bytes.len() > 0`. Because length has type `usize`, subtracting one is
+representable; `index = len - 1` therefore satisfies `index < len`. No call or
+state transition intervenes. This exactly discharges `get_unchecked(index)`'s
+bounds condition; the shared borrow keeps the initialized `u8` element alive
+through the dereference. Thus empty input returns `None`, and nonempty input
+returns its last element without UB.
+
+For O-5, a valid `L: Lane` supplies `L::INDEX < 2`; `word.0` has exactly two
+initialized `u32` elements by its type. Therefore the index is in bounds for
+`get_unchecked`. `&Word` keeps the element alive and shared through the read.
+O-4 establishes that the selected in-scope provider `High` is valid. Unknown
+downstream implementations are not assumed correct: an implementation that
+breaks `LANE-1` violates its caller-side unsafe obligation. The generic proof
+covers every downstream implementation that does satisfy it.
+
+## Findings and repairs
+
+### F-1 — Safe caller controls an unchecked index (UNSOUND)
+
+Safe code can define `struct P; impl Position for P { fn position(&self) ->
+usize { 0 } }`. Calling `read(&[], &P)` is well-typed safe use and invokes
+`get_unchecked(0)` on a length-zero slice. Independently, passing a mutable
+empty slice to `write(..., &P, value)` invokes `get_unchecked_mut(0)`. Each
+complete execution reaches the documented UB; no hidden caller obligation can
+be added to a safe API.
+
+Smallest repair: replace both unchecked expressions with checked slice
+indexing, preserving signatures and caller-selected positions:
+
+```rust
+bytes[position.position()]
+bytes[position.position()] = value;
+```
+
+Out-of-range positions then panic rather than cause UB. Since `Position` need
+not be preserved, a later cleanup may accept `usize` directly, but that is a
+larger, source-breaking change and is unnecessary for soundness. Neither
+proposal is certified: implement it, document panic behavior as desired, and
+freshly audit the new snapshot.
+
+### F-2 — `last` proof comment is materially inadequate
+
+“This is the fast path” states neither the unsafe operation's precondition nor
+the derivation above. Implementation correctness is nevertheless proved by
+O-3. Proposed adjacent replacement:
+
+```rust
+// SAFETY: This branch establishes that `bytes.len() > 0`. Therefore
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// exactly the bound required by `get_unchecked`.
+```
+
+### F-3 — Lane implementation proofs are absent
+
+The published contract is sufficient and the code satisfies it, but neither
+the unsafe impl nor unchecked call records the proof. Add, without changing the
+contract, comments equivalent to:
+
+```rust
+// SAFETY: INDEX is 1 (< 2), and NAME is "high" as required for index 1.
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: Every valid Lane impl guarantees L::INDEX < 2, and word.0 is
+// [u32; 2], so the index is in bounds for get_unchecked.
+```
+
+Because this is a published 1.x unsafe-trait contract with unknown impls and
+consumers, do not strengthen implementer obligations or weaken/remove the
+`NAME` guarantee merely because the visible consumer uses only `INDEX`; either
+change can break downstream safety reasoning. Comment-only proof repair leaves
+the contract unchanged. Any contract change requires compatibility handling
+and a fresh audit.
+
+## Residual scope and attestation
+
+Downstream `Lane` implementations and consumers are not individually audited;
+the result is deliberately parametric over contract-satisfying impls, and no
+repository-visible inventory is treated as exhaustive. No tool-derived or test
+evidence was used. Every in-scope unsafe operation, provider, safe boundary,
+contract clause, target/profile class, and material reconstructed proof has a
+disposition above. Re-audit on source or contract edits, Rust/stdlib or support
+changes, new generated/configured code, or discovery of another consumer
+obligation.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/F.md
new file mode 100644
index 0000000000..6f0bc01b88
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/F.md
@@ -0,0 +1,148 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Artifact: the exact supplied `lib.rs`. Scope: all public and unsafe surfaces in
+`callback_index`, `local_proof`, and `published_lane`. `Supported(c)` means Rust
+and standard library 1.82.0, every target where this source and its used 1.82.0
+items exist, and every ordinary profile. There are no dependencies, `cfg`s,
+macros, generated artifacts, FFI, concurrency, or build-time inputs in the
+supplied artifact. No target was built, run, expanded, or tested.
+
+The theorem is freedom from Rust UB for every well-typed safe call and every
+unsafe-trait implementation satisfying its published safety contract, plus the
+literal `Lane` implementer contract. TCB `TCB-R182-1` consists only of the
+verified Rust 1.82 normative axioms listed below; there are no additional
+assumptions.
+
+**Combined soundness verdict: UNSOUND**, because both safe `callback_index`
+operations admit UB. Separately: `local_proof::last` implementation **PROVED**;
+its existing proof comment is deficient. `published_lane` implementation and
+its mandatory `Lane` clauses are **PROVED**. There are no other documented
+postconditions in the source. Proposed repairs below are **uncertified** until
+implemented as a new snapshot and freshly audited.
+
+## Authority / compact TCB log
+
+All entries apply exactly to Rust/std 1.82.0 over `Supported(c)`, are accepted
+as authoritative, and must be rechecked if the version or cited text changes.
+
+- **A-SLICE:** [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)
+  and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+  require the supplied index to be in bounds; an out-of-bounds index is UB even
+  if the resulting reference is unused. Consumers: CB-R, CB-W, LP-GET, PL-READ.
+- **A-LENGTH:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len)
+  returns the element count, and [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty)
+  is true exactly when that count is zero. Consumers: LP-SUB, LP-GET.
+- **A-INTEGER:** the Reference defines integer subtraction and its overflow
+  cases ([operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators));
+  `usize` is an unsigned target-width integer
+  ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)).
+  Thus for a representable `n > 0`, `n - 1` is representable and less than
+  `n`. Consumer: LP-SUB.
+- **A-UNSAFE-TRAIT:** unsafe traits may impose compiler-unchecked implementer
+  obligations and require unsafe implementation
+  ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits),
+  [`unsafe` keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+  Consumer: PL-IMPL and the quantification of PL-READ.
+
+No tool-derived evidence or non-authoritative TCB entries were used.
+
+## Boundary, invariant, and obligation coverage
+
+| ID | Surface / obligation | Disposition |
+|---|---|---|
+| CB-P | Safe, downstream-implementable `Position::position -> usize` | No contract or type constraint relates its result to any slice. Safe implementations may return every `usize`. |
+| CB-R | Safe `read`; unchecked shared access | **UNSOUND**: required `position() < bytes.len()` is not established. |
+| CB-W | Safe `write`; unchecked mutable access | **UNSOUND**: the same missing bound. |
+| LP | Safe `last`; subtraction and unchecked access | **PROVED** by the reconstruction below. |
+| PL-W | Public `Word(pub [u32; 2])`, including literal construction and field read/write | **PROVED**: every field value has the fixed two-element representation; no hidden invariant exists. |
+| PL-L | Public unsafe `Lane`, constants, and downstream unsafe impl boundary | Contract is exactly `INDEX < 2` and the stated `NAME` mapping; both clauses remain live. |
+| PL-I | Public `High` and `unsafe impl Lane for High` | **PROVED**: `1 < 2`, and at index 1 the supplied name is exactly `"high"`. |
+| PL-R | Safe generic `read<L: Lane>` and unchecked access | **PROVED** for every valid `L`: PL-L gives `L::INDEX < 2`; `word.0` has length 2, so A-SLICE is satisfied. |
+
+The only safety-relevant cross-boundary invariant is **LANE-1**: throughout
+use of a valid `Lane` implementation, `INDEX < 2`, and `NAME` equals `"low"`
+for index 0 or `"high"` for index 1. Its owner is the unsafe implementation
+boundary; implementations produce it and generic consumers may consume both
+clauses. `High` establishes it syntactically. Unknown downstream unsafe impls
+are quantified by, not silently trusted by, this theorem: an impl violating
+LANE-1 fails its explicit out-of-scope unsafe obligation.
+
+Configuration closure is parametric. The CB witnesses use index 0 and an empty
+slice on every target. LP uses only `len > 0`, making overflow checks and
+profile irrelevant. PL uses the type-level array length 2 and indices 0/1.
+Panic strategy and optimization do not change these arguments. There are no
+uncovered supported configurations.
+
+## Findings and repairs
+
+### F-CB — safe callers reach out-of-bounds unchecked access
+
+**Status: UNSOUND** for both CB-R and CB-W; proof artifacts are missing and no
+proof can exist for the current bodies. A valid all-safe witness implements
+`Position` with `position() == 0`, then calls `read(&[], &p)`. The index is out
+of bounds, so A-SLICE establishes UB. Independently, `let mut x = []; write(&mut
+x, &p, 1)` reaches the mutable form of the same UB. These whole executions need
+no caller `unsafe`. No documented-postcondition verdict is inferred from these
+UB-containing executions.
+
+Smallest proof-oriented repair, given that `Position` need not survive: remove
+the trait and accept the chosen `usize` directly, using checked safe indexing:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 { bytes[position] }
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+Both operations remain callable by safe callers with caller-chosen positions;
+an out-of-range position follows the safe indexing API's defined failure path
+rather than forming an invalid reference. This removes the unsupported premise,
+callback surface, and unsafe blocks. It changes the public signatures and
+removes a public trait, so migration is source-breaking; the request expressly
+does not require preserving that abstraction. This sketch is not certified.
+
+### F-LP-DOC — correct code, non-proof `SAFETY` comment
+
+**Implementation: PROVED. Proof artifact: deficient.** On the `else` branch,
+A-LENGTH and `!bytes.is_empty()` give `n = bytes.len() > 0`. A-INTEGER gives a
+defined `index = n - 1` with `index < n`. A-SLICE's sole relevant `usize`
+index obligation is therefore met; dereferencing yields the initialized `u8`
+last element. The empty branch performs no unsafe operation and returns `None`.
+This covers every slice and profile on every supported target.
+
+“This is the fast path” states neither the operation's obligation nor any fact
+implying it. Replace it with:
+
+```rust
+// SAFETY: This branch establishes `!bytes.is_empty()`, so `bytes.len() > 0`.
+// Hence `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// satisfying `get_unchecked`'s in-bounds requirement.
+```
+
+### F-PL-DOC/COMPAT — preserve the full published unsafe-trait contract
+
+The implementation is proved, but the two unsafe sites lack adjacent proof
+artifacts. Suggested comments are: before the impl, “SAFETY: `INDEX` is 1,
+which is less than 2, and its `NAME` is `"high"`”; before `get_unchecked`,
+“SAFETY: every valid `L: Lane` guarantees `L::INDEX < 2`, and `word.0` has
+length 2.”
+
+`NAME` is not consumed by this repository-visible `read`, but it remains a
+mandatory published 1.x implementer obligation and a guarantee available to
+unknown generic consumers. It must not be silently weakened, removed, or
+reinterpreted based on the visible consumer inventory; strengthening either
+implementer clause could likewise invalidate unknown existing impls. Any
+contract change requires an explicit breaking-version/migration decision and
+fresh audits of implementations and consumers. No source repair is required
+for current soundness.
+
+## Residual scope and review triggers
+
+Excluded: compiler-backend/binary correctness and any source, implementation,
+consumer, or configuration not supplied. Re-audit on any source or safety-text
+change; Rust/std or support-domain change; addition of cfg/generated code; or
+implementation of either proposed proof/comment repair. No current-artifact
+verdict transfers to a repaired snapshot.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/G.md
new file mode 100644
index 0000000000..4a9b181a3d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/G.md
@@ -0,0 +1,93 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Snapshot: exactly the supplied `lib.rs`. Scope is all three modules, Rust and standard library 1.82.0, every target on which this source and its used standard-library items exist, and every ordinary profile. There are no features, `cfg`s, dependencies, generated artifacts, FFI, concurrency, or build-time inputs in the supplied source.
+
+Claim: every well-typed safe use of each safe surface is free of Rust undefined behavior; uses of the unsafe `Lane` implementer boundary must satisfy its complete published contract. The result is relative only to the Rust 1.82.0 axioms recorded below; there are no additional TCB assumptions.
+
+**Combined soundness verdict: UNSOUND.** `callback_index::read` and `write` each admit an independent, wholly safe call that reaches UB. Review continued through the remaining modules: `local_proof::last` is **PROVED** sound, and `published_lane` (including `High` and generic `read`) is **PROVED** sound under the literal current `Lane` contract. Their local proof documentation is deficient. There are no documented unsafe-function postconditions. Conformance of `High` to both published trait clauses is **PROVED**.
+
+## Boundary and obligation inventory
+
+| ID | Surface or proof site | Result |
+|---|---|---|
+| CB-P | safe, downstream-implementable `Position` and safe `position` | unconstrained `usize` producer |
+| CB-R | safe `callback_index::read`; `get_unchecked` consumer | **UNSOUND** |
+| CB-W | safe `callback_index::write`; `get_unchecked_mut` consumer | **UNSOUND** |
+| LP | safe `local_proof::last`; unchecked shared access | implementation **PROVED**; comment deficient |
+| PL-W | public `Word(pub [u32; 2])`, including tuple construction/field access | **PROVED**; array length is type-enforced |
+| PL-L | public unsafe `Lane`, associated constants, downstream unsafe impl boundary | literal two-clause contract reviewed |
+| PL-H | safe `High` construction and `unsafe impl Lane for High` | implementation **PROVED**; proof comment missing |
+| PL-R | safe generic `published_lane::read`; unchecked shared access | implementation **PROVED**; proof comment missing |
+
+There is no representation invariant beyond the types. The relevant local contracts are `CB-IN-BOUNDS` (an unchecked index must be in bounds) and `LANE-1X` (`INDEX < 2`, plus the stated `NAME`/`INDEX` correspondence).
+
+## Rust 1.82.0 axioms / TCB log
+
+All entries were opened at the exact versioned URLs and are accepted only for the requested domain.
+
+- **A-SHARED:** [`slice::get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked): “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumer: CB-R, LP, PL-R.
+- **A-MUT:** [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) states the same requirement for mutable access. Consumer: CB-W.
+- **A-SLICE:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) returns true when that length is zero. Consumer: LP.
+- **A-ARITH:** The Reference classifies `usize` as an [unsigned integer type](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types), and `-` on integers as [subtraction](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators). Consumer: LP.
+- **A-TRAIT:** An unsafe trait has extra conditions that implementations must uphold, and an `unsafe impl` asserts their discharge ([unsafe-trait explanation](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); it is safe to use a correctly implemented unsafe trait ([trait rule](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)). Consumer: PL-H, PL-R.
+
+No tools, tests, executions, or sampled evidence were used.
+
+## Findings and proofs
+
+### F-CB-R — safe read reaches UB
+
+`Position` has no safety contract or enforced range. Safe downstream code can implement `position` to return `0`, then call `read(&[], &p)`. The index is out of bounds for the empty slice, yet `read` passes it to `get_unchecked`. A-SHARED therefore proves UB. No unsafe caller action or additional premise occurs. This refutes soundness on every requested target/profile.
+
+### F-CB-W — safe write independently reaches UB
+
+The analogous safe call `write(&mut [], &p, 1)` passes `0` to `get_unchecked_mut`. A-MUT proves UB. This is a separate defect and witness from F-CB-R. Neither UB-containing execution is used as a postcondition refutation.
+
+**Smallest repair:** retain the signatures and caller-implementable trait, but replace the bodies with checked indexing:
+
+```rust
+bytes[position.position()]
+bytes[position.position()] = value;
+```
+
+This preserves safe callers' ability to select positions for both reads and writes; an invalid position panics rather than becoming a hidden safety precondition. It requires neither sealing nor making `Position` unsafe. Replacing `Position` with a `usize` parameter is an optional larger API simplification, not needed for the minimal repair. **The proposal is not implemented and is not certified; audit the exact changed snapshot anew.**
+
+### F-LP-DOC — correct implementation, inadequate `SAFETY` comment
+
+Implementation proof: the unsafe path is reached only when `is_empty()` is false. By A-SLICE, `len != 0`; because `len: usize` is unsigned, `len >= 1`. A-ARITH then makes `index = len - 1` representable, with `0 <= index < len`. Thus `index` is in bounds and A-SHARED's sole safety requirement is met. Dereferencing the resulting shared reference copies its valid `u8`. The empty path performs neither subtraction nor unsafe access. This argument is parametric over target and profile; overflow checking is irrelevant because subtraction cannot underflow.
+
+“This is the fast path” states none of the obligation, dominating fact, or derivation. Replace it with:
+
+```rust
+// SAFETY: This branch establishes bytes.len() != 0. Therefore
+// index = bytes.len() - 1 is in 0..bytes.len(), as get_unchecked requires.
+```
+
+The current implementation verdict remains **PROVED**; the current proof artifact is deficient.
+
+### F-PL-PROOF — sound implementation, missing adjacent proofs
+
+`High` discharges every literal `LANE-1X` clause: `1 < 2`; the `INDEX == 1` implication requires `NAME == "high"`, which holds; the `INDEX == 0` antecedent is false. Suggested adjacent impl proof:
+
+```rust
+// SAFETY: INDEX is 1 (< 2), NAME is "high" as required for INDEX == 1,
+// and the INDEX == 0 clause is inapplicable.
+```
+
+For every valid `L: Lane`, the published first clause gives `L::INDEX < 2`. `word.0` is exactly `[u32; 2]`, so that index is in bounds and A-SHARED is satisfied. Suggested `read` proof:
+
+```rust
+// SAFETY: Lane requires L::INDEX < 2, and word.0 has exactly two elements.
+```
+
+A bad downstream `unsafe impl` is outside valid use because A-TRAIT assigns it the published obligations; no hidden condition is imposed on safe callers. The current implementations are **PROVED**, while both adjacent proof artifacts are missing.
+
+`NAME` is not consumed by this file's `read`, but remains a published 1.x implementer guarantee. Unknown downstream consumers may rely on it, including in soundness proofs. Removing or weakening it can invalidate consumers; strengthening either clause can invalidate existing implementations. Repository-visible uses cannot justify either change. Any evolution needs the applicable compatibility process and a fresh audit; this review certifies no proposed contract change.
+
+## Configuration closure, residual scope, and triggers
+
+Coverage is parametric: the callback witnesses use only an empty slice and index zero; LP derives a mathematical in-bounds index before profile-sensitive overflow behavior can differ; PL uses a fixed two-element array and the contract's strict bound. Hence target widths and ordinary profiles do not change any result. There are no generated/configuration branches to enumerate and no excluded requested cases.
+
+Residual scope is limited to implementations and consumers not supplied here: they are not individually audited, but PL-R quantifies over every implementation satisfying the published unsafe contract. Re-audit on any source or safety-contract change, Rust/standard-library version change, support-domain expansion, or implementation of either proposed documentation/code repair.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/H.md
new file mode 100644
index 0000000000..ebc686c112
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/H.md
@@ -0,0 +1,84 @@
+# Unsafe Rust source review
+
+## Claim and verdict
+
+Snapshot: the supplied `lib.rs`, source-reviewed without execution, expansion, tests, dependencies, or generated artifacts. `Supported(c)` means Rust/stdlib exactly 1.82.0, every target where this source and the used items exist, and every ordinary profile. The claim is source-level freedom from Rust UB for every well-typed safe use, in a context satisfying any explicitly published out-of-scope unsafe obligations.
+
+**Combined soundness verdict: UNSOUND** (`CBI-READ`, `CBI-WRITE`). Separately: `local_proof` implementation **PROVED**, with a deficient proof comment; `published_lane` **PROVED** for every valid `Lane` implementation. `High`'s complete published implementer contract is **PROVED**. There are no other documented postconditions. No conditional application claim is made.
+
+TCB log `R058-TCB-1`: no additional assumptions or dependencies. The accepted Rust 1.82.0 axioms are:
+
+- A1: slice `len` “Returns the number of elements in the slice”; `is_empty` “Returns `true` if the slice has a length of 0.” ([`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len), [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty)).
+- A2: `get_unchecked` and `get_unchecked_mut` return references without bounds checking, and calling either with an out-of-bounds index is UB even if the reference is unused. ([shared](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked), [mutable](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)).
+- A3: `usize` is unsigned (minimum zero), and binary `-` is subtraction; representable subtraction does not overflow. ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types), [operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)).
+- A4: an unsafe trait may impose conditions the compiler cannot verify; implementations must be unsafe and uphold its documented conditions. ([unsafe traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe trait`](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+
+These propositions apply throughout `Supported(c)`. Re-audit on source/contract changes, any Rust/stdlib or support-set change, or a change to these cited contracts.
+
+## Boundary, invariant, and obligation coverage
+
+All language-reachable surfaces were covered: `Position` and its safe caller implementations; safe `read`/`write`; safe `last`; public `Word` tuple construction/field access; unit construction of `High`; unsafe `Lane`, its associated constants and downstream unsafe impl boundary; the in-scope `unsafe impl` for `High`; and safe generic `published_lane::read`. There are no macros, hidden items, dependencies, FFI, generated APIs, or relevant custom drop/auto-trait behavior.
+
+| ID | Exact obligation | Status |
+|---|---|---|
+| CBI-READ | Every safe `Position::position()` result used by shared `get_unchecked` is `< bytes.len()` | **UNSOUND** |
+| CBI-WRITE | Every safe result used by mutable `get_unchecked_mut` is `< bytes.len()` | **UNSOUND** |
+| LOCAL | On the nonempty branch, `bytes.len() - 1` is representable and in bounds | **PROVED**; comment deficient |
+| LANE-IMPL | `High::INDEX < 2`; if index is 0/1, `NAME` is respectively `"low"`/`"high"` | **PROVED** |
+| LANE-READ | Every valid `L: Lane` has an index in the two-element `Word::0` array | **PROVED** |
+
+The only invariant consumed by `published_lane::read` is `LANE-INDEX`: every valid `Lane` implementation has `INDEX < 2`. It is owned by the unsafe trait boundary. `Word(pub [u32; 2])` needs no value invariant: arbitrary safe field replacement preserves the type-enforced length two.
+
+Configuration closure is parametric. There is no conditional source selection. A1–A4 and the type/constant facts cover all targets in scope. Profile overflow behavior is irrelevant: LOCAL proves no underflow; the callback witnesses and lane proof use 0, 1, and length 2. No configurations were sampled.
+
+## Findings
+
+### CBI-READ / CBI-WRITE — safe callbacks do not establish bounds
+
+Implementation and safe-surface classification: **UNSOUND**; proof artifacts are missing. `Position` is safe and caller-implementable, so its method may return any `usize`. No type, check, privacy boundary, or contract establishes either required inequality.
+
+Two independent entirely safe witnesses are:
+
+```rust
+struct P;
+impl callback_index::Position for P { fn position(&self) -> usize { 0 } }
+let _ = callback_index::read(&[], &P); // shared out-of-bounds call
+```
+
+and an implementation returning `1` passed to `write(&mut [0], ..., 7)`. A2 makes each whole execution UB at its respective unchecked call. These UB executions do not establish any defined postcondition refutation.
+
+Smallest requested repair: remove `Position`, accept `position: usize`, and use checked safe indexing while retaining both callable APIs:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 { bytes[position] }
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+Safe callers still choose every position; out-of-range input panics rather than causing UB. Removing the public trait and changing generic signatures is source-breaking, but the request authorizes abandoning that abstraction. This candidate is **not implemented and not certified**; freshly audit its exact implemented snapshot and specified panic/return behavior.
+
+### LOCAL — correct operation, materially inadequate comment
+
+The existing “This is the fast path” neither states A2's bounds obligation nor supplies a fact. Reconstruction: reaching `else` means `is_empty()` returned false. By A1's implication, contraposition gives `len != 0`. A3 then gives `len >= 1`, so `len - 1` is representable and strictly less than `len`. No call or mutation intervenes. A1 identifies that same `len` as the slice's element count; therefore the index is in bounds and A2 permits the shared unchecked access. Empty slices take the branch with no unsafe operation.
+
+Proposed replacement:
+
+```rust
+// SAFETY: This branch establishes `bytes.len() != 0`. Because `len()` is a
+// `usize`, `index = bytes.len() - 1` is representable and `index < bytes.len()`.
+// No mutation intervenes, so `index` is in bounds for this same slice, as
+// `get_unchecked` requires.
+```
+
+The current implementation obligation is **PROVED**; the current adjacent proof artifact remains **deficient**.
+
+### LANE — current contract closes; evolution is constrained
+
+`High` sets `(INDEX, NAME)` to `(1, "high")`, satisfying every literal conjunct. For arbitrary downstream `L`, validity of its unsafe impl supplies `INDEX < 2`; the array type supplies length exactly two, so A2's bound holds. `NAME` is not consumed by this function. An incorrect downstream `unsafe impl` violates an out-of-scope unsafe obligation and is not a safe-use counterexample.
+
+Unknown downstream impls are covered parametrically, not presumed absent. Unknown consumers may rely on the published 1.x `NAME` relation, so deleting or weakening it can invalidate their reasoning; strengthening either obligation can invalidate existing impls. Do not “clean up” that clause based only on this repository-visible consumer. Any contract change needs the applicable breaking-change process and a fresh audit; no change is proposed or certified here.
+
+## Residual scope and attestation
+
+Compiler/backend binary correctness and contexts already violating an unsafe obligation are outside the source theorem. No documentation or skill gap was needed. Every in-scope obligation and safe surface has a disposition; no test result or absence of a counterexample supports any verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/I.md
new file mode 100644
index 0000000000..076c452f97
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/I.md
@@ -0,0 +1,90 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the supplied `lib.rs`, all three modules, with no generated code, dependencies, prior result, execution, or tool-derived evidence. The source-level claim is: for every well-typed safe use (and every unsafe-trait implementation satisfying its published contract), execution is free of Rust undefined behavior under Rust 1.82.0 abstract semantics. Mandatory unsafe-contract clauses are also in scope.
+
+`Required = {exact supplied source} × {Rust and std 1.82.0} × {every target on which this source and the used 1.82.0 std items exist} × {every ordinary profile}`. The audit cutoff is 2026-08-01. There are no `cfg`s, features, macros, generators, FFI, dependencies, or enforced exclusions.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All three modules, combined soundness | **UNSOUND** | CB-R and CB-W independently establish UB from valid safe uses. |
+| `callback_index::read` | **UNSOUND** | CB-R. |
+| `callback_index::write` | **UNSOUND** | CB-W. |
+| `local_proof::last` implementation | **PROVED** | LP below; `Required ⊆ Covered`. |
+| `local_proof::last` existing `SAFETY` comment | **Deficient** | It states no obligation or derivation. |
+| `published_lane::{Lane, High, read}` | **PROVED** | PL below, for all valid `Lane` implementations; `Required ⊆ Covered`. |
+| `published_lane` proof artifacts | **Deficient** | The unsafe impl and unchecked access lack adjacent proofs. |
+
+No broader undocumented safe-API behavior (including panic freedom) is claimed. CB-R/CB-W apply on every required target/profile, so the aggregate result is not diluted by configuration uncertainty.
+
+## Authority and TCB log R080-TCB-1
+
+There are no additional TCB assumptions. These accepted Rust-1.82-only axioms are the complete trust boundary:
+
+- AX-SLICE: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) each state that an out-of-bounds call is undefined behavior, even if the reference is unused. They return shared/mutable references without bounds checking.
+- AX-LENGTH: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when length is zero.
+- AX-INTEGER: the Reference defines binary `-` as subtraction and overflow as producing a value outside the integer type's range ([operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)); `usize` is unsigned and has pointer width ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)).
+- AX-TRAIT: implementing an unsafe trait may be unsafe, while using a correctly implemented one is safe ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)); an unsafe impl asserts discharge of the trait's extra safety conditions ([unsafe keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+
+Each entry applies to all `Required` cases and is consumed below. Re-audit on source, contract, Rust version, support-domain, or cited-document change.
+
+## Boundary and obligation inventory
+
+| ID | Surface/obligation | Disposition |
+|---|---|---|
+| CB-P | Public safe `Position` trait and safe `position`; downstream safe implementations are adversarial. | No invariant enforces an in-bounds result. |
+| CB-R | Public safe `read`; unchecked shared indexing at line 9. | **UNSOUND**. |
+| CB-W | Public safe `write`; unchecked mutable indexing at line 13. | **UNSOUND**. |
+| LP | Public safe `last`; nonempty branch, subtraction, unchecked indexing at lines 19–24. | Implementation **PROVED**; comment deficient. |
+| PL-W | Public `Word(pub [u32; 2])`, including tuple construction/field access/move/drop. | The field's type enforces exactly two initialized `u32` lanes; no hidden invariant. |
+| PL-T | Public unsafe `Lane`, constants `INDEX` and `NAME`, and unknown downstream impls. | Valid impls owe both literal clauses at lines 36–37. |
+| PL-H | Safe unit construction of `High`; its unsafe `Lane` impl. | Contract **PROVED**; proof comment missing. |
+| PL-R | Public safe generic `read`; unchecked indexing at line 51. | **PROVED** for every valid impl; proof comment missing. |
+
+No other constructors, methods, callbacks, hidden items, macros, reexports, operators, or semantically relevant custom trait behavior occur in the supplied source.
+
+## Findings and proofs
+
+### CB-R — safe `read` reaches UB
+
+Let safe downstream code define `struct P; impl Position for P { fn position(&self) -> usize { 0 } }` and call `read(&[], &P)`. This is well-typed and uses no unsafe operation or undocumented precondition. Line 9 executes `get_unchecked(0)` on a slice of length zero. Index 0 is out of bounds; AX-SLICE makes the call itself UB. This proves every existential link: valid in-scope use, reachability, false bounds proposition, and authoritative UB consequence.
+
+### CB-W — safe `write` independently reaches UB
+
+With the same safe `P`, call `write(&mut [], &P, 1)`. Line 13 executes `get_unchecked_mut(0)` on length zero. The use is valid safe Rust, index 0 is out of bounds, and AX-SLICE makes that call UB before assignment. This is a second complete certificate, not merely fallout from CB-R. No UB-free documented-postcondition refutation is needed or established.
+
+**Smallest repair:** retain the public signatures and `Position`, but implement `read` as `bytes[position.position()]` and `write` as `bytes[position.position()] = value`. Safe callers still choose positions for reads and writes; out-of-range positions panic rather than violate a hidden safety condition. No caller-implementable abstraction was required to be preserved, but retaining it minimizes API and source change. This proposal is **not certified**: implement it, then freshly audit the new snapshot and its documented panic behavior if promised.
+
+### LP — correct implementation, inadequate comment
+
+On the else branch, AX-LENGTH gives `len != 0`; because `len: usize` is unsigned, `len > 0`. Therefore mathematical `len - 1` is representable, so AX-INTEGER's overflow condition is false in every overflow-check profile, and `0 ≤ index = len - 1 < len`. AX-LENGTH identifies `len` as the element count, hence `index` is in bounds. AX-SLICE discharges `get_unchecked(index)`; dereferencing the returned shared reference copies the selected valid `u8`. The empty branch performs no unsafe operation. These exhaustive branches prove soundness on `Required` and the evident result (`None` exactly for empty input; otherwise the final element).
+
+“This is the fast path” supplies none of that material derivation. Replacement:
+
+```rust
+// SAFETY: The else branch establishes `bytes.len() > 0`, so `len - 1`
+// cannot underflow and is strictly less than `bytes.len()`; `index` is in bounds.
+```
+
+### PL — current contract and unknown downstream code
+
+The published contract is a conjunction: (1) `INDEX < 2`; (2) at index 0, `NAME == "low"`; (3) at index 1, `NAME == "high"`. `High` sets index 1 and name `"high"`, discharging all applicable clauses. For any valid downstream `L`, clause (1) and `word.0: [u32; 2]` imply `L::INDEX` is in bounds, so AX-SLICE proves line 51. `read` consumes no stronger fact. Clauses (2)–(3) remain binding even though this file does not consume `NAME`: unknown published 1.x consumers may rely on them in their own unsafe proofs. Removing/weakening the mapping can invalidate consumers; strengthening it can invalidate existing impls. Either is a compatibility change requiring downstream analysis, not a documentation cleanup.
+
+Proposed adjacent proofs:
+
+```rust
+// SAFETY: `1 < 2`, and the contract requires `NAME == "high"` at index 1.
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: Every valid `Lane` impl guarantees `L::INDEX < 2`, and `word.0`
+// is `[u32; 2]`; therefore the index is in bounds.
+```
+
+These documentation proposals do not alter the current implementation verdict and remain unaudited until applied.
+
+## Configuration closure and residual scope
+
+The relevant axes are target pointer width, optimization, overflow checks/debug assertions, and panic strategy. The proofs are parametric: CB uses index zero on length zero; LP proves subtraction representable before profile-dependent overflow behavior matters; PL uses a type-level array length. Thus each stated positive proof covers all `Required`, and the witnesses refute soundness throughout it. No configuration was sampled or tested. Binary/compiler-correctness, security, and any source outside the two supplied target files are excluded.
+
+Final attestation: every supplied surface and unsafe obligation has a disposition; all citations were checked at Rust 1.82.0; no result relies on testing, a missing counterexample, hidden caller obligations, repository-visible consumer completeness, or a proposed repair.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/J.md
new file mode 100644
index 0000000000..7c024640bb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/reports/J.md
@@ -0,0 +1,97 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Audited snapshot: the supplied `target/lib.rs` in full, reviewed 2026-08-01 using the supplied unsafe-Rust skill snapshot. No generated code, dependencies, features, `cfg`, FFI, assembly, allocator, concurrency, or macro surfaces exist in the supplied target. No code was built, tested, executed, expanded, or modified.
+
+`Required(c) := c uses Rust/stdlib 1.82.0, is a target on which this exact source and the used standard-library items exist, and uses any ordinary profile.` The claim is source-level freedom from Rust undefined behavior for every well-typed safe use, while unsafe-trait implementations satisfy their published safety obligations, plus the requested behavior checks.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All three modules, aggregate soundness | **UNSOUND** | CB-READ and CB-WRITE are distinct valid safe executions reaching UB. |
+| `callback_index::read` | **UNSOUND** | CB-READ. |
+| `callback_index::write` | **UNSOUND** | CB-WRITE. |
+| `local_proof::last` implementation and requested return behavior | **PROVED** | LP below, for all `Required`. Existing proof comment is deficient. |
+| `published_lane::High` contract and `read` soundness | **PROVED** | PL below, for all `Required` and every contract-valid `Lane` implementation. Local proof artifacts are missing. |
+
+There is no `CONTRACT-BROKEN` result. The callback witnesses contain UB and therefore cannot prove a defined-behavior postcondition violation; no independent UB-free refutation was found. The combined mandatory result remains `UNSOUND`, not diluted by the independently proved modules.
+
+## Authority and TCB (`R061-TCB-1`)
+
+There are no additional assumptions. These verified Rust 1.82 axioms are the complete consumed authority:
+
+- AX-SLICE-INDEX: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) require an in-bounds index. Their common safety text states: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.”
+- AX-SLICE-SIZE: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns the element count; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when that count is zero.
+- AX-INTEGER: the Reference identifies `-` as integer subtraction and describes overflow/profile behavior; [`usize` is unsigned](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types). Thus for a nonzero `usize` value `n`, `n - 1` is representable and less than `n`, independently of overflow-check settings. See [binary arithmetic](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators).
+- AX-TRAIT: Rust says correctly implemented unsafe traits are safe to use and implementations must be `unsafe`; the unsafe keyword marks extra conditions implementations must uphold. See [unsafe traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits) and [unsafe-trait obligations](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait).
+
+Disposition: accepted as the governing versioned Rust semantics; no dependency, tool, implementation, external, deployment, probabilistic, or out-of-band entry is consumed.
+
+## Boundary and configuration closure
+
+The safe/caller-reachable inventory is complete: public safe trait `Position` and its caller-supplied method; safe `callback_index::{read, write}`; safe `local_proof::last`; public tuple constructor and field of `Word`; public unsafe trait `Lane` and associated constants; public unit constructor `High`; its `unsafe impl`; and safe `published_lane::read`. There are no hidden or configuration-generated surfaces. Ordinary compiler-supplied move/drop/auto-trait behavior creates no invariant used by an unsafe operation.
+
+The exact source is configuration-invariant. CB-READ/CB-WRITE work on every `Required` target. LP is parametric over every target's `usize` width and does not rely on profile-dependent overflow behavior. PL uses the target-independent array length 2. Therefore each proved obligation has `Covered = Required`, and `Required ⊆ Covered`; no sampled configuration or version-compatibility premise is used.
+
+## Findings and obligation proofs
+
+### CB-READ — safe callback can select an out-of-bounds index
+
+`Position` is a safe, public, downstream-implementable trait with no bound contract. Safe code may define:
+
+```rust
+struct Bad;
+impl callback_index::Position for Bad {
+    fn position(&self) -> usize { 0 }
+}
+let _ = callback_index::read(&[], &Bad);
+```
+
+This is a well-typed safe use. `read` calls `position()` once, then executes `get_unchecked(0)` on a length-zero slice. `0` is out of bounds, so AX-SLICE-INDEX entails UB at the call, before dereference relevance. This closes the full `UNSOUND` certificate: valid use, reachability, false in-bounds proposition, and authoritative UB consequence. The unsafe block has no proof comment, but the implementation defect is independently established.
+
+### CB-WRITE — independent mutable out-of-bounds witness
+
+Using the same safe `Bad` implementation:
+
+```rust
+let mut bytes: [u8; 0] = [];
+callback_index::write(&mut bytes, &Bad, 7);
+```
+
+This safe execution reaches `get_unchecked_mut(0)` on length zero. Its in-bounds condition is false, and AX-SLICE-INDEX entails UB. This is a separate certificate for `write`; exclusive borrowing does not establish bounds.
+
+Documentation cannot add a safety precondition to either safe API. Making or sealing `Position` unsafe would also fail the stated requirement that safe callers choose positions.
+
+**Smallest repair (proposal only):** retain signatures and `Position`, but replace the bodies with `bytes[position.position()]` and `bytes[position.position()] = value`. In-range behavior is retained; arbitrary safe caller-selected positions remain accepted; out-of-range positions panic rather than cause UB; and both unsafe blocks disappear. Changing the parameter to `usize` is an optional, larger API simplification, not needed for soundness. This proposal is **uncertified** until implemented and freshly audited.
+
+### LP — implementation correct; existing comment inadequate
+
+Let `n = bytes.len()`. The empty branch executes no unsafe operation and returns `None`. In the other branch, the dominating `!bytes.is_empty()` and AX-SLICE-SIZE give `n != 0`. AX-INTEGER gives representable `index = n - 1` and `index < n`; AX-SLICE-INDEX therefore permits `get_unchecked(index)`. The returned shared reference designates the final initialized `u8` in the input slice, and copying it yields `Some(bytes[n-1])`. This covers both exhaustive branches and every `Required` profile/target.
+
+The existing `SAFETY: This is the fast path` states neither the operation's precondition nor any fact or derivation. Replace it with:
+
+```rust
+// SAFETY: `bytes.is_empty()` was false, so `bytes.len() != 0`.
+// Therefore `index = bytes.len() - 1` is representable and
+// `index < bytes.len()`, satisfying `get_unchecked`'s bounds condition.
+```
+
+### PL — published contract closes the proof
+
+The published unsafe contract is literal: every valid `Lane` implementation has `INDEX < 2`, and `NAME` is `"low"` for index 0 and `"high"` for index 1. `High` establishes both clauses with `(1, "high")`. For any contract-valid downstream `L`, `Word::0` has exactly two elements and `L::INDEX < 2`; hence AX-SLICE-INDEX permits `get_unchecked`, and `read` returns `word.0[L::INDEX]`. Unknown invalid unsafe impls violate an out-of-scope implementer obligation; they are not hidden premises or valid uses.
+
+Proof artifacts are nevertheless missing. Add adjacent comments equivalent to:
+
+```rust
+// SAFETY: `INDEX` is 1 (< 2), and the required name for index 1 is "high".
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: `Lane`'s published contract gives `L::INDEX < 2`, while
+// `Word::0` has length 2, satisfying `get_unchecked`'s bounds condition.
+```
+
+Because this is a published 1.x unsafe-trait contract, repository-visible users are not exhaustive. Do not strengthen implementer obligations (unknown impls may cease to comply), weaken/remove the `NAME` guarantee (unknown consumers may rely on it), or seal/remove the trait without explicit breaking-change handling. No contract change is needed for the current proof.
+
+## Residual scope and re-audit triggers
+
+No source outside the supplied target, non-ordinary configuration, other Rust release, downstream implementation body, or downstream consumer body was audited. Re-audit after any source or safety-documentation change, repair implementation, support-domain expansion, Rust/stdlib authority change, or change to the published `Lane` contract. All current-artifact verdicts above are independent of the unimplemented proposal.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/PACKET.json
new file mode 100644
index 0000000000..9e11f8bde8
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "b6a645f1b58c1ed0dab7480352ce18df11fe7a02468fd3df7fb6b403bc40d965",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "K",
+  "presentation_order": [
+    "J",
+    "F",
+    "H",
+    "I",
+    "A",
+    "B",
+    "E",
+    "D",
+    "C",
+    "G"
+  ],
+  "report_sha256": {
+    "A": "afa2159eb13ec9ede81adee124835d0ab9c5e0468202378356654636f23d1e66",
+    "B": "beda1907cffd4ca75cd8ecb5dc9fb5526c52b20aa0e683109815e6526d752499",
+    "C": "57b8763022b39ffe547decc694003c7ce27f6f5e9caec5020f8c3174c53935f5",
+    "D": "c250345e3ded76516cb26af1a80874ba305fb015d70c75b3a82ad5eb7c3821b9",
+    "E": "40a82f89628eb8235ce387a5caaf04ff4ecfae417bd0404d05f8f307d826509b",
+    "F": "862e943f99c56fd423ac9003945cc8170717ced6c05c9d61ed681d513c1ebdf5",
+    "G": "900af7df55266fc2bb71f705014f9c2bb396adddfebb0bf70f6d3926d9939f51",
+    "H": "0e2fc947abce81854d0af02b955fbfa0b36f0bbcdaa8b7027f450a6b3c3e2d7e",
+    "I": "c5f1e887706023c4ef50e285bbe0640c6b73f461ceda3bbeca8a63e143618042",
+    "J": "18c6702f1987cf50f6511f0e1d09f515dd468abed2ad03af5d8af962d7e5c27a"
+  },
+  "rubric_sha256": "66ceb460ffb0893d9df8321707889c6f122fe0ccd9ec674fb31b07eb1ce5793e",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "c0bae3390ab041d5cd112c9d3e49235508b0b2fb8d88ac20b434b6112d04fa54"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/RUBRIC.md
new file mode 100644
index 0000000000..4d3bcb7133
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/RUBRIC.md
@@ -0,0 +1,97 @@
+# Mode K Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## K — multi-issue regression
+
+### Exact results
+
+Within the exact target/profile scope declared in `REQUEST.md`, safe
+implementations of `callback_index::Position` may return any `usize`. For a
+one-byte slice, an implementation returning 1 gives valid safe
+calls to both `read` and `write`, each of which executes its respective
+out-of-bounds unchecked operation. Both safe surfaces are independently
+`UNSOUND`.
+
+`local_proof::last` is sound. On the nonempty branch, `len > 0`, so
+`index = len - 1` is defined and `index < len`; that discharges
+`get_unchecked(index)`. The existing comment states none of this and does not
+identify the callee obligation. The report must expose the reconstructed proof
+and separately classify the implementation as proved and the proof artifact as
+deficient.
+
+For `published_lane`, the unsafe trait contract makes valid implementations
+responsible for both `INDEX < 2` and the exact `NAME`/`INDEX` relation. The shown
+`High` implementation satisfies both clauses. `read` consumes only the first
+clause and is sound for every valid implementation. Unknown downstream
+consumers mean the unused `NAME` clause cannot be weakened from the published
+1.x contract merely because `read` does not consume it.
+
+### Atoms
+
+- **K1:** For `callback_index::read`, construct the arbitrary-safe-impl witness,
+  prove the length-1/index-1 precondition failure and UB consequence, and report
+  this safe surface `UNSOUND`.
+- **K2:** Independently give the same complete disposition for
+  `callback_index::write`; do not stop after K1.
+- **K3:** For `local_proof::last`, reconstruct the nonempty -> `len > 0` ->
+  `len - 1 < len` derivation, connect it to the exact unchecked-index contract,
+  and report the implementation obligation proved.
+- **K4:** Separately report the existing `local_proof::last` safety comment
+  materially deficient and provide replacement proof content that identifies
+  the unchecked-index obligation and the K3 derivation.
+- **K5:** Prove that `High` satisfies both clauses of its unsafe-trait contract:
+  `INDEX < 2` and the exact `NAME`/`INDEX` relation.
+- **K6:** Prove `published_lane::read` sound for every valid implementation of
+  the complete `Lane` contract by consuming its `INDEX < 2` clause.
+- **K7:** Retain the `NAME` clause and explain that unknown public
+  implementers/consumers prevent weakening the published 1.x contract merely
+  because the only visible consumer uses `INDEX`.
+- **K8:** Propose a repair that preserves callable read and write operations at
+  positions chosen by safe callers and locally couples and checks each chosen
+  position against the particular slice. Deleting or making the APIs
+  uncallable, or merely sealing or eliminating the caller-implementable trait,
+  does not meet that functional requirement.
+
+Score each atom independently. Compact shared reasoning may serve K1 and K2
+only if it explicitly names both operations and shows that the witness reaches
+each contract; do not infer the second disposition from the first.
+
+### Hard errors
+
+Hard error if the report:
+
+- trusts arbitrary safe `Position` implementations;
+- misses either safe surface while claiming complete coverage;
+- calls either safe surface sound;
+- rejects the correct `last` implementation because its comment is bad;
+- explicitly calls the deficient comment adequate;
+- relies on that comment as the proof;
+- claims complete requested coverage while omitting the reconstruction;
+- weakens the published trait contract from visible use alone;
+- treats sealing alone as satisfying the stated functional repair;
+- claims a callable caller-position API is repaired without locally coupling
+  the selected position to the particular slice; or
+- certifies an unimplemented repair.
+
+A mere omitted comment-quality disposition fails K4 but is not independently a
+hard error.
+
+### Authority
+
+- Rust 1.82.0 slice `get_unchecked`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked`
+- Rust 1.82.0 slice `get_unchecked_mut`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut`
+- Rust 1.82.0 slice `len` and `is_empty`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len`
+  and
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty`
+- Rust 1.82.0 Reference, arithmetic binary operators and integer overflow:
+  `https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators`
+- Rust 1.82.0 Reference, unsigned integer value domains:
+  `https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types`
+- Rust 1.82.0 Reference, unsafe traits:
+  `https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits`
+- Rust 1.82.0 Reference, unsafe-trait proof obligations:
+  `https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait`
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/allowlist.txt
new file mode 100644
index 0000000000..5c46faa1e1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/allowlist.txt
@@ -0,0 +1,8 @@
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty
+https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators
+https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types
+https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits
+https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/A.md
new file mode 100644
index 0000000000..44eca2feab
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/A.md
@@ -0,0 +1,86 @@
+# Focused unsafe-Rust review
+
+## Claim, domain, and verdicts
+
+Snapshot: the supplied `lib.rs`, reviewed 2026-08-01 without expansion, execution, tests, or repository context. Scope is all three modules and every language-reachable surface in that file.
+
+`Required(c) := rustc/stdlib 1.82.0 AND c.target admits this exact source and every used 1.82.0 std item AND c.profile is an ordinary profile.` There are no source `cfg`s, features, dependencies, generators, FFI, concurrency, allocator choices, or profile-dependent assertions. The arguments below are parametric in target and profile, so their covered domain equals `Required`; no finite target/profile enumeration or exclusion is inferred.
+
+The TCB consists only of the linked, version-exact Rust 1.82.0 Reference and standard-library axioms; there are no additional assumptions, selected dependencies, tools, or prior results.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Combined safe-API freedom from UB | **UNSOUND** | CB-R and CB-W below are valid safe executions reaching documented UB. |
+| `callback_index::read` | **UNSOUND** | CB-R, throughout `Required`. |
+| `callback_index::write` | **UNSOUND** | CB-W, throughout `Required`. |
+| `local_proof::last` | **PROVED** | LP below, throughout `Required`; proof comment deficient. |
+| `High: Lane` contract | **PROVED** | PL-I proves both published clauses. |
+| `published_lane::read` | **PROVED** | PL-R, for every valid `Lane` implementation throughout `Required`; proof comment missing. |
+
+No unsafe function documents a provider postcondition. `Lane`'s two implementer obligations are both disposed below. No `CONTRACT-BROKEN` witness is claimed.
+
+## Boundary, invariants, and obligation ledger
+
+The complete explicit surface is: safe public `Position` and `Position::position`; safe public callback `read` and `write`; safe public `last`; public tuple struct `Word` and its field/constructor; public unsafe `Lane` and its associated constants; public unit struct `High`, its unsafe impl, and safe public lane `read`. No macros, hidden items, explicit reexports, or user-defined trait impls beyond those listed occur.
+
+**CB-NONE.** `Position` owns no slice-relative invariant. A safe implementation may return every `usize`; neither callback validates the result before consuming it.
+
+**LP-BOUND.** On the nonempty branch only, `index = bytes.len() - 1` and `index < bytes.len()`.
+
+**PL-LANE.** Each valid unsafe `Lane` impl continually supplies `INDEX < 2` and the exact `NAME` mapping in the published contract. `Word([u32; 2])` supplies length 2 by its type; its public field permits arbitrary lane values but cannot change that length.
+
+The applicable slice contracts state that out-of-bounds `get_unchecked` and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) calls are UB even if their resulting references are unused; the immutable contract says the same and expressly includes index `len` ([`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)).
+
+### CB-R — safe read has an in-scope UB witness
+
+Safe code may define `struct P; impl Position for P { fn position(&self) -> usize { 0 } }` and call `read(&[], &P)`. This is well typed, requires no unsafe act or hidden precondition, and reaches `get_unchecked(0)` on a length-zero slice. Thus 0 is out of bounds, the required safety proposition is false, and the cited contract entails UB. This completes the **UNSOUND** certificate independently of any later behavior.
+
+### CB-W — safe write has an in-scope UB witness
+
+The same safe `P` can be passed to `write(&mut [], &P, 7)`. It reaches `get_unchecked_mut(0)` on a length-zero slice, falsifying its in-bounds requirement; the cited mutable-slice contract entails UB. This separately completes **UNSOUND**.
+
+### LP — implementation proof and comment review
+
+[`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when slice length is zero, and [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns the element count. Therefore the `else` branch establishes `len != 0`. `usize` is an unsigned pointer-width integer ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)), hence `len >= 1`. Consequently `len - 1` is representable and strictly below `len`; binary subtraction overflows only when its result is outside the type's range ([operator semantics](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)). LP-BOUND therefore entails the exact `get_unchecked` precondition. Dereferencing the returned shared reference copies its valid `u8`. The empty branch performs no unsafe operation. This proves implementation soundness in every ordinary profile, including when overflow checks differ.
+
+The existing comment, “This is the fast path,” identifies neither the operation's precondition nor any fact implying it. Its proof-artifact status is **deficient** despite the proved implementation. Material replacement:
+
+```rust
+// SAFETY: The `else` branch establishes `bytes.len() != 0`. Because the
+// length is a `usize`, `index = bytes.len() - 1` is representable and
+// `index < bytes.len()`, so `index` is in bounds as `get_unchecked` requires.
+```
+
+### PL-I/PL-R — published unsafe-trait boundary
+
+Rust 1.82 says unsafe traits impose extra conditions on implementations and that an `unsafe impl` asserts those obligations are discharged ([unsafe traits and impls](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); using a correctly implemented unsafe trait is safe ([trait items](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)). This is an enforced unsafe boundary, not trust in arbitrary safe caller code.
+
+PL-I: `High` sets `INDEX = 1`, so it is less than 2, and sets `NAME = "high"`, exactly the clause applicable at index 1. The index-0 implication is vacuous. Both published obligations are proved.
+
+PL-R: for any valid (including unknown downstream) `L: Lane`, PL-LANE yields `L::INDEX < 2`; the array type yields `word.0.len() = 2`. The index is therefore in bounds and the immutable unchecked access satisfies its contract. Contents and `NAME` are irrelevant to this operation. The implementation is **PROVED**, but the unsafe block lacks the material local bridge. Proposed adjacent comment:
+
+```rust
+// SAFETY: Every valid `Lane` implementation guarantees `INDEX < 2`, and
+// `word.0` is a `[u32; 2]`; therefore `L::INDEX` is in bounds.
+```
+
+The unsafe impl likewise deserves adjacent proof text: `INDEX` is 1 (<2) and its required name is `"high"`. These documentation defects do not negate the reconstructed implementation proofs.
+
+Because this is a published 1.x unsafe contract with unknown implementations and consumers, `NAME` is not removable merely because local `read` ignores it: unsafe downstream consumers may rely on that guarantee. Strengthening implementer obligations may invalidate unknown impls; weakening guarantees may invalidate consumers. No contract change is certified here.
+
+## Repair and residual scope
+
+The smallest callback repair retains all signatures and safe caller-selected positions, evaluates the callback once, and uses checked indexing:
+
+```rust
+pub fn read<P: Position>(bytes: &[u8], position: &P) -> u8 {
+    bytes[position.position()]
+}
+pub fn write<P: Position>(bytes: &mut [u8], position: &P, value: u8) {
+    bytes[position.position()] = value;
+}
+```
+
+Out-of-range positions then panic rather than violate an unsafe precondition. Making `Position` unsafe/sealed or making either operation unsafe is unnecessary and would shift or restrict the required safe functionality. Replacing `Position` with `usize` could be a larger breaking simplification, not the smallest repair. Every proposal remains **uncertified** until implemented as a new snapshot and freshly audited.
+
+Unknown downstream `Lane` implementations and unsafe consumers were not inspected. Their compliance is their documented unsafe obligation; they do not narrow the current contract or justify changing it. Re-audit is required after any source, Rust-version, support-domain, trait-contract, or proposed-repair change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/B.md
new file mode 100644
index 0000000000..bb16779767
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/B.md
@@ -0,0 +1,73 @@
+# Focused unsafe-Rust audit
+
+## Claim, scope, and verdicts
+
+Snapshot: the exact supplied `target/lib.rs`; no expansion, execution, build, or repository history was used. `Required = {Rust 1.82.0} × {targets on which this exact source and its used 1.82.0 standard-library items exist} × {ordinary profiles}`, exactly preserving the request's symbolic target and profile predicates. The claim is freedom from Rust undefined behavior for every well-typed safe use, plus compliance with the published `Lane` implementer contract for in-scope implementations.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Whole supplied source | **UNSOUND** | CB-R and CB-W are independent valid safe-use UB witnesses. |
+| `callback_index::read` | **UNSOUND** | CB-R. |
+| `callback_index::write` | **UNSOUND** | CB-W. |
+| `local_proof::last` unsafe operation | **PROVED** | LP proves the unchecked index in bounds for every input. |
+| `published_lane::High` contract and `read` | **PROVED** | PL-I and PL-R cover every contract-valid implementation, not merely visible ones. |
+
+The combined mandatory result is therefore **UNSOUND**, without stopping review of the other modules. There are no extra TCB assumptions, dependencies, generated artifacts, tools, FFI, concurrency, or conditional code. TCB-R82 contains only the cited, exact Rust 1.82.0 Reference/standard-library contracts as governing semantics.
+
+## Boundary and obligation inventory
+
+All language-reachable surfaces are: `Position` and its safe caller-provided `position`; safe `callback_index::{read, write}`; safe `local_proof::last`; public `Word` tuple constructor/field; public `High` unit constructor; unsafe `Lane`, its associated constants, downstream `unsafe impl`s, the `High` impl, and safe `published_lane::read`. There are no macros, reexports, hidden APIs, methods, `Drop` implementations, or configuration-specific surfaces in the supplied source.
+
+Rust 1.82.0 documents for both [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut): “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.”
+
+### CB-R — safe read permits an out-of-bounds index
+
+**Implementation: UNSOUND; proof artifact: missing.** Define in safe code `struct End; impl Position for End { fn position(&self) -> usize { 0 } }`, then call `read(&[], &End)`. Implementing this safe trait, constructing the empty slice, and calling `read` are valid safe uses; `Position` has no behavioral restriction. The call reaches `get_unchecked(0)` on a length-zero slice. Index 0 is out of bounds, so the quoted Rust 1.82.0 contract entails UB. This establishes valid use, reachability, the false bounds proposition, and the UB consequence. It applies parametrically to every required target/profile.
+
+### CB-W — safe write permits an out-of-bounds index
+
+**Implementation: UNSOUND; proof artifact: missing.** With the same safe `End`, `let mut bytes = []; write(&mut bytes, &End, 7)` is a valid all-safe call. It reaches `get_unchecked_mut(0)` on a length-zero slice. The required in-bounds proposition is false and the cited mutable contract entails UB, independently of CB-R and before the assignment can justify anything. This witness is likewise target/profile-parametric.
+
+### LP — implementation correct, existing comment inadequate
+
+**Implementation: PROVED; proof artifact: deficient.** Let `n = bytes.len()`. [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when the slice length is zero, and [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns its element count. The unsafe branch therefore has `n > 0`. Consequently `n - 1` is representable in unsigned `usize` (no underflow under the [integer arithmetic rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)) and yields `i = n - 1 < n`. Thus `i` is in bounds, satisfying `get_unchecked`; dereferencing the shared element reference copies a valid `u8`. The empty branch executes no unsafe operation. This also proves `None` for an empty slice and `Some` of the final element otherwise.
+
+“This is the fast path” supplies none of the required obligation, dominating fact, arithmetic step, or bound. Replace it with:
+
+```rust
+// SAFETY: `is_empty()` was false, so `bytes.len() > 0`. Thus
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// which is the bounds precondition of `get_unchecked`.
+```
+
+### PL-I/PL-R — published unsafe-trait boundary closes
+
+The Rust 1.82.0 Reference requires unsafe traits to be implemented through an unsafe implementation ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe` keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); the source's published `# Safety` text is the controlling implementer contract.
+
+**PL-I: PROVED; local proof missing.** `High` supplies `INDEX = 1`, hence `INDEX < 2`, and supplies `NAME = "high"`, exactly the clause required when `INDEX == 1`. Suggested adjacent proof: `// SAFETY: INDEX is 1 (< 2), and for INDEX == 1 the required NAME is "high".`
+
+**PL-R: PROVED; local proof missing.** For every valid `L: Lane`, including unknown downstream implementations, the unsafe-trait contract entails `L::INDEX < 2`. `word.0` is always `[u32; 2]`; its public field introduces no stronger invariant and has length 2. Therefore `L::INDEX` is in bounds and `get_unchecked` is permitted. Suggested comment: `// SAFETY: Every valid Lane impl guarantees L::INDEX < 2, and word.0 is [u32; 2].`
+
+An incorrect downstream `unsafe impl` is a violated out-of-scope implementer obligation, not a hidden precondition on safe callers. Conversely, repository-visible consumers are not exhaustive: `NAME` is a literal published guarantee even though this `read` does not consume it. Removing or weakening it in a 1.x release could invalidate downstream unsafe reasoning; strengthening either clause could invalidate existing implementations. No such contract change is justified by this audit.
+
+## Minimal repair for `callback_index` (proposal only)
+
+Keep the signatures and caller-selected positions, but replace the two bodies with checked indexing:
+
+```rust
+pub fn read<P: Position>(bytes: &[u8], position: &P) -> u8 {
+    bytes[position.position()]
+}
+
+pub fn write<P: Position>(bytes: &mut [u8], position: &P, value: u8) {
+    bytes[position.position()] = value;
+}
+```
+
+This is the smallest repair: in-range behavior and both callable APIs remain; an adversarial/out-of-range safe position now causes defined bounds-check failure rather than UB. The trait could instead be replaced by `usize`, since its preservation is not required, but that is a larger public API change. Making `Position` unsafe, sealing it without usable implementations, or deleting the functions would transfer/bypass the required safe-caller functionality and is not recommended. This proposal is **not certified**: it must be implemented as a new snapshot and freshly audited, including its panic behavior across the intended ordinary profiles.
+
+## Domain closure, residual scope, and triggers
+
+No finite target enumeration was inferred. LP and PL are parametric in the request's target/profile predicates: target-dependent `usize` width is irrelevant because LP proves subtraction non-overflowing and PL uses only 1 and a fixed length 2; overflow-check and optimization choices do not alter those facts. Thus `Covered_LP = Covered_PL = Required`, establishing `Required ⊆ Covered` for each proved claim. CB-R/CB-W refute universal soundness with witnesses available throughout `Required`.
+
+This is a Rust source-level result only, not a compiler-binary, platform, security, or downstream-implementation audit. Re-audit on any source or safety-contract change, implementation of the repair, Rust/support-domain change, added configuration/generation/dependency, or new downstream-facing contract evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/C.md
new file mode 100644
index 0000000000..35b8c6bab7
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/C.md
@@ -0,0 +1,76 @@
+# Focused unsafe-Rust audit
+
+## Claim and verdict
+
+**Snapshot:** the complete supplied `lib.rs`; no generated code, dependencies, macros, FFI, assembly, or prior audit. **Supported set:** Rust and standard library 1.82.0, every target on which this source and the used items exist, and every ordinary profile. **Claim:** every well-typed safe use of the safe surfaces is free of Rust undefined behavior, provided any out-of-scope unsafe-trait implementation satisfies its published contract; the in-scope `unsafe impl` must satisfy that contract. This is a source-level claim under documented Rust abstract semantics, not a compiler-binary claim.
+
+**Combined soundness verdict: UNSOUND (F-CB).** `callback_index::read` and `write` each admit a wholly safe call that violates `get_unchecked[_mut]`'s precondition. The review did not stop at that aggregate result:
+
+- `callback_index`: `Position` alone is sound, but `read` and `write` are each **UNSOUND**.
+- `local_proof::last`: implementation **PROVED**; existing `SAFETY` comment **deficient** (F-LP).
+- `published_lane`: `Lane`'s contract, `High`'s `unsafe impl`, and `read` are **PROVED** for valid implementations (P-PL). Unknown downstream implementations and consumers do not change that literal result.
+- Mandatory documented guarantee: `High` supplies both published `Lane` constant requirements, **PROVED**. No `CONTRACT-BROKEN` witness is established.
+
+**TCB:** TCB-1 below contains only Rust 1.82 authoritative axioms; there are no additional assumptions, dependency entries, tool-derived facts, or conditional application claims. No build, test, execution, or expansion was performed.
+
+## Boundary and obligation coverage
+
+| ID | Language-reachable surface | Status / obligation |
+|---|---|---|
+| C1 | safe public `Position` and caller implementation of `position` | A safe implementation may return every `usize`; no in-bounds invariant follows. |
+| C2 | safe public `read<P: Position>` | Must prove returned position `< bytes.len()`; false (F-CB-R). |
+| C3 | safe public `write<P: Position>` | Same obligation; false (F-CB-W). |
+| L1 | safe public `last` | Empty and nonempty paths covered; implementation P-LP, comment F-LP. |
+| P1 | public `Word` tuple constructor/field; public `High` constructor | `[u32; 2]` fixes field length at two; safe construction/access introduces no stronger invariant. |
+| P2 | public unsafe `Lane`, `INDEX`, `NAME`; `unsafe impl Lane for High` | Literal implementer contract and both `High` clauses covered by P-PL-I. |
+| P3 | safe public `published_lane::read<L: Lane>` | Requires `L::INDEX < word.0.len()`; P-PL-R derives it. |
+
+There are no hidden/configuration-specific items, callbacks other than `Position::position`, custom trait methods, custom destruction, or generated surfaces in this file. Built-in auto-trait/destruction behavior creates no additional unsafe consumer here.
+
+## TCB-1: authoritative premise log
+
+All entries are accepted as the request's governing Rust 1.82 authority, apply to the full supported set, and are rechecked if that version/scope changes.
+
+- **AX-SHARED:** [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) returns a reference without bounds checking and states: “Calling this method with an out-of-bounds index is undefined behavior”. Consumers: C2, L1, P3.
+- **AX-MUT:** [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) gives the same quoted rule for a mutable reference. Consumer: C3.
+- **AX-LENGTH:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when that length is zero. Consumers: L1, P1/P3.
+- **AX-INTEGER:** the [`usize` table](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types) gives minimum zero; the [binary-operator table and overflow rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators) define integer subtraction. Thus for a `usize n != 0`, `n - 1` is representable and strictly below `n`. Consumer: L1.
+- **AX-TRAIT:** the [unsafe-trait description](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait) says an unsafe trait has extra safety conditions “that must be upheld by implementations of the trait”; the [trait rules](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits) state that a correctly implemented unsafe trait is safe to use. Consumers: P2/P3.
+
+No rejected or pending premise is consumed.
+
+## Findings and proofs
+
+### F-CB — safe callback results reach unchecked indexing
+
+**Implementation: UNSOUND; proof artifact: missing.** `Position::position` has no contract or enforcement restricting its result. A safe caller may define `P::position` to return `0`. In one valid execution, `read(&[], &P)` calls `get_unchecked(0)`; in a separate valid execution, `write(&mut [], &P, value)` calls `get_unchecked_mut(0)`. Index zero is out of bounds for the empty slice, so AX-SHARED/AX-MUT proves UB even if the resulting reference were not used. These witnesses use only safe caller syntax and work throughout the supported set. They establish F-CB-R and F-CB-W independently. No UB-free postcondition refutation is claimed.
+
+**Smallest repair:** retain all public signatures and make the two accesses safe-indexing expressions: `bytes[position.position()]` and `bytes[position.position()] = value`. Then arbitrary safe callback results cause a bounds-check panic rather than forming an unchecked out-of-bounds reference, while safe callers still choose positions and both read/write remain callable. Removing `Position` in favor of `usize` is possible but is a larger, source-breaking change and is not needed for soundness. This proposal is **not implemented and not certified**; the resulting snapshot needs a fresh audit.
+
+### F-LP — correct implementation, inadequate local proof
+
+**P-LP reconstructed proof:** On the `None` branch there is no unsafe operation. On the other branch, AX-LENGTH turns `!bytes.is_empty()` into `n = bytes.len() != 0`. Since `n: usize`, AX-INTEGER gives `n >= 1`, makes `index = n - 1` non-overflowing in every profile, and gives `index < n`. AX-SHARED's bounds obligation is therefore satisfied; it returns the last element reference, and copying its valid `u8` yields `Some(last byte)`. This proves implementation soundness over every supported target/profile.
+
+The existing comment, “This is the fast path,” states none of the required facts or implication. Replace it with:
+
+```rust
+// SAFETY: The else branch means `bytes.len() != 0`. Therefore
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// which satisfies `get_unchecked`'s bounds requirement.
+```
+
+### P-PL — published unsafe-trait composition
+
+**P-PL-I:** `High::INDEX` is `1`, hence less than `2`; because it is `1`, the contract requires and the impl supplies `NAME == "high"`. The `INDEX == 0` implication is vacuously true. Thus the in-scope `unsafe impl` discharges every literal clause, including the clause unused locally.
+
+**P-PL-R:** for every valid `L: Lane`, its published contract supplies `L::INDEX < 2`. `word.0` has exactly two elements, so the index is in bounds and AX-SHARED discharges `get_unchecked`. `read` consumes no `NAME` proposition.
+
+An incorrect unknown downstream `unsafe impl` violates its out-of-scope obligation and is not a valid implementation; it does not add a hidden precondition to safe callers. Conversely, unknown downstream consumers may rely on both `INDEX` and `NAME`. Because this is a published 1.x contract, deleting/weakening either guarantee or strengthening implementer obligations requires compatibility handling; the absence of a repository-visible `NAME` consumer is not evidence that weakening is safe.
+
+## Configuration closure, residual scope, and triggers
+
+There are no source selection axes. The proofs are parametric in target and ordinary profile: slice/array lengths and the non-overflowing arithmetic relation are unchanged; both callback witnesses remain available. No generated artifact or enforced exclusion exists or is needed.
+
+Excluded from the source theorem are correctness of a particular compiler/backend binary and downstream unsafe implementations that breach `Lane`. Unknown downstream consumers were intentionally not treated as enumerable. The proposed repair remains outside the audited snapshot.
+
+Re-audit on any source or safety-contract change; Rust/standard-library version or supported-set change; addition of cfg, generation, dependencies, or new consumers; or any evolution of the published `Lane` guarantees. No authoritative-documentation or skill-guidance gap blocked this audit. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/D.md
new file mode 100644
index 0000000000..51b4b178b6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/D.md
@@ -0,0 +1,103 @@
+# Focused unsafe-Rust source audit
+
+## Claim, domain, and result
+
+Snapshot: the complete supplied `lib.rs`; no generated code, dependencies, `cfg`, macros, FFI, or build inputs are present. `Required` is exactly Rust/stdlib 1.82.0 × every target on which this source and the used 1.82.0 std items exist × every ordinary profile. The claim quantifies over every well-typed safe call, in a context satisfying any independently introduced unsafe-code obligations (notably, downstream `unsafe impl Lane`). It is a source-level claim under documented Rust abstract semantics, not a compiler-binary claim.
+
+| Scope | Soundness verdict | Proof-artifact verdict |
+|---|---|---|
+| `callback_index::read` | **UNSOUND** (CB-R) | missing and incapable of proving the current code |
+| `callback_index::write` | **UNSOUND** (CB-W) | missing and incapable of proving the current code |
+| `local_proof::last` | **PROVED** | **deficient**; material proof reconstructed below |
+| `published_lane` (`Word`, `Lane`, `High`, `read`) | **PROVED** | trait contract adequate; `High` and `read` local proofs missing |
+| All three modules, aggregate | **UNSOUND** | CB-R and CB-W |
+
+There are no explicit function postconditions to certify. The two normative clauses of `Lane`'s published safety contract are separately discharged for the in-scope `High` implementation. No UB-free documented-postcondition counterexample was established, so `CONTRACT-BROKEN` is not claimed.
+
+## Authoritative premises (TCB-1)
+
+No additional TCB assumptions are admitted. The only ground premises are these verified Rust 1.82 authorities:
+
+- AX-SLICE: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) require the index to be in bounds; “Calling this method with an out-of-bounds index is undefined behavior.” They return a reference to the selected element when their contract holds.
+- AX-LEN: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when length is zero.
+- AX-INT: [`usize` is an unsigned integer type](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types); the [binary-operator rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators) govern subtraction and overflow. The proofs below perform subtraction only from a positive value.
+- AX-TRAIT: Rust requires an unsafe implementation for an unsafe trait and assigns such implementations extra safety invariants: [trait rules](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe` trait rules](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait).
+
+These axioms apply exactly to 1.82.0 across `Required`; there is no cross-version compatibility premise.
+
+## Boundary and obligation inventory
+
+| Surface/obligation | Disposition |
+|---|---|
+| safe, downstream-implementable `Position` and safe `position()` | An implementation may return any `usize`; no bounds invariant exists. |
+| safe `callback_index::{read, write}` | Each passes that adversarial result to an unchecked operation; false obligation, CB-R/CB-W. |
+| safe `local_proof::last` | All inputs covered by the empty/nonempty branch proof LP. |
+| public `Word(pub [u32; 2])` and its tuple constructor | Safe construction cannot alter the type-enforced length of two; no stronger invariant is needed. |
+| public unsafe `Lane`, `INDEX`, and `NAME` | Valid implementations promise `INDEX < 2` and the exact index/name mapping. Both clauses remain live published obligations. |
+| public unit `High` constructor and `unsafe impl Lane for High` | `INDEX = 1 < 2`; because it is 1, `NAME = "high"` meets the second clause. |
+| safe `published_lane::read<L: Lane>` | PL proves its unchecked access for every valid implementation, including unknown downstream ones. |
+
+There are no other constructors, methods, fields, callbacks, hidden items, reexports, generated APIs, or configuration-specific surfaces in the supplied source.
+
+## CB-R and CB-W — complete UB certificates
+
+Define, entirely in safe caller code, `struct Bad; impl Position for Bad { fn position(&self) -> usize { 1 } }`.
+
+- **CB-R valid use:** `read(&[0u8], &Bad)` is well typed and invokes only safe APIs. No caller safety precondition exists.
+- **CB-R reachability/falsity/consequence:** `position()` returns 1; the slice length is 1, so index 1 is out of bounds. `get_unchecked(1)` executes. AX-SLICE classifies that call as UB.
+- **CB-W valid use:** with `let mut a = [0u8];`, `write(&mut a, &Bad, 7)` is likewise a well-typed safe call.
+- **CB-W reachability/falsity/consequence:** `get_unchecked_mut(1)` executes on length 1; the required in-bounds proposition is false, and AX-SLICE classifies the call as UB.
+
+The witnesses use values available on every `Required` target and do not depend on optimization, overflow checks, or panic strategy. Thus both scoped universal safe-API claims are refuted throughout `Required`; one witness would also suffice for the aggregate `UNSOUND` result.
+
+### Smallest required repair (proposal only)
+
+Delete `Position` and replace the functions with:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 {
+    bytes[position]
+}
+
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+This retains caller-chosen positions and callable read/write operations, removes the caller-implementable behavioral boundary and all unsafe operations, and gives out-of-range inputs the safe indexing behavior. Removing the public trait and changing parameter types is a source/API compatibility break; migrate callers from `&P` to a `usize`. This candidate is **not certified**: implement it as a new snapshot and freshly audit its exact behavior and full domain.
+
+## LP — implementation proof and proof-documentation defect
+
+On the `None` branch no unsafe operation executes. On the other branch, AX-LEN gives `n = bytes.len() != 0`. Since `n: usize` is unsigned, `n >= 1`; therefore `n - 1` neither underflows nor varies by overflow-check profile, and `0 <= n - 1 < n`. Hence `index` is in bounds, satisfying AX-SLICE. The returned shared reference designates the last initialized `u8`; copying it into `Some` adds no aliasing or lifetime obligation. This proof is parametric over `usize` width and every target/profile in `Required`.
+
+The existing comment, “This is the fast path,” identifies neither the operation nor any precondition or fact. Replace it with:
+
+```rust
+// SAFETY: `is_empty()` was false on this branch, so `bytes.len() != 0`.
+// Thus `bytes.len() >= 1`, subtraction cannot underflow, and
+// `index = bytes.len() - 1 < bytes.len()`. `index` is therefore in bounds,
+// as required by `slice::get_unchecked`.
+```
+
+## PL — unsafe-trait proof and published-contract constraints
+
+For any valid `L: Lane`, the published unsafe contract supplies `L::INDEX < 2`. `Word.0` has type `[u32; 2]`, hence that index is in bounds and AX-SLICE discharges `read`'s unchecked access. `NAME` is not consumed locally, but it is not ignored: `High` satisfies it syntactically, and every valid downstream implementation owes it. An incorrect downstream `unsafe impl` is a violation of an out-of-scope unsafe obligation, not a valid-use counterexample to this safe generic API.
+
+Add these local proofs:
+
+```rust
+// SAFETY: `INDEX` is 1, hence less than 2, and for index 1 `NAME` is "high".
+unsafe impl Lane for High { /* unchanged items */ }
+
+// SAFETY: every valid `Lane` implementation guarantees `L::INDEX < 2`;
+// `word.0` is a two-element array, so that index is in bounds.
+unsafe { *word.0.get_unchecked(L::INDEX) }
+```
+
+Because this is a published 1.x unsafe-trait contract with unknown implementations and consumers, a repository-only search cannot authorize evolution. Weakening/removing `INDEX < 2` breaks `read`; weakening/removing the `NAME` mapping can invalidate downstream unsafe consumers; strengthening either clause can invalidate existing downstream implementations. Making the trait safe would admit arbitrary indices unless every consumer validates them, and would also withdraw guarantees from unknown consumers. Preserve the contract in 1.x; any redesign needs an explicit compatibility/migration plan and a fresh whole-ecosystem-facing audit.
+
+## Configuration closure, residual scope, and triggers
+
+Source inspection finds no configuration-selecting construct. LP and PL are parametric over target `usize` width and profile behavior; their aggregate `Covered` equals `Required`, so `Required ⊆ Covered`. CB-R/CB-W witnesses apply to every member of `Required`. Nothing was built, tested, executed, or expanded; no tool evidence is claimed.
+
+Excluded: compiler/backend correctness, binary/platform behavior beyond Rust's abstract semantics, nonexistent downstream implementation auditing, and undocumented robustness properties. Re-audit on any source or safety-contract change, implementation of the repair, support-domain/Rust-version change, or material change to a consumed Rust 1.82 authority.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/E.md
new file mode 100644
index 0000000000..6723038b06
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/E.md
@@ -0,0 +1,162 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Snapshot: the supplied 53-line `target/lib.rs`, including `callback_index`,
+`local_proof`, and `published_lane`. No generated code, dependencies, build
+scripts, FFI, assembly, allocators, concurrency, or prior audit is present.
+Review was source-only; nothing was built, executed, expanded, or modified.
+
+Claim: under Rust/stdlib 1.82.0, on every target where this source and the used
+stdlib items exist, in every ordinary profile, every well-typed safe use and
+every unsafe-trait use satisfying its published safety contract is free of
+Rust UB; additionally, every in-scope unsafe contract clause holds.
+
+**Combined verdict: UNSOUND (F-1).** Component results:
+
+- `callback_index::{read,write}`: **UNSOUND**, independently.
+- `local_proof::last`: implementation **PROVED**; existing `SAFETY` comment
+  deficient (F-2).
+- `published_lane::High`'s unsafe impl and `published_lane::read`:
+  implementation **PROVED** for every valid `Lane` implementation; local proof
+  artifacts deficient (F-3).
+- Documented contract clauses: **PROVED** for the in-scope `High` impl. There
+  are no documented unsafe-function postconditions. No
+  `CONTRACT-BROKEN` witness is claimed.
+
+The TCB is `TCB-R1`: only the Rust 1.82 authoritative axioms cited below; there
+are no additional assumptions, dependencies, tool theorems, or conditional
+application claims.
+
+## Boundary, contracts, and configuration closure
+
+Safe surfaces exhaustively covered: the caller-implementable `Position` trait
+and its safe `position` method; safe `read` and `write`; safe `last`; `Word`'s
+public tuple constructor/field; `High`'s unit constructor; `Lane`'s associated
+constants as exposed through an unsafe implementation boundary; and safe
+`published_lane::read`. Unsafe surfaces are `Lane`, downstream `unsafe impl
+Lane` declarations, and the in-scope `unsafe impl Lane for High`. There are no
+macros, reexports, hidden APIs, custom trait behavior, or invariant-relevant
+drop operations.
+
+`Position` carries no bounds invariant. `Word` needs no abstraction invariant:
+its public field always has type `[u32; 2]`. Contract `LANE-1`, owned by the
+unsafe trait boundary, requires for every valid impl: `INDEX < 2`, plus
+`NAME == "low"` when index 0 and `NAME == "high"` when index 1. Each generic
+consumer may rely on that published contract.
+
+Configuration coverage is parametric. The counterexamples use an empty slice
+and index zero and therefore apply on every included target/profile. The proved
+paths use only slice length, a fixed two-element array, and representable
+`usize` subtraction after proving non-emptiness; pointer width, optimization,
+overflow checks, and panic strategy do not alter the arguments. There is no
+conditional compilation or generated artifact to partition.
+
+## Obligation ledger and proofs
+
+| ID | Site | Required proposition | Result |
+|---|---|---|---|
+| O-1 | callback `read` | callback result is in bounds before `get_unchecked` | false; F-1 |
+| O-2 | callback `write` | callback result is in bounds before `get_unchecked_mut` | false; F-1 |
+| O-3 | `last` | `len - 1 < len` and subtraction is representable | proved; F-2 |
+| O-4 | `High` impl | both clauses of `LANE-1` | proved: `1 < 2`, name is `"high"` |
+| O-5 | lane `read` | `L::INDEX < word.0.len()` | proved from `LANE-1` and array length 2; F-3 |
+
+Rust 1.82 documents that an out-of-bounds call to
+[`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)
+or
+[`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+is UB even if the resulting reference is unused. The remaining authoritative
+premises are: [`len` returns the number of slice elements](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len),
+[`is_empty` means length zero](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty),
+the Rust 1.82 [unsigned-integer domain](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)
+and [integer arithmetic rules](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators),
+and the rule that an unsafe trait may impose obligations which an
+[`unsafe impl` must uphold](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits).
+These are accepted AXIOM entries in `TCB-R1`, consumed by O-1 through O-5;
+changing Rust version or any cited contract triggers re-audit.
+
+For O-3, the `else` branch establishes `!bytes.is_empty()`, hence
+`bytes.len() > 0`. Because length has type `usize`, subtracting one is
+representable; `index = len - 1` therefore satisfies `index < len`. No call or
+state transition intervenes. This exactly discharges `get_unchecked(index)`'s
+bounds condition; the shared borrow keeps the initialized `u8` element alive
+through the dereference. Thus empty input returns `None`, and nonempty input
+returns its last element without UB.
+
+For O-5, a valid `L: Lane` supplies `L::INDEX < 2`; `word.0` has exactly two
+initialized `u32` elements by its type. Therefore the index is in bounds for
+`get_unchecked`. `&Word` keeps the element alive and shared through the read.
+O-4 establishes that the selected in-scope provider `High` is valid. Unknown
+downstream implementations are not assumed correct: an implementation that
+breaks `LANE-1` violates its caller-side unsafe obligation. The generic proof
+covers every downstream implementation that does satisfy it.
+
+## Findings and repairs
+
+### F-1 — Safe caller controls an unchecked index (UNSOUND)
+
+Safe code can define `struct P; impl Position for P { fn position(&self) ->
+usize { 0 } }`. Calling `read(&[], &P)` is well-typed safe use and invokes
+`get_unchecked(0)` on a length-zero slice. Independently, passing a mutable
+empty slice to `write(..., &P, value)` invokes `get_unchecked_mut(0)`. Each
+complete execution reaches the documented UB; no hidden caller obligation can
+be added to a safe API.
+
+Smallest repair: replace both unchecked expressions with checked slice
+indexing, preserving signatures and caller-selected positions:
+
+```rust
+bytes[position.position()]
+bytes[position.position()] = value;
+```
+
+Out-of-range positions then panic rather than cause UB. Since `Position` need
+not be preserved, a later cleanup may accept `usize` directly, but that is a
+larger, source-breaking change and is unnecessary for soundness. Neither
+proposal is certified: implement it, document panic behavior as desired, and
+freshly audit the new snapshot.
+
+### F-2 — `last` proof comment is materially inadequate
+
+“This is the fast path” states neither the unsafe operation's precondition nor
+the derivation above. Implementation correctness is nevertheless proved by
+O-3. Proposed adjacent replacement:
+
+```rust
+// SAFETY: This branch establishes that `bytes.len() > 0`. Therefore
+// `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// exactly the bound required by `get_unchecked`.
+```
+
+### F-3 — Lane implementation proofs are absent
+
+The published contract is sufficient and the code satisfies it, but neither
+the unsafe impl nor unchecked call records the proof. Add, without changing the
+contract, comments equivalent to:
+
+```rust
+// SAFETY: INDEX is 1 (< 2), and NAME is "high" as required for index 1.
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: Every valid Lane impl guarantees L::INDEX < 2, and word.0 is
+// [u32; 2], so the index is in bounds for get_unchecked.
+```
+
+Because this is a published 1.x unsafe-trait contract with unknown impls and
+consumers, do not strengthen implementer obligations or weaken/remove the
+`NAME` guarantee merely because the visible consumer uses only `INDEX`; either
+change can break downstream safety reasoning. Comment-only proof repair leaves
+the contract unchanged. Any contract change requires compatibility handling
+and a fresh audit.
+
+## Residual scope and attestation
+
+Downstream `Lane` implementations and consumers are not individually audited;
+the result is deliberately parametric over contract-satisfying impls, and no
+repository-visible inventory is treated as exhaustive. No tool-derived or test
+evidence was used. Every in-scope unsafe operation, provider, safe boundary,
+contract clause, target/profile class, and material reconstructed proof has a
+disposition above. Re-audit on source or contract edits, Rust/stdlib or support
+changes, new generated/configured code, or discovery of another consumer
+obligation.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/F.md
new file mode 100644
index 0000000000..6f0bc01b88
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/F.md
@@ -0,0 +1,148 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Artifact: the exact supplied `lib.rs`. Scope: all public and unsafe surfaces in
+`callback_index`, `local_proof`, and `published_lane`. `Supported(c)` means Rust
+and standard library 1.82.0, every target where this source and its used 1.82.0
+items exist, and every ordinary profile. There are no dependencies, `cfg`s,
+macros, generated artifacts, FFI, concurrency, or build-time inputs in the
+supplied artifact. No target was built, run, expanded, or tested.
+
+The theorem is freedom from Rust UB for every well-typed safe call and every
+unsafe-trait implementation satisfying its published safety contract, plus the
+literal `Lane` implementer contract. TCB `TCB-R182-1` consists only of the
+verified Rust 1.82 normative axioms listed below; there are no additional
+assumptions.
+
+**Combined soundness verdict: UNSOUND**, because both safe `callback_index`
+operations admit UB. Separately: `local_proof::last` implementation **PROVED**;
+its existing proof comment is deficient. `published_lane` implementation and
+its mandatory `Lane` clauses are **PROVED**. There are no other documented
+postconditions in the source. Proposed repairs below are **uncertified** until
+implemented as a new snapshot and freshly audited.
+
+## Authority / compact TCB log
+
+All entries apply exactly to Rust/std 1.82.0 over `Supported(c)`, are accepted
+as authoritative, and must be rechecked if the version or cited text changes.
+
+- **A-SLICE:** [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked)
+  and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+  require the supplied index to be in bounds; an out-of-bounds index is UB even
+  if the resulting reference is unused. Consumers: CB-R, CB-W, LP-GET, PL-READ.
+- **A-LENGTH:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len)
+  returns the element count, and [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty)
+  is true exactly when that count is zero. Consumers: LP-SUB, LP-GET.
+- **A-INTEGER:** the Reference defines integer subtraction and its overflow
+  cases ([operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators));
+  `usize` is an unsigned target-width integer
+  ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)).
+  Thus for a representable `n > 0`, `n - 1` is representable and less than
+  `n`. Consumer: LP-SUB.
+- **A-UNSAFE-TRAIT:** unsafe traits may impose compiler-unchecked implementer
+  obligations and require unsafe implementation
+  ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits),
+  [`unsafe` keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+  Consumer: PL-IMPL and the quantification of PL-READ.
+
+No tool-derived evidence or non-authoritative TCB entries were used.
+
+## Boundary, invariant, and obligation coverage
+
+| ID | Surface / obligation | Disposition |
+|---|---|---|
+| CB-P | Safe, downstream-implementable `Position::position -> usize` | No contract or type constraint relates its result to any slice. Safe implementations may return every `usize`. |
+| CB-R | Safe `read`; unchecked shared access | **UNSOUND**: required `position() < bytes.len()` is not established. |
+| CB-W | Safe `write`; unchecked mutable access | **UNSOUND**: the same missing bound. |
+| LP | Safe `last`; subtraction and unchecked access | **PROVED** by the reconstruction below. |
+| PL-W | Public `Word(pub [u32; 2])`, including literal construction and field read/write | **PROVED**: every field value has the fixed two-element representation; no hidden invariant exists. |
+| PL-L | Public unsafe `Lane`, constants, and downstream unsafe impl boundary | Contract is exactly `INDEX < 2` and the stated `NAME` mapping; both clauses remain live. |
+| PL-I | Public `High` and `unsafe impl Lane for High` | **PROVED**: `1 < 2`, and at index 1 the supplied name is exactly `"high"`. |
+| PL-R | Safe generic `read<L: Lane>` and unchecked access | **PROVED** for every valid `L`: PL-L gives `L::INDEX < 2`; `word.0` has length 2, so A-SLICE is satisfied. |
+
+The only safety-relevant cross-boundary invariant is **LANE-1**: throughout
+use of a valid `Lane` implementation, `INDEX < 2`, and `NAME` equals `"low"`
+for index 0 or `"high"` for index 1. Its owner is the unsafe implementation
+boundary; implementations produce it and generic consumers may consume both
+clauses. `High` establishes it syntactically. Unknown downstream unsafe impls
+are quantified by, not silently trusted by, this theorem: an impl violating
+LANE-1 fails its explicit out-of-scope unsafe obligation.
+
+Configuration closure is parametric. The CB witnesses use index 0 and an empty
+slice on every target. LP uses only `len > 0`, making overflow checks and
+profile irrelevant. PL uses the type-level array length 2 and indices 0/1.
+Panic strategy and optimization do not change these arguments. There are no
+uncovered supported configurations.
+
+## Findings and repairs
+
+### F-CB — safe callers reach out-of-bounds unchecked access
+
+**Status: UNSOUND** for both CB-R and CB-W; proof artifacts are missing and no
+proof can exist for the current bodies. A valid all-safe witness implements
+`Position` with `position() == 0`, then calls `read(&[], &p)`. The index is out
+of bounds, so A-SLICE establishes UB. Independently, `let mut x = []; write(&mut
+x, &p, 1)` reaches the mutable form of the same UB. These whole executions need
+no caller `unsafe`. No documented-postcondition verdict is inferred from these
+UB-containing executions.
+
+Smallest proof-oriented repair, given that `Position` need not survive: remove
+the trait and accept the chosen `usize` directly, using checked safe indexing:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 { bytes[position] }
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+Both operations remain callable by safe callers with caller-chosen positions;
+an out-of-range position follows the safe indexing API's defined failure path
+rather than forming an invalid reference. This removes the unsupported premise,
+callback surface, and unsafe blocks. It changes the public signatures and
+removes a public trait, so migration is source-breaking; the request expressly
+does not require preserving that abstraction. This sketch is not certified.
+
+### F-LP-DOC — correct code, non-proof `SAFETY` comment
+
+**Implementation: PROVED. Proof artifact: deficient.** On the `else` branch,
+A-LENGTH and `!bytes.is_empty()` give `n = bytes.len() > 0`. A-INTEGER gives a
+defined `index = n - 1` with `index < n`. A-SLICE's sole relevant `usize`
+index obligation is therefore met; dereferencing yields the initialized `u8`
+last element. The empty branch performs no unsafe operation and returns `None`.
+This covers every slice and profile on every supported target.
+
+“This is the fast path” states neither the operation's obligation nor any fact
+implying it. Replace it with:
+
+```rust
+// SAFETY: This branch establishes `!bytes.is_empty()`, so `bytes.len() > 0`.
+// Hence `index = bytes.len() - 1` is representable and `index < bytes.len()`,
+// satisfying `get_unchecked`'s in-bounds requirement.
+```
+
+### F-PL-DOC/COMPAT — preserve the full published unsafe-trait contract
+
+The implementation is proved, but the two unsafe sites lack adjacent proof
+artifacts. Suggested comments are: before the impl, “SAFETY: `INDEX` is 1,
+which is less than 2, and its `NAME` is `"high"`”; before `get_unchecked`,
+“SAFETY: every valid `L: Lane` guarantees `L::INDEX < 2`, and `word.0` has
+length 2.”
+
+`NAME` is not consumed by this repository-visible `read`, but it remains a
+mandatory published 1.x implementer obligation and a guarantee available to
+unknown generic consumers. It must not be silently weakened, removed, or
+reinterpreted based on the visible consumer inventory; strengthening either
+implementer clause could likewise invalidate unknown existing impls. Any
+contract change requires an explicit breaking-version/migration decision and
+fresh audits of implementations and consumers. No source repair is required
+for current soundness.
+
+## Residual scope and review triggers
+
+Excluded: compiler-backend/binary correctness and any source, implementation,
+consumer, or configuration not supplied. Re-audit on any source or safety-text
+change; Rust/std or support-domain change; addition of cfg/generated code; or
+implementation of either proposed proof/comment repair. No current-artifact
+verdict transfers to a repaired snapshot.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/G.md
new file mode 100644
index 0000000000..4a9b181a3d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/G.md
@@ -0,0 +1,93 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Snapshot: exactly the supplied `lib.rs`. Scope is all three modules, Rust and standard library 1.82.0, every target on which this source and its used standard-library items exist, and every ordinary profile. There are no features, `cfg`s, dependencies, generated artifacts, FFI, concurrency, or build-time inputs in the supplied source.
+
+Claim: every well-typed safe use of each safe surface is free of Rust undefined behavior; uses of the unsafe `Lane` implementer boundary must satisfy its complete published contract. The result is relative only to the Rust 1.82.0 axioms recorded below; there are no additional TCB assumptions.
+
+**Combined soundness verdict: UNSOUND.** `callback_index::read` and `write` each admit an independent, wholly safe call that reaches UB. Review continued through the remaining modules: `local_proof::last` is **PROVED** sound, and `published_lane` (including `High` and generic `read`) is **PROVED** sound under the literal current `Lane` contract. Their local proof documentation is deficient. There are no documented unsafe-function postconditions. Conformance of `High` to both published trait clauses is **PROVED**.
+
+## Boundary and obligation inventory
+
+| ID | Surface or proof site | Result |
+|---|---|---|
+| CB-P | safe, downstream-implementable `Position` and safe `position` | unconstrained `usize` producer |
+| CB-R | safe `callback_index::read`; `get_unchecked` consumer | **UNSOUND** |
+| CB-W | safe `callback_index::write`; `get_unchecked_mut` consumer | **UNSOUND** |
+| LP | safe `local_proof::last`; unchecked shared access | implementation **PROVED**; comment deficient |
+| PL-W | public `Word(pub [u32; 2])`, including tuple construction/field access | **PROVED**; array length is type-enforced |
+| PL-L | public unsafe `Lane`, associated constants, downstream unsafe impl boundary | literal two-clause contract reviewed |
+| PL-H | safe `High` construction and `unsafe impl Lane for High` | implementation **PROVED**; proof comment missing |
+| PL-R | safe generic `published_lane::read`; unchecked shared access | implementation **PROVED**; proof comment missing |
+
+There is no representation invariant beyond the types. The relevant local contracts are `CB-IN-BOUNDS` (an unchecked index must be in bounds) and `LANE-1X` (`INDEX < 2`, plus the stated `NAME`/`INDEX` correspondence).
+
+## Rust 1.82.0 axioms / TCB log
+
+All entries were opened at the exact versioned URLs and are accepted only for the requested domain.
+
+- **A-SHARED:** [`slice::get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked): “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumer: CB-R, LP, PL-R.
+- **A-MUT:** [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) states the same requirement for mutable access. Consumer: CB-W.
+- **A-SLICE:** [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) returns true when that length is zero. Consumer: LP.
+- **A-ARITH:** The Reference classifies `usize` as an [unsigned integer type](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types), and `-` on integers as [subtraction](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators). Consumer: LP.
+- **A-TRAIT:** An unsafe trait has extra conditions that implementations must uphold, and an `unsafe impl` asserts their discharge ([unsafe-trait explanation](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)); it is safe to use a correctly implemented unsafe trait ([trait rule](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)). Consumer: PL-H, PL-R.
+
+No tools, tests, executions, or sampled evidence were used.
+
+## Findings and proofs
+
+### F-CB-R — safe read reaches UB
+
+`Position` has no safety contract or enforced range. Safe downstream code can implement `position` to return `0`, then call `read(&[], &p)`. The index is out of bounds for the empty slice, yet `read` passes it to `get_unchecked`. A-SHARED therefore proves UB. No unsafe caller action or additional premise occurs. This refutes soundness on every requested target/profile.
+
+### F-CB-W — safe write independently reaches UB
+
+The analogous safe call `write(&mut [], &p, 1)` passes `0` to `get_unchecked_mut`. A-MUT proves UB. This is a separate defect and witness from F-CB-R. Neither UB-containing execution is used as a postcondition refutation.
+
+**Smallest repair:** retain the signatures and caller-implementable trait, but replace the bodies with checked indexing:
+
+```rust
+bytes[position.position()]
+bytes[position.position()] = value;
+```
+
+This preserves safe callers' ability to select positions for both reads and writes; an invalid position panics rather than becoming a hidden safety precondition. It requires neither sealing nor making `Position` unsafe. Replacing `Position` with a `usize` parameter is an optional larger API simplification, not needed for the minimal repair. **The proposal is not implemented and is not certified; audit the exact changed snapshot anew.**
+
+### F-LP-DOC — correct implementation, inadequate `SAFETY` comment
+
+Implementation proof: the unsafe path is reached only when `is_empty()` is false. By A-SLICE, `len != 0`; because `len: usize` is unsigned, `len >= 1`. A-ARITH then makes `index = len - 1` representable, with `0 <= index < len`. Thus `index` is in bounds and A-SHARED's sole safety requirement is met. Dereferencing the resulting shared reference copies its valid `u8`. The empty path performs neither subtraction nor unsafe access. This argument is parametric over target and profile; overflow checking is irrelevant because subtraction cannot underflow.
+
+“This is the fast path” states none of the obligation, dominating fact, or derivation. Replace it with:
+
+```rust
+// SAFETY: This branch establishes bytes.len() != 0. Therefore
+// index = bytes.len() - 1 is in 0..bytes.len(), as get_unchecked requires.
+```
+
+The current implementation verdict remains **PROVED**; the current proof artifact is deficient.
+
+### F-PL-PROOF — sound implementation, missing adjacent proofs
+
+`High` discharges every literal `LANE-1X` clause: `1 < 2`; the `INDEX == 1` implication requires `NAME == "high"`, which holds; the `INDEX == 0` antecedent is false. Suggested adjacent impl proof:
+
+```rust
+// SAFETY: INDEX is 1 (< 2), NAME is "high" as required for INDEX == 1,
+// and the INDEX == 0 clause is inapplicable.
+```
+
+For every valid `L: Lane`, the published first clause gives `L::INDEX < 2`. `word.0` is exactly `[u32; 2]`, so that index is in bounds and A-SHARED is satisfied. Suggested `read` proof:
+
+```rust
+// SAFETY: Lane requires L::INDEX < 2, and word.0 has exactly two elements.
+```
+
+A bad downstream `unsafe impl` is outside valid use because A-TRAIT assigns it the published obligations; no hidden condition is imposed on safe callers. The current implementations are **PROVED**, while both adjacent proof artifacts are missing.
+
+`NAME` is not consumed by this file's `read`, but remains a published 1.x implementer guarantee. Unknown downstream consumers may rely on it, including in soundness proofs. Removing or weakening it can invalidate consumers; strengthening either clause can invalidate existing implementations. Repository-visible uses cannot justify either change. Any evolution needs the applicable compatibility process and a fresh audit; this review certifies no proposed contract change.
+
+## Configuration closure, residual scope, and triggers
+
+Coverage is parametric: the callback witnesses use only an empty slice and index zero; LP derives a mathematical in-bounds index before profile-sensitive overflow behavior can differ; PL uses a fixed two-element array and the contract's strict bound. Hence target widths and ordinary profiles do not change any result. There are no generated/configuration branches to enumerate and no excluded requested cases.
+
+Residual scope is limited to implementations and consumers not supplied here: they are not individually audited, but PL-R quantifies over every implementation satisfying the published unsafe contract. Re-audit on any source or safety-contract change, Rust/standard-library version change, support-domain expansion, or implementation of either proposed documentation/code repair.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/H.md
new file mode 100644
index 0000000000..ebc686c112
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/H.md
@@ -0,0 +1,84 @@
+# Unsafe Rust source review
+
+## Claim and verdict
+
+Snapshot: the supplied `lib.rs`, source-reviewed without execution, expansion, tests, dependencies, or generated artifacts. `Supported(c)` means Rust/stdlib exactly 1.82.0, every target where this source and the used items exist, and every ordinary profile. The claim is source-level freedom from Rust UB for every well-typed safe use, in a context satisfying any explicitly published out-of-scope unsafe obligations.
+
+**Combined soundness verdict: UNSOUND** (`CBI-READ`, `CBI-WRITE`). Separately: `local_proof` implementation **PROVED**, with a deficient proof comment; `published_lane` **PROVED** for every valid `Lane` implementation. `High`'s complete published implementer contract is **PROVED**. There are no other documented postconditions. No conditional application claim is made.
+
+TCB log `R058-TCB-1`: no additional assumptions or dependencies. The accepted Rust 1.82.0 axioms are:
+
+- A1: slice `len` “Returns the number of elements in the slice”; `is_empty` “Returns `true` if the slice has a length of 0.” ([`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len), [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty)).
+- A2: `get_unchecked` and `get_unchecked_mut` return references without bounds checking, and calling either with an out-of-bounds index is UB even if the reference is unused. ([shared](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked), [mutable](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)).
+- A3: `usize` is unsigned (minimum zero), and binary `-` is subtraction; representable subtraction does not overflow. ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types), [operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)).
+- A4: an unsafe trait may impose conditions the compiler cannot verify; implementations must be unsafe and uphold its documented conditions. ([unsafe traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits), [`unsafe trait`](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+
+These propositions apply throughout `Supported(c)`. Re-audit on source/contract changes, any Rust/stdlib or support-set change, or a change to these cited contracts.
+
+## Boundary, invariant, and obligation coverage
+
+All language-reachable surfaces were covered: `Position` and its safe caller implementations; safe `read`/`write`; safe `last`; public `Word` tuple construction/field access; unit construction of `High`; unsafe `Lane`, its associated constants and downstream unsafe impl boundary; the in-scope `unsafe impl` for `High`; and safe generic `published_lane::read`. There are no macros, hidden items, dependencies, FFI, generated APIs, or relevant custom drop/auto-trait behavior.
+
+| ID | Exact obligation | Status |
+|---|---|---|
+| CBI-READ | Every safe `Position::position()` result used by shared `get_unchecked` is `< bytes.len()` | **UNSOUND** |
+| CBI-WRITE | Every safe result used by mutable `get_unchecked_mut` is `< bytes.len()` | **UNSOUND** |
+| LOCAL | On the nonempty branch, `bytes.len() - 1` is representable and in bounds | **PROVED**; comment deficient |
+| LANE-IMPL | `High::INDEX < 2`; if index is 0/1, `NAME` is respectively `"low"`/`"high"` | **PROVED** |
+| LANE-READ | Every valid `L: Lane` has an index in the two-element `Word::0` array | **PROVED** |
+
+The only invariant consumed by `published_lane::read` is `LANE-INDEX`: every valid `Lane` implementation has `INDEX < 2`. It is owned by the unsafe trait boundary. `Word(pub [u32; 2])` needs no value invariant: arbitrary safe field replacement preserves the type-enforced length two.
+
+Configuration closure is parametric. There is no conditional source selection. A1–A4 and the type/constant facts cover all targets in scope. Profile overflow behavior is irrelevant: LOCAL proves no underflow; the callback witnesses and lane proof use 0, 1, and length 2. No configurations were sampled.
+
+## Findings
+
+### CBI-READ / CBI-WRITE — safe callbacks do not establish bounds
+
+Implementation and safe-surface classification: **UNSOUND**; proof artifacts are missing. `Position` is safe and caller-implementable, so its method may return any `usize`. No type, check, privacy boundary, or contract establishes either required inequality.
+
+Two independent entirely safe witnesses are:
+
+```rust
+struct P;
+impl callback_index::Position for P { fn position(&self) -> usize { 0 } }
+let _ = callback_index::read(&[], &P); // shared out-of-bounds call
+```
+
+and an implementation returning `1` passed to `write(&mut [0], ..., 7)`. A2 makes each whole execution UB at its respective unchecked call. These UB executions do not establish any defined postcondition refutation.
+
+Smallest requested repair: remove `Position`, accept `position: usize`, and use checked safe indexing while retaining both callable APIs:
+
+```rust
+pub fn read(bytes: &[u8], position: usize) -> u8 { bytes[position] }
+pub fn write(bytes: &mut [u8], position: usize, value: u8) {
+    bytes[position] = value;
+}
+```
+
+Safe callers still choose every position; out-of-range input panics rather than causing UB. Removing the public trait and changing generic signatures is source-breaking, but the request authorizes abandoning that abstraction. This candidate is **not implemented and not certified**; freshly audit its exact implemented snapshot and specified panic/return behavior.
+
+### LOCAL — correct operation, materially inadequate comment
+
+The existing “This is the fast path” neither states A2's bounds obligation nor supplies a fact. Reconstruction: reaching `else` means `is_empty()` returned false. By A1's implication, contraposition gives `len != 0`. A3 then gives `len >= 1`, so `len - 1` is representable and strictly less than `len`. No call or mutation intervenes. A1 identifies that same `len` as the slice's element count; therefore the index is in bounds and A2 permits the shared unchecked access. Empty slices take the branch with no unsafe operation.
+
+Proposed replacement:
+
+```rust
+// SAFETY: This branch establishes `bytes.len() != 0`. Because `len()` is a
+// `usize`, `index = bytes.len() - 1` is representable and `index < bytes.len()`.
+// No mutation intervenes, so `index` is in bounds for this same slice, as
+// `get_unchecked` requires.
+```
+
+The current implementation obligation is **PROVED**; the current adjacent proof artifact remains **deficient**.
+
+### LANE — current contract closes; evolution is constrained
+
+`High` sets `(INDEX, NAME)` to `(1, "high")`, satisfying every literal conjunct. For arbitrary downstream `L`, validity of its unsafe impl supplies `INDEX < 2`; the array type supplies length exactly two, so A2's bound holds. `NAME` is not consumed by this function. An incorrect downstream `unsafe impl` violates an out-of-scope unsafe obligation and is not a safe-use counterexample.
+
+Unknown downstream impls are covered parametrically, not presumed absent. Unknown consumers may rely on the published 1.x `NAME` relation, so deleting or weakening it can invalidate their reasoning; strengthening either obligation can invalidate existing impls. Do not “clean up” that clause based only on this repository-visible consumer. Any contract change needs the applicable breaking-change process and a fresh audit; no change is proposed or certified here.
+
+## Residual scope and attestation
+
+Compiler/backend binary correctness and contexts already violating an unsafe obligation are outside the source theorem. No documentation or skill gap was needed. Every in-scope obligation and safe surface has a disposition; no test result or absence of a counterexample supports any verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/I.md
new file mode 100644
index 0000000000..076c452f97
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/I.md
@@ -0,0 +1,90 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the supplied `lib.rs`, all three modules, with no generated code, dependencies, prior result, execution, or tool-derived evidence. The source-level claim is: for every well-typed safe use (and every unsafe-trait implementation satisfying its published contract), execution is free of Rust undefined behavior under Rust 1.82.0 abstract semantics. Mandatory unsafe-contract clauses are also in scope.
+
+`Required = {exact supplied source} × {Rust and std 1.82.0} × {every target on which this source and the used 1.82.0 std items exist} × {every ordinary profile}`. The audit cutoff is 2026-08-01. There are no `cfg`s, features, macros, generators, FFI, dependencies, or enforced exclusions.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All three modules, combined soundness | **UNSOUND** | CB-R and CB-W independently establish UB from valid safe uses. |
+| `callback_index::read` | **UNSOUND** | CB-R. |
+| `callback_index::write` | **UNSOUND** | CB-W. |
+| `local_proof::last` implementation | **PROVED** | LP below; `Required ⊆ Covered`. |
+| `local_proof::last` existing `SAFETY` comment | **Deficient** | It states no obligation or derivation. |
+| `published_lane::{Lane, High, read}` | **PROVED** | PL below, for all valid `Lane` implementations; `Required ⊆ Covered`. |
+| `published_lane` proof artifacts | **Deficient** | The unsafe impl and unchecked access lack adjacent proofs. |
+
+No broader undocumented safe-API behavior (including panic freedom) is claimed. CB-R/CB-W apply on every required target/profile, so the aggregate result is not diluted by configuration uncertainty.
+
+## Authority and TCB log R080-TCB-1
+
+There are no additional TCB assumptions. These accepted Rust-1.82-only axioms are the complete trust boundary:
+
+- AX-SLICE: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) each state that an out-of-bounds call is undefined behavior, even if the reference is unused. They return shared/mutable references without bounds checking.
+- AX-LENGTH: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) “Returns the number of elements in the slice”; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when length is zero.
+- AX-INTEGER: the Reference defines binary `-` as subtraction and overflow as producing a value outside the integer type's range ([operators](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)); `usize` is unsigned and has pointer width ([integer types](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types)).
+- AX-TRAIT: implementing an unsafe trait may be unsafe, while using a correctly implemented one is safe ([traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits)); an unsafe impl asserts discharge of the trait's extra safety conditions ([unsafe keyword](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait)).
+
+Each entry applies to all `Required` cases and is consumed below. Re-audit on source, contract, Rust version, support-domain, or cited-document change.
+
+## Boundary and obligation inventory
+
+| ID | Surface/obligation | Disposition |
+|---|---|---|
+| CB-P | Public safe `Position` trait and safe `position`; downstream safe implementations are adversarial. | No invariant enforces an in-bounds result. |
+| CB-R | Public safe `read`; unchecked shared indexing at line 9. | **UNSOUND**. |
+| CB-W | Public safe `write`; unchecked mutable indexing at line 13. | **UNSOUND**. |
+| LP | Public safe `last`; nonempty branch, subtraction, unchecked indexing at lines 19–24. | Implementation **PROVED**; comment deficient. |
+| PL-W | Public `Word(pub [u32; 2])`, including tuple construction/field access/move/drop. | The field's type enforces exactly two initialized `u32` lanes; no hidden invariant. |
+| PL-T | Public unsafe `Lane`, constants `INDEX` and `NAME`, and unknown downstream impls. | Valid impls owe both literal clauses at lines 36–37. |
+| PL-H | Safe unit construction of `High`; its unsafe `Lane` impl. | Contract **PROVED**; proof comment missing. |
+| PL-R | Public safe generic `read`; unchecked indexing at line 51. | **PROVED** for every valid impl; proof comment missing. |
+
+No other constructors, methods, callbacks, hidden items, macros, reexports, operators, or semantically relevant custom trait behavior occur in the supplied source.
+
+## Findings and proofs
+
+### CB-R — safe `read` reaches UB
+
+Let safe downstream code define `struct P; impl Position for P { fn position(&self) -> usize { 0 } }` and call `read(&[], &P)`. This is well-typed and uses no unsafe operation or undocumented precondition. Line 9 executes `get_unchecked(0)` on a slice of length zero. Index 0 is out of bounds; AX-SLICE makes the call itself UB. This proves every existential link: valid in-scope use, reachability, false bounds proposition, and authoritative UB consequence.
+
+### CB-W — safe `write` independently reaches UB
+
+With the same safe `P`, call `write(&mut [], &P, 1)`. Line 13 executes `get_unchecked_mut(0)` on length zero. The use is valid safe Rust, index 0 is out of bounds, and AX-SLICE makes that call UB before assignment. This is a second complete certificate, not merely fallout from CB-R. No UB-free documented-postcondition refutation is needed or established.
+
+**Smallest repair:** retain the public signatures and `Position`, but implement `read` as `bytes[position.position()]` and `write` as `bytes[position.position()] = value`. Safe callers still choose positions for reads and writes; out-of-range positions panic rather than violate a hidden safety condition. No caller-implementable abstraction was required to be preserved, but retaining it minimizes API and source change. This proposal is **not certified**: implement it, then freshly audit the new snapshot and its documented panic behavior if promised.
+
+### LP — correct implementation, inadequate comment
+
+On the else branch, AX-LENGTH gives `len != 0`; because `len: usize` is unsigned, `len > 0`. Therefore mathematical `len - 1` is representable, so AX-INTEGER's overflow condition is false in every overflow-check profile, and `0 ≤ index = len - 1 < len`. AX-LENGTH identifies `len` as the element count, hence `index` is in bounds. AX-SLICE discharges `get_unchecked(index)`; dereferencing the returned shared reference copies the selected valid `u8`. The empty branch performs no unsafe operation. These exhaustive branches prove soundness on `Required` and the evident result (`None` exactly for empty input; otherwise the final element).
+
+“This is the fast path” supplies none of that material derivation. Replacement:
+
+```rust
+// SAFETY: The else branch establishes `bytes.len() > 0`, so `len - 1`
+// cannot underflow and is strictly less than `bytes.len()`; `index` is in bounds.
+```
+
+### PL — current contract and unknown downstream code
+
+The published contract is a conjunction: (1) `INDEX < 2`; (2) at index 0, `NAME == "low"`; (3) at index 1, `NAME == "high"`. `High` sets index 1 and name `"high"`, discharging all applicable clauses. For any valid downstream `L`, clause (1) and `word.0: [u32; 2]` imply `L::INDEX` is in bounds, so AX-SLICE proves line 51. `read` consumes no stronger fact. Clauses (2)–(3) remain binding even though this file does not consume `NAME`: unknown published 1.x consumers may rely on them in their own unsafe proofs. Removing/weakening the mapping can invalidate consumers; strengthening it can invalidate existing impls. Either is a compatibility change requiring downstream analysis, not a documentation cleanup.
+
+Proposed adjacent proofs:
+
+```rust
+// SAFETY: `1 < 2`, and the contract requires `NAME == "high"` at index 1.
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: Every valid `Lane` impl guarantees `L::INDEX < 2`, and `word.0`
+// is `[u32; 2]`; therefore the index is in bounds.
+```
+
+These documentation proposals do not alter the current implementation verdict and remain unaudited until applied.
+
+## Configuration closure and residual scope
+
+The relevant axes are target pointer width, optimization, overflow checks/debug assertions, and panic strategy. The proofs are parametric: CB uses index zero on length zero; LP proves subtraction representable before profile-dependent overflow behavior matters; PL uses a type-level array length. Thus each stated positive proof covers all `Required`, and the witnesses refute soundness throughout it. No configuration was sampled or tested. Binary/compiler-correctness, security, and any source outside the two supplied target files are excluded.
+
+Final attestation: every supplied surface and unsafe obligation has a disposition; all citations were checked at Rust 1.82.0; no result relies on testing, a missing counterexample, hidden caller obligations, repository-visible consumer completeness, or a proposed repair.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/J.md
new file mode 100644
index 0000000000..7c024640bb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/reports/J.md
@@ -0,0 +1,97 @@
+# Focused unsafe-Rust audit
+
+## Claim, snapshot, and verdict
+
+Audited snapshot: the supplied `target/lib.rs` in full, reviewed 2026-08-01 using the supplied unsafe-Rust skill snapshot. No generated code, dependencies, features, `cfg`, FFI, assembly, allocator, concurrency, or macro surfaces exist in the supplied target. No code was built, tested, executed, expanded, or modified.
+
+`Required(c) := c uses Rust/stdlib 1.82.0, is a target on which this exact source and the used standard-library items exist, and uses any ordinary profile.` The claim is source-level freedom from Rust undefined behavior for every well-typed safe use, while unsafe-trait implementations satisfy their published safety obligations, plus the requested behavior checks.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All three modules, aggregate soundness | **UNSOUND** | CB-READ and CB-WRITE are distinct valid safe executions reaching UB. |
+| `callback_index::read` | **UNSOUND** | CB-READ. |
+| `callback_index::write` | **UNSOUND** | CB-WRITE. |
+| `local_proof::last` implementation and requested return behavior | **PROVED** | LP below, for all `Required`. Existing proof comment is deficient. |
+| `published_lane::High` contract and `read` soundness | **PROVED** | PL below, for all `Required` and every contract-valid `Lane` implementation. Local proof artifacts are missing. |
+
+There is no `CONTRACT-BROKEN` result. The callback witnesses contain UB and therefore cannot prove a defined-behavior postcondition violation; no independent UB-free refutation was found. The combined mandatory result remains `UNSOUND`, not diluted by the independently proved modules.
+
+## Authority and TCB (`R061-TCB-1`)
+
+There are no additional assumptions. These verified Rust 1.82 axioms are the complete consumed authority:
+
+- AX-SLICE-INDEX: [`get_unchecked`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked) and [`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) require an in-bounds index. Their common safety text states: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.”
+- AX-SLICE-SIZE: [`len`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.len) returns the element count; [`is_empty`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.is_empty) is true exactly when that count is zero.
+- AX-INTEGER: the Reference identifies `-` as integer subtraction and describes overflow/profile behavior; [`usize` is unsigned](https://doc.rust-lang.org/1.82.0/reference/types/numeric.html#integer-types). Thus for a nonzero `usize` value `n`, `n - 1` is representable and less than `n`, independently of overflow-check settings. See [binary arithmetic](https://doc.rust-lang.org/1.82.0/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators).
+- AX-TRAIT: Rust says correctly implemented unsafe traits are safe to use and implementations must be `unsafe`; the unsafe keyword marks extra conditions implementations must uphold. See [unsafe traits](https://doc.rust-lang.org/1.82.0/reference/items/traits.html#unsafe-traits) and [unsafe-trait obligations](https://doc.rust-lang.org/1.82.0/reference/unsafe-keyword.html#unsafe-traits-unsafe-trait).
+
+Disposition: accepted as the governing versioned Rust semantics; no dependency, tool, implementation, external, deployment, probabilistic, or out-of-band entry is consumed.
+
+## Boundary and configuration closure
+
+The safe/caller-reachable inventory is complete: public safe trait `Position` and its caller-supplied method; safe `callback_index::{read, write}`; safe `local_proof::last`; public tuple constructor and field of `Word`; public unsafe trait `Lane` and associated constants; public unit constructor `High`; its `unsafe impl`; and safe `published_lane::read`. There are no hidden or configuration-generated surfaces. Ordinary compiler-supplied move/drop/auto-trait behavior creates no invariant used by an unsafe operation.
+
+The exact source is configuration-invariant. CB-READ/CB-WRITE work on every `Required` target. LP is parametric over every target's `usize` width and does not rely on profile-dependent overflow behavior. PL uses the target-independent array length 2. Therefore each proved obligation has `Covered = Required`, and `Required ⊆ Covered`; no sampled configuration or version-compatibility premise is used.
+
+## Findings and obligation proofs
+
+### CB-READ — safe callback can select an out-of-bounds index
+
+`Position` is a safe, public, downstream-implementable trait with no bound contract. Safe code may define:
+
+```rust
+struct Bad;
+impl callback_index::Position for Bad {
+    fn position(&self) -> usize { 0 }
+}
+let _ = callback_index::read(&[], &Bad);
+```
+
+This is a well-typed safe use. `read` calls `position()` once, then executes `get_unchecked(0)` on a length-zero slice. `0` is out of bounds, so AX-SLICE-INDEX entails UB at the call, before dereference relevance. This closes the full `UNSOUND` certificate: valid use, reachability, false in-bounds proposition, and authoritative UB consequence. The unsafe block has no proof comment, but the implementation defect is independently established.
+
+### CB-WRITE — independent mutable out-of-bounds witness
+
+Using the same safe `Bad` implementation:
+
+```rust
+let mut bytes: [u8; 0] = [];
+callback_index::write(&mut bytes, &Bad, 7);
+```
+
+This safe execution reaches `get_unchecked_mut(0)` on length zero. Its in-bounds condition is false, and AX-SLICE-INDEX entails UB. This is a separate certificate for `write`; exclusive borrowing does not establish bounds.
+
+Documentation cannot add a safety precondition to either safe API. Making or sealing `Position` unsafe would also fail the stated requirement that safe callers choose positions.
+
+**Smallest repair (proposal only):** retain signatures and `Position`, but replace the bodies with `bytes[position.position()]` and `bytes[position.position()] = value`. In-range behavior is retained; arbitrary safe caller-selected positions remain accepted; out-of-range positions panic rather than cause UB; and both unsafe blocks disappear. Changing the parameter to `usize` is an optional, larger API simplification, not needed for soundness. This proposal is **uncertified** until implemented and freshly audited.
+
+### LP — implementation correct; existing comment inadequate
+
+Let `n = bytes.len()`. The empty branch executes no unsafe operation and returns `None`. In the other branch, the dominating `!bytes.is_empty()` and AX-SLICE-SIZE give `n != 0`. AX-INTEGER gives representable `index = n - 1` and `index < n`; AX-SLICE-INDEX therefore permits `get_unchecked(index)`. The returned shared reference designates the final initialized `u8` in the input slice, and copying it yields `Some(bytes[n-1])`. This covers both exhaustive branches and every `Required` profile/target.
+
+The existing `SAFETY: This is the fast path` states neither the operation's precondition nor any fact or derivation. Replace it with:
+
+```rust
+// SAFETY: `bytes.is_empty()` was false, so `bytes.len() != 0`.
+// Therefore `index = bytes.len() - 1` is representable and
+// `index < bytes.len()`, satisfying `get_unchecked`'s bounds condition.
+```
+
+### PL — published contract closes the proof
+
+The published unsafe contract is literal: every valid `Lane` implementation has `INDEX < 2`, and `NAME` is `"low"` for index 0 and `"high"` for index 1. `High` establishes both clauses with `(1, "high")`. For any contract-valid downstream `L`, `Word::0` has exactly two elements and `L::INDEX < 2`; hence AX-SLICE-INDEX permits `get_unchecked`, and `read` returns `word.0[L::INDEX]`. Unknown invalid unsafe impls violate an out-of-scope implementer obligation; they are not hidden premises or valid uses.
+
+Proof artifacts are nevertheless missing. Add adjacent comments equivalent to:
+
+```rust
+// SAFETY: `INDEX` is 1 (< 2), and the required name for index 1 is "high".
+unsafe impl Lane for High { /* unchanged */ }
+
+// SAFETY: `Lane`'s published contract gives `L::INDEX < 2`, while
+// `Word::0` has length 2, satisfying `get_unchecked`'s bounds condition.
+```
+
+Because this is a published 1.x unsafe-trait contract, repository-visible users are not exhaustive. Do not strengthen implementer obligations (unknown impls may cease to comply), weaken/remove the `NAME` guarantee (unknown consumers may rely on it), or seal/remove the trait without explicit breaking-change handling. No contract change is needed for the current proof.
+
+## Residual scope and re-audit triggers
+
+No source outside the supplied target, non-ordinary configuration, other Rust release, downstream implementation body, or downstream consumer body was audited. Re-audit after any source or safety-documentation change, repair implementation, support-domain expansion, Rust/stdlib authority change, or change to the published `Lane` contract. All current-artifact verdicts above are independent of the unimplemented proposal.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/K/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/PACKET.json
new file mode 100644
index 0000000000..5949e44d9e
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "M",
+  "presentation_order": [
+    "F",
+    "E",
+    "D",
+    "G",
+    "A",
+    "C",
+    "J",
+    "I",
+    "H",
+    "B"
+  ],
+  "report_sha256": {
+    "A": "e963c7770bfa0ee351fff523e1a2e992ade90c82028c9b017731d53e2319c647",
+    "B": "06e79bd6b8b63d837b56c80f95a012f301f5b47ab10d2112882ae72c41f0ea7f",
+    "C": "acbc1ad06963f179d034a1daec025f797ff8576dcda40718197ed2dbdd639acc",
+    "D": "6a4721ff173210588f9720b233d83c613ca6e460b15e46c52b311793b090f9d2",
+    "E": "f171bae3f575098cdab781093b1dc9e5455f576fc232bf6c0eadf70ce1a634fe",
+    "F": "52351c5c0755e56dc544a5814cc0bfaeb51f1cf6000e4db4a24ab2699e927812",
+    "G": "cfa8049918cc9eb89660940173c43c86bda06e974d3ef134b3f82fb21dbcb3af",
+    "H": "b9cfc956cc8580d2722d554a8e40b81f781aab75650f69efd833756f9b67b355",
+    "I": "46a2e9a7de676f0249b9a248e2d2d18a0894fb0379999bc3721cb31e84c4db9d",
+    "J": "3e728c8ae2e5aea7eecfd5af8aab61c637c06478e3182e6f7dccdaa569a170c2"
+  },
+  "rubric_sha256": "d06d60ffd6b3478500caabb2ca88bb4b9327a7c63a3f0d913633ecb9a837d6e2",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/RUBRIC.md
new file mode 100644
index 0000000000..dbd98585cc
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/RUBRIC.md
@@ -0,0 +1,171 @@
+# Mode M Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## M — Multi-release affirmative certificates
+
+Target: supplied M snapshot.
+
+Let `C_M` be every supported target times every ordinary profile. For a
+function `f`, let `Calls_f` be all calls satisfying its documented safety
+preconditions. The exact required domains are:
+
+- `Required(M-ack) = V_ack times C_M times Calls_ack`, where
+  `V_ack = {1.80.0, 1.80.1, 1.81.0, 1.82.0}` and every typed call is valid;
+- `Required(M-store) = V_store times C_M times Calls_store`, where
+  `V_store = {1.80.0, 1.81.0}`;
+- `Required(M-copy) = V_copy times C_M times Calls_copy`, where
+  `V_copy = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`; and
+- `Required(M-load) = V_load times C_M times Calls_load`, where
+  `V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`.
+
+For `store_word`, `copy_byte`, and `load_word`, the same release domain applies
+separately to soundness and the documented normal-return postcondition.
+
+### Expected results and atoms
+
+- **M1 — `acknowledge` domain:** Preserve exact finite set `V_ack` and its
+  target/profile product; every well-typed call is in `Calls_ack` because the
+  API adds no safety precondition.
+- **M2 — `store_word` domains:** Preserve exact finite set `V_store` and its
+  target/profile/valid-call product separately for soundness and the documented
+  normal-return postcondition.
+- **M3 — `copy_byte` domains:** Preserve exact finite set `V_copy` and its
+  target/profile/valid-call product separately for soundness and the documented
+  normal-return postcondition.
+- **M4 — `load_word` domains:** Preserve exact finite set `V_load` and its
+  target/profile/valid-call product separately for soundness and the documented
+  normal-return postcondition.
+
+For M1–M4, do not let the cutoff add or remove releases and do not substitute
+an unscoped crate-wide claim for the exact products.
+
+- **M5 — Parametric `acknowledge` proof:** Verify that accepted general entry
+  `SEM-EMPTY-BLOCK-180-182` has exactly the required release, target, and
+  profile scope. Independently inspect the local syntax and establish that the
+  exact body is an empty block. For arbitrary
+  `(v, target, profile, call) in Required(M-ack)`, combine only those premises:
+  `acknowledge` is zero-parameter and unit-returning, the valid call has defined
+  callee evaluation and returns `()`, and the `unsafe fn` marker changes only
+  its static caller obligation. Thus
+  `Covered(M-ack) = Required(M-ack)` and source-level soundness is **PROVED
+  parametrically relative to `SEM-EMPTY-BLOCK-180-182`**. Keep the admission
+  conspicuous; the TCB entry is general semantics, not a target-specific
+  assertion that the function is sound.
+- **M6 — `store_word` soundness partition:** The 1.80.0 `ptr::write` authority
+  applies exactly to the 1.80.0 case and the 1.81.0 authority to the 1.81.0
+  case. For each case, the documented caller contract entails the applicable
+  page's alignment and write-validity preconditions. The identity
+  `V_store = {1.80.0} union {1.81.0}` proves exhaustiveness. Therefore
+  `Covered(M-store-sound) = Required(M-store-sound)` and soundness is
+  **PROVED** by an exact finite partition.
+- **M7 — `store_word` postcondition partition:** In each exact release case,
+  the applicable page says that `ptr::write(dst, value)` writes the supplied
+  `value` to `dst` without reading or dropping the old value. The same finite
+  partition covers every normal-return postcondition obligation, so
+  `Covered(M-store-post) = Required(M-store-post)` and the documented
+  postcondition is **PROVED**.
+- **M8 — `copy_byte` soundness under the exact TCB:** Verify the Rust 1.80.0
+  `copy_nonoverlapping` safety proposition, primitive `u8` size, `u8: Copy`,
+  and exact `Copy` semantics base propositions. Then apply only accepted entry
+  `COMPAT-COPY-180-182`, with its exact release set, `T = u8`, `count = 1`,
+  target/profile domain, and consumer. The caller contract entails its source
+  and destination validity, initialization, alignment, and nonoverlap clauses;
+  the admitted `u8` and `Copy` facts establish the one-byte specialization and
+  avoid the ownership hazard for non-`Copy` values. Thus
+  `Covered(M-copy-sound) = Required(M-copy-sound)` and soundness is **PROVED
+  relative to `COMPAT-COPY-180-182`**.
+- **M9 — `copy_byte` postcondition under the exact TCB:** The accepted entry
+  preserves the base proposition that the call copies the source byte into the
+  destination while leaving the source byte unchanged; `u8` has size one and
+  implements `Copy` with the cited copy rather than move semantics. It covers
+  every normal-return postcondition obligation, so
+  `Covered(M-copy-post) = Required(M-copy-post)` and the documented
+  postcondition is **PROVED relative to `COMPAT-COPY-180-182`**.
+- **M10 — `load_word` soundness remainder:** In the 1.80.0 and 1.82.0 endpoint
+  cases, the exact `ptr::read` Safety sections plus exact-version `u32: Copy`
+  and `Copy`-semantics facts prove soundness from the caller contract,
+  including safe retention of the source value alongside the returned copy.
+  Thus
+  `Covered(M-load-sound) = {1.80.0, 1.82.0} times C_M times Calls_load`.
+  The 1.80.1 and 1.81.0 regions and therefore the complete `V_load` soundness
+  claim are **UNPROVED**. No UB witness is supplied, so `UNSOUND` does not
+  follow.
+- **M11 — `load_word` postcondition remainder:** In the same two endpoint
+  cases, the applicable `ptr::read` descriptions establish that the returned
+  value is read from `src` while the source is left unchanged; the exact
+  `u32: Copy` and `Copy`-semantics facts discharge the ownership qualification.
+  Therefore
+  `Covered(M-load-post) = {1.80.0, 1.82.0} times C_M times Calls_load`.
+  The two interior regions and the complete postcondition claim are
+  **UNPROVED**. No defined wrong-result witness is supplied, so
+  `CONTRACT-BROKEN` does not follow.
+
+Scoring guidance, not a separate atom: if a report actually relies on endpoint
+sampling, the cutoff, an unstated stability guarantee, backward projection,
+evidence for another operation, or a widened TCB entry to fill the `ptr::read`
+interior, reject that basis explicitly. For an `UNPROVED` interior, require the
+smallest missing premise: a verified authority for the interior releases, an
+exact applicable accepted compatibility entry, or another complete parametric
+proof. A report that uses none of the listed invalid bases need not recite them.
+
+### M hard errors
+
+Any of these is a hard error:
+
+- reporting the complete `load_word` claim `PROVED` by endpoint sampling,
+  cutoff reasoning, a stability badge, unprovided interior docs, or another
+  operation's evidence;
+- claiming `Required subset Covered` for `load_word` while omitting either
+  interior release;
+- silently widening `COMPAT-COPY-180-182` by release, operation, type/count,
+  target/profile domain, proposition, or consumer;
+- silently widening `SEM-EMPTY-BLOCK-180-182` by release, source shape,
+  proposition, or consumer;
+- treating either accepted entry as authoritative Rust text rather than a
+  conspicuous TCB premise;
+- projecting a later Rust proposition backward to an earlier release without
+  an exact applicable premise; or
+- issuing `UNSOUND` or `CONTRACT-BROKEN` for an unresolved interior merely from
+  failure to prove it.
+
+Failure to establish a required positive regional result is an atom failure. It
+is not by itself a hard error unless the report also makes one of the false
+affirmative or scope-changing claims above.
+
+### M checked authorities
+
+Open each exact page and confirm the named description and Safety propositions,
+including all qualifications relevant to its exact release case:
+
+- `https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html`
+  — overwrites without reading or dropping the old value; `dst` must be valid
+  for writes and properly aligned.
+- `https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html`
+  — the same exact propositions for the separate 1.81.0 case.
+- `https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html`
+  — copies `count * size_of::<T>()` bytes; source/destination validity,
+  alignment, and nonoverlap requirements; base case only.
+- `https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout`
+  — `u8` has size 1.
+- `https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8`
+  — `u8` implements `Copy` in the compatibility base case.
+- `https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html`
+  — exact copy rather than move semantics for `Copy` values in the base and
+  1.80.0 endpoint cases.
+- `https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html`
+  — reads without moving, leaves source unchanged, and requires read validity,
+  alignment, and initialization for this non-ZST.
+- `https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32`
+  — `u32` implements `Copy` in the 1.80.0 endpoint case.
+- `https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html`
+  — the same named propositions for the separate endpoint case.
+- `https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32`
+  — `u32` implements `Copy` in the 1.82.0 endpoint case.
+- `https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html`
+  — exact copy rather than move semantics for `Copy` values in the 1.82.0
+  endpoint case.
+
+The `acknowledge` and compatibility results additionally consume the two exact
+accepted propositions in target file `TCB.md`; that file is not Rust authority
+and both admissions must remain identified as part of the conditional TCB.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/allowlist.txt
new file mode 100644
index 0000000000..d74c62056e
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/allowlist.txt
@@ -0,0 +1,11 @@
+https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html
+https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html
+https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html
+https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout
+https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8
+https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html
+https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html
+https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32
+https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html
+https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32
+https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/A.md
new file mode 100644
index 0000000000..52da9e9ef5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/A.md
@@ -0,0 +1,61 @@
+# Source-only unsafe Rust audit
+
+## Claim, snapshot, and domain
+
+This audits exactly the four exported unsafe functions in `target/lib.rs`, under their published caller contracts, for absence of Rust undefined behavior and every documented postcondition. The snapshot is the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; no generated code, dependencies, tools, builds, or execution are involved. Audit cutoff: 2026-07-31. TCB revision: the submitted `TCB.md`.
+
+`SUPPORT.md` expressly defines complete finite sets, so no interval inference is used:
+
+- `V_ack = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+- `V_store = {1.80.0, 1.81.0}`
+- `V_copy = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+- `V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+
+For each, `Required` is its exact release set crossed with every target where the item exists, every ordinary debug/release profile, and every call satisfying its documented safety obligations. The explicit completeness statement proves equality between each list and its `Required` release projection. There is no `cfg`, generator, feature, or profile-dependent source. Target/profile coverage below is parametric: the cited abstract operation contract is unqualified over those axes, or the accepted TCB entry expressly quantifies over them.
+
+## Verdict ledger
+
+| API / component | Exact `Covered` release region | Regional and full-domain verdict |
+|---|---|---|
+| `acknowledge` soundness | `V_ack` | **PROVED** on `V_ack` |
+| `acknowledge` postconditions | No prose postcondition; unit return is covered on `V_ack` | **PROVED** for the signature-implied `()` return |
+| `store_word` soundness | `V_store` | **PROVED** on `V_store` |
+| `store_word`: destination contains `value` | `V_store` | **PROVED** on `V_store` |
+| `store_word`: old `u16` is not read | `V_store` | **PROVED** on `V_store` |
+| `store_word`: old `u16` is not dropped | `V_store` | **PROVED** on `V_store` |
+| `copy_byte` soundness | `V_copy` | **PROVED** on `V_copy` |
+| `copy_byte`: destination byte equals the pre-call source byte | `V_copy` | **PROVED** on `V_copy` |
+| `copy_byte`: source byte is preserved | `V_copy` | **PROVED** on `V_copy` |
+| `load_word` soundness | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+| `load_word`: return equals the initialized pre-call source `u32` | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+| `load_word`: source remains unchanged | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+
+Thus the strongest combined per-API verdicts are: `acknowledge` **PROVED**, `store_word` **PROVED**, `copy_byte` **PROVED**, and `load_word` **UNPROVED**. The combined four-API packet is **UNPROVED**. No submitted fact proves an existential UB execution or an UB-free postcondition counterexample, so neither **UNSOUND** nor **CONTRACT-BROKEN** is certified.
+
+## Proof certificates
+
+### `acknowledge`
+
+The inspected signature has no parameters, returns `()`, documents no additional caller obligation, and its body is exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` says precisely that, for every case in `V_ack` and the required target/profile axes, such evaluation is defined and returns `()`; `unsafe` only adds the static call obligation. The entry is restricted to this consumer. Hence aggregate `Covered = V_ack`, so `Required ⊆ Covered`.
+
+### `store_word`
+
+The only operation is `ptr::write::<u16>(dst, value)`. The caller contract supplies its two safety clauses: `dst` is properly aligned and valid to write one `u16`. The exact [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) authorities make those the operation requirements and specify overwrite with the supplied value without reading or dropping the old value. One authority applies to each member of `V_store`; their exhaustive union covers every required release. The source has no other operation or exit. Each soundness and postcondition obligation therefore has `Covered = V_store`, and their pointwise intersection is `V_store`.
+
+### `copy_byte`
+
+The source fixes `T = u8` and `count = 1`; its caller contract supplies readable initialized source, writable destination, alignment, and non-overlap. The accepted `COMPAT-COPY-180-182` entry preserves, for every `v ∈ V_copy` and required target/profile case, the exact 1.80.0 propositions for this operation: satisfaction of the safety contract, copying exactly one byte to `dst`, and leaving `src` unchanged, with `u8` size 1 and `Copy` semantics. Its verified bases are [`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy`](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html). The TCB expressly restricts consumption to `copy_byte`. Thus every obligation has `Covered = V_copy`; their intersection equals `Required`.
+
+### `load_word`
+
+The only operation is `ptr::read::<u32>(src)`. At 1.80.0 and 1.82.0, the caller supplies the cited operation's readable, aligned, initialized-source requirements. The respective [`read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) pages establish returning the read value while leaving source memory unchanged; the corresponding [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) discharge the copy/ownership bridge at those endpoints.
+
+No authority or accepted TCB entry applies these propositions to 1.80.1 or 1.81.0. Endpoint documentation, stability, and unchanged-looking source cannot supply semantic continuity. The smallest missing premise is: for each missing release and all required target/profile cases, `ptr::read::<u32>` retains the cited safety and result/source-preservation contract and `u32` retains the cited `Copy` semantics. Consequently `Covered = {1.80.0, 1.82.0}`, which does not contain `V_load`.
+
+## TCB, proof artifacts, and residual scope
+
+The only admitted non-authoritative premises are accepted OUT-OF-BAND entries `SEM-EMPTY-BLOCK-180-182` (consumer: `acknowledge`) and `COMPAT-COPY-180-182` (consumer: `copy_byte`). Their exact scopes, exclusions, and source/signature/contract/domain/disposition re-audit triggers are retained from `TCB.md`; neither is transferred to another API. All other consumed premises are the exact claim-specific versioned Rust pages above. No pending premise was used.
+
+The adjacent `SAFETY` comments correctly identify caller-contract forwarding but omit the material release-applicability and postcondition derivations reconstructed here. They should cite a canonical proof containing the exact authority/TCB entry and covered set. For `load_word`, comment wording cannot repair the missing 1.80.1/1.81.0 premise; resolution requires applicable authority or an explicitly accepted narrow compatibility entry.
+
+Re-audit on any source/signature/contract change, any supported-set or configuration expansion, material change to a cited page, or change to either TCB entry/disposition. Releases outside the four explicit predicates, binary/backend correctness, and broader robustness are excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/B.md
new file mode 100644
index 0000000000..145cd3c312
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/B.md
@@ -0,0 +1,45 @@
+# Source-only audit of four exported unsafe APIs
+
+## Claim, snapshot, and domain
+
+Snapshot: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`, audited at the support cutoff 2026-07-31. Scope is source-level Rust abstract-semantics soundness plus every documented postcondition of `acknowledge`, `store_word`, `copy_byte`, and `load_word`. A valid use satisfies the API's documented safety clauses. No backend/binary claim is made. No build, execution, expansion, generated artifact, dependency, or prior result is used.
+
+Let `D={ordinary-debug, ordinary-release}` and `C_A(V)={(v,t,p) | v in V, A exists on target t, p in D}`. `SUPPORT.md` explicitly defines finite sets, so no interval inference is involved:
+
+- `Required_ack=C_ack({1.80.0,1.80.1,1.81.0,1.82.0})`.
+- `Required_store=C_store({1.80.0,1.81.0})`.
+- `Required_copy=C_copy({1.80.0,1.80.1,1.81.0,1.82.0})`.
+- `Required_load=C_load({1.80.0,1.80.1,1.81.0,1.82.0})`.
+
+This is an exact normalization of each controlling expression: membership is listed explicitly and `SUPPORT.md` excludes every other release. The source has no `cfg`, feature, profile branch, macro, FFI, concurrency, allocator, or generated code. Thus target/profile coverage is parametric wherever the cited source-level contract or accepted TCB entry covers a release; only release applicability partitions the claims.
+
+## Results
+
+| API | Soundness | Documented postconditions, separately | Aggregate `Covered` | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | **PROVED** on `Required_ack` | returns `()`: **PROVED** on `Required_ack` | `Required_ack` | **PROVED** relative to `SEM-EMPTY-BLOCK-180-182` |
+| `store_word` | **PROVED** on `Required_store` | (1) stores `value` at `dst`; (2) does not read the old `u16`; (3) does not drop it: each **PROVED** on `Required_store` | `Required_store` | **PROVED** |
+| `copy_byte` | **PROVED** on `Required_copy` | (1) destination receives the pre-call source byte; (2) source byte remains unchanged: each **PROVED** on `Required_copy` | `Required_copy` | **PROVED** relative to `COMPAT-COPY-180-182` |
+| `load_word` | **PROVED** on `C_load({1.80.0,1.82.0})`; **UNPROVED** on `C_load({1.80.1,1.81.0})` | (1) returns the pre-call initialized `u32`; (2) source remains unchanged: each has the same regional split | `C_load({1.80.0,1.82.0})` | **UNPROVED** over `Required_load` |
+
+The strongest combined packet verdict is **UNPROVED** because `Required_load` is not contained in its aggregate `Covered`. No existential UB or UB-free postcondition counterexample is established, so neither `UNSOUND` nor `CONTRACT-BROKEN` applies.
+
+## Obligation ledger and derivations
+
+**ACK-S/P.** The body is syntactically exactly `{}` and the signature has no parameters and unit return. Accepted entry `SEM-EMPTY-BLOCK-180-182` states, for every required release/target/profile case, that such a body has defined evaluation and returns `()`, and that `unsafe` changes only the caller obligation. The documentation imposes no additional caller requirement. This proves soundness and the unit result; full-set closure is immediate.
+
+**STORE-S.** At both required releases the call is exactly `ptr::write::<u16>(dst,value)`. The caller contract supplies `dst` valid for writes of one `u16` and properly aligned, exactly the two safety clauses on the [1.80.0 contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and independently on the [1.81.0 contract](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html): “valid for writes” and “properly aligned.” Therefore each executed unsafe operation meets its applicable contract. **STORE-P1/P2/P3.** Each page says the operation overwrites with the given value “without reading or dropping the old value.” This directly entails all three postconditions. The exhaustive release partition `{1.80.0} union {1.81.0}` equals `V_store`.
+
+**COPY-S.** The local facts are `T=u8`, `count=1`, and exactly the documented source/destination alignment, access, initialization, and non-overlap obligations. The [1.80.0 operation contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) requires read/write validity, alignment, and non-overlap for `count*size_of::<T>()`; [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>()=1`. The stronger initialized-source clause is sufficient. This closes 1.80.0. Accepted `COMPAT-COPY-180-182` preserves these exact premises and the operation's satisfaction for every required release/target/profile case. **COPY-P1/P2.** The operation copies the one byte. [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and the [Copy contract](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)—“always a simple bit-wise copy”—permit both resulting values; the accepted entry explicitly preserves destination equality and unchanged source throughout `V_copy`. Hence each obligation covers all `Required_copy`.
+
+**LOAD-S.** For release 1.80.0, the exact `ptr::read::<u32>` call receives the three facts required by the [1.80.0 contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html): readable, aligned, and properly initialized. The same derivation independently uses the [1.82.0 contract](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) at 1.82.0. **LOAD-P1/P2.** Both pages state that `read` reads without moving and leaves source memory unchanged. The endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [Copy 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [Copy 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish safe coexistence and value preservation at those endpoints. No authority or accepted TCB proposition covers 1.80.1 or 1.81.0. Endpoint samples do not cover the intervening members, and `COMPAT-COPY-180-182` expressly excludes `ptr::read`. The smallest missing proposition is preservation, at 1.80.1 and 1.81.0, of the cited `ptr::read` safety and return/source guarantees plus `u32: Copy` semantics.
+
+## Boundary, TCB, findings, and maintenance
+
+The complete public surface in `lib.rs` is the four unsafe free functions; there are no safe wrappers, public fields, traits/impls, callbacks, hidden items, reexports, macros, representation invariants, or later unsafe consumers. Each caller-facing safety contract is sufficient for the covered regions. The short local `SAFETY` comments correctly identify the callee-contract handoff; release applicability is supplied by this evidence packet.
+
+TCB revision is the submitted `TCB.md`: `SEM-EMPTY-BLOCK-180-182` (accepted OUT-OF-BAND semantics; consumer only ACK-S/P) and `COMPAT-COPY-180-182` (accepted OUT-OF-BAND compatibility; consumers only COPY-S/P). Their exact identities, scope, exclusions, disposition, and triggers were checked; neither is transferred to another operation. All other consumed premises are the exact versioned official pages cited above. No tool-derived evidence or dependency trust is consumed.
+
+**Finding LOAD-COVERAGE (UNPROVED):** affects soundness and both postconditions only for `load_word` on releases 1.80.1 and 1.81.0, across every required target/profile. Resolution requires exact applicable authorities for those releases or a newly authorized, narrowly scoped compatibility premise proving the missing propositions. Re-audit all four claims if source/contracts or support sets change; re-audit consumers if either accepted entry or cited authority changes. Overall closure remains unavailable until `Required_load subseteq Covered_load` is established.
+
+All in-scope obligations have a disposition; every affirmative result above is relative only to the stated authorities and accepted TCB entries.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/C.md
new file mode 100644
index 0000000000..f8da4bed52
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/C.md
@@ -0,0 +1,53 @@
+# Multi-release unsafe Rust source review
+
+## Claim and result
+
+Snapshot: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; audit cutoff 2026-07-31. For each exported unsafe function, the independent claim is: every call satisfying its documented caller obligations is free of Rust undefined behavior and establishes each documented postcondition, for every required release, every target on which the item exists, and ordinary debug/release profiles, relative only to the accepted TCB below.
+
+Let:
+
+- `A = C = L = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `S = {1.80.0, 1.81.0}`;
+- `E = {1.80.0, 1.82.0}` and `M = {1.80.1, 1.81.0}`.
+
+`Covered` is the exact release region on which all premises consumed by a derivation apply.
+
+| API | Required | Covered | Soundness | Documented postconditions | Strongest combined verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `A` | `A` | `PROVED` on `A` | Normal return is `()` (`Q-A`): `PROVED` on `A`; no other postcondition is documented. | **PROVED** on Required, relative to `SEM-EMPTY-BLOCK-180-182`. |
+| `store_word` | `S` | `S` | `PROVED` on `S` | `Q-S1`: stores `value`; `Q-S2`: does not read the old `u16`; `Q-S3`: does not drop it. Each is `PROVED` on `S`. | **PROVED** on Required. |
+| `copy_byte` | `C` | `C` | `PROVED` on `C` | `Q-C1`: destination becomes the source byte; `Q-C2`: source byte is preserved. Each is `PROVED` on `C`. | **PROVED** on Required, relative to `COMPAT-COPY-180-182`. |
+| `load_word` | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M` | `Q-L1`: return equals the initialized source `u32`; `Q-L2`: source remains unchanged. Each is `PROVED` on `E`, `UNPROVED` on `M`. | **UNPROVED** on Required; endpoint region `E` is **PROVED**. |
+
+Thus the combined result for all four requested claims is **UNPROVED** solely because `load_word` is uncovered on `M`. No `UNSOUND` or `CONTRACT-BROKEN` witness is established.
+
+## Boundary and configuration closure
+
+The complete exported surface is four public unsafe free functions; there are no public fields, constructors, safe wrappers or methods, traits, callbacks, macros, hidden items, dependencies, generated artifacts, `cfg` branches, or invariant-bearing state in the submitted source. The only unsafe operations are one `ptr::write`, one `copy_nonoverlapping`, and one `ptr::read`; the empty function has none. Target/profile axes are proof-parametric: source selection and arguments do not vary, the versioned standard-library contracts apply wherever each item exists, and both admitted entries expressly quantify over the stated target/profile domain. No tests or tool-derived evidence were used.
+
+## Obligation ledger and derivations
+
+**A — `acknowledge`.** Local inspection establishes a zero-parameter, unit-returning function whose body is exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies exactly to that fact over `A`, entails defined callee evaluation and `()`, and therefore proves soundness and `Q-A`. “Has no additional safety requirements” leaves no hidden caller premise.
+
+**S — `store_word`.** At both required releases, the submitted [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) pages say it overwrites with the given value “without reading or dropping the old value”; each requires `dst` to be valid for writes and properly aligned. The function's Safety clauses supply those exact requirements for `T = u16`. The single call therefore satisfies its callee contract and the description entails `Q-S1`–`Q-S3` on each member of `S`.
+
+**C — `copy_byte`.** The [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) contract requires readable/writable `count * size_of::<T>()` regions, alignment, and non-overlap, and says it copies that many bytes. The [1.80.0 layout table](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>() = 1`; [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and the [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) establish bit-copy rather than move semantics. Locally, `T = u8` and `count = 1`, so the documented caller clauses entail every callee clause. Accepted `COMPAT-COPY-180-182` preserves precisely these propositions, including `Q-C1` and `Q-C2`, over all `C`; no cross-operation transfer occurs.
+
+**L — `load_word`.** Both submitted [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) pages require readable, aligned, properly initialized storage and say the value is read without moving it while source memory remains unchanged. The caller contract supplies the three requirements. At each endpoint, [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish copy semantics, closing soundness and both postconditions on `E`.
+
+## TCB audit
+
+| Entry | Exact admitted proposition/domain | Consumer | Disposition |
+|---|---|---|---|
+| `SEM-EMPTY-BLOCK-180-182` | Defined evaluation and unit return for the exact empty-function shape, all `A` targets/profiles. | `acknowledge` only | Accepted; local shape verified. |
+| `COMPAT-COPY-180-182` | Preserves the enumerated 1.80.0 one-`u8` copy contract, safety, size, Copy semantics, and both results over `C`. | `copy_byte` only | Accepted; base pages and local type/count verified. |
+
+There are no other admitted premises, pending entries, or dependencies. Re-audit each entry on its stated source, contract, domain, or disposition trigger.
+
+## Findings
+
+**F-L-COVERAGE — `UNPROVED`.** On `M`, the smallest missing proposition is: `ptr::read::<u32>` has the stated three safety requirements and read/unchanged postconditions, and `u32` has the required Copy semantics. Endpoint documentation does not propagate inward or backward, and neither accepted entry applies to `ptr::read`. No UB witness and no UB-free postcondition refutation is established. Resolution requires admissible release-specific authorities or an accepted compatibility proposition covering exactly `M`; then re-audit all `load_word` obligations.
+
+**F-C-PROOF-DOC — proof artifact deficient; implementation proved.** The adjacent `copy_byte` comment omits the material `T = u8`, `count = 1`, `size = 1`, Copy/source-preservation, and compatibility derivation reconstructed above. Suitable replacement: “For `T=u8,count=1`, the caller's one-byte read/write, alignment, and non-overlap clauses satisfy the callee contract; `COMPAT-COPY-180-182` supplies the applicable one-byte copy and source-preservation result.” This does not change the implementation verdict.
+
+Residual scope excludes releases outside Required and binary/backend correctness. Re-audit on source or contract changes, support-set expansion, relevant Rust-documentation changes, or either TCB trigger.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/D.md
new file mode 100644
index 0000000000..08828c4235
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/D.md
@@ -0,0 +1,124 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and aggregate result
+
+This is a source-level review of the supplied `lib.rs` snapshot, at the
+2026-07-31 support cutoff, relative only to `EVIDENCE.md` and accepted TCB
+entries `SEM-EMPTY-BLOCK-180-182` and `COMPAT-COPY-180-182`. It covers all four
+exported unsafe functions, their caller contracts, UB freedom for every valid
+call, and every stated result. It makes no compiler-backend, binary, deployment,
+or broader robustness claim. There are no dependencies, generated artifacts,
+features, conditional source paths, stateful invariants, safe wrappers, fields,
+traits, macros, or other exported surfaces in the supplied source.
+
+Let `T_f(v)` mean every target on which item `f` exists, and let
+`P={ordinary-debug, ordinary-release}`. For each API,
+`Required_f={(v,t,p) | v in V_f, t in T_f(v), p in P}`. `SUPPORT.md` directly
+defines each `V_f` as an exact finite set, so no interval interpolation or
+enumeration inference is used. Target and profile are semantic parameters: the
+source has no branch on either, and every cited authority or consumed TCB entry
+applies to all such cases in its stated release region.
+
+| API | `V_f` | Exact aggregate `Covered` release region | Soundness | Documented results | Strongest API verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `V_f` | **PROVED** | return `()`: **PROVED** | **PROVED** |
+| `store_word` | `{1.80.0,1.81.0}` | all `V_f` | **PROVED** | stores `value`: **PROVED**; old `u16` is neither read nor dropped: **PROVED** | **PROVED** |
+| `copy_byte` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `V_f` | **PROVED** | destination receives the source byte: **PROVED**; source is preserved: **PROVED** | **PROVED**, relative to `COMPAT-COPY-180-182` |
+| `load_word` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | `{1.80.0,1.82.0}` | **UNPROVED** over `Required`; **PROVED** on `Covered` | returned value and unchanged source: each **UNPROVED** over `Required`, **PROVED** on `Covered` | **UNPROVED** |
+
+Thus the combined four-API mandatory claim is **UNPROVED**, solely because
+`Required_load` is not contained in `Covered_load`. No submitted fact proves a
+valid UB witness or a UB-free postcondition counterexample, so neither
+`UNSOUND` nor `CONTRACT-BROKEN` is certified.
+
+## Obligation ledger and proofs
+
+**ACK-S/Q.** The caller contract imposes no additional safety requirement, and
+the exact body is `{}`. `SEM-EMPTY-BLOCK-180-182` applies to precisely all four
+releases, all item-bearing targets, and both profiles; the checked empty body
+connects the source to its admitted proposition that evaluation is defined and
+returns `()`. Hence `Required_ack = Covered_ack` for soundness and return.
+
+**STORE-S.** The only operation is `ptr::write::<u16>(dst,value)`. The public
+contract supplies its two documented safety clauses: `dst` is properly aligned
+and valid for one `u16` write. The 1.80.0 and 1.81.0 `ptr::write` authorities
+apply separately to the two members of `V_store`; their exhaustive union is
+`Covered_store=V_store`. A typed `u16` supplies the value passed to the exact
+call. Soundness is therefore proved.
+
+**STORE-Q1/Q2.** Those same two release-specific pages state that `write`
+overwrites the destination with the given value without reading or dropping
+the old value. The direct call has no later transition, proving both documented
+results over the same exhaustive union.
+
+**COPY-S.** Locally, `T=u8` and `count=1`; the caller contract establishes
+initialized readable source, writable destination, alignment, and non-overlap
+for the one-byte regions. The 1.80.0 `copy_nonoverlapping` contract, primitive
+layout, `u8: Copy`, and `Copy` semantics establish the base case.
+`COMPAT-COPY-180-182` explicitly preserves those exact propositions for every
+member of `V_copy`, target, and profile, and is authorized only for this call.
+Thus `Covered_copy=V_copy` and soundness is proved.
+
+**COPY-Q1/Q2.** The same accepted entry expressly guarantees that this exact
+call copies exactly one byte to `dst`, leaves the source byte unchanged, and
+does not move ownership from it. These propositions directly establish both
+documented results throughout `Required_copy`.
+
+**LOAD-S/Q.** The only operation is `ptr::read::<u32>(src)`. The caller contract
+provides readable validity, alignment, and initialization. At 1.80.0, that
+release's `read`, `u32: Copy`, and `Copy` pages prove a defined read returning
+the source value while leaving source memory unchanged. The parallel 1.82.0
+pages prove the same case at 1.82.0. Therefore each soundness and result
+obligation has `Covered={1.80.0,1.82.0}` (with all corresponding targets and
+profiles). No authority applies at 1.80.1 or 1.81.0, and `TCB.md` explicitly has
+no `read` compatibility entry. Endpoint facts do not cover the interior.
+
+## Evidence and TCB audit log
+
+All authority entries are accepted versioned Rust standard-library/Reference
+premises with exactly the claim-specific applicability stated in `EVIDENCE.md`:
+[write 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and
+[write 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html);
+[copy_nonoverlapping 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html),
+[primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout),
+[u8: Copy](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8),
+and [Copy semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html);
+and `read`, `u32: Copy`, and `Copy` semantics at
+[1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html), with the
+corresponding versioned primitive/trait pages identified in `EVIDENCE.md`. No
+entry is transferred between operations.
+
+| TCB ID | Disposition and exact use | Limit / trigger |
+|---|---|---|
+| `SEM-EMPTY-BLOCK-180-182` | accepted; defined evaluation and `()` return of an exact empty-body unsafe function over `V_ack` | only `ACK-S/Q`; any signature, body, contract, release-set, or disposition change |
+| `COMPAT-COPY-180-182` | accepted; preserves the enumerated 1.80 copy/layout/Copy propositions over all `V_copy` | only `COPY-S/Q`; any call/type/count/base proposition/release-set/disposition change |
+
+No tool-derived evidence, test result, sampled configuration, or unlisted
+assumption contributes to a verdict.
+
+## Findings, proof artifacts, and residual scope
+
+**F-LOAD-COVERAGE — UNPROVED.** The smallest missing proposition is: for each
+`v in {1.80.1,1.81.0}`, `ptr::read::<u32>` under the documented caller clauses
+is defined, returns the read value, leaves the source unchanged, and the needed
+`u32: Copy` semantics apply, for every supported target/profile. Resolution
+requires applicable versioned authorities or an accepted, exact compatibility
+premise; testing or endpoint interpolation is insufficient. Re-audit all
+`load_word` claims after resolution.
+
+The three local `SAFETY` comments identify their callees but omit the material
+release-applicability and, for copy/read, layout/`Copy` bridges and TCB route.
+Implementation status remains as above, but the proof artifacts are deficient.
+Minimum documentation repair is to cite stable canonical proofs containing the
+corresponding ledger derivation; this cannot repair `F-LOAD-COVERAGE` without
+new evidence.
+
+Residual scope is exactly nonlisted Rust releases, nonordinary profiles,
+targets where an item does not exist, backend/binary correctness, and behavior
+beyond the stated results. Re-audit on source or contract changes, support-set
+changes, material authority changes, or either TCB entry's trigger.
+
+**Attestation:** every in-scope surface, safety obligation, documented result,
+release case, and consumed premise has a disposition; affirmative claims have
+`Required subseteq Covered`, and the unresolved remainder remains explicit.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/E.md
new file mode 100644
index 0000000000..7960f7bf85
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/E.md
@@ -0,0 +1,121 @@
+# Unsafe Rust source review
+
+## Claim, snapshot, and boundary
+
+This review covers exactly the four unconditional `pub unsafe fn` items in
+`lib.rs`, with `SUPPORT.md`, `EVIDENCE.md`, and accepted TCB revision `TCB.md`,
+at cutoff 2026-07-31. For each item the claim is: every call satisfying its
+literal `# Safety` contract has UB-free callee evaluation and establishes every
+documented postcondition, for every required release, every target on which the
+item exists, and every ordinary debug or release profile, relative only to the
+TCB below.
+
+The four functions are the complete exported surface. There are no safe
+functions, fields, traits, macros, generated artifacts, dependencies, FFI,
+stateful invariants, or conditional bodies in the submitted source. This is a
+source-level Rust-semantics result, not a compiler/backend or binary theorem.
+
+## Results
+
+Sets below are finite sets, not intervals.
+
+| API | `Required` | Exact `Covered` by evidence | Soundness | Documented postconditions | Strongest combined verdict over `Required` |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `Required` | **PROVED** | No prose postcondition; signature/body return `()` is **PROVED** | **PROVED** |
+| `store_word` | `{1.80.0,1.81.0}` | all `Required` | **PROVED** | stores `value`: **PROVED**; does not read old contents: **PROVED**; does not drop old contents: **PROVED** | **PROVED** |
+| `copy_byte` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `Required` | **PROVED** | destination receives source byte: **PROVED**; source byte is preserved: **PROVED** | **PROVED** |
+| `load_word` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | `{1.80.0,1.82.0}` | **PROVED** on `Covered`; **UNPROVED** on `{1.80.1,1.81.0}` | returned value equals source `u32`: same regional result; source is unchanged: same regional result | **UNPROVED** |
+
+No UB witness or UB-free postcondition refutation is established. Thus no
+`UNSOUND` or `CONTRACT-BROKEN` result applies.
+
+## Obligation ledger and derivations
+
+### `acknowledge`
+
+Its caller contract imposes no additional condition, and the inspected body is
+exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies to precisely this
+signature/body and all `Required` target/profile cases: evaluation is defined
+and returns `()`. Those facts discharge soundness and the signature result
+without transferring the entry to another API.
+
+### `store_word`
+
+For each required release, the caller supplies write-validity and alignment for
+one `u16`. The exact [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html)
+and [1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) contracts
+require exactly write-validity and alignment. Substitution of `T=u16` therefore
+discharges the sole `ptr::write(dst, value)` call. Each page also states that
+`write` overwrites with the supplied value without reading or dropping the old
+contents, proving all three postconditions. No compatibility premise is used.
+
+### `copy_byte`
+
+The caller provides read-valid, initialized `src`, write-valid `dst`, alignment
+of both, and nonoverlap of the one-byte regions. The
+[1.80.0 operation contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html)
+requires those region properties for `count * size_of::<T>()`; the
+[layout axiom](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout)
+gives `size_of::<u8>()=1`. The [implementation fact](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8)
+and [Copy semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)
+establish ordinary bitwise duplication rather than ownership transfer.
+Accepted `COMPAT-COPY-180-182` preserves exactly these safety and result
+propositions over every `Required` release/target/profile. With source
+`T=u8,count=1`, the call is defined, writes the source byte to `dst`, and leaves
+the source byte unchanged.
+
+### `load_word`
+
+At each covered endpoint, the caller's read-validity, alignment, and initialized
+`u32` facts exactly discharge the [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html)
+or [1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) `ptr::read`
+contract. Those pages say the value is read without moving and source memory is
+unchanged. Endpoint-specific `u32: Copy` evidence
+([1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32),
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32))
+and Copy semantics
+([1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html),
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html)) permit the
+returned duplicate and original source value to remain usable.
+
+For 1.80.1 and 1.81.0, the smallest missing implication is: the endpoint
+`ptr::read` safety/effect propositions and `u32: Copy` semantics apply without
+weaker guarantees or added preconditions. No submitted authority or accepted
+TCB entry supplies it; later evidence cannot propagate backward and 1.80.0
+evidence cannot propagate forward unaided. Soundness and both postconditions
+therefore remain `UNPROVED`.
+
+## Configuration closure and TCB log
+
+Release is the only evidence-sensitive axis. Target/profile coverage is
+parametric because each consumed authority or TCB proposition has the stated
+all-targets-where-present and ordinary-profile applicability, and source
+selection does not vary. The table exhaustively partitions every required
+finite release set. No builds or tool-derived evidence were used.
+
+| Entry | Disposition and exact consumers |
+|---|---|
+| Versioned Rust/std pages listed above | authoritative, claim-specific axioms only in their stated release regions |
+| `SEM-EMPTY-BLOCK-180-182` | accepted OUT-OF-BAND proposition; only `acknowledge` |
+| `COMPAT-COPY-180-182` | accepted OUT-OF-BAND compatibility proposition; only `copy_byte` |
+
+There are no other admitted premises. The TCB entries do not assume an in-scope
+conclusion: local source facts connect each narrow proposition to its consumer.
+
+## Proof-artifact findings and residual scope
+
+The caller-facing safety clauses are sufficient where evidence covers them.
+The three pointer-operation `SAFETY` comments state call-precondition transfer
+but omit the material result derivations and release applicability reconstructed
+above; `acknowledge` states its contract outside a conventional `# Safety`
+section. These are documentation deficiencies, not implementation defects in
+proved regions. Suitable adjacent result text is, respectively: `write`
+overwrites without reading/dropping; the one-`u8` copy copies one byte and,
+because `u8: Copy`, preserves source ownership; `read` returns a `u32` copy and
+leaves source unchanged. No comment can close `load_word`'s middle releases
+without new admissible evidence.
+
+Residual scope is exactly `load_word` on 1.80.1 and 1.81.0, plus all binary,
+backend, nonordinary-profile, and unlisted-release claims. Re-audit on any
+source/contract change, support-set expansion, changed cited documentation,
+TCB disposition/scope change, or addition of configuration-dependent code.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/F.md
new file mode 100644
index 0000000000..2a38edeae6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/F.md
@@ -0,0 +1,40 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and strongest results
+
+This review covers exactly `lib.rs` in the submitted packet, independently for the four exported unsafe free functions. For each API, the claim is: every call satisfying its documented safety obligations has defined source-level Rust evaluation and establishes every stated normal-return postcondition, for every release in its `Required` set, every target on which the item exists, and ordinary debug and release profiles. The audit cutoff is 2026-07-31. Results are relative to the exact submitted authorities and accepted `TCB.md`; no compiler-backend or binary theorem is claimed.
+
+| API | `Required` | Exact evidence-backed `Covered` | Soundness | Documented postconditions | Strongest combined verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same set | **PROVED** throughout | Normal return yields `()`: **PROVED** throughout | **PROVED** |
+| `store_word` | `{1.80.0, 1.81.0}` | same set | **PROVED** throughout | Stores `value`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop it: **PROVED**, each throughout | **PROVED** |
+| `copy_byte` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same set | **PROVED** throughout | Destination receives the source byte: **PROVED**; source byte remains unchanged: **PROVED**, each throughout | **PROVED** |
+| `load_word` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | `{1.80.0, 1.82.0}` | **PROVED** on `Covered`; **UNPROVED** on `{1.80.1, 1.81.0}`, hence **UNPROVED** for `Required` | Returns the initialized source `u32`: endpoint **PROVED**, interior **UNPROVED**; leaves source unchanged: endpoint **PROVED**, interior **UNPROVED** | **UNPROVED** for `Required`; **PROVED** on `Covered` |
+
+No valid UB witness or UB-free postcondition refutation is established. Thus no result is `UNSOUND` or `CONTRACT-BROKEN`.
+
+## Obligation ledger and proofs
+
+**ACK-S/ACK-Q (`lib.rs:3-4`).** The function has no caller safety precondition beyond making an unsafe call, and its exact body is `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies to precisely this body, signature, all four required releases, applicable targets, and both profile classes. Its proposition entails defined evaluation and the unit return. Nothing is transferred to another API.
+
+**STORE-S/STORE-Q (`lib.rs:6-13`).** At both required releases, the call is exactly `ptr::write::<u16>(dst, value)`. The caller contract supplies the two [1.80.0 `write`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) / [1.81.0 `write`](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) safety conjuncts: write-validity for one `u16` and proper alignment. `value` is a well-typed `u16`. Each versioned description states that `write` overwrites with the supplied value without reading or dropping the old value; this proves all three postconditions. The two singleton authority regions exhaust `Required`.
+
+**COPY-S/COPY-Q (`lib.rs:16-25`).** The call fixes `T = u8`, `count = 1`. The [1.80.0 layout table](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>() = 1`; therefore the [1.80.0 `copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) read-validity, write-validity, alignment, and nonoverlap regions reduce exactly to the one-byte obligations documented at lines 20-22. [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and [1.80.0 `Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) establish that duplicating this byte does not move ownership. The operation copies exactly that byte and preserves source initialization/state. Accepted `COMPAT-COPY-180-182` explicitly preserves this complete safety and postcondition proposition over every release in `Required`, target, and profile. Its four-release region exhausts `Required`.
+
+**LOAD-S/LOAD-Q (`lib.rs:28-36`).** At each covered endpoint, the call is `ptr::read::<u32>(src)`. The [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) contracts require read-validity, alignment, and a properly initialized `u32`, exactly supplied at lines 32-33. Their descriptions establish reading/returning the value while leaving source memory unchanged. Endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) discharge duplicate-ownership concerns. For 1.80.1 and 1.81.0 the smallest missing proposition is that these exact `ptr::read` safety, return-value, source-preservation, and `u32: Copy` propositions apply. Endpoint documentation does not cover interior releases, and neither accepted TCB entry permits that transfer. This blocks every interior obligation.
+
+## Boundary, configuration, and trust closure
+
+The complete source surface is the four unsafe functions above. There are no safe APIs, fields, constructors, traits/impls, macros, hidden items, FFI, generated artifacts, dependencies, callbacks, persistent invariants, or configuration branches in the submitted source. Target and profile coverage is parametric: the source has one path, and each consumed authority or TCB proposition applies without a target/profile branch over its stated region. No tests or tool-derived evidence were used.
+
+TCB identity is the exact submitted `TCB.md` (no external revision was supplied). Both entries are accepted OUT-OF-BAND propositions: `SEM-EMPTY-BLOCK-180-182`, consumed only by ACK-S/ACK-Q, and `COMPAT-COPY-180-182`, consumed only by COPY-S/COPY-Q. Their identities, quantifiers, consumers, exclusions, and re-audit triggers were checked. There are no admitted dependency, platform, implementation, deployment, or probabilistic premises. The absent `load_word` compatibility proposition is not silently added.
+
+## Finding DOC-1: local proof comments are deficient
+
+The three pointer-operation comments merely assert that the caller supplies “exactly/every” callee precondition. They omit the material type/count/size and ownership derivations above and cite no applicable authority. This is proof-documentation debt, not an implementation defect in each API's `Covered` region. Minimal replacements should state: for `store_word`, `T=u16` and lines 10-13 discharge write-validity/alignment; for `copy_byte`, `T=u8`, `count=1`, `size=1`, lines 20-22 discharge all four regional obligations, and `u8: Copy` makes duplication ownership-safe; for `load_word`, `T=u32`, lines 32-33 discharge read-validity/alignment/initialization, and `u32: Copy` permits the returned copy while the source remains. The latter wording must cite only a release region actually covered.
+
+## Residual scope and re-audit triggers
+
+Excluded are releases outside `Required`, nonordinary profiles, targets where an item does not exist, compiler correctness, code generation, and binary/platform behavior. To close `load_word`, supply accepted claim-specific authority or compatibility evidence for both missing releases (or change the support contract); `COMPAT-COPY-180-182` cannot be reused. Re-audit on any source/signature/contract change, change to a required set or configuration scope, material authority change, or change in either accepted TCB entry or its disposition.
+
+Final attestation: every in-scope soundness and documented-postcondition obligation has a regional status; every `PROVED` region has a complete derivation relative to the stated TCB; uncovered regions remain conspicuously `UNPROVED`.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/G.md
new file mode 100644
index 0000000000..d387539998
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/G.md
@@ -0,0 +1,59 @@
+# Multi-release unsafe Rust source review
+
+## Claim, snapshot, and verdicts
+
+This review covers exactly the four exported `unsafe` free functions in the submitted `lib.rs`, with `SUPPORT.md` (cutoff 2026-07-31), `EVIDENCE.md`, and `TCB.md` controlling. A valid call is a well-typed call satisfying the function's documented `# Safety` obligations. For each API and each required release/target/profile, the soundness claim is that every valid call has defined Rust-abstract-semantics evaluation. Each stated result/post-state guarantee is a separate mandatory postcondition. This is source-level only; no compiler-binary, deployment, security, or extra robustness claim is made.
+
+Let:
+
+- `A = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `S = {1.80.0, 1.81.0}`;
+- `C = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `L = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`, `E = {1.80.0, 1.82.0}`, and `M = {1.80.1, 1.81.0}`.
+
+Every set also quantifies over every target on which the item exists and every ordinary debug or release profile.
+
+| API / independent claim | `Required` | Exact `Covered` | Regional and strongest verdict |
+|---|---:|---:|---|
+| `acknowledge` soundness | `A` | `A` | `PROVED` |
+| `acknowledge` returns `()` | `A` | `A` | `PROVED` |
+| `store_word` soundness | `S` | `S` | `PROVED` |
+| destination receives `value` | `S` | `S` | `PROVED` |
+| old `u16` is not read | `S` | `S` | `PROVED` |
+| old `u16` is not dropped | `S` | `S` | `PROVED` |
+| `copy_byte` soundness | `C` | `C` | `PROVED` |
+| destination receives the pre-call source byte | `C` | `C` | `PROVED` |
+| source byte remains unchanged | `C` | `C` | `PROVED` |
+| `load_word` soundness | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+| returned `u32` equals the pre-call source value | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+| source `u32` remains unchanged | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+
+Thus the strongest combined mandatory verdict is `PROVED` independently for `acknowledge`, `store_word`, and `copy_byte`, and `UNPROVED` for `load_word`. No `UNSOUND` execution or UB-free `CONTRACT-BROKEN` witness is established.
+
+## Derivations and obligation coverage
+
+**`acknowledge`.** The inspected signature has no parameters and returns unit; its body is exactly `{}`. Accepted TCB entry `SEM-EMPTY-BLOCK-180-182`, restricted to this consumer, says exactly that across `A` such a body has defined evaluation and returns `()`, and that `unsafe` changes only the caller obligation. The published contract imposes no additional obligation. These facts entail both rows over all of `A`.
+
+**`store_word`.** For each member of `S`, the corresponding versioned [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) or [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) authority requires `dst` to be write-valid and properly aligned. The API's caller contract supplies both for one `u16`; the source fixes `T = u16` and calls `write(dst, value)` once. The same authorities state that `write` overwrites with the given value “without reading or dropping the old value.” Therefore the call is permitted and establishes each of the three postconditions. The two exact authority regions exhaust `S`.
+
+**`copy_byte`.** The source fixes `T = u8`, `count = 1`. Its caller contract supplies initialized one-byte source readability, destination writability, alignment of both pointers, and non-overlap. The submitted [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) authorities establish permission, one-byte extent, copying rather than moving, destination equality, and source preservation at 1.80.0. Accepted consumer-specific `COMPAT-COPY-180-182` preserves exactly those propositions, without added preconditions, throughout `C` and all required targets/profiles. Hence all three rows are proved on `C`.
+
+**`load_word`.** At each endpoint in `E`, the matching [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) or [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) authority requires a non-ZST source to be read-valid, aligned, and initialized; the caller contract supplies those facts for the source-fixed `T = u32`. The matching endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32) and [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), or [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32) and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html), combine with `read`'s “without moving” and source-unchanged guarantees to prove both postconditions.
+
+For `M`, no submitted authority applies and no accepted TCB entry transfers either endpoint's `ptr::read`, `u32: Copy`, or `Copy` propositions. Similar source and endpoint documentation cannot propagate guarantees forward or backward. The smallest missing premise is the same safety and behavior contract, including applicable `u32` copy semantics, for each release in `M`, or an accepted compatibility proposition covering precisely those releases. All three `load_word` claims therefore remain `UNPROVED` there.
+
+## Boundary, configuration, and evidence closure
+
+The complete submitted source has four public unsafe free-function surfaces and no public safe functions, fields, constructors, traits/impls, macros, hidden/reexported APIs, invariant-bearing state, dependencies, generated artifacts, conditional compilation, callbacks, FFI, assembly, allocation, or concurrency. Each call is its own unsafe boundary; there are no cross-call invariants or transitions.
+
+Configuration coverage is parametric over target and ordinary profile because the source has no configuration branch and every consumed authority/TCB proposition carries the stated target/profile applicability. Release coverage is the explicit finite partition above, not a numeric interval. No builds or tool-derived evidence were used. Regions outside each API's `Required`, nonordinary profiles/flags, binaries/backends, and releases after the cutoff are excluded rather than inferred unsupported by the project.
+
+## TCB audit log and findings
+
+TCB identity is the exact submitted `TCB.md`. Trust policy admits only versioned Rust authorities listed in `EVIDENCE.md` and the two human-accepted `OUT-OF-BAND` entries. `SEM-EMPTY-BLOCK-180-182` is consumed only by `acknowledge`; `COMPAT-COPY-180-182` only by `copy_byte`. Their quantification, exclusions, consumers, and source/support-change re-audit triggers were checked. No entry is transferred to `store_word` or `load_word`; no new premise is admitted.
+
+`F-LOAD-MIDDLE` (`UNPROVED`) is the only verdict-affecting finding: it affects soundness and both postconditions for `load_word` on `M`; there is no admissible release-applicable semantic bridge. Resolution requires the missing versioned authorities or authorized narrowly scoped compatibility entry, followed by re-review.
+
+`F-PROOF-DOC` is non-verdict documentation debt: the three pointer-operation `SAFETY` comments assert “exactly”/“every” precondition but omit the versioned contract clauses and resulting postconditions reconstructed above. A replacement should name the concrete type/count, enumerate the locally inherited caller facts, cite the applicable authority/TCB entry, and state the established post-state. No wording can close `load_word` on `M` without new evidence.
+
+Re-audit on any source/signature/contract change, support-set or cutoff change, material authority change, or change to either TCB entry/disposition. Final attestation: every in-scope surface, soundness obligation, documented postcondition, release region, and consumed premise has a status; `PROVED` is asserted only on the exact covered regions relative to the stated TCB.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/H.md
new file mode 100644
index 0000000000..dcb861f59f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/H.md
@@ -0,0 +1,109 @@
+# Multi-release unsafe API source audit
+
+## Claim, snapshot, and result
+
+This review covers exactly the four exported `unsafe fn`s in `lib.rs`, at the
+2026-07-31 cutoff. For each API independently, the soundness claim is: every
+call satisfying its documented caller obligations has defined source-level Rust
+evaluation. The postcondition claim is each behavioral promise stated in that
+API's documentation. `Required` is the API-specific finite release set in
+`SUPPORT.md`; it is not an interval. In every listed release the target domain
+is every target on which the item exists and every ordinary debug or release
+profile. There are no dependencies, generated artifacts, conditional source,
+or additional configuration axes in the submitted snapshot. Compiler/backend
+correctness and binary behavior are excluded.
+
+| API | Required | Covered by admissible evidence | Soundness | Documented postconditions | Strongest combined verdict over Required |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same as Required | **PROVED** throughout | No behavioral postcondition is documented; the signature-level return of `()` is also **PROVED** throughout | **PROVED** |
+| `store_word` | `{1.80.0, 1.81.0}` | same as Required | **PROVED** throughout | Stores `value` at `dst`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop the old `u16`: **PROVED**, all throughout | **PROVED** |
+| `copy_byte` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same as Required | **PROVED** throughout | Destination becomes the source byte: **PROVED**; source byte is preserved: **PROVED**, all throughout | **PROVED** |
+| `load_word` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | `{1.80.0, 1.82.0}` | **PROVED** on Covered; **UNPROVED** on `{1.80.1, 1.81.0}` | Returned `u32` equals the initialized source value: **PROVED** on Covered and **UNPROVED** on the remainder; source is unchanged: the same regional result | **UNPROVED** |
+
+No valid UB witness or UB-free postcondition refutation is established. Thus no
+regional result is `UNSOUND` or `CONTRACT-BROKEN`.
+
+## Obligation derivations
+
+### `acknowledge`
+
+The local body is exactly `{}`, with zero parameters and unit return, and the
+documentation imposes no additional safety requirement. Accepted
+`SEM-EMPTY-BLOCK-180-182` states, for every release, target, and profile in
+Required, that this exact form has defined evaluation and returns `()`; making
+the function unsafe changes only the static call obligation. The body/signature
+facts therefore instantiate that entry over all of Required. The TCB entry is
+not used by any other API.
+
+### `store_word`
+
+The only unsafe operation is `ptr::write(dst, value)`. For both required
+releases, the submitted version-matched [`write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html)
+and [`write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html)
+contracts require `dst` to be properly aligned and valid for writes; these are
+exactly the public caller obligations. The well-typed `value: u16` supplies the
+value being written. The same version-matched descriptions establish overwrite
+without reading or dropping the old value. Hence soundness and every listed
+effect are covered in both required releases without a compatibility premise.
+
+### `copy_byte`
+
+The source fixes `T = u8` and `count = 1`. Its caller contract supplies a
+readable initialized source `u8`, a writable destination `u8`, alignment of
+both, and nonoverlap of the one-byte regions. The submitted 1.80.0
+[`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html),
+[primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout),
+[`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8),
+and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)
+establish the base safety requirements, one-byte size, copying effect, and
+non-moving source preservation. Accepted `COMPAT-COPY-180-182` preserves those
+exact propositions across every release, target, and profile in Required.
+Together with the local fixed type/count and caller clauses, this proves both
+soundness and both postconditions throughout Required. The entry expressly
+cannot support `ptr::read`, `ptr::write`, or another API.
+
+### `load_word`
+
+At 1.80.0 and 1.82.0, the version-matched [`read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html)
+and [`read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html)
+contracts require a readable, aligned, properly initialized non-ZST source;
+the public caller contract supplies those facts for one `u32`. The respective
+[`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32)
+and [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html),
+and the corresponding [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32)
+and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html),
+combine with each `read` description to establish the returned value and
+unchanged source at those endpoints.
+
+For 1.80.1 and 1.81.0, the packet supplies neither version-applicable `read` and
+`Copy` authorities nor an accepted compatibility proposition. Later 1.82.0
+text cannot establish earlier semantics, and 1.80.0 text cannot be propagated
+forward without an admitted compatibility premise. `COMPAT-COPY-180-182` is
+operation-specific and explicitly excludes `ptr::read`. The smallest missing
+implication is that, in each uncovered release and full target/profile domain,
+the documented caller facts satisfy `ptr::read`'s safety contract and the call
+returns the source `u32` while leaving the source unchanged. Absence of that
+premise makes both regional claims `UNPROVED`; it is not evidence of UB.
+
+## TCB, proof artifacts, and maintenance
+
+The complete non-authoritative TCB is the two accepted entries in `TCB.md`:
+`SEM-EMPTY-BLOCK-180-182`, consumed only by `acknowledge`, and
+`COMPAT-COPY-180-182`, consumed only by `copy_byte`. All `write`, `read`, layout,
+and `Copy` facts above are claim- and release-specific submitted Rust authority;
+none is transferred to a different operation or release.
+
+The API safety contracts are sufficient for the proved regions. The terse
+`SAFETY` comments do not themselves record the material release-applicability
+derivations reconstructed above, especially the `copy_byte` compatibility
+bridge and the endpoint-only `load_word` proof. This is proof-documentation
+debt, not a contrary implementation verdict. A replacement comment should cite
+the exact local type/count and caller clauses plus the applicable authority/TCB
+entry; no comment can close `load_word`'s two missing release premises.
+
+Re-audit is required upon any source/signature/contract change, change to a
+Required set or target/profile policy, change or withdrawal of either accepted
+TCB entry, or material change to a consumed versioned authority. To obtain a
+full `load_word` verdict, submit applicable authority for 1.80.1 and 1.81.0 or
+an accepted narrowly scoped compatibility premise covering the exact missing
+propositions.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/I.md
new file mode 100644
index 0000000000..28fcb1744f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/I.md
@@ -0,0 +1,48 @@
+# Multi-release source-only unsafe Rust audit
+
+## Claim, snapshot, and boundary
+
+Artifact: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; audit cutoff 2026-07-31. For each exported unsafe function independently, the claim is: for every listed Rust release, every target on which the item exists, every ordinary debug/release profile, and every call satisfying its documented safety contract, evaluating the exact body is free of Rust undefined behavior and establishes each stated postcondition, relative only to the accepted TCB below.
+
+The complete reachable surface is four stateless exported unsafe functions: `acknowledge`, `store_word`, `copy_byte`, and `load_word`. There are no exported safe wrappers, fields, constructors, traits/impls, macros, generated artifacts, `cfg` branches, dependencies, callbacks, or invariant-bearing state in the submitted source. Thus target and profile are parametric axes: the source operation does not vary, and each proof below covers every such case to which its cited premise applies. This is a Rust source-semantics result, not a compiler-backend or binary theorem.
+
+`SUPPORT.md` directly defines explicit finite sets, so no interval normalization is used:
+
+- `V_ack = V_copy = V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`.
+- `V_store = {1.80.0, 1.81.0}`.
+
+For each claim, `Required = V_api × targets-where-item-exists × {ordinary-debug, ordinary-release}`. No release may be inferred between submitted evidence points.
+
+## Verdict summary
+
+| API | Soundness | Documented postconditions, separately | Aggregate `Covered` | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | **PROVED** on `V_ack` | returns `()`: **PROVED** on `V_ack` (there is no additional prose postcondition) | `Required_ack` | **PROVED**, relative to `SEM-EMPTY-BLOCK-180-182` |
+| `store_word` | **PROVED** on `V_store` | stores `value` at `dst`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop the old `u16`: **PROVED**, each on `V_store` | `Required_store` | **PROVED** |
+| `copy_byte` | **PROVED** on `V_copy` | copies exactly the source byte to `dst`: **PROVED**; leaves the source byte unchanged: **PROVED**, each on `V_copy` | `Required_copy` | **PROVED**, relative to `COMPAT-COPY-180-182` |
+| `load_word` | **PROVED** on `{1.80.0,1.82.0}`; **UNPROVED** on `{1.80.1,1.81.0}` | returns the initialized source `u32`: same regional result; leaves source unchanged: same regional result | `{1.80.0,1.82.0} × targets × profiles` | **UNPROVED** over `Required_load` |
+
+The combined mandatory result for all four APIs is **UNPROVED**, solely because `Required_load ⊄ Covered_load`. No submitted fact proves an in-scope UB execution or a UB-free postcondition counterexample, so neither `UNSOUND` nor `CONTRACT-BROKEN` is certified.
+
+## Obligation proofs
+
+**`acknowledge`.** Its contract imposes no additional caller condition; inspection establishes a zero-parameter, unit-returning function with body exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` states parametrically over every `v ∈ V_ack`, relevant target, and ordinary profile that such a well-typed call has defined callee evaluation and returns `()`, and that `unsafe` changes only the static caller obligation. These facts prove both obligations and `Required_ack ⊆ Covered_ack`.
+
+**`store_word`.** At each member of `V_store`, the applicable [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) contracts require `dst` to be valid for writes and aligned and say that the given value overwrites the location without reading or dropping the old value. The API contract supplies validity for one `u16` and alignment; `value: u16` is supplied by value; the body performs exactly `write(dst, value)`. Therefore soundness and all three postconditions hold in each release case. The two singleton cases exhaust `V_store`, hence their union is `Covered_store = Required_store`.
+
+**`copy_byte`.** The body instantiates `copy_nonoverlapping` with `T=u8,count=1`. The contract supplies readable initialized source, writable destination, both alignments, and non-overlap of the one-byte regions. The accepted compatibility entry imports, for every case in `V_copy`, the exact relevant propositions from [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html): these conditions satisfy the operation contract, one byte is copied to `dst`, and the source is unchanged. Thus every obligation has `Covered = Required_copy`.
+
+**`load_word`.** For 1.80.0, [`ptr::read`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html), [`u32: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) apply. The corresponding [1.82.0 `read`](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html), [`u32: Copy`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) apply at 1.82.0. At each endpoint, the caller supplies readable, aligned, initialized `u32` storage; `read(src)` therefore is defined, returns its value, and leaves the source unchanged, with copying rather than ownership-moving semantics. No authority or accepted compatibility premise applies those propositions to 1.80.1 or 1.81.0. Endpoint agreement cannot cover the interior. The smallest missing propositions are the same `ptr::read`, `u32: Copy`, and Copy-semantic guarantees for both middle releases.
+
+## TCB, findings, and maintenance
+
+TCB identity: submitted `TCB.md`. Both entries are human-accepted and narrowly consumed:
+
+- `SEM-EMPTY-BLOCK-180-182`: only the empty-body evaluation and unit return used by `acknowledge`.
+- `COMPAT-COPY-180-182`: only the enumerated one-byte `copy_nonoverlapping` safety and postcondition propositions used by `copy_byte`.
+
+They are not transferred to `store_word` or `load_word`. There is no tool-derived or test evidence and no other admitted premise.
+
+**Finding F-LOAD-COVERAGE (UNPROVED; evidence/domain closure).** Affects soundness and both postconditions of `load_word` on 1.80.1 and 1.81.0. This is not an established implementation defect: the packet lacks the applicability bridge required for those releases. Resolution requires exact applicable authorities for both releases or an accepted proposition-preserving compatibility entry covering precisely the missing operations and release region. Re-audit on any source/contract/support-set change, either TCB disposition change, or material change to a consumed versioned authority.
+
+Residual scope: compiler implementation, code generation, binaries, nonordinary profiles, targets where an item does not exist, and Rust releases outside the explicit finite sets are excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/J.md
new file mode 100644
index 0000000000..10168ee5d5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/reports/J.md
@@ -0,0 +1,44 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and result
+
+This review covers exactly the submitted `lib.rs`, its four exported unsafe functions, the contracts in that file, the finite policies in `SUPPORT.md`, and the submitted evidence/TCB packet. Audit cutoff: 2026-07-31. There is no generated code, conditional compilation, dependency, safe wrapper, trait, field, macro, FFI, concurrency, allocator, or other API surface in the submitted source. No binary/backend claim is made.
+
+For API `f`, let `D(V) = V × {every target on which f exists} × {ordinary debug, ordinary release}`. The theorem is: every call satisfying `f`'s documented caller obligations has defined callee evaluation under documented Rust abstract semantics and establishes each listed postcondition. The exact target/profile quantifiers come directly from `SUPPORT.md`; copying each explicitly declared finite release set into `D` is an equality, not interval inference.
+
+**Strongest four-API result: UNPROVED.** `acknowledge`, `store_word`, and `copy_byte` are fully **PROVED** relative to the accepted submitted TCB. `load_word` is regionally proved but its full required claim is **UNPROVED**. No `UNSOUND` or `CONTRACT-BROKEN` witness is established.
+
+| API | Required releases | Soundness | Documented postconditions (separate results) | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | `A={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED**, `Covered=A` | No prose postcondition; its signature-level `()` return is **PROVED**, `Covered=A` | **PROVED** over `D(A)` |
+| `store_word` | `S={1.80.0,1.81.0}` | **PROVED**, `Covered=S` | destination stores `value`: **PROVED**, `Covered=S`; old `u16` is not read: **PROVED**, `Covered=S`; old `u16` is not dropped: **PROVED**, `Covered=S` | **PROVED** over `D(S)` |
+| `copy_byte` | `C={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED**, `Covered=C` | destination receives the pre-call source byte: **PROVED**, `Covered=C`; source byte is preserved: **PROVED**, `Covered=C` | **PROVED** over `D(C)` |
+| `load_word` | `L={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED** on `E={1.80.0,1.82.0}`; **UNPROVED** on `M={1.80.1,1.81.0}`; aggregate `Covered=E` | returned value equals the initialized source `u32`: same regional results; source is unchanged: same regional results | **UNPROVED** over `D(L)` |
+
+For each proved claim, all required obligations have the displayed same release coverage, so their pointwise intersection is that `Covered`; equality with the relevant required set proves `Required ⊆ Covered`. For `load_word`, `E ⊂ L`, so closure fails.
+
+## Obligation proofs
+
+**ACK-SOUND/RET.** The inspected body is exactly `{}`, has no operation or state transition, and matches the signature covered by accepted `SEM-EMPTY-BLOCK-180-182`. That entry parametrically guarantees defined evaluation and return of `()` for every case in `D(A)`. There are no caller safety preconditions or other postconditions.
+
+**STORE-SOUND/VALUE/NOREAD/NODROP.** The caller contract supplies an aligned `dst` valid to write one `u16`; these are exactly the safety clauses of [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html), independently verified for their respective singleton cases. The call uses that `dst` and passed `value`. Each page says the operation overwrites the location with the value without reading or dropping the old value. The exhaustive union of the two singleton lemmas is `S`.
+
+**COPY-SOUND/DEST/SOURCE.** The call fixes `T=u8,count=1`. The caller contract supplies source/destination validity, initialization, alignment, and non-overlap. The verified 1.80 authorities establish the matching [`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) clauses, [`size_of::<u8>()=1`](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [bitwise `Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html). Accepted `COMPAT-COPY-180-182` preserves exactly the defined-call, one-byte destination-copy, source-preservation, size, and `Copy` propositions over every case in `D(C)`. Its consumer restriction is obeyed.
+
+**LOAD-SOUND/RETURN/SOURCE.** At 1.80.0 and 1.82.0, the caller's aligned/readable/initialized `src` exactly discharges the independently verified [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) safety clauses. Those pages establish return of the read value and unchanged source. The corresponding [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish that retaining and returning the duplicate `u32` preserves ownership validity. These are endpoint lemmas only.
+
+## Finding LOAD-GAP — missing interior-release applicability
+
+- **Status:** `UNPROVED`; implementation and both postconditions on `D(M)`.
+- **Smallest missing premise:** for each `v∈M`, under the documented pointer conditions, this exact `ptr::read::<u32>` call is defined, returns the source value, leaves the source unchanged, and `u32` has the required `Copy` semantics.
+- **Why unresolved:** the submitted pages apply only to 1.80.0 and 1.82.0. An audit cutoff and endpoint agreement do not establish semantic continuity. `TCB.md` supplies no `load_word` compatibility entry, and operation-specific evidence may not be transferred.
+- **Certificate check:** no valid in-scope execution with a proved false safety proposition or UB consequence exists in the packet; no UB-free falsifying execution exists. Therefore neither `UNSOUND` nor `CONTRACT-BROKEN` applies.
+- **Resolution:** provide applicable authorities for both interior releases or accept an exact proposition-preserving compatibility premise covering them, then re-audit all three obligations.
+
+## TCB, proof artifacts, and residual scope
+
+TCB identity is the exact submitted `TCB.md`. Its only non-authoritative entries are accepted `SEM-EMPTY-BLOCK-180-182` (consumed only by ACK-SOUND/RET) and accepted `COMPAT-COPY-180-182` (consumed only by COPY-SOUND/DEST/SOURCE). Their identities, scopes, limitations, consumers, and triggers were checked. All eleven submitted official pages were opened at their exact versioned URLs and their stated propositions verified. No tool-derived theorem or additional premise is consumed.
+
+**Proof-documentation finding:** implementation proofs above reconstruct facts absent from the adjacent comments. `acknowledge` should place its no-requirements contract under `# Safety`. The three pointer comments identify caller-side preconditions but omit resulting facts and version applicability; `copy_byte` especially omits the `u8/count/size/Copy` bridge, and `load_word` omits the `u32: Copy` bridge. This does not weaken proved implementation regions, but the proof artifacts are deficient. Add the corresponding compact derivations above; no wording change can repair `LOAD-GAP` without new evidence.
+
+Excluded: releases outside the explicit sets, nonordinary profiles, targets where an item does not exist, backend/binary correctness, and properties not documented or requested. Re-audit on any source/signature/contract change, support-set or configuration change, authoritative-page change, or change/disposition change to either consumed TCB entry.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/PACKET.json
new file mode 100644
index 0000000000..b68ee095d5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "48b51034360f118b44292431a6776ee1eb24437abbd86a639e26fdd845cb3c70",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "M",
+  "presentation_order": [
+    "G",
+    "J",
+    "A",
+    "B",
+    "F",
+    "E",
+    "H",
+    "C",
+    "I",
+    "D"
+  ],
+  "report_sha256": {
+    "A": "e963c7770bfa0ee351fff523e1a2e992ade90c82028c9b017731d53e2319c647",
+    "B": "06e79bd6b8b63d837b56c80f95a012f301f5b47ab10d2112882ae72c41f0ea7f",
+    "C": "acbc1ad06963f179d034a1daec025f797ff8576dcda40718197ed2dbdd639acc",
+    "D": "6a4721ff173210588f9720b233d83c613ca6e460b15e46c52b311793b090f9d2",
+    "E": "f171bae3f575098cdab781093b1dc9e5455f576fc232bf6c0eadf70ce1a634fe",
+    "F": "52351c5c0755e56dc544a5814cc0bfaeb51f1cf6000e4db4a24ab2699e927812",
+    "G": "cfa8049918cc9eb89660940173c43c86bda06e974d3ef134b3f82fb21dbcb3af",
+    "H": "b9cfc956cc8580d2722d554a8e40b81f781aab75650f69efd833756f9b67b355",
+    "I": "46a2e9a7de676f0249b9a248e2d2d18a0894fb0379999bc3721cb31e84c4db9d",
+    "J": "3e728c8ae2e5aea7eecfd5af8aab61c637c06478e3182e6f7dccdaa569a170c2"
+  },
+  "rubric_sha256": "d06d60ffd6b3478500caabb2ca88bb4b9327a7c63a3f0d913633ecb9a837d6e2",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "9078b4eeffab0b182dc48340ad3a04fc900e363e638ab64f8ac39f868dd46290"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/RUBRIC.md
new file mode 100644
index 0000000000..dbd98585cc
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/RUBRIC.md
@@ -0,0 +1,171 @@
+# Mode M Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## M — Multi-release affirmative certificates
+
+Target: supplied M snapshot.
+
+Let `C_M` be every supported target times every ordinary profile. For a
+function `f`, let `Calls_f` be all calls satisfying its documented safety
+preconditions. The exact required domains are:
+
+- `Required(M-ack) = V_ack times C_M times Calls_ack`, where
+  `V_ack = {1.80.0, 1.80.1, 1.81.0, 1.82.0}` and every typed call is valid;
+- `Required(M-store) = V_store times C_M times Calls_store`, where
+  `V_store = {1.80.0, 1.81.0}`;
+- `Required(M-copy) = V_copy times C_M times Calls_copy`, where
+  `V_copy = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`; and
+- `Required(M-load) = V_load times C_M times Calls_load`, where
+  `V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`.
+
+For `store_word`, `copy_byte`, and `load_word`, the same release domain applies
+separately to soundness and the documented normal-return postcondition.
+
+### Expected results and atoms
+
+- **M1 — `acknowledge` domain:** Preserve exact finite set `V_ack` and its
+  target/profile product; every well-typed call is in `Calls_ack` because the
+  API adds no safety precondition.
+- **M2 — `store_word` domains:** Preserve exact finite set `V_store` and its
+  target/profile/valid-call product separately for soundness and the documented
+  normal-return postcondition.
+- **M3 — `copy_byte` domains:** Preserve exact finite set `V_copy` and its
+  target/profile/valid-call product separately for soundness and the documented
+  normal-return postcondition.
+- **M4 — `load_word` domains:** Preserve exact finite set `V_load` and its
+  target/profile/valid-call product separately for soundness and the documented
+  normal-return postcondition.
+
+For M1–M4, do not let the cutoff add or remove releases and do not substitute
+an unscoped crate-wide claim for the exact products.
+
+- **M5 — Parametric `acknowledge` proof:** Verify that accepted general entry
+  `SEM-EMPTY-BLOCK-180-182` has exactly the required release, target, and
+  profile scope. Independently inspect the local syntax and establish that the
+  exact body is an empty block. For arbitrary
+  `(v, target, profile, call) in Required(M-ack)`, combine only those premises:
+  `acknowledge` is zero-parameter and unit-returning, the valid call has defined
+  callee evaluation and returns `()`, and the `unsafe fn` marker changes only
+  its static caller obligation. Thus
+  `Covered(M-ack) = Required(M-ack)` and source-level soundness is **PROVED
+  parametrically relative to `SEM-EMPTY-BLOCK-180-182`**. Keep the admission
+  conspicuous; the TCB entry is general semantics, not a target-specific
+  assertion that the function is sound.
+- **M6 — `store_word` soundness partition:** The 1.80.0 `ptr::write` authority
+  applies exactly to the 1.80.0 case and the 1.81.0 authority to the 1.81.0
+  case. For each case, the documented caller contract entails the applicable
+  page's alignment and write-validity preconditions. The identity
+  `V_store = {1.80.0} union {1.81.0}` proves exhaustiveness. Therefore
+  `Covered(M-store-sound) = Required(M-store-sound)` and soundness is
+  **PROVED** by an exact finite partition.
+- **M7 — `store_word` postcondition partition:** In each exact release case,
+  the applicable page says that `ptr::write(dst, value)` writes the supplied
+  `value` to `dst` without reading or dropping the old value. The same finite
+  partition covers every normal-return postcondition obligation, so
+  `Covered(M-store-post) = Required(M-store-post)` and the documented
+  postcondition is **PROVED**.
+- **M8 — `copy_byte` soundness under the exact TCB:** Verify the Rust 1.80.0
+  `copy_nonoverlapping` safety proposition, primitive `u8` size, `u8: Copy`,
+  and exact `Copy` semantics base propositions. Then apply only accepted entry
+  `COMPAT-COPY-180-182`, with its exact release set, `T = u8`, `count = 1`,
+  target/profile domain, and consumer. The caller contract entails its source
+  and destination validity, initialization, alignment, and nonoverlap clauses;
+  the admitted `u8` and `Copy` facts establish the one-byte specialization and
+  avoid the ownership hazard for non-`Copy` values. Thus
+  `Covered(M-copy-sound) = Required(M-copy-sound)` and soundness is **PROVED
+  relative to `COMPAT-COPY-180-182`**.
+- **M9 — `copy_byte` postcondition under the exact TCB:** The accepted entry
+  preserves the base proposition that the call copies the source byte into the
+  destination while leaving the source byte unchanged; `u8` has size one and
+  implements `Copy` with the cited copy rather than move semantics. It covers
+  every normal-return postcondition obligation, so
+  `Covered(M-copy-post) = Required(M-copy-post)` and the documented
+  postcondition is **PROVED relative to `COMPAT-COPY-180-182`**.
+- **M10 — `load_word` soundness remainder:** In the 1.80.0 and 1.82.0 endpoint
+  cases, the exact `ptr::read` Safety sections plus exact-version `u32: Copy`
+  and `Copy`-semantics facts prove soundness from the caller contract,
+  including safe retention of the source value alongside the returned copy.
+  Thus
+  `Covered(M-load-sound) = {1.80.0, 1.82.0} times C_M times Calls_load`.
+  The 1.80.1 and 1.81.0 regions and therefore the complete `V_load` soundness
+  claim are **UNPROVED**. No UB witness is supplied, so `UNSOUND` does not
+  follow.
+- **M11 — `load_word` postcondition remainder:** In the same two endpoint
+  cases, the applicable `ptr::read` descriptions establish that the returned
+  value is read from `src` while the source is left unchanged; the exact
+  `u32: Copy` and `Copy`-semantics facts discharge the ownership qualification.
+  Therefore
+  `Covered(M-load-post) = {1.80.0, 1.82.0} times C_M times Calls_load`.
+  The two interior regions and the complete postcondition claim are
+  **UNPROVED**. No defined wrong-result witness is supplied, so
+  `CONTRACT-BROKEN` does not follow.
+
+Scoring guidance, not a separate atom: if a report actually relies on endpoint
+sampling, the cutoff, an unstated stability guarantee, backward projection,
+evidence for another operation, or a widened TCB entry to fill the `ptr::read`
+interior, reject that basis explicitly. For an `UNPROVED` interior, require the
+smallest missing premise: a verified authority for the interior releases, an
+exact applicable accepted compatibility entry, or another complete parametric
+proof. A report that uses none of the listed invalid bases need not recite them.
+
+### M hard errors
+
+Any of these is a hard error:
+
+- reporting the complete `load_word` claim `PROVED` by endpoint sampling,
+  cutoff reasoning, a stability badge, unprovided interior docs, or another
+  operation's evidence;
+- claiming `Required subset Covered` for `load_word` while omitting either
+  interior release;
+- silently widening `COMPAT-COPY-180-182` by release, operation, type/count,
+  target/profile domain, proposition, or consumer;
+- silently widening `SEM-EMPTY-BLOCK-180-182` by release, source shape,
+  proposition, or consumer;
+- treating either accepted entry as authoritative Rust text rather than a
+  conspicuous TCB premise;
+- projecting a later Rust proposition backward to an earlier release without
+  an exact applicable premise; or
+- issuing `UNSOUND` or `CONTRACT-BROKEN` for an unresolved interior merely from
+  failure to prove it.
+
+Failure to establish a required positive regional result is an atom failure. It
+is not by itself a hard error unless the report also makes one of the false
+affirmative or scope-changing claims above.
+
+### M checked authorities
+
+Open each exact page and confirm the named description and Safety propositions,
+including all qualifications relevant to its exact release case:
+
+- `https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html`
+  — overwrites without reading or dropping the old value; `dst` must be valid
+  for writes and properly aligned.
+- `https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html`
+  — the same exact propositions for the separate 1.81.0 case.
+- `https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html`
+  — copies `count * size_of::<T>()` bytes; source/destination validity,
+  alignment, and nonoverlap requirements; base case only.
+- `https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout`
+  — `u8` has size 1.
+- `https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8`
+  — `u8` implements `Copy` in the compatibility base case.
+- `https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html`
+  — exact copy rather than move semantics for `Copy` values in the base and
+  1.80.0 endpoint cases.
+- `https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html`
+  — reads without moving, leaves source unchanged, and requires read validity,
+  alignment, and initialization for this non-ZST.
+- `https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32`
+  — `u32` implements `Copy` in the 1.80.0 endpoint case.
+- `https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html`
+  — the same named propositions for the separate endpoint case.
+- `https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32`
+  — `u32` implements `Copy` in the 1.82.0 endpoint case.
+- `https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html`
+  — exact copy rather than move semantics for `Copy` values in the 1.82.0
+  endpoint case.
+
+The `acknowledge` and compatibility results additionally consume the two exact
+accepted propositions in target file `TCB.md`; that file is not Rust authority
+and both admissions must remain identified as part of the conditional TCB.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/allowlist.txt
new file mode 100644
index 0000000000..d74c62056e
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/allowlist.txt
@@ -0,0 +1,11 @@
+https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html
+https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html
+https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html
+https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout
+https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8
+https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html
+https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html
+https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32
+https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html
+https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32
+https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/A.md
new file mode 100644
index 0000000000..52da9e9ef5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/A.md
@@ -0,0 +1,61 @@
+# Source-only unsafe Rust audit
+
+## Claim, snapshot, and domain
+
+This audits exactly the four exported unsafe functions in `target/lib.rs`, under their published caller contracts, for absence of Rust undefined behavior and every documented postcondition. The snapshot is the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; no generated code, dependencies, tools, builds, or execution are involved. Audit cutoff: 2026-07-31. TCB revision: the submitted `TCB.md`.
+
+`SUPPORT.md` expressly defines complete finite sets, so no interval inference is used:
+
+- `V_ack = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+- `V_store = {1.80.0, 1.81.0}`
+- `V_copy = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+- `V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`
+
+For each, `Required` is its exact release set crossed with every target where the item exists, every ordinary debug/release profile, and every call satisfying its documented safety obligations. The explicit completeness statement proves equality between each list and its `Required` release projection. There is no `cfg`, generator, feature, or profile-dependent source. Target/profile coverage below is parametric: the cited abstract operation contract is unqualified over those axes, or the accepted TCB entry expressly quantifies over them.
+
+## Verdict ledger
+
+| API / component | Exact `Covered` release region | Regional and full-domain verdict |
+|---|---|---|
+| `acknowledge` soundness | `V_ack` | **PROVED** on `V_ack` |
+| `acknowledge` postconditions | No prose postcondition; unit return is covered on `V_ack` | **PROVED** for the signature-implied `()` return |
+| `store_word` soundness | `V_store` | **PROVED** on `V_store` |
+| `store_word`: destination contains `value` | `V_store` | **PROVED** on `V_store` |
+| `store_word`: old `u16` is not read | `V_store` | **PROVED** on `V_store` |
+| `store_word`: old `u16` is not dropped | `V_store` | **PROVED** on `V_store` |
+| `copy_byte` soundness | `V_copy` | **PROVED** on `V_copy` |
+| `copy_byte`: destination byte equals the pre-call source byte | `V_copy` | **PROVED** on `V_copy` |
+| `copy_byte`: source byte is preserved | `V_copy` | **PROVED** on `V_copy` |
+| `load_word` soundness | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+| `load_word`: return equals the initialized pre-call source `u32` | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+| `load_word`: source remains unchanged | `{1.80.0, 1.82.0}` | **PROVED** there; **UNPROVED** on `{1.80.1, 1.81.0}`; full `V_load`: **UNPROVED** |
+
+Thus the strongest combined per-API verdicts are: `acknowledge` **PROVED**, `store_word` **PROVED**, `copy_byte` **PROVED**, and `load_word` **UNPROVED**. The combined four-API packet is **UNPROVED**. No submitted fact proves an existential UB execution or an UB-free postcondition counterexample, so neither **UNSOUND** nor **CONTRACT-BROKEN** is certified.
+
+## Proof certificates
+
+### `acknowledge`
+
+The inspected signature has no parameters, returns `()`, documents no additional caller obligation, and its body is exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` says precisely that, for every case in `V_ack` and the required target/profile axes, such evaluation is defined and returns `()`; `unsafe` only adds the static call obligation. The entry is restricted to this consumer. Hence aggregate `Covered = V_ack`, so `Required ⊆ Covered`.
+
+### `store_word`
+
+The only operation is `ptr::write::<u16>(dst, value)`. The caller contract supplies its two safety clauses: `dst` is properly aligned and valid to write one `u16`. The exact [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) authorities make those the operation requirements and specify overwrite with the supplied value without reading or dropping the old value. One authority applies to each member of `V_store`; their exhaustive union covers every required release. The source has no other operation or exit. Each soundness and postcondition obligation therefore has `Covered = V_store`, and their pointwise intersection is `V_store`.
+
+### `copy_byte`
+
+The source fixes `T = u8` and `count = 1`; its caller contract supplies readable initialized source, writable destination, alignment, and non-overlap. The accepted `COMPAT-COPY-180-182` entry preserves, for every `v ∈ V_copy` and required target/profile case, the exact 1.80.0 propositions for this operation: satisfaction of the safety contract, copying exactly one byte to `dst`, and leaving `src` unchanged, with `u8` size 1 and `Copy` semantics. Its verified bases are [`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy`](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html). The TCB expressly restricts consumption to `copy_byte`. Thus every obligation has `Covered = V_copy`; their intersection equals `Required`.
+
+### `load_word`
+
+The only operation is `ptr::read::<u32>(src)`. At 1.80.0 and 1.82.0, the caller supplies the cited operation's readable, aligned, initialized-source requirements. The respective [`read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) pages establish returning the read value while leaving source memory unchanged; the corresponding [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) discharge the copy/ownership bridge at those endpoints.
+
+No authority or accepted TCB entry applies these propositions to 1.80.1 or 1.81.0. Endpoint documentation, stability, and unchanged-looking source cannot supply semantic continuity. The smallest missing premise is: for each missing release and all required target/profile cases, `ptr::read::<u32>` retains the cited safety and result/source-preservation contract and `u32` retains the cited `Copy` semantics. Consequently `Covered = {1.80.0, 1.82.0}`, which does not contain `V_load`.
+
+## TCB, proof artifacts, and residual scope
+
+The only admitted non-authoritative premises are accepted OUT-OF-BAND entries `SEM-EMPTY-BLOCK-180-182` (consumer: `acknowledge`) and `COMPAT-COPY-180-182` (consumer: `copy_byte`). Their exact scopes, exclusions, and source/signature/contract/domain/disposition re-audit triggers are retained from `TCB.md`; neither is transferred to another API. All other consumed premises are the exact claim-specific versioned Rust pages above. No pending premise was used.
+
+The adjacent `SAFETY` comments correctly identify caller-contract forwarding but omit the material release-applicability and postcondition derivations reconstructed here. They should cite a canonical proof containing the exact authority/TCB entry and covered set. For `load_word`, comment wording cannot repair the missing 1.80.1/1.81.0 premise; resolution requires applicable authority or an explicitly accepted narrow compatibility entry.
+
+Re-audit on any source/signature/contract change, any supported-set or configuration expansion, material change to a cited page, or change to either TCB entry/disposition. Releases outside the four explicit predicates, binary/backend correctness, and broader robustness are excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/B.md
new file mode 100644
index 0000000000..145cd3c312
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/B.md
@@ -0,0 +1,45 @@
+# Source-only audit of four exported unsafe APIs
+
+## Claim, snapshot, and domain
+
+Snapshot: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`, audited at the support cutoff 2026-07-31. Scope is source-level Rust abstract-semantics soundness plus every documented postcondition of `acknowledge`, `store_word`, `copy_byte`, and `load_word`. A valid use satisfies the API's documented safety clauses. No backend/binary claim is made. No build, execution, expansion, generated artifact, dependency, or prior result is used.
+
+Let `D={ordinary-debug, ordinary-release}` and `C_A(V)={(v,t,p) | v in V, A exists on target t, p in D}`. `SUPPORT.md` explicitly defines finite sets, so no interval inference is involved:
+
+- `Required_ack=C_ack({1.80.0,1.80.1,1.81.0,1.82.0})`.
+- `Required_store=C_store({1.80.0,1.81.0})`.
+- `Required_copy=C_copy({1.80.0,1.80.1,1.81.0,1.82.0})`.
+- `Required_load=C_load({1.80.0,1.80.1,1.81.0,1.82.0})`.
+
+This is an exact normalization of each controlling expression: membership is listed explicitly and `SUPPORT.md` excludes every other release. The source has no `cfg`, feature, profile branch, macro, FFI, concurrency, allocator, or generated code. Thus target/profile coverage is parametric wherever the cited source-level contract or accepted TCB entry covers a release; only release applicability partitions the claims.
+
+## Results
+
+| API | Soundness | Documented postconditions, separately | Aggregate `Covered` | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | **PROVED** on `Required_ack` | returns `()`: **PROVED** on `Required_ack` | `Required_ack` | **PROVED** relative to `SEM-EMPTY-BLOCK-180-182` |
+| `store_word` | **PROVED** on `Required_store` | (1) stores `value` at `dst`; (2) does not read the old `u16`; (3) does not drop it: each **PROVED** on `Required_store` | `Required_store` | **PROVED** |
+| `copy_byte` | **PROVED** on `Required_copy` | (1) destination receives the pre-call source byte; (2) source byte remains unchanged: each **PROVED** on `Required_copy` | `Required_copy` | **PROVED** relative to `COMPAT-COPY-180-182` |
+| `load_word` | **PROVED** on `C_load({1.80.0,1.82.0})`; **UNPROVED** on `C_load({1.80.1,1.81.0})` | (1) returns the pre-call initialized `u32`; (2) source remains unchanged: each has the same regional split | `C_load({1.80.0,1.82.0})` | **UNPROVED** over `Required_load` |
+
+The strongest combined packet verdict is **UNPROVED** because `Required_load` is not contained in its aggregate `Covered`. No existential UB or UB-free postcondition counterexample is established, so neither `UNSOUND` nor `CONTRACT-BROKEN` applies.
+
+## Obligation ledger and derivations
+
+**ACK-S/P.** The body is syntactically exactly `{}` and the signature has no parameters and unit return. Accepted entry `SEM-EMPTY-BLOCK-180-182` states, for every required release/target/profile case, that such a body has defined evaluation and returns `()`, and that `unsafe` changes only the caller obligation. The documentation imposes no additional caller requirement. This proves soundness and the unit result; full-set closure is immediate.
+
+**STORE-S.** At both required releases the call is exactly `ptr::write::<u16>(dst,value)`. The caller contract supplies `dst` valid for writes of one `u16` and properly aligned, exactly the two safety clauses on the [1.80.0 contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and independently on the [1.81.0 contract](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html): “valid for writes” and “properly aligned.” Therefore each executed unsafe operation meets its applicable contract. **STORE-P1/P2/P3.** Each page says the operation overwrites with the given value “without reading or dropping the old value.” This directly entails all three postconditions. The exhaustive release partition `{1.80.0} union {1.81.0}` equals `V_store`.
+
+**COPY-S.** The local facts are `T=u8`, `count=1`, and exactly the documented source/destination alignment, access, initialization, and non-overlap obligations. The [1.80.0 operation contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) requires read/write validity, alignment, and non-overlap for `count*size_of::<T>()`; [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>()=1`. The stronger initialized-source clause is sufficient. This closes 1.80.0. Accepted `COMPAT-COPY-180-182` preserves these exact premises and the operation's satisfaction for every required release/target/profile case. **COPY-P1/P2.** The operation copies the one byte. [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and the [Copy contract](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)—“always a simple bit-wise copy”—permit both resulting values; the accepted entry explicitly preserves destination equality and unchanged source throughout `V_copy`. Hence each obligation covers all `Required_copy`.
+
+**LOAD-S.** For release 1.80.0, the exact `ptr::read::<u32>` call receives the three facts required by the [1.80.0 contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html): readable, aligned, and properly initialized. The same derivation independently uses the [1.82.0 contract](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) at 1.82.0. **LOAD-P1/P2.** Both pages state that `read` reads without moving and leaves source memory unchanged. The endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [Copy 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [Copy 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish safe coexistence and value preservation at those endpoints. No authority or accepted TCB proposition covers 1.80.1 or 1.81.0. Endpoint samples do not cover the intervening members, and `COMPAT-COPY-180-182` expressly excludes `ptr::read`. The smallest missing proposition is preservation, at 1.80.1 and 1.81.0, of the cited `ptr::read` safety and return/source guarantees plus `u32: Copy` semantics.
+
+## Boundary, TCB, findings, and maintenance
+
+The complete public surface in `lib.rs` is the four unsafe free functions; there are no safe wrappers, public fields, traits/impls, callbacks, hidden items, reexports, macros, representation invariants, or later unsafe consumers. Each caller-facing safety contract is sufficient for the covered regions. The short local `SAFETY` comments correctly identify the callee-contract handoff; release applicability is supplied by this evidence packet.
+
+TCB revision is the submitted `TCB.md`: `SEM-EMPTY-BLOCK-180-182` (accepted OUT-OF-BAND semantics; consumer only ACK-S/P) and `COMPAT-COPY-180-182` (accepted OUT-OF-BAND compatibility; consumers only COPY-S/P). Their exact identities, scope, exclusions, disposition, and triggers were checked; neither is transferred to another operation. All other consumed premises are the exact versioned official pages cited above. No tool-derived evidence or dependency trust is consumed.
+
+**Finding LOAD-COVERAGE (UNPROVED):** affects soundness and both postconditions only for `load_word` on releases 1.80.1 and 1.81.0, across every required target/profile. Resolution requires exact applicable authorities for those releases or a newly authorized, narrowly scoped compatibility premise proving the missing propositions. Re-audit all four claims if source/contracts or support sets change; re-audit consumers if either accepted entry or cited authority changes. Overall closure remains unavailable until `Required_load subseteq Covered_load` is established.
+
+All in-scope obligations have a disposition; every affirmative result above is relative only to the stated authorities and accepted TCB entries.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/C.md
new file mode 100644
index 0000000000..f8da4bed52
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/C.md
@@ -0,0 +1,53 @@
+# Multi-release unsafe Rust source review
+
+## Claim and result
+
+Snapshot: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; audit cutoff 2026-07-31. For each exported unsafe function, the independent claim is: every call satisfying its documented caller obligations is free of Rust undefined behavior and establishes each documented postcondition, for every required release, every target on which the item exists, and ordinary debug/release profiles, relative only to the accepted TCB below.
+
+Let:
+
+- `A = C = L = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `S = {1.80.0, 1.81.0}`;
+- `E = {1.80.0, 1.82.0}` and `M = {1.80.1, 1.81.0}`.
+
+`Covered` is the exact release region on which all premises consumed by a derivation apply.
+
+| API | Required | Covered | Soundness | Documented postconditions | Strongest combined verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `A` | `A` | `PROVED` on `A` | Normal return is `()` (`Q-A`): `PROVED` on `A`; no other postcondition is documented. | **PROVED** on Required, relative to `SEM-EMPTY-BLOCK-180-182`. |
+| `store_word` | `S` | `S` | `PROVED` on `S` | `Q-S1`: stores `value`; `Q-S2`: does not read the old `u16`; `Q-S3`: does not drop it. Each is `PROVED` on `S`. | **PROVED** on Required. |
+| `copy_byte` | `C` | `C` | `PROVED` on `C` | `Q-C1`: destination becomes the source byte; `Q-C2`: source byte is preserved. Each is `PROVED` on `C`. | **PROVED** on Required, relative to `COMPAT-COPY-180-182`. |
+| `load_word` | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M` | `Q-L1`: return equals the initialized source `u32`; `Q-L2`: source remains unchanged. Each is `PROVED` on `E`, `UNPROVED` on `M`. | **UNPROVED** on Required; endpoint region `E` is **PROVED**. |
+
+Thus the combined result for all four requested claims is **UNPROVED** solely because `load_word` is uncovered on `M`. No `UNSOUND` or `CONTRACT-BROKEN` witness is established.
+
+## Boundary and configuration closure
+
+The complete exported surface is four public unsafe free functions; there are no public fields, constructors, safe wrappers or methods, traits, callbacks, macros, hidden items, dependencies, generated artifacts, `cfg` branches, or invariant-bearing state in the submitted source. The only unsafe operations are one `ptr::write`, one `copy_nonoverlapping`, and one `ptr::read`; the empty function has none. Target/profile axes are proof-parametric: source selection and arguments do not vary, the versioned standard-library contracts apply wherever each item exists, and both admitted entries expressly quantify over the stated target/profile domain. No tests or tool-derived evidence were used.
+
+## Obligation ledger and derivations
+
+**A — `acknowledge`.** Local inspection establishes a zero-parameter, unit-returning function whose body is exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies exactly to that fact over `A`, entails defined callee evaluation and `()`, and therefore proves soundness and `Q-A`. “Has no additional safety requirements” leaves no hidden caller premise.
+
+**S — `store_word`.** At both required releases, the submitted [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) pages say it overwrites with the given value “without reading or dropping the old value”; each requires `dst` to be valid for writes and properly aligned. The function's Safety clauses supply those exact requirements for `T = u16`. The single call therefore satisfies its callee contract and the description entails `Q-S1`–`Q-S3` on each member of `S`.
+
+**C — `copy_byte`.** The [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) contract requires readable/writable `count * size_of::<T>()` regions, alignment, and non-overlap, and says it copies that many bytes. The [1.80.0 layout table](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>() = 1`; [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and the [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) establish bit-copy rather than move semantics. Locally, `T = u8` and `count = 1`, so the documented caller clauses entail every callee clause. Accepted `COMPAT-COPY-180-182` preserves precisely these propositions, including `Q-C1` and `Q-C2`, over all `C`; no cross-operation transfer occurs.
+
+**L — `load_word`.** Both submitted [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) pages require readable, aligned, properly initialized storage and say the value is read without moving it while source memory remains unchanged. The caller contract supplies the three requirements. At each endpoint, [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish copy semantics, closing soundness and both postconditions on `E`.
+
+## TCB audit
+
+| Entry | Exact admitted proposition/domain | Consumer | Disposition |
+|---|---|---|---|
+| `SEM-EMPTY-BLOCK-180-182` | Defined evaluation and unit return for the exact empty-function shape, all `A` targets/profiles. | `acknowledge` only | Accepted; local shape verified. |
+| `COMPAT-COPY-180-182` | Preserves the enumerated 1.80.0 one-`u8` copy contract, safety, size, Copy semantics, and both results over `C`. | `copy_byte` only | Accepted; base pages and local type/count verified. |
+
+There are no other admitted premises, pending entries, or dependencies. Re-audit each entry on its stated source, contract, domain, or disposition trigger.
+
+## Findings
+
+**F-L-COVERAGE — `UNPROVED`.** On `M`, the smallest missing proposition is: `ptr::read::<u32>` has the stated three safety requirements and read/unchanged postconditions, and `u32` has the required Copy semantics. Endpoint documentation does not propagate inward or backward, and neither accepted entry applies to `ptr::read`. No UB witness and no UB-free postcondition refutation is established. Resolution requires admissible release-specific authorities or an accepted compatibility proposition covering exactly `M`; then re-audit all `load_word` obligations.
+
+**F-C-PROOF-DOC — proof artifact deficient; implementation proved.** The adjacent `copy_byte` comment omits the material `T = u8`, `count = 1`, `size = 1`, Copy/source-preservation, and compatibility derivation reconstructed above. Suitable replacement: “For `T=u8,count=1`, the caller's one-byte read/write, alignment, and non-overlap clauses satisfy the callee contract; `COMPAT-COPY-180-182` supplies the applicable one-byte copy and source-preservation result.” This does not change the implementation verdict.
+
+Residual scope excludes releases outside Required and binary/backend correctness. Re-audit on source or contract changes, support-set expansion, relevant Rust-documentation changes, or either TCB trigger.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/D.md
new file mode 100644
index 0000000000..08828c4235
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/D.md
@@ -0,0 +1,124 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and aggregate result
+
+This is a source-level review of the supplied `lib.rs` snapshot, at the
+2026-07-31 support cutoff, relative only to `EVIDENCE.md` and accepted TCB
+entries `SEM-EMPTY-BLOCK-180-182` and `COMPAT-COPY-180-182`. It covers all four
+exported unsafe functions, their caller contracts, UB freedom for every valid
+call, and every stated result. It makes no compiler-backend, binary, deployment,
+or broader robustness claim. There are no dependencies, generated artifacts,
+features, conditional source paths, stateful invariants, safe wrappers, fields,
+traits, macros, or other exported surfaces in the supplied source.
+
+Let `T_f(v)` mean every target on which item `f` exists, and let
+`P={ordinary-debug, ordinary-release}`. For each API,
+`Required_f={(v,t,p) | v in V_f, t in T_f(v), p in P}`. `SUPPORT.md` directly
+defines each `V_f` as an exact finite set, so no interval interpolation or
+enumeration inference is used. Target and profile are semantic parameters: the
+source has no branch on either, and every cited authority or consumed TCB entry
+applies to all such cases in its stated release region.
+
+| API | `V_f` | Exact aggregate `Covered` release region | Soundness | Documented results | Strongest API verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `V_f` | **PROVED** | return `()`: **PROVED** | **PROVED** |
+| `store_word` | `{1.80.0,1.81.0}` | all `V_f` | **PROVED** | stores `value`: **PROVED**; old `u16` is neither read nor dropped: **PROVED** | **PROVED** |
+| `copy_byte` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `V_f` | **PROVED** | destination receives the source byte: **PROVED**; source is preserved: **PROVED** | **PROVED**, relative to `COMPAT-COPY-180-182` |
+| `load_word` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | `{1.80.0,1.82.0}` | **UNPROVED** over `Required`; **PROVED** on `Covered` | returned value and unchanged source: each **UNPROVED** over `Required`, **PROVED** on `Covered` | **UNPROVED** |
+
+Thus the combined four-API mandatory claim is **UNPROVED**, solely because
+`Required_load` is not contained in `Covered_load`. No submitted fact proves a
+valid UB witness or a UB-free postcondition counterexample, so neither
+`UNSOUND` nor `CONTRACT-BROKEN` is certified.
+
+## Obligation ledger and proofs
+
+**ACK-S/Q.** The caller contract imposes no additional safety requirement, and
+the exact body is `{}`. `SEM-EMPTY-BLOCK-180-182` applies to precisely all four
+releases, all item-bearing targets, and both profiles; the checked empty body
+connects the source to its admitted proposition that evaluation is defined and
+returns `()`. Hence `Required_ack = Covered_ack` for soundness and return.
+
+**STORE-S.** The only operation is `ptr::write::<u16>(dst,value)`. The public
+contract supplies its two documented safety clauses: `dst` is properly aligned
+and valid for one `u16` write. The 1.80.0 and 1.81.0 `ptr::write` authorities
+apply separately to the two members of `V_store`; their exhaustive union is
+`Covered_store=V_store`. A typed `u16` supplies the value passed to the exact
+call. Soundness is therefore proved.
+
+**STORE-Q1/Q2.** Those same two release-specific pages state that `write`
+overwrites the destination with the given value without reading or dropping
+the old value. The direct call has no later transition, proving both documented
+results over the same exhaustive union.
+
+**COPY-S.** Locally, `T=u8` and `count=1`; the caller contract establishes
+initialized readable source, writable destination, alignment, and non-overlap
+for the one-byte regions. The 1.80.0 `copy_nonoverlapping` contract, primitive
+layout, `u8: Copy`, and `Copy` semantics establish the base case.
+`COMPAT-COPY-180-182` explicitly preserves those exact propositions for every
+member of `V_copy`, target, and profile, and is authorized only for this call.
+Thus `Covered_copy=V_copy` and soundness is proved.
+
+**COPY-Q1/Q2.** The same accepted entry expressly guarantees that this exact
+call copies exactly one byte to `dst`, leaves the source byte unchanged, and
+does not move ownership from it. These propositions directly establish both
+documented results throughout `Required_copy`.
+
+**LOAD-S/Q.** The only operation is `ptr::read::<u32>(src)`. The caller contract
+provides readable validity, alignment, and initialization. At 1.80.0, that
+release's `read`, `u32: Copy`, and `Copy` pages prove a defined read returning
+the source value while leaving source memory unchanged. The parallel 1.82.0
+pages prove the same case at 1.82.0. Therefore each soundness and result
+obligation has `Covered={1.80.0,1.82.0}` (with all corresponding targets and
+profiles). No authority applies at 1.80.1 or 1.81.0, and `TCB.md` explicitly has
+no `read` compatibility entry. Endpoint facts do not cover the interior.
+
+## Evidence and TCB audit log
+
+All authority entries are accepted versioned Rust standard-library/Reference
+premises with exactly the claim-specific applicability stated in `EVIDENCE.md`:
+[write 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and
+[write 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html);
+[copy_nonoverlapping 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html),
+[primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout),
+[u8: Copy](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8),
+and [Copy semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html);
+and `read`, `u32: Copy`, and `Copy` semantics at
+[1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html), with the
+corresponding versioned primitive/trait pages identified in `EVIDENCE.md`. No
+entry is transferred between operations.
+
+| TCB ID | Disposition and exact use | Limit / trigger |
+|---|---|---|
+| `SEM-EMPTY-BLOCK-180-182` | accepted; defined evaluation and `()` return of an exact empty-body unsafe function over `V_ack` | only `ACK-S/Q`; any signature, body, contract, release-set, or disposition change |
+| `COMPAT-COPY-180-182` | accepted; preserves the enumerated 1.80 copy/layout/Copy propositions over all `V_copy` | only `COPY-S/Q`; any call/type/count/base proposition/release-set/disposition change |
+
+No tool-derived evidence, test result, sampled configuration, or unlisted
+assumption contributes to a verdict.
+
+## Findings, proof artifacts, and residual scope
+
+**F-LOAD-COVERAGE — UNPROVED.** The smallest missing proposition is: for each
+`v in {1.80.1,1.81.0}`, `ptr::read::<u32>` under the documented caller clauses
+is defined, returns the read value, leaves the source unchanged, and the needed
+`u32: Copy` semantics apply, for every supported target/profile. Resolution
+requires applicable versioned authorities or an accepted, exact compatibility
+premise; testing or endpoint interpolation is insufficient. Re-audit all
+`load_word` claims after resolution.
+
+The three local `SAFETY` comments identify their callees but omit the material
+release-applicability and, for copy/read, layout/`Copy` bridges and TCB route.
+Implementation status remains as above, but the proof artifacts are deficient.
+Minimum documentation repair is to cite stable canonical proofs containing the
+corresponding ledger derivation; this cannot repair `F-LOAD-COVERAGE` without
+new evidence.
+
+Residual scope is exactly nonlisted Rust releases, nonordinary profiles,
+targets where an item does not exist, backend/binary correctness, and behavior
+beyond the stated results. Re-audit on source or contract changes, support-set
+changes, material authority changes, or either TCB entry's trigger.
+
+**Attestation:** every in-scope surface, safety obligation, documented result,
+release case, and consumed premise has a disposition; affirmative claims have
+`Required subseteq Covered`, and the unresolved remainder remains explicit.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/E.md
new file mode 100644
index 0000000000..7960f7bf85
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/E.md
@@ -0,0 +1,121 @@
+# Unsafe Rust source review
+
+## Claim, snapshot, and boundary
+
+This review covers exactly the four unconditional `pub unsafe fn` items in
+`lib.rs`, with `SUPPORT.md`, `EVIDENCE.md`, and accepted TCB revision `TCB.md`,
+at cutoff 2026-07-31. For each item the claim is: every call satisfying its
+literal `# Safety` contract has UB-free callee evaluation and establishes every
+documented postcondition, for every required release, every target on which the
+item exists, and every ordinary debug or release profile, relative only to the
+TCB below.
+
+The four functions are the complete exported surface. There are no safe
+functions, fields, traits, macros, generated artifacts, dependencies, FFI,
+stateful invariants, or conditional bodies in the submitted source. This is a
+source-level Rust-semantics result, not a compiler/backend or binary theorem.
+
+## Results
+
+Sets below are finite sets, not intervals.
+
+| API | `Required` | Exact `Covered` by evidence | Soundness | Documented postconditions | Strongest combined verdict over `Required` |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `Required` | **PROVED** | No prose postcondition; signature/body return `()` is **PROVED** | **PROVED** |
+| `store_word` | `{1.80.0,1.81.0}` | all `Required` | **PROVED** | stores `value`: **PROVED**; does not read old contents: **PROVED**; does not drop old contents: **PROVED** | **PROVED** |
+| `copy_byte` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | all `Required` | **PROVED** | destination receives source byte: **PROVED**; source byte is preserved: **PROVED** | **PROVED** |
+| `load_word` | `{1.80.0,1.80.1,1.81.0,1.82.0}` | `{1.80.0,1.82.0}` | **PROVED** on `Covered`; **UNPROVED** on `{1.80.1,1.81.0}` | returned value equals source `u32`: same regional result; source is unchanged: same regional result | **UNPROVED** |
+
+No UB witness or UB-free postcondition refutation is established. Thus no
+`UNSOUND` or `CONTRACT-BROKEN` result applies.
+
+## Obligation ledger and derivations
+
+### `acknowledge`
+
+Its caller contract imposes no additional condition, and the inspected body is
+exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies to precisely this
+signature/body and all `Required` target/profile cases: evaluation is defined
+and returns `()`. Those facts discharge soundness and the signature result
+without transferring the entry to another API.
+
+### `store_word`
+
+For each required release, the caller supplies write-validity and alignment for
+one `u16`. The exact [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html)
+and [1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) contracts
+require exactly write-validity and alignment. Substitution of `T=u16` therefore
+discharges the sole `ptr::write(dst, value)` call. Each page also states that
+`write` overwrites with the supplied value without reading or dropping the old
+contents, proving all three postconditions. No compatibility premise is used.
+
+### `copy_byte`
+
+The caller provides read-valid, initialized `src`, write-valid `dst`, alignment
+of both, and nonoverlap of the one-byte regions. The
+[1.80.0 operation contract](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html)
+requires those region properties for `count * size_of::<T>()`; the
+[layout axiom](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout)
+gives `size_of::<u8>()=1`. The [implementation fact](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8)
+and [Copy semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)
+establish ordinary bitwise duplication rather than ownership transfer.
+Accepted `COMPAT-COPY-180-182` preserves exactly these safety and result
+propositions over every `Required` release/target/profile. With source
+`T=u8,count=1`, the call is defined, writes the source byte to `dst`, and leaves
+the source byte unchanged.
+
+### `load_word`
+
+At each covered endpoint, the caller's read-validity, alignment, and initialized
+`u32` facts exactly discharge the [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html)
+or [1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) `ptr::read`
+contract. Those pages say the value is read without moving and source memory is
+unchanged. Endpoint-specific `u32: Copy` evidence
+([1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32),
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32))
+and Copy semantics
+([1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html),
+[1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html)) permit the
+returned duplicate and original source value to remain usable.
+
+For 1.80.1 and 1.81.0, the smallest missing implication is: the endpoint
+`ptr::read` safety/effect propositions and `u32: Copy` semantics apply without
+weaker guarantees or added preconditions. No submitted authority or accepted
+TCB entry supplies it; later evidence cannot propagate backward and 1.80.0
+evidence cannot propagate forward unaided. Soundness and both postconditions
+therefore remain `UNPROVED`.
+
+## Configuration closure and TCB log
+
+Release is the only evidence-sensitive axis. Target/profile coverage is
+parametric because each consumed authority or TCB proposition has the stated
+all-targets-where-present and ordinary-profile applicability, and source
+selection does not vary. The table exhaustively partitions every required
+finite release set. No builds or tool-derived evidence were used.
+
+| Entry | Disposition and exact consumers |
+|---|---|
+| Versioned Rust/std pages listed above | authoritative, claim-specific axioms only in their stated release regions |
+| `SEM-EMPTY-BLOCK-180-182` | accepted OUT-OF-BAND proposition; only `acknowledge` |
+| `COMPAT-COPY-180-182` | accepted OUT-OF-BAND compatibility proposition; only `copy_byte` |
+
+There are no other admitted premises. The TCB entries do not assume an in-scope
+conclusion: local source facts connect each narrow proposition to its consumer.
+
+## Proof-artifact findings and residual scope
+
+The caller-facing safety clauses are sufficient where evidence covers them.
+The three pointer-operation `SAFETY` comments state call-precondition transfer
+but omit the material result derivations and release applicability reconstructed
+above; `acknowledge` states its contract outside a conventional `# Safety`
+section. These are documentation deficiencies, not implementation defects in
+proved regions. Suitable adjacent result text is, respectively: `write`
+overwrites without reading/dropping; the one-`u8` copy copies one byte and,
+because `u8: Copy`, preserves source ownership; `read` returns a `u32` copy and
+leaves source unchanged. No comment can close `load_word`'s middle releases
+without new admissible evidence.
+
+Residual scope is exactly `load_word` on 1.80.1 and 1.81.0, plus all binary,
+backend, nonordinary-profile, and unlisted-release claims. Re-audit on any
+source/contract change, support-set expansion, changed cited documentation,
+TCB disposition/scope change, or addition of configuration-dependent code.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/F.md
new file mode 100644
index 0000000000..2a38edeae6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/F.md
@@ -0,0 +1,40 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and strongest results
+
+This review covers exactly `lib.rs` in the submitted packet, independently for the four exported unsafe free functions. For each API, the claim is: every call satisfying its documented safety obligations has defined source-level Rust evaluation and establishes every stated normal-return postcondition, for every release in its `Required` set, every target on which the item exists, and ordinary debug and release profiles. The audit cutoff is 2026-07-31. Results are relative to the exact submitted authorities and accepted `TCB.md`; no compiler-backend or binary theorem is claimed.
+
+| API | `Required` | Exact evidence-backed `Covered` | Soundness | Documented postconditions | Strongest combined verdict |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same set | **PROVED** throughout | Normal return yields `()`: **PROVED** throughout | **PROVED** |
+| `store_word` | `{1.80.0, 1.81.0}` | same set | **PROVED** throughout | Stores `value`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop it: **PROVED**, each throughout | **PROVED** |
+| `copy_byte` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same set | **PROVED** throughout | Destination receives the source byte: **PROVED**; source byte remains unchanged: **PROVED**, each throughout | **PROVED** |
+| `load_word` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | `{1.80.0, 1.82.0}` | **PROVED** on `Covered`; **UNPROVED** on `{1.80.1, 1.81.0}`, hence **UNPROVED** for `Required` | Returns the initialized source `u32`: endpoint **PROVED**, interior **UNPROVED**; leaves source unchanged: endpoint **PROVED**, interior **UNPROVED** | **UNPROVED** for `Required`; **PROVED** on `Covered` |
+
+No valid UB witness or UB-free postcondition refutation is established. Thus no result is `UNSOUND` or `CONTRACT-BROKEN`.
+
+## Obligation ledger and proofs
+
+**ACK-S/ACK-Q (`lib.rs:3-4`).** The function has no caller safety precondition beyond making an unsafe call, and its exact body is `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` applies to precisely this body, signature, all four required releases, applicable targets, and both profile classes. Its proposition entails defined evaluation and the unit return. Nothing is transferred to another API.
+
+**STORE-S/STORE-Q (`lib.rs:6-13`).** At both required releases, the call is exactly `ptr::write::<u16>(dst, value)`. The caller contract supplies the two [1.80.0 `write`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) / [1.81.0 `write`](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) safety conjuncts: write-validity for one `u16` and proper alignment. `value` is a well-typed `u16`. Each versioned description states that `write` overwrites with the supplied value without reading or dropping the old value; this proves all three postconditions. The two singleton authority regions exhaust `Required`.
+
+**COPY-S/COPY-Q (`lib.rs:16-25`).** The call fixes `T = u8`, `count = 1`. The [1.80.0 layout table](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout) gives `size_of::<u8>() = 1`; therefore the [1.80.0 `copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) read-validity, write-validity, alignment, and nonoverlap regions reduce exactly to the one-byte obligations documented at lines 20-22. [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8) and [1.80.0 `Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) establish that duplicating this byte does not move ownership. The operation copies exactly that byte and preserves source initialization/state. Accepted `COMPAT-COPY-180-182` explicitly preserves this complete safety and postcondition proposition over every release in `Required`, target, and profile. Its four-release region exhausts `Required`.
+
+**LOAD-S/LOAD-Q (`lib.rs:28-36`).** At each covered endpoint, the call is `ptr::read::<u32>(src)`. The [1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) contracts require read-validity, alignment, and a properly initialized `u32`, exactly supplied at lines 32-33. Their descriptions establish reading/returning the value while leaving source memory unchanged. Endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) discharge duplicate-ownership concerns. For 1.80.1 and 1.81.0 the smallest missing proposition is that these exact `ptr::read` safety, return-value, source-preservation, and `u32: Copy` propositions apply. Endpoint documentation does not cover interior releases, and neither accepted TCB entry permits that transfer. This blocks every interior obligation.
+
+## Boundary, configuration, and trust closure
+
+The complete source surface is the four unsafe functions above. There are no safe APIs, fields, constructors, traits/impls, macros, hidden items, FFI, generated artifacts, dependencies, callbacks, persistent invariants, or configuration branches in the submitted source. Target and profile coverage is parametric: the source has one path, and each consumed authority or TCB proposition applies without a target/profile branch over its stated region. No tests or tool-derived evidence were used.
+
+TCB identity is the exact submitted `TCB.md` (no external revision was supplied). Both entries are accepted OUT-OF-BAND propositions: `SEM-EMPTY-BLOCK-180-182`, consumed only by ACK-S/ACK-Q, and `COMPAT-COPY-180-182`, consumed only by COPY-S/COPY-Q. Their identities, quantifiers, consumers, exclusions, and re-audit triggers were checked. There are no admitted dependency, platform, implementation, deployment, or probabilistic premises. The absent `load_word` compatibility proposition is not silently added.
+
+## Finding DOC-1: local proof comments are deficient
+
+The three pointer-operation comments merely assert that the caller supplies “exactly/every” callee precondition. They omit the material type/count/size and ownership derivations above and cite no applicable authority. This is proof-documentation debt, not an implementation defect in each API's `Covered` region. Minimal replacements should state: for `store_word`, `T=u16` and lines 10-13 discharge write-validity/alignment; for `copy_byte`, `T=u8`, `count=1`, `size=1`, lines 20-22 discharge all four regional obligations, and `u8: Copy` makes duplication ownership-safe; for `load_word`, `T=u32`, lines 32-33 discharge read-validity/alignment/initialization, and `u32: Copy` permits the returned copy while the source remains. The latter wording must cite only a release region actually covered.
+
+## Residual scope and re-audit triggers
+
+Excluded are releases outside `Required`, nonordinary profiles, targets where an item does not exist, compiler correctness, code generation, and binary/platform behavior. To close `load_word`, supply accepted claim-specific authority or compatibility evidence for both missing releases (or change the support contract); `COMPAT-COPY-180-182` cannot be reused. Re-audit on any source/signature/contract change, change to a required set or configuration scope, material authority change, or change in either accepted TCB entry or its disposition.
+
+Final attestation: every in-scope soundness and documented-postcondition obligation has a regional status; every `PROVED` region has a complete derivation relative to the stated TCB; uncovered regions remain conspicuously `UNPROVED`.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/G.md
new file mode 100644
index 0000000000..d387539998
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/G.md
@@ -0,0 +1,59 @@
+# Multi-release unsafe Rust source review
+
+## Claim, snapshot, and verdicts
+
+This review covers exactly the four exported `unsafe` free functions in the submitted `lib.rs`, with `SUPPORT.md` (cutoff 2026-07-31), `EVIDENCE.md`, and `TCB.md` controlling. A valid call is a well-typed call satisfying the function's documented `# Safety` obligations. For each API and each required release/target/profile, the soundness claim is that every valid call has defined Rust-abstract-semantics evaluation. Each stated result/post-state guarantee is a separate mandatory postcondition. This is source-level only; no compiler-binary, deployment, security, or extra robustness claim is made.
+
+Let:
+
+- `A = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `S = {1.80.0, 1.81.0}`;
+- `C = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`;
+- `L = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`, `E = {1.80.0, 1.82.0}`, and `M = {1.80.1, 1.81.0}`.
+
+Every set also quantifies over every target on which the item exists and every ordinary debug or release profile.
+
+| API / independent claim | `Required` | Exact `Covered` | Regional and strongest verdict |
+|---|---:|---:|---|
+| `acknowledge` soundness | `A` | `A` | `PROVED` |
+| `acknowledge` returns `()` | `A` | `A` | `PROVED` |
+| `store_word` soundness | `S` | `S` | `PROVED` |
+| destination receives `value` | `S` | `S` | `PROVED` |
+| old `u16` is not read | `S` | `S` | `PROVED` |
+| old `u16` is not dropped | `S` | `S` | `PROVED` |
+| `copy_byte` soundness | `C` | `C` | `PROVED` |
+| destination receives the pre-call source byte | `C` | `C` | `PROVED` |
+| source byte remains unchanged | `C` | `C` | `PROVED` |
+| `load_word` soundness | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+| returned `u32` equals the pre-call source value | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+| source `u32` remains unchanged | `L` | `E` | `PROVED` on `E`; `UNPROVED` on `M`; whole-`L` `UNPROVED` |
+
+Thus the strongest combined mandatory verdict is `PROVED` independently for `acknowledge`, `store_word`, and `copy_byte`, and `UNPROVED` for `load_word`. No `UNSOUND` execution or UB-free `CONTRACT-BROKEN` witness is established.
+
+## Derivations and obligation coverage
+
+**`acknowledge`.** The inspected signature has no parameters and returns unit; its body is exactly `{}`. Accepted TCB entry `SEM-EMPTY-BLOCK-180-182`, restricted to this consumer, says exactly that across `A` such a body has defined evaluation and returns `()`, and that `unsafe` changes only the caller obligation. The published contract imposes no additional obligation. These facts entail both rows over all of `A`.
+
+**`store_word`.** For each member of `S`, the corresponding versioned [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) or [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) authority requires `dst` to be write-valid and properly aligned. The API's caller contract supplies both for one `u16`; the source fixes `T = u16` and calls `write(dst, value)` once. The same authorities state that `write` overwrites with the given value “without reading or dropping the old value.” Therefore the call is permitted and establishes each of the three postconditions. The two exact authority regions exhaust `S`.
+
+**`copy_byte`.** The source fixes `T = u8`, `count = 1`. Its caller contract supplies initialized one-byte source readability, destination writability, alignment of both pointers, and non-overlap. The submitted [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) authorities establish permission, one-byte extent, copying rather than moving, destination equality, and source preservation at 1.80.0. Accepted consumer-specific `COMPAT-COPY-180-182` preserves exactly those propositions, without added preconditions, throughout `C` and all required targets/profiles. Hence all three rows are proved on `C`.
+
+**`load_word`.** At each endpoint in `E`, the matching [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) or [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) authority requires a non-ZST source to be read-valid, aligned, and initialized; the caller contract supplies those facts for the source-fixed `T = u32`. The matching endpoint [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32) and [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), or [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32) and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html), combine with `read`'s “without moving” and source-unchanged guarantees to prove both postconditions.
+
+For `M`, no submitted authority applies and no accepted TCB entry transfers either endpoint's `ptr::read`, `u32: Copy`, or `Copy` propositions. Similar source and endpoint documentation cannot propagate guarantees forward or backward. The smallest missing premise is the same safety and behavior contract, including applicable `u32` copy semantics, for each release in `M`, or an accepted compatibility proposition covering precisely those releases. All three `load_word` claims therefore remain `UNPROVED` there.
+
+## Boundary, configuration, and evidence closure
+
+The complete submitted source has four public unsafe free-function surfaces and no public safe functions, fields, constructors, traits/impls, macros, hidden/reexported APIs, invariant-bearing state, dependencies, generated artifacts, conditional compilation, callbacks, FFI, assembly, allocation, or concurrency. Each call is its own unsafe boundary; there are no cross-call invariants or transitions.
+
+Configuration coverage is parametric over target and ordinary profile because the source has no configuration branch and every consumed authority/TCB proposition carries the stated target/profile applicability. Release coverage is the explicit finite partition above, not a numeric interval. No builds or tool-derived evidence were used. Regions outside each API's `Required`, nonordinary profiles/flags, binaries/backends, and releases after the cutoff are excluded rather than inferred unsupported by the project.
+
+## TCB audit log and findings
+
+TCB identity is the exact submitted `TCB.md`. Trust policy admits only versioned Rust authorities listed in `EVIDENCE.md` and the two human-accepted `OUT-OF-BAND` entries. `SEM-EMPTY-BLOCK-180-182` is consumed only by `acknowledge`; `COMPAT-COPY-180-182` only by `copy_byte`. Their quantification, exclusions, consumers, and source/support-change re-audit triggers were checked. No entry is transferred to `store_word` or `load_word`; no new premise is admitted.
+
+`F-LOAD-MIDDLE` (`UNPROVED`) is the only verdict-affecting finding: it affects soundness and both postconditions for `load_word` on `M`; there is no admissible release-applicable semantic bridge. Resolution requires the missing versioned authorities or authorized narrowly scoped compatibility entry, followed by re-review.
+
+`F-PROOF-DOC` is non-verdict documentation debt: the three pointer-operation `SAFETY` comments assert “exactly”/“every” precondition but omit the versioned contract clauses and resulting postconditions reconstructed above. A replacement should name the concrete type/count, enumerate the locally inherited caller facts, cite the applicable authority/TCB entry, and state the established post-state. No wording can close `load_word` on `M` without new evidence.
+
+Re-audit on any source/signature/contract change, support-set or cutoff change, material authority change, or change to either TCB entry/disposition. Final attestation: every in-scope surface, soundness obligation, documented postcondition, release region, and consumed premise has a status; `PROVED` is asserted only on the exact covered regions relative to the stated TCB.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/H.md
new file mode 100644
index 0000000000..dcb861f59f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/H.md
@@ -0,0 +1,109 @@
+# Multi-release unsafe API source audit
+
+## Claim, snapshot, and result
+
+This review covers exactly the four exported `unsafe fn`s in `lib.rs`, at the
+2026-07-31 cutoff. For each API independently, the soundness claim is: every
+call satisfying its documented caller obligations has defined source-level Rust
+evaluation. The postcondition claim is each behavioral promise stated in that
+API's documentation. `Required` is the API-specific finite release set in
+`SUPPORT.md`; it is not an interval. In every listed release the target domain
+is every target on which the item exists and every ordinary debug or release
+profile. There are no dependencies, generated artifacts, conditional source,
+or additional configuration axes in the submitted snapshot. Compiler/backend
+correctness and binary behavior are excluded.
+
+| API | Required | Covered by admissible evidence | Soundness | Documented postconditions | Strongest combined verdict over Required |
+|---|---|---|---|---|---|
+| `acknowledge` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same as Required | **PROVED** throughout | No behavioral postcondition is documented; the signature-level return of `()` is also **PROVED** throughout | **PROVED** |
+| `store_word` | `{1.80.0, 1.81.0}` | same as Required | **PROVED** throughout | Stores `value` at `dst`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop the old `u16`: **PROVED**, all throughout | **PROVED** |
+| `copy_byte` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | same as Required | **PROVED** throughout | Destination becomes the source byte: **PROVED**; source byte is preserved: **PROVED**, all throughout | **PROVED** |
+| `load_word` | `{1.80.0, 1.80.1, 1.81.0, 1.82.0}` | `{1.80.0, 1.82.0}` | **PROVED** on Covered; **UNPROVED** on `{1.80.1, 1.81.0}` | Returned `u32` equals the initialized source value: **PROVED** on Covered and **UNPROVED** on the remainder; source is unchanged: the same regional result | **UNPROVED** |
+
+No valid UB witness or UB-free postcondition refutation is established. Thus no
+regional result is `UNSOUND` or `CONTRACT-BROKEN`.
+
+## Obligation derivations
+
+### `acknowledge`
+
+The local body is exactly `{}`, with zero parameters and unit return, and the
+documentation imposes no additional safety requirement. Accepted
+`SEM-EMPTY-BLOCK-180-182` states, for every release, target, and profile in
+Required, that this exact form has defined evaluation and returns `()`; making
+the function unsafe changes only the static call obligation. The body/signature
+facts therefore instantiate that entry over all of Required. The TCB entry is
+not used by any other API.
+
+### `store_word`
+
+The only unsafe operation is `ptr::write(dst, value)`. For both required
+releases, the submitted version-matched [`write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html)
+and [`write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html)
+contracts require `dst` to be properly aligned and valid for writes; these are
+exactly the public caller obligations. The well-typed `value: u16` supplies the
+value being written. The same version-matched descriptions establish overwrite
+without reading or dropping the old value. Hence soundness and every listed
+effect are covered in both required releases without a compatibility premise.
+
+### `copy_byte`
+
+The source fixes `T = u8` and `count = 1`. Its caller contract supplies a
+readable initialized source `u8`, a writable destination `u8`, alignment of
+both, and nonoverlap of the one-byte regions. The submitted 1.80.0
+[`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html),
+[primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout),
+[`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8),
+and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html)
+establish the base safety requirements, one-byte size, copying effect, and
+non-moving source preservation. Accepted `COMPAT-COPY-180-182` preserves those
+exact propositions across every release, target, and profile in Required.
+Together with the local fixed type/count and caller clauses, this proves both
+soundness and both postconditions throughout Required. The entry expressly
+cannot support `ptr::read`, `ptr::write`, or another API.
+
+### `load_word`
+
+At 1.80.0 and 1.82.0, the version-matched [`read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html)
+and [`read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html)
+contracts require a readable, aligned, properly initialized non-ZST source;
+the public caller contract supplies those facts for one `u32`. The respective
+[`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32)
+and [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html),
+and the corresponding [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32)
+and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html),
+combine with each `read` description to establish the returned value and
+unchanged source at those endpoints.
+
+For 1.80.1 and 1.81.0, the packet supplies neither version-applicable `read` and
+`Copy` authorities nor an accepted compatibility proposition. Later 1.82.0
+text cannot establish earlier semantics, and 1.80.0 text cannot be propagated
+forward without an admitted compatibility premise. `COMPAT-COPY-180-182` is
+operation-specific and explicitly excludes `ptr::read`. The smallest missing
+implication is that, in each uncovered release and full target/profile domain,
+the documented caller facts satisfy `ptr::read`'s safety contract and the call
+returns the source `u32` while leaving the source unchanged. Absence of that
+premise makes both regional claims `UNPROVED`; it is not evidence of UB.
+
+## TCB, proof artifacts, and maintenance
+
+The complete non-authoritative TCB is the two accepted entries in `TCB.md`:
+`SEM-EMPTY-BLOCK-180-182`, consumed only by `acknowledge`, and
+`COMPAT-COPY-180-182`, consumed only by `copy_byte`. All `write`, `read`, layout,
+and `Copy` facts above are claim- and release-specific submitted Rust authority;
+none is transferred to a different operation or release.
+
+The API safety contracts are sufficient for the proved regions. The terse
+`SAFETY` comments do not themselves record the material release-applicability
+derivations reconstructed above, especially the `copy_byte` compatibility
+bridge and the endpoint-only `load_word` proof. This is proof-documentation
+debt, not a contrary implementation verdict. A replacement comment should cite
+the exact local type/count and caller clauses plus the applicable authority/TCB
+entry; no comment can close `load_word`'s two missing release premises.
+
+Re-audit is required upon any source/signature/contract change, change to a
+Required set or target/profile policy, change or withdrawal of either accepted
+TCB entry, or material change to a consumed versioned authority. To obtain a
+full `load_word` verdict, submit applicable authority for 1.80.1 and 1.81.0 or
+an accepted narrowly scoped compatibility premise covering the exact missing
+propositions.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/I.md
new file mode 100644
index 0000000000..28fcb1744f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/I.md
@@ -0,0 +1,48 @@
+# Multi-release source-only unsafe Rust audit
+
+## Claim, snapshot, and boundary
+
+Artifact: the submitted `lib.rs`, `SUPPORT.md`, `EVIDENCE.md`, and `TCB.md`; audit cutoff 2026-07-31. For each exported unsafe function independently, the claim is: for every listed Rust release, every target on which the item exists, every ordinary debug/release profile, and every call satisfying its documented safety contract, evaluating the exact body is free of Rust undefined behavior and establishes each stated postcondition, relative only to the accepted TCB below.
+
+The complete reachable surface is four stateless exported unsafe functions: `acknowledge`, `store_word`, `copy_byte`, and `load_word`. There are no exported safe wrappers, fields, constructors, traits/impls, macros, generated artifacts, `cfg` branches, dependencies, callbacks, or invariant-bearing state in the submitted source. Thus target and profile are parametric axes: the source operation does not vary, and each proof below covers every such case to which its cited premise applies. This is a Rust source-semantics result, not a compiler-backend or binary theorem.
+
+`SUPPORT.md` directly defines explicit finite sets, so no interval normalization is used:
+
+- `V_ack = V_copy = V_load = {1.80.0, 1.80.1, 1.81.0, 1.82.0}`.
+- `V_store = {1.80.0, 1.81.0}`.
+
+For each claim, `Required = V_api × targets-where-item-exists × {ordinary-debug, ordinary-release}`. No release may be inferred between submitted evidence points.
+
+## Verdict summary
+
+| API | Soundness | Documented postconditions, separately | Aggregate `Covered` | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | **PROVED** on `V_ack` | returns `()`: **PROVED** on `V_ack` (there is no additional prose postcondition) | `Required_ack` | **PROVED**, relative to `SEM-EMPTY-BLOCK-180-182` |
+| `store_word` | **PROVED** on `V_store` | stores `value` at `dst`: **PROVED**; does not read the old `u16`: **PROVED**; does not drop the old `u16`: **PROVED**, each on `V_store` | `Required_store` | **PROVED** |
+| `copy_byte` | **PROVED** on `V_copy` | copies exactly the source byte to `dst`: **PROVED**; leaves the source byte unchanged: **PROVED**, each on `V_copy` | `Required_copy` | **PROVED**, relative to `COMPAT-COPY-180-182` |
+| `load_word` | **PROVED** on `{1.80.0,1.82.0}`; **UNPROVED** on `{1.80.1,1.81.0}` | returns the initialized source `u32`: same regional result; leaves source unchanged: same regional result | `{1.80.0,1.82.0} × targets × profiles` | **UNPROVED** over `Required_load` |
+
+The combined mandatory result for all four APIs is **UNPROVED**, solely because `Required_load ⊄ Covered_load`. No submitted fact proves an in-scope UB execution or a UB-free postcondition counterexample, so neither `UNSOUND` nor `CONTRACT-BROKEN` is certified.
+
+## Obligation proofs
+
+**`acknowledge`.** Its contract imposes no additional caller condition; inspection establishes a zero-parameter, unit-returning function with body exactly `{}`. Accepted `SEM-EMPTY-BLOCK-180-182` states parametrically over every `v ∈ V_ack`, relevant target, and ordinary profile that such a well-typed call has defined callee evaluation and returns `()`, and that `unsafe` changes only the static caller obligation. These facts prove both obligations and `Required_ack ⊆ Covered_ack`.
+
+**`store_word`.** At each member of `V_store`, the applicable [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html) contracts require `dst` to be valid for writes and aligned and say that the given value overwrites the location without reading or dropping the old value. The API contract supplies validity for one `u16` and alignment; `value: u16` is supplied by value; the body performs exactly `write(dst, value)`. Therefore soundness and all three postconditions hold in each release case. The two singleton cases exhaust `V_store`, hence their union is `Covered_store = Required_store`.
+
+**`copy_byte`.** The body instantiates `copy_nonoverlapping` with `T=u8,count=1`. The contract supplies readable initialized source, writable destination, both alignments, and non-overlap of the one-byte regions. The accepted compatibility entry imports, for every case in `V_copy`, the exact relevant propositions from [`copy_nonoverlapping` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html), [primitive layout](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html): these conditions satisfy the operation contract, one byte is copied to `dst`, and the source is unchanged. Thus every obligation has `Covered = Required_copy`.
+
+**`load_word`.** For 1.80.0, [`ptr::read`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html), [`u32: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html) apply. The corresponding [1.82.0 `read`](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html), [`u32: Copy`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) apply at 1.82.0. At each endpoint, the caller supplies readable, aligned, initialized `u32` storage; `read(src)` therefore is defined, returns its value, and leaves the source unchanged, with copying rather than ownership-moving semantics. No authority or accepted compatibility premise applies those propositions to 1.80.1 or 1.81.0. Endpoint agreement cannot cover the interior. The smallest missing propositions are the same `ptr::read`, `u32: Copy`, and Copy-semantic guarantees for both middle releases.
+
+## TCB, findings, and maintenance
+
+TCB identity: submitted `TCB.md`. Both entries are human-accepted and narrowly consumed:
+
+- `SEM-EMPTY-BLOCK-180-182`: only the empty-body evaluation and unit return used by `acknowledge`.
+- `COMPAT-COPY-180-182`: only the enumerated one-byte `copy_nonoverlapping` safety and postcondition propositions used by `copy_byte`.
+
+They are not transferred to `store_word` or `load_word`. There is no tool-derived or test evidence and no other admitted premise.
+
+**Finding F-LOAD-COVERAGE (UNPROVED; evidence/domain closure).** Affects soundness and both postconditions of `load_word` on 1.80.1 and 1.81.0. This is not an established implementation defect: the packet lacks the applicability bridge required for those releases. Resolution requires exact applicable authorities for both releases or an accepted proposition-preserving compatibility entry covering precisely the missing operations and release region. Re-audit on any source/contract/support-set change, either TCB disposition change, or material change to a consumed versioned authority.
+
+Residual scope: compiler implementation, code generation, binaries, nonordinary profiles, targets where an item does not exist, and Rust releases outside the explicit finite sets are excluded.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/J.md
new file mode 100644
index 0000000000..10168ee5d5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/reports/J.md
@@ -0,0 +1,44 @@
+# Unsafe Rust source audit: four exported APIs
+
+## Claim, snapshot, and result
+
+This review covers exactly the submitted `lib.rs`, its four exported unsafe functions, the contracts in that file, the finite policies in `SUPPORT.md`, and the submitted evidence/TCB packet. Audit cutoff: 2026-07-31. There is no generated code, conditional compilation, dependency, safe wrapper, trait, field, macro, FFI, concurrency, allocator, or other API surface in the submitted source. No binary/backend claim is made.
+
+For API `f`, let `D(V) = V × {every target on which f exists} × {ordinary debug, ordinary release}`. The theorem is: every call satisfying `f`'s documented caller obligations has defined callee evaluation under documented Rust abstract semantics and establishes each listed postcondition. The exact target/profile quantifiers come directly from `SUPPORT.md`; copying each explicitly declared finite release set into `D` is an equality, not interval inference.
+
+**Strongest four-API result: UNPROVED.** `acknowledge`, `store_word`, and `copy_byte` are fully **PROVED** relative to the accepted submitted TCB. `load_word` is regionally proved but its full required claim is **UNPROVED**. No `UNSOUND` or `CONTRACT-BROKEN` witness is established.
+
+| API | Required releases | Soundness | Documented postconditions (separate results) | Strongest combined verdict |
+|---|---|---|---|---|
+| `acknowledge` | `A={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED**, `Covered=A` | No prose postcondition; its signature-level `()` return is **PROVED**, `Covered=A` | **PROVED** over `D(A)` |
+| `store_word` | `S={1.80.0,1.81.0}` | **PROVED**, `Covered=S` | destination stores `value`: **PROVED**, `Covered=S`; old `u16` is not read: **PROVED**, `Covered=S`; old `u16` is not dropped: **PROVED**, `Covered=S` | **PROVED** over `D(S)` |
+| `copy_byte` | `C={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED**, `Covered=C` | destination receives the pre-call source byte: **PROVED**, `Covered=C`; source byte is preserved: **PROVED**, `Covered=C` | **PROVED** over `D(C)` |
+| `load_word` | `L={1.80.0,1.80.1,1.81.0,1.82.0}` | **PROVED** on `E={1.80.0,1.82.0}`; **UNPROVED** on `M={1.80.1,1.81.0}`; aggregate `Covered=E` | returned value equals the initialized source `u32`: same regional results; source is unchanged: same regional results | **UNPROVED** over `D(L)` |
+
+For each proved claim, all required obligations have the displayed same release coverage, so their pointwise intersection is that `Covered`; equality with the relevant required set proves `Required ⊆ Covered`. For `load_word`, `E ⊂ L`, so closure fails.
+
+## Obligation proofs
+
+**ACK-SOUND/RET.** The inspected body is exactly `{}`, has no operation or state transition, and matches the signature covered by accepted `SEM-EMPTY-BLOCK-180-182`. That entry parametrically guarantees defined evaluation and return of `()` for every case in `D(A)`. There are no caller safety preconditions or other postconditions.
+
+**STORE-SOUND/VALUE/NOREAD/NODROP.** The caller contract supplies an aligned `dst` valid to write one `u16`; these are exactly the safety clauses of [`ptr::write` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.write.html) and [`ptr::write` 1.81.0](https://doc.rust-lang.org/1.81.0/std/ptr/fn.write.html), independently verified for their respective singleton cases. The call uses that `dst` and passed `value`. Each page says the operation overwrites the location with the value without reading or dropping the old value. The exhaustive union of the two singleton lemmas is `S`.
+
+**COPY-SOUND/DEST/SOURCE.** The call fixes `T=u8,count=1`. The caller contract supplies source/destination validity, initialization, alignment, and non-overlap. The verified 1.80 authorities establish the matching [`copy_nonoverlapping`](https://doc.rust-lang.org/1.80.0/std/ptr/fn.copy_nonoverlapping.html) clauses, [`size_of::<u8>()=1`](https://doc.rust-lang.org/1.80.0/reference/type-layout.html#primitive-data-layout), [`u8: Copy`](https://doc.rust-lang.org/1.80.0/std/primitive.u8.html#impl-Copy-for-u8), and [bitwise `Copy` semantics](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html). Accepted `COMPAT-COPY-180-182` preserves exactly the defined-call, one-byte destination-copy, source-preservation, size, and `Copy` propositions over every case in `D(C)`. Its consumer restriction is obeyed.
+
+**LOAD-SOUND/RETURN/SOURCE.** At 1.80.0 and 1.82.0, the caller's aligned/readable/initialized `src` exactly discharges the independently verified [`ptr::read` 1.80.0](https://doc.rust-lang.org/1.80.0/std/ptr/fn.read.html) and [`ptr::read` 1.82.0](https://doc.rust-lang.org/1.82.0/std/ptr/fn.read.html) safety clauses. Those pages establish return of the read value and unchanged source. The corresponding [`u32: Copy` 1.80.0](https://doc.rust-lang.org/1.80.0/std/primitive.u32.html#impl-Copy-for-u32), [`Copy` semantics 1.80.0](https://doc.rust-lang.org/1.80.0/std/marker/trait.Copy.html), [`u32: Copy` 1.82.0](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#impl-Copy-for-u32), and [`Copy` semantics 1.82.0](https://doc.rust-lang.org/1.82.0/std/marker/trait.Copy.html) establish that retaining and returning the duplicate `u32` preserves ownership validity. These are endpoint lemmas only.
+
+## Finding LOAD-GAP — missing interior-release applicability
+
+- **Status:** `UNPROVED`; implementation and both postconditions on `D(M)`.
+- **Smallest missing premise:** for each `v∈M`, under the documented pointer conditions, this exact `ptr::read::<u32>` call is defined, returns the source value, leaves the source unchanged, and `u32` has the required `Copy` semantics.
+- **Why unresolved:** the submitted pages apply only to 1.80.0 and 1.82.0. An audit cutoff and endpoint agreement do not establish semantic continuity. `TCB.md` supplies no `load_word` compatibility entry, and operation-specific evidence may not be transferred.
+- **Certificate check:** no valid in-scope execution with a proved false safety proposition or UB consequence exists in the packet; no UB-free falsifying execution exists. Therefore neither `UNSOUND` nor `CONTRACT-BROKEN` applies.
+- **Resolution:** provide applicable authorities for both interior releases or accept an exact proposition-preserving compatibility premise covering them, then re-audit all three obligations.
+
+## TCB, proof artifacts, and residual scope
+
+TCB identity is the exact submitted `TCB.md`. Its only non-authoritative entries are accepted `SEM-EMPTY-BLOCK-180-182` (consumed only by ACK-SOUND/RET) and accepted `COMPAT-COPY-180-182` (consumed only by COPY-SOUND/DEST/SOURCE). Their identities, scopes, limitations, consumers, and triggers were checked. All eleven submitted official pages were opened at their exact versioned URLs and their stated propositions verified. No tool-derived theorem or additional premise is consumed.
+
+**Proof-documentation finding:** implementation proofs above reconstruct facts absent from the adjacent comments. `acknowledge` should place its no-requirements contract under `# Safety`. The three pointer comments identify caller-side preconditions but omit resulting facts and version applicability; `copy_byte` especially omits the `u8/count/size/Copy` bridge, and `load_word` omits the `u32: Copy` bridge. This does not weaken proved implementation regions, but the proof artifacts are deficient. Add the corresponding compact derivations above; no wording change can repair `LOAD-GAP` without new evidence.
+
+Excluded: releases outside the explicit sets, nonordinary profiles, targets where an item does not exist, backend/binary correctness, and properties not documented or requested. Re-audit on any source/signature/contract change, support-set or configuration change, authoritative-page change, or change/disposition change to either consumed TCB entry.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/M/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/PACKET.json
new file mode 100644
index 0000000000..5f13f542c0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "Q",
+  "presentation_order": [
+    "D",
+    "B",
+    "E",
+    "F",
+    "A",
+    "I",
+    "G",
+    "J",
+    "H",
+    "C"
+  ],
+  "report_sha256": {
+    "A": "6ff6a7e4a093b5a955df9709844c232c585146e16d159b1c5a51e93e53dee468",
+    "B": "a596f12e22efee1d14c1f64eea7c3a10da7c32d779c496b890874fd4ef2be972",
+    "C": "199d71241d40542bdfcb5dff45e6e3f2384eacfe6f21f69747a7eaab44f200d4",
+    "D": "0ff6cb9b958a530a041aa729635ab67524b6fbcc772a8cf5856d861bbe23fb17",
+    "E": "36c357bebb8df0544f587b00a99169a56e62e1d1386c18984697ae62001ef573",
+    "F": "7545ffde31d113e2377bb3eb1304b7711101e88f6f29b168d2483ae2210177a4",
+    "G": "741de41033e7f4a9d25be1cf0231aee79363e384a8b71070b43a4b7f053baa67",
+    "H": "759b413defb47d8ad4c15c08233757841f374762b686d51515a8eddcd5ac1989",
+    "I": "4a8554d2840bc21e1a1da10ff8c50dc52fb362117b24e0d30e3359864a3db4b9",
+    "J": "a6eb34fd1d3c89310961cd76a7f61566e7226a18edb237f3540b96bf915b40e2"
+  },
+  "rubric_sha256": "154645b5d02c12a09d8162c6daca9d8843e81c9d4caa03165dc4acb5391d2a0a",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/RUBRIC.md
new file mode 100644
index 0000000000..fcec5e9489
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/RUBRIC.md
@@ -0,0 +1,76 @@
+# Mode Q Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## Q — Existential refutation and missing unsafe dependency
+
+Target: supplied Q snapshot.
+
+Let `C_Q` be Rust 1.80.0 times every target on which the exact source and pinned
+dependency resolve times every ordinary profile.
+
+- `Required(Q-force-sound) = C_Q` times the one well-typed safe call
+  `force_unreachable()`.
+- `Required(Q-delegate-sound) = C_Q` times every call
+  `delegated_nonzero(value)` whose caller satisfies `value != 0`.
+
+### Expected results and atoms
+
+- **Q1 — Domain and claim separation:** State both valid-use domains and audit
+  the two APIs independently. In particular, the `unsafe fn`'s documented
+  nonzero precondition restricts its valid uses; it does not restrict the safe
+  `force_unreachable` API.
+- **Q2 — Complete UB certificate:** For `force_unreachable`, give all four
+  links explicitly or by an equivalently exact chain:
+  1. `force_unreachable()` is a well-typed, valid safe call in `Required`;
+  2. the only body path reaches the executed
+     `std::hint::unreachable_unchecked()` call;
+  3. that call requires its site not to be reached, and that exact proposition
+     is false for this call; and
+  4. Rust 1.80.0 std documentation says reaching the function is undefined
+     behavior.
+- **Q3 — Existential closure:** Report `Q-force-sound` as **UNSOUND**. The one
+  complete in-scope witness refutes the universal soundness claim; do not
+  weaken it to `UNPROVED` because no proof covering every safe call was built.
+  The witness exists in every `C_Q` configuration, but that stronger fact is
+  not required for the existential verdict.
+- **Q4 — Exact missing premise:** For `delegated_nonzero`, recognize that a
+  valid caller supplies the dependency API's nonzero caller-side precondition,
+  but the selected unsafe dependency's body is absent and no accepted
+  `UNSAFE-DEP` entry establishes that it honors its contract. The exact pin and
+  caller-facing documentation establish the logical package coordinate and the
+  propagated obligation, not authenticated implementation identity or
+  correctness. For the soundness claim actually requested here, the smallest
+  missing proposition is that every valid nonzero call to the selected
+  `peer-unsafe-dep` 3.4.5 implementation is free of UB over this exact domain.
+- **Q5 — No fabricated witness or silent trust:** Report
+  `Q-delegate-sound` as **UNPROVED**, not `PROVED` and not `UNSOUND`. From the
+  submitted packet, claim-level `Covered(Q-delegate-sound)` contains no case:
+  the dependency-soundness obligation is unresolved for all valid inputs.
+  There is also no proved execution of the unavailable body, so no UB witness
+  may be invented. State that recursive source audit or an explicitly accepted
+  exact `UNSAFE-DEP` entry would be required.
+
+### Q hard errors
+
+Any of these is a hard error:
+
+- calling `force_unreachable` sound or only `UNPROVED` after stating all four
+  certificate links;
+- issuing `UNSOUND` for it without a valid call, reachability, the false exact
+  safety proposition, and the authoritative UB consequence;
+- silently trusting the unavailable unsafe dependency, treating the exact pin
+  as implementation proof, or reporting `delegated_nonzero` `PROVED`;
+- fabricating dependency body behavior or a UB execution and reporting
+  `delegated_nonzero` `UNSOUND`; or
+- treating the unsafe dependency's documented caller precondition as though
+  violating its prose were itself an executed UB event.
+
+### Q checked authority
+
+- `https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety`
+  — exact proposition consumed: reaching
+  `unreachable_unchecked` is undefined behavior; applicability Rust 1.80.0,
+  without a target/profile qualification relevant to this fixture.
+
+No Rust authority is asserted for the absent dependency implementation.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/allowlist.txt
new file mode 100644
index 0000000000..d467a88cf6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/allowlist.txt
@@ -0,0 +1 @@
+https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/A.md
new file mode 100644
index 0000000000..d0a4f0c6f1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/A.md
@@ -0,0 +1,60 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+This is a source-level review of the two exported functions in the submitted `lib.rs`, relative to Rust 1.80.0 abstract semantics. The inspected snapshot consists of `lib.rs`, `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, `TCB.md`, and `REQUEST.md`. The manifest selects edition 2021 and pins `peer-unsafe-dep = "=3.4.5"`; the submitted dependency record says that 3.4.5 is the exact resolution. No prior audit, dependency body, generated dependency output, binary, or tool result was supplied or reused.
+
+Define the common compilation predicate
+
+`D(c) := rust(c) = 1.80.0 ∧ edition(c) = 2021 ∧ target(c) is a target on which this source and exact peer-unsafe-dep 3.4.5 resolve ∧ profile(c) ∈ {ordinary debug, ordinary release}`.
+
+This is exactly the support expression in `REQUEST.md`, with the manifest facts conjoined; no target inventory or exclusion replaces it. The target and profile axes remain symbolic. The source has no `cfg`, feature declaration, generator, FFI, assembly, allocator, concurrency, or profile-dependent branch. The proofs below are therefore parametric in every `c` satisfying `D`. Unavailable dependency configuration paths are not excluded; they cause the second claim's gap.
+
+The API inventory is complete for the submitted crate source: one safe public free function, `force_unreachable`, and one unsafe public free function, `delegated_nonzero`; there are no fields, types, traits, impls, macros, callbacks, hidden APIs, reexports, or invariants. The only unsafe operations are their respective calls to `std::hint::unreachable_unchecked` and `peer_unsafe_dep::duplicate_nonzero`.
+
+## TCB and evidence disposition
+
+**AXIOM-UU (accepted):** the supplied Rust 1.80.0 standard-library page was opened and verified. Its Safety section states: “Reaching this function is Undefined Behavior.” The page is versioned 1.80.0 and supplies no narrower target/profile qualification. Per the human trust decision in `TCB.md`, this proposition applies throughout `D`. Source: [`std::hint::unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). Consumers: OBL-FU.
+
+**UNSAFE-DEP-PEER (not accepted):** no proposition about the implementation of exact `peer-unsafe-dep` 3.4.5 may be trusted. The exact pin establishes identity only. `TCB.md` expressly rejects such trust, and `DEPENDENCY-API.md` supplies a declaration and contract but no implementation assertion. Consumers: OBL-DN-SOUND and OBL-DN-RETURN.
+
+TCB identity is the submitted `TCB.md`; there are no other admitted implementation, compatibility, tool, or deployment propositions.
+
+## Claim 1 — `force_unreachable`
+
+**Exact claim.** For every `c` satisfying `D` and every well-typed safe call to `force_unreachable()`, the execution is free of Rust undefined behavior. Safe valid use has no caller-side safety precondition.
+
+**Verdict: UNSOUND throughout `D`.**
+
+**Existential certificate (OBL-FU):**
+
+1. In any `c ∈ D`, a safe caller may invoke the exported safe function `force_unreachable()`; this is a valid in-scope use.
+2. On entry, the body unconditionally evaluates `std::hint::unreachable_unchecked()`. There is no branch, check, input, or invariant that can prevent reaching it.
+3. Thus that valid call reaches the operation. Its required safety proposition—“this function is not reached”—is false.
+4. AXIOM-UU entails that reaching it is undefined behavior.
+
+This certificate is source-parametric over target and profile, so every member of `D` is affected. The local comment, “This site is assumed to be unreachable,” supplies no fact and is contradicted by public entry. This is both an implementation defect and a deficient proof artifact, not merely a documentation gap. No separate return-value postcondition is documented, and the UB-containing witness cannot establish `CONTRACT-BROKEN`.
+
+Minimum resolution: remove the reachable unchecked operation (for example, use a defined panic if non-return is intended) or establish non-reachability through an enforced boundary. A prose-only restriction cannot repair a safe API.
+
+## Claim 2 — `delegated_nonzero`
+
+**Exact valid-use domain.** For every `c` satisfying `D` and every call with `value ∈ {1, …, 255}` that observes the unsafe boundary, every permitted execution must be UB-free. The only documented initial obligation is `value != 0`; there are no documented ongoing or terminal obligations.
+
+**Verdict: UNPROVED.**
+
+**Local derivation (OBL-DN-CALLER, proved over all `D`):** the submitted dependency contract requires `value != 0`. A valid wrapper call supplies exactly that fact. The body forwards the same `u8` local, without transition, to `duplicate_nonzero`; therefore the dependency's caller-side precondition holds at the unsafe call. The adjacent safety comment adequately records this local bridge.
+
+**Smallest missing proposition (OBL-DN-SOUND):**
+
+> For exact `peer-unsafe-dep` 3.4.5, every `c ∈ D`, and every nonzero `v: u8`, every permitted execution of `duplicate_nonzero(v)` is free of Rust undefined behavior.
+
+Neither inspected source nor an accepted `UNSAFE-DEP` entry establishes it. Consequently the local caller obligation has coverage `D`, but provider-correctness coverage is established for no member of `D`; aggregate `Required ⊆ Covered` does not close. Absence of the body supplies no valid execution reaching UB, so the certificate for `UNSOUND` also does not close.
+
+The dependency documentation additionally says “Returns `value`.” If that provider guarantee is included as delegated wrapper behavior, **OBL-DN-RETURN is UNPROVED**: syntactically the wrapper returns the callee's result unchanged, but the missing proposition is that every valid call to the exact 3.4.5 implementation returns its input. No UB-free falsifying execution is supplied, so `CONTRACT-BROKEN` is not established.
+
+Minimum resolution: recursively audit the exact dependency implementation, including every path over `D`, or have an authorized reviewer accept precise `UNSAFE-DEP` propositions for UB freedom and any consumed return guarantee. The version pin or published unsafe contract alone is insufficient.
+
+## Closure, residual scope, and triggers
+
+For Claim 1, the refutation covers `D` parametrically. For Claim 2, only the wrapper-to-callee precondition proof covers `D`; the unavailable dependency implementation is the exact unresolved remainder. No tests or tools contribute evidence. Re-audit is required if either function or its documentation changes, `D` changes, Rust or AXIOM-UU changes, dependency identity/contract/implementation evidence changes, or the TCB disposition changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/B.md
new file mode 100644
index 0000000000..6c068e7472
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/B.md
@@ -0,0 +1,53 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+The audited snapshot is the supplied `Cargo.toml`, `lib.rs`, `DEPENDENCY-API.md`, `TCB.md`, `EVIDENCE.md`, and `REQUEST.md`. Scope is exactly the two exported functions in `lib.rs`; no dependency implementation, generated dependency output, binary, or prior audit was supplied.
+
+Let `C` be: Rust compiler and standard library 1.80.0, edition 2021; exact resolved package `peer-unsafe-dep` 3.4.5; every target on which this source and that exact dependency resolve; and every ordinary debug or release profile. The submitted source has no `cfg`, features, generated source, build script, profile-dependent assertion, arithmetic, allocation, panic-mode-sensitive cleanup, or target-specific operation. Thus the first result is parametric over `C`; for the second, both the proved local argument fact and the dependency gap are parametric over `C`.
+
+The sole admitted authority is `AXIOM-UU-1`: the verified Rust 1.80.0 standard-library page for [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states, “Reaching this function is Undefined Behavior.” The page identifies version 1.80.0 and places no target/profile qualification on that Safety clause. `TCB.md` accepts this proposition throughout `C`. There is no accepted `UNSAFE-DEP`, implementation, tool, compatibility, or deployment premise.
+
+## Claims and verdicts
+
+| API | Exact valid-use theorem over `C` | Soundness verdict |
+|---|---|---|
+| `pub fn force_unreachable()` | Every well-typed safe invocation, with no caller-side safety precondition, must have every permitted execution free of Rust UB. | **UNSOUND** |
+| `pub unsafe fn delegated_nonzero(value: u8) -> u8` | For every invocation whose caller ensures `value != 0`, every permitted execution must be free of Rust UB. No other caller obligation is documented. | **UNPROVED** |
+
+No additional caller-facing return-value postcondition is documented for `delegated_nonzero`; its sentence says that it delegates the value, not that the result equals it. The dependency's distinct provider contract says “Returns `value`.” If equality of the wrapper's result is intended to consume that contract, it is also **UNPROVED** because the provider implementation proposition below is neither proved nor admitted. No UB-free postcondition refutation is established.
+
+## Complete derivation: `force_unreachable`
+
+1. This is a safe free function. Therefore any well-typed safe call is valid; its prose cannot impose a hidden safety precondition.
+2. Its body has no branch or prior diverging operation. Every execution entering the body evaluates `std::hint::unreachable_unchecked()`.
+3. By `AXIOM-UU-1`, reaching that operation is UB throughout `C`.
+4. Consequently, a safe program that invokes `force_unreachable()` once is a valid in-scope execution that reaches UB. This witnesses **UNSOUND** uniformly for every configuration in `C`.
+
+The adjacent comment, “This site is assumed to be unreachable,” asserts the required conclusion but supplies no fact implying it. It is circular as a proof and cannot move the obligation across a safe API boundary. There is no separate mandatory unsafe-API postcondition for this safe function. Minimum repair would be to avoid `unreachable_unchecked` (for example, use a defined panic/divergence), or arrange that a locally proved impossible branch dominates the unsafe call; merely changing the comment is insufficient.
+
+## Derivation and smallest gap: `delegated_nonzero`
+
+1. The wrapper's controlling Safety contract requires exactly `value != 0`. A valid invocation therefore supplies that fact.
+2. The body passes the same `u8` value, unchanged, to `peer_unsafe_dep::duplicate_nonzero`.
+3. The submitted dependency contract requires exactly that its argument not equal zero. Steps 1–2 completely discharge this caller-side precondition for every valid wrapper call throughout `C`.
+4. Soundness of the wrapper also requires the selected unsafe dependency implementation to uphold its side of the contract. An unsafe function's caller documentation does not prove that its body avoids UB. The exact pin fixes identity but does not establish implementation correctness.
+5. The implementation and prior audit are absent, and `TCB.md` expressly declines any `UNSAFE-DEP` admission. Therefore the smallest missing soundness proposition is:
+
+   **DEP-SND-1:** For exact `peer-unsafe-dep` 3.4.5, every configuration in `C`, and every `v: u8` with `v != 0`, every permitted execution of `duplicate_nonzero(v)` is free of Rust UB.
+
+No supplied premise entails `DEP-SND-1`, so the verdict is **UNPROVED**, not **UNSOUND**: no valid UB witness for the unavailable implementation is established. To rely on the dependency's return promise as well, the additional missing proposition is:
+
+   **DEP-RET-1:** Under the same quantification, every normal UB-free return from `duplicate_nonzero(v)` equals `v`.
+
+The local `SAFETY` comment correctly proves the argument precondition but is not a complete end-to-end proof of provider correctness. Resolution requires either a recursive audit of the exact dependency implementation over all of `C`, or explicit human acceptance of precise `UNSAFE-DEP` entries for `DEP-SND-1` and, if consumed, `DEP-RET-1`.
+
+## Coverage, TCB, and residual scope
+
+The complete exported surface is the safe free function and unsafe free function above; there are no types, fields, constructors, methods, traits/impls, macros, callbacks, statics, FFI items, or reexports in the submitted `lib.rs`. There is no persistent invariant: `delegated_nonzero` transfers a per-call nonzero obligation directly to the dependency.
+
+Obligation status is complete: `force_unreachable` reachability is refuted by the unconditional control flow; the wrapper-to-dependency precondition is proved; dependency provider soundness is unproved; and the dependency return promise is unproved if treated as consumed. No tool-derived evidence was submitted or used. Tests or compilation could not establish the missing universal implementation theorem in any event.
+
+Residual scope consists of the dependency implementation, its generated artifacts, transitive unsafe behavior, prior audits, and binaries. They are not silently excluded from the wrapper theorem: their absence is exactly why it remains unproved. Re-audit is required if either function or contract changes, the supported set changes, the Rust authority changes, dependency identity/implementation/evidence changes, or a `DEP-SND-1`/`DEP-RET-1` trust decision is proposed.
+
+Combined result for the two requested claims: **UNSOUND** for `force_unreachable`; **UNPROVED** for `delegated_nonzero`, relative to the accepted `AXIOM-UU-1` and the explicit rejection of unsafe-dependency trust.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/C.md
new file mode 100644
index 0000000000..2a15e68799
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/C.md
@@ -0,0 +1,65 @@
+# Focused unsafe Rust source audit
+
+## Claim, snapshot, and domain
+
+The audited snapshot is the submitted `quantifier-target` 0.1.0 package: `lib.rs`, `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, and `TCB.md`. The two exported surfaces are the safe function `force_unreachable()` and the unsafe function `delegated_nonzero(u8) -> u8`. No fields, traits, macros, generated artifacts, `cfg`s, features, build scripts, FFI, concurrency, or other public surfaces are supplied. No build or dynamic evidence is used.
+
+Let
+
+`D = { (Rust 1.80.0, target t, profile p) | this exact source and peer-unsafe-dep 3.4.5 resolve on t, and p is an ordinary debug or ordinary release profile }`.
+
+This is exactly the support expression in `REQUEST.md`; it is retained symbolically rather than replaced by a sampled target inventory. `Cargo.toml` fixes edition 2021 and declares `peer-unsafe-dep = "=3.4.5"`; `DEPENDENCY-API.md` confirms that exact resolution. There are no other submitted configuration axes. Thus `Required = D`. The arguments below are parametric in `t` and `p`, so no target enumeration or profile sampling is used.
+
+The TCB for this report is the submitted `TCB.md` (“TCB-SUBMITTED”). Its sole accepted entry is:
+
+- **AXIOM-UU-1 (Rust authority):** for Rust 1.80.0 throughout `D`, reaching `std::hint::unreachable_unchecked` is undefined behavior. The exact official page was opened and independently verified; its Safety section says, “Reaching this function is *Undefined Behavior*.” ([Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety))
+
+The dependency declaration and submitted documentation establish identity and contract text, not implementation correctness. The human reviewer expressly declined an `UNSAFE-DEP` admission for `peer-unsafe-dep` 3.4.5. There are no compatibility, implementation, tool, or deployment assumptions.
+
+## CLAIM-FORCE — `force_unreachable`
+
+**Exact theorem.** For every configuration in `D` and every well-typed safe invocation of `force_unreachable()`, every permitted execution is free of Rust undefined behavior. Valid use has no input, state, temporal, or caller-side safety precondition because this is a safe API.
+
+**Verdict: UNSOUND throughout `D`, relative to TCB-SUBMITTED.**
+
+Complete existential certificate:
+
+1. **Valid in-scope use:** ordinary safe Rust invokes the exported safe function `force_unreachable()` in any configuration in `D`. The API imposes no precondition, so this invocation is valid.
+2. **Reachability:** the function body has no condition or earlier exit; its sole expression evaluates `unsafe { std::hint::unreachable_unchecked() }`. Therefore that invocation reaches the unsafe operation.
+3. **False safety proposition:** the operation requires that it not be reached. Step 2 proves the negation for the witness.
+4. **UB consequence:** AXIOM-UU-1 directly entails undefined behavior upon reaching it.
+
+The same source-local argument and target/profile-wide axiom cover every member of `D`; optimization level is irrelevant to the source-level UB event. The comment “This site is assumed to be unreachable” supplies no fact and is contradicted by every call. This is both an implementation defect and a deficient proof comment, not merely missing documentation. Because the witness execution contains UB, it establishes no separate UB-free postcondition refutation.
+
+Minimal repair: remove this safe path to `unreachable_unchecked`; for an intentionally callable safe API, use defined behavior such as a panic. Any changed artifact requires a fresh audit.
+
+## CLAIM-DELEGATED — `delegated_nonzero`
+
+**Exact theorem.** For every configuration in `D`, every `value: u8` with `value != 0`, and every unsafe invocation satisfying that sole documented precondition, every permitted execution of `delegated_nonzero(value)` is free of Rust undefined behavior. There are no documented ongoing or terminal caller obligations.
+
+**Verdict: UNPROVED throughout `D`, relative to TCB-SUBMITTED.**
+
+The complete available derivation is:
+
+1. The wrapper contract requires `value != 0`.
+2. The submitted contract of exact dependency API `peer_unsafe_dep::duplicate_nonzero` 3.4.5 has the identical caller-side safety precondition.
+3. At the only unsafe call, the argument is the unchanged `value`. Therefore every valid wrapper invocation satisfies the dependency call’s caller-side obligation. The adjacent SAFETY comment adequately records this local implication.
+4. The wrapper immediately returns the dependency call’s result and contains no other operation that can close the provider-side obligation.
+
+The smallest missing soundness proposition is:
+
+> **DEP-SOUND-1:** For every configuration in `D` and every nonzero `v: u8`, every execution of the exact `peer-unsafe-dep` 3.4.5 implementation of `duplicate_nonzero(v)` is free of Rust undefined behavior.
+
+Neither an exact pin nor the submitted unsafe API declaration proves DEP-SOUND-1. The implementation, generated output, prior audit, and binary are absent, and TCB-SUBMITTED expressly refuses to trust them. Consequently the caller-side obligation has coverage `D`, but the required provider-side obligation has no established covered region; their pointwise conjunction does not establish `Required ⊆ Covered`.
+
+No `UNSOUND` certificate exists: the unavailable body supplies no proved valid execution reaching a false safety proposition. Failure of the universal proof therefore yields `UNPROVED`, not `UNSOUND`.
+
+The dependency documentation also promises “Returns `value`.” If that provider guarantee is treated as a mandatory postcondition of this delegation, the wrapper’s `result == value` postcondition is likewise **UNPROVED**: the additional smallest missing proposition is that every valid, UB-free call to this exact implementation returns its input. There is no UB-free counterexample, so `CONTRACT-BROKEN` is not established.
+
+Minimal resolution: supply and recursively audit the exact dependency implementation and all generated/configuration-specific artifacts, or obtain explicit human acceptance of narrowly stated `UNSAFE-DEP` propositions covering DEP-SOUND-1 (and the return guarantee if consumed) over all of `D`.
+
+## Closure, residual scope, and triggers
+
+For CLAIM-FORCE, the certificate is target- and profile-parametric over `D`. For CLAIM-DELEGATED, the unresolved dependency proposition affects all of `D`; no tested subset can repair it. There is no tool-derived evidence. Binary/backend correctness and targets where the exact package does not resolve are outside this source-level theorem.
+
+Re-audit is required if either exported contract or body changes; Rust/standard-library version or cited semantics changes; the supported target/profile predicate changes; dependency identity, features, documentation, implementation, generated output, or trust disposition changes; or new public/generated surfaces appear.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/D.md
new file mode 100644
index 0000000000..97b39d6272
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/D.md
@@ -0,0 +1,102 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+This review covers exactly the submitted `lib.rs` exports in package
+`quantifier-target` 0.1.0 (edition 2021), with the manifest's exact dependency
+`peer-unsafe-dep = 3.4.5`, the submitted dependency declaration/contract, and
+the submitted evidence and trust decision. No dependency implementation,
+generated output, binary, source revision/digest, or prior audit was supplied.
+No build, execution, expansion, or implementation inference is used.
+
+Let **D** be Rust and standard library 1.80.0, every target on which this exact
+source and dependency resolve, and every ordinary debug or release profile.
+Both claims are source-level Rust-abstract-semantics claims over D. There are no
+source `cfg`s, features, profile-dependent checks, generators, FFI, allocation,
+concurrency, or other configuration branches in the submitted crate. Thus the
+source reasoning below is parametric over target and profile; the unavailable
+dependency implementation is a proof premise gap, not a silently excluded
+configuration.
+
+The complete exported surface is the two public free functions. There are no
+exported fields, types, traits, macros, statics, hidden items, or generated APIs
+in the supplied source, and no invariant-bearing state.
+
+## Evidence and TCB (`TCB.md`, submitted revision)
+
+| ID | Disposition | Exact proposition and scope | Consumer |
+|---|---|---|---|
+| AXIOM-UU | accepted and independently verified | Rust 1.80.0 documents: “Reaching this function is Undefined Behavior.” The page gives no target/profile qualification, so the supplied policy applies it throughout D. [Versioned Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). | FU-1 |
+| DEP-CONTRACT | controlling submitted contract, not implementation trust | `peer-unsafe-dep` 3.4.5 declares unsafe `duplicate_nonzero(value: u8) -> u8`; callers must supply `value != 0`, and its documented result is `value`. | DN-1, DN-2 |
+| UNSAFE-DEP-PEER | expressly not proposed or accepted | For every configuration in D and every nonzero `u8`, the exact 3.4.5 implementation executes without Rust UB and returns the input value. | Would be required by DN-2 |
+
+No implementation, compatibility, tool, or deployment premise is admitted.
+An exact version pin fixes identity but does not prove an unsafe provider's
+implementation conforms to its contract.
+
+## Claim 1: `force_unreachable`
+
+**Valid-use domain.** Every well-typed safe call in every configuration in D;
+the safe signature permits no caller-side safety precondition.
+
+**Claim.** Every such call and permitted execution is free of Rust UB.
+
+**Verdict: UNSOUND throughout D.** The body has no condition or alternative
+path: every invocation reaches `std::hint::unreachable_unchecked()`. FU-1's
+only obligation is that this call site not be reached. A well-typed safe caller
+can invoke the function, and the body necessarily reaches it. AXIOM-UU then
+entails UB. This is a valid in-scope UB witness for every member of D and
+refutes the universal soundness claim.
+
+The adjacent comment merely assumes the proposition contradicted by control
+flow; it supplies no fact or boundary. This is both an implementation defect
+and a deficient proof artifact. The minimal resolution is to remove the
+unchecked operation (for example, use defined panic/nonreturning behavior) or
+remove the callable safe surface; prose cannot impose a hidden safety
+precondition. The summary sentence supplies no ordinary-return postcondition,
+and the UB-containing witness is not a `CONTRACT-BROKEN` witness.
+
+## Claim 2: `delegated_nonzero`
+
+**Valid-use domain.** Every call in D whose caller satisfies the complete
+published safety condition `value != 0`; `u8` is passed by value, so the
+submitted contract creates no ongoing or terminal caller obligation.
+
+**Claim.** Every such call and permitted execution is free of Rust UB.
+
+**Verdict: UNPROVED throughout D.** DN-1, the local call obligation, is proved:
+the wrapper passes the unchanged `value`, and its caller contract is literally
+the dependency call's submitted precondition. The local `SAFETY` comment
+adequately records this implication.
+
+DN-2, provider conformance, is not proved. The smallest missing soundness
+proposition is:
+
+> For every configuration in D and every `value: u8` with `value != 0`, the
+> exact `peer-unsafe-dep` 3.4.5 implementation of `duplicate_nonzero(value)`
+> executes without Rust undefined behavior.
+
+No supplied source or accepted TCB entry establishes that proposition, and the
+human trust decision expressly rejects assuming it. Therefore satisfying the
+callee's caller precondition proves permission to call, not correctness of the
+unavailable unsafe implementation. No UB witness is established, so
+`UNSOUND` would be unjustified.
+
+The dependency contract additionally promises that the result equals `value`.
+If that result guarantee is treated as incorporated by the wrapper's
+“Delegates” documentation, its postcondition verdict is also **UNPROVED**: add
+“and returns `value`” to the missing proposition above. There is no independent
+UB-free refutation, so `CONTRACT-BROKEN` is not established. Equality is not
+needed merely for validity of the returned `u8` and therefore cannot repair or
+worsen the soundness proof gap.
+
+## Residual scope and review triggers
+
+Dependency internals, generated artifacts, binaries/backend correctness, and
+configurations outside D are not audited. Re-audit both claims if `lib.rs`,
+Rust/standard-library version, supported targets/profiles, or the authoritative
+Safety text changes. Re-audit the second claim if dependency identity, features,
+contract, implementation evidence, or its human TCB disposition changes.
+
+All in-scope obligations have dispositions: FU-1 is disproved; DN-1 is proved;
+DN-2 is unproved. No tests or tool-derived evidence contribute to a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/E.md
new file mode 100644
index 0000000000..bcdc7d4fa2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/E.md
@@ -0,0 +1,111 @@
+# Focused unsafe-Rust source audit
+
+## Snapshot, scope, and domain
+
+Audited artifact: the submitted `lib.rs` for `quantifier-target` 0.1.0
+(edition 2021), its submitted manifest, dependency contract, evidence packet,
+and trust decision. The manifest selects exactly `peer-unsafe-dep` 3.4.5. No
+dependency implementation, generated output, lockfile, prior audit, binary, or
+tool result was supplied or inspected. Review cutoff: 2026-08-01. This is a
+source-level Rust-abstract-semantics review only.
+
+Let
+
+`C = {Rust 1.80.0} × Tresolve × {ordinary debug, ordinary release}`,
+
+where `Tresolve` is exactly the set of targets on which this submitted source
+and the submitted exact dependency resolution resolve. This preserves the
+request's symbolic target predicate; it is not replaced by an unevidenced
+inventory. There are no `cfg`, feature, target, profile, macro, build-script, or
+generated-source branches in `lib.rs`. The arguments below are parametric in
+every `c ∈ C`: neither source reachability nor the value passed to the peer call
+depends on target or profile. Thus those arguments cover all of `C` without
+sampling.
+
+The complete exported surface is the two free functions below. There are no
+exported fields, types, traits, methods, statics, macros, hidden items, FFI
+entrypoints, callbacks, or generated APIs in the submitted source.
+
+## Claims and verdicts
+
+| Claim | Exact valid uses and theorem | Verdict |
+|---|---|---|
+| `force_unreachable` (`lib.rs:4-7`) | For every `c ∈ C` and every well-typed safe call to this safe, argument-free function (there is no caller safety precondition), the execution is free of Rust UB. | **UNSOUND**, throughout `C`. |
+| `delegated_nonzero` (`lib.rs:14-18`) | For every `c ∈ C` and every unsafe call with `value: u8` satisfying the complete documented safety precondition `value != 0`, the execution is free of Rust UB. There are no stated ongoing or terminal caller obligations. | **UNPROVED**, throughout `C`. |
+
+No broader safe-API robustness property was requested. If the peer contract's
+“Returns `value`” is treated as a mandatory consumed provider postcondition,
+that postcondition is also **UNPROVED**; no UB-free counterexample establishes
+`CONTRACT-BROKEN`.
+
+## Proof certificates and obligation ledger
+
+### `force_unreachable`: complete existential UB certificate
+
+1. **Valid in-scope use.** For arbitrary `c ∈ C`, a safe program may call
+   `force_unreachable()`; the item is `pub fn`, takes no argument, and exposes
+   no unsafe obligation. Such a call is therefore a valid well-typed safe use.
+2. **Reachability.** Entry executes the body, whose only statement is the
+   unconditional call to `std::hint::unreachable_unchecked()` at `lib.rs:6`.
+   There is no branch, return, panic, callback, or dependency operation before
+   it. The unsafe operation is reached.
+3. **False required proposition.** The call requires that its site not be
+   reached. Step 2 proves the opposite. The comment “This site is assumed to be
+   unreachable” supplies no fact and is false for every invocation.
+4. **UB consequence.** The verified Rust 1.80.0 standard-library Safety text
+   states: “Reaching this function is Undefined Behavior.” Therefore the valid
+   call reaches UB. The reasoning is source-, target-, and profile-parametric,
+   so every member of `C` has this witness.
+
+This satisfies every link required for `UNSOUND`; it is not merely a failed
+universal proof. The minimal correction is to remove the unchecked-unreachable
+operation (for example, use a defined panic) or move a sufficient, enforced
+unreachability obligation to an unsafe API. Rewording the current safety
+comment cannot repair the safe implementation.
+
+### `delegated_nonzero`: exact closed and open obligations
+
+- **D1—peer caller precondition: PROVED locally over `C`.** A valid wrapper call
+  has `value != 0` by `lib.rs:11-13`. The exact submitted peer contract requires
+  precisely `value != 0`. `lib.rs:17` passes the same `u8` without mutation or
+  intervening code. Hence the wrapper satisfies the peer call's documented
+  caller-side safety precondition. The adjacent comment adequately records
+  this local implication.
+- **D2—peer provider soundness: UNPROVED over all `C`.** Calling a third-party
+  unsafe API also requires establishing that its exact implementation fulfills
+  its promise for valid calls. The smallest missing proposition is:
+  `for every c ∈ C and every v: u8 with v != 0, peer-unsafe-dep 3.4.5's exact
+  duplicate_nonzero(v) implementation executes without Rust UB`.
+  Neither declaration nor caller contract proves that implementation theorem.
+  The body and prior audit are unavailable, and the submitted human decision
+  expressly declines an `UNSAFE-DEP` assumption. Consequently aggregate
+  `Covered` for this claim contains no configuration under the admitted
+  premises, so `Required = C × {v | v != 0}` is not contained in `Covered`.
+- **D3—return guarantee: UNPROVED if in scope.** The wrapper returns the peer
+  result unchanged, so the peer implementation's promised `result == value`
+  would entail the same result. The missing provider theorem must additionally
+  establish that equality. No UB-free falsifying execution was supplied, so
+  absence of proof is not `CONTRACT-BROKEN` or `UNSOUND`.
+
+Accepting a precisely scoped `UNSAFE-DEP` entry for D2/D3, recursively auditing
+the exact dependency implementation, or replacing the call with a proved
+implementation is necessary to close this claim. The local safety comment
+cannot establish provider correctness.
+
+## TCB and evidence disposition
+
+- **AXIOM-UU-1 — accepted.** Rust 1.80.0 `std::hint::unreachable_unchecked`
+  Safety documentation, independently opened at the exact supplied URL:
+  https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety.
+  Exact consumed proposition: reaching the function is UB. Scope supplied and
+  admitted by `EVIDENCE.md`/`TCB.md`: Rust 1.80.0, all targets and ordinary
+  profiles. Consumer: the `force_unreachable` certificate.
+- **UNSAFE-DEP-PEER-345 — rejected/not admitted.** Proposed proposition would
+  be D2 (and D3 if return behavior is claimed) for exact package 3.4.5 over
+  `C`. `TCB.md` expressly declines it; it supports no affirmative verdict.
+- No implementation, compatibility, tool, environment, deployment, or
+  probabilistic premise is admitted. No test or tool evidence contributes.
+
+Re-audit is required if either function or its documentation changes, the Rust
+version/domain changes, the peer version/contracts/features/implementation or
+trust disposition changes, or generated/configuration-dependent code is added.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/F.md
new file mode 100644
index 0000000000..ffd528c46d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/F.md
@@ -0,0 +1,59 @@
+# Focused unsafe-Rust source review
+
+## Claims and verdicts
+
+Audit cutoff: 2026-08-01. `C` is the exact submitted source packet, compiled with Rust/rustc/stdlib 1.80.0 and edition 2021, for every target on which this source and the exact resolved `peer-unsafe-dep` 3.4.5 package resolve, under every ordinary debug or release profile. There are no crate features, `cfg` branches, generators, build scripts, or generated artifacts in the packet.
+
+| Claim | Exact valid use | Soundness verdict |
+|---|---|---|
+| `force_unreachable` | Every well-typed safe invocation in `C`; there is no caller-side safety precondition. | **UNSOUND** (`F-1`) |
+| `delegated_nonzero` | Every invocation in `C` for which the unsafe caller establishes `value != 0` (equivalently, `value` is in `1..=255`); there are no documented ongoing or terminal obligations. | **UNPROVED** (`F-2`) |
+
+These are separate source-level Rust abstract-semantics claims. The first verdict does not imply the second. No binary-, backend-, deployment-, security-, or probabilistic claim is made.
+
+The dependency contract also documents `duplicate_nonzero(value)`'s postcondition “Returns `value`.” Any corresponding claim that `delegated_nonzero(value)` returns its input is **UNPROVED** for the same missing proposition as `F-2`; no UB-free refutation is established, so `CONTRACT-BROKEN` is not justified. No additional robustness property was requested.
+
+## Snapshot, boundary, and configuration coverage
+
+The audited packet comprises `REQUEST.md`, `Cargo.toml`, `lib.rs`, `DEPENDENCY-API.md`, `TCB.md`, and `EVIDENCE.md`. Key SHA-256 identities are `lib.rs` `778d644359b84bc0e519ed7220bfcadfbba578e2c9fd4c474ce742c4b0021ceb`, `Cargo.toml` `57b66359b9447d371fa68a2cfdc04f49176b1a3ce815bb96027b2f76d917d0a7`, `DEPENDENCY-API.md` `6f29bb01be852cc9cf2861d0447ef0b2001350f090ab947866d1495d68a27fc2`, and TCB revision `TCB.md` `86796b85804436595c0f6ffbfa773dac4fce5cbfe28e02223c802a055037d0f4`. The dependency is exactly pinned by `=3.4.5`; that fixes package/version identity but does not prove its unsafe implementation.
+
+The only exported surfaces in the submitted source are the safe free function `force_unreachable` and unsafe free function `delegated_nonzero`. There are no submitted fields, types, constructors, traits/impls, methods, statics, callbacks, macros, reexports, hidden items, FFI surfaces, or state invariants. The dependency is called but not reexported. Its implementation, generated output, prior audit, and binary are inaccessible and excluded from inspection, not silently assumed correct.
+
+The proofs below are parametric over target and profile. The source selects the same statements in every member of `C`; no debug assertion, overflow-dependent expression, target fact, panic mode, allocator, concurrency, or generated-code premise is used. `AXIOM-UU-1` expressly covers all targets/profiles in `C`. The local nonzero dataflow proof is likewise configuration-independent. The unresolved dependency-implementation obligation remains unresolved throughout `C`. No configuration was sampled or tested.
+
+## TCB audit log
+
+TCB ID is the `TCB.md` digest above. Trust policy admits the verified versioned Rust authority but expressly rejects trust in the unavailable third-party unsafe implementation.
+
+| ID | Category/disposition | Exact proposition, scope, and consumer |
+|---|---|---|
+| `AXIOM-UU-1` | AXIOM / accepted | Rust 1.80.0 `std::hint::unreachable_unchecked`: [“Reaching this function is Undefined Behavior.”](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) Verified at the exact versioned page; it states no narrower target/profile condition. Applies throughout `C`; consumed by `O-F1`. Re-review if Rust scope or cited contract changes. |
+| `UNSAFE-DEP-1` | UNSAFE-DEP / rejected, not consumable | For exact `peer-unsafe-dep` 3.4.5 throughout `C`, every execution of `duplicate_nonzero(v)` with `v != 0` is UB-free and returns `v`. No implementation/audit is supplied, and the human trust decision expressly declines admission. Blocks `O-D2` and the return postcondition. Resolve by recursive source audit or explicit human acceptance of this exact proposition; re-review on dependency identity, contract, feature, target, or profile change. |
+
+There are no SAFE-DEP, tool, implementation, external, environment, or compatibility entries. No tool-derived evidence was supplied or consumed.
+
+## Obligation ledger and proofs
+
+### `O-F1` — `force_unreachable` must be sound for every safe call
+
+At `lib.rs:4`, any caller may enter through a safe, argument-free public function. Control then unconditionally reaches the sole statement, the unsafe call at `lib.rs:6`; there is no branch, check, input, or invariant that can make this site unreachable. By `AXIOM-UU-1`, reaching that call is UB. Thus the well-typed safe invocation `force_unreachable()` is a valid in-scope use whose execution reaches UB, uniformly over `C`. This proves **UNSOUND**.
+
+The line-5 comment, “This site is assumed to be unreachable,” supplies no fact and is circular: the public function entry makes the site reachable. It is therefore a deficient proof artifact as well as an implementation defect.
+
+### `O-D1` — satisfy the dependency's caller precondition
+
+For a valid call of `delegated_nonzero`, its published safety contract at `lib.rs:11-13` gives `value != 0`. Line 17 passes that same, unmodified `u8` to `duplicate_nonzero`. The submitted dependency contract requires exactly `value != 0`. Identity plus the caller fact entails that precondition for every valid wrapper call throughout `C`. **PROVED.** The adjacent comment adequately explains this caller-side step.
+
+### `O-D2` — establish provider implementation soundness
+
+The wrapper's soundness additionally requires every permitted execution of the dependency call, after `O-D1` is satisfied, to be UB-free. A declaration and caller contract constrain valid callers; they do not prove that an unavailable unsafe implementation honors its promise. `UNSAFE-DEP-1` is rejected, and no recursive implementation proof exists. The smallest missing proposition is: “For every `v: u8` with `v != 0` and every configuration in `C`, every execution of exact `peer-unsafe-dep` 3.4.5 `duplicate_nonzero(v)` is free of Rust UB.” Therefore `O-D2`, and hence `delegated_nonzero` soundness, is **UNPROVED**. No valid UB witness is established, so `UNSOUND` is not justified.
+
+The return-equality guarantee separately needs the additional conjunct that every such UB-free execution returns `v`; it is also absent. No proof-comment rewrite alone can close either provider obligation.
+
+## Findings and required resolutions
+
+`F-1` (**UNSOUND**, all of `C`): remove the unconditional unsafe call or replace it with defined behavior such as a safe panic. Merely changing the comment cannot repair the proof. Making a formerly safe API unsafe or changing documented behavior requires compatibility review. Re-audit all uses and all of `force_unreachable` after remediation.
+
+`F-2` (**UNPROVED**, all of `C`): recursively audit the exact dependency implementation over `C`, or obtain authorized acceptance of `UNSAFE-DEP-1` with exact identity and configuration scope. An exact version pin and published unsafe contract are insufficient. Re-audit both soundness and return behavior after resolution.
+
+Residual scope is limited to the unavailable dependency implementation and its omitted artifacts. Review is also triggered by any source/API contract change, Rust version or support-domain change, dependency resolution/contract change, or TCB disposition change. There is no authoritative Rust-documentation gap and no skill-guidance gap identified.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/G.md
new file mode 100644
index 0000000000..e86ca70049
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/G.md
@@ -0,0 +1,134 @@
+# Focused unsafe-Rust source review
+
+## Scope, snapshot, and domain
+
+This review covers exactly the two exported free functions in the supplied
+`lib.rs`, with the supplied `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, and
+`TCB.md`. No repository revision or dependency implementation was supplied. No
+generated target code, tests, tool results, or prior audit are consumed.
+
+For both claims, define:
+
+`Required(C) := C uses Rust and std 1.80.0, edition 2021; resolves
+peer-unsafe-dep exactly 3.4.5; targets any target on which this source and that
+exact dependency resolve; and uses an ordinary debug or ordinary release
+profile.`
+
+This is an exact transcription of `REQUEST.md`; `Cargo.toml` independently
+confirms the exact dependency constraint `=3.4.5`. The target set is kept as
+the request's symbolic predicate rather than replaced by an unevidenced finite
+inventory. There are no target-source `cfg`s, Cargo features, macros,
+generators, build scripts, profile branches, or target branches in the supplied
+artifact. Thus the inspected call paths are identical for every `C` satisfying
+`Required`. There are no exclusions or policy conflicts. The audit cutoff is
+the supplied source/evidence packet; no dynamic support policy is present.
+
+The complete exported surface is:
+
+| API | Boundary | Valid-use domain |
+|---|---|---|
+| `force_unreachable()` | safe free function | every well-typed safe invocation; no caller safety precondition |
+| `delegated_nonzero(value: u8) -> u8` | unsafe free function | every invocation with `value != 0`, i.e. `value` in `1..=255`; no ongoing or terminal obligation is documented |
+
+There are no representation fields, constructors, traits, impls, callbacks,
+hidden items, reexports, or abstraction invariants in the supplied source.
+
+## TCB and authority
+
+**AXIOM-UU-1 (accepted):** Rust 1.80.0's versioned standard-library Safety
+section states: “Reaching this function is *Undefined Behavior*.” The fetched
+page identifies rustdoc 1.80.0, and the proposition has no narrower target or
+profile qualification. [Official Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+It is consumed only by the `force_unreachable` certificate.
+
+**UNSAFE-DEP-1 (not admitted):** No proposition about the implementation of
+`peer-unsafe-dep` 3.4.5 is accepted. `TCB.md` expressly declines that trust.
+The exact pin fixes identity but proves neither implementation soundness nor
+postcondition correctness. There are no other TCB premises.
+
+## Claim F — `force_unreachable`
+
+**Exact theorem.** For every `C` satisfying `Required`, every well-typed safe
+invocation of `force_unreachable()` is free of Rust undefined behavior.
+
+**Verdict: UNSOUND for every `C` satisfying `Required`.** Fix any such `C` and
+use the safe call `force_unreachable()` as the witness:
+
+1. **Valid in-scope use:** the function is public and safe, takes no arguments,
+   and documents no caller safety condition.
+2. **Reachability:** its body has no check, branch, earlier divergence, or
+   intervening call; control unconditionally executes
+   `std::hint::unreachable_unchecked()`.
+3. **False required proposition:** that operation requires its call site not to
+   be reached, but step 2 proves that it is reached.
+4. **UB consequence:** AXIOM-UU-1 directly classifies reaching the function as
+   undefined behavior.
+
+This is a parametric certificate over the entire target/profile predicate, not
+a sampled configuration result. The existing safety comment merely assumes
+the proposition contradicted by local control flow; it is not a proof.
+
+**Finding F-1 (implementation defect; deficient proof artifact).** No revised
+`SAFETY` wording can justify the current body. A minimal sound repair is to use
+the safe `unreachable!()` panic or to redesign the surrounding control flow so
+an independently proved invariant makes the site unreachable. Any changed
+artifact requires a fresh audit. No broader safe-API behavioral postcondition
+was requested; the soundness failure is complete without one.
+
+## Claim D — `delegated_nonzero`
+
+**Exact theorem.** For every `C` satisfying `Required` and every `value` in
+`1..=255`, every permitted execution of `delegated_nonzero(value)` is free of
+Rust undefined behavior.
+
+**Verdict: UNPROVED.** The local caller-side obligation is proved: the wrapper's
+unsafe contract requires `value != 0`; the submitted dependency contract places
+the identical precondition on `duplicate_nonzero`; and the source passes the
+same `value` without modification. This derivation is parametric over all
+`Required` configurations, so the adjacent safety comment adequately explains
+that limited obligation.
+
+The separate provider-side obligation is not proved. The smallest missing
+soundness proposition is:
+
+`DEP-SOUND := for every C satisfying Required and every v in 1..=255, every
+permitted execution of peer_unsafe_dep::duplicate_nonzero(v) in exact package
+3.4.5 is free of Rust undefined behavior.`
+
+The dependency implementation and generated output are absent, and
+UNSAFE-DEP-1 is not admitted. The published caller contract does not establish
+`DEP-SOUND`. Therefore no configuration has a complete affirmative derivation,
+and `Required ⊆ Covered` cannot be certified. Conversely, the packet supplies
+no execution, implementation fact, or other premise proving an existential UB
+witness, so `UNSOUND` is not justified.
+
+**Documented behavior.** The source itself proves that the same nonzero value is
+passed to the peer function and that the peer's return value is returned. The
+submitted peer documentation additionally says it returns `value`. If that
+provider guarantee is included as the wrapper's return-value postcondition,
+its verdict is **UNPROVED**: the smallest missing proposition is that, for every
+`C` and nonzero `v` above, every defined normal return from exact dependency
+3.4.5 equals `v`. No UB-free falsifying execution is supplied, so
+`CONTRACT-BROKEN` is not justified.
+
+**Finding D-1 (missing dependency proof/TCB premise).** Resolve by recursively
+auditing the exact dependency implementation and relevant generated output, or
+by an authorized human accepting precise `UNSAFE-DEP` propositions covering
+`DEP-SOUND` and any consumed return guarantee over all `Required`
+configurations. Strengthening the wrapper's caller contract would not repair
+this provider-side gap.
+
+## Coverage, residual scope, and triggers
+
+For Claim F, the existential UB certificate closes for an arbitrary member of
+`Required`. For Claim D, the local precondition proof covers all `Required`, but
+the necessary provider theorem covers none on the supplied evidence; proof
+regions for distinct obligations cannot be unioned. No testing or tool-derived
+evidence contributes.
+
+Residual scope is precisely the unavailable dependency implementation,
+generated output, and any facts about its executions. Re-audit is required if
+either API or its documentation changes; Rust/std, edition, target, profile, or
+support policy changes; dependency identity, features, contract, source, or
+trust disposition changes; or dependency implementation/generated evidence is
+added.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/H.md
new file mode 100644
index 0000000000..6b32e1d398
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/H.md
@@ -0,0 +1,110 @@
+# Focused source-only unsafe Rust review
+
+## Claim frame and snapshot
+
+Scope is exactly the two exported functions in the supplied `lib.rs`. The
+source snapshot consists of the submitted `lib.rs` and manifest, with edition
+2021 and the exact requirement `peer-unsafe-dep = "=3.4.5"`. The submitted
+dependency record identifies the resolved package as `peer-unsafe-dep` 3.4.5
+and supplies its declaration and public contract, but no implementation,
+generated output, binary, or prior audit.
+
+Let `C` be: Rust compiler and standard library 1.80.0; every target on which
+this exact source and exact dependency resolve; and every ordinary debug or
+release profile. There are no source `cfg`s, features, generated artifacts, or
+profile-dependent branches in the submitted crate. The source arguments below
+are therefore parametric over target and profile. Dependency-side target or
+generated variation is inaccessible and is not assumed away.
+
+The only public surfaces are the safe free function `force_unreachable` and
+the unsafe free function `delegated_nonzero`; there are no public fields,
+constructors, methods, traits, macros, callbacks, or invariant-bearing state.
+No build, test, execution, expansion, or tool-derived evidence was used.
+
+Combined result: **UNSOUND** for `force_unreachable`; **UNPROVED** for
+`delegated_nonzero`. There is no whole-scope `PROVED` result.
+
+## Claim 1: `force_unreachable`
+
+**Exact claim.** For every configuration in `C`, every well-typed safe
+invocation, with no caller-side safety precondition, has no Rust undefined
+behavior.
+
+**Verdict: UNSOUND**, throughout `C`.
+
+**Complete refutation.** `lib.rs:4` exports an ordinary safe function with no
+arguments or checked branch. Every invocation reaches `lib.rs:6`, which
+unconditionally calls `std::hint::unreachable_unchecked`. The independently
+opened Rust 1.80.0 standard-library Safety section states: “Reaching this
+function is Undefined Behavior.”
+([versioned authority](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+Thus a safe program that calls `force_unreachable()` is a valid in-domain use
+whose execution reaches undefined behavior. The same source-level derivation
+applies on every target/profile in `C`; optimization behavior is irrelevant.
+
+The adjacent comment, “This site is assumed to be unreachable,” proves no
+dominating fact and is contradicted by the public safe entry path. This is both
+an implementation defect and a missing/false proof artifact. A minimum repair
+must remove the reachable `unreachable_unchecked` operation (for example, use a
+defined diverging behavior); merely strengthening the comment cannot repair a
+safe API. Because the witness contains UB, it does not establish a separate
+UB-free documented-postcondition refutation.
+
+## Claim 2: `delegated_nonzero`
+
+**Exact valid-use claim.** For every configuration in `C`, every invocation of
+`delegated_nonzero(value)` for which the unsafe caller establishes the complete
+documented obligation `value != 0` is free of Rust undefined behavior. No
+ongoing or terminal caller obligation is documented.
+
+**Verdict: UNPROVED**, throughout `C`; neither `UNSOUND` nor `PROVED` is
+justified by this packet.
+
+**Local derivation and precise gap.** At `lib.rs:14`, valid use gives the local
+fact `value != 0`. At `lib.rs:17`, that identical `u8` value is passed directly
+to `peer_unsafe_dep::duplicate_nonzero`. The submitted dependency contract's
+sole caller-side safety clause is also `value != 0`. Therefore the wrapper's
+call-site precondition is completely discharged for every nonzero `u8`, target,
+and profile in `C`; the local SAFETY comment accurately records this step.
+
+That step is not a proof of the unsafe dependency implementation. Full
+soundness additionally requires the following smallest missing proposition:
+
+> **DEP-IMPL.** For `peer-unsafe-dep` 3.4.5 as exactly resolved, on every target
+> and ordinary debug/release profile in `C`, every execution of
+> `duplicate_nonzero(v)` with `v != 0` is free of Rust undefined behavior.
+
+No supplied source or universal evidence proves DEP-IMPL, and the human trust
+decision expressly declines an `UNSAFE-DEP` assumption for it. The exact pin
+fixes package version but does not establish undocumented implementation
+correctness. The published unsafe caller contract establishes what this crate
+must pass; it does not establish that the unavailable body fulfills its
+promise. No valid UB witness is supplied either, so the fail-closed result is
+`UNPROVED`, not `UNSOUND`.
+
+The wrapper's Safety section states a precondition, not a result
+postcondition. Its summary's “delegates” description is realized syntactically
+by the direct call. The dependency separately promises “Returns `value`.” If
+same-value return behavior is consumed as a wrapper guarantee, it is also
+**UNPROVED**: DEP-IMPL must be strengthened to say that every such call returns
+`v` on normal return. There is no independent UB-free refutation, so
+`CONTRACT-BROKEN` is not established.
+
+## TCB and coverage ledger
+
+| ID | Proposition and scope | Disposition | Consumers |
+|---|---|---|---|
+| AXIOM-UR-1 | The quoted Rust 1.80.0 `unreachable_unchecked` Safety proposition, all targets/profiles in `C` | Accepted after direct citation verification | Claim 1 |
+| DEP-IMPL | Exact dependency proposition stated above | Expressly not accepted; no implementation evidence | Claim 2 |
+
+Obligation coverage: Claim 1's only unsafe-operation precondition fails on its
+public entry path. Claim 2's dependency call precondition is proved, while
+dependency implementation soundness remains open. No other local unsafe sites,
+state transitions, mandatory unsafe-API postconditions, or configuration
+branches appear in the submitted crate.
+
+Residual scope is the unavailable dependency implementation and any of its
+target/generated variants. Re-audit is required if either function or its
+documentation changes, Rust or the supported domain changes, dependency
+identity/contract/features/generated output changes, dependency source or an
+accepted audit becomes available, or the TCB trust decision changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/I.md
new file mode 100644
index 0000000000..6901e1a983
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/I.md
@@ -0,0 +1,104 @@
+# Focused source-only unsafe Rust review
+
+## Claim frame and results
+
+The audited source is `lib.rs` SHA-256
+`778d644359b84bc0e519ed7220bfcadfbba578e2c9fd4c474ce742c4b0021ceb`,
+together with the submitted manifest, dependency declaration, evidence policy,
+request, and TCB decision. The manifest selects edition 2021 and exactly
+`peer-unsafe-dep =3.4.5`. No dependency implementation, generated output,
+prior audit, or binary was supplied.
+
+Let **C** be: Rust compiler and standard library exactly 1.80.0; every target
+on which this source and that exact dependency resolve; and every ordinary
+debug or release profile. These are source-level Rust-abstract-semantics
+claims, not compiler-backend or binary claims.
+
+| Exported API | Exact valid uses | Soundness claim and strongest verdict |
+|---|---|---|
+| `pub fn force_unreachable()` | Every well-typed safe invocation; there is no caller safety precondition. | Every execution of every valid use in C is UB-free: **UNSOUND**, relative to TCB-R1. |
+| `pub unsafe fn delegated_nonzero(value: u8) -> u8` | Every invocation whose caller ensures `value != 0`; the contract states no ongoing or terminal obligation. | Every execution of every valid use in C is UB-free: **UNPROVED**, relative to TCB-R1. |
+
+Thus there is no combined `PROVED` result. The conjunction that both exports
+are sound is refuted by the first API, while the second API retains its own
+`UNPROVED` status.
+
+## API and boundary coverage
+
+The complete exported surface in `lib.rs` is the two public free functions
+above. There are no exported fields, constructors, types, traits, methods,
+statics, macros, reexports, hidden items, FFI declarations, or generated APIs.
+The relevant unsafe consumers are the call to
+`std::hint::unreachable_unchecked` and the call across the unsafe dependency
+boundary. `#![allow(dead_code)]` only changes linting.
+
+## Proof S1 — `force_unreachable`
+
+1. A direct safe call `force_unreachable()` is a well-typed valid use.
+2. On entry, the body has no branch, check, or earlier diverging operation. It
+   immediately evaluates `std::hint::unreachable_unchecked()`; therefore that
+   site is reached.
+3. Verified Rust 1.80.0 standard-library authority states: “Reaching this
+   function is Undefined Behavior.”
+   ([Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+4. Consequently the valid safe invocation is a complete in-scope UB witness.
+
+The derivation is parametric over C: neither the source control flow nor the
+verified proposition has a target or ordinary-profile qualification. The
+existing comment, “This site is assumed to be unreachable,” is circular and
+false whenever the exported function is invoked; it proves no precondition.
+No comment-only repair can make this safe implementation sound. A resolution
+must remove the unchecked operation (for example, use a defined panic) or
+enforce an appropriate boundary; a safe API cannot impose a hidden
+unreachability obligation on callers.
+
+## Proof S2 — `delegated_nonzero`
+
+For an arbitrary valid call, let the input be `v: u8` with `v != 0`. The
+wrapper performs no mutation or conversion and passes that same `v` to
+`peer_unsafe_dep::duplicate_nonzero`. The submitted dependency contract's
+caller-side requirement is exactly `value != 0`. Thus the wrapper's documented
+precondition and unchanged dataflow completely discharge the local unsafe-call
+precondition, throughout C. The adjacent safety comment adequately identifies
+this local derivation.
+
+That does not prove the unsafe callee's provider obligation. The smallest
+missing soundness proposition is:
+
+> For exact `peer-unsafe-dep` 3.4.5, on every configuration in C, for every
+> `v: u8` with `v != 0`, every permitted execution of
+> `duplicate_nonzero(v)` is free from Rust undefined behavior.
+
+Neither declaration nor documentation proves that implementation theorem. The
+implementation is unavailable, and the human trust decision explicitly
+declines an `UNSAFE-DEP` admission. Exact pinning fixes identity but not
+correctness. Therefore the wrapper claim is `UNPROVED`; no valid UB witness was
+supplied, so `UNSOUND` is not justified.
+
+The wrapper itself does not explicitly promise result equality. The submitted
+dependency contract separately says it returns `value`; that provider
+postcondition is not consumed by S2, but its implementation status is also
+`UNPROVED`. Its smallest missing proposition is that every UB-free normal
+return for the same domain yields exactly `v`.
+
+## Configuration closure and TCB-R1
+
+There are no declared Cargo features or source `cfg` branches. Target and
+profile are the only stated axes. S1 is covered parametrically across them; the
+local part of S2 is likewise parametric, but the missing dependency proposition
+blocks all of C. No build, execution, test, expansion, or tool-derived evidence
+was used.
+
+TCB-R1 contains one accepted entry:
+
+- **AXIOM-UU-1:** for Rust/std 1.80.0 throughout C, reaching
+  `unreachable_unchecked` is UB. Identity and wording were independently
+  verified at the exact versioned page above. Consumers: S1. Re-audit on a
+  Rust version/domain or cited-contract change.
+
+There are no accepted implementation, compatibility, tool, or deployment
+entries. The proposed dependency-implementation proposition is deliberately
+unavailable/rejected and supports no proof. Re-audit S2 if dependency source is
+audited or the exact proposition is explicitly accepted; re-audit either claim
+on source, safety-contract, dependency identity, supported-domain, TCB, or Rust
+authority changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/J.md
new file mode 100644
index 0000000000..2394ba2c43
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/reports/J.md
@@ -0,0 +1,123 @@
+# Focused unsafe-Rust source review
+
+## Claim frame, snapshot, and domain
+
+Reviewed on 2026-08-01: the supplied `Cargo.toml`, `lib.rs`,
+`DEPENDENCY-API.md`, `EVIDENCE.md`, and `TCB.md` for `quantifier-target` 0.1.0.
+The dependency implementation, generated output, binary, and prior audit are
+absent. The complete exported surface in `lib.rs` is the safe free function
+`force_unreachable` and unsafe free function `delegated_nonzero`; there are no
+exported fields, types, traits, impls, macros, statics, reexports, or
+configuration-specific items in the submitted source.
+
+Let
+
+`D = {(Rust 1.80.0, t, p) | this exact source and peer-unsafe-dep 3.4.5 resolve
+for target t, and p is an ordinary debug or ordinary release profile}`.
+
+This is the request's controlling expression, retained symbolically: the
+packet does not justify enumerating its target projection. `Cargo.toml` pins
+`peer-unsafe-dep = "=3.4.5"`, and `DEPENDENCY-API.md` confirms that exact
+resolution. The reviewed crate has no `cfg`, features, generated code, build
+script, profile branch, target branch, or input-dependent control-flow branch.
+Thus the local source arguments below are parametric over `t` and `p`.
+Dependency-side variation is not available for inspection and is addressed as
+trust, not silently excluded.
+
+## Evidence and TCB
+
+`AXIOM-UU-1.80` is accepted exactly as authorized by `TCB.md`. The opened Rust
+1.80.0 standard-library Safety section states: “Reaching this function is
+Undefined Behavior.” ([versioned source](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+The page identifies rustdoc 1.80.0 and gives no target- or profile-specific
+qualification. It therefore covers all of `D` under the submitted evidence
+policy.
+
+There is no accepted `UNSAFE-DEP` proposition for `peer-unsafe-dep` 3.4.5;
+`TCB.md` expressly declines that trust. The selected-safe-dependency exception
+does not apply to correctness of a third-party **unsafe** API. No tool,
+implementation, compatibility, or deployment premise is admitted.
+
+## Claim 1 — `force_unreachable`: **UNSOUND**
+
+**Exact claim.** For every configuration in `D`, every well-typed safe call to
+`force_unreachable()` is free of Rust undefined behavior. Because the API is
+safe, valid use has no caller-side safety precondition.
+
+**Existential UB certificate (parametric over `D`).**
+
+1. **Valid use:** in any `d in D`, safe code may call the public safe function
+   `force_unreachable()` with no arguments (`lib.rs:4`).
+2. **Reachability:** after entry, its sole, unconditional expression directly
+   calls `std::hint::unreachable_unchecked()` (`lib.rs:6`). There is no guard,
+   earlier divergence, callback, or alternate path.
+3. **False required proposition:** the call site is therefore reached; the
+   required proposition that it be unreachable is false.
+4. **UB consequence:** `AXIOM-UU-1.80` says reaching that function is undefined
+   behavior.
+
+This supplies a valid in-scope UB execution for every member of `D`, so the
+strongest soundness verdict is `UNSOUND`, not merely `UNPROVED`. The local
+comment “This site is assumed to be unreachable” (`lib.rs:5`) is circular and
+false for the witness; it supplies no derivation. No UB-free whole execution is
+claimed as a postcondition witness.
+
+**Required resolution:** remove the unsafe operation (for example, use a
+defined diverging/panicking path), or expose and document a sufficient unsafe
+caller obligation and re-audit the resulting new API. Changing the comment
+alone cannot repair this safe API.
+
+## Claim 2 — `delegated_nonzero`: **UNPROVED**
+
+**Exact valid-use claim.** For every `d in D` and every `value: u8` with
+`value != 0`, every execution of the unsafe call
+`delegated_nonzero(value)` is free of Rust undefined behavior. The inequality
+is the complete documented caller safety obligation (`lib.rs:11-14`); no
+ongoing or terminal obligation is stated. The supplied peer contract also says
+that, on return, `duplicate_nonzero(value)` returns `value`.
+
+**Proved local portion (all of `D`).** The wrapper passes the unchanged
+`value` directly to `peer_unsafe_dep::duplicate_nonzero` (`lib.rs:17`). For
+every valid wrapper call, `value != 0`; this is exactly the dependency's
+documented caller-side precondition. The adjacent safety comment correctly
+proves this call-site obligation. There are no intervening transitions or
+other local unsafe operations.
+
+**Smallest missing propositions.** For the exact implementation selected as
+`peer-unsafe-dep` 3.4.5, over every target/profile in `D`:
+
+- for every `u8 v != 0`, every permitted execution of
+  `duplicate_nonzero(v)` is free of undefined behavior; and
+- on normal return, its result equals `v` (the submitted dependency
+  postcondition).
+
+The declaration and caller contract do not prove that an unavailable unsafe
+implementation fulfills its promise. `DEPENDENCY-API.md` expressly supplies
+no body-execution assertion, implementation artifact, generated output, or
+prior audit, and the only possible implementation premise is rejected by the
+TCB. Consequently the local precondition coverage is `D`, but aggregate
+soundness/postcondition coverage cannot be established for any part of `D`.
+`Required subset Covered` is therefore not certified.
+
+No existential refutation is available either: the packet contains no fact
+showing what the dependency body executes for any valid value. Thus `UNSOUND`
+would be unjustified, and the strongest verdict is `UNPROVED`. The peer's
+return-equals-input guarantee is likewise `UNPROVED`; it cannot be promoted
+from documentation to an implementation fact for this unsafe dependency.
+
+**Required resolution:** recursively audit the exact resolved 3.4.5
+implementation (including relevant generated/configuration-dependent code) and
+prove both propositions throughout `D`. Alternatively, an authorized reviewer
+could accept a precise `UNSAFE-DEP` entry, but the governing trust decision for
+this review expressly refuses that route.
+
+## Closure and residual scope
+
+For Claim 1, the witness proof is target/profile-parametric and the Rust axiom
+covers `D`; no configuration is omitted. For Claim 2, every wrapper-owned
+obligation is proved parametrically, while the dependency-implementation
+obligation remains missing over the entire symbolic target/profile domain.
+No builds, executions, tests, downloads, macro expansions, or dependency-source
+claims contribute evidence. Re-audit on source/API changes, Rust-version or
+support-domain changes, dependency identity/contract changes, or provision or
+acceptance of dependency implementation evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/PACKET.json
new file mode 100644
index 0000000000..b99c573863
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "3dc7862cdc2fdc1d44fd97235ad043602bd26ab3b428209b94fe9fb0602c14f8",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "Q",
+  "presentation_order": [
+    "C",
+    "B",
+    "D",
+    "A",
+    "G",
+    "J",
+    "I",
+    "F",
+    "H",
+    "E"
+  ],
+  "report_sha256": {
+    "A": "6ff6a7e4a093b5a955df9709844c232c585146e16d159b1c5a51e93e53dee468",
+    "B": "a596f12e22efee1d14c1f64eea7c3a10da7c32d779c496b890874fd4ef2be972",
+    "C": "199d71241d40542bdfcb5dff45e6e3f2384eacfe6f21f69747a7eaab44f200d4",
+    "D": "0ff6cb9b958a530a041aa729635ab67524b6fbcc772a8cf5856d861bbe23fb17",
+    "E": "36c357bebb8df0544f587b00a99169a56e62e1d1386c18984697ae62001ef573",
+    "F": "7545ffde31d113e2377bb3eb1304b7711101e88f6f29b168d2483ae2210177a4",
+    "G": "741de41033e7f4a9d25be1cf0231aee79363e384a8b71070b43a4b7f053baa67",
+    "H": "759b413defb47d8ad4c15c08233757841f374762b686d51515a8eddcd5ac1989",
+    "I": "4a8554d2840bc21e1a1da10ff8c50dc52fb362117b24e0d30e3359864a3db4b9",
+    "J": "a6eb34fd1d3c89310961cd76a7f61566e7226a18edb237f3540b96bf915b40e2"
+  },
+  "rubric_sha256": "154645b5d02c12a09d8162c6daca9d8843e81c9d4caa03165dc4acb5391d2a0a",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "35bb6be0402f9d81918c3afc850dd54cde012865bba90d0cd8d7042d78a582ee"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/RUBRIC.md
new file mode 100644
index 0000000000..fcec5e9489
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/RUBRIC.md
@@ -0,0 +1,76 @@
+# Mode Q Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## Q — Existential refutation and missing unsafe dependency
+
+Target: supplied Q snapshot.
+
+Let `C_Q` be Rust 1.80.0 times every target on which the exact source and pinned
+dependency resolve times every ordinary profile.
+
+- `Required(Q-force-sound) = C_Q` times the one well-typed safe call
+  `force_unreachable()`.
+- `Required(Q-delegate-sound) = C_Q` times every call
+  `delegated_nonzero(value)` whose caller satisfies `value != 0`.
+
+### Expected results and atoms
+
+- **Q1 — Domain and claim separation:** State both valid-use domains and audit
+  the two APIs independently. In particular, the `unsafe fn`'s documented
+  nonzero precondition restricts its valid uses; it does not restrict the safe
+  `force_unreachable` API.
+- **Q2 — Complete UB certificate:** For `force_unreachable`, give all four
+  links explicitly or by an equivalently exact chain:
+  1. `force_unreachable()` is a well-typed, valid safe call in `Required`;
+  2. the only body path reaches the executed
+     `std::hint::unreachable_unchecked()` call;
+  3. that call requires its site not to be reached, and that exact proposition
+     is false for this call; and
+  4. Rust 1.80.0 std documentation says reaching the function is undefined
+     behavior.
+- **Q3 — Existential closure:** Report `Q-force-sound` as **UNSOUND**. The one
+  complete in-scope witness refutes the universal soundness claim; do not
+  weaken it to `UNPROVED` because no proof covering every safe call was built.
+  The witness exists in every `C_Q` configuration, but that stronger fact is
+  not required for the existential verdict.
+- **Q4 — Exact missing premise:** For `delegated_nonzero`, recognize that a
+  valid caller supplies the dependency API's nonzero caller-side precondition,
+  but the selected unsafe dependency's body is absent and no accepted
+  `UNSAFE-DEP` entry establishes that it honors its contract. The exact pin and
+  caller-facing documentation establish the logical package coordinate and the
+  propagated obligation, not authenticated implementation identity or
+  correctness. For the soundness claim actually requested here, the smallest
+  missing proposition is that every valid nonzero call to the selected
+  `peer-unsafe-dep` 3.4.5 implementation is free of UB over this exact domain.
+- **Q5 — No fabricated witness or silent trust:** Report
+  `Q-delegate-sound` as **UNPROVED**, not `PROVED` and not `UNSOUND`. From the
+  submitted packet, claim-level `Covered(Q-delegate-sound)` contains no case:
+  the dependency-soundness obligation is unresolved for all valid inputs.
+  There is also no proved execution of the unavailable body, so no UB witness
+  may be invented. State that recursive source audit or an explicitly accepted
+  exact `UNSAFE-DEP` entry would be required.
+
+### Q hard errors
+
+Any of these is a hard error:
+
+- calling `force_unreachable` sound or only `UNPROVED` after stating all four
+  certificate links;
+- issuing `UNSOUND` for it without a valid call, reachability, the false exact
+  safety proposition, and the authoritative UB consequence;
+- silently trusting the unavailable unsafe dependency, treating the exact pin
+  as implementation proof, or reporting `delegated_nonzero` `PROVED`;
+- fabricating dependency body behavior or a UB execution and reporting
+  `delegated_nonzero` `UNSOUND`; or
+- treating the unsafe dependency's documented caller precondition as though
+  violating its prose were itself an executed UB event.
+
+### Q checked authority
+
+- `https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety`
+  — exact proposition consumed: reaching
+  `unreachable_unchecked` is undefined behavior; applicability Rust 1.80.0,
+  without a target/profile qualification relevant to this fixture.
+
+No Rust authority is asserted for the absent dependency implementation.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/allowlist.txt
new file mode 100644
index 0000000000..d467a88cf6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/allowlist.txt
@@ -0,0 +1 @@
+https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/A.md
new file mode 100644
index 0000000000..d0a4f0c6f1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/A.md
@@ -0,0 +1,60 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+This is a source-level review of the two exported functions in the submitted `lib.rs`, relative to Rust 1.80.0 abstract semantics. The inspected snapshot consists of `lib.rs`, `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, `TCB.md`, and `REQUEST.md`. The manifest selects edition 2021 and pins `peer-unsafe-dep = "=3.4.5"`; the submitted dependency record says that 3.4.5 is the exact resolution. No prior audit, dependency body, generated dependency output, binary, or tool result was supplied or reused.
+
+Define the common compilation predicate
+
+`D(c) := rust(c) = 1.80.0 ∧ edition(c) = 2021 ∧ target(c) is a target on which this source and exact peer-unsafe-dep 3.4.5 resolve ∧ profile(c) ∈ {ordinary debug, ordinary release}`.
+
+This is exactly the support expression in `REQUEST.md`, with the manifest facts conjoined; no target inventory or exclusion replaces it. The target and profile axes remain symbolic. The source has no `cfg`, feature declaration, generator, FFI, assembly, allocator, concurrency, or profile-dependent branch. The proofs below are therefore parametric in every `c` satisfying `D`. Unavailable dependency configuration paths are not excluded; they cause the second claim's gap.
+
+The API inventory is complete for the submitted crate source: one safe public free function, `force_unreachable`, and one unsafe public free function, `delegated_nonzero`; there are no fields, types, traits, impls, macros, callbacks, hidden APIs, reexports, or invariants. The only unsafe operations are their respective calls to `std::hint::unreachable_unchecked` and `peer_unsafe_dep::duplicate_nonzero`.
+
+## TCB and evidence disposition
+
+**AXIOM-UU (accepted):** the supplied Rust 1.80.0 standard-library page was opened and verified. Its Safety section states: “Reaching this function is Undefined Behavior.” The page is versioned 1.80.0 and supplies no narrower target/profile qualification. Per the human trust decision in `TCB.md`, this proposition applies throughout `D`. Source: [`std::hint::unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). Consumers: OBL-FU.
+
+**UNSAFE-DEP-PEER (not accepted):** no proposition about the implementation of exact `peer-unsafe-dep` 3.4.5 may be trusted. The exact pin establishes identity only. `TCB.md` expressly rejects such trust, and `DEPENDENCY-API.md` supplies a declaration and contract but no implementation assertion. Consumers: OBL-DN-SOUND and OBL-DN-RETURN.
+
+TCB identity is the submitted `TCB.md`; there are no other admitted implementation, compatibility, tool, or deployment propositions.
+
+## Claim 1 — `force_unreachable`
+
+**Exact claim.** For every `c` satisfying `D` and every well-typed safe call to `force_unreachable()`, the execution is free of Rust undefined behavior. Safe valid use has no caller-side safety precondition.
+
+**Verdict: UNSOUND throughout `D`.**
+
+**Existential certificate (OBL-FU):**
+
+1. In any `c ∈ D`, a safe caller may invoke the exported safe function `force_unreachable()`; this is a valid in-scope use.
+2. On entry, the body unconditionally evaluates `std::hint::unreachable_unchecked()`. There is no branch, check, input, or invariant that can prevent reaching it.
+3. Thus that valid call reaches the operation. Its required safety proposition—“this function is not reached”—is false.
+4. AXIOM-UU entails that reaching it is undefined behavior.
+
+This certificate is source-parametric over target and profile, so every member of `D` is affected. The local comment, “This site is assumed to be unreachable,” supplies no fact and is contradicted by public entry. This is both an implementation defect and a deficient proof artifact, not merely a documentation gap. No separate return-value postcondition is documented, and the UB-containing witness cannot establish `CONTRACT-BROKEN`.
+
+Minimum resolution: remove the reachable unchecked operation (for example, use a defined panic if non-return is intended) or establish non-reachability through an enforced boundary. A prose-only restriction cannot repair a safe API.
+
+## Claim 2 — `delegated_nonzero`
+
+**Exact valid-use domain.** For every `c` satisfying `D` and every call with `value ∈ {1, …, 255}` that observes the unsafe boundary, every permitted execution must be UB-free. The only documented initial obligation is `value != 0`; there are no documented ongoing or terminal obligations.
+
+**Verdict: UNPROVED.**
+
+**Local derivation (OBL-DN-CALLER, proved over all `D`):** the submitted dependency contract requires `value != 0`. A valid wrapper call supplies exactly that fact. The body forwards the same `u8` local, without transition, to `duplicate_nonzero`; therefore the dependency's caller-side precondition holds at the unsafe call. The adjacent safety comment adequately records this local bridge.
+
+**Smallest missing proposition (OBL-DN-SOUND):**
+
+> For exact `peer-unsafe-dep` 3.4.5, every `c ∈ D`, and every nonzero `v: u8`, every permitted execution of `duplicate_nonzero(v)` is free of Rust undefined behavior.
+
+Neither inspected source nor an accepted `UNSAFE-DEP` entry establishes it. Consequently the local caller obligation has coverage `D`, but provider-correctness coverage is established for no member of `D`; aggregate `Required ⊆ Covered` does not close. Absence of the body supplies no valid execution reaching UB, so the certificate for `UNSOUND` also does not close.
+
+The dependency documentation additionally says “Returns `value`.” If that provider guarantee is included as delegated wrapper behavior, **OBL-DN-RETURN is UNPROVED**: syntactically the wrapper returns the callee's result unchanged, but the missing proposition is that every valid call to the exact 3.4.5 implementation returns its input. No UB-free falsifying execution is supplied, so `CONTRACT-BROKEN` is not established.
+
+Minimum resolution: recursively audit the exact dependency implementation, including every path over `D`, or have an authorized reviewer accept precise `UNSAFE-DEP` propositions for UB freedom and any consumed return guarantee. The version pin or published unsafe contract alone is insufficient.
+
+## Closure, residual scope, and triggers
+
+For Claim 1, the refutation covers `D` parametrically. For Claim 2, only the wrapper-to-callee precondition proof covers `D`; the unavailable dependency implementation is the exact unresolved remainder. No tests or tools contribute evidence. Re-audit is required if either function or its documentation changes, `D` changes, Rust or AXIOM-UU changes, dependency identity/contract/implementation evidence changes, or the TCB disposition changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/B.md
new file mode 100644
index 0000000000..6c068e7472
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/B.md
@@ -0,0 +1,53 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+The audited snapshot is the supplied `Cargo.toml`, `lib.rs`, `DEPENDENCY-API.md`, `TCB.md`, `EVIDENCE.md`, and `REQUEST.md`. Scope is exactly the two exported functions in `lib.rs`; no dependency implementation, generated dependency output, binary, or prior audit was supplied.
+
+Let `C` be: Rust compiler and standard library 1.80.0, edition 2021; exact resolved package `peer-unsafe-dep` 3.4.5; every target on which this source and that exact dependency resolve; and every ordinary debug or release profile. The submitted source has no `cfg`, features, generated source, build script, profile-dependent assertion, arithmetic, allocation, panic-mode-sensitive cleanup, or target-specific operation. Thus the first result is parametric over `C`; for the second, both the proved local argument fact and the dependency gap are parametric over `C`.
+
+The sole admitted authority is `AXIOM-UU-1`: the verified Rust 1.80.0 standard-library page for [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states, “Reaching this function is Undefined Behavior.” The page identifies version 1.80.0 and places no target/profile qualification on that Safety clause. `TCB.md` accepts this proposition throughout `C`. There is no accepted `UNSAFE-DEP`, implementation, tool, compatibility, or deployment premise.
+
+## Claims and verdicts
+
+| API | Exact valid-use theorem over `C` | Soundness verdict |
+|---|---|---|
+| `pub fn force_unreachable()` | Every well-typed safe invocation, with no caller-side safety precondition, must have every permitted execution free of Rust UB. | **UNSOUND** |
+| `pub unsafe fn delegated_nonzero(value: u8) -> u8` | For every invocation whose caller ensures `value != 0`, every permitted execution must be free of Rust UB. No other caller obligation is documented. | **UNPROVED** |
+
+No additional caller-facing return-value postcondition is documented for `delegated_nonzero`; its sentence says that it delegates the value, not that the result equals it. The dependency's distinct provider contract says “Returns `value`.” If equality of the wrapper's result is intended to consume that contract, it is also **UNPROVED** because the provider implementation proposition below is neither proved nor admitted. No UB-free postcondition refutation is established.
+
+## Complete derivation: `force_unreachable`
+
+1. This is a safe free function. Therefore any well-typed safe call is valid; its prose cannot impose a hidden safety precondition.
+2. Its body has no branch or prior diverging operation. Every execution entering the body evaluates `std::hint::unreachable_unchecked()`.
+3. By `AXIOM-UU-1`, reaching that operation is UB throughout `C`.
+4. Consequently, a safe program that invokes `force_unreachable()` once is a valid in-scope execution that reaches UB. This witnesses **UNSOUND** uniformly for every configuration in `C`.
+
+The adjacent comment, “This site is assumed to be unreachable,” asserts the required conclusion but supplies no fact implying it. It is circular as a proof and cannot move the obligation across a safe API boundary. There is no separate mandatory unsafe-API postcondition for this safe function. Minimum repair would be to avoid `unreachable_unchecked` (for example, use a defined panic/divergence), or arrange that a locally proved impossible branch dominates the unsafe call; merely changing the comment is insufficient.
+
+## Derivation and smallest gap: `delegated_nonzero`
+
+1. The wrapper's controlling Safety contract requires exactly `value != 0`. A valid invocation therefore supplies that fact.
+2. The body passes the same `u8` value, unchanged, to `peer_unsafe_dep::duplicate_nonzero`.
+3. The submitted dependency contract requires exactly that its argument not equal zero. Steps 1–2 completely discharge this caller-side precondition for every valid wrapper call throughout `C`.
+4. Soundness of the wrapper also requires the selected unsafe dependency implementation to uphold its side of the contract. An unsafe function's caller documentation does not prove that its body avoids UB. The exact pin fixes identity but does not establish implementation correctness.
+5. The implementation and prior audit are absent, and `TCB.md` expressly declines any `UNSAFE-DEP` admission. Therefore the smallest missing soundness proposition is:
+
+   **DEP-SND-1:** For exact `peer-unsafe-dep` 3.4.5, every configuration in `C`, and every `v: u8` with `v != 0`, every permitted execution of `duplicate_nonzero(v)` is free of Rust UB.
+
+No supplied premise entails `DEP-SND-1`, so the verdict is **UNPROVED**, not **UNSOUND**: no valid UB witness for the unavailable implementation is established. To rely on the dependency's return promise as well, the additional missing proposition is:
+
+   **DEP-RET-1:** Under the same quantification, every normal UB-free return from `duplicate_nonzero(v)` equals `v`.
+
+The local `SAFETY` comment correctly proves the argument precondition but is not a complete end-to-end proof of provider correctness. Resolution requires either a recursive audit of the exact dependency implementation over all of `C`, or explicit human acceptance of precise `UNSAFE-DEP` entries for `DEP-SND-1` and, if consumed, `DEP-RET-1`.
+
+## Coverage, TCB, and residual scope
+
+The complete exported surface is the safe free function and unsafe free function above; there are no types, fields, constructors, methods, traits/impls, macros, callbacks, statics, FFI items, or reexports in the submitted `lib.rs`. There is no persistent invariant: `delegated_nonzero` transfers a per-call nonzero obligation directly to the dependency.
+
+Obligation status is complete: `force_unreachable` reachability is refuted by the unconditional control flow; the wrapper-to-dependency precondition is proved; dependency provider soundness is unproved; and the dependency return promise is unproved if treated as consumed. No tool-derived evidence was submitted or used. Tests or compilation could not establish the missing universal implementation theorem in any event.
+
+Residual scope consists of the dependency implementation, its generated artifacts, transitive unsafe behavior, prior audits, and binaries. They are not silently excluded from the wrapper theorem: their absence is exactly why it remains unproved. Re-audit is required if either function or contract changes, the supported set changes, the Rust authority changes, dependency identity/implementation/evidence changes, or a `DEP-SND-1`/`DEP-RET-1` trust decision is proposed.
+
+Combined result for the two requested claims: **UNSOUND** for `force_unreachable`; **UNPROVED** for `delegated_nonzero`, relative to the accepted `AXIOM-UU-1` and the explicit rejection of unsafe-dependency trust.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/C.md
new file mode 100644
index 0000000000..2a15e68799
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/C.md
@@ -0,0 +1,65 @@
+# Focused unsafe Rust source audit
+
+## Claim, snapshot, and domain
+
+The audited snapshot is the submitted `quantifier-target` 0.1.0 package: `lib.rs`, `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, and `TCB.md`. The two exported surfaces are the safe function `force_unreachable()` and the unsafe function `delegated_nonzero(u8) -> u8`. No fields, traits, macros, generated artifacts, `cfg`s, features, build scripts, FFI, concurrency, or other public surfaces are supplied. No build or dynamic evidence is used.
+
+Let
+
+`D = { (Rust 1.80.0, target t, profile p) | this exact source and peer-unsafe-dep 3.4.5 resolve on t, and p is an ordinary debug or ordinary release profile }`.
+
+This is exactly the support expression in `REQUEST.md`; it is retained symbolically rather than replaced by a sampled target inventory. `Cargo.toml` fixes edition 2021 and declares `peer-unsafe-dep = "=3.4.5"`; `DEPENDENCY-API.md` confirms that exact resolution. There are no other submitted configuration axes. Thus `Required = D`. The arguments below are parametric in `t` and `p`, so no target enumeration or profile sampling is used.
+
+The TCB for this report is the submitted `TCB.md` (“TCB-SUBMITTED”). Its sole accepted entry is:
+
+- **AXIOM-UU-1 (Rust authority):** for Rust 1.80.0 throughout `D`, reaching `std::hint::unreachable_unchecked` is undefined behavior. The exact official page was opened and independently verified; its Safety section says, “Reaching this function is *Undefined Behavior*.” ([Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety))
+
+The dependency declaration and submitted documentation establish identity and contract text, not implementation correctness. The human reviewer expressly declined an `UNSAFE-DEP` admission for `peer-unsafe-dep` 3.4.5. There are no compatibility, implementation, tool, or deployment assumptions.
+
+## CLAIM-FORCE — `force_unreachable`
+
+**Exact theorem.** For every configuration in `D` and every well-typed safe invocation of `force_unreachable()`, every permitted execution is free of Rust undefined behavior. Valid use has no input, state, temporal, or caller-side safety precondition because this is a safe API.
+
+**Verdict: UNSOUND throughout `D`, relative to TCB-SUBMITTED.**
+
+Complete existential certificate:
+
+1. **Valid in-scope use:** ordinary safe Rust invokes the exported safe function `force_unreachable()` in any configuration in `D`. The API imposes no precondition, so this invocation is valid.
+2. **Reachability:** the function body has no condition or earlier exit; its sole expression evaluates `unsafe { std::hint::unreachable_unchecked() }`. Therefore that invocation reaches the unsafe operation.
+3. **False safety proposition:** the operation requires that it not be reached. Step 2 proves the negation for the witness.
+4. **UB consequence:** AXIOM-UU-1 directly entails undefined behavior upon reaching it.
+
+The same source-local argument and target/profile-wide axiom cover every member of `D`; optimization level is irrelevant to the source-level UB event. The comment “This site is assumed to be unreachable” supplies no fact and is contradicted by every call. This is both an implementation defect and a deficient proof comment, not merely missing documentation. Because the witness execution contains UB, it establishes no separate UB-free postcondition refutation.
+
+Minimal repair: remove this safe path to `unreachable_unchecked`; for an intentionally callable safe API, use defined behavior such as a panic. Any changed artifact requires a fresh audit.
+
+## CLAIM-DELEGATED — `delegated_nonzero`
+
+**Exact theorem.** For every configuration in `D`, every `value: u8` with `value != 0`, and every unsafe invocation satisfying that sole documented precondition, every permitted execution of `delegated_nonzero(value)` is free of Rust undefined behavior. There are no documented ongoing or terminal caller obligations.
+
+**Verdict: UNPROVED throughout `D`, relative to TCB-SUBMITTED.**
+
+The complete available derivation is:
+
+1. The wrapper contract requires `value != 0`.
+2. The submitted contract of exact dependency API `peer_unsafe_dep::duplicate_nonzero` 3.4.5 has the identical caller-side safety precondition.
+3. At the only unsafe call, the argument is the unchanged `value`. Therefore every valid wrapper invocation satisfies the dependency call’s caller-side obligation. The adjacent SAFETY comment adequately records this local implication.
+4. The wrapper immediately returns the dependency call’s result and contains no other operation that can close the provider-side obligation.
+
+The smallest missing soundness proposition is:
+
+> **DEP-SOUND-1:** For every configuration in `D` and every nonzero `v: u8`, every execution of the exact `peer-unsafe-dep` 3.4.5 implementation of `duplicate_nonzero(v)` is free of Rust undefined behavior.
+
+Neither an exact pin nor the submitted unsafe API declaration proves DEP-SOUND-1. The implementation, generated output, prior audit, and binary are absent, and TCB-SUBMITTED expressly refuses to trust them. Consequently the caller-side obligation has coverage `D`, but the required provider-side obligation has no established covered region; their pointwise conjunction does not establish `Required ⊆ Covered`.
+
+No `UNSOUND` certificate exists: the unavailable body supplies no proved valid execution reaching a false safety proposition. Failure of the universal proof therefore yields `UNPROVED`, not `UNSOUND`.
+
+The dependency documentation also promises “Returns `value`.” If that provider guarantee is treated as a mandatory postcondition of this delegation, the wrapper’s `result == value` postcondition is likewise **UNPROVED**: the additional smallest missing proposition is that every valid, UB-free call to this exact implementation returns its input. There is no UB-free counterexample, so `CONTRACT-BROKEN` is not established.
+
+Minimal resolution: supply and recursively audit the exact dependency implementation and all generated/configuration-specific artifacts, or obtain explicit human acceptance of narrowly stated `UNSAFE-DEP` propositions covering DEP-SOUND-1 (and the return guarantee if consumed) over all of `D`.
+
+## Closure, residual scope, and triggers
+
+For CLAIM-FORCE, the certificate is target- and profile-parametric over `D`. For CLAIM-DELEGATED, the unresolved dependency proposition affects all of `D`; no tested subset can repair it. There is no tool-derived evidence. Binary/backend correctness and targets where the exact package does not resolve are outside this source-level theorem.
+
+Re-audit is required if either exported contract or body changes; Rust/standard-library version or cited semantics changes; the supported target/profile predicate changes; dependency identity, features, documentation, implementation, generated output, or trust disposition changes; or new public/generated surfaces appear.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/D.md
new file mode 100644
index 0000000000..97b39d6272
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/D.md
@@ -0,0 +1,102 @@
+# Focused unsafe-Rust source review
+
+## Claim frame and snapshot
+
+This review covers exactly the submitted `lib.rs` exports in package
+`quantifier-target` 0.1.0 (edition 2021), with the manifest's exact dependency
+`peer-unsafe-dep = 3.4.5`, the submitted dependency declaration/contract, and
+the submitted evidence and trust decision. No dependency implementation,
+generated output, binary, source revision/digest, or prior audit was supplied.
+No build, execution, expansion, or implementation inference is used.
+
+Let **D** be Rust and standard library 1.80.0, every target on which this exact
+source and dependency resolve, and every ordinary debug or release profile.
+Both claims are source-level Rust-abstract-semantics claims over D. There are no
+source `cfg`s, features, profile-dependent checks, generators, FFI, allocation,
+concurrency, or other configuration branches in the submitted crate. Thus the
+source reasoning below is parametric over target and profile; the unavailable
+dependency implementation is a proof premise gap, not a silently excluded
+configuration.
+
+The complete exported surface is the two public free functions. There are no
+exported fields, types, traits, macros, statics, hidden items, or generated APIs
+in the supplied source, and no invariant-bearing state.
+
+## Evidence and TCB (`TCB.md`, submitted revision)
+
+| ID | Disposition | Exact proposition and scope | Consumer |
+|---|---|---|---|
+| AXIOM-UU | accepted and independently verified | Rust 1.80.0 documents: “Reaching this function is Undefined Behavior.” The page gives no target/profile qualification, so the supplied policy applies it throughout D. [Versioned Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). | FU-1 |
+| DEP-CONTRACT | controlling submitted contract, not implementation trust | `peer-unsafe-dep` 3.4.5 declares unsafe `duplicate_nonzero(value: u8) -> u8`; callers must supply `value != 0`, and its documented result is `value`. | DN-1, DN-2 |
+| UNSAFE-DEP-PEER | expressly not proposed or accepted | For every configuration in D and every nonzero `u8`, the exact 3.4.5 implementation executes without Rust UB and returns the input value. | Would be required by DN-2 |
+
+No implementation, compatibility, tool, or deployment premise is admitted.
+An exact version pin fixes identity but does not prove an unsafe provider's
+implementation conforms to its contract.
+
+## Claim 1: `force_unreachable`
+
+**Valid-use domain.** Every well-typed safe call in every configuration in D;
+the safe signature permits no caller-side safety precondition.
+
+**Claim.** Every such call and permitted execution is free of Rust UB.
+
+**Verdict: UNSOUND throughout D.** The body has no condition or alternative
+path: every invocation reaches `std::hint::unreachable_unchecked()`. FU-1's
+only obligation is that this call site not be reached. A well-typed safe caller
+can invoke the function, and the body necessarily reaches it. AXIOM-UU then
+entails UB. This is a valid in-scope UB witness for every member of D and
+refutes the universal soundness claim.
+
+The adjacent comment merely assumes the proposition contradicted by control
+flow; it supplies no fact or boundary. This is both an implementation defect
+and a deficient proof artifact. The minimal resolution is to remove the
+unchecked operation (for example, use defined panic/nonreturning behavior) or
+remove the callable safe surface; prose cannot impose a hidden safety
+precondition. The summary sentence supplies no ordinary-return postcondition,
+and the UB-containing witness is not a `CONTRACT-BROKEN` witness.
+
+## Claim 2: `delegated_nonzero`
+
+**Valid-use domain.** Every call in D whose caller satisfies the complete
+published safety condition `value != 0`; `u8` is passed by value, so the
+submitted contract creates no ongoing or terminal caller obligation.
+
+**Claim.** Every such call and permitted execution is free of Rust UB.
+
+**Verdict: UNPROVED throughout D.** DN-1, the local call obligation, is proved:
+the wrapper passes the unchanged `value`, and its caller contract is literally
+the dependency call's submitted precondition. The local `SAFETY` comment
+adequately records this implication.
+
+DN-2, provider conformance, is not proved. The smallest missing soundness
+proposition is:
+
+> For every configuration in D and every `value: u8` with `value != 0`, the
+> exact `peer-unsafe-dep` 3.4.5 implementation of `duplicate_nonzero(value)`
+> executes without Rust undefined behavior.
+
+No supplied source or accepted TCB entry establishes that proposition, and the
+human trust decision expressly rejects assuming it. Therefore satisfying the
+callee's caller precondition proves permission to call, not correctness of the
+unavailable unsafe implementation. No UB witness is established, so
+`UNSOUND` would be unjustified.
+
+The dependency contract additionally promises that the result equals `value`.
+If that result guarantee is treated as incorporated by the wrapper's
+“Delegates” documentation, its postcondition verdict is also **UNPROVED**: add
+“and returns `value`” to the missing proposition above. There is no independent
+UB-free refutation, so `CONTRACT-BROKEN` is not established. Equality is not
+needed merely for validity of the returned `u8` and therefore cannot repair or
+worsen the soundness proof gap.
+
+## Residual scope and review triggers
+
+Dependency internals, generated artifacts, binaries/backend correctness, and
+configurations outside D are not audited. Re-audit both claims if `lib.rs`,
+Rust/standard-library version, supported targets/profiles, or the authoritative
+Safety text changes. Re-audit the second claim if dependency identity, features,
+contract, implementation evidence, or its human TCB disposition changes.
+
+All in-scope obligations have dispositions: FU-1 is disproved; DN-1 is proved;
+DN-2 is unproved. No tests or tool-derived evidence contribute to a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/E.md
new file mode 100644
index 0000000000..bcdc7d4fa2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/E.md
@@ -0,0 +1,111 @@
+# Focused unsafe-Rust source audit
+
+## Snapshot, scope, and domain
+
+Audited artifact: the submitted `lib.rs` for `quantifier-target` 0.1.0
+(edition 2021), its submitted manifest, dependency contract, evidence packet,
+and trust decision. The manifest selects exactly `peer-unsafe-dep` 3.4.5. No
+dependency implementation, generated output, lockfile, prior audit, binary, or
+tool result was supplied or inspected. Review cutoff: 2026-08-01. This is a
+source-level Rust-abstract-semantics review only.
+
+Let
+
+`C = {Rust 1.80.0} × Tresolve × {ordinary debug, ordinary release}`,
+
+where `Tresolve` is exactly the set of targets on which this submitted source
+and the submitted exact dependency resolution resolve. This preserves the
+request's symbolic target predicate; it is not replaced by an unevidenced
+inventory. There are no `cfg`, feature, target, profile, macro, build-script, or
+generated-source branches in `lib.rs`. The arguments below are parametric in
+every `c ∈ C`: neither source reachability nor the value passed to the peer call
+depends on target or profile. Thus those arguments cover all of `C` without
+sampling.
+
+The complete exported surface is the two free functions below. There are no
+exported fields, types, traits, methods, statics, macros, hidden items, FFI
+entrypoints, callbacks, or generated APIs in the submitted source.
+
+## Claims and verdicts
+
+| Claim | Exact valid uses and theorem | Verdict |
+|---|---|---|
+| `force_unreachable` (`lib.rs:4-7`) | For every `c ∈ C` and every well-typed safe call to this safe, argument-free function (there is no caller safety precondition), the execution is free of Rust UB. | **UNSOUND**, throughout `C`. |
+| `delegated_nonzero` (`lib.rs:14-18`) | For every `c ∈ C` and every unsafe call with `value: u8` satisfying the complete documented safety precondition `value != 0`, the execution is free of Rust UB. There are no stated ongoing or terminal caller obligations. | **UNPROVED**, throughout `C`. |
+
+No broader safe-API robustness property was requested. If the peer contract's
+“Returns `value`” is treated as a mandatory consumed provider postcondition,
+that postcondition is also **UNPROVED**; no UB-free counterexample establishes
+`CONTRACT-BROKEN`.
+
+## Proof certificates and obligation ledger
+
+### `force_unreachable`: complete existential UB certificate
+
+1. **Valid in-scope use.** For arbitrary `c ∈ C`, a safe program may call
+   `force_unreachable()`; the item is `pub fn`, takes no argument, and exposes
+   no unsafe obligation. Such a call is therefore a valid well-typed safe use.
+2. **Reachability.** Entry executes the body, whose only statement is the
+   unconditional call to `std::hint::unreachable_unchecked()` at `lib.rs:6`.
+   There is no branch, return, panic, callback, or dependency operation before
+   it. The unsafe operation is reached.
+3. **False required proposition.** The call requires that its site not be
+   reached. Step 2 proves the opposite. The comment “This site is assumed to be
+   unreachable” supplies no fact and is false for every invocation.
+4. **UB consequence.** The verified Rust 1.80.0 standard-library Safety text
+   states: “Reaching this function is Undefined Behavior.” Therefore the valid
+   call reaches UB. The reasoning is source-, target-, and profile-parametric,
+   so every member of `C` has this witness.
+
+This satisfies every link required for `UNSOUND`; it is not merely a failed
+universal proof. The minimal correction is to remove the unchecked-unreachable
+operation (for example, use a defined panic) or move a sufficient, enforced
+unreachability obligation to an unsafe API. Rewording the current safety
+comment cannot repair the safe implementation.
+
+### `delegated_nonzero`: exact closed and open obligations
+
+- **D1—peer caller precondition: PROVED locally over `C`.** A valid wrapper call
+  has `value != 0` by `lib.rs:11-13`. The exact submitted peer contract requires
+  precisely `value != 0`. `lib.rs:17` passes the same `u8` without mutation or
+  intervening code. Hence the wrapper satisfies the peer call's documented
+  caller-side safety precondition. The adjacent comment adequately records
+  this local implication.
+- **D2—peer provider soundness: UNPROVED over all `C`.** Calling a third-party
+  unsafe API also requires establishing that its exact implementation fulfills
+  its promise for valid calls. The smallest missing proposition is:
+  `for every c ∈ C and every v: u8 with v != 0, peer-unsafe-dep 3.4.5's exact
+  duplicate_nonzero(v) implementation executes without Rust UB`.
+  Neither declaration nor caller contract proves that implementation theorem.
+  The body and prior audit are unavailable, and the submitted human decision
+  expressly declines an `UNSAFE-DEP` assumption. Consequently aggregate
+  `Covered` for this claim contains no configuration under the admitted
+  premises, so `Required = C × {v | v != 0}` is not contained in `Covered`.
+- **D3—return guarantee: UNPROVED if in scope.** The wrapper returns the peer
+  result unchanged, so the peer implementation's promised `result == value`
+  would entail the same result. The missing provider theorem must additionally
+  establish that equality. No UB-free falsifying execution was supplied, so
+  absence of proof is not `CONTRACT-BROKEN` or `UNSOUND`.
+
+Accepting a precisely scoped `UNSAFE-DEP` entry for D2/D3, recursively auditing
+the exact dependency implementation, or replacing the call with a proved
+implementation is necessary to close this claim. The local safety comment
+cannot establish provider correctness.
+
+## TCB and evidence disposition
+
+- **AXIOM-UU-1 — accepted.** Rust 1.80.0 `std::hint::unreachable_unchecked`
+  Safety documentation, independently opened at the exact supplied URL:
+  https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety.
+  Exact consumed proposition: reaching the function is UB. Scope supplied and
+  admitted by `EVIDENCE.md`/`TCB.md`: Rust 1.80.0, all targets and ordinary
+  profiles. Consumer: the `force_unreachable` certificate.
+- **UNSAFE-DEP-PEER-345 — rejected/not admitted.** Proposed proposition would
+  be D2 (and D3 if return behavior is claimed) for exact package 3.4.5 over
+  `C`. `TCB.md` expressly declines it; it supports no affirmative verdict.
+- No implementation, compatibility, tool, environment, deployment, or
+  probabilistic premise is admitted. No test or tool evidence contributes.
+
+Re-audit is required if either function or its documentation changes, the Rust
+version/domain changes, the peer version/contracts/features/implementation or
+trust disposition changes, or generated/configuration-dependent code is added.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/F.md
new file mode 100644
index 0000000000..ffd528c46d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/F.md
@@ -0,0 +1,59 @@
+# Focused unsafe-Rust source review
+
+## Claims and verdicts
+
+Audit cutoff: 2026-08-01. `C` is the exact submitted source packet, compiled with Rust/rustc/stdlib 1.80.0 and edition 2021, for every target on which this source and the exact resolved `peer-unsafe-dep` 3.4.5 package resolve, under every ordinary debug or release profile. There are no crate features, `cfg` branches, generators, build scripts, or generated artifacts in the packet.
+
+| Claim | Exact valid use | Soundness verdict |
+|---|---|---|
+| `force_unreachable` | Every well-typed safe invocation in `C`; there is no caller-side safety precondition. | **UNSOUND** (`F-1`) |
+| `delegated_nonzero` | Every invocation in `C` for which the unsafe caller establishes `value != 0` (equivalently, `value` is in `1..=255`); there are no documented ongoing or terminal obligations. | **UNPROVED** (`F-2`) |
+
+These are separate source-level Rust abstract-semantics claims. The first verdict does not imply the second. No binary-, backend-, deployment-, security-, or probabilistic claim is made.
+
+The dependency contract also documents `duplicate_nonzero(value)`'s postcondition “Returns `value`.” Any corresponding claim that `delegated_nonzero(value)` returns its input is **UNPROVED** for the same missing proposition as `F-2`; no UB-free refutation is established, so `CONTRACT-BROKEN` is not justified. No additional robustness property was requested.
+
+## Snapshot, boundary, and configuration coverage
+
+The audited packet comprises `REQUEST.md`, `Cargo.toml`, `lib.rs`, `DEPENDENCY-API.md`, `TCB.md`, and `EVIDENCE.md`. Key SHA-256 identities are `lib.rs` `778d644359b84bc0e519ed7220bfcadfbba578e2c9fd4c474ce742c4b0021ceb`, `Cargo.toml` `57b66359b9447d371fa68a2cfdc04f49176b1a3ce815bb96027b2f76d917d0a7`, `DEPENDENCY-API.md` `6f29bb01be852cc9cf2861d0447ef0b2001350f090ab947866d1495d68a27fc2`, and TCB revision `TCB.md` `86796b85804436595c0f6ffbfa773dac4fce5cbfe28e02223c802a055037d0f4`. The dependency is exactly pinned by `=3.4.5`; that fixes package/version identity but does not prove its unsafe implementation.
+
+The only exported surfaces in the submitted source are the safe free function `force_unreachable` and unsafe free function `delegated_nonzero`. There are no submitted fields, types, constructors, traits/impls, methods, statics, callbacks, macros, reexports, hidden items, FFI surfaces, or state invariants. The dependency is called but not reexported. Its implementation, generated output, prior audit, and binary are inaccessible and excluded from inspection, not silently assumed correct.
+
+The proofs below are parametric over target and profile. The source selects the same statements in every member of `C`; no debug assertion, overflow-dependent expression, target fact, panic mode, allocator, concurrency, or generated-code premise is used. `AXIOM-UU-1` expressly covers all targets/profiles in `C`. The local nonzero dataflow proof is likewise configuration-independent. The unresolved dependency-implementation obligation remains unresolved throughout `C`. No configuration was sampled or tested.
+
+## TCB audit log
+
+TCB ID is the `TCB.md` digest above. Trust policy admits the verified versioned Rust authority but expressly rejects trust in the unavailable third-party unsafe implementation.
+
+| ID | Category/disposition | Exact proposition, scope, and consumer |
+|---|---|---|
+| `AXIOM-UU-1` | AXIOM / accepted | Rust 1.80.0 `std::hint::unreachable_unchecked`: [“Reaching this function is Undefined Behavior.”](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) Verified at the exact versioned page; it states no narrower target/profile condition. Applies throughout `C`; consumed by `O-F1`. Re-review if Rust scope or cited contract changes. |
+| `UNSAFE-DEP-1` | UNSAFE-DEP / rejected, not consumable | For exact `peer-unsafe-dep` 3.4.5 throughout `C`, every execution of `duplicate_nonzero(v)` with `v != 0` is UB-free and returns `v`. No implementation/audit is supplied, and the human trust decision expressly declines admission. Blocks `O-D2` and the return postcondition. Resolve by recursive source audit or explicit human acceptance of this exact proposition; re-review on dependency identity, contract, feature, target, or profile change. |
+
+There are no SAFE-DEP, tool, implementation, external, environment, or compatibility entries. No tool-derived evidence was supplied or consumed.
+
+## Obligation ledger and proofs
+
+### `O-F1` — `force_unreachable` must be sound for every safe call
+
+At `lib.rs:4`, any caller may enter through a safe, argument-free public function. Control then unconditionally reaches the sole statement, the unsafe call at `lib.rs:6`; there is no branch, check, input, or invariant that can make this site unreachable. By `AXIOM-UU-1`, reaching that call is UB. Thus the well-typed safe invocation `force_unreachable()` is a valid in-scope use whose execution reaches UB, uniformly over `C`. This proves **UNSOUND**.
+
+The line-5 comment, “This site is assumed to be unreachable,” supplies no fact and is circular: the public function entry makes the site reachable. It is therefore a deficient proof artifact as well as an implementation defect.
+
+### `O-D1` — satisfy the dependency's caller precondition
+
+For a valid call of `delegated_nonzero`, its published safety contract at `lib.rs:11-13` gives `value != 0`. Line 17 passes that same, unmodified `u8` to `duplicate_nonzero`. The submitted dependency contract requires exactly `value != 0`. Identity plus the caller fact entails that precondition for every valid wrapper call throughout `C`. **PROVED.** The adjacent comment adequately explains this caller-side step.
+
+### `O-D2` — establish provider implementation soundness
+
+The wrapper's soundness additionally requires every permitted execution of the dependency call, after `O-D1` is satisfied, to be UB-free. A declaration and caller contract constrain valid callers; they do not prove that an unavailable unsafe implementation honors its promise. `UNSAFE-DEP-1` is rejected, and no recursive implementation proof exists. The smallest missing proposition is: “For every `v: u8` with `v != 0` and every configuration in `C`, every execution of exact `peer-unsafe-dep` 3.4.5 `duplicate_nonzero(v)` is free of Rust UB.” Therefore `O-D2`, and hence `delegated_nonzero` soundness, is **UNPROVED**. No valid UB witness is established, so `UNSOUND` is not justified.
+
+The return-equality guarantee separately needs the additional conjunct that every such UB-free execution returns `v`; it is also absent. No proof-comment rewrite alone can close either provider obligation.
+
+## Findings and required resolutions
+
+`F-1` (**UNSOUND**, all of `C`): remove the unconditional unsafe call or replace it with defined behavior such as a safe panic. Merely changing the comment cannot repair the proof. Making a formerly safe API unsafe or changing documented behavior requires compatibility review. Re-audit all uses and all of `force_unreachable` after remediation.
+
+`F-2` (**UNPROVED**, all of `C`): recursively audit the exact dependency implementation over `C`, or obtain authorized acceptance of `UNSAFE-DEP-1` with exact identity and configuration scope. An exact version pin and published unsafe contract are insufficient. Re-audit both soundness and return behavior after resolution.
+
+Residual scope is limited to the unavailable dependency implementation and its omitted artifacts. Review is also triggered by any source/API contract change, Rust version or support-domain change, dependency resolution/contract change, or TCB disposition change. There is no authoritative Rust-documentation gap and no skill-guidance gap identified.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/G.md
new file mode 100644
index 0000000000..e86ca70049
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/G.md
@@ -0,0 +1,134 @@
+# Focused unsafe-Rust source review
+
+## Scope, snapshot, and domain
+
+This review covers exactly the two exported free functions in the supplied
+`lib.rs`, with the supplied `Cargo.toml`, `DEPENDENCY-API.md`, `EVIDENCE.md`, and
+`TCB.md`. No repository revision or dependency implementation was supplied. No
+generated target code, tests, tool results, or prior audit are consumed.
+
+For both claims, define:
+
+`Required(C) := C uses Rust and std 1.80.0, edition 2021; resolves
+peer-unsafe-dep exactly 3.4.5; targets any target on which this source and that
+exact dependency resolve; and uses an ordinary debug or ordinary release
+profile.`
+
+This is an exact transcription of `REQUEST.md`; `Cargo.toml` independently
+confirms the exact dependency constraint `=3.4.5`. The target set is kept as
+the request's symbolic predicate rather than replaced by an unevidenced finite
+inventory. There are no target-source `cfg`s, Cargo features, macros,
+generators, build scripts, profile branches, or target branches in the supplied
+artifact. Thus the inspected call paths are identical for every `C` satisfying
+`Required`. There are no exclusions or policy conflicts. The audit cutoff is
+the supplied source/evidence packet; no dynamic support policy is present.
+
+The complete exported surface is:
+
+| API | Boundary | Valid-use domain |
+|---|---|---|
+| `force_unreachable()` | safe free function | every well-typed safe invocation; no caller safety precondition |
+| `delegated_nonzero(value: u8) -> u8` | unsafe free function | every invocation with `value != 0`, i.e. `value` in `1..=255`; no ongoing or terminal obligation is documented |
+
+There are no representation fields, constructors, traits, impls, callbacks,
+hidden items, reexports, or abstraction invariants in the supplied source.
+
+## TCB and authority
+
+**AXIOM-UU-1 (accepted):** Rust 1.80.0's versioned standard-library Safety
+section states: “Reaching this function is *Undefined Behavior*.” The fetched
+page identifies rustdoc 1.80.0, and the proposition has no narrower target or
+profile qualification. [Official Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+It is consumed only by the `force_unreachable` certificate.
+
+**UNSAFE-DEP-1 (not admitted):** No proposition about the implementation of
+`peer-unsafe-dep` 3.4.5 is accepted. `TCB.md` expressly declines that trust.
+The exact pin fixes identity but proves neither implementation soundness nor
+postcondition correctness. There are no other TCB premises.
+
+## Claim F — `force_unreachable`
+
+**Exact theorem.** For every `C` satisfying `Required`, every well-typed safe
+invocation of `force_unreachable()` is free of Rust undefined behavior.
+
+**Verdict: UNSOUND for every `C` satisfying `Required`.** Fix any such `C` and
+use the safe call `force_unreachable()` as the witness:
+
+1. **Valid in-scope use:** the function is public and safe, takes no arguments,
+   and documents no caller safety condition.
+2. **Reachability:** its body has no check, branch, earlier divergence, or
+   intervening call; control unconditionally executes
+   `std::hint::unreachable_unchecked()`.
+3. **False required proposition:** that operation requires its call site not to
+   be reached, but step 2 proves that it is reached.
+4. **UB consequence:** AXIOM-UU-1 directly classifies reaching the function as
+   undefined behavior.
+
+This is a parametric certificate over the entire target/profile predicate, not
+a sampled configuration result. The existing safety comment merely assumes
+the proposition contradicted by local control flow; it is not a proof.
+
+**Finding F-1 (implementation defect; deficient proof artifact).** No revised
+`SAFETY` wording can justify the current body. A minimal sound repair is to use
+the safe `unreachable!()` panic or to redesign the surrounding control flow so
+an independently proved invariant makes the site unreachable. Any changed
+artifact requires a fresh audit. No broader safe-API behavioral postcondition
+was requested; the soundness failure is complete without one.
+
+## Claim D — `delegated_nonzero`
+
+**Exact theorem.** For every `C` satisfying `Required` and every `value` in
+`1..=255`, every permitted execution of `delegated_nonzero(value)` is free of
+Rust undefined behavior.
+
+**Verdict: UNPROVED.** The local caller-side obligation is proved: the wrapper's
+unsafe contract requires `value != 0`; the submitted dependency contract places
+the identical precondition on `duplicate_nonzero`; and the source passes the
+same `value` without modification. This derivation is parametric over all
+`Required` configurations, so the adjacent safety comment adequately explains
+that limited obligation.
+
+The separate provider-side obligation is not proved. The smallest missing
+soundness proposition is:
+
+`DEP-SOUND := for every C satisfying Required and every v in 1..=255, every
+permitted execution of peer_unsafe_dep::duplicate_nonzero(v) in exact package
+3.4.5 is free of Rust undefined behavior.`
+
+The dependency implementation and generated output are absent, and
+UNSAFE-DEP-1 is not admitted. The published caller contract does not establish
+`DEP-SOUND`. Therefore no configuration has a complete affirmative derivation,
+and `Required ⊆ Covered` cannot be certified. Conversely, the packet supplies
+no execution, implementation fact, or other premise proving an existential UB
+witness, so `UNSOUND` is not justified.
+
+**Documented behavior.** The source itself proves that the same nonzero value is
+passed to the peer function and that the peer's return value is returned. The
+submitted peer documentation additionally says it returns `value`. If that
+provider guarantee is included as the wrapper's return-value postcondition,
+its verdict is **UNPROVED**: the smallest missing proposition is that, for every
+`C` and nonzero `v` above, every defined normal return from exact dependency
+3.4.5 equals `v`. No UB-free falsifying execution is supplied, so
+`CONTRACT-BROKEN` is not justified.
+
+**Finding D-1 (missing dependency proof/TCB premise).** Resolve by recursively
+auditing the exact dependency implementation and relevant generated output, or
+by an authorized human accepting precise `UNSAFE-DEP` propositions covering
+`DEP-SOUND` and any consumed return guarantee over all `Required`
+configurations. Strengthening the wrapper's caller contract would not repair
+this provider-side gap.
+
+## Coverage, residual scope, and triggers
+
+For Claim F, the existential UB certificate closes for an arbitrary member of
+`Required`. For Claim D, the local precondition proof covers all `Required`, but
+the necessary provider theorem covers none on the supplied evidence; proof
+regions for distinct obligations cannot be unioned. No testing or tool-derived
+evidence contributes.
+
+Residual scope is precisely the unavailable dependency implementation,
+generated output, and any facts about its executions. Re-audit is required if
+either API or its documentation changes; Rust/std, edition, target, profile, or
+support policy changes; dependency identity, features, contract, source, or
+trust disposition changes; or dependency implementation/generated evidence is
+added.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/H.md
new file mode 100644
index 0000000000..6b32e1d398
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/H.md
@@ -0,0 +1,110 @@
+# Focused source-only unsafe Rust review
+
+## Claim frame and snapshot
+
+Scope is exactly the two exported functions in the supplied `lib.rs`. The
+source snapshot consists of the submitted `lib.rs` and manifest, with edition
+2021 and the exact requirement `peer-unsafe-dep = "=3.4.5"`. The submitted
+dependency record identifies the resolved package as `peer-unsafe-dep` 3.4.5
+and supplies its declaration and public contract, but no implementation,
+generated output, binary, or prior audit.
+
+Let `C` be: Rust compiler and standard library 1.80.0; every target on which
+this exact source and exact dependency resolve; and every ordinary debug or
+release profile. There are no source `cfg`s, features, generated artifacts, or
+profile-dependent branches in the submitted crate. The source arguments below
+are therefore parametric over target and profile. Dependency-side target or
+generated variation is inaccessible and is not assumed away.
+
+The only public surfaces are the safe free function `force_unreachable` and
+the unsafe free function `delegated_nonzero`; there are no public fields,
+constructors, methods, traits, macros, callbacks, or invariant-bearing state.
+No build, test, execution, expansion, or tool-derived evidence was used.
+
+Combined result: **UNSOUND** for `force_unreachable`; **UNPROVED** for
+`delegated_nonzero`. There is no whole-scope `PROVED` result.
+
+## Claim 1: `force_unreachable`
+
+**Exact claim.** For every configuration in `C`, every well-typed safe
+invocation, with no caller-side safety precondition, has no Rust undefined
+behavior.
+
+**Verdict: UNSOUND**, throughout `C`.
+
+**Complete refutation.** `lib.rs:4` exports an ordinary safe function with no
+arguments or checked branch. Every invocation reaches `lib.rs:6`, which
+unconditionally calls `std::hint::unreachable_unchecked`. The independently
+opened Rust 1.80.0 standard-library Safety section states: “Reaching this
+function is Undefined Behavior.”
+([versioned authority](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+Thus a safe program that calls `force_unreachable()` is a valid in-domain use
+whose execution reaches undefined behavior. The same source-level derivation
+applies on every target/profile in `C`; optimization behavior is irrelevant.
+
+The adjacent comment, “This site is assumed to be unreachable,” proves no
+dominating fact and is contradicted by the public safe entry path. This is both
+an implementation defect and a missing/false proof artifact. A minimum repair
+must remove the reachable `unreachable_unchecked` operation (for example, use a
+defined diverging behavior); merely strengthening the comment cannot repair a
+safe API. Because the witness contains UB, it does not establish a separate
+UB-free documented-postcondition refutation.
+
+## Claim 2: `delegated_nonzero`
+
+**Exact valid-use claim.** For every configuration in `C`, every invocation of
+`delegated_nonzero(value)` for which the unsafe caller establishes the complete
+documented obligation `value != 0` is free of Rust undefined behavior. No
+ongoing or terminal caller obligation is documented.
+
+**Verdict: UNPROVED**, throughout `C`; neither `UNSOUND` nor `PROVED` is
+justified by this packet.
+
+**Local derivation and precise gap.** At `lib.rs:14`, valid use gives the local
+fact `value != 0`. At `lib.rs:17`, that identical `u8` value is passed directly
+to `peer_unsafe_dep::duplicate_nonzero`. The submitted dependency contract's
+sole caller-side safety clause is also `value != 0`. Therefore the wrapper's
+call-site precondition is completely discharged for every nonzero `u8`, target,
+and profile in `C`; the local SAFETY comment accurately records this step.
+
+That step is not a proof of the unsafe dependency implementation. Full
+soundness additionally requires the following smallest missing proposition:
+
+> **DEP-IMPL.** For `peer-unsafe-dep` 3.4.5 as exactly resolved, on every target
+> and ordinary debug/release profile in `C`, every execution of
+> `duplicate_nonzero(v)` with `v != 0` is free of Rust undefined behavior.
+
+No supplied source or universal evidence proves DEP-IMPL, and the human trust
+decision expressly declines an `UNSAFE-DEP` assumption for it. The exact pin
+fixes package version but does not establish undocumented implementation
+correctness. The published unsafe caller contract establishes what this crate
+must pass; it does not establish that the unavailable body fulfills its
+promise. No valid UB witness is supplied either, so the fail-closed result is
+`UNPROVED`, not `UNSOUND`.
+
+The wrapper's Safety section states a precondition, not a result
+postcondition. Its summary's “delegates” description is realized syntactically
+by the direct call. The dependency separately promises “Returns `value`.” If
+same-value return behavior is consumed as a wrapper guarantee, it is also
+**UNPROVED**: DEP-IMPL must be strengthened to say that every such call returns
+`v` on normal return. There is no independent UB-free refutation, so
+`CONTRACT-BROKEN` is not established.
+
+## TCB and coverage ledger
+
+| ID | Proposition and scope | Disposition | Consumers |
+|---|---|---|---|
+| AXIOM-UR-1 | The quoted Rust 1.80.0 `unreachable_unchecked` Safety proposition, all targets/profiles in `C` | Accepted after direct citation verification | Claim 1 |
+| DEP-IMPL | Exact dependency proposition stated above | Expressly not accepted; no implementation evidence | Claim 2 |
+
+Obligation coverage: Claim 1's only unsafe-operation precondition fails on its
+public entry path. Claim 2's dependency call precondition is proved, while
+dependency implementation soundness remains open. No other local unsafe sites,
+state transitions, mandatory unsafe-API postconditions, or configuration
+branches appear in the submitted crate.
+
+Residual scope is the unavailable dependency implementation and any of its
+target/generated variants. Re-audit is required if either function or its
+documentation changes, Rust or the supported domain changes, dependency
+identity/contract/features/generated output changes, dependency source or an
+accepted audit becomes available, or the TCB trust decision changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/I.md
new file mode 100644
index 0000000000..6901e1a983
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/I.md
@@ -0,0 +1,104 @@
+# Focused source-only unsafe Rust review
+
+## Claim frame and results
+
+The audited source is `lib.rs` SHA-256
+`778d644359b84bc0e519ed7220bfcadfbba578e2c9fd4c474ce742c4b0021ceb`,
+together with the submitted manifest, dependency declaration, evidence policy,
+request, and TCB decision. The manifest selects edition 2021 and exactly
+`peer-unsafe-dep =3.4.5`. No dependency implementation, generated output,
+prior audit, or binary was supplied.
+
+Let **C** be: Rust compiler and standard library exactly 1.80.0; every target
+on which this source and that exact dependency resolve; and every ordinary
+debug or release profile. These are source-level Rust-abstract-semantics
+claims, not compiler-backend or binary claims.
+
+| Exported API | Exact valid uses | Soundness claim and strongest verdict |
+|---|---|---|
+| `pub fn force_unreachable()` | Every well-typed safe invocation; there is no caller safety precondition. | Every execution of every valid use in C is UB-free: **UNSOUND**, relative to TCB-R1. |
+| `pub unsafe fn delegated_nonzero(value: u8) -> u8` | Every invocation whose caller ensures `value != 0`; the contract states no ongoing or terminal obligation. | Every execution of every valid use in C is UB-free: **UNPROVED**, relative to TCB-R1. |
+
+Thus there is no combined `PROVED` result. The conjunction that both exports
+are sound is refuted by the first API, while the second API retains its own
+`UNPROVED` status.
+
+## API and boundary coverage
+
+The complete exported surface in `lib.rs` is the two public free functions
+above. There are no exported fields, constructors, types, traits, methods,
+statics, macros, reexports, hidden items, FFI declarations, or generated APIs.
+The relevant unsafe consumers are the call to
+`std::hint::unreachable_unchecked` and the call across the unsafe dependency
+boundary. `#![allow(dead_code)]` only changes linting.
+
+## Proof S1 — `force_unreachable`
+
+1. A direct safe call `force_unreachable()` is a well-typed valid use.
+2. On entry, the body has no branch, check, or earlier diverging operation. It
+   immediately evaluates `std::hint::unreachable_unchecked()`; therefore that
+   site is reached.
+3. Verified Rust 1.80.0 standard-library authority states: “Reaching this
+   function is Undefined Behavior.”
+   ([Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+4. Consequently the valid safe invocation is a complete in-scope UB witness.
+
+The derivation is parametric over C: neither the source control flow nor the
+verified proposition has a target or ordinary-profile qualification. The
+existing comment, “This site is assumed to be unreachable,” is circular and
+false whenever the exported function is invoked; it proves no precondition.
+No comment-only repair can make this safe implementation sound. A resolution
+must remove the unchecked operation (for example, use a defined panic) or
+enforce an appropriate boundary; a safe API cannot impose a hidden
+unreachability obligation on callers.
+
+## Proof S2 — `delegated_nonzero`
+
+For an arbitrary valid call, let the input be `v: u8` with `v != 0`. The
+wrapper performs no mutation or conversion and passes that same `v` to
+`peer_unsafe_dep::duplicate_nonzero`. The submitted dependency contract's
+caller-side requirement is exactly `value != 0`. Thus the wrapper's documented
+precondition and unchanged dataflow completely discharge the local unsafe-call
+precondition, throughout C. The adjacent safety comment adequately identifies
+this local derivation.
+
+That does not prove the unsafe callee's provider obligation. The smallest
+missing soundness proposition is:
+
+> For exact `peer-unsafe-dep` 3.4.5, on every configuration in C, for every
+> `v: u8` with `v != 0`, every permitted execution of
+> `duplicate_nonzero(v)` is free from Rust undefined behavior.
+
+Neither declaration nor documentation proves that implementation theorem. The
+implementation is unavailable, and the human trust decision explicitly
+declines an `UNSAFE-DEP` admission. Exact pinning fixes identity but not
+correctness. Therefore the wrapper claim is `UNPROVED`; no valid UB witness was
+supplied, so `UNSOUND` is not justified.
+
+The wrapper itself does not explicitly promise result equality. The submitted
+dependency contract separately says it returns `value`; that provider
+postcondition is not consumed by S2, but its implementation status is also
+`UNPROVED`. Its smallest missing proposition is that every UB-free normal
+return for the same domain yields exactly `v`.
+
+## Configuration closure and TCB-R1
+
+There are no declared Cargo features or source `cfg` branches. Target and
+profile are the only stated axes. S1 is covered parametrically across them; the
+local part of S2 is likewise parametric, but the missing dependency proposition
+blocks all of C. No build, execution, test, expansion, or tool-derived evidence
+was used.
+
+TCB-R1 contains one accepted entry:
+
+- **AXIOM-UU-1:** for Rust/std 1.80.0 throughout C, reaching
+  `unreachable_unchecked` is UB. Identity and wording were independently
+  verified at the exact versioned page above. Consumers: S1. Re-audit on a
+  Rust version/domain or cited-contract change.
+
+There are no accepted implementation, compatibility, tool, or deployment
+entries. The proposed dependency-implementation proposition is deliberately
+unavailable/rejected and supports no proof. Re-audit S2 if dependency source is
+audited or the exact proposition is explicitly accepted; re-audit either claim
+on source, safety-contract, dependency identity, supported-domain, TCB, or Rust
+authority changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/J.md
new file mode 100644
index 0000000000..2394ba2c43
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/reports/J.md
@@ -0,0 +1,123 @@
+# Focused unsafe-Rust source review
+
+## Claim frame, snapshot, and domain
+
+Reviewed on 2026-08-01: the supplied `Cargo.toml`, `lib.rs`,
+`DEPENDENCY-API.md`, `EVIDENCE.md`, and `TCB.md` for `quantifier-target` 0.1.0.
+The dependency implementation, generated output, binary, and prior audit are
+absent. The complete exported surface in `lib.rs` is the safe free function
+`force_unreachable` and unsafe free function `delegated_nonzero`; there are no
+exported fields, types, traits, impls, macros, statics, reexports, or
+configuration-specific items in the submitted source.
+
+Let
+
+`D = {(Rust 1.80.0, t, p) | this exact source and peer-unsafe-dep 3.4.5 resolve
+for target t, and p is an ordinary debug or ordinary release profile}`.
+
+This is the request's controlling expression, retained symbolically: the
+packet does not justify enumerating its target projection. `Cargo.toml` pins
+`peer-unsafe-dep = "=3.4.5"`, and `DEPENDENCY-API.md` confirms that exact
+resolution. The reviewed crate has no `cfg`, features, generated code, build
+script, profile branch, target branch, or input-dependent control-flow branch.
+Thus the local source arguments below are parametric over `t` and `p`.
+Dependency-side variation is not available for inspection and is addressed as
+trust, not silently excluded.
+
+## Evidence and TCB
+
+`AXIOM-UU-1.80` is accepted exactly as authorized by `TCB.md`. The opened Rust
+1.80.0 standard-library Safety section states: “Reaching this function is
+Undefined Behavior.” ([versioned source](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)).
+The page identifies rustdoc 1.80.0 and gives no target- or profile-specific
+qualification. It therefore covers all of `D` under the submitted evidence
+policy.
+
+There is no accepted `UNSAFE-DEP` proposition for `peer-unsafe-dep` 3.4.5;
+`TCB.md` expressly declines that trust. The selected-safe-dependency exception
+does not apply to correctness of a third-party **unsafe** API. No tool,
+implementation, compatibility, or deployment premise is admitted.
+
+## Claim 1 — `force_unreachable`: **UNSOUND**
+
+**Exact claim.** For every configuration in `D`, every well-typed safe call to
+`force_unreachable()` is free of Rust undefined behavior. Because the API is
+safe, valid use has no caller-side safety precondition.
+
+**Existential UB certificate (parametric over `D`).**
+
+1. **Valid use:** in any `d in D`, safe code may call the public safe function
+   `force_unreachable()` with no arguments (`lib.rs:4`).
+2. **Reachability:** after entry, its sole, unconditional expression directly
+   calls `std::hint::unreachable_unchecked()` (`lib.rs:6`). There is no guard,
+   earlier divergence, callback, or alternate path.
+3. **False required proposition:** the call site is therefore reached; the
+   required proposition that it be unreachable is false.
+4. **UB consequence:** `AXIOM-UU-1.80` says reaching that function is undefined
+   behavior.
+
+This supplies a valid in-scope UB execution for every member of `D`, so the
+strongest soundness verdict is `UNSOUND`, not merely `UNPROVED`. The local
+comment “This site is assumed to be unreachable” (`lib.rs:5`) is circular and
+false for the witness; it supplies no derivation. No UB-free whole execution is
+claimed as a postcondition witness.
+
+**Required resolution:** remove the unsafe operation (for example, use a
+defined diverging/panicking path), or expose and document a sufficient unsafe
+caller obligation and re-audit the resulting new API. Changing the comment
+alone cannot repair this safe API.
+
+## Claim 2 — `delegated_nonzero`: **UNPROVED**
+
+**Exact valid-use claim.** For every `d in D` and every `value: u8` with
+`value != 0`, every execution of the unsafe call
+`delegated_nonzero(value)` is free of Rust undefined behavior. The inequality
+is the complete documented caller safety obligation (`lib.rs:11-14`); no
+ongoing or terminal obligation is stated. The supplied peer contract also says
+that, on return, `duplicate_nonzero(value)` returns `value`.
+
+**Proved local portion (all of `D`).** The wrapper passes the unchanged
+`value` directly to `peer_unsafe_dep::duplicate_nonzero` (`lib.rs:17`). For
+every valid wrapper call, `value != 0`; this is exactly the dependency's
+documented caller-side precondition. The adjacent safety comment correctly
+proves this call-site obligation. There are no intervening transitions or
+other local unsafe operations.
+
+**Smallest missing propositions.** For the exact implementation selected as
+`peer-unsafe-dep` 3.4.5, over every target/profile in `D`:
+
+- for every `u8 v != 0`, every permitted execution of
+  `duplicate_nonzero(v)` is free of undefined behavior; and
+- on normal return, its result equals `v` (the submitted dependency
+  postcondition).
+
+The declaration and caller contract do not prove that an unavailable unsafe
+implementation fulfills its promise. `DEPENDENCY-API.md` expressly supplies
+no body-execution assertion, implementation artifact, generated output, or
+prior audit, and the only possible implementation premise is rejected by the
+TCB. Consequently the local precondition coverage is `D`, but aggregate
+soundness/postcondition coverage cannot be established for any part of `D`.
+`Required subset Covered` is therefore not certified.
+
+No existential refutation is available either: the packet contains no fact
+showing what the dependency body executes for any valid value. Thus `UNSOUND`
+would be unjustified, and the strongest verdict is `UNPROVED`. The peer's
+return-equals-input guarantee is likewise `UNPROVED`; it cannot be promoted
+from documentation to an implementation fact for this unsafe dependency.
+
+**Required resolution:** recursively audit the exact resolved 3.4.5
+implementation (including relevant generated/configuration-dependent code) and
+prove both propositions throughout `D`. Alternatively, an authorized reviewer
+could accept a precise `UNSAFE-DEP` entry, but the governing trust decision for
+this review expressly refuses that route.
+
+## Closure and residual scope
+
+For Claim 1, the witness proof is target/profile-parametric and the Rust axiom
+covers `D`; no configuration is omitted. For Claim 2, every wrapper-owned
+obligation is proved parametrically, while the dependency-implementation
+obligation remains missing over the entire symbolic target/profile domain.
+No builds, executions, tests, downloads, macro expansions, or dependency-source
+claims contribute evidence. Re-audit on source/API changes, Rust-version or
+support-domain changes, dependency identity/contract changes, or provision or
+acceptance of dependency implementation evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/Q/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/PACKET.json
new file mode 100644
index 0000000000..d2f7a58812
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "R",
+  "presentation_order": [
+    "H",
+    "F",
+    "G",
+    "I",
+    "A",
+    "D",
+    "J",
+    "E",
+    "C",
+    "B"
+  ],
+  "report_sha256": {
+    "A": "dac13c86e54c024ce799a6b3184e7c6d0e72cb9fdb3ce113aa7ef189c9b65630",
+    "B": "33f7ad5b9d6de92126d674c4b964e5d7ce46a3752b8883e324ce257ea928854f",
+    "C": "130367c76a139f7075e90837340f67fbb8411604f57a468cb3a30499bfc9a585",
+    "D": "745c8a81613a865eb7c42cf2f0b0d3c14f6e28b3aae745881d3a322e1fa409a3",
+    "E": "8a4870792d2b539f3f1adb115796eea44f36fc3c49d9c36d39996133f51502ad",
+    "F": "98fe0f05b276a3cd41156e7d3568f698c2232410faed435a32f8b27626172091",
+    "G": "034a581627624218f85a2e12af3590c9346c1227c7846bf28e3bacf75c8c7a5f",
+    "H": "c9e2ad98c41d88e0c379eff9f0c5b74f545076ca97483f05bbac2f1c46d1a1a4",
+    "I": "c29cf094b7026bbde11940bb1784b6393918115d74c5eec57207772ba46f0012",
+    "J": "ff506100d0e272b8bd653caab454d10845a938aee535aa0cb927869bc553b883"
+  },
+  "rubric_sha256": "a3e9b8d28e8b9d4eafc5f9c4b553d6b862a623b2f786e1e5e806ea212317bc18",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/RUBRIC.md
new file mode 100644
index 0000000000..17b4a752e1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/RUBRIC.md
@@ -0,0 +1,67 @@
+# Mode R Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## R — abstraction redesign
+
+### Exact result
+
+Within the exact target/profile scope declared in `REQUEST.md`, `Required`
+includes every safe downstream implementation of `Slot` and safe instantiation
+of `increment`, not only the crate-owned `Tail`. A safe
+implementation can return 2. Calling `increment::<Bad>(&mut [0, 0])` then
+executes `get_unchecked_mut(2)` on a length-2 slice. The Rust 1.82.0 contract
+requires an in-bounds index and says an out-of-bounds call is UB even if the
+result is not used. The current safe API is therefore `UNSOUND`.
+
+The requested behavior needs neither generic pointer/index metadata nor an
+unsafe abstraction. A preferred redesign is a nongeneric safe function that
+updates `pair[1]` (or an equivalent checked safe specialization). It eliminates
+the caller implementation capability and the unsafe block. Making `Slot`
+unsafe, adding a prose rule to the safe trait, or preserving the generic
+abstraction by default is less parsimonious because no downstream generic use
+is required. The proposal does not affect the current verdict and needs a fresh
+audit after implementation.
+
+### Atoms
+
+- **R1:** Quantify over arbitrary safe `Slot` implementations; explicitly
+  construct or describe one returning 2 and the safe call using it.
+- **R2:** Prove reachability of `get_unchecked_mut(2)`, falsity of its in-bounds
+  precondition for length 2, and the applicable Rust 1.82 UB consequence.
+- **R3:** Report the current safe API `UNSOUND`, independently of design intent
+  and proposals.
+- **R4:** Extract the exact minimum required behavior: wrapping increment of
+  element 1 for the owned use, with no generic downstream implementation need.
+- **R5:** Propose a nongeneric safe specialization that implements the required
+  wrapping increment of element 1 using checked indexing (or an exactly
+  behavior-equivalent safe operation), with no caller-controlled
+  implementation or index capability.
+- **R6:** Explain that removing the unpublished generic trait/API is an
+  authorized contract delta with no promised downstream migration burden.
+- **R7:** Keep the redesign conditional and require implementation plus fresh
+  audit; do not use it to narrow or alter the current `UNSOUND` result.
+
+Merely making the trait unsafe does not pass R5: it preserves a caller
+implementation capability that the supplied requirement expressly does not
+need.
+
+### Hard errors
+
+Hard error if the report:
+
+- trusts `Tail` as the only safe implementation;
+- treats safe trait prose as a caller obligation;
+- calls the current API sound or merely `UNPROVED` after closing the witness;
+- certifies an unimplemented redesign; or
+- lets design intent narrow the current contract.
+
+### Authority
+
+- Rust 1.82.0 slice `get_unchecked_mut`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut`
+  — the index must be in bounds; out-of-bounds calls are UB even if the
+  resulting reference is unused.
+- Rust 1.82.0 `u32::wrapping_add`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add`
+  — wrapping modular addition supplies the requested update semantics.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/allowlist.txt
new file mode 100644
index 0000000000..7515068ad3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/allowlist.txt
@@ -0,0 +1,2 @@
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut
+https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/A.md
new file mode 100644
index 0000000000..2b619ac2f5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/A.md
@@ -0,0 +1,72 @@
+# Focused unsafe-Rust audit: `lib.rs`
+
+## Claim, snapshot, and verdict
+
+**Snapshot.** Exactly the supplied `lib.rs` (19 lines), with no expansion or generated artifact. The audit covers Rust and standard library 1.82.0, every target on which this source and the two used standard-library items exist, and every ordinary profile. The supplied source has no `cfg`, feature, dependency, FFI, allocator, concurrency, macro, or build-time branch. No prior audit or tool-derived evidence was used.
+
+**Soundness theorem.** Every well-typed safe use of the public items `Slot`, `Tail`, and `increment`, including caller-provided safe `Slot` implementations, must be free of Rust undefined behavior under the documented Rust 1.82 abstract semantics.
+
+**Verdict: UNSOUND.** `increment` is safe but its unchecked access requires a property that the open safe trait does not enforce. This holds throughout the supported set; profiles and targets do not alter the source, array length, index, or applicable Rust 1.82 contract.
+
+**Requested `Tail` behavior: PROVED.** Independently of the whole-surface verdict, for every input `pair`, `increment::<Tail>` returns with element 0 unchanged and element 1 equal to its prior value plus one modulo `2^32`.
+
+There are no source-documented postconditions. Consequently no `CONTRACT-BROKEN` verdict applies. The user-stated `Tail` requirement is reported separately as an explicit robustness requirement. The UB witness below is not used as a defined behavioral witness.
+
+## Boundary and obligation coverage
+
+| ID | Safe surface / proof site | Disposition |
+|---|---|---|
+| API-1 | Public safe trait `Slot` and safe required method `index() -> usize` | Downstream code may implement it; no bound or behavioral contract constrains the result. |
+| API-2 | Public unit struct/constructor `Tail`; crate impl of `Slot` | `index()` always returns `1`; adequate for the requested path only. |
+| API-3 | Public safe generic `increment<S: Slot>` | Accepts every valid `S: Slot`, then consumes `S::index()` in unsafe code; UNSOUND. |
+| OBL-1 | `pair.get_unchecked_mut(S::index())` | Requires the returned index to be in bounds. No check, type fact, sealed boundary, or trait contract establishes this for arbitrary `S`; refuted by WITNESS-1. |
+| OBL-2 | Same call for `S = Tail` | `Tail::index() = 1`, and `[u32; 2]` has indices 0 and 1; PROVED. |
+| OBL-3 | Tail update | The call returns a mutable reference to element 1; `wrapping_add(1)` computes modular addition; assignment writes that result to element 1. Element 0 is not selected; PROVED. |
+
+There is no owned invariant. The proposition `S::index() < 2` would be needed at API-3, but neither `Slot` nor module privacy establishes it. Proving it for the crate-owned producer `Tail` cannot be reversed into a fact about every implementation of the public trait.
+
+No public fields, unsafe declarations, hidden APIs, reexports, callbacks, custom `Drop`, or generated surfaces occur in the supplied source. The unsafe block has no adjacent `SAFETY` proof. Its proof artifact is therefore missing; more importantly, its general implementation obligation is false, so a comment alone cannot repair it.
+
+## Finding F-1 — safe downstream implementation reaches UB
+
+A valid safe caller can write:
+
+```rust
+struct Oob;
+impl Slot for Oob {
+    fn index() -> usize { 2 }
+}
+
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+The caller contains no unsafe operation and violates no contract: `Slot` is a public safe trait and specifies no restriction. `pair` has length 2, hence index 2 is out of bounds. AX-1 states that calling `get_unchecked_mut` with such an index is UB even if its returned reference is unused. The UB occurs at the unchecked call, before wrapping arithmetic. This is a concrete valid-use witness on every in-scope configuration.
+
+**Minimum current-API repair:** enforce the bound before unsafe use, or change the implementer boundary to a sufficient compiler-enforced unsafe/sealed contract and audit every implementation and consumer. Given the authorized requirements, both retain unnecessary machinery; the specialization below is preferable.
+
+## TCB log TCB-R1
+
+Trust policy: only exact authoritative Rust 1.82 standard-library propositions may be consumed. There are no additional assumptions, dependencies, external specifications, compiler-implementation premises, or tools.
+
+- **AX-1 (accepted, Rust axiom):** Rust 1.82 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut), all in-scope targets/profiles: it “Returns a mutable reference to an element or subslice, without doing bounds checking,” and “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumers: OBL-1, OBL-2, F-1.
+- **AX-2 (accepted, Rust axiom):** Rust 1.82 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add), all in-scope targets/profiles: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” Consumer: OBL-3 and the redesign contract.
+
+Both pages were opened at their exact versioned URLs and checked in context. Re-audit their consumers if those contracts or the Rust version changes.
+
+## Preferred redesign
+
+Remove the unused generic capability and all unsafe code:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    let value = &mut pair[1];
+    *value = value.wrapping_add(1);
+}
+```
+
+**Contract.** This is a safe function with no caller safety precondition. It returns normally with `pair[0]` unchanged and `pair[1] = old(pair[1]).wrapping_add(1)`, equivalently addition modulo `2^32`. The fixed array type makes index 1 locally in bounds; ordinary checked indexing removes the unchecked-operation obligation. AX-2 supplies the arithmetic postcondition. There is no representation invariant, implementer promise, unsafe surface, or additional TCB premise.
+
+**Migration delta.** Delete public `Slot`, `Tail`, the type parameter, and the unsafe block. Change `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Downstream `Slot` implementations and generic calls cease to compile, exactly as authorized; the abstraction is unreleased, so no compatibility commitment is retained. The required observable `Tail` behavior is unchanged.
+
+This is a design proposal, not a verdict for a new artifact. After implementation, freshly audit the exact new source: confirm the old trait/type/generic and all reexports or generated copies are absent; verify Rust 1.82 checked access and AX-2 over the full target/profile set; prove both-element postconditions and all exits; and inventory any surrounding code introduced with the change. Source, API, support-set, or cited-contract changes trigger re-audit.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/B.md
new file mode 100644
index 0000000000..c092e7d612
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/B.md
@@ -0,0 +1,126 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the supplied `lib.rs`, exactly as inspected; no expansion,
+execution, tests, dependencies, generated artifacts, features, or prior audit
+were used. Scope is Rust and standard library 1.82.0, every target on which this
+source and its used standard-library items exist, and every ordinary profile.
+
+Let `D` be exactly that configuration predicate. Valid use of each safe public
+API means every well-typed safe use, including caller-chosen implementations of
+the safe `Slot` trait. The source-level claims are:
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every safe use of the exposed API is free of Rust UB over `D`. | **UNSOUND** | `F-1` gives a valid safe use, reaches the unsafe operation, falsifies its bounds precondition, and reaches the documented UB consequence. |
+| For every `pair`, `increment::<Tail>` changes element 1 to its prior value plus 1 modulo `2^32` and leaves element 0 unchanged, over `D`. | **PROVED** | `P-TAIL` below; `D ⊆ CoveredTail = D`. |
+
+The overall current-artifact soundness verdict is **UNSOUND**. The redesign
+proposal below does not qualify or alter it. There is no separate
+`CONTRACT-BROKEN` finding: the requested `Tail` behavior holds, and the source
+contains no other documented postcondition.
+
+## Boundary and inventory
+
+The complete relevant public surface is: safe trait `Slot`; its safe required
+associated function `index`; the public unit struct/constructor `Tail`; its safe
+`Slot` implementation; and safe generic free function `increment`. A downstream
+crate may implement `Slot` without `unsafe`. There are no unsafe public APIs,
+fields, hidden items, macros, callbacks, FFI, dependencies, or persistent
+representation invariants. `increment` contains the sole unsafe operation,
+`get_unchecked_mut(S::index())`, with no adjacent `SAFETY` proof.
+
+The only local invariant-like fact is `ARRAY-2`: the borrowed array has exactly
+two elements, hence valid scalar indices are `0` and `1`. `Tail::index()`
+locally establishes `INDEX-TAIL = 1`. No type or boundary establishes
+`S::index() < 2` for arbitrary `S: Slot`.
+
+## Obligations and proofs
+
+The Rust 1.82 slice contract says that `get_unchecked_mut` returns a mutable
+reference without bounds checking and that calling it with an out-of-bounds
+index is UB, even if the reference is unused
+([slice documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)).
+Thus obligation `O-BOUNDS` is `S::index() < 2` at the call for every safe
+instantiation. The Rust 1.82 integer contract says `wrapping_add` performs
+modular addition, wrapping at the type boundary
+([u32 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)).
+
+**F-1 — open safe trait makes `increment` unsound.** A downstream safe program
+may write:
+
+```rust
+struct Outside;
+impl Slot for Outside { fn index() -> usize { 2 } }
+let mut pair = [0u32, 0u32];
+increment::<Outside>(&mut pair);
+```
+
+This uses no unsafe caller operation and violates no documented or
+compiler-enforced caller obligation. Dynamic dispatch is not involved:
+`Outside::index()` returns `2`, so the safe call reaches
+`pair.get_unchecked_mut(2)`. By `ARRAY-2`, `2` is out of bounds. The cited
+contract makes the call itself UB. The witness is parametric over `D`: the
+literal `2`, array length, trait implementation, and callee selection are
+profile- and target-independent wherever the source/items exist. This closes
+every link of the `UNSOUND` certificate. The missing safety comment is also a
+proof-artifact defect, but documentation cannot repair this safe boundary.
+
+**P-TAIL — requested behavior.** For `S = Tail`, inspected code gives
+`S::index() = 1`; `ARRAY-2` gives `1 < 2`, discharging `O-BOUNDS`. The cited
+slice contract therefore identifies the returned mutable reference with
+element 1. If its old value is `x`, the cited integer contract gives
+`x.wrapping_add(1) = (x + 1) mod 2^32`; assignment stores that result through
+the element-1 reference. No operation targets element 0. This one parametric
+case applies to every input and every configuration in `D`, including overflow
+and all ordinary profile settings.
+
+## Domain closure and TCB log
+
+`Required = D` comes verbatim from the request; no range normalization,
+enumeration, exclusion, or moving policy is used. Actual axes are target and
+ordinary profile. There is one handwritten implementation with no `cfg`; both
+proofs above are parametric over those axes. Therefore the unsound witness and
+`P-TAIL` each cover all of `D`. Audit cutoff is 2026-08-01 and only freezes the
+inspected source and fixed-version documentation.
+
+TCB `TCB-1` contains only two verified authoritative Rust 1.82 axioms: (A1) the
+quoted `get_unchecked_mut` contract, consumed by `F-1` and `P-TAIL`; and (A2) the
+quoted `wrapping_add` contract, consumed by `P-TAIL`. Both apply over `D` by its
+definition. No additional assumptions, safe/unsafe dependencies, compiler
+implementation claims, tools, external specifications, or deployment premises
+are admitted.
+
+## Preferred redesign
+
+Replace the generic abstraction with one concrete safe operation:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its contract is: for every input array, normal return leaves element 0 equal to
+its entry value and sets element 1 to its entry value plus 1 modulo `2^32`; it
+has no caller safety precondition. The fixed array type and safe indexing
+enforce selection of the required element, and `wrapping_add` supplies the
+arithmetic. There is no unsafe block, implementer contract, or representation
+invariant. `Slot` and `Tail` should be removed because nominal slot identity and
+extensibility supply no required capability.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)` and
+removes all `Slot` implementations and generic uses. This is an authorized
+source/API break: the request says the abstraction is unreleased and those
+surfaces need not be preserved. The required observable `Tail` behavior is
+unchanged.
+
+This is a design, not an implemented-artifact verdict. After implementation,
+fresh review must inspect the exact new snapshot; enumerate its complete public
+surface; prove safe index `1` is in bounds for `[u32; 2]`; prove the modular
+write and preservation of element 0 for every input; re-establish `D ⊆
+Covered`; and check that no conditional/generated alternative or remaining
+unsafe/generic surface exists. Re-audit is also required for any source,
+contract, Rust version, support-domain, or relevant standard-library contract
+change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/C.md
new file mode 100644
index 0000000000..83ccfb4387
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/C.md
@@ -0,0 +1,62 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot and scope.** This is a source-only review of the complete supplied `lib.rs`, lines 1–18. The supported predicate is exactly Rust/standard library 1.82.0, every target on which this source and the used standard-library items exist, and every ordinary profile. There are no dependencies, `cfg` branches, features, generated artifacts, macros, FFI, allocation, concurrency, or build inputs in the supplied artifact. The proof is parametric over target and profile: array length `2`, values `1` and `2`, safe-trait openness, and the cited library contracts do not vary across that set. Audit date: 2026-08-01.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces is free from Rust undefined behavior under Rust 1.82.0 abstract semantics. **Verdict: UNSOUND** (`F-1`) over the entire supported predicate. The safe generic API admits an out-of-bounds unchecked access.
+
+**Requested Tail behavior.** For every initial `pair == [a, b]`, `increment::<Tail>(&mut pair)` returns with `pair == [a, b.wrapping_add(1)]`. **Verdict: PROVED** (`O-2`) over the entire supported predicate. This regional behavioral result does not qualify the soundness verdict. The source documents no caller-facing postcondition, so there is no separate source-documented postcondition to classify as `CONTRACT-BROKEN`.
+
+**Combined current-artifact result: UNSOUND.** No proposal below participates in this verdict.
+
+## Boundary and obligation coverage
+
+The complete public surface is: safe, downstream-implementable trait `Slot` and safe associated function `Slot::index` (lines 3–5); publicly constructible unit struct `Tail` (line 7); its safe `Slot` implementation (lines 9–13); and safe generic function `increment<S: Slot>` (lines 15–18). The sole unsafe operation is the internal `get_unchecked_mut` call at line 16. There are no fields, unsafe declarations/impls, hidden APIs, callbacks, custom `Drop`, or generated surfaces. Ordinary compiler-provided moves, destruction, and auto traits carry no state and do not affect the finding.
+
+| ID | Exact obligation and derivation | Status |
+|---|---|---|
+| O-1 | A safe call to `increment::<S>` must establish `S::index() < 2` before line 16 for every safe `S: Slot`. The trait type/signature and source perform no check and enforce no such behavior. | **False; UNSOUND (F-1)** |
+| O-2 | For `S = Tail`, line 11 yields `1`; a `[u32; 2]` has indices `0,1`, so the unchecked call is in bounds and selects element 1. `wrapping_add(1)` computes its modular successor, which line 17 stores through that exclusive reference. Only element 1 is targeted. | **PROVED** |
+| O-3 | The unsafe block needs an adjacent proof of O-1. It has no `SAFETY` comment, and no truthful proof exists for its generic domain. The O-2 reconstruction validates only the Tail specialization and cannot retroactively narrow the safe API. | **Proof artifact deficient; implementation globally UNSOUND** |
+| O-4 | Configuration closure: F-1 uses index `2`, representable on every supported target, against an array of invariant length `2`; O-2 uses index `1`. No profile-dependent assertion, overflow operation, or code selection occurs. | **Complete** |
+
+There is no enforceable representation invariant. The needed proposition “all `Slot` implementations return an index below 2” has no owner or sealing boundary and is disproved by F-1.
+
+## TCB audit log `TCB-R028-r1`
+
+Policy: only exact Rust 1.82.0 Reference/standard-library axioms may be consumed; no additional assumptions, dependencies, tools, tests, implementation behavior, or compatibility premise is admitted.
+
+* **AXIOM-SLICE-1 (accepted):** for Rust 1.82.0 on the supported set, `slice::get_unchecked_mut` returns the indexed mutable reference without bounds checking, and: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82.0 `get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut). Consumers: O-1, O-2, F-1. Recheck if the Rust version or contract changes.
+* **AXIOM-U32-1 (accepted):** for Rust 1.82.0 on the supported set, `u32::wrapping_add` is “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82.0 `wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add). Consumer: O-2 and the proposed contract. Recheck if the Rust version or contract changes.
+
+No tool-derived evidence or sampled execution was used. Both citations were opened at the exact version. No premise is pending or rejected.
+
+## F-1 — safe implementer controls an unchecked index
+
+**Classification:** implementation `UNSOUND`; proof artifact missing. `Slot` is a public safe trait, so well-typed safe downstream code may implement it with any `usize` result:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+This is a valid safe use. `Bad::index()` returns `2`; for length 2 that is out of bounds. AXIOM-SLICE-1 therefore makes the call at line 16 UB immediately, independently of later dereference. This witness applies to every supported target and profile. No UB-free postcondition refutation is claimed from this execution. Minimum resolution is to remove the unchecked generic access, validate the index before unsafe use, or enforce implementer behavior at an actual unsafe/sealed boundary. Given the stated requirement, specialization is smaller and removes the premise entirely.
+
+## Preferred redesign (not implemented; no fresh verdict)
+
+Use one monomorphic safe function and delete `Slot` and `Tail`:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed contract is: no caller safety precondition; for every `[a,b]`, normal return produces `[a, b.wrapping_add(1)]`. The fixed array type and safe constant indexing enforce access to element 1; AXIOM-U32-1 supplies the arithmetic postcondition. There is no unsafe surface, implementer obligation, representation, or abstraction invariant. Making `Slot` unsafe, sealing it, or retaining a checked generic index would preserve genericity that no required consumer needs.
+
+**Migration/contract delta.** Remove the public trait, its downstream implementation capability, `Tail`, and the type parameter. Replace `increment::<Tail>(&mut pair)` with `increment(&mut pair)`. Generic calls and downstream `Slot` implementations intentionally cease to compile, as authorized for this unreleased abstraction. The required Tail-observable mutation is unchanged; the new explicit function contract strengthens the previously undocumented behavioral surface.
+
+After implementation, audit the new snapshot independently: enumerate its actual public surface; verify constant array indexing and wrapping semantics for Rust 1.82.0; prove the complete mutation/postcondition and panic behavior for every input; re-establish target/profile closure; and confirm that no conditional/generated code or unsafe operation was introduced. Source, public-contract, supported-set, or cited Rust-contract changes trigger re-audit. Nothing outside the supplied file was audited.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/D.md
new file mode 100644
index 0000000000..c651b97bb2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/D.md
@@ -0,0 +1,154 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Audited artifact.** Exact `lib.rs` with SHA-256
+`b2d9d02f117745925aa24c5b09461c200c3f36f1d1e026c1f289f971711dc122`,
+under `REQUEST.md` SHA-256
+`2d044b4aa4dca16c51aeedd3bd9db58d182a0929e6b73a98478fdc2710094b8f`.
+No generated source, dependencies, macros, FFI, or configuration branches occur
+in the inspected artifact. Audit date: 2026-08-01. Unsafe-Rust skill identity:
+`SKILL.md` SHA-256
+`a0a75ef8a14497aa78b50b459981097ee99605c57fec95c637cf59aaa20fe766`.
+
+**Supported set.** Exactly Rust and standard library 1.82.0; every target on
+which this source and its used standard-library items exist; every ordinary
+profile. This predicate comes directly from `REQUEST.md`. The proof and witness
+below are parametric in target and profile: the source has no `cfg`, profile,
+layout, pointer-width, panic-strategy, or generated-code branch relevant to
+them.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces is free
+of Rust undefined behavior under Rust 1.82's documented abstract semantics,
+with no caller-side safety precondition and no additional TCB assumptions.
+
+**Verdicts.**
+
+- Current-artifact soundness: **UNSOUND** over the entire supported set
+  (`F-1`).
+- Requested restricted behavior: **PROVED** for
+  `increment::<Tail>(&mut pair)`: if the input is `[a, b]`, normal return leaves
+  `[a, b.wrapping_add(1)]`, over the entire supported set (`P-2`).
+- Source-documented postconditions: none. Consequently there is no
+  `CONTRACT-BROKEN` finding. The user-requested `Tail` behavior is a separate
+  reviewed requirement, not a retroactive restriction on the current generic
+  safe API.
+- Combined current-artifact result: **UNSOUND**, irrespective of the redesign.
+  There is no conditional application claim.
+
+## Boundary and configuration coverage
+
+The complete public surface is: safe, downstream-implementable trait `Slot`
+and its safe associated function `index` (`lib.rs:3-5`); constructible unit
+struct `Tail` (`lib.rs:7`); the crate-owned safe `Slot for Tail` implementation
+returning `1` (`lib.rs:9-13`); and safe generic function `increment`
+(`lib.rs:15-18`). `increment` contains the sole unsafe operation. There are no
+fields, unsafe declarations/impls, hidden items, callbacks, reexports, or
+generated APIs. `Tail` carries no representation invariant. The relevant
+cross-call proposition would have to be an invariant of every `S: Slot`, but
+the safe trait boundary enforces none.
+
+Because both the counterexample and the `Tail` proof depend only on a
+two-element array, integer indices `1`/`2`, and the cited 1.82 contracts, they
+cover every target/profile in the supported predicate without enumeration.
+No test, build, execution, or tool-derived evidence was used.
+
+## TCB audit log `TCB-R011-1`
+
+No additional assumptions are admitted. These two accepted Rust 1.82
+authoritative axioms are the complete consumed TCB:
+
+- **AXIOM-GET.** For `slice::get_unchecked_mut`, an in-bounds index selects and
+  returns a mutable reference to that element; the Safety section states:
+  “Calling this method with an out-of-bounds index is undefined behavior even
+  if the resulting reference is not used.”
+  [Rust 1.82 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut).
+  Consumers: `P-1`, `P-2`. Re-audit if the Rust version or contract changes.
+- **AXIOM-WRAP.** `u32::wrapping_add` performs modular addition, wrapping at the
+  type boundary.
+  [Rust 1.82 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add).
+  Consumer: `P-2`. Re-audit if the Rust version or contract changes.
+
+Both exact pages were opened and their wording and version checked. There are
+no dependency, environment, implementation, probabilistic, or tool entries;
+no rejected or pending premises; and no prior audit was reused.
+
+## Obligation ledger and proofs
+
+**P-1 — unsafe call precondition: FAILED / UNSOUND.** At `lib.rs:16`, every
+executed `S::index()` must be in `0..2`; AXIOM-GET makes an out-of-bounds call
+UB. Neither `S: Slot` nor the safe trait contract constrains the result. A
+well-typed, entirely safe downstream witness is:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+The call reaches `get_unchecked_mut(2)` on a length-two array, hence UB by
+AXIOM-GET. The smallest false implication is
+`S: Slot => S::index() < 2`. A safe caller cannot be assigned this undocumented
+obligation.
+
+**P-2 — crate-owned `Tail` behavior: PROVED.** `Tail::index()` returns `1`
+(`lib.rs:11`); a `[u32; 2]` has indices `0` and `1`, so AXIOM-GET's bound is
+satisfied and the returned reference designates element 1. The only write is
+through that reference. AXIOM-WRAP proves the new value is the old value plus
+one modulo `2^32`; element 0 is untouched. This derivation is target- and
+profile-independent.
+
+**Proof artifact.** The unsafe block has no adjacent `SAFETY` proof. This is a
+missing proof artifact as well as an implementation defect: no truthful local
+comment can derive P-1 for the current generic safe contract. Documentation
+alone cannot repair it.
+
+## F-1 — unconstrained safe implementer controls an unsafe index
+
+- **Status/severity:** **UNSOUND / critical**; affects `increment` and the
+  aggregate safe-surface theorem on every supported configuration.
+- **Defect:** a caller-provided implementation of a safe trait supplies the
+  safety-critical bound without validation, sealing, or an unsafe implementer
+  contract.
+- **UB witness:** the safe `Bad` program above. **Defined postcondition
+  refutation:** not established or needed; the witness contains UB.
+- **Minimum resolution:** eliminate the unchecked operation, validate the
+  index, or enforce an implementer boundary. Merely adding a comment is
+  insufficient.
+
+## Recommended redesign
+
+The most parsimonious abstraction is no generic abstraction at all:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed safe contract has no precondition beyond a well-typed mutable
+borrow. For input `[a, b]`, it returns with `[a, b + 1 mod 2^32]`. The fixed
+array type and constant safe index enforce selection locally; AXIOM-WRAP
+supplies the arithmetic result. It removes the unsafe block, the behavioral
+implementer premise, the invariant fan-out, and all need for `Slot` and `Tail`.
+
+**Migration delta.** Delete public `Slot` and `Tail`; change
+`increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls and
+downstream `Slot` implementations cease to exist. This is a public breaking
+change, expressly authorized because the abstraction is unreleased and those
+uses need not be preserved. Required `Tail` behavior is unchanged.
+
+The proposal is not implemented and has no artifact verdict. After
+implementation, freshly audit the exact snapshot: enumerate its public
+surface; verify the fixed index, modular result, and preservation of element
+0; confirm absence of unsafe/generated/configuration-dependent paths; and
+re-establish Rust-1.82 target/profile closure. Re-audit on any source, API,
+support-predicate, or consumed standard-library-contract change.
+
+## Residual scope
+
+This is a source-level review of exactly the supplied files, not a compiler,
+backend, binary, or broader-crate certification. No authoritative-documentation
+or skill-guidance gap blocked the result. The unimplemented redesign remains
+outside the current-artifact verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/E.md
new file mode 100644
index 0000000000..bd10f0e665
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/E.md
@@ -0,0 +1,90 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: `lib.rs`, SHA-256 `b2d9d02f117745925aa24c5b09461c200c3f36f1d1e026c1f289f971711dc122`; request SHA-256 `2d044b4aa4dca16c51aeedd3bd9db58d182a0929e6b73a98478fdc2710094b8f`. Scope is exactly this source, under documented Rust abstract semantics. No source was executed or expanded; no generated artifacts, dependencies, `cfg`s, features, FFI, concurrency, or allocator behavior occur in the supplied artifact.
+
+`DOMAIN-R1` is preserved directly from the request:
+
+> Rust and standard library exactly 1.82.0; every target on which this exact source and its used 1.82.0 standard-library items exist; every ordinary profile.
+
+Other Rust releases, targets where those conditions fail, nonordinary profiles, compiler/backend correctness, and any wider crate are excluded. Audit cutoff: 2026-08-01; it does not broaden the fixed version.
+
+- **CLAIM-SOUND — UNSOUND.** The public safe generic `increment<S: Slot>` is not sound for all well-typed safe uses. `F-1` below supplies a valid safe witness, reachability, a false unsafe precondition, and the authoritative UB consequence. The witness is parametric over every configuration in `DOMAIN-R1`.
+- **CLAIM-TAIL — PROVED.** For every initial `[a, b]: [u32; 2]` and every configuration in `DOMAIN-R1`, `increment::<Tail>` is UB-free and returns with `[a, b.wrapping_add(1)]`. `P-TAIL` below proves this requested behavior independently of the redesign.
+- **Combined current-artifact result: UNSOUND.** There is no source-authored documented generic postcondition. The UB-containing witness is not used to claim `CONTRACT-BROKEN`.
+
+TCB log `TCB-R1` contains only the two accepted Rust 1.82 authoritative axioms below; there are no additional admitted assumptions, dependency facts, implementation claims, or tool results.
+
+## Boundary, invariants, and obligation ledger
+
+The complete relevant language-reachable surface is: public safe trait `Slot` and its safe implementer-provided static method `index`; public constructible unit struct `Tail` and its safe `Slot` impl; and public safe generic function `increment`. There are no fields, unsafe declarations/impls, macros, hidden items, callbacks other than `S::index`, or generated APIs in the supplied source. Downstream code may implement `Slot` for a downstream type because the trait is public and unsealed.
+
+No enforced invariant connects `Slot` to the two-element array. The tempting proposition `S::index() < 2` is neither type-enforced, checked, nor module-owned. Its producer is adversarial safe code (`S::index`); its consumer is `get_unchecked_mut`.
+
+| ID | Obligation | Status |
+|---|---|---|
+| O-1 | Every safe `increment::<S>` call avoids UB without a hidden caller/implementer safety condition. | **Refuted: F-1** |
+| O-2 | At the unsafe call, `S::index()` is in bounds for the length-2 slice. | **False generically; proved for `Tail`** |
+| O-3 | The returned reference denotes the selected element and is used within the exclusive `&mut` borrow. | **Proved when O-2 holds, by the method contract and types** |
+| O-4 | The stored value is old value plus one modulo the `u32` range. | **Proved by AX-WRAP** |
+| O-5 | Element 0 is unchanged for `Tail`. | **Proved: only the reference to element 1 is written** |
+
+The unsafe block has no adjacent `SAFETY` proof. This is a missing proof artifact, but documentation alone cannot repair O-1: prose on a safe trait cannot impose a soundness precondition on safe implementers.
+
+## Authoritative premises (`TCB-R1`)
+
+- **AX-SLICE (accepted AXIOM).** Rust 1.82 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) returns a mutable reference to the indexed element/subslice without checking bounds and states: “Calling this method with an out-of-bounds index is undefined behavior.” Scope: every `DOMAIN-R1` use of this item. Consumers: O-2, O-3, F-1, P-TAIL.
+- **AX-WRAP (accepted AXIOM).** Rust 1.82 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add) specifies wrapping modular addition at the type boundary. Scope: every `DOMAIN-R1` use of this item. Consumers: O-4, P-TAIL.
+
+Both citations were opened at the exact version and fragment. Re-audit either entry if that exact documentation, source, or supported domain changes.
+
+## F-1 — complete UB certificate
+
+Downstream safe code can write:
+
+```rust
+struct Oob;
+impl Slot for Oob {
+    fn index() -> usize { 2 }
+}
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+**Valid use.** The trait and method are safe and public; the implementation and call are well-typed and contain no caller-written unsafe operation or violated documented obligation.
+
+**Reachability.** `Oob::index()` returns `2`; `increment` then executes `pair.get_unchecked_mut(2)` on the two-element array viewed as a slice of length 2.
+
+**False safety proposition.** Its valid element indices are 0 and 1, so index 2 is out of bounds.
+
+**Consequence.** AX-SLICE says that this call itself has undefined behavior, even independently of later reference use. Thus one valid safe use reaches an executed operation whose required proposition is false and whose applicable contract entails UB. The same construction uses no target- or profile-dependent fact, so it witnesses every member of `DOMAIN-R1`.
+
+Minimum repair requires enforcing the bound before the unsafe call, making an implementer obligation compiler-enforced, or removing the unnecessary extensibility. The last is preferred below.
+
+## P-TAIL — requested-behavior proof and configuration closure
+
+`Tail::index()` is locally and unconditionally `1`. The input type fixes length at 2, hence 1 is in bounds. AX-SLICE therefore supplies a mutable reference to element 1. The subsequent assignment reads that element, applies AX-WRAP with operand 1, and writes only through that reference; element 0 is untouched. This proves UB freedom and the exact `[a, b] -> [a, b.wrapping_add(1)]` postcondition for all `u32` values.
+
+The source has no conditional compilation or profile-sensitive arithmetic: unchecked indexing's contract and modular addition apply parametrically across the request's target/profile predicate. Thus `Covered(CLAIM-TAIL) = DOMAIN-R1`, proving `Required ⊆ Covered`. For CLAIM-SOUND, F-1 applies parametrically across the same domain; no configuration remainder can weaken its `UNSOUND` verdict.
+
+## Preferred redesign
+
+Replace the trait, marker, generic dispatch, and unsafe operation with one specialized safe function:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    let tail = &mut pair[1];
+    *tail = tail.wrapping_add(1);
+}
+```
+
+Its proposed public contract has no safety precondition: on normal return, element 0 equals its entry value and element 1 equals its entry value plus one modulo `u32`. It has no invariant-bearing representation, downstream implementer contract, generic capability, or unsafe proof site. Fixed index 1 is valid by the array's type; `wrapping_add` supplies the requested arithmetic. This is the minimum capability actually required.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. `Slot`, downstream `Slot` implementations, generic calls, and the nominal `Tail` marker disappear. Those are breaking source/contract changes, explicitly authorized because the abstraction is unreleased and none must be preserved. No caller safety obligation is transferred.
+
+This is a design, not a verdict for a new artifact. After implementation, freeze and audit that exact snapshot anew: re-inventory every exposed/reexported/generated surface; verify the fixed-index operation for `[u32; 2]`, borrow/dataflow, AX-WRAP postcondition, both elements' outcomes and every exit; confirm no unsafe or hidden extensibility remains; and re-establish parametric `DOMAIN-R1` closure. Any changed signature, documentation, configuration, generated code, standard-library contract, or Rust version triggers re-audit.
+
+## Residual attestation
+
+Every in-scope surface and unsafe obligation has a disposition above. No test or absence of counterexamples supports either verdict. No independent second review was performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/F.md
new file mode 100644
index 0000000000..2daf3a9a34
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/F.md
@@ -0,0 +1,67 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, domain, and verdicts
+
+**Snapshot and scope.** This is a source-level review of `lib.rs` exactly as supplied. The in-scope boundary is its public `Slot`, `Tail`, and `increment` items and the single unsafe operation inside `increment`. No generated artifacts, dependencies other than Rust 1.82.0 `std`, or tool-derived evidence were supplied or used; the source was not built, tested, executed, or expanded.
+
+Let
+
+`Required(r,t,p) := (r = Rust/stdlib 1.82.0) && source-and-used-items-exist(t) && ordinary-profile(p)`.
+
+This preserves the request's target and profile predicates symbolically. There are no `cfg`s, features, generators, FFI, assembly, allocator choices, concurrency, profile-dependent assertions, or ordinary overflowing `+` operations in the source. Both proofs below are parametric in `t` and `p`; thus no finite target/profile inventory is assumed.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe use of the current public surface is free of Rust UB over `Required` | **UNSOUND** | `F-1` gives a valid safe call that executes `get_unchecked_mut(2)` on a length-2 array; this is UB. The witness works throughout `Required`. |
+| For every initial `[a,b]`, current `increment::<Tail>` returns with `[a, b+1 mod 2^32]` without UB over `Required` | **PROVED** | `P-TAIL` below; aggregate `Covered = Required`, so `Required ⊆ Covered`. |
+
+The combined current-artifact soundness result is **UNSOUND**. The proved `Tail` subcase neither narrows the current safe generic API nor changes that verdict. There is no source-documented postcondition for generic `increment`; the second claim is the behavior expressly required by the request.
+
+**TCB-1.** No additional TCB assumptions are admitted. The only ground premises are these verified, version-exact authoritative standard-library axioms:
+
+- `AXIOM-BOUNDS`: Rust 1.82.0 says, “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” It also says the method returns a mutable reference to the indexed element/subslice. [slice::get_unchecked_mut](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+- `AXIOM-WRAP`: Rust 1.82.0 specifies modular addition, “wrapping around at the boundary of the type.” [u32::wrapping_add](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)
+
+These axioms apply to every member of `Required` by construction (exact Rust/stdlib version, and only targets where the items exist).
+
+## Boundary, invariants, and obligation ledger
+
+The complete crate-owned surface is: public safe trait `Slot`; its safe implementer-controlled `index() -> usize`; publicly constructible unit struct `Tail`; the safe `Slot for Tail` impl returning `1`; and public safe generic function `increment<S: Slot>`. There are no unsafe declarations, fields, impls, macros, hidden items, callbacks, or explicit constructors beyond the unit-struct constructor. Downstream safe code may implement `Slot` for a downstream-local type. No invariant enforces `S::index() < 2`; documentation cannot supply a hidden safety precondition to either safe boundary.
+
+| ID | Proposition and disposition |
+|---|---|
+| `O-OPEN` | Every safe `Slot` implementation used by `increment` must return an index below 2. **False:** neither the type nor validation, privacy, or sealing enforces it. |
+| `O-BOUNDS` | At the unsafe call, `S::index()` must be in `0..2`. **False in general** by `F-1`; true for `Tail`. |
+| `O-TAIL` | `Tail::index() = 1` and `1 < 2`. **Proved directly from the impl and array type.** |
+| `O-POST` | The selected element receives old value plus one modulo `2^32`. **Proved for `Tail`** from `O-TAIL`, the returned-reference postcondition, assignment, and `AXIOM-WRAP`. |
+
+`P-TAIL`: for input `[a,b]`, the inspected impl makes the index exactly `1`; a `[u32; 2]` has indices `0` and `1`. `AXIOM-BOUNDS` therefore is not violated, and `get_unchecked_mut` returns a mutable reference to element 1. `wrapping_add(1)` produces `b+1 mod 2^32`; assignment writes that value only to element 1, leaving element 0 as `a`. These facts do not vary by target or ordinary profile.
+
+The unsafe block has no adjacent `SAFETY` proof. That proof artifact is missing, but prose cannot repair the false generic obligation; the implementation must change or the implementer set must be enforced.
+
+## F-1 — open safe trait makes the safe function unsound
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+This is a well-typed, entirely safe downstream use: `Slot` and its method are safe and public, and the implementation uses a downstream-local type. The call reaches the unsafe operation because `Bad::index()` returns normally. The exact required proposition is `2 < pair.len()`; it is false because `pair.len() = 2`. `AXIOM-BOUNDS` then entails UB at the call itself, even before any use of the returned reference. This completes the existential `UNSOUND` certificate for every `Required` configuration. No separate UB-free postcondition refutation is claimed.
+
+## Recommended provable abstraction
+
+The minimum capability is not implementer-selected indexing; it is one fixed transformation. Delete `Slot`, `Tail`, their impl, and the generic parameter, and implement only:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+**Proposed contract.** This safe function has no caller-side safety precondition beyond a well-typed `&mut [u32; 2]`. On return, element 0 equals its old value and element 1 equals its old value plus one modulo `2^32`. It has no representation invariant or unsafe surface. Constant safe indexing is within the type-enforced length; even an indexing defect would panic rather than create an unchecked reference.
+
+**Migration/contract delta.** Replace `increment::<Tail>(&mut pair)` with `increment(&mut pair)`. Remove construction/naming of `Tail`, downstream `Slot` implementations, and generic calls; the request explicitly permits all of these breaking source/API changes and states the abstraction is unreleased. The required `Tail` behavior is unchanged, while unsupported extensibility and its hidden range obligation disappear.
+
+This is an unimplemented proposal, not a `PROVED` new artifact. After implementation, freshly audit the exact snapshot: enumerate remaining exports/reexports/generated surfaces; verify all old generic paths are gone; prove both output clauses and any promised panic behavior from applicable Rust 1.82.0 contracts; re-establish `Required ⊆ Covered`; and recheck that no unsafe operation or invariant remains. Re-audit on source/API changes, Rust or support-domain changes, newly generated surfaces, or material changes to either consumed standard-library contract.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/G.md
new file mode 100644
index 0000000000..3dce4d872a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/G.md
@@ -0,0 +1,74 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot.** Exact supplied `lib.rs`; no expansion, execution, tests, dependencies, generated artifacts, or prior audit were used. Audit date: 2026-08-01. Scope is Rust and standard library 1.82.0, every target on which this exact source and its used standard-library items exist, and every ordinary profile. The source has no `cfg`, feature, target, generator, FFI, allocator, concurrency, or dependency branch. Profile-dependent overflow checks are immaterial because the code explicitly uses wrapping arithmetic.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces must be free of Rust undefined behavior, with no caller safety precondition, over that supported set.
+
+**Current-artifact soundness verdict: UNSOUND (F-1).** The result is universal across the supported set; a safe downstream trait implementation can select an out-of-bounds index.
+
+**Required `Tail` behavior: PROVED.** For every initial `pair == [a, b]`, `increment::<Tail>(&mut pair)` returns without UB with `pair == [a, b.wrapping_add(1)]`. This requested behavior is not a source-documented postcondition, so there is no separate `CONTRACT-BROKEN` result. The overall safe API remains `UNSOUND` despite this regional proof.
+
+**TCB:** `TCB-1` below. It contains only verified Rust 1.82.0 standard-library axioms and no additional admitted assumptions. Conditional application claims: none.
+
+## Boundary, invariants, and obligation ledger
+
+Public safe surfaces are: implementable trait `Slot`; safe associated function `Slot::index`; constructible unit struct `Tail`; its safe `Slot` implementation; and safe generic free function `increment<S: Slot>`. The sole unsafe operation is the internal `get_unchecked_mut` call. There are no unsafe public APIs, fields, macros, hidden items, or generated surfaces in the supplied source. Ordinary unit-struct construction and auto traits do not supply an index-range guarantee.
+
+No enforced invariant exists. The needed proposition, `S::index() < 2`, cannot be an invariant of all `S: Slot`: the safe public trait permits caller-controlled implementations and its method has neither a type-enforced restriction nor validation.
+
+| ID | Location | Exact obligation | Status |
+|---|---|---|---|
+| O-1 | `increment`, unchecked projection | The particular returned index is in bounds for the two-element slice before `get_unchecked_mut` is called. | **False** for general `S`; F-1. |
+| O-2 | `increment::<Tail>` | `Tail::index() == 1` and `1 < 2`. | **PROVED** directly from the implementation and array length. |
+| O-3 | mutation | On the Tail path, write the old second value plus one modulo the `u32` range, leaving element 0 unchanged. | **PROVED** from O-2, exclusive `&mut` access, A-1, and A-2. |
+| O-4 | configuration closure | O-1--O-3 cover every requested target/profile. | **PROVED** parametrically: the fixed length, constants, and cited 1.82 contracts do not vary across this source's supported set. |
+
+For the Tail derivation, method evaluation yields `1`; the receiver has length two, so A-1's only stated safety condition is met. The resulting mutable reference designates element 1 and is used within the exclusive borrow without intervening caller code. A-2 makes the computed value `(b + 1) mod 2^32`; assignment changes only that element. No material derivation is present in the source: the unsafe block has no adjacent `SAFETY` proof. More importantly, no comment could prove O-1 for arbitrary safe implementations.
+
+## F-1 — safe implementer reaches out-of-bounds unchecked access
+
+**Implementation classification:** `UNSOUND`. **Proof artifact:** missing and irreparable under the current safe generic contract.
+
+A downstream crate can use only safe Rust:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+`Bad` is caller-controlled and satisfies the complete declared bound. The array/slice length is 2, and `Bad::index()` returns that length. A-1 says this call itself has undefined behavior even if the reference is unused. Thus this valid safe use reaches UB on every supported configuration. This whole-execution witness establishes `UNSOUND`; it is not used as a defined postcondition refutation.
+
+Minimum resolution is to remove the unchecked operation or enforce bounds before it. Merely documenting that a safe `Slot` implementation should return 0 or 1 would leave a hidden safety precondition and would not repair soundness.
+
+## TCB-1 audit log
+
+| ID | Category and exact proposition | Identity, evidence, consumers, disposition |
+|---|---|---|
+| A-1 | AXIOM: `get_unchecked_mut` returns a mutable element/subslice reference without a bounds check; an out-of-bounds index makes the call UB. | Rust 1.82.0 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut), verified in context. Exact safety text: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumers O-1--O-3; accepted authoritative axiom. |
+| A-2 | AXIOM: `u32::wrapping_add(rhs)` computes modular addition at the type boundary. | Rust 1.82.0 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add), verified in context: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” Consumer O-3; accepted authoritative axiom. |
+
+There are no safe/unsafe dependency, implementation, tool, external, deployment, probabilistic, or out-of-band entries. No tool-derived evidence was used. Re-audit triggers are any source/API change, supported-set change, or material change to either cited Rust contract.
+
+## Preferred redesign (not a verdict on current source)
+
+The minimum capability is one fixed, safe mutation; neither type-level slot identity nor implementer extensibility is required. Delete `Slot`, `Tail`, the generic parameter, and all unsafe code:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed safe contract is: for every `[a, b]`, return normally as `[a, (b + 1) mod 2^32]`, with no caller safety obligations. Constant `1` is in bounds by the input type; safe indexing localizes enforcement, and A-2 supplies the arithmetic result. There is no representation invariant, unsafe surface, implementer promise, or extra TCB premise.
+
+This intentionally breaking migration replaces `increment::<Tail>(&mut pair)` with `increment(&mut pair)` and removes all `Slot` implementations, generic calls, and references to the marker type. Those losses are expressly authorized for this unreleased API; the required observable mutation is unchanged.
+
+The proposal is unimplemented and has no audit verdict. After implementation, freeze a new snapshot and audit its complete public/reexported and generated surface, confirm the exact fixed index and array type, prove safe indexing and A-2's postcondition over the full supported set, check every normal exit and call-site migration, and re-establish configuration closure. Any retained compatibility wrapper or newly introduced macro/configuration becomes additional audit scope.
+
+## Residual scope and attestation
+
+Only the supplied source and requested Tail behavior were audited; no broader crate or binary claim is made. Every discovered obligation has a status, both allowlisted citations were opened and checked at version 1.82.0, no test result substitutes for proof, and the redesign does not alter the current-artifact verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/H.md
new file mode 100644
index 0000000000..5b2adf44bb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/H.md
@@ -0,0 +1,65 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the exact supplied `lib.rs`, lines 1–18. `REQUEST.md` is the controlling scope. No generated code, dependencies, features, `cfg`, FFI, allocator, concurrency, or build-time inputs appear in the artifact.
+
+Let `Required` be: Rust and standard library 1.82.0, every target on which this exact source and the two used standard-library items exist, and every ordinary profile. The source is identical over that domain; target and profile do not affect the array length, either index value below, or the selected methods. The audit cutoff is this supplied snapshot. TCB-R1 contains only the two verified Rust 1.82.0 standard-library axioms below; it admits no additional assumptions, dependency implementations, tools, compiler backend, or environment.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe use of the public API is free of Rust UB over `Required` | **UNSOUND** | U1 below |
+| For every input `[a, b]`, `increment::<Tail>` returns with `[a, b.wrapping_add(1)]` | **PROVED** | OBL-2–3; `Covered_tail = Required`, hence `Required ⊆ Covered_tail` |
+
+There are no source-documented unsafe-API postconditions. The second claim is the user-required behavior, not a repair or narrowing of the first claim. The combined current-artifact result is **UNSOUND**.
+
+## Authority and TCB-R1
+
+- **AXIOM-SLICE-1 (accepted):** Rust 1.82.0 documents that `get_unchecked_mut` returns a mutable reference to the indexed element or subslice without bounds checking, and: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82.0 slice documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut). Applies to every `Required` case where that item exists; consumed by U1 and P2.
+- **AXIOM-U32-1 (accepted):** `wrapping_add` performs “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82.0 `u32` documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add). Applies throughout `Required`; consumed by P3.
+
+Re-audit these entries if Rust/stdlib version or either cited contract changes. This is a source-level result relative to documented Rust semantics, not a binary/backend claim.
+
+## Boundary and obligation coverage
+
+| ID | Safe surface / proof site | Disposition |
+|---|---|---|
+| API-1 | Public safe trait `Slot` and safe required method `index() -> usize` (lines 3–5) | Downstream safe code may implement it and return any `usize`; no contract or type restriction enforces bounds. |
+| API-2 | Public constructible unit struct `Tail` and its safe `Slot` impl (lines 7–13) | `index()` is locally fixed to `1`. |
+| API-3 | Public safe generic `increment<S: Slot>` (lines 15–18) | Must be sound for every well-typed safe `S`; it invokes caller-controlled safe code, then consumes its result in unsafe code. |
+| OBL-1 | `get_unchecked_mut(S::index())` (line 16) | For the `usize` index, the required proposition is `S::index() < pair.len() = 2`. **False in a valid safe use; U1.** |
+| OBL-2 | `increment::<Tail>` at line 16 | **Proved:** `Tail::index() = 1`, and `1 < 2`; AXIOM-SLICE-1 therefore supplies a mutable reference to element 1. |
+| OBL-3 | Assignment at line 17 | **Proved for `Tail`:** the only write is through that element-1 reference; AXIOM-U32-1 gives the new value `b + 1 mod 2^32`, while element 0 is untouched. |
+
+There are no fields, other constructors, methods, macros, hidden items, reexports, callbacks other than the trait implementation dispatch, or invariant-bearing state in the supplied source. No tool-derived evidence was used.
+
+## U1 — complete UB certificate
+
+A downstream crate can write entirely safe Rust:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0u32, 0u32];
+increment::<Bad>(&mut pair);
+```
+
+This is a valid in-scope use: `Slot` is safe and public, `Bad` is downstream-owned, and `increment` is safe. Dispatch reaches line 16 with index `2`. The borrowed array has exactly two elements, so valid indices are `0` and `1`; `2` is out of bounds. AXIOM-SLICE-1 makes the call itself UB, independently of later dereference. The witness is parametric over every `Required` target/profile because the same source path and constants apply. Thus the universal safe-API claim is **UNSOUND**, not merely unproved.
+
+The unsafe block also has no adjacent `SAFETY` proof. More importantly, no truthful proof comment can close OBL-1: the needed implication `S: Slot => S::index() < 2` is unenforced and refuted above. Behavioral prose on a safe trait would not fix that.
+
+## Preferred redesign (not a verdict on implemented code)
+
+Remove `Slot`, `Tail`, the type parameter, and the unsafe operation. Specialize the sole required capability:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Proposed safe contract: for every input whose old value is `[a, b]`, normal return produces `[a, b + 1 mod 2^32]`; callers have no safety precondition beyond supplying the typed mutable reference. Fixed safe indexing enforces the only projection needed. There is no representation invariant, implementer obligation, generic capability, or unsafe surface to trust. This is more parsimonious than sealing or making `Slot` unsafe because no required consumer needs generic selection.
+
+Migration is intentionally breaking but authorized for this unreleased abstraction: delete downstream `Slot` implementations and change `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls cease to exist; the required element-1 behavior and wrapping arithmetic remain.
+
+The proposal is unimplemented and has no audit verdict. After implementation, audit the new exact snapshot independently: verify its public contract, safe indexing of `1` into `[u32; 2]`, the wrapping result and preservation of element 0, panic/profile independence, configuration closure, and absence of generated or alternate paths. Re-audit on source/API changes, support-domain expansion, or relevant Rust documentation changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/I.md
new file mode 100644
index 0000000000..acc42fb5b5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/I.md
@@ -0,0 +1,83 @@
+# Focused literal audit and redesign
+
+## Claim, scope, and verdict
+
+**Snapshot:** the supplied `lib.rs`, reviewed as source without execution or expansion. **Supported set:** Rust 1.82.0; every Rust 1.82 edition, target on which this source and the used standard-library items exist, and ordinary profile. The proof is parametric over target, edition, and profile: the file has no `cfg`, features, generated code, dependencies, FFI, concurrency, target features, allocation, panic-mode-sensitive checks, or profile-sensitive arithmetic.
+
+The current-artifact claim is that every well-typed safe use of its public safe surfaces is free of Rust undefined behavior. The separately requested behavior is: for input `[a, b]`, `increment::<Tail>` returns normally with `[a, b.wrapping_add(1)]`.
+
+- **Current safe-API soundness: UNSOUND** (`F-1`).
+- **Required `Tail` behavior: PROVED** throughout the supported set, relative only to the cited Rust 1.82 standard-library semantics.
+- **Documented-postcondition result:** the source contains no API documentation. The user-specified `Tail` postcondition is proved; there is no current documented postcondition to classify as `CONTRACT-BROKEN`.
+- **Combined current-artifact result: UNSOUND.** The successful `Tail` proof does not qualify the public generic function's universal safe-use claim.
+- **Additional TCB assumptions:** none. No dependency, implementation, environmental, compatibility, or tool-result premise is admitted.
+
+## Authority and exact contracts
+
+`AXIOM-INDEX`, Rust 1.82 slice documentation: `get_unchecked_mut` returns a mutable reference without bounds checking, and “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82 `get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut).
+
+`AXIOM-WRAP`, Rust 1.82 `u32` documentation: `wrapping_add` is “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82 `wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add).
+
+These are version-matched Rust axioms, not additional TCB assumptions. No tool-derived evidence was used.
+
+## Boundary and obligation coverage
+
+The complete language-reachable source surface is:
+
+| Surface | Kind | Disposition |
+|---|---|---|
+| `Slot` and safe `Slot::index` (`lib.rs:3-5`) | public safe, downstream-implementable trait | Supplies an arbitrary `usize`; no contract or enforcement makes it less than 2. |
+| `Tail`, its public unit constructor, and `impl Slot` (`lib.rs:7-13`) | public safe type/implementation | `Tail::index()` is locally fixed at 1. No fields or state invariants exist. |
+| `increment<S: Slot>` (`lib.rs:15-18`) | public safe generic function containing the sole unsafe operation | Unsound for arbitrary valid `S`; proved for `S = Tail`. |
+
+There are no manual trait implementations other than `Slot for Tail`, macros, hidden APIs, restricted-visible fields, reexports, callbacks, custom destruction, or configuration-specific surfaces in the supplied source. Compiler-provided behavior of the fieldless `Tail` is irrelevant to the unsafe call.
+
+The sole safety invariant consumed at `lib.rs:16` is `INV-BOUND: S::index() < pair.len() = 2` at the instant `get_unchecked_mut` is called. The array-reference type fixes the length at 2. `Tail::index()` establishes `1`, so `INV-BOUND` holds for `Tail`. The public safe trait boundary neither checks nor promises it for arbitrary `S`.
+
+Obligation ledger:
+
+| ID | Proposition | Status |
+|---|---|---|
+| `OBL-1` | At `lib.rs:16`, `S::index() < 2` for every safe-callable `S`. | **Refuted** by `F-1`; hence **UNSOUND**. |
+| `OBL-2` | For `S = Tail`, the unchecked access produces a mutable reference to element 1. | **PROVED:** local constant 1 is in the type-fixed length 2; `AXIOM-INDEX` supplies the operation contract. |
+| `OBL-3` | The `Tail` call leaves element 0 unchanged and replaces element 1 by its old value plus 1 modulo `2^32`. | **PROVED:** `OBL-2` identifies the only assignment target; `AXIOM-WRAP` gives the assigned value. |
+
+No existing `SAFETY` comment states any of these obligations. The reconstructed `Tail` derivation is material, but it cannot repair the generic case.
+
+## F-1 — safe downstream implementation reaches UB
+
+**Status:** `UNSOUND`; implementation defective and local proof missing.
+
+This is a valid, entirely safe downstream use:
+
+```rust
+struct Bad;
+impl Slot for Bad {
+    fn index() -> usize { 2 }
+}
+
+let mut pair = [0u32, 0u32];
+increment::<Bad>(&mut pair);
+```
+
+The public trait is safe and unsealed, its method has no precondition, and the downstream type is local to its implementing crate. The call therefore satisfies every current caller obligation. It passes index 2 to a length-2 array. By `AXIOM-INDEX`, the call at `lib.rs:16` itself has undefined behavior, whether or not the returned reference is later used. This witness and reasoning are independent of target and profile.
+
+The smallest false implication is `S: Slot => S::index() < 2`. Neither the type system, validation, privacy, nor a trait contract supplies it. A comment cannot impose a safety precondition on this safe trait or safe function. Because the witness execution contains UB, it does not establish a defined postcondition refutation.
+
+## Preferred design
+
+Delete `Slot`, `Tail`, the type parameter, and the unsafe operation. Expose exactly the required capability:
+
+```rust
+/// Increments the second element modulo 2^32.
+pub fn increment(pair: &mut [u32; 2]) {
+    let [_, tail] = pair;
+    *tail = tail.wrapping_add(1);
+}
+```
+
+This is the most parsimonious boundary because no runtime-selected slot or nominal marker is required. The two-element pattern structurally obtains the second element; no index validity proposition is delegated to a caller or implementer. All operations are safe, and `AXIOM-WRAP` directly supplies the behavioral postcondition. There is no representation invariant, unsafe surface, sealing argument, or additional TCB entry.
+
+**Contract and migration delta:** `increment::<Tail>(&mut pair)` becomes `increment(&mut pair)`. `Slot`, downstream implementations, generic dispatch, and the `Tail` marker disappear. Those are source-breaking changes, expressly authorized because the abstraction is unreleased and none of those capabilities must be preserved. The new public contract should state normal return with element 0 unchanged and element 1 incremented modulo `2^32`.
+
+This is a proposal, not a verdict for an unimplemented artifact. After implementation, audit the fresh source snapshot: confirm the exact public surface and documentation; re-prove element selection and modular arithmetic on Rust 1.82.0 across the requested target/edition/profile set; and recheck any newly introduced configuration, generated code, dependency, or caller surface. Re-audit on source, contract, supported-set, or relevant Rust-documentation change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/J.md
new file mode 100644
index 0000000000..479dbf06ff
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/reports/J.md
@@ -0,0 +1,66 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot.** Exact supplied `lib.rs` (18 lines) under Rust/standard library 1.82.0; no generated code, dependencies, build scripts, `cfg`, features, FFI, concurrency, or prior audit is present in the supplied artifact. Audit cutoff: 2026-08-01. Report/TCB ID: `R029-1` / `R029-TCB-1`.
+
+`Required(c)` is exactly: Rust 1.82.0, every target `c.target` on which this source and the two used standard-library items exist, and every ordinary profile, for every well-typed safe use of the public surfaces. This preserves the request's symbolic target and profile predicates rather than inventing an enumeration.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All well-typed safe uses of the current public API avoid Rust UB | **UNSOUND** | `F-1` gives a valid safe use, reaches the unchecked call with a false bounds precondition, and the applicable Rust 1.82 contract declares UB. |
+| For `increment::<Tail>` and every initial `[a,b]`, normal return is UB-free and produces `[a, b.wrapping_add(1)]` | **PROVED** | `P-TAIL` below, over all `Required(c)`, relative only to the two Rust 1.82 axioms in `R029-TCB-1`. |
+
+The combined current-artifact result is **UNSOUND**. The Tail-specific proof does not repair or narrow the safe generic API's claim.
+
+## Boundary, invariant, and obligation inventory
+
+Safe public surfaces are: downstream-implementable trait `Slot` and its safe associated function `index` (lines 3–5); publicly constructible unit struct `Tail` (line 7); its safe `Slot` implementation (lines 9–13); and safe generic function `increment<S: Slot>` (lines 15–18). There are no public fields, unsafe declarations, macros, hidden APIs, callbacks, custom destruction, or other source surfaces. The sole unsafe operation is `get_unchecked_mut` at line 16.
+
+The unsafe call requires `INV-INDEX(S): S::index() < 2`. No type, privacy boundary, validation, or trait contract establishes that proposition for all `S: Slot`. `Tail::index() == 1` is only a local fact about `Tail`; it cannot be promoted to an invariant of every implementation of the public safe trait.
+
+| ID | Exact obligation | Required domain | Status |
+|---|---|---|---|
+| `O-BOUNDS` | At line 16, the `usize` index is in bounds for the length-2 receiver | Every safe `S: Slot` call in `Required` | **Refuted (`F-1`)** |
+| `O-TAIL` | The same bound when `S = Tail` | All inputs/configurations in `Required` | **PROVED:** source gives `1 < 2` |
+| `O-WRAP` | Tail element 1 becomes its old value plus one modulo `2^32`; element 0 is unchanged | All inputs/configurations in `Required` | **PROVED (`P-TAIL`)** |
+| `O-PROOF` | Adjacent proof derives every unsafe-call precondition | Line 16 | **Missing**; there is no `SAFETY` comment, and the needed generic premise is false |
+
+### `P-TAIL`
+
+For an input `[a,b]`, the inspected `Tail` implementation returns literal `1`; the array has length 2, hence the unchecked index is in bounds. Rust 1.82 documents that this method returns a mutable reference to the indexed element without bounds checking, while its safety clause says: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” ([`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)). Thus the Tail call obtains the exclusive reference to element 1 permitted by the input `&mut` borrow. Rust 1.82 specifies `wrapping_add` as: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” ([`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)). The assignment therefore changes only element 1 to `b + 1 mod 2^32`; element 0 remains `a`. No branch, panic, unwind, or profile-dependent arithmetic exists on this path.
+
+Both proofs are parametric in target and ordinary profile: the source has no conditional selection, target operation, debug assertion, ordinary `+`, generator, or build input, and consumes the same Rust 1.82 contracts everywhere in `Required`. Therefore `Covered(O-TAIL) = Covered(O-WRAP) = Required`, and their intersection contains `Required`.
+
+## `F-1` — safe trait implementation makes `increment` UB
+
+**Implementation defect; proof artifact missing.** A downstream crate can use only safe Rust:
+
+```rust
+struct Oob;
+impl Slot for Oob { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+This is a well-typed, valid use: `Slot` is a public safe trait, its method has no contract or enforced range, and the safe `increment` signature imposes no safety precondition. The call reaches line 16; `Oob::index()` is 2, while the receiver length is 2, so the exact required proposition `index < len` is false. The quoted Rust 1.82 safety clause entails UB at the call itself. Literal `2`, array length 2, and the unconditional source path make the same witness available on every `Required` target/profile. This completes the existential **UNSOUND** certificate; it is not merely a failed universal proof. No UB-free postcondition refutation is needed or claimed. A comment or undocumented request to implementors cannot resolve it.
+
+## TCB and evidence
+
+`R029-TCB-1` contains only verified authoritative Rust 1.82 standard-library axioms: `AX-BOUNDS`, the quoted out-of-bounds UB clause consumed by `F-1`/`P-TAIL`; and `AX-WRAP`, the quoted modular-addition guarantee consumed by `P-TAIL`. Exact identities are the two versioned links above; scope is every target where those items exist. There are no admitted dependency, implementation, tool, environment, compatibility, or external assumptions. No tests, execution, compilation, expansion, or tool-derived evidence was used. Re-audit either axiom if its cited contract or the Rust version changes.
+
+## Preferred redesign (not a verdict on implemented code)
+
+The minimum required capability is one fixed operation, not an implementer-selected index. Delete `Slot` and `Tail`, remove the type parameter, and implement a concrete safe function:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed contract is: for every input `[a,b]`, normal return yields `[a, b.wrapping_add(1)]`; it has no caller safety precondition. The fixed array type and literal index keep selection local, safe indexing removes the unsafe contract entirely, and `wrapping_add` supplies the required overflow behavior. There is no invariant-bearing representation or implementer boundary to trust. Removing the nominal `Tail` type is intentional: the stated requirement retains only its operation, not nominal identity.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls, downstream `Slot` implementations, and references to `Slot`/`Tail` stop compiling; the request explicitly authorizes all of those public-contract changes and says the abstraction is unreleased. Required Tail-observable behavior is unchanged.
+
+This candidate is **not implemented and has no audit verdict**. After implementation, audit the exact new snapshot independently: confirm the old trait/type/generic and unchecked call are absent; inventory any actual reexports or callers; verify the stated normal-return postcondition and no hidden panic path for the fixed length; re-establish the same target/profile closure under Rust 1.82; and recheck the `wrapping_add` citation. Source, contract, Rust version, support predicate, or newly introduced configuration/build machinery triggers re-audit. Binary/backend correctness and material not supplied in the target remain outside this source-level review.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/PACKET.json
new file mode 100644
index 0000000000..73ebd14112
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "1cef79dd2eaef588d2343439d0b1a54b816adebf188a59fc6349f45055872ea4",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "R",
+  "presentation_order": [
+    "A",
+    "J",
+    "G",
+    "B",
+    "F",
+    "I",
+    "C",
+    "E",
+    "D",
+    "H"
+  ],
+  "report_sha256": {
+    "A": "dac13c86e54c024ce799a6b3184e7c6d0e72cb9fdb3ce113aa7ef189c9b65630",
+    "B": "33f7ad5b9d6de92126d674c4b964e5d7ce46a3752b8883e324ce257ea928854f",
+    "C": "130367c76a139f7075e90837340f67fbb8411604f57a468cb3a30499bfc9a585",
+    "D": "745c8a81613a865eb7c42cf2f0b0d3c14f6e28b3aae745881d3a322e1fa409a3",
+    "E": "8a4870792d2b539f3f1adb115796eea44f36fc3c49d9c36d39996133f51502ad",
+    "F": "98fe0f05b276a3cd41156e7d3568f698c2232410faed435a32f8b27626172091",
+    "G": "034a581627624218f85a2e12af3590c9346c1227c7846bf28e3bacf75c8c7a5f",
+    "H": "c9e2ad98c41d88e0c379eff9f0c5b74f545076ca97483f05bbac2f1c46d1a1a4",
+    "I": "c29cf094b7026bbde11940bb1784b6393918115d74c5eec57207772ba46f0012",
+    "J": "ff506100d0e272b8bd653caab454d10845a938aee535aa0cb927869bc553b883"
+  },
+  "rubric_sha256": "a3e9b8d28e8b9d4eafc5f9c4b553d6b862a623b2f786e1e5e806ea212317bc18",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "d69df1b286abd8f7f8955ac56d702c1910eb596c0bd105b7998e39d7246ca063"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/RUBRIC.md
new file mode 100644
index 0000000000..17b4a752e1
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/RUBRIC.md
@@ -0,0 +1,67 @@
+# Mode R Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## R — abstraction redesign
+
+### Exact result
+
+Within the exact target/profile scope declared in `REQUEST.md`, `Required`
+includes every safe downstream implementation of `Slot` and safe instantiation
+of `increment`, not only the crate-owned `Tail`. A safe
+implementation can return 2. Calling `increment::<Bad>(&mut [0, 0])` then
+executes `get_unchecked_mut(2)` on a length-2 slice. The Rust 1.82.0 contract
+requires an in-bounds index and says an out-of-bounds call is UB even if the
+result is not used. The current safe API is therefore `UNSOUND`.
+
+The requested behavior needs neither generic pointer/index metadata nor an
+unsafe abstraction. A preferred redesign is a nongeneric safe function that
+updates `pair[1]` (or an equivalent checked safe specialization). It eliminates
+the caller implementation capability and the unsafe block. Making `Slot`
+unsafe, adding a prose rule to the safe trait, or preserving the generic
+abstraction by default is less parsimonious because no downstream generic use
+is required. The proposal does not affect the current verdict and needs a fresh
+audit after implementation.
+
+### Atoms
+
+- **R1:** Quantify over arbitrary safe `Slot` implementations; explicitly
+  construct or describe one returning 2 and the safe call using it.
+- **R2:** Prove reachability of `get_unchecked_mut(2)`, falsity of its in-bounds
+  precondition for length 2, and the applicable Rust 1.82 UB consequence.
+- **R3:** Report the current safe API `UNSOUND`, independently of design intent
+  and proposals.
+- **R4:** Extract the exact minimum required behavior: wrapping increment of
+  element 1 for the owned use, with no generic downstream implementation need.
+- **R5:** Propose a nongeneric safe specialization that implements the required
+  wrapping increment of element 1 using checked indexing (or an exactly
+  behavior-equivalent safe operation), with no caller-controlled
+  implementation or index capability.
+- **R6:** Explain that removing the unpublished generic trait/API is an
+  authorized contract delta with no promised downstream migration burden.
+- **R7:** Keep the redesign conditional and require implementation plus fresh
+  audit; do not use it to narrow or alter the current `UNSOUND` result.
+
+Merely making the trait unsafe does not pass R5: it preserves a caller
+implementation capability that the supplied requirement expressly does not
+need.
+
+### Hard errors
+
+Hard error if the report:
+
+- trusts `Tail` as the only safe implementation;
+- treats safe trait prose as a caller obligation;
+- calls the current API sound or merely `UNPROVED` after closing the witness;
+- certifies an unimplemented redesign; or
+- lets design intent narrow the current contract.
+
+### Authority
+
+- Rust 1.82.0 slice `get_unchecked_mut`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut`
+  — the index must be in bounds; out-of-bounds calls are UB even if the
+  resulting reference is unused.
+- Rust 1.82.0 `u32::wrapping_add`:
+  `https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add`
+  — wrapping modular addition supplies the requested update semantics.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/allowlist.txt
new file mode 100644
index 0000000000..7515068ad3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/allowlist.txt
@@ -0,0 +1,2 @@
+https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut
+https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/A.md
new file mode 100644
index 0000000000..2b619ac2f5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/A.md
@@ -0,0 +1,72 @@
+# Focused unsafe-Rust audit: `lib.rs`
+
+## Claim, snapshot, and verdict
+
+**Snapshot.** Exactly the supplied `lib.rs` (19 lines), with no expansion or generated artifact. The audit covers Rust and standard library 1.82.0, every target on which this source and the two used standard-library items exist, and every ordinary profile. The supplied source has no `cfg`, feature, dependency, FFI, allocator, concurrency, macro, or build-time branch. No prior audit or tool-derived evidence was used.
+
+**Soundness theorem.** Every well-typed safe use of the public items `Slot`, `Tail`, and `increment`, including caller-provided safe `Slot` implementations, must be free of Rust undefined behavior under the documented Rust 1.82 abstract semantics.
+
+**Verdict: UNSOUND.** `increment` is safe but its unchecked access requires a property that the open safe trait does not enforce. This holds throughout the supported set; profiles and targets do not alter the source, array length, index, or applicable Rust 1.82 contract.
+
+**Requested `Tail` behavior: PROVED.** Independently of the whole-surface verdict, for every input `pair`, `increment::<Tail>` returns with element 0 unchanged and element 1 equal to its prior value plus one modulo `2^32`.
+
+There are no source-documented postconditions. Consequently no `CONTRACT-BROKEN` verdict applies. The user-stated `Tail` requirement is reported separately as an explicit robustness requirement. The UB witness below is not used as a defined behavioral witness.
+
+## Boundary and obligation coverage
+
+| ID | Safe surface / proof site | Disposition |
+|---|---|---|
+| API-1 | Public safe trait `Slot` and safe required method `index() -> usize` | Downstream code may implement it; no bound or behavioral contract constrains the result. |
+| API-2 | Public unit struct/constructor `Tail`; crate impl of `Slot` | `index()` always returns `1`; adequate for the requested path only. |
+| API-3 | Public safe generic `increment<S: Slot>` | Accepts every valid `S: Slot`, then consumes `S::index()` in unsafe code; UNSOUND. |
+| OBL-1 | `pair.get_unchecked_mut(S::index())` | Requires the returned index to be in bounds. No check, type fact, sealed boundary, or trait contract establishes this for arbitrary `S`; refuted by WITNESS-1. |
+| OBL-2 | Same call for `S = Tail` | `Tail::index() = 1`, and `[u32; 2]` has indices 0 and 1; PROVED. |
+| OBL-3 | Tail update | The call returns a mutable reference to element 1; `wrapping_add(1)` computes modular addition; assignment writes that result to element 1. Element 0 is not selected; PROVED. |
+
+There is no owned invariant. The proposition `S::index() < 2` would be needed at API-3, but neither `Slot` nor module privacy establishes it. Proving it for the crate-owned producer `Tail` cannot be reversed into a fact about every implementation of the public trait.
+
+No public fields, unsafe declarations, hidden APIs, reexports, callbacks, custom `Drop`, or generated surfaces occur in the supplied source. The unsafe block has no adjacent `SAFETY` proof. Its proof artifact is therefore missing; more importantly, its general implementation obligation is false, so a comment alone cannot repair it.
+
+## Finding F-1 — safe downstream implementation reaches UB
+
+A valid safe caller can write:
+
+```rust
+struct Oob;
+impl Slot for Oob {
+    fn index() -> usize { 2 }
+}
+
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+The caller contains no unsafe operation and violates no contract: `Slot` is a public safe trait and specifies no restriction. `pair` has length 2, hence index 2 is out of bounds. AX-1 states that calling `get_unchecked_mut` with such an index is UB even if its returned reference is unused. The UB occurs at the unchecked call, before wrapping arithmetic. This is a concrete valid-use witness on every in-scope configuration.
+
+**Minimum current-API repair:** enforce the bound before unsafe use, or change the implementer boundary to a sufficient compiler-enforced unsafe/sealed contract and audit every implementation and consumer. Given the authorized requirements, both retain unnecessary machinery; the specialization below is preferable.
+
+## TCB log TCB-R1
+
+Trust policy: only exact authoritative Rust 1.82 standard-library propositions may be consumed. There are no additional assumptions, dependencies, external specifications, compiler-implementation premises, or tools.
+
+- **AX-1 (accepted, Rust axiom):** Rust 1.82 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut), all in-scope targets/profiles: it “Returns a mutable reference to an element or subslice, without doing bounds checking,” and “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumers: OBL-1, OBL-2, F-1.
+- **AX-2 (accepted, Rust axiom):** Rust 1.82 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add), all in-scope targets/profiles: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” Consumer: OBL-3 and the redesign contract.
+
+Both pages were opened at their exact versioned URLs and checked in context. Re-audit their consumers if those contracts or the Rust version changes.
+
+## Preferred redesign
+
+Remove the unused generic capability and all unsafe code:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    let value = &mut pair[1];
+    *value = value.wrapping_add(1);
+}
+```
+
+**Contract.** This is a safe function with no caller safety precondition. It returns normally with `pair[0]` unchanged and `pair[1] = old(pair[1]).wrapping_add(1)`, equivalently addition modulo `2^32`. The fixed array type makes index 1 locally in bounds; ordinary checked indexing removes the unchecked-operation obligation. AX-2 supplies the arithmetic postcondition. There is no representation invariant, implementer promise, unsafe surface, or additional TCB premise.
+
+**Migration delta.** Delete public `Slot`, `Tail`, the type parameter, and the unsafe block. Change `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Downstream `Slot` implementations and generic calls cease to compile, exactly as authorized; the abstraction is unreleased, so no compatibility commitment is retained. The required observable `Tail` behavior is unchanged.
+
+This is a design proposal, not a verdict for a new artifact. After implementation, freshly audit the exact new source: confirm the old trait/type/generic and all reexports or generated copies are absent; verify Rust 1.82 checked access and AX-2 over the full target/profile set; prove both-element postconditions and all exits; and inventory any surrounding code introduced with the change. Source, API, support-set, or cited-contract changes trigger re-audit.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/B.md
new file mode 100644
index 0000000000..c092e7d612
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/B.md
@@ -0,0 +1,126 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the supplied `lib.rs`, exactly as inspected; no expansion,
+execution, tests, dependencies, generated artifacts, features, or prior audit
+were used. Scope is Rust and standard library 1.82.0, every target on which this
+source and its used standard-library items exist, and every ordinary profile.
+
+Let `D` be exactly that configuration predicate. Valid use of each safe public
+API means every well-typed safe use, including caller-chosen implementations of
+the safe `Slot` trait. The source-level claims are:
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every safe use of the exposed API is free of Rust UB over `D`. | **UNSOUND** | `F-1` gives a valid safe use, reaches the unsafe operation, falsifies its bounds precondition, and reaches the documented UB consequence. |
+| For every `pair`, `increment::<Tail>` changes element 1 to its prior value plus 1 modulo `2^32` and leaves element 0 unchanged, over `D`. | **PROVED** | `P-TAIL` below; `D ⊆ CoveredTail = D`. |
+
+The overall current-artifact soundness verdict is **UNSOUND**. The redesign
+proposal below does not qualify or alter it. There is no separate
+`CONTRACT-BROKEN` finding: the requested `Tail` behavior holds, and the source
+contains no other documented postcondition.
+
+## Boundary and inventory
+
+The complete relevant public surface is: safe trait `Slot`; its safe required
+associated function `index`; the public unit struct/constructor `Tail`; its safe
+`Slot` implementation; and safe generic free function `increment`. A downstream
+crate may implement `Slot` without `unsafe`. There are no unsafe public APIs,
+fields, hidden items, macros, callbacks, FFI, dependencies, or persistent
+representation invariants. `increment` contains the sole unsafe operation,
+`get_unchecked_mut(S::index())`, with no adjacent `SAFETY` proof.
+
+The only local invariant-like fact is `ARRAY-2`: the borrowed array has exactly
+two elements, hence valid scalar indices are `0` and `1`. `Tail::index()`
+locally establishes `INDEX-TAIL = 1`. No type or boundary establishes
+`S::index() < 2` for arbitrary `S: Slot`.
+
+## Obligations and proofs
+
+The Rust 1.82 slice contract says that `get_unchecked_mut` returns a mutable
+reference without bounds checking and that calling it with an out-of-bounds
+index is UB, even if the reference is unused
+([slice documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)).
+Thus obligation `O-BOUNDS` is `S::index() < 2` at the call for every safe
+instantiation. The Rust 1.82 integer contract says `wrapping_add` performs
+modular addition, wrapping at the type boundary
+([u32 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)).
+
+**F-1 — open safe trait makes `increment` unsound.** A downstream safe program
+may write:
+
+```rust
+struct Outside;
+impl Slot for Outside { fn index() -> usize { 2 } }
+let mut pair = [0u32, 0u32];
+increment::<Outside>(&mut pair);
+```
+
+This uses no unsafe caller operation and violates no documented or
+compiler-enforced caller obligation. Dynamic dispatch is not involved:
+`Outside::index()` returns `2`, so the safe call reaches
+`pair.get_unchecked_mut(2)`. By `ARRAY-2`, `2` is out of bounds. The cited
+contract makes the call itself UB. The witness is parametric over `D`: the
+literal `2`, array length, trait implementation, and callee selection are
+profile- and target-independent wherever the source/items exist. This closes
+every link of the `UNSOUND` certificate. The missing safety comment is also a
+proof-artifact defect, but documentation cannot repair this safe boundary.
+
+**P-TAIL — requested behavior.** For `S = Tail`, inspected code gives
+`S::index() = 1`; `ARRAY-2` gives `1 < 2`, discharging `O-BOUNDS`. The cited
+slice contract therefore identifies the returned mutable reference with
+element 1. If its old value is `x`, the cited integer contract gives
+`x.wrapping_add(1) = (x + 1) mod 2^32`; assignment stores that result through
+the element-1 reference. No operation targets element 0. This one parametric
+case applies to every input and every configuration in `D`, including overflow
+and all ordinary profile settings.
+
+## Domain closure and TCB log
+
+`Required = D` comes verbatim from the request; no range normalization,
+enumeration, exclusion, or moving policy is used. Actual axes are target and
+ordinary profile. There is one handwritten implementation with no `cfg`; both
+proofs above are parametric over those axes. Therefore the unsound witness and
+`P-TAIL` each cover all of `D`. Audit cutoff is 2026-08-01 and only freezes the
+inspected source and fixed-version documentation.
+
+TCB `TCB-1` contains only two verified authoritative Rust 1.82 axioms: (A1) the
+quoted `get_unchecked_mut` contract, consumed by `F-1` and `P-TAIL`; and (A2) the
+quoted `wrapping_add` contract, consumed by `P-TAIL`. Both apply over `D` by its
+definition. No additional assumptions, safe/unsafe dependencies, compiler
+implementation claims, tools, external specifications, or deployment premises
+are admitted.
+
+## Preferred redesign
+
+Replace the generic abstraction with one concrete safe operation:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its contract is: for every input array, normal return leaves element 0 equal to
+its entry value and sets element 1 to its entry value plus 1 modulo `2^32`; it
+has no caller safety precondition. The fixed array type and safe indexing
+enforce selection of the required element, and `wrapping_add` supplies the
+arithmetic. There is no unsafe block, implementer contract, or representation
+invariant. `Slot` and `Tail` should be removed because nominal slot identity and
+extensibility supply no required capability.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)` and
+removes all `Slot` implementations and generic uses. This is an authorized
+source/API break: the request says the abstraction is unreleased and those
+surfaces need not be preserved. The required observable `Tail` behavior is
+unchanged.
+
+This is a design, not an implemented-artifact verdict. After implementation,
+fresh review must inspect the exact new snapshot; enumerate its complete public
+surface; prove safe index `1` is in bounds for `[u32; 2]`; prove the modular
+write and preservation of element 0 for every input; re-establish `D ⊆
+Covered`; and check that no conditional/generated alternative or remaining
+unsafe/generic surface exists. Re-audit is also required for any source,
+contract, Rust version, support-domain, or relevant standard-library contract
+change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/C.md
new file mode 100644
index 0000000000..83ccfb4387
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/C.md
@@ -0,0 +1,62 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot and scope.** This is a source-only review of the complete supplied `lib.rs`, lines 1–18. The supported predicate is exactly Rust/standard library 1.82.0, every target on which this source and the used standard-library items exist, and every ordinary profile. There are no dependencies, `cfg` branches, features, generated artifacts, macros, FFI, allocation, concurrency, or build inputs in the supplied artifact. The proof is parametric over target and profile: array length `2`, values `1` and `2`, safe-trait openness, and the cited library contracts do not vary across that set. Audit date: 2026-08-01.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces is free from Rust undefined behavior under Rust 1.82.0 abstract semantics. **Verdict: UNSOUND** (`F-1`) over the entire supported predicate. The safe generic API admits an out-of-bounds unchecked access.
+
+**Requested Tail behavior.** For every initial `pair == [a, b]`, `increment::<Tail>(&mut pair)` returns with `pair == [a, b.wrapping_add(1)]`. **Verdict: PROVED** (`O-2`) over the entire supported predicate. This regional behavioral result does not qualify the soundness verdict. The source documents no caller-facing postcondition, so there is no separate source-documented postcondition to classify as `CONTRACT-BROKEN`.
+
+**Combined current-artifact result: UNSOUND.** No proposal below participates in this verdict.
+
+## Boundary and obligation coverage
+
+The complete public surface is: safe, downstream-implementable trait `Slot` and safe associated function `Slot::index` (lines 3–5); publicly constructible unit struct `Tail` (line 7); its safe `Slot` implementation (lines 9–13); and safe generic function `increment<S: Slot>` (lines 15–18). The sole unsafe operation is the internal `get_unchecked_mut` call at line 16. There are no fields, unsafe declarations/impls, hidden APIs, callbacks, custom `Drop`, or generated surfaces. Ordinary compiler-provided moves, destruction, and auto traits carry no state and do not affect the finding.
+
+| ID | Exact obligation and derivation | Status |
+|---|---|---|
+| O-1 | A safe call to `increment::<S>` must establish `S::index() < 2` before line 16 for every safe `S: Slot`. The trait type/signature and source perform no check and enforce no such behavior. | **False; UNSOUND (F-1)** |
+| O-2 | For `S = Tail`, line 11 yields `1`; a `[u32; 2]` has indices `0,1`, so the unchecked call is in bounds and selects element 1. `wrapping_add(1)` computes its modular successor, which line 17 stores through that exclusive reference. Only element 1 is targeted. | **PROVED** |
+| O-3 | The unsafe block needs an adjacent proof of O-1. It has no `SAFETY` comment, and no truthful proof exists for its generic domain. The O-2 reconstruction validates only the Tail specialization and cannot retroactively narrow the safe API. | **Proof artifact deficient; implementation globally UNSOUND** |
+| O-4 | Configuration closure: F-1 uses index `2`, representable on every supported target, against an array of invariant length `2`; O-2 uses index `1`. No profile-dependent assertion, overflow operation, or code selection occurs. | **Complete** |
+
+There is no enforceable representation invariant. The needed proposition “all `Slot` implementations return an index below 2” has no owner or sealing boundary and is disproved by F-1.
+
+## TCB audit log `TCB-R028-r1`
+
+Policy: only exact Rust 1.82.0 Reference/standard-library axioms may be consumed; no additional assumptions, dependencies, tools, tests, implementation behavior, or compatibility premise is admitted.
+
+* **AXIOM-SLICE-1 (accepted):** for Rust 1.82.0 on the supported set, `slice::get_unchecked_mut` returns the indexed mutable reference without bounds checking, and: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82.0 `get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut). Consumers: O-1, O-2, F-1. Recheck if the Rust version or contract changes.
+* **AXIOM-U32-1 (accepted):** for Rust 1.82.0 on the supported set, `u32::wrapping_add` is “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82.0 `wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add). Consumer: O-2 and the proposed contract. Recheck if the Rust version or contract changes.
+
+No tool-derived evidence or sampled execution was used. Both citations were opened at the exact version. No premise is pending or rejected.
+
+## F-1 — safe implementer controls an unchecked index
+
+**Classification:** implementation `UNSOUND`; proof artifact missing. `Slot` is a public safe trait, so well-typed safe downstream code may implement it with any `usize` result:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+This is a valid safe use. `Bad::index()` returns `2`; for length 2 that is out of bounds. AXIOM-SLICE-1 therefore makes the call at line 16 UB immediately, independently of later dereference. This witness applies to every supported target and profile. No UB-free postcondition refutation is claimed from this execution. Minimum resolution is to remove the unchecked generic access, validate the index before unsafe use, or enforce implementer behavior at an actual unsafe/sealed boundary. Given the stated requirement, specialization is smaller and removes the premise entirely.
+
+## Preferred redesign (not implemented; no fresh verdict)
+
+Use one monomorphic safe function and delete `Slot` and `Tail`:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed contract is: no caller safety precondition; for every `[a,b]`, normal return produces `[a, b.wrapping_add(1)]`. The fixed array type and safe constant indexing enforce access to element 1; AXIOM-U32-1 supplies the arithmetic postcondition. There is no unsafe surface, implementer obligation, representation, or abstraction invariant. Making `Slot` unsafe, sealing it, or retaining a checked generic index would preserve genericity that no required consumer needs.
+
+**Migration/contract delta.** Remove the public trait, its downstream implementation capability, `Tail`, and the type parameter. Replace `increment::<Tail>(&mut pair)` with `increment(&mut pair)`. Generic calls and downstream `Slot` implementations intentionally cease to compile, as authorized for this unreleased abstraction. The required Tail-observable mutation is unchanged; the new explicit function contract strengthens the previously undocumented behavioral surface.
+
+After implementation, audit the new snapshot independently: enumerate its actual public surface; verify constant array indexing and wrapping semantics for Rust 1.82.0; prove the complete mutation/postcondition and panic behavior for every input; re-establish target/profile closure; and confirm that no conditional/generated code or unsafe operation was introduced. Source, public-contract, supported-set, or cited Rust-contract changes trigger re-audit. Nothing outside the supplied file was audited.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/D.md
new file mode 100644
index 0000000000..c651b97bb2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/D.md
@@ -0,0 +1,154 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Audited artifact.** Exact `lib.rs` with SHA-256
+`b2d9d02f117745925aa24c5b09461c200c3f36f1d1e026c1f289f971711dc122`,
+under `REQUEST.md` SHA-256
+`2d044b4aa4dca16c51aeedd3bd9db58d182a0929e6b73a98478fdc2710094b8f`.
+No generated source, dependencies, macros, FFI, or configuration branches occur
+in the inspected artifact. Audit date: 2026-08-01. Unsafe-Rust skill identity:
+`SKILL.md` SHA-256
+`a0a75ef8a14497aa78b50b459981097ee99605c57fec95c637cf59aaa20fe766`.
+
+**Supported set.** Exactly Rust and standard library 1.82.0; every target on
+which this source and its used standard-library items exist; every ordinary
+profile. This predicate comes directly from `REQUEST.md`. The proof and witness
+below are parametric in target and profile: the source has no `cfg`, profile,
+layout, pointer-width, panic-strategy, or generated-code branch relevant to
+them.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces is free
+of Rust undefined behavior under Rust 1.82's documented abstract semantics,
+with no caller-side safety precondition and no additional TCB assumptions.
+
+**Verdicts.**
+
+- Current-artifact soundness: **UNSOUND** over the entire supported set
+  (`F-1`).
+- Requested restricted behavior: **PROVED** for
+  `increment::<Tail>(&mut pair)`: if the input is `[a, b]`, normal return leaves
+  `[a, b.wrapping_add(1)]`, over the entire supported set (`P-2`).
+- Source-documented postconditions: none. Consequently there is no
+  `CONTRACT-BROKEN` finding. The user-requested `Tail` behavior is a separate
+  reviewed requirement, not a retroactive restriction on the current generic
+  safe API.
+- Combined current-artifact result: **UNSOUND**, irrespective of the redesign.
+  There is no conditional application claim.
+
+## Boundary and configuration coverage
+
+The complete public surface is: safe, downstream-implementable trait `Slot`
+and its safe associated function `index` (`lib.rs:3-5`); constructible unit
+struct `Tail` (`lib.rs:7`); the crate-owned safe `Slot for Tail` implementation
+returning `1` (`lib.rs:9-13`); and safe generic function `increment`
+(`lib.rs:15-18`). `increment` contains the sole unsafe operation. There are no
+fields, unsafe declarations/impls, hidden items, callbacks, reexports, or
+generated APIs. `Tail` carries no representation invariant. The relevant
+cross-call proposition would have to be an invariant of every `S: Slot`, but
+the safe trait boundary enforces none.
+
+Because both the counterexample and the `Tail` proof depend only on a
+two-element array, integer indices `1`/`2`, and the cited 1.82 contracts, they
+cover every target/profile in the supported predicate without enumeration.
+No test, build, execution, or tool-derived evidence was used.
+
+## TCB audit log `TCB-R011-1`
+
+No additional assumptions are admitted. These two accepted Rust 1.82
+authoritative axioms are the complete consumed TCB:
+
+- **AXIOM-GET.** For `slice::get_unchecked_mut`, an in-bounds index selects and
+  returns a mutable reference to that element; the Safety section states:
+  “Calling this method with an out-of-bounds index is undefined behavior even
+  if the resulting reference is not used.”
+  [Rust 1.82 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut).
+  Consumers: `P-1`, `P-2`. Re-audit if the Rust version or contract changes.
+- **AXIOM-WRAP.** `u32::wrapping_add` performs modular addition, wrapping at the
+  type boundary.
+  [Rust 1.82 documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add).
+  Consumer: `P-2`. Re-audit if the Rust version or contract changes.
+
+Both exact pages were opened and their wording and version checked. There are
+no dependency, environment, implementation, probabilistic, or tool entries;
+no rejected or pending premises; and no prior audit was reused.
+
+## Obligation ledger and proofs
+
+**P-1 — unsafe call precondition: FAILED / UNSOUND.** At `lib.rs:16`, every
+executed `S::index()` must be in `0..2`; AXIOM-GET makes an out-of-bounds call
+UB. Neither `S: Slot` nor the safe trait contract constrains the result. A
+well-typed, entirely safe downstream witness is:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+The call reaches `get_unchecked_mut(2)` on a length-two array, hence UB by
+AXIOM-GET. The smallest false implication is
+`S: Slot => S::index() < 2`. A safe caller cannot be assigned this undocumented
+obligation.
+
+**P-2 — crate-owned `Tail` behavior: PROVED.** `Tail::index()` returns `1`
+(`lib.rs:11`); a `[u32; 2]` has indices `0` and `1`, so AXIOM-GET's bound is
+satisfied and the returned reference designates element 1. The only write is
+through that reference. AXIOM-WRAP proves the new value is the old value plus
+one modulo `2^32`; element 0 is untouched. This derivation is target- and
+profile-independent.
+
+**Proof artifact.** The unsafe block has no adjacent `SAFETY` proof. This is a
+missing proof artifact as well as an implementation defect: no truthful local
+comment can derive P-1 for the current generic safe contract. Documentation
+alone cannot repair it.
+
+## F-1 — unconstrained safe implementer controls an unsafe index
+
+- **Status/severity:** **UNSOUND / critical**; affects `increment` and the
+  aggregate safe-surface theorem on every supported configuration.
+- **Defect:** a caller-provided implementation of a safe trait supplies the
+  safety-critical bound without validation, sealing, or an unsafe implementer
+  contract.
+- **UB witness:** the safe `Bad` program above. **Defined postcondition
+  refutation:** not established or needed; the witness contains UB.
+- **Minimum resolution:** eliminate the unchecked operation, validate the
+  index, or enforce an implementer boundary. Merely adding a comment is
+  insufficient.
+
+## Recommended redesign
+
+The most parsimonious abstraction is no generic abstraction at all:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed safe contract has no precondition beyond a well-typed mutable
+borrow. For input `[a, b]`, it returns with `[a, b + 1 mod 2^32]`. The fixed
+array type and constant safe index enforce selection locally; AXIOM-WRAP
+supplies the arithmetic result. It removes the unsafe block, the behavioral
+implementer premise, the invariant fan-out, and all need for `Slot` and `Tail`.
+
+**Migration delta.** Delete public `Slot` and `Tail`; change
+`increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls and
+downstream `Slot` implementations cease to exist. This is a public breaking
+change, expressly authorized because the abstraction is unreleased and those
+uses need not be preserved. Required `Tail` behavior is unchanged.
+
+The proposal is not implemented and has no artifact verdict. After
+implementation, freshly audit the exact snapshot: enumerate its public
+surface; verify the fixed index, modular result, and preservation of element
+0; confirm absence of unsafe/generated/configuration-dependent paths; and
+re-establish Rust-1.82 target/profile closure. Re-audit on any source, API,
+support-predicate, or consumed standard-library-contract change.
+
+## Residual scope
+
+This is a source-level review of exactly the supplied files, not a compiler,
+backend, binary, or broader-crate certification. No authoritative-documentation
+or skill-guidance gap blocked the result. The unimplemented redesign remains
+outside the current-artifact verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/E.md
new file mode 100644
index 0000000000..bd10f0e665
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/E.md
@@ -0,0 +1,90 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: `lib.rs`, SHA-256 `b2d9d02f117745925aa24c5b09461c200c3f36f1d1e026c1f289f971711dc122`; request SHA-256 `2d044b4aa4dca16c51aeedd3bd9db58d182a0929e6b73a98478fdc2710094b8f`. Scope is exactly this source, under documented Rust abstract semantics. No source was executed or expanded; no generated artifacts, dependencies, `cfg`s, features, FFI, concurrency, or allocator behavior occur in the supplied artifact.
+
+`DOMAIN-R1` is preserved directly from the request:
+
+> Rust and standard library exactly 1.82.0; every target on which this exact source and its used 1.82.0 standard-library items exist; every ordinary profile.
+
+Other Rust releases, targets where those conditions fail, nonordinary profiles, compiler/backend correctness, and any wider crate are excluded. Audit cutoff: 2026-08-01; it does not broaden the fixed version.
+
+- **CLAIM-SOUND — UNSOUND.** The public safe generic `increment<S: Slot>` is not sound for all well-typed safe uses. `F-1` below supplies a valid safe witness, reachability, a false unsafe precondition, and the authoritative UB consequence. The witness is parametric over every configuration in `DOMAIN-R1`.
+- **CLAIM-TAIL — PROVED.** For every initial `[a, b]: [u32; 2]` and every configuration in `DOMAIN-R1`, `increment::<Tail>` is UB-free and returns with `[a, b.wrapping_add(1)]`. `P-TAIL` below proves this requested behavior independently of the redesign.
+- **Combined current-artifact result: UNSOUND.** There is no source-authored documented generic postcondition. The UB-containing witness is not used to claim `CONTRACT-BROKEN`.
+
+TCB log `TCB-R1` contains only the two accepted Rust 1.82 authoritative axioms below; there are no additional admitted assumptions, dependency facts, implementation claims, or tool results.
+
+## Boundary, invariants, and obligation ledger
+
+The complete relevant language-reachable surface is: public safe trait `Slot` and its safe implementer-provided static method `index`; public constructible unit struct `Tail` and its safe `Slot` impl; and public safe generic function `increment`. There are no fields, unsafe declarations/impls, macros, hidden items, callbacks other than `S::index`, or generated APIs in the supplied source. Downstream code may implement `Slot` for a downstream type because the trait is public and unsealed.
+
+No enforced invariant connects `Slot` to the two-element array. The tempting proposition `S::index() < 2` is neither type-enforced, checked, nor module-owned. Its producer is adversarial safe code (`S::index`); its consumer is `get_unchecked_mut`.
+
+| ID | Obligation | Status |
+|---|---|---|
+| O-1 | Every safe `increment::<S>` call avoids UB without a hidden caller/implementer safety condition. | **Refuted: F-1** |
+| O-2 | At the unsafe call, `S::index()` is in bounds for the length-2 slice. | **False generically; proved for `Tail`** |
+| O-3 | The returned reference denotes the selected element and is used within the exclusive `&mut` borrow. | **Proved when O-2 holds, by the method contract and types** |
+| O-4 | The stored value is old value plus one modulo the `u32` range. | **Proved by AX-WRAP** |
+| O-5 | Element 0 is unchanged for `Tail`. | **Proved: only the reference to element 1 is written** |
+
+The unsafe block has no adjacent `SAFETY` proof. This is a missing proof artifact, but documentation alone cannot repair O-1: prose on a safe trait cannot impose a soundness precondition on safe implementers.
+
+## Authoritative premises (`TCB-R1`)
+
+- **AX-SLICE (accepted AXIOM).** Rust 1.82 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut) returns a mutable reference to the indexed element/subslice without checking bounds and states: “Calling this method with an out-of-bounds index is undefined behavior.” Scope: every `DOMAIN-R1` use of this item. Consumers: O-2, O-3, F-1, P-TAIL.
+- **AX-WRAP (accepted AXIOM).** Rust 1.82 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add) specifies wrapping modular addition at the type boundary. Scope: every `DOMAIN-R1` use of this item. Consumers: O-4, P-TAIL.
+
+Both citations were opened at the exact version and fragment. Re-audit either entry if that exact documentation, source, or supported domain changes.
+
+## F-1 — complete UB certificate
+
+Downstream safe code can write:
+
+```rust
+struct Oob;
+impl Slot for Oob {
+    fn index() -> usize { 2 }
+}
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+**Valid use.** The trait and method are safe and public; the implementation and call are well-typed and contain no caller-written unsafe operation or violated documented obligation.
+
+**Reachability.** `Oob::index()` returns `2`; `increment` then executes `pair.get_unchecked_mut(2)` on the two-element array viewed as a slice of length 2.
+
+**False safety proposition.** Its valid element indices are 0 and 1, so index 2 is out of bounds.
+
+**Consequence.** AX-SLICE says that this call itself has undefined behavior, even independently of later reference use. Thus one valid safe use reaches an executed operation whose required proposition is false and whose applicable contract entails UB. The same construction uses no target- or profile-dependent fact, so it witnesses every member of `DOMAIN-R1`.
+
+Minimum repair requires enforcing the bound before the unsafe call, making an implementer obligation compiler-enforced, or removing the unnecessary extensibility. The last is preferred below.
+
+## P-TAIL — requested-behavior proof and configuration closure
+
+`Tail::index()` is locally and unconditionally `1`. The input type fixes length at 2, hence 1 is in bounds. AX-SLICE therefore supplies a mutable reference to element 1. The subsequent assignment reads that element, applies AX-WRAP with operand 1, and writes only through that reference; element 0 is untouched. This proves UB freedom and the exact `[a, b] -> [a, b.wrapping_add(1)]` postcondition for all `u32` values.
+
+The source has no conditional compilation or profile-sensitive arithmetic: unchecked indexing's contract and modular addition apply parametrically across the request's target/profile predicate. Thus `Covered(CLAIM-TAIL) = DOMAIN-R1`, proving `Required ⊆ Covered`. For CLAIM-SOUND, F-1 applies parametrically across the same domain; no configuration remainder can weaken its `UNSOUND` verdict.
+
+## Preferred redesign
+
+Replace the trait, marker, generic dispatch, and unsafe operation with one specialized safe function:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    let tail = &mut pair[1];
+    *tail = tail.wrapping_add(1);
+}
+```
+
+Its proposed public contract has no safety precondition: on normal return, element 0 equals its entry value and element 1 equals its entry value plus one modulo `u32`. It has no invariant-bearing representation, downstream implementer contract, generic capability, or unsafe proof site. Fixed index 1 is valid by the array's type; `wrapping_add` supplies the requested arithmetic. This is the minimum capability actually required.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. `Slot`, downstream `Slot` implementations, generic calls, and the nominal `Tail` marker disappear. Those are breaking source/contract changes, explicitly authorized because the abstraction is unreleased and none must be preserved. No caller safety obligation is transferred.
+
+This is a design, not a verdict for a new artifact. After implementation, freeze and audit that exact snapshot anew: re-inventory every exposed/reexported/generated surface; verify the fixed-index operation for `[u32; 2]`, borrow/dataflow, AX-WRAP postcondition, both elements' outcomes and every exit; confirm no unsafe or hidden extensibility remains; and re-establish parametric `DOMAIN-R1` closure. Any changed signature, documentation, configuration, generated code, standard-library contract, or Rust version triggers re-audit.
+
+## Residual attestation
+
+Every in-scope surface and unsafe obligation has a disposition above. No test or absence of counterexamples supports either verdict. No independent second review was performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/F.md
new file mode 100644
index 0000000000..2daf3a9a34
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/F.md
@@ -0,0 +1,67 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, domain, and verdicts
+
+**Snapshot and scope.** This is a source-level review of `lib.rs` exactly as supplied. The in-scope boundary is its public `Slot`, `Tail`, and `increment` items and the single unsafe operation inside `increment`. No generated artifacts, dependencies other than Rust 1.82.0 `std`, or tool-derived evidence were supplied or used; the source was not built, tested, executed, or expanded.
+
+Let
+
+`Required(r,t,p) := (r = Rust/stdlib 1.82.0) && source-and-used-items-exist(t) && ordinary-profile(p)`.
+
+This preserves the request's target and profile predicates symbolically. There are no `cfg`s, features, generators, FFI, assembly, allocator choices, concurrency, profile-dependent assertions, or ordinary overflowing `+` operations in the source. Both proofs below are parametric in `t` and `p`; thus no finite target/profile inventory is assumed.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe use of the current public surface is free of Rust UB over `Required` | **UNSOUND** | `F-1` gives a valid safe call that executes `get_unchecked_mut(2)` on a length-2 array; this is UB. The witness works throughout `Required`. |
+| For every initial `[a,b]`, current `increment::<Tail>` returns with `[a, b+1 mod 2^32]` without UB over `Required` | **PROVED** | `P-TAIL` below; aggregate `Covered = Required`, so `Required ⊆ Covered`. |
+
+The combined current-artifact soundness result is **UNSOUND**. The proved `Tail` subcase neither narrows the current safe generic API nor changes that verdict. There is no source-documented postcondition for generic `increment`; the second claim is the behavior expressly required by the request.
+
+**TCB-1.** No additional TCB assumptions are admitted. The only ground premises are these verified, version-exact authoritative standard-library axioms:
+
+- `AXIOM-BOUNDS`: Rust 1.82.0 says, “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” It also says the method returns a mutable reference to the indexed element/subslice. [slice::get_unchecked_mut](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)
+- `AXIOM-WRAP`: Rust 1.82.0 specifies modular addition, “wrapping around at the boundary of the type.” [u32::wrapping_add](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)
+
+These axioms apply to every member of `Required` by construction (exact Rust/stdlib version, and only targets where the items exist).
+
+## Boundary, invariants, and obligation ledger
+
+The complete crate-owned surface is: public safe trait `Slot`; its safe implementer-controlled `index() -> usize`; publicly constructible unit struct `Tail`; the safe `Slot for Tail` impl returning `1`; and public safe generic function `increment<S: Slot>`. There are no unsafe declarations, fields, impls, macros, hidden items, callbacks, or explicit constructors beyond the unit-struct constructor. Downstream safe code may implement `Slot` for a downstream-local type. No invariant enforces `S::index() < 2`; documentation cannot supply a hidden safety precondition to either safe boundary.
+
+| ID | Proposition and disposition |
+|---|---|
+| `O-OPEN` | Every safe `Slot` implementation used by `increment` must return an index below 2. **False:** neither the type nor validation, privacy, or sealing enforces it. |
+| `O-BOUNDS` | At the unsafe call, `S::index()` must be in `0..2`. **False in general** by `F-1`; true for `Tail`. |
+| `O-TAIL` | `Tail::index() = 1` and `1 < 2`. **Proved directly from the impl and array type.** |
+| `O-POST` | The selected element receives old value plus one modulo `2^32`. **Proved for `Tail`** from `O-TAIL`, the returned-reference postcondition, assignment, and `AXIOM-WRAP`. |
+
+`P-TAIL`: for input `[a,b]`, the inspected impl makes the index exactly `1`; a `[u32; 2]` has indices `0` and `1`. `AXIOM-BOUNDS` therefore is not violated, and `get_unchecked_mut` returns a mutable reference to element 1. `wrapping_add(1)` produces `b+1 mod 2^32`; assignment writes that value only to element 1, leaving element 0 as `a`. These facts do not vary by target or ordinary profile.
+
+The unsafe block has no adjacent `SAFETY` proof. That proof artifact is missing, but prose cannot repair the false generic obligation; the implementation must change or the implementer set must be enforced.
+
+## F-1 — open safe trait makes the safe function unsound
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+This is a well-typed, entirely safe downstream use: `Slot` and its method are safe and public, and the implementation uses a downstream-local type. The call reaches the unsafe operation because `Bad::index()` returns normally. The exact required proposition is `2 < pair.len()`; it is false because `pair.len() = 2`. `AXIOM-BOUNDS` then entails UB at the call itself, even before any use of the returned reference. This completes the existential `UNSOUND` certificate for every `Required` configuration. No separate UB-free postcondition refutation is claimed.
+
+## Recommended provable abstraction
+
+The minimum capability is not implementer-selected indexing; it is one fixed transformation. Delete `Slot`, `Tail`, their impl, and the generic parameter, and implement only:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+**Proposed contract.** This safe function has no caller-side safety precondition beyond a well-typed `&mut [u32; 2]`. On return, element 0 equals its old value and element 1 equals its old value plus one modulo `2^32`. It has no representation invariant or unsafe surface. Constant safe indexing is within the type-enforced length; even an indexing defect would panic rather than create an unchecked reference.
+
+**Migration/contract delta.** Replace `increment::<Tail>(&mut pair)` with `increment(&mut pair)`. Remove construction/naming of `Tail`, downstream `Slot` implementations, and generic calls; the request explicitly permits all of these breaking source/API changes and states the abstraction is unreleased. The required `Tail` behavior is unchanged, while unsupported extensibility and its hidden range obligation disappear.
+
+This is an unimplemented proposal, not a `PROVED` new artifact. After implementation, freshly audit the exact snapshot: enumerate remaining exports/reexports/generated surfaces; verify all old generic paths are gone; prove both output clauses and any promised panic behavior from applicable Rust 1.82.0 contracts; re-establish `Required ⊆ Covered`; and recheck that no unsafe operation or invariant remains. Re-audit on source/API changes, Rust or support-domain changes, newly generated surfaces, or material changes to either consumed standard-library contract.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/G.md
new file mode 100644
index 0000000000..3dce4d872a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/G.md
@@ -0,0 +1,74 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot.** Exact supplied `lib.rs`; no expansion, execution, tests, dependencies, generated artifacts, or prior audit were used. Audit date: 2026-08-01. Scope is Rust and standard library 1.82.0, every target on which this exact source and its used standard-library items exist, and every ordinary profile. The source has no `cfg`, feature, target, generator, FFI, allocator, concurrency, or dependency branch. Profile-dependent overflow checks are immaterial because the code explicitly uses wrapping arithmetic.
+
+**Soundness theorem.** Every well-typed safe use of the public surfaces must be free of Rust undefined behavior, with no caller safety precondition, over that supported set.
+
+**Current-artifact soundness verdict: UNSOUND (F-1).** The result is universal across the supported set; a safe downstream trait implementation can select an out-of-bounds index.
+
+**Required `Tail` behavior: PROVED.** For every initial `pair == [a, b]`, `increment::<Tail>(&mut pair)` returns without UB with `pair == [a, b.wrapping_add(1)]`. This requested behavior is not a source-documented postcondition, so there is no separate `CONTRACT-BROKEN` result. The overall safe API remains `UNSOUND` despite this regional proof.
+
+**TCB:** `TCB-1` below. It contains only verified Rust 1.82.0 standard-library axioms and no additional admitted assumptions. Conditional application claims: none.
+
+## Boundary, invariants, and obligation ledger
+
+Public safe surfaces are: implementable trait `Slot`; safe associated function `Slot::index`; constructible unit struct `Tail`; its safe `Slot` implementation; and safe generic free function `increment<S: Slot>`. The sole unsafe operation is the internal `get_unchecked_mut` call. There are no unsafe public APIs, fields, macros, hidden items, or generated surfaces in the supplied source. Ordinary unit-struct construction and auto traits do not supply an index-range guarantee.
+
+No enforced invariant exists. The needed proposition, `S::index() < 2`, cannot be an invariant of all `S: Slot`: the safe public trait permits caller-controlled implementations and its method has neither a type-enforced restriction nor validation.
+
+| ID | Location | Exact obligation | Status |
+|---|---|---|---|
+| O-1 | `increment`, unchecked projection | The particular returned index is in bounds for the two-element slice before `get_unchecked_mut` is called. | **False** for general `S`; F-1. |
+| O-2 | `increment::<Tail>` | `Tail::index() == 1` and `1 < 2`. | **PROVED** directly from the implementation and array length. |
+| O-3 | mutation | On the Tail path, write the old second value plus one modulo the `u32` range, leaving element 0 unchanged. | **PROVED** from O-2, exclusive `&mut` access, A-1, and A-2. |
+| O-4 | configuration closure | O-1--O-3 cover every requested target/profile. | **PROVED** parametrically: the fixed length, constants, and cited 1.82 contracts do not vary across this source's supported set. |
+
+For the Tail derivation, method evaluation yields `1`; the receiver has length two, so A-1's only stated safety condition is met. The resulting mutable reference designates element 1 and is used within the exclusive borrow without intervening caller code. A-2 makes the computed value `(b + 1) mod 2^32`; assignment changes only that element. No material derivation is present in the source: the unsafe block has no adjacent `SAFETY` proof. More importantly, no comment could prove O-1 for arbitrary safe implementations.
+
+## F-1 — safe implementer reaches out-of-bounds unchecked access
+
+**Implementation classification:** `UNSOUND`. **Proof artifact:** missing and irreparable under the current safe generic contract.
+
+A downstream crate can use only safe Rust:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Bad>(&mut pair);
+```
+
+`Bad` is caller-controlled and satisfies the complete declared bound. The array/slice length is 2, and `Bad::index()` returns that length. A-1 says this call itself has undefined behavior even if the reference is unused. Thus this valid safe use reaches UB on every supported configuration. This whole-execution witness establishes `UNSOUND`; it is not used as a defined postcondition refutation.
+
+Minimum resolution is to remove the unchecked operation or enforce bounds before it. Merely documenting that a safe `Slot` implementation should return 0 or 1 would leave a hidden safety precondition and would not repair soundness.
+
+## TCB-1 audit log
+
+| ID | Category and exact proposition | Identity, evidence, consumers, disposition |
+|---|---|---|
+| A-1 | AXIOM: `get_unchecked_mut` returns a mutable element/subslice reference without a bounds check; an out-of-bounds index makes the call UB. | Rust 1.82.0 [`slice::get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut), verified in context. Exact safety text: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” Consumers O-1--O-3; accepted authoritative axiom. |
+| A-2 | AXIOM: `u32::wrapping_add(rhs)` computes modular addition at the type boundary. | Rust 1.82.0 [`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add), verified in context: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” Consumer O-3; accepted authoritative axiom. |
+
+There are no safe/unsafe dependency, implementation, tool, external, deployment, probabilistic, or out-of-band entries. No tool-derived evidence was used. Re-audit triggers are any source/API change, supported-set change, or material change to either cited Rust contract.
+
+## Preferred redesign (not a verdict on current source)
+
+The minimum capability is one fixed, safe mutation; neither type-level slot identity nor implementer extensibility is required. Delete `Slot`, `Tail`, the generic parameter, and all unsafe code:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed safe contract is: for every `[a, b]`, return normally as `[a, (b + 1) mod 2^32]`, with no caller safety obligations. Constant `1` is in bounds by the input type; safe indexing localizes enforcement, and A-2 supplies the arithmetic result. There is no representation invariant, unsafe surface, implementer promise, or extra TCB premise.
+
+This intentionally breaking migration replaces `increment::<Tail>(&mut pair)` with `increment(&mut pair)` and removes all `Slot` implementations, generic calls, and references to the marker type. Those losses are expressly authorized for this unreleased API; the required observable mutation is unchanged.
+
+The proposal is unimplemented and has no audit verdict. After implementation, freeze a new snapshot and audit its complete public/reexported and generated surface, confirm the exact fixed index and array type, prove safe indexing and A-2's postcondition over the full supported set, check every normal exit and call-site migration, and re-establish configuration closure. Any retained compatibility wrapper or newly introduced macro/configuration becomes additional audit scope.
+
+## Residual scope and attestation
+
+Only the supplied source and requested Tail behavior were audited; no broader crate or binary claim is made. Every discovered obligation has a status, both allowlisted citations were opened and checked at version 1.82.0, no test result substitutes for proof, and the redesign does not alter the current-artifact verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/H.md
new file mode 100644
index 0000000000..5b2adf44bb
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/H.md
@@ -0,0 +1,65 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: the exact supplied `lib.rs`, lines 1–18. `REQUEST.md` is the controlling scope. No generated code, dependencies, features, `cfg`, FFI, allocator, concurrency, or build-time inputs appear in the artifact.
+
+Let `Required` be: Rust and standard library 1.82.0, every target on which this exact source and the two used standard-library items exist, and every ordinary profile. The source is identical over that domain; target and profile do not affect the array length, either index value below, or the selected methods. The audit cutoff is this supplied snapshot. TCB-R1 contains only the two verified Rust 1.82.0 standard-library axioms below; it admits no additional assumptions, dependency implementations, tools, compiler backend, or environment.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe use of the public API is free of Rust UB over `Required` | **UNSOUND** | U1 below |
+| For every input `[a, b]`, `increment::<Tail>` returns with `[a, b.wrapping_add(1)]` | **PROVED** | OBL-2–3; `Covered_tail = Required`, hence `Required ⊆ Covered_tail` |
+
+There are no source-documented unsafe-API postconditions. The second claim is the user-required behavior, not a repair or narrowing of the first claim. The combined current-artifact result is **UNSOUND**.
+
+## Authority and TCB-R1
+
+- **AXIOM-SLICE-1 (accepted):** Rust 1.82.0 documents that `get_unchecked_mut` returns a mutable reference to the indexed element or subslice without bounds checking, and: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82.0 slice documentation](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut). Applies to every `Required` case where that item exists; consumed by U1 and P2.
+- **AXIOM-U32-1 (accepted):** `wrapping_add` performs “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82.0 `u32` documentation](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add). Applies throughout `Required`; consumed by P3.
+
+Re-audit these entries if Rust/stdlib version or either cited contract changes. This is a source-level result relative to documented Rust semantics, not a binary/backend claim.
+
+## Boundary and obligation coverage
+
+| ID | Safe surface / proof site | Disposition |
+|---|---|---|
+| API-1 | Public safe trait `Slot` and safe required method `index() -> usize` (lines 3–5) | Downstream safe code may implement it and return any `usize`; no contract or type restriction enforces bounds. |
+| API-2 | Public constructible unit struct `Tail` and its safe `Slot` impl (lines 7–13) | `index()` is locally fixed to `1`. |
+| API-3 | Public safe generic `increment<S: Slot>` (lines 15–18) | Must be sound for every well-typed safe `S`; it invokes caller-controlled safe code, then consumes its result in unsafe code. |
+| OBL-1 | `get_unchecked_mut(S::index())` (line 16) | For the `usize` index, the required proposition is `S::index() < pair.len() = 2`. **False in a valid safe use; U1.** |
+| OBL-2 | `increment::<Tail>` at line 16 | **Proved:** `Tail::index() = 1`, and `1 < 2`; AXIOM-SLICE-1 therefore supplies a mutable reference to element 1. |
+| OBL-3 | Assignment at line 17 | **Proved for `Tail`:** the only write is through that element-1 reference; AXIOM-U32-1 gives the new value `b + 1 mod 2^32`, while element 0 is untouched. |
+
+There are no fields, other constructors, methods, macros, hidden items, reexports, callbacks other than the trait implementation dispatch, or invariant-bearing state in the supplied source. No tool-derived evidence was used.
+
+## U1 — complete UB certificate
+
+A downstream crate can write entirely safe Rust:
+
+```rust
+struct Bad;
+impl Slot for Bad { fn index() -> usize { 2 } }
+let mut pair = [0u32, 0u32];
+increment::<Bad>(&mut pair);
+```
+
+This is a valid in-scope use: `Slot` is safe and public, `Bad` is downstream-owned, and `increment` is safe. Dispatch reaches line 16 with index `2`. The borrowed array has exactly two elements, so valid indices are `0` and `1`; `2` is out of bounds. AXIOM-SLICE-1 makes the call itself UB, independently of later dereference. The witness is parametric over every `Required` target/profile because the same source path and constants apply. Thus the universal safe-API claim is **UNSOUND**, not merely unproved.
+
+The unsafe block also has no adjacent `SAFETY` proof. More importantly, no truthful proof comment can close OBL-1: the needed implication `S: Slot => S::index() < 2` is unenforced and refuted above. Behavioral prose on a safe trait would not fix that.
+
+## Preferred redesign (not a verdict on implemented code)
+
+Remove `Slot`, `Tail`, the type parameter, and the unsafe operation. Specialize the sole required capability:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Proposed safe contract: for every input whose old value is `[a, b]`, normal return produces `[a, b + 1 mod 2^32]`; callers have no safety precondition beyond supplying the typed mutable reference. Fixed safe indexing enforces the only projection needed. There is no representation invariant, implementer obligation, generic capability, or unsafe surface to trust. This is more parsimonious than sealing or making `Slot` unsafe because no required consumer needs generic selection.
+
+Migration is intentionally breaking but authorized for this unreleased abstraction: delete downstream `Slot` implementations and change `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls cease to exist; the required element-1 behavior and wrapping arithmetic remain.
+
+The proposal is unimplemented and has no audit verdict. After implementation, audit the new exact snapshot independently: verify its public contract, safe indexing of `1` into `[u32; 2]`, the wrapping result and preservation of element 0, panic/profile independence, configuration closure, and absence of generated or alternate paths. Re-audit on source/API changes, support-domain expansion, or relevant Rust documentation changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/I.md
new file mode 100644
index 0000000000..acc42fb5b5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/I.md
@@ -0,0 +1,83 @@
+# Focused literal audit and redesign
+
+## Claim, scope, and verdict
+
+**Snapshot:** the supplied `lib.rs`, reviewed as source without execution or expansion. **Supported set:** Rust 1.82.0; every Rust 1.82 edition, target on which this source and the used standard-library items exist, and ordinary profile. The proof is parametric over target, edition, and profile: the file has no `cfg`, features, generated code, dependencies, FFI, concurrency, target features, allocation, panic-mode-sensitive checks, or profile-sensitive arithmetic.
+
+The current-artifact claim is that every well-typed safe use of its public safe surfaces is free of Rust undefined behavior. The separately requested behavior is: for input `[a, b]`, `increment::<Tail>` returns normally with `[a, b.wrapping_add(1)]`.
+
+- **Current safe-API soundness: UNSOUND** (`F-1`).
+- **Required `Tail` behavior: PROVED** throughout the supported set, relative only to the cited Rust 1.82 standard-library semantics.
+- **Documented-postcondition result:** the source contains no API documentation. The user-specified `Tail` postcondition is proved; there is no current documented postcondition to classify as `CONTRACT-BROKEN`.
+- **Combined current-artifact result: UNSOUND.** The successful `Tail` proof does not qualify the public generic function's universal safe-use claim.
+- **Additional TCB assumptions:** none. No dependency, implementation, environmental, compatibility, or tool-result premise is admitted.
+
+## Authority and exact contracts
+
+`AXIOM-INDEX`, Rust 1.82 slice documentation: `get_unchecked_mut` returns a mutable reference without bounds checking, and “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” [Rust 1.82 `get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut).
+
+`AXIOM-WRAP`, Rust 1.82 `u32` documentation: `wrapping_add` is “Wrapping (modular) addition” and wraps at the type boundary. [Rust 1.82 `wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add).
+
+These are version-matched Rust axioms, not additional TCB assumptions. No tool-derived evidence was used.
+
+## Boundary and obligation coverage
+
+The complete language-reachable source surface is:
+
+| Surface | Kind | Disposition |
+|---|---|---|
+| `Slot` and safe `Slot::index` (`lib.rs:3-5`) | public safe, downstream-implementable trait | Supplies an arbitrary `usize`; no contract or enforcement makes it less than 2. |
+| `Tail`, its public unit constructor, and `impl Slot` (`lib.rs:7-13`) | public safe type/implementation | `Tail::index()` is locally fixed at 1. No fields or state invariants exist. |
+| `increment<S: Slot>` (`lib.rs:15-18`) | public safe generic function containing the sole unsafe operation | Unsound for arbitrary valid `S`; proved for `S = Tail`. |
+
+There are no manual trait implementations other than `Slot for Tail`, macros, hidden APIs, restricted-visible fields, reexports, callbacks, custom destruction, or configuration-specific surfaces in the supplied source. Compiler-provided behavior of the fieldless `Tail` is irrelevant to the unsafe call.
+
+The sole safety invariant consumed at `lib.rs:16` is `INV-BOUND: S::index() < pair.len() = 2` at the instant `get_unchecked_mut` is called. The array-reference type fixes the length at 2. `Tail::index()` establishes `1`, so `INV-BOUND` holds for `Tail`. The public safe trait boundary neither checks nor promises it for arbitrary `S`.
+
+Obligation ledger:
+
+| ID | Proposition | Status |
+|---|---|---|
+| `OBL-1` | At `lib.rs:16`, `S::index() < 2` for every safe-callable `S`. | **Refuted** by `F-1`; hence **UNSOUND**. |
+| `OBL-2` | For `S = Tail`, the unchecked access produces a mutable reference to element 1. | **PROVED:** local constant 1 is in the type-fixed length 2; `AXIOM-INDEX` supplies the operation contract. |
+| `OBL-3` | The `Tail` call leaves element 0 unchanged and replaces element 1 by its old value plus 1 modulo `2^32`. | **PROVED:** `OBL-2` identifies the only assignment target; `AXIOM-WRAP` gives the assigned value. |
+
+No existing `SAFETY` comment states any of these obligations. The reconstructed `Tail` derivation is material, but it cannot repair the generic case.
+
+## F-1 — safe downstream implementation reaches UB
+
+**Status:** `UNSOUND`; implementation defective and local proof missing.
+
+This is a valid, entirely safe downstream use:
+
+```rust
+struct Bad;
+impl Slot for Bad {
+    fn index() -> usize { 2 }
+}
+
+let mut pair = [0u32, 0u32];
+increment::<Bad>(&mut pair);
+```
+
+The public trait is safe and unsealed, its method has no precondition, and the downstream type is local to its implementing crate. The call therefore satisfies every current caller obligation. It passes index 2 to a length-2 array. By `AXIOM-INDEX`, the call at `lib.rs:16` itself has undefined behavior, whether or not the returned reference is later used. This witness and reasoning are independent of target and profile.
+
+The smallest false implication is `S: Slot => S::index() < 2`. Neither the type system, validation, privacy, nor a trait contract supplies it. A comment cannot impose a safety precondition on this safe trait or safe function. Because the witness execution contains UB, it does not establish a defined postcondition refutation.
+
+## Preferred design
+
+Delete `Slot`, `Tail`, the type parameter, and the unsafe operation. Expose exactly the required capability:
+
+```rust
+/// Increments the second element modulo 2^32.
+pub fn increment(pair: &mut [u32; 2]) {
+    let [_, tail] = pair;
+    *tail = tail.wrapping_add(1);
+}
+```
+
+This is the most parsimonious boundary because no runtime-selected slot or nominal marker is required. The two-element pattern structurally obtains the second element; no index validity proposition is delegated to a caller or implementer. All operations are safe, and `AXIOM-WRAP` directly supplies the behavioral postcondition. There is no representation invariant, unsafe surface, sealing argument, or additional TCB entry.
+
+**Contract and migration delta:** `increment::<Tail>(&mut pair)` becomes `increment(&mut pair)`. `Slot`, downstream implementations, generic dispatch, and the `Tail` marker disappear. Those are source-breaking changes, expressly authorized because the abstraction is unreleased and none of those capabilities must be preserved. The new public contract should state normal return with element 0 unchanged and element 1 incremented modulo `2^32`.
+
+This is a proposal, not a verdict for an unimplemented artifact. After implementation, audit the fresh source snapshot: confirm the exact public surface and documentation; re-prove element selection and modular arithmetic on Rust 1.82.0 across the requested target/edition/profile set; and recheck any newly introduced configuration, generated code, dependency, or caller surface. Re-audit on source, contract, supported-set, or relevant Rust-documentation change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/J.md
new file mode 100644
index 0000000000..479dbf06ff
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/reports/J.md
@@ -0,0 +1,66 @@
+# Focused unsafe-Rust audit and redesign
+
+## Claim, snapshot, and verdicts
+
+**Snapshot.** Exact supplied `lib.rs` (18 lines) under Rust/standard library 1.82.0; no generated code, dependencies, build scripts, `cfg`, features, FFI, concurrency, or prior audit is present in the supplied artifact. Audit cutoff: 2026-08-01. Report/TCB ID: `R029-1` / `R029-TCB-1`.
+
+`Required(c)` is exactly: Rust 1.82.0, every target `c.target` on which this source and the two used standard-library items exist, and every ordinary profile, for every well-typed safe use of the public surfaces. This preserves the request's symbolic target and profile predicates rather than inventing an enumeration.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| All well-typed safe uses of the current public API avoid Rust UB | **UNSOUND** | `F-1` gives a valid safe use, reaches the unchecked call with a false bounds precondition, and the applicable Rust 1.82 contract declares UB. |
+| For `increment::<Tail>` and every initial `[a,b]`, normal return is UB-free and produces `[a, b.wrapping_add(1)]` | **PROVED** | `P-TAIL` below, over all `Required(c)`, relative only to the two Rust 1.82 axioms in `R029-TCB-1`. |
+
+The combined current-artifact result is **UNSOUND**. The Tail-specific proof does not repair or narrow the safe generic API's claim.
+
+## Boundary, invariant, and obligation inventory
+
+Safe public surfaces are: downstream-implementable trait `Slot` and its safe associated function `index` (lines 3–5); publicly constructible unit struct `Tail` (line 7); its safe `Slot` implementation (lines 9–13); and safe generic function `increment<S: Slot>` (lines 15–18). There are no public fields, unsafe declarations, macros, hidden APIs, callbacks, custom destruction, or other source surfaces. The sole unsafe operation is `get_unchecked_mut` at line 16.
+
+The unsafe call requires `INV-INDEX(S): S::index() < 2`. No type, privacy boundary, validation, or trait contract establishes that proposition for all `S: Slot`. `Tail::index() == 1` is only a local fact about `Tail`; it cannot be promoted to an invariant of every implementation of the public safe trait.
+
+| ID | Exact obligation | Required domain | Status |
+|---|---|---|---|
+| `O-BOUNDS` | At line 16, the `usize` index is in bounds for the length-2 receiver | Every safe `S: Slot` call in `Required` | **Refuted (`F-1`)** |
+| `O-TAIL` | The same bound when `S = Tail` | All inputs/configurations in `Required` | **PROVED:** source gives `1 < 2` |
+| `O-WRAP` | Tail element 1 becomes its old value plus one modulo `2^32`; element 0 is unchanged | All inputs/configurations in `Required` | **PROVED (`P-TAIL`)** |
+| `O-PROOF` | Adjacent proof derives every unsafe-call precondition | Line 16 | **Missing**; there is no `SAFETY` comment, and the needed generic premise is false |
+
+### `P-TAIL`
+
+For an input `[a,b]`, the inspected `Tail` implementation returns literal `1`; the array has length 2, hence the unchecked index is in bounds. Rust 1.82 documents that this method returns a mutable reference to the indexed element without bounds checking, while its safety clause says: “Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.” ([`get_unchecked_mut`](https://doc.rust-lang.org/1.82.0/std/primitive.slice.html#method.get_unchecked_mut)). Thus the Tail call obtains the exclusive reference to element 1 permitted by the input `&mut` borrow. Rust 1.82 specifies `wrapping_add` as: “Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the boundary of the type.” ([`u32::wrapping_add`](https://doc.rust-lang.org/1.82.0/std/primitive.u32.html#method.wrapping_add)). The assignment therefore changes only element 1 to `b + 1 mod 2^32`; element 0 remains `a`. No branch, panic, unwind, or profile-dependent arithmetic exists on this path.
+
+Both proofs are parametric in target and ordinary profile: the source has no conditional selection, target operation, debug assertion, ordinary `+`, generator, or build input, and consumes the same Rust 1.82 contracts everywhere in `Required`. Therefore `Covered(O-TAIL) = Covered(O-WRAP) = Required`, and their intersection contains `Required`.
+
+## `F-1` — safe trait implementation makes `increment` UB
+
+**Implementation defect; proof artifact missing.** A downstream crate can use only safe Rust:
+
+```rust
+struct Oob;
+impl Slot for Oob { fn index() -> usize { 2 } }
+let mut pair = [0, 0];
+increment::<Oob>(&mut pair);
+```
+
+This is a well-typed, valid use: `Slot` is a public safe trait, its method has no contract or enforced range, and the safe `increment` signature imposes no safety precondition. The call reaches line 16; `Oob::index()` is 2, while the receiver length is 2, so the exact required proposition `index < len` is false. The quoted Rust 1.82 safety clause entails UB at the call itself. Literal `2`, array length 2, and the unconditional source path make the same witness available on every `Required` target/profile. This completes the existential **UNSOUND** certificate; it is not merely a failed universal proof. No UB-free postcondition refutation is needed or claimed. A comment or undocumented request to implementors cannot resolve it.
+
+## TCB and evidence
+
+`R029-TCB-1` contains only verified authoritative Rust 1.82 standard-library axioms: `AX-BOUNDS`, the quoted out-of-bounds UB clause consumed by `F-1`/`P-TAIL`; and `AX-WRAP`, the quoted modular-addition guarantee consumed by `P-TAIL`. Exact identities are the two versioned links above; scope is every target where those items exist. There are no admitted dependency, implementation, tool, environment, compatibility, or external assumptions. No tests, execution, compilation, expansion, or tool-derived evidence was used. Re-audit either axiom if its cited contract or the Rust version changes.
+
+## Preferred redesign (not a verdict on implemented code)
+
+The minimum required capability is one fixed operation, not an implementer-selected index. Delete `Slot` and `Tail`, remove the type parameter, and implement a concrete safe function:
+
+```rust
+pub fn increment(pair: &mut [u32; 2]) {
+    pair[1] = pair[1].wrapping_add(1);
+}
+```
+
+Its proposed contract is: for every input `[a,b]`, normal return yields `[a, b.wrapping_add(1)]`; it has no caller safety precondition. The fixed array type and literal index keep selection local, safe indexing removes the unsafe contract entirely, and `wrapping_add` supplies the required overflow behavior. There is no invariant-bearing representation or implementer boundary to trust. Removing the nominal `Tail` type is intentional: the stated requirement retains only its operation, not nominal identity.
+
+Migration changes `increment::<Tail>(&mut pair)` to `increment(&mut pair)`. Generic calls, downstream `Slot` implementations, and references to `Slot`/`Tail` stop compiling; the request explicitly authorizes all of those public-contract changes and says the abstraction is unreleased. Required Tail-observable behavior is unchanged.
+
+This candidate is **not implemented and has no audit verdict**. After implementation, audit the exact new snapshot independently: confirm the old trait/type/generic and unchecked call are absent; inventory any actual reexports or callers; verify the stated normal-return postcondition and no hidden panic path for the fixed length; re-establish the same target/profile closure under Rust 1.82; and recheck the `wrapping_add` citation. Source, contract, Rust version, support predicate, or newly introduced configuration/build machinery triggers re-audit. Binary/backend correctness and material not supplied in the target remain outside this source-level review.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/R/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/PACKET.json
new file mode 100644
index 0000000000..b20c735c63
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "S",
+  "presentation_order": [
+    "A",
+    "B",
+    "E",
+    "F",
+    "G",
+    "I",
+    "J",
+    "C",
+    "D",
+    "H"
+  ],
+  "report_sha256": {
+    "A": "d135ad89e2b402af49206d79186ad5f4454716f99c32debe93ff458ed07d086e",
+    "B": "44941853a2458104b934dfa73aa5411c39c4e5c0ac33730d7bd754757f96e176",
+    "C": "4661ad891ae68f808fefc57a29a5b2d1ee36364508329ddb3163e18761d0b9ad",
+    "D": "cae33ebb10f593bbebe9722ae1b12d2a8e1ebbeaa477704ed16d61296c964bae",
+    "E": "2ce56cb39ecd21ba188269290a81702a5f56f4eb84cf09a916a019a850d4436a",
+    "F": "63ff5fdf0f56585dca05bde1ea6b36f118c19ad66ef40b0a10ff43349399c0ad",
+    "G": "a4e4c1ea234c10cd9830139d9c8c2d59a1da533003609c68cb81cb4a22a366d9",
+    "H": "d91ac2821d69b57dd7bd98303059093769e6e2b6b99226936b2bf4edc90cdd32",
+    "I": "aaf0fe262d82d837f4f011b5707956852b8db0df9830d91ec927d0ce16fcbd8a",
+    "J": "f5b0a2be88ccf8436af7044f8a321be0582d57dacffa84012c994a705779dc77"
+  },
+  "rubric_sha256": "d215ac1a4ed2e150f369b28aa12a4d77cf391c94ce47a98fccf132ad6a0c60f3",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/RUBRIC.md
new file mode 100644
index 0000000000..b7dd209431
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/RUBRIC.md
@@ -0,0 +1,111 @@
+# Mode S Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## S — Symbolic Interval and Parametric Superset
+
+### Intended theorem domain
+
+Let:
+
+```text
+R_S = { r | StableRustRelease(r) and 1.84.0 <= r <= 1.86.0 }
+T_S = { x86_64-unknown-linux-gnu,
+        aarch64-apple-darwin,
+        wasm32-unknown-unknown }
+F_S = { telemetry-off, telemetry-on }
+O_S = { None } union { Some(b) | b is any u8 }
+```
+
+The exact requested case predicate is:
+
+```text
+Required_S(r, t, f, p, d, o)
+  iff r in R_S and t in T_S and f in F_S and p in P and d in D and o in O_S.
+```
+
+This predicate is symbolic. It is not the CI matrix or the Cargo minimum. It
+contains non-`.0` stable releases such as Rust 1.84.1 and 1.85.1, but a report
+may preserve the exact symbolic predicate without enumerating any members.
+
+Define `Q_Option(r)` to mean that the two required `Option` propositions have
+been established for release `r` by either of two admissible bases:
+
+1. the Rust 1.84.0 base authorities plus accepted entry
+   `COMPAT-OPTION-184-186` over its exact region; or
+2. an exact finite partition that proves the released members of `R_S` are
+   `{1.84.0, 1.84.1, 1.85.0, 1.85.1, 1.86.0}` and verifies the two exact
+   versioned pages for every member.
+
+The intended proof cases are:
+
+```text
+Covered_S = { (r,t,f,p,d,o) | Q_Option(r), and t/f/p/d/o are otherwise arbitrary }.
+```
+
+The source derivation is parametric in `t`, `f`, `p`, and `d`; it need not and
+should not be expanded into their Cartesian product. Applicability still must
+establish `R_S subset-of {r | Q_Option(r)}`. Either admissible basis above can
+do so. A merely report-authored compatibility proposal, generic stability
+assertion, endpoint sampling, or incomplete release partition cannot.
+
+### Expected verdicts
+
+- Safe-API soundness over `Required_S`: **PROVED**, either from the exact
+  finite authoritative partition or relative to `COMPAT-OPTION-184-186`.
+- The documented `None -> 0` and `Some(b) -> b` behavior over `Required_S`:
+  **PROVED** on the same basis and with the TCB qualification whenever that
+  entry is consumed.
+- Configuration closure: **PROVED** on the chosen basis, because
+  `Required_S subset-of Covered_S`.
+
+The local proof is: `is_none()` returning true takes the `return 0` branch. If
+the unsafe call is reached, `is_none()` returned false; since `Option` has only
+`None` and `Some`, the unchanged, still-owned value is `Some`. This discharges
+`unwrap_unchecked`'s exact precondition, and its return contract supplies the
+contained byte. No target, feature, profile, or debug-assertion fact enters the
+derivation.
+
+### Atoms
+
+- **S1 — Lossless domain recovery:** States `R_S` as the closed symbolic
+  stable-release predicate and keeps the three targets and both feature states.
+  It does not substitute Cargo's lower bound or CI's rows for the policy. Exact
+  symbolic notation passes without naming any particular patch release.
+- **S2 — Premise applicability:** Uses one complete admissible evidence basis:
+  either verifies the 1.84.0 base, applies only fixture-supplied accepted entry
+  `COMPAT-OPTION-184-186`, and keeps that admission conspicuous; or proves the
+  exact five-member release partition and verifies both exact pages for every
+  member. A report-authored premise, partial partition, or mixed gap does not
+  pass.
+- **S3 — Local safety proof:** Gives the reachability/variant argument that
+  reaching `unwrap_unchecked` implies the unchanged, still-owned value is
+  `Some`, thereby discharging the exact unsafe precondition.
+- **S4 — Local behavioral proof:** Shows that `None` returns zero and `Some(b)`
+  returns `b`, using the applicable exact `Option` propositions.
+- **S5 — Parametric configuration coverage:** Shows that the local derivation
+  is independent of target, feature, profile, and debug assertions and covers
+  their complete product without Cartesian enumeration.
+- **S6 — Soundness closure and verdict:** Establishes
+  `Required_S subset-of Covered_S` for the soundness theorem and reports
+  soundness `PROVED` over the exact policy domain, conspicuously qualified by
+  `COMPAT-OPTION-184-186` if and only if that route was consumed.
+- **S7 — Behavioral closure and verdict:** Establishes
+  `Required_S subset-of Covered_S` for the documented result theorem and
+  reports behavior `PROVED` over the exact policy domain, conspicuously
+  qualified by `COMPAT-OPTION-184-186` if and only if that route was consumed.
+
+### Hard-error triggers
+
+A report commits a hard error if it:
+
+- claims full closure or an affirmative whole-domain result after contracting
+  the release predicate to `.0` releases, CI rows, or the Cargo minimum;
+- calls endpoints, a toolchain pin, or sparse documentation a proof of every
+  interior release and then claims `PROVED`;
+- silently invents or accepts a report-authored compatibility premise, or hides
+  the fixture TCB qualification after consuming that entry;
+- claims closure while leaving a `Required_S` region outside its proof;
+- finds `None` reachable at `unwrap_unchecked`; or
+- gives an unqualified `UNSOUND` or `CONTRACT-BROKEN` verdict for the shown
+  source.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/allowlist.txt
new file mode 100644
index 0000000000..f13c981a34
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/allowlist.txt
@@ -0,0 +1,12 @@
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.84.1/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.84.1/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.85.1/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.85.1/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30
+https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/A.md
new file mode 100644
index 0000000000..3a76df465c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/A.md
@@ -0,0 +1,64 @@
+# Unsafe Rust audit: supplied `symbolic-domain-target` snapshot
+
+## Claims and verdicts
+
+**Soundness theorem.** For every well-typed safe call to `value_or_zero` in every supported configuration defined below, execution is free of Rust undefined behavior under the documented Rust abstract semantics.
+
+**Soundness verdict: PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** That qualification is material: the proof consumes both propositions preserved by that entry throughout the complete supported Rust/configuration domain.
+
+**Documented-behavior theorem.** In the same domain, `value_or_zero(None) == 0`, and for every `b: u8`, `value_or_zero(Some(b)) == b`.
+
+**Documented-behavior verdict: PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** Combined mandatory result: **PROVED relative to `COMPAT-OPTION-184-186`**. No conditional application or binary claim is made.
+
+## Snapshot and supported set
+
+Scope is the complete supplied source snapshot: package `symbolic-domain-target` 0.1.0, edition 2021, `rust-version = "1.84"`, `#![no_std]`, manifest, policy, CI, and TCB files. There are no dependencies, lockfile, build script, generated source, macros, FFI, assembly, allocator selection, concurrency, or prior audit.
+
+`Supported(c)` means: `c` uses a released stable Rust toolchain `r` with `1.84.0 <= r <= 1.86.0`; target is exactly `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `telemetry` is either disabled or enabled; Cargo profile is arbitrary; and debug assertions are either disabled or enabled. `SUPPORT.md`, including its upper cutoff, is controlling. `Cargo.toml` only supplies Cargo's lower acceptance bound. `CI.md` is sampling evidence and neither defines nor proves support.
+
+This audit uses the policy predicate parametrically; it need not guess or freeze the interval's patch-release membership. Source identity is the supplied files, with an audit cutoff of this review. Unlisted configurations are outside the claimed theorem by the explicit support commitment; no build-time rejection is claimed.
+
+## Boundary, surfaces, and invariant
+
+The sole crate API surface is safe public function `value_or_zero(Option<u8>) -> u8`. It has no public fields, constructors, traits/impls, associated items, reexports, hidden items, statics, callbacks, operators, custom destruction, or configuration-generated variants. The sole unsafe operation is the internal call to `Option::unwrap_unchecked`; there is no public unsafe API and therefore no caller safety obligation.
+
+`INV-BRANCH`: at the unsafe call, the unchanged local `value` is `Some(b)` for some `b`. Its owner is the function's straight-line control flow. The `is_none` check establishes it on the fallthrough edge; no mutation, callback, or other intervening operation can suspend it; `unwrap_unchecked` consumes it.
+
+## Obligation ledger and reconstructed proof
+
+| ID | Exact obligation and derivation | Domain | Status |
+|---|---|---|---|
+| OBL-1 | `value.is_none()` is true exactly when `value` is `None`. This is the base [`is_none` contract](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), whose relevant text is “Returns true if the option is a `None` value,” carried over the domain by `COMPAT-OPTION-184-186`. | All `Supported(c)` | PROVED relative to the TCB entry |
+| OBL-2 | On fallthrough, the check returned false. By OBL-1 and `Option`'s two variants, `value = Some(b)`. `is_none` only borrowed the by-value local, and no transition follows, establishing `INV-BRANCH`. | All inputs/configurations | PROVED relative to the TCB entry |
+| OBL-3 | [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) requires non-`None`; its safety text says calling it on `None` is undefined behavior. OBL-2 proves the precondition. `COMPAT-OPTION-184-186` additionally preserves that `unwrap_unchecked(Some(b))` returns `b`. | All fallthrough executions in `Supported(c)` | PROVED relative to the TCB entry |
+| OBL-4 | If the check is true, OBL-1 gives `None` and the explicit return yields 0 without unsafe execution. If false, OBL-2/3 give `Some(b)` and result `b`. These exhaustive paths prove the documented result. | All safe inputs/configurations | PROVED relative to the TCB entry |
+
+The derivation is uniform across targets, releases, features, profiles, and assertion states: the source contains no `cfg`, feature use, target branch, assertion, overflow, allocation, or profile-sensitive operation. The accepted TCB proposition expressly quantifies over every supported value of those axes, so their Cartesian product is closed by the same proof.
+
+## TCB audit log
+
+| ID | Disposition | Exact consumed proposition | Consumers / limitations |
+|---|---|---|---|
+| `COMPAT-OPTION-184-186` | Accepted by the authorized human reviewer | For every released stable `r` in 1.84.0–1.86.0 and all supported targets/profiles/feature/assertion states, Rust preserves: `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; calling it on `None` is UB. Base authority is the linked Rust 1.84.0 standard-library documentation. | OBL-1–4 and both verdicts only. It establishes no interval membership, Cargo fact, other API, backend, or binary property. |
+
+No other admitted premise is consumed. Source-level reasoning does not trust a particular compiler backend. Re-audit is required on any source, support-domain, base-contract, feature/target, or human-disposition change.
+
+## Finding DOC-1: adjacent proof is incomplete
+
+**Classification:** implementation obligation PROVED; proof artifact deficient; no UB witness and no defined postcondition refutation. The existing `SAFETY` comment states the branch conclusion and callee precondition, but does not identify the exact `is_none` fact, its domain/TCB basis, the absence of an intervening transition, or the result used for the public postcondition.
+
+Proposed replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 guarantees throughout the supported domain
+// that is_none is true exactly for None. This fallthrough is therefore
+// Some(b); value has not been mutated. The same entry guarantees that
+// unwrap_unchecked(Some(b)) is defined and returns b.
+unsafe { value.unwrap_unchecked() }
+```
+
+Minimal resolution is to install equivalent adjacent or canonical proof text. This is documentation debt, not an implementation or API-contract failure.
+
+## Residual scope and attestation
+
+No code was modified, expanded, built, run, or tested; there is no tool-derived proof. Compiler/backend correctness, emitted binaries, non-supported configurations, resource/security properties, and undocumented behavior are excluded. Every source/API, unsafe operation, invariant transition, documented result, and supported configuration class has a disposition. Re-audit on changes to source/contracts, support policy, Rust/std documentation, TCB disposition, generated/build inputs, or newly discovered obligations.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/B.md
new file mode 100644
index 0000000000..0173722cae
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/B.md
@@ -0,0 +1,63 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Soundness — PROVED relative to `TCB.md` / `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior in every configuration in `Required` below.
+
+**Documented result — PROVED relative to the same TCB entry.** Every such call returns `0` for `None` and returns `v` for `Some(v)`.
+
+The combined mandatory result is **PROVED**. This is a source-level Rust-abstract-semantics result, not a claim about a compiler backend or emitted binary.
+
+## Snapshot, scope, and boundary
+
+The audited snapshot is the complete supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`. It is a Rust-2021 `#![no_std]` library with no dependencies, build script, generated source, or prior audit reused.
+
+The complete language-reachable crate-defined API surface is the safe free function `pub fn value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4-13`). There are no public fields, constructors, types, traits or impls, statics, reexports, macros, hidden items, callbacks, FFI, assembly, allocator operations, or concurrency surfaces. The sole unsafe site is the internal `Option::unwrap_unchecked` call at line 12. There is no persistent representation invariant; the only safety fact is the control-flow-local proposition `value != None` at that call.
+
+## Exact supported domain and closure
+
+Let
+
+* `R = { r | r is a released stable Rust toolchain and 1.84.0 <= r <= 1.86.0 }`;
+* `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`;
+* `F = {telemetry disabled, telemetry enabled}`;
+* `P` be every Cargo profile; and
+* `A = {debug assertions disabled, debug assertions enabled}`.
+
+Then `Required = R × T × F × P × A`, for this source and its version-matched standard library. `SUPPORT.md` is controlling: it says the release predicate is exact and expressly supports every cross-product member. `Cargo.toml`'s `rust-version = "1.84"` is only Cargo's minimum-admission statement, as `SUPPORT.md` itself explains; it agrees with the lower bound and does not erase the upper bound. `default = []` and the sole declared feature establish the two feature states. `CI.md` supplies samples only and neither defines nor proves support.
+
+This preserves `R` symbolically. No finite release inventory is substituted, so no unproved “there were no other patch releases” premise is needed. `COMPAT-OPTION-184-186` quantifies over exactly the same released-stable predicate.
+
+`Covered = Required`. The source contains no `cfg`, feature read, target branch, assertion, arithmetic, panic, profile-sensitive operation, generator, or external component. Thus its control-flow proof is parametric over `T × F × P × A`. The accepted compatibility premise is parametric over `R` and all those axes. Their conjunction covers every cross-product member, establishing `Required ⊆ Covered`. CI endpoints are not used in this certificate.
+
+## Authorities, TCB, and proof ledger
+
+The Rust 1.84.0 documentation says `is_none` “[r]eturns `true` if the option is a `None` value” ([versioned page](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). It says `unwrap_unchecked` returns the contained `Some` value and that calling it on `None` is undefined behavior ([versioned page](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). Both exact pages and their version were checked.
+
+`COMPAT-OPTION-184-186` is an accepted human compatibility premise. Its exact consumed proposition is: throughout `Required`, `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; and calling it on `None` is UB. Its only consumers here are the following obligations, matching `TCB.md`. It establishes no release inventory, Cargo fact, backend, or binary fact. No other assumption is consumed.
+
+| ID | Obligation and derivation | Status |
+|---|---|---|
+| O1 | At line 12, `unwrap_unchecked` must receive `Some(v)`. If `is_none()` were true, line 6 returned. On the continuing path it is false; by `COMPAT-OPTION-184-186`, `value` is `Some(v)`. | PROVED over `Required` |
+| O2 | Every safe input is covered. `None` takes the first return and executes no unsafe operation. `Some(v)` reaches line 12 with O1 true, and the TCB premise supplies a defined return of `v`. | PROVED over `Required` |
+| O3 | The same exhaustive cases return respectively `0` and `v`, exactly the documented behavior. Both executions are UB-free as established by O2. | PROVED over `Required` |
+| O4 | Configuration/version closure is the parametric argument above; applicability of every consumed premise contains `Required`. | PROVED |
+
+No test, build, execution, or tool-derived evidence was used.
+
+## Proof-documentation finding
+
+**DOC-01 — local `SAFETY` proof is incomplete as a persistent proof artifact; implementation remains proved.** The comment identifies the branch and callee precondition, but does not identify the semantic premise establishing that `is_none() == false` means `Some`, nor its supported-release applicability. Suggested replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 guarantees throughout the supported domain
+// that is_none() is true exactly for None. The true case returned above, so
+// value is Some(v); the same premise guarantees unwrap_unchecked(Some(v))
+// is defined and returns v.
+```
+
+This is documentation debt, not an implementation, soundness, or behavioral defect.
+
+## Residual scope and triggers
+
+Excluded are configurations outside `Required`, backend/binary correctness, and undocumented robustness properties. Re-audit is required for any source or documentation change; support-domain expansion or reinterpretation; change to either cited standard-library proposition; change or withdrawal of `COMPAT-OPTION-184-186`; or addition of dependencies, generated code, configuration-sensitive code, or API surfaces. Every in-scope obligation and mandatory postcondition has a disposition; there is no unresolved domain or proof remainder.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/C.md
new file mode 100644
index 0000000000..6f14f1778b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/C.md
@@ -0,0 +1,71 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+| Claim | Exact theorem | Verdict | Qualification |
+|---|---|---|---|
+| SOUND | For every `Required` configuration and every well-typed safe call `value_or_zero(value: Option<u8>)`, execution is free of Rust undefined behavior. | **PROVED** | Source-level Rust semantics, relative to accepted TCB entry `COMPAT-OPTION-184-186`. |
+| RESULT | In the same domain, `value_or_zero(None) == 0` and `value_or_zero(Some(v)) == v` for every `u8` `v`. | **PROVED** | Relative to the same accepted entry. |
+
+**Combined mandatory result: PROVED**, relative to conspicuous use of `TCB.md` entry `COMPAT-OPTION-184-186`. Scope is the complete supplied crate snapshot and its sole public safe API. This is not a compiler-backend or emitted-binary claim.
+
+## Snapshot and required domain
+
+Audited inputs are `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs` as supplied. There are no dependencies, build scripts, generators, generated artifacts, macros, FFI, assembly, concurrency, allocation, mutable state, or target-specific source. The crate is edition 2021 and `no_std`.
+
+Preserving the controlling expression rather than inventing a finite release list:
+
+```text
+Required(r,t,f,p,d) :=
+  ReleasedStableRust(r) && 1.84.0 <= r <= 1.86.0
+  && t in {x86_64-unknown-linux-gnu,
+           aarch64-apple-darwin,
+           wasm32-unknown-unknown}
+  && f in {telemetry-off, telemetry-on}
+  && p is any Cargo profile
+  && d in {debug-assertions-off, debug-assertions-on}.
+```
+
+`SUPPORT.md` expressly makes that predicate, including its upper cutoff, the support commitment. `Cargo.toml`'s `rust-version = "1.84"` supplies the compatible lower Cargo admission threshold but does not replace the policy or erase its upper bound. `CI.md` is only a sample and is not used to transform or prove the domain. No enumeration of `ReleasedStableRust` is used: the proof below and the accepted compatibility premise quantify over the symbolic predicate directly.
+
+Configuration selection is source-identical: neither feature nor target appears in a `cfg`; there are no assertions or profile-sensitive arithmetic; and the only unsafe operation's admitted contract explicitly covers every `Required` target, profile, feature, and debug-assertion state. Thus each obligation's `Covered` predicate equals `Required`, establishing `Required ⊆ Covered` without relying on CI samples. The audit cutoff is 2026-08-01; the fixed upper bound makes it non-moving.
+
+## Boundary, invariants, and obligations
+
+The complete language-reachable crate-defined API surface is the safe free function `value_or_zero`. There are no public fields, constructors, types, traits or impls, methods, statics, reexports, hidden items, callbacks, or macro-generated APIs. The internal unsafe consumer is `Option::unwrap_unchecked` at `src/lib.rs:12`. There is no persistent representation invariant; the sole proof fact is the branch-local classification of `value`.
+
+| ID | Proposition | Proof/status |
+|---|---|---|
+| O1 | The `None` branch returns before the unsafe call. | Direct control flow at lines 6–8; **PROVED** for `Required`. |
+| O2 | Every execution reaching line 12 has `value = Some(v)`. | `is_none` is exactly the `None` discriminator by the accepted TCB proposition; negating the taken condition and the two `Option` variants gives `Some(v)`; **PROVED** for `Required`. |
+| O3 | Line 12 satisfies `unwrap_unchecked`'s safety precondition and returns `v`. | O2 plus the version-applicable contract below; **PROVED** for `Required`. |
+| O4 | Both documented result cases hold. | Exhaustive `None`/`Some(v)` partition and O1/O3; **PROVED** for `Required`. |
+
+The Rust 1.84.0 documentation says `is_none` “Returns `true` if the option is a `None` value” and says, for `unwrap_unchecked`, “Calling this method on `None` is undefined behavior”; it also specifies that a `Some` receiver yields its contained value ([`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). The same method contracts were independently checked in [1.84.1](https://doc.rust-lang.org/1.84.1/std/option/enum.Option.html#method.unwrap_unchecked), [1.85.0](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [1.85.1](https://doc.rust-lang.org/1.85.1/std/option/enum.Option.html#method.unwrap_unchecked), and [1.86.0](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked). These checks corroborate but do not purport to enumerate the release interval.
+
+The proof is exhaustive:
+
+- If `value = None`, accepted proposition (1) makes `is_none()` true; line 7 returns `0`, line 12 is unreachable, and both SOUND and RESULT hold.
+- If `value = Some(v)`, proposition (1) makes `is_none()` false; line 12 is reached with a non-`None` receiver. Its safety obligation is satisfied, and accepted proposition (2) makes the result `v`. Thus SOUND and RESULT hold.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact consumed proposition and scope | Consumers / trigger |
+|---|---|---|---|
+| STD-OPTION-184 | Versioned standard-library authority; verified | The two quoted 1.84.0 method contracts above. | Basis for COMPAT; revisit if those pages materially change. |
+| COMPAT-OPTION-184-186 | Compatibility premise; **accepted by the authorized human reviewer** | For every `Required` release/configuration, `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`, while calling it on `None` is UB. It establishes no release-set inventory, Cargo fact, backend, or binary fact. | O2–O4 and both verdicts; triggers exactly as stated in `TCB.md`. |
+
+No other premise, dependency, implementation, tool, deployment, or probabilistic trust is consumed. The accepted entry is not inferred from the sampled version pages; it is the explicit interval-coverage basis authorized by the request.
+
+## Finding DOC-1: local proof artifact is incomplete
+
+**Implementation obligation: PROVED. Proof-artifact classification: deficient.** The existing `SAFETY` comment captures the branch idea but neither names the semantic premise nor its applicability throughout `Required`. The material reconstruction is O2–O3 above. This does not weaken either verdict, but the smallest adequate repair is an adjacent comment such as:
+
+```rust
+// SAFETY: By accepted TCB entry COMPAT-OPTION-184-186, for every
+// supported configuration is_none() is true exactly for None. The true
+// branch returned above, so value is Some(v). The same entry preserves
+// unwrap_unchecked's contract: this call is permitted and returns v.
+```
+
+No caller-facing contract change is needed. Re-audit after any source, support predicate, method contract, TCB disposition, or configuration-scope change. Outside scope are unsupported toolchains/configurations and binary correctness. No tools, builds, tests, execution, or macro expansion were used as evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/D.md
new file mode 100644
index 0000000000..c14157b3be
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/D.md
@@ -0,0 +1,101 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Combined mandatory verdict: PROVED**, relative to accepted TCB entry
+`COMPAT-OPTION-184-186` in the supplied `TCB.md` (SHA-256
+`db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413`). For
+the exact supplied source, every well-typed safe call to `value_or_zero` is free
+of Rust undefined behavior and returns the contained byte for `Some(v)` or zero
+for `None`, throughout the supported set below. Soundness: **PROVED relative to
+that TCB entry**. Documented result: **PROVED relative to that TCB entry**.
+
+This is a source-level Rust-abstract-semantics claim, not a claim about compiler
+correctness or any emitted binary.
+
+## Snapshot, scope, and supported set
+
+The complete target consists of `Cargo.toml`, `TCB.md`, `CI.md`, `REQUEST.md`,
+`SUPPORT.md`, and `src/lib.rs`; the latter has SHA-256
+`6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8`.
+Scope is the entire `no_std`, edition-2021 library. It has no dependencies,
+build script, generated source, or prior audit.
+
+`SUPPORT.md` controls support (the manifest's `rust-version = "1.84"` is only
+the Cargo minimum). The exact predicate is:
+
+* released stable Rust `r` with `1.84.0 <= r <= 1.86.0`—namely 1.84.0,
+  1.84.1, 1.85.0, 1.85.1, or 1.86.0; the official notes record
+  [1.84.1](https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30)
+  and [1.85.1](https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18);
+* target `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or
+  `wasm32-unknown-unknown`;
+* either `telemetry` state, every Cargo profile, and either debug-assertion
+  state.
+
+CI is sampling only and supplies no proof. There are no source `cfg`s or uses
+of the feature, target, profile, assertions, allocation, arithmetic,
+concurrency, panic, FFI, assembly, macros, or linking. Thus one source/dataflow
+proof is parametric over every non-toolchain axis; the accepted TCB proposition
+explicitly covers every toolchain member and all those axes. No supported
+combination is uncovered.
+
+## Boundary and obligation inventory
+
+The sole language-reachable crate surface is safe free function
+`value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4-12`). There are no public
+fields/types, constructors, traits or impls, hidden items, statics, reexports,
+callbacks, macros, or FFI. The sole unsafe site is the internal
+`Option::unwrap_unchecked` call at line 11. There is no persistent state or
+abstraction invariant; only the dominating branch fact is consumed.
+
+| ID | Exact obligation | Derivation | Status |
+|---|---|---|---|
+| O1 | Safe callers have no hidden safety precondition. | The function accepts every `Option<u8>` and branches before its only unsafe operation. | PROVED |
+| O2 | Line 11 is never called on `None`. | Under `COMPAT-OPTION-184-186`, `is_none` is true exactly for `None`. Reaching line 11 means the test at line 5 returned false, so `value = Some(v)`. The same accepted entry states that `unwrap_unchecked(Some(v))` is defined and returns `v`, whereas `None` would be UB. | PROVED relative to TCB |
+| O3 | The documented result is returned. | If `None`, O2's `is_none` proposition makes line 6 return zero. If `Some(v)`, the test is false and O2 makes line 11 return `v`. These exhaustive cases establish the documentation at line 3. | PROVED relative to TCB |
+
+The Rust 1.84.0 base pages say `is_none` “[r]eturns `true` if the option is a
+`None` value” and `unwrap_unchecked` “[r]eturns the contained `Some` value”; they
+also state that calling it on `None` is undefined behavior
+([`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+The exact uniform proposition used above is nevertheless the human-accepted
+compatibility entry, not an inference from API stability. Its permitted
+consumers are precisely O2/O3; it supplies no release-membership, Cargo,
+backend, or binary fact.
+
+## Finding D1 — deficient adjacent proof, implementation proved
+
+The line 9 comment identifies the branch and callee precondition, but omits the
+material authoritative/TCB bridge and its supported-domain applicability.
+Implementation classification: **PROVED relative to
+`COMPAT-OPTION-184-186`**. Proof-artifact classification: **deficient**. No UB
+witness or defined postcondition refutation is established.
+
+Proposed replacement:
+
+```rust
+// SAFETY: By COMPAT-OPTION-184-186 throughout the supported domain,
+// value.is_none() is true exactly for None. Reaching here means it returned
+// false, so value is Some(v); unwrap_unchecked(Some(v)) is defined and returns v.
+```
+
+This documentation repair changes no API or behavior. Re-audit the proof if
+the source, documented result, support interval/axes, cited base propositions,
+or TCB disposition changes.
+
+## TCB, evidence, and residual scope
+
+`COMPAT-OPTION-184-186` is an accepted compatibility premise, scoped only as
+quoted above; its identity, consumers, exclusions, and re-audit triggers were
+verified. No dependency, tool-derived, test-derived, environmental,
+probabilistic, or implementation premise is consumed. The version-matched
+allowlisted standard-library pages for all five releases were checked and do
+not add a qualification, but they are not used to invent a general
+compatibility rule.
+
+Excluded: unsupported configurations, compiler/backend correctness, emitted
+binaries, and ordinary robustness beyond the requested documented result. No
+build, execution, macro expansion, or test was performed. No authoritative
+documentation gap or unresolved proof obligation remains.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/E.md
new file mode 100644
index 0000000000..1f9c0998f6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/E.md
@@ -0,0 +1,74 @@
+# Unsafe Rust audit — `symbolic-domain-target`
+
+## Claim and verdicts
+
+For the exact supplied snapshot, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior and returns the contained byte for `Some(v)`, or zero for `None`, throughout supported set **S**, relative to accepted TCB entry **COMPAT-OPTION-184-186**.
+
+- **Soundness: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- **Documented result: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- **Combined mandatory result: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- No binary/backend, deployment, security, probabilistic, or extra robustness claim is made.
+
+These are source-level Rust-abstract-semantics results. The accepted compatibility premise is indispensable and is not a claim that any compiler binary is correct.
+
+## Snapshot and supported domain
+
+The audited snapshot comprises all six supplied target files. SHA-256 identities:
+
+| File | SHA-256 |
+|---|---|
+| `CI.md` | `d3ff0564c4f96fcf7e9ff2784dbafcf1baa446c4d44cf3f55371e45b1687e46e` |
+| `Cargo.toml` | `7e25c6b1489e215d6e4ecdc8b7beea11fc35237b3207fb01e836e6c7b4e818f6` |
+| `REQUEST.md` | `161fad09885c67715d35859f24a1c41bd12bcba58c2cd7e1f933670bdda71d21` |
+| `SUPPORT.md` | `45ee272e31a71fe28da355624691db55439d234c92ae8be5ce1af460aed4069c` |
+| `TCB.md` | `db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413` |
+| `src/lib.rs` | `6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8` |
+
+At the 2026-08-01 audit cutoff, **S** is exactly: edition 2021; any released stable Rust `r` with `1.84.0 <= r <= 1.86.0`; target `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; either `telemetry` state; every Cargo profile; and either debug-assertion state. `SUPPORT.md` controls. `Cargo.toml` agrees on the lower bound and edition; its lack of an upper bound is expressly only Cargo admission, not a support conflict. `CI.md` is sample evidence and proves no semantic obligation.
+
+There are no dependencies, build script, generated/expanded artifacts, macros, `cfg` branches, target-specific operations, FFI, assembly, allocation, concurrency, or panic path. The feature is unused. One source implementation therefore applies parametrically to every axis; COMPAT-OPTION-184-186 expressly covers every member of S. No supported combination is uncovered. Releases entering the closed version interval after the cutoff require re-audit.
+
+## Boundary, contracts, and invariants
+
+The complete language-reachable crate surface is the safe public free function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields, types, constructors, methods, traits/impls, statics, reexports, hidden items, callbacks, macros, or destruction behavior defined by this crate. The sole unsafe surface is the internal call `value.unwrap_unchecked()`; callers have no safety obligation beyond passing a well-typed `Option<u8>`.
+
+**RESULT-1:** for every input, return `0` if it is `None`; return `v` if it is `Some(v)`. No persistent abstraction invariant exists. The only transient fact is **BRANCH-SOME**: on the fallthrough edge after `is_none()` returned false, the unchanged `value` is `Some(v)` for some `v`.
+
+## Authorities and TCB audit log
+
+The Rust 1.84.0 standard-library page declares `Option<T>` with only `None` and `Some(T)`. Its `is_none` contract says: “Returns `true` if the option is a `None` value.” ([1.84.0 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). Its unsafe method says it returns the contained `Some` value and: “Calling this method on `None` is undefined behavior.” ([1.84.0 `unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+
+**COMPAT-OPTION-184-186** is an accepted, authorized human compatibility premise from `TCB.md`. Exact admitted proposition: for every configuration in S, the 1.84.0 base propositions remain unweakened—`is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; calling it on `None` is UB. Category: out-of-band compatibility premise. Consumers: only SOUND-1 and RESULT-1 below. Limitations: it proves neither S's membership nor Cargo, backend, binary, or other-API facts. Disposition: accepted. Re-audit on any source, interval, base-proposition, target/feature, or disposition change. No other assumption, dependency trust, or tool result is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Obligation | Proof and applicability | Status |
+|---|---|---|---|
+| SOUND-1 | Every safe input avoids calling `unwrap_unchecked` on `None`. | Complete case split below; local control flow plus COMPAT-OPTION-184-186 over all S. | **PROVED relative to COMPAT-OPTION-184-186** |
+| RESULT-1 | Return zero for `None`, contained byte for `Some(v)`. | Same split plus the admitted return proposition, over all S. | **PROVED relative to COMPAT-OPTION-184-186** |
+
+Case `value = None`: COMPAT-OPTION-184-186 makes `is_none()` true. The dominating branch returns literal `0`; the unsafe call is not executed. This proves soundness and the `None` result.
+
+Case `value = Some(v)`: the same premise makes `is_none()` false. `is_none` only borrows the same value, so fallthrough establishes BRANCH-SOME. COMPAT-OPTION-184-186 then supplies both permission and result for `unwrap_unchecked(Some(v))`: the execution has no UB from that call and returns `v`. The two exhaustive `Option` cases prove both universal claims. There is no intervening mutation, callback, unwind, or alternative exit.
+
+## Finding DOC-1 — local proof omits its material authority
+
+- **Classification:** implementation obligations PROVED; proof artifact deficient; maintenance/documentation severity.
+- The adjacent `SAFETY` comment identifies the branch conclusion but does not name the exact `is_none` proposition or the accepted compatibility premise needed across S. This does not change the source verdict because the complete reconstruction appears above.
+- Proposed replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 states, over the complete supported
+// domain, that is_none is true exactly for None and that
+// unwrap_unchecked(Some(v)) returns v. The false branch above, which only
+// borrowed this unchanged value, therefore establishes value = Some(v).
+unsafe { value.unwrap_unchecked() }
+```
+
+No UB witness, UB-free postcondition refutation, authoritative-documentation gap, or skill-guidance gap was established.
+
+## Residual scope and review triggers
+
+Excluded: compiler/backend correctness, emitted binaries, unsupported configurations, and properties not requested. No build, execution, test, macro expansion, or tool-derived proof was used. Re-audit on any source/API/documentation change; support-axis or post-cutoff release change; material change to the cited pages; or weakening, rejection, or broader use of COMPAT-OPTION-184-186.
+
+All in-scope surfaces and obligations have a status; every supported configuration is covered; both mandatory claims expose their accepted TCB dependence. Independent second review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/F.md
new file mode 100644
index 0000000000..5cb31ea3f5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/F.md
@@ -0,0 +1,60 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Source-level soundness — PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior for every supported configuration.
+
+**Documented behavior — PROVED, relative to `COMPAT-OPTION-184-186`.** Every such call returns the contained byte for `Some(v)` and returns zero for `None`.
+
+**Combined mandatory result — PROVED, relative to `COMPAT-OPTION-184-186`.** This qualification is material: no result here applies that entry outside `value_or_zero`, its two named `Option` propositions, or the supported region.
+
+The supported predicate, controlled by `SUPPORT.md:3-21`, is exactly: released stable Rust `r` with `1.84.0 <= r <= 1.86.0`; target in `{x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`; either `telemetry` state; every Cargo profile; and either debug-assertion state. `Cargo.toml:5` supplies Cargo's minimum, not the upper support cutoff. `CI.md` is sampling evidence only and does not narrow this predicate.
+
+## Snapshot, scope, and boundary
+
+Audited source is the complete supplied six-file snapshot (`Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`); no revision, dependencies, generated artifacts, build script, lockfile, or prior audit was supplied. This was source review only: no target execution, build, test, expansion, or tool-derived proof was used. Edition is 2021 and the crate is `no_std`.
+
+The sole public surface is safe function `value_or_zero(Option<u8>) -> u8` (`src/lib.rs:3-12`). There are no public representation fields, constructors for a crate-owned type, traits or impls, macros, reexports, hidden APIs, callbacks, statics, FFI, or configuration-specific APIs. The sole unsafe operation is the internal `Option::unwrap_unchecked` call at `src/lib.rs:11`; it is not a caller-facing unsafe boundary. No persistent representation invariant exists. The only transient invariant is **BRANCH-SOME**: after the `is_none()` true branch returns, the still-owned `value` is `Some(v)`.
+
+## Authorities and TCB log
+
+Rust 1.84.0 standard-library documentation states that [`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) “Returns `true` if the option is a `None` value.” The version-matched [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) contract says it returns the contained `Some` value and that calling it on `None` is undefined behavior.
+
+`TCB.md:3-23` is the accepted human trust decision and the complete additional TCB:
+
+| ID | Disposition | Exact admitted proposition and domain | Consumers |
+|---|---|---|---|
+| `COMPAT-OPTION-184-186` | accepted | Across the entire supported Rust/target/feature/profile/debug domain, the 1.84.0 base propositions are preserved: `is_none()` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`, while invocation on `None` is UB. | Only soundness and documented-result proofs below |
+
+It admits neither release membership nor Cargo/backend/binary facts. No safe or unsafe dependency, compiler implementation, platform, deployment, or other compatibility premise is consumed. Its stated re-audit trigger is any source, support interval, base-proposition, feature/target-scope, or human-disposition change.
+
+## Obligation ledger and derivation
+
+| ID | Site / exact obligation | Derivation over the supported predicate | Status |
+|---|---|---|---|
+| O1 | `lib.rs:5-7`: `None` behavior | By `COMPAT-OPTION-184-186`, `is_none()` is true exactly on `None`; the dominating branch returns literal `0`. No unsafe operation executes. | PROVED relative to TCB |
+| O2 | `lib.rs:11`: do not call `unwrap_unchecked` on `None` | Reaching line 11 means the true branch did not execute, hence `is_none()` was false. The same TCB proposition yields BRANCH-SOME, so the callee's sole documented UB case is excluded. | PROVED relative to TCB |
+| O3 | `lib.rs:11`: `Some(v)` result | BRANCH-SOME and the TCB-preserved postcondition give `unwrap_unchecked(Some(v)) = v`; the function immediately returns it. | PROVED relative to TCB |
+| O4 | Safe API, all executions | `Option<u8>` exhausts the `None` case (O1) and `Some(v)` case (O2-O3). Thus every well-typed safe input is UB-free and meets the sole documented result contract. | PROVED relative to TCB |
+
+Configuration closure is parametric, not empirical: the source has no `cfg`, feature use, profile/debug-dependent assertion, target-dependent operation, allocation, panic/unwind branch, concurrency, FFI, generated code, or build-time input. Consequently the same control/data-flow proof applies to every Cartesian combination in `Supported`; `COMPAT-OPTION-184-186` supplies exactly the only version-sensitive semantics. CI contributes no proof.
+
+## Finding: local proof documentation is deficient
+
+**Documentation defect; implementation remains PROVED relative to the TCB.** The `SAFETY` comment at `src/lib.rs:9-10` correctly names the branch fact and callee precondition, but omits the material bridge that `is_none() == false` implies `Some(v)` throughout every supported Rust release, and it does not identify the accepted compatibility premise on which that bridge and the result proof depend.
+
+Proposed replacement:
+
+```rust
+// SAFETY: By COMPAT-OPTION-184-186, throughout the supported domain
+// `is_none()` is true exactly for `None`. This continuation therefore has
+// `value = Some(v)`; the same accepted premise preserves that
+// `unwrap_unchecked(Some(v))` is permitted and returns `v`.
+unsafe { value.unwrap_unchecked() }
+```
+
+This is a proof-artifact repair only; it adds no caller obligation or new contract.
+
+## Residual scope and triggers
+
+Compiler/backend and binary correctness, unsupported toolchains/targets, and undocumented robustness properties are excluded. Re-audit on any source or public-documentation change; change to the supported predicate; change/rejection of `COMPAT-OPTION-184-186` or either cited base contract; addition of dependencies, generated code, configuration branches, unsafe operations, or public surfaces. All in-scope obligations have a disposition; no UB witness or UB-free postcondition refutation is established or needed for the proved theorem.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/G.md
new file mode 100644
index 0000000000..0bf1a4a5b6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/G.md
@@ -0,0 +1,56 @@
+# Unsafe Rust Audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Soundness — PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` under `Supported(c)` is free of Rust undefined behavior under the documented Rust abstract semantics.
+
+**Documented behavior — PROVED, relative to the same accepted TCB entry.** In that domain, `value_or_zero(None) == 0` and `value_or_zero(Some(v)) == v` for every `v: u8`.
+
+**Combined mandatory result — PROVED, relative to accepted `COMPAT-OPTION-184-186`.** There is no conditional binary, deployment, security, or probabilistic claim.
+
+`Supported(c)` means: edition 2021; `c.r` is any released stable Rust toolchain satisfying `1.84.0 <= c.r <= 1.86.0`; target is exactly `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `telemetry` is disabled or enabled; and any Cargo profile and either debug-assertion state are used. This is the literal commitment in `SUPPORT.md`; `Cargo.toml`'s `rust-version = "1.84"` is only the Cargo minimum. The sources do not conflict. Audit cutoff: 2026-08-01.
+
+## Snapshot and scope
+
+The artifact is the exact supplied contents of `Cargo.toml`, `src/lib.rs`, `SUPPORT.md`, `CI.md`, `TCB.md`, and `REQUEST.md`; no repository revision or digest was supplied. The crate is `no_std`, has no dependencies or build script, and contains no generated source. Scope is the complete library and its documented safe behavior. No build, execution, test, expansion, or binary/backend claim was used. Skill identity: supplied `unsafe-rust` package, revision unspecified.
+
+The sole language-reachable public surface is safe function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields, types, constructors, trait implementations, macros, reexports, statics, callbacks, FFI items, hidden items, or destruction behavior owned by this crate. The only unsafe operation is `Option::unwrap_unchecked` at `src/lib.rs:11`. There is no persistent representation invariant; the only proof state is the local branch fact.
+
+## Authorities and TCB audit log
+
+The Rust 1.84.0 standard-library page says `is_none` “Returns `true` if the option is a `None` value” and declares `Option`'s `None` and `Some(T)` variants ([1.84.0 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). The version-matched `unwrap_unchecked` contract says it returns the contained `Some` value and is the controlling unsafe operation ([1.84.0 `unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+
+`TCB.md` is the canonical log. Its sole entry, `COMPAT-OPTION-184-186`, is **accepted by the authorized human reviewer**. It admits, for every `Supported(c)`, exactly: (1) `is_none` is true iff the value is `None`; and (2) `unwrap_unchecked(Some(v))` returns `v`, while calling it on `None` is UB. Category: accepted compatibility/out-of-band semantic premise; base identity: the two Rust 1.84.0 pages above. Consumers: only obligations O1–O3 below. It admits neither release membership nor Cargo/backend/other-API facts. No release enumeration is needed: the proof is universal over whichever released stable `r` satisfies the policy predicate. Trigger: any source, interval, base proposition, target/feature/profile/debug scope, or human-disposition change. The entry is precise, non-circular, within its authorized scope, and accepted; no other dependency, implementation, tool, or environmental premise is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Proposition and proof | Domain | Status |
+|---|---|---|---|
+| O1 | If line 11 is reached, `value` is `Some(v)`. On `None`, accepted `COMPAT-OPTION-184-186` makes `is_none()` true, so lines 5–6 return. If line 11 is reached, the test was false; the accepted iff proposition excludes `None`, and `Option`'s exhaustive remaining variant is `Some`. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O2 | The unsafe call never receives `None`; by O1 it receives `Some(v)`. Accepted `COMPAT-OPTION-184-186` therefore gives a defined return of `v`, discharging the exact unsafe precondition. The `None` branch executes no unsafe operation. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O3 | For `None`, accepted `is_none` semantics select line 6, yielding zero. For `Some(v)`, they select line 11, and accepted `unwrap_unchecked` semantics yield `v`. These cases exhaust `Option<u8>`. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O4 | Configuration closure: source has no `cfg`; `telemetry` is declared but unused; target, profile, and debug assertions select no path; there are no allocation, panic, arithmetic, concurrency, FFI, or generated-code obligations. O1–O3 are parametric, and the accepted TCB explicitly has the same configuration quantification. | Entire `Supported(c)` | PROVED relative to accepted TCB |
+
+`CI.md` describes only samples (1.84.0 on one target/feature state and 1.86.0 across targets/feature states). It neither defines support nor contributes proof evidence. No tool-derived evidence was used.
+
+## Finding D1 — deficient adjacent proof artifact
+
+**Implementation classification:** PROVED relative to accepted `COMPAT-OPTION-184-186`. **Proof-artifact classification:** deficient. Lines 9–10 state the correct branch idea, but omit the material `is_none` iff premise, exhaustive-variant step, applicability, accepted TCB bridge, and `unwrap_unchecked(Some(v))` postcondition. This is not an implementation defect, UB witness, or defined postcondition refutation.
+
+Proposed replacement:
+
+```rust
+// SAFETY: Under accepted COMPAT-OPTION-184-186 throughout Supported(c),
+// is_none is true iff value is None. Reaching here means it returned false;
+// Option has only None and Some variants, so value is Some(v). Under the same
+// entry, unwrap_unchecked(Some(v)) is defined and returns v.
+unsafe { value.unwrap_unchecked() }
+```
+
+Minimum resolution: add an adjacent proof with a stable local link to the canonical TCB entry and authoritative contracts. This is documentation maintenance, not a change to the caller contract.
+
+## Residual scope and attestation
+
+Excluded: configurations outside `Supported(c)`, compiler/backend and emitted-binary correctness, non-Rust environments, and undocumented robustness properties. No supported source configuration is uncovered. Re-audit on any source/API/documentation change; support/edition/target/feature/profile/debug change; material change to the cited Rust contracts; TCB disposition or proposition change; dependency/build-generation introduction; or a newly discovered obligation.
+
+Every public surface, unsafe site, mandatory postcondition, supported configuration class, citation, and consumed TCB premise has a disposition above. Every `PROVED` result is expressly relative to the accepted TCB; no absence-of-counterexample or test inference is used. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/H.md
new file mode 100644
index 0000000000..641c035a37
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/H.md
@@ -0,0 +1,53 @@
+# Unsafe Rust Audit: `symbolic-domain-target` complete supplied snapshot
+
+## Claims and verdicts
+
+Let `D` be all tuples `(r,t,f,p,d)` where `r` is a released stable Rust toolchain and `1.84.0 <= r <= 1.86.0`; `t` is `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `f` is either state of `telemetry`; `p` is any Cargo profile; and `d` is either debug-assertion state.
+
+| Claim | Exact source-level theorem for every configuration in `D` and every well-typed safe call | Verdict |
+|---|---|---|
+| SOUND | `value_or_zero` executes without Rust undefined behavior | **PROVED relative to accepted TCB entry `COMPAT-OPTION-184-186`** |
+| RESULT | `None` returns `0`; `Some(v)` returns `v` | **PROVED relative to accepted TCB entry `COMPAT-OPTION-184-186`** |
+
+**Combined mandatory result: PROVED over exactly `D`, relative to `COMPAT-OPTION-184-186`.** This is an abstract Rust source theorem, not a compiler/backend or emitted-binary theorem.
+
+## Snapshot and scope
+
+The complete supplied package is edition 2021, `#![no_std]`, has no dependencies or build script, and contains one library source file. Relevant SHA-256 identities are: `src/lib.rs` `6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8`; `Cargo.toml` `7e25c6b1489e215d6e4ecdc8b7beea11fc35237b3207fb01e836e6c7b4e818f6`; `SUPPORT.md` `45ee272e31a71fe28da355624691db55439d234c92ae8be5ce1af460aed4069c`; and `TCB.md` `db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413`. `REQUEST.md`, `CI.md`, and every supplied target file were reviewed. Audit cutoff: 2026-08-01. No code was generated, expanded, built, run, or tested; no prior audit was reused.
+
+## Domain recovery and configuration closure
+
+`SUPPORT.md` is explicit that its closed toolchain interval, including the upper cutoff, is the project commitment. Its predicate is crossed with the three enumerated targets, both feature states, every profile, and both debug-assertion states; this is exactly `D`, with no normalization to a finite release inventory. `Cargo.toml`'s `rust-version = "1.84"` is expressly only Cargo's minimum and is consistent with, but does not replace, that policy. `CI.md` lists samples only and supplies neither domain membership nor semantic proof.
+
+The source has no `cfg`, feature-conditioned item, profile-dependent check, arithmetic, target operation, dependency, macro, FFI, assembly, allocation, concurrency, or generated artifact. Its proof is therefore parametric in `t`, `f`, `p`, and `d`. Version coverage is parametric in `r` through the accepted TCB entry, rather than inferred from endpoints or sampled documentation.
+
+For every `c in D`, the proof below covers both valid `Option<u8>` variants. Hence each obligation's `Covered` predicate is `D`; their pointwise intersection is `D`, and `Required = D subseteq Covered = D`. No supported configuration is excluded or unresolved.
+
+## Boundary, invariant, and obligation ledger
+
+The only crate-defined language-reachable API is the safe free function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields or types, crate constructors, traits/impls, methods, statics, macros, reexports, hidden items, callbacks, FFI entrypoints, or configuration-specific APIs. The sole unsafe surface is the internal call `value.unwrap_unchecked()`.
+
+The only invariant is transient `FALLTHROUGH-SOME`: from completion of the false `is_none` branch until the consuming unsafe call, the owned, immutable local `value` is `Some(v)`. It is established by the branch and `COMPAT-OPTION-184-186`; no assignment, alias-capable callback, or other operation intervenes.
+
+| Obligation | Required proposition | Derivation and status |
+|---|---|---|
+| O1 branch classification | `is_none` distinguishes `None` from `Some(v)` | The accepted entry preserves the exact classification throughout `D`. **PROVED** |
+| O2 unsafe precondition | the receiver of `unwrap_unchecked` is not `None` | Only fallthrough reaches the call; O1 and unchanged ownership establish `FALLTHROUGH-SOME`. **PROVED** |
+| O3 unsafe result | `unwrap_unchecked(Some(v))` returns `v` | The accepted entry preserves this base proposition throughout `D`. **PROVED** |
+| O4 documented result | `None -> 0`, `Some(v) -> v` | `None` returns before unsafe; `Some(v)` uses O2/O3. **PROVED** |
+
+The adjacent `SAFETY` comment identifies the dominating return, derives `Some`, and names the callee precondition; it is adequate. Full case proof: for `None`, O1 makes the condition true and the function returns `0` without reaching unsafe code. For `Some(v)`, O1 makes it false; the immutable value remains `Some(v)`; O2 permits the unsafe call and O3 returns `v`. These cases exhaust valid safe inputs, proving UB freedom and the complete documented behavior.
+
+## TCB audit log
+
+**Log identity:** supplied `TCB.md`, SHA-256 above. **Trust policy:** only its authorized, accepted proposition is admitted; no implementation, compiler, dependency, or environmental premise is added.
+
+`COMPAT-OPTION-184-186` is accepted by the authorized human reviewer. Its base authorities are the Rust 1.84.0 [`Option::is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) and [`Option::unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) pages. Verified relevant text states: “Returns true if the option is a None value”; “Returns the contained Some value”; and “Calling this method on None is undefined behavior.” The entry admits that the exact classification and `Some(v)` result/`None` UB propositions are preserved, without weakening, for every `r` and configuration in `D`. Consumers are O1–O4 only. It establishes neither interval membership nor Cargo/compiler/backend facts. Re-audit is required for any source, support interval, base proposition, feature/target scope, or human-disposition change. No rejected, pending, unused, or additional entries exist.
+
+## Evidence, findings, and residual scope
+
+No tool-derived evidence was used. **Findings: none.** Every required obligation is proved; there is no documentation gap, unresolved domain, or postcondition failure.
+
+Excluded from this source theorem are invalid values created by out-of-scope unsafe caller behavior, unsupported configurations, compiler/backend correctness, emitted binaries, and deployment properties. Re-audit on any source/API/documentation change, support/configuration expansion, material authoritative-document change, or change to `COMPAT-OPTION-184-186`.
+
+Final attestation: all safe and unsafe surfaces, target files, controlling domain expressions, mandatory postconditions, premise applicability, and TCB consumers have a disposition; `Required subseteq Covered` is established; the verdict does not rely on CI, tests, or absence of a counterexample.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/I.md
new file mode 100644
index 0000000000..f83b5b1563
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/I.md
@@ -0,0 +1,60 @@
+# Unsafe Rust Audit: complete supplied snapshot
+
+## Claims and verdicts
+
+| Claim | Exact theorem | Verdict | Certificate and qualification |
+|---|---|---|---|
+| SOUND | For every well-typed safe call to `value_or_zero` in `Required`, execution is free of Rust undefined behavior under documented Rust abstract semantics. | **PROVED** | OBL-1 and configuration closure below, **relative to accepted TCB entry `COMPAT-OPTION-184-186`**. |
+| RESULT | For every such call, `None` returns `0` and `Some(v)` returns `v`. | **PROVED** | OBL-2 below, **relative to accepted TCB entry `COMPAT-OPTION-184-186`**. |
+
+**Combined mandatory result: PROVED**, relative to `target/TCB.md` as supplied. This is a source-level result, not a compiler-backend or binary theorem.
+
+## Snapshot, scope, and contracts
+
+The audited artifact is the exact supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, and `src/lib.rs`; `REQUEST.md` controls this review. It is a Rust-2021 `#![no_std]` library, has no declared dependencies, build script, generated source, macros, FFI, allocator use, concurrency, or mutable state. No prior audit or tool result was reused; the target was not built, run, tested, modified, or expanded.
+
+The complete language-reachable public surface is the safe free function `value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4`). There are no public fields, constructors, traits/impls, methods, hidden items, reexports, unsafe APIs, or configuration-specific APIs. Its documentation is normative: “Returns the contained byte, or zero when `value` is `None`.” Safe callers have no safety precondition. There is no abstraction invariant: the function owns its input and retains no state.
+
+## Required domain and closure
+
+`SUPPORT.md`, expressly identified there as the support commitment, defines
+
+`Required = R × T × F × P × D`, where:
+
+- `R = { released stable r | 1.84.0 <= r <= 1.86.0 }`;
+- `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`;
+- `F = {telemetry disabled, telemetry enabled}`;
+- `P = every Cargo profile`; and
+- `D = {debug assertions disabled, debug assertions enabled}`.
+
+Edition 2021 and the standard library bundled with `r` are fixed additional coordinates. The official version history through 1.86.0 gives the exhaustive release inventory `R = {1.84.0, 1.84.1, 1.85.0, 1.85.1, 1.86.0}` ([1.84.1 section](https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30), [1.85.1 section](https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18)). Thus the inventory equals the symbolic interval; it is not inferred from endpoints. `Cargo.toml`'s `rust-version = "1.84"` supplies only the stated Cargo minimum and does not erase the upper bound. `CI.md` is sampling evidence only and does not narrow or prove support.
+
+There is no `cfg`, profile-sensitive operation, debug assertion, or use of `telemetry`; every required tuple selects the same function body. The accepted TCB entry explicitly covers both required `Option` propositions for every `r`, target, feature state, profile, and debug-assertion state in `Required`. Therefore each obligation below has `Covered = Required`, their pointwise intersection is `Required`, and `Required ⊆ Covered`. Panic strategy, optimization, overflow checks, target layout, and allocator choice do not enter the derivation.
+
+## Obligation ledger and proof
+
+| ID | Site and exact obligation | Derivation | Status |
+|---|---|---|---|
+| OBL-1 | `src/lib.rs:5-11`: `unwrap_unchecked` is reached only on `Some`. | If `is_none()` is true, line 6 returns before the unsafe call. If false, AXIOM-OPTION-184 plus COMPAT says the input is not `None`; exhaustive `Option<u8>` variants make it `Some(v)`. COMPAT then permits `unwrap_unchecked(Some(v))` and says it returns `v`. | **PROVED throughout `Required`, relative to COMPAT**. |
+| OBL-2 | Documented result for all inputs. | `None`: COMPAT's exact `is_none` proposition selects line 6, returning `0`. `Some(v)`: it selects the fallthrough, and COMPAT's exact unwrap proposition returns `v`. These exhaustive cases also include `Some(0)`. | **PROVED throughout `Required`, relative to COMPAT**. |
+
+The adjacent `SAFETY` comment identifies the dominating `None` return, derives `Some`, and names the callee precondition. Its implementation proof is adequate; the report-level TCB citation supplies the version/configuration applicability. No panic, unwind, destructor, alias, provenance, initialization, or arithmetic obligation remains.
+
+## TCB audit log
+
+**Log identity:** supplied `target/TCB.md`, entry `COMPAT-OPTION-184-186`; human disposition accepted. **Trust policy:** consume only versioned Rust documentation and that exact accepted proposition; no dependency, implementation, backend, platform, or binary premise is admitted.
+
+| ID | Category and exact proposition | Scope/consumer/disposition |
+|---|---|---|
+| AXIOM-OPTION-184 | Rust 1.84.0 docs state that `is_none` returns true for `None` ([source](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)); `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB ([source](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). | Rust 1.84.0 base propositions; verified authoritative basis for COMPAT. |
+| COMPAT-OPTION-184-186 | Preserves, without weakening or added precondition, “`is_none` iff `None`” and “unwrap `Some(v)` to `v`; `None` is UB.” | Exactly `Required`; only OBL-1/2; **accepted by authorized human**. No interval-membership, Cargo, backend, or binary fact is consumed. |
+
+The entry is minimal, non-vacuous, and used only by its named consumers. Re-audit is required on any source, support interval, base proposition, target/feature/profile/debug scope, or disposition change. There are no dependencies or unresolved/rejected premises.
+
+## Findings, residual scope, and attestation
+
+No soundness, contract, proof-documentation, authoritative-documentation, or skill-guidance finding remains. No additional robustness property was requested, and no tool-derived evidence was used.
+
+Excluded from the theorem are unreleased, pre-1.84.0, post-1.86.0, nightly/beta/custom toolchains; other targets or feature names; compiler/backend correctness; emitted binaries; and behavior beyond the documented return value. These are theorem boundaries, not inferred project exclusions. Review must recur if source/API documentation, support policy, Cargo configuration, generated inputs, authoritative pages, or the TCB entry changes.
+
+Attestation: every safe/unsafe surface, obligation, documented result, controlling domain expression, TCB consumer, and required configuration class in the supplied snapshot has a disposition. The verdict follows the required universal coverage certificate, not tests or absence of a counterexample. Audit date: 2026-08-01; independent second review not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/J.md
new file mode 100644
index 0000000000..de72a5364a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/reports/J.md
@@ -0,0 +1,52 @@
+# Unsafe Rust audit: `symbolic-domain-target` 0.1.0
+
+## Claim and verdict
+
+| Claim | Exact theorem | Verdict |
+|---|---|---|
+| SOUND | For the supplied source and every configuration in `Required`, every well-typed safe call `value_or_zero(value: Option<u8>)` is free of Rust undefined behavior. | **PROVED relative to accepted `COMPAT-OPTION-184-186`** |
+| RESULT | Under the same quantification, the function returns `0` for `None` and the contained byte for `Some(b)`. | **PROVED relative to accepted `COMPAT-OPTION-184-186`** |
+
+The combined mandatory result is **PROVED relative to `TCB.md` as supplied**, specifically its conspicuous human-accepted compatibility premise `COMPAT-OPTION-184-186`. This is a source-level Rust-abstract-semantics result, not a compiler-backend or binary claim.
+
+Snapshot: the complete supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`; edition 2021, `#![no_std]`, `rust-version = "1.84"`, no Cargo dependencies, build script, generator, or generated artifact. No prior audit or tool-derived evidence was used. Audit cutoff: 2026-08-01. Skill identity: supplied `unsafe-rust` package; no revision was provided.
+
+## Required domain and configuration closure
+
+Let `ReleasedStable(r)` retain its literal policy meaning, `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`, `F = {telemetry off, telemetry on}`, `D = {debug assertions off, debug assertions on}`, and `P` be the symbolic set of all Cargo profiles. `SUPPORT.md` states exactly:
+
+`Required(r,t,f,p,d) = ReleasedStable(r) ∧ 1.84.0 ≤ r ≤ 1.86.0 ∧ t∈T ∧ f∈F ∧ p∈P ∧ d∈D`.
+
+This is a literal normalization, hence equality in both directions; no release or profile enumeration is substituted. `Cargo.toml` supplies only Cargo's lower acceptance bound, while `SUPPORT.md` expressly controls the project promise including its upper cutoff. `CI.md` samples 1.84.0/x86_64/no-feature and 1.86.0/all targets/both features; it is not support-definition or semantic proof evidence.
+
+Actual source-selection axes are empty: neither `telemetry`, `cfg`, target, profile, nor `debug_assertions` occurs in `lib.rs`. There are no allocator, FFI, assembly, concurrency, macro, dependency, panic, arithmetic, generated-code, or linking obligations in the function. The derivation below is syntactically identical across `t,f,p,d`; accepted `COMPAT-OPTION-184-186` supplies the two consumed `Option` propositions parametrically for every `r,t,p,f,d` in `Required`. Therefore each obligation's `Covered = Required`, their pointwise intersection is `Required`, and `Required ⊆ Covered` follows by identity. The cutoff does not enumerate releases and is not used as continuity evidence.
+
+## Boundary, invariant, and obligation coverage
+
+The only language-reachable crate surface is the public safe free function `value_or_zero` (`src/lib.rs:3-12`). There are no public fields, constructors of an owned representation, methods, traits/impls, reexports, macros, hidden items, statics, callbacks, FFI entrypoints, or custom destruction. The sole unsafe operation is `Option::unwrap_unchecked` at line 11. No persistent representation invariant exists. The transient fact `INV-NONNONE` is: after the `if value.is_none() { return 0; }` fallthrough, `value` is not `None`; the branch produces it and line 11 consumes it.
+
+| ID | Obligation and proof | Domain | Status |
+|---|---|---|---|
+| O1 | `is_none` classifies `None` exactly. This is the accepted preserved base proposition; the true branch returns before line 11. | `Required` | PROVED, TCB-relative |
+| O2 | `unwrap_unchecked` is not called on `None`. Reaching line 11 means `is_none()` was false; O1 gives `INV-NONNONE`, exactly discharging the unsafe call's condition. | `Required` | PROVED, TCB-relative |
+| O3 | Result: on `None`, O1 takes the branch and returns `0`; on `Some(b)`, O1 falls through and the accepted `unwrap_unchecked(Some(b)) = b` proposition returns `b`. These cases exhaust `Option<u8>`. | `Required` | PROVED, TCB-relative |
+| O4 | Configuration closure. Source and control flow are independent of every non-release axis, and the accepted premise covers the complete symbolic release predicate and all stated axes. | `Required` | PROVED, TCB-relative |
+
+The adjacent `SAFETY` comment is adequate: it names the dominating `None` return, derives `Some` at the call, and identifies that fact as `unwrap_unchecked`'s precondition. The proof above exposes the otherwise project-level version/configuration premise. Every normal exit re-establishes the result contract; there is no mutation, unwind point, callback, aliasing, allocation, or retained capability.
+
+## TCB audit log
+
+Log identity: supplied `TCB.md`, reviewed for this audit; disposition **accepted by the authorized human reviewer**.
+
+| ID/category | Exact proposition, identity, scope, consumers | Disposition and limits |
+|---|---|---|
+| BASE-OPTION-184 / AXIOM | Rust 1.84.0 [`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) says it returns true for `None`; [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) returns the contained `Some` value and makes `None` undefined behavior. Base for O1-O3. | Version-matched authoritative base text inspected. |
+| COMPAT-OPTION-184-186 / accepted compatibility premise | Without weakening, qualification, or added precondition, preserves exactly: (1) `is_none` is true exactly for `None`; (2) `unwrap_unchecked(Some(v))` returns `v`, and calling it on `None` is UB; for every released stable `r` in the inclusive interval, all supported targets/profiles, either feature state, and either debug-assertion state. Consumers: only O1-O3 and the two verdicts. | **Accepted.** Establishes neither interval membership, Cargo facts, other APIs, backend correctness, nor emitted binaries. Re-audit on any source, interval, base-proposition, feature/target-scope, or disposition change. |
+
+No other compatibility, dependency, implementation, environment, probabilistic, or tool premise is consumed. The selected premise does not assume the in-scope implementation conclusion; it only transports two standard-library contracts across the exact symbolic domain.
+
+## Findings, residual scope, and triggers
+
+All in-scope obligations have complete derivations; there is no `UNPROVED`, `UNSOUND`, `CONTRACT-BROKEN`, proof-documentation, authoritative-documentation, or skill-guidance finding. Broader robustness, binary correctness, backend/linker behavior, and unsupported configurations were not claimed or audited. Re-audit is required if any supplied source or contract changes; `Required` expands or changes; the authoritative base text or accepted TCB disposition changes; generated code, dependencies, or configuration-sensitive code appears; or a new consumer relies on the premise.
+
+Auditor: source-review agent. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/PACKET.json
new file mode 100644
index 0000000000..53138aa0e3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "c800f0c77ac630cbe60f1068cd172d32bc711d0a8ebe918c609996a8a3141977",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "S",
+  "presentation_order": [
+    "J",
+    "E",
+    "F",
+    "I",
+    "B",
+    "G",
+    "H",
+    "C",
+    "D",
+    "A"
+  ],
+  "report_sha256": {
+    "A": "d135ad89e2b402af49206d79186ad5f4454716f99c32debe93ff458ed07d086e",
+    "B": "44941853a2458104b934dfa73aa5411c39c4e5c0ac33730d7bd754757f96e176",
+    "C": "4661ad891ae68f808fefc57a29a5b2d1ee36364508329ddb3163e18761d0b9ad",
+    "D": "cae33ebb10f593bbebe9722ae1b12d2a8e1ebbeaa477704ed16d61296c964bae",
+    "E": "2ce56cb39ecd21ba188269290a81702a5f56f4eb84cf09a916a019a850d4436a",
+    "F": "63ff5fdf0f56585dca05bde1ea6b36f118c19ad66ef40b0a10ff43349399c0ad",
+    "G": "a4e4c1ea234c10cd9830139d9c8c2d59a1da533003609c68cb81cb4a22a366d9",
+    "H": "d91ac2821d69b57dd7bd98303059093769e6e2b6b99226936b2bf4edc90cdd32",
+    "I": "aaf0fe262d82d837f4f011b5707956852b8db0df9830d91ec927d0ce16fcbd8a",
+    "J": "f5b0a2be88ccf8436af7044f8a321be0582d57dacffa84012c994a705779dc77"
+  },
+  "rubric_sha256": "d215ac1a4ed2e150f369b28aa12a4d77cf391c94ce47a98fccf132ad6a0c60f3",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "0f07b43abcc96fddcabc7db2e1be66a3f28f5a793f2cceebe19590c3dd7aec9b"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/RUBRIC.md
new file mode 100644
index 0000000000..b7dd209431
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/RUBRIC.md
@@ -0,0 +1,111 @@
+# Mode S Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## S — Symbolic Interval and Parametric Superset
+
+### Intended theorem domain
+
+Let:
+
+```text
+R_S = { r | StableRustRelease(r) and 1.84.0 <= r <= 1.86.0 }
+T_S = { x86_64-unknown-linux-gnu,
+        aarch64-apple-darwin,
+        wasm32-unknown-unknown }
+F_S = { telemetry-off, telemetry-on }
+O_S = { None } union { Some(b) | b is any u8 }
+```
+
+The exact requested case predicate is:
+
+```text
+Required_S(r, t, f, p, d, o)
+  iff r in R_S and t in T_S and f in F_S and p in P and d in D and o in O_S.
+```
+
+This predicate is symbolic. It is not the CI matrix or the Cargo minimum. It
+contains non-`.0` stable releases such as Rust 1.84.1 and 1.85.1, but a report
+may preserve the exact symbolic predicate without enumerating any members.
+
+Define `Q_Option(r)` to mean that the two required `Option` propositions have
+been established for release `r` by either of two admissible bases:
+
+1. the Rust 1.84.0 base authorities plus accepted entry
+   `COMPAT-OPTION-184-186` over its exact region; or
+2. an exact finite partition that proves the released members of `R_S` are
+   `{1.84.0, 1.84.1, 1.85.0, 1.85.1, 1.86.0}` and verifies the two exact
+   versioned pages for every member.
+
+The intended proof cases are:
+
+```text
+Covered_S = { (r,t,f,p,d,o) | Q_Option(r), and t/f/p/d/o are otherwise arbitrary }.
+```
+
+The source derivation is parametric in `t`, `f`, `p`, and `d`; it need not and
+should not be expanded into their Cartesian product. Applicability still must
+establish `R_S subset-of {r | Q_Option(r)}`. Either admissible basis above can
+do so. A merely report-authored compatibility proposal, generic stability
+assertion, endpoint sampling, or incomplete release partition cannot.
+
+### Expected verdicts
+
+- Safe-API soundness over `Required_S`: **PROVED**, either from the exact
+  finite authoritative partition or relative to `COMPAT-OPTION-184-186`.
+- The documented `None -> 0` and `Some(b) -> b` behavior over `Required_S`:
+  **PROVED** on the same basis and with the TCB qualification whenever that
+  entry is consumed.
+- Configuration closure: **PROVED** on the chosen basis, because
+  `Required_S subset-of Covered_S`.
+
+The local proof is: `is_none()` returning true takes the `return 0` branch. If
+the unsafe call is reached, `is_none()` returned false; since `Option` has only
+`None` and `Some`, the unchanged, still-owned value is `Some`. This discharges
+`unwrap_unchecked`'s exact precondition, and its return contract supplies the
+contained byte. No target, feature, profile, or debug-assertion fact enters the
+derivation.
+
+### Atoms
+
+- **S1 — Lossless domain recovery:** States `R_S` as the closed symbolic
+  stable-release predicate and keeps the three targets and both feature states.
+  It does not substitute Cargo's lower bound or CI's rows for the policy. Exact
+  symbolic notation passes without naming any particular patch release.
+- **S2 — Premise applicability:** Uses one complete admissible evidence basis:
+  either verifies the 1.84.0 base, applies only fixture-supplied accepted entry
+  `COMPAT-OPTION-184-186`, and keeps that admission conspicuous; or proves the
+  exact five-member release partition and verifies both exact pages for every
+  member. A report-authored premise, partial partition, or mixed gap does not
+  pass.
+- **S3 — Local safety proof:** Gives the reachability/variant argument that
+  reaching `unwrap_unchecked` implies the unchanged, still-owned value is
+  `Some`, thereby discharging the exact unsafe precondition.
+- **S4 — Local behavioral proof:** Shows that `None` returns zero and `Some(b)`
+  returns `b`, using the applicable exact `Option` propositions.
+- **S5 — Parametric configuration coverage:** Shows that the local derivation
+  is independent of target, feature, profile, and debug assertions and covers
+  their complete product without Cartesian enumeration.
+- **S6 — Soundness closure and verdict:** Establishes
+  `Required_S subset-of Covered_S` for the soundness theorem and reports
+  soundness `PROVED` over the exact policy domain, conspicuously qualified by
+  `COMPAT-OPTION-184-186` if and only if that route was consumed.
+- **S7 — Behavioral closure and verdict:** Establishes
+  `Required_S subset-of Covered_S` for the documented result theorem and
+  reports behavior `PROVED` over the exact policy domain, conspicuously
+  qualified by `COMPAT-OPTION-184-186` if and only if that route was consumed.
+
+### Hard-error triggers
+
+A report commits a hard error if it:
+
+- claims full closure or an affirmative whole-domain result after contracting
+  the release predicate to `.0` releases, CI rows, or the Cargo minimum;
+- calls endpoints, a toolchain pin, or sparse documentation a proof of every
+  interior release and then claims `PROVED`;
+- silently invents or accepts a report-authored compatibility premise, or hides
+  the fixture TCB qualification after consuming that entry;
+- claims closure while leaving a `Required_S` region outside its proof;
+- finds `None` reachable at `unwrap_unchecked`; or
+- gives an unqualified `UNSOUND` or `CONTRACT-BROKEN` verdict for the shown
+  source.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/allowlist.txt
new file mode 100644
index 0000000000..f13c981a34
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/allowlist.txt
@@ -0,0 +1,12 @@
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.84.1/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.84.1/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.85.1/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.85.1/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.is_none
+https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked
+https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30
+https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/A.md
new file mode 100644
index 0000000000..3a76df465c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/A.md
@@ -0,0 +1,64 @@
+# Unsafe Rust audit: supplied `symbolic-domain-target` snapshot
+
+## Claims and verdicts
+
+**Soundness theorem.** For every well-typed safe call to `value_or_zero` in every supported configuration defined below, execution is free of Rust undefined behavior under the documented Rust abstract semantics.
+
+**Soundness verdict: PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** That qualification is material: the proof consumes both propositions preserved by that entry throughout the complete supported Rust/configuration domain.
+
+**Documented-behavior theorem.** In the same domain, `value_or_zero(None) == 0`, and for every `b: u8`, `value_or_zero(Some(b)) == b`.
+
+**Documented-behavior verdict: PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** Combined mandatory result: **PROVED relative to `COMPAT-OPTION-184-186`**. No conditional application or binary claim is made.
+
+## Snapshot and supported set
+
+Scope is the complete supplied source snapshot: package `symbolic-domain-target` 0.1.0, edition 2021, `rust-version = "1.84"`, `#![no_std]`, manifest, policy, CI, and TCB files. There are no dependencies, lockfile, build script, generated source, macros, FFI, assembly, allocator selection, concurrency, or prior audit.
+
+`Supported(c)` means: `c` uses a released stable Rust toolchain `r` with `1.84.0 <= r <= 1.86.0`; target is exactly `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `telemetry` is either disabled or enabled; Cargo profile is arbitrary; and debug assertions are either disabled or enabled. `SUPPORT.md`, including its upper cutoff, is controlling. `Cargo.toml` only supplies Cargo's lower acceptance bound. `CI.md` is sampling evidence and neither defines nor proves support.
+
+This audit uses the policy predicate parametrically; it need not guess or freeze the interval's patch-release membership. Source identity is the supplied files, with an audit cutoff of this review. Unlisted configurations are outside the claimed theorem by the explicit support commitment; no build-time rejection is claimed.
+
+## Boundary, surfaces, and invariant
+
+The sole crate API surface is safe public function `value_or_zero(Option<u8>) -> u8`. It has no public fields, constructors, traits/impls, associated items, reexports, hidden items, statics, callbacks, operators, custom destruction, or configuration-generated variants. The sole unsafe operation is the internal call to `Option::unwrap_unchecked`; there is no public unsafe API and therefore no caller safety obligation.
+
+`INV-BRANCH`: at the unsafe call, the unchanged local `value` is `Some(b)` for some `b`. Its owner is the function's straight-line control flow. The `is_none` check establishes it on the fallthrough edge; no mutation, callback, or other intervening operation can suspend it; `unwrap_unchecked` consumes it.
+
+## Obligation ledger and reconstructed proof
+
+| ID | Exact obligation and derivation | Domain | Status |
+|---|---|---|---|
+| OBL-1 | `value.is_none()` is true exactly when `value` is `None`. This is the base [`is_none` contract](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), whose relevant text is “Returns true if the option is a `None` value,” carried over the domain by `COMPAT-OPTION-184-186`. | All `Supported(c)` | PROVED relative to the TCB entry |
+| OBL-2 | On fallthrough, the check returned false. By OBL-1 and `Option`'s two variants, `value = Some(b)`. `is_none` only borrowed the by-value local, and no transition follows, establishing `INV-BRANCH`. | All inputs/configurations | PROVED relative to the TCB entry |
+| OBL-3 | [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) requires non-`None`; its safety text says calling it on `None` is undefined behavior. OBL-2 proves the precondition. `COMPAT-OPTION-184-186` additionally preserves that `unwrap_unchecked(Some(b))` returns `b`. | All fallthrough executions in `Supported(c)` | PROVED relative to the TCB entry |
+| OBL-4 | If the check is true, OBL-1 gives `None` and the explicit return yields 0 without unsafe execution. If false, OBL-2/3 give `Some(b)` and result `b`. These exhaustive paths prove the documented result. | All safe inputs/configurations | PROVED relative to the TCB entry |
+
+The derivation is uniform across targets, releases, features, profiles, and assertion states: the source contains no `cfg`, feature use, target branch, assertion, overflow, allocation, or profile-sensitive operation. The accepted TCB proposition expressly quantifies over every supported value of those axes, so their Cartesian product is closed by the same proof.
+
+## TCB audit log
+
+| ID | Disposition | Exact consumed proposition | Consumers / limitations |
+|---|---|---|---|
+| `COMPAT-OPTION-184-186` | Accepted by the authorized human reviewer | For every released stable `r` in 1.84.0–1.86.0 and all supported targets/profiles/feature/assertion states, Rust preserves: `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; calling it on `None` is UB. Base authority is the linked Rust 1.84.0 standard-library documentation. | OBL-1–4 and both verdicts only. It establishes no interval membership, Cargo fact, other API, backend, or binary property. |
+
+No other admitted premise is consumed. Source-level reasoning does not trust a particular compiler backend. Re-audit is required on any source, support-domain, base-contract, feature/target, or human-disposition change.
+
+## Finding DOC-1: adjacent proof is incomplete
+
+**Classification:** implementation obligation PROVED; proof artifact deficient; no UB witness and no defined postcondition refutation. The existing `SAFETY` comment states the branch conclusion and callee precondition, but does not identify the exact `is_none` fact, its domain/TCB basis, the absence of an intervening transition, or the result used for the public postcondition.
+
+Proposed replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 guarantees throughout the supported domain
+// that is_none is true exactly for None. This fallthrough is therefore
+// Some(b); value has not been mutated. The same entry guarantees that
+// unwrap_unchecked(Some(b)) is defined and returns b.
+unsafe { value.unwrap_unchecked() }
+```
+
+Minimal resolution is to install equivalent adjacent or canonical proof text. This is documentation debt, not an implementation or API-contract failure.
+
+## Residual scope and attestation
+
+No code was modified, expanded, built, run, or tested; there is no tool-derived proof. Compiler/backend correctness, emitted binaries, non-supported configurations, resource/security properties, and undocumented behavior are excluded. Every source/API, unsafe operation, invariant transition, documented result, and supported configuration class has a disposition. Re-audit on changes to source/contracts, support policy, Rust/std documentation, TCB disposition, generated/build inputs, or newly discovered obligations.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/B.md
new file mode 100644
index 0000000000..0173722cae
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/B.md
@@ -0,0 +1,63 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Soundness — PROVED relative to `TCB.md` / `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior in every configuration in `Required` below.
+
+**Documented result — PROVED relative to the same TCB entry.** Every such call returns `0` for `None` and returns `v` for `Some(v)`.
+
+The combined mandatory result is **PROVED**. This is a source-level Rust-abstract-semantics result, not a claim about a compiler backend or emitted binary.
+
+## Snapshot, scope, and boundary
+
+The audited snapshot is the complete supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`. It is a Rust-2021 `#![no_std]` library with no dependencies, build script, generated source, or prior audit reused.
+
+The complete language-reachable crate-defined API surface is the safe free function `pub fn value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4-13`). There are no public fields, constructors, types, traits or impls, statics, reexports, macros, hidden items, callbacks, FFI, assembly, allocator operations, or concurrency surfaces. The sole unsafe site is the internal `Option::unwrap_unchecked` call at line 12. There is no persistent representation invariant; the only safety fact is the control-flow-local proposition `value != None` at that call.
+
+## Exact supported domain and closure
+
+Let
+
+* `R = { r | r is a released stable Rust toolchain and 1.84.0 <= r <= 1.86.0 }`;
+* `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`;
+* `F = {telemetry disabled, telemetry enabled}`;
+* `P` be every Cargo profile; and
+* `A = {debug assertions disabled, debug assertions enabled}`.
+
+Then `Required = R × T × F × P × A`, for this source and its version-matched standard library. `SUPPORT.md` is controlling: it says the release predicate is exact and expressly supports every cross-product member. `Cargo.toml`'s `rust-version = "1.84"` is only Cargo's minimum-admission statement, as `SUPPORT.md` itself explains; it agrees with the lower bound and does not erase the upper bound. `default = []` and the sole declared feature establish the two feature states. `CI.md` supplies samples only and neither defines nor proves support.
+
+This preserves `R` symbolically. No finite release inventory is substituted, so no unproved “there were no other patch releases” premise is needed. `COMPAT-OPTION-184-186` quantifies over exactly the same released-stable predicate.
+
+`Covered = Required`. The source contains no `cfg`, feature read, target branch, assertion, arithmetic, panic, profile-sensitive operation, generator, or external component. Thus its control-flow proof is parametric over `T × F × P × A`. The accepted compatibility premise is parametric over `R` and all those axes. Their conjunction covers every cross-product member, establishing `Required ⊆ Covered`. CI endpoints are not used in this certificate.
+
+## Authorities, TCB, and proof ledger
+
+The Rust 1.84.0 documentation says `is_none` “[r]eturns `true` if the option is a `None` value” ([versioned page](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). It says `unwrap_unchecked` returns the contained `Some` value and that calling it on `None` is undefined behavior ([versioned page](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). Both exact pages and their version were checked.
+
+`COMPAT-OPTION-184-186` is an accepted human compatibility premise. Its exact consumed proposition is: throughout `Required`, `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; and calling it on `None` is UB. Its only consumers here are the following obligations, matching `TCB.md`. It establishes no release inventory, Cargo fact, backend, or binary fact. No other assumption is consumed.
+
+| ID | Obligation and derivation | Status |
+|---|---|---|
+| O1 | At line 12, `unwrap_unchecked` must receive `Some(v)`. If `is_none()` were true, line 6 returned. On the continuing path it is false; by `COMPAT-OPTION-184-186`, `value` is `Some(v)`. | PROVED over `Required` |
+| O2 | Every safe input is covered. `None` takes the first return and executes no unsafe operation. `Some(v)` reaches line 12 with O1 true, and the TCB premise supplies a defined return of `v`. | PROVED over `Required` |
+| O3 | The same exhaustive cases return respectively `0` and `v`, exactly the documented behavior. Both executions are UB-free as established by O2. | PROVED over `Required` |
+| O4 | Configuration/version closure is the parametric argument above; applicability of every consumed premise contains `Required`. | PROVED |
+
+No test, build, execution, or tool-derived evidence was used.
+
+## Proof-documentation finding
+
+**DOC-01 — local `SAFETY` proof is incomplete as a persistent proof artifact; implementation remains proved.** The comment identifies the branch and callee precondition, but does not identify the semantic premise establishing that `is_none() == false` means `Some`, nor its supported-release applicability. Suggested replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 guarantees throughout the supported domain
+// that is_none() is true exactly for None. The true case returned above, so
+// value is Some(v); the same premise guarantees unwrap_unchecked(Some(v))
+// is defined and returns v.
+```
+
+This is documentation debt, not an implementation, soundness, or behavioral defect.
+
+## Residual scope and triggers
+
+Excluded are configurations outside `Required`, backend/binary correctness, and undocumented robustness properties. Re-audit is required for any source or documentation change; support-domain expansion or reinterpretation; change to either cited standard-library proposition; change or withdrawal of `COMPAT-OPTION-184-186`; or addition of dependencies, generated code, configuration-sensitive code, or API surfaces. Every in-scope obligation and mandatory postcondition has a disposition; there is no unresolved domain or proof remainder.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/C.md
new file mode 100644
index 0000000000..6f14f1778b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/C.md
@@ -0,0 +1,71 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+| Claim | Exact theorem | Verdict | Qualification |
+|---|---|---|---|
+| SOUND | For every `Required` configuration and every well-typed safe call `value_or_zero(value: Option<u8>)`, execution is free of Rust undefined behavior. | **PROVED** | Source-level Rust semantics, relative to accepted TCB entry `COMPAT-OPTION-184-186`. |
+| RESULT | In the same domain, `value_or_zero(None) == 0` and `value_or_zero(Some(v)) == v` for every `u8` `v`. | **PROVED** | Relative to the same accepted entry. |
+
+**Combined mandatory result: PROVED**, relative to conspicuous use of `TCB.md` entry `COMPAT-OPTION-184-186`. Scope is the complete supplied crate snapshot and its sole public safe API. This is not a compiler-backend or emitted-binary claim.
+
+## Snapshot and required domain
+
+Audited inputs are `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs` as supplied. There are no dependencies, build scripts, generators, generated artifacts, macros, FFI, assembly, concurrency, allocation, mutable state, or target-specific source. The crate is edition 2021 and `no_std`.
+
+Preserving the controlling expression rather than inventing a finite release list:
+
+```text
+Required(r,t,f,p,d) :=
+  ReleasedStableRust(r) && 1.84.0 <= r <= 1.86.0
+  && t in {x86_64-unknown-linux-gnu,
+           aarch64-apple-darwin,
+           wasm32-unknown-unknown}
+  && f in {telemetry-off, telemetry-on}
+  && p is any Cargo profile
+  && d in {debug-assertions-off, debug-assertions-on}.
+```
+
+`SUPPORT.md` expressly makes that predicate, including its upper cutoff, the support commitment. `Cargo.toml`'s `rust-version = "1.84"` supplies the compatible lower Cargo admission threshold but does not replace the policy or erase its upper bound. `CI.md` is only a sample and is not used to transform or prove the domain. No enumeration of `ReleasedStableRust` is used: the proof below and the accepted compatibility premise quantify over the symbolic predicate directly.
+
+Configuration selection is source-identical: neither feature nor target appears in a `cfg`; there are no assertions or profile-sensitive arithmetic; and the only unsafe operation's admitted contract explicitly covers every `Required` target, profile, feature, and debug-assertion state. Thus each obligation's `Covered` predicate equals `Required`, establishing `Required ⊆ Covered` without relying on CI samples. The audit cutoff is 2026-08-01; the fixed upper bound makes it non-moving.
+
+## Boundary, invariants, and obligations
+
+The complete language-reachable crate-defined API surface is the safe free function `value_or_zero`. There are no public fields, constructors, types, traits or impls, methods, statics, reexports, hidden items, callbacks, or macro-generated APIs. The internal unsafe consumer is `Option::unwrap_unchecked` at `src/lib.rs:12`. There is no persistent representation invariant; the sole proof fact is the branch-local classification of `value`.
+
+| ID | Proposition | Proof/status |
+|---|---|---|
+| O1 | The `None` branch returns before the unsafe call. | Direct control flow at lines 6–8; **PROVED** for `Required`. |
+| O2 | Every execution reaching line 12 has `value = Some(v)`. | `is_none` is exactly the `None` discriminator by the accepted TCB proposition; negating the taken condition and the two `Option` variants gives `Some(v)`; **PROVED** for `Required`. |
+| O3 | Line 12 satisfies `unwrap_unchecked`'s safety precondition and returns `v`. | O2 plus the version-applicable contract below; **PROVED** for `Required`. |
+| O4 | Both documented result cases hold. | Exhaustive `None`/`Some(v)` partition and O1/O3; **PROVED** for `Required`. |
+
+The Rust 1.84.0 documentation says `is_none` “Returns `true` if the option is a `None` value” and says, for `unwrap_unchecked`, “Calling this method on `None` is undefined behavior”; it also specifies that a `Some` receiver yields its contained value ([`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none), [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). The same method contracts were independently checked in [1.84.1](https://doc.rust-lang.org/1.84.1/std/option/enum.Option.html#method.unwrap_unchecked), [1.85.0](https://doc.rust-lang.org/1.85.0/std/option/enum.Option.html#method.unwrap_unchecked), [1.85.1](https://doc.rust-lang.org/1.85.1/std/option/enum.Option.html#method.unwrap_unchecked), and [1.86.0](https://doc.rust-lang.org/1.86.0/std/option/enum.Option.html#method.unwrap_unchecked). These checks corroborate but do not purport to enumerate the release interval.
+
+The proof is exhaustive:
+
+- If `value = None`, accepted proposition (1) makes `is_none()` true; line 7 returns `0`, line 12 is unreachable, and both SOUND and RESULT hold.
+- If `value = Some(v)`, proposition (1) makes `is_none()` false; line 12 is reached with a non-`None` receiver. Its safety obligation is satisfied, and accepted proposition (2) makes the result `v`. Thus SOUND and RESULT hold.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact consumed proposition and scope | Consumers / trigger |
+|---|---|---|---|
+| STD-OPTION-184 | Versioned standard-library authority; verified | The two quoted 1.84.0 method contracts above. | Basis for COMPAT; revisit if those pages materially change. |
+| COMPAT-OPTION-184-186 | Compatibility premise; **accepted by the authorized human reviewer** | For every `Required` release/configuration, `is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`, while calling it on `None` is UB. It establishes no release-set inventory, Cargo fact, backend, or binary fact. | O2–O4 and both verdicts; triggers exactly as stated in `TCB.md`. |
+
+No other premise, dependency, implementation, tool, deployment, or probabilistic trust is consumed. The accepted entry is not inferred from the sampled version pages; it is the explicit interval-coverage basis authorized by the request.
+
+## Finding DOC-1: local proof artifact is incomplete
+
+**Implementation obligation: PROVED. Proof-artifact classification: deficient.** The existing `SAFETY` comment captures the branch idea but neither names the semantic premise nor its applicability throughout `Required`. The material reconstruction is O2–O3 above. This does not weaken either verdict, but the smallest adequate repair is an adjacent comment such as:
+
+```rust
+// SAFETY: By accepted TCB entry COMPAT-OPTION-184-186, for every
+// supported configuration is_none() is true exactly for None. The true
+// branch returned above, so value is Some(v). The same entry preserves
+// unwrap_unchecked's contract: this call is permitted and returns v.
+```
+
+No caller-facing contract change is needed. Re-audit after any source, support predicate, method contract, TCB disposition, or configuration-scope change. Outside scope are unsupported toolchains/configurations and binary correctness. No tools, builds, tests, execution, or macro expansion were used as evidence.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/D.md
new file mode 100644
index 0000000000..c14157b3be
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/D.md
@@ -0,0 +1,101 @@
+# Unsafe Rust source audit
+
+## Claim and verdict
+
+**Combined mandatory verdict: PROVED**, relative to accepted TCB entry
+`COMPAT-OPTION-184-186` in the supplied `TCB.md` (SHA-256
+`db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413`). For
+the exact supplied source, every well-typed safe call to `value_or_zero` is free
+of Rust undefined behavior and returns the contained byte for `Some(v)` or zero
+for `None`, throughout the supported set below. Soundness: **PROVED relative to
+that TCB entry**. Documented result: **PROVED relative to that TCB entry**.
+
+This is a source-level Rust-abstract-semantics claim, not a claim about compiler
+correctness or any emitted binary.
+
+## Snapshot, scope, and supported set
+
+The complete target consists of `Cargo.toml`, `TCB.md`, `CI.md`, `REQUEST.md`,
+`SUPPORT.md`, and `src/lib.rs`; the latter has SHA-256
+`6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8`.
+Scope is the entire `no_std`, edition-2021 library. It has no dependencies,
+build script, generated source, or prior audit.
+
+`SUPPORT.md` controls support (the manifest's `rust-version = "1.84"` is only
+the Cargo minimum). The exact predicate is:
+
+* released stable Rust `r` with `1.84.0 <= r <= 1.86.0`—namely 1.84.0,
+  1.84.1, 1.85.0, 1.85.1, or 1.86.0; the official notes record
+  [1.84.1](https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30)
+  and [1.85.1](https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18);
+* target `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or
+  `wasm32-unknown-unknown`;
+* either `telemetry` state, every Cargo profile, and either debug-assertion
+  state.
+
+CI is sampling only and supplies no proof. There are no source `cfg`s or uses
+of the feature, target, profile, assertions, allocation, arithmetic,
+concurrency, panic, FFI, assembly, macros, or linking. Thus one source/dataflow
+proof is parametric over every non-toolchain axis; the accepted TCB proposition
+explicitly covers every toolchain member and all those axes. No supported
+combination is uncovered.
+
+## Boundary and obligation inventory
+
+The sole language-reachable crate surface is safe free function
+`value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4-12`). There are no public
+fields/types, constructors, traits or impls, hidden items, statics, reexports,
+callbacks, macros, or FFI. The sole unsafe site is the internal
+`Option::unwrap_unchecked` call at line 11. There is no persistent state or
+abstraction invariant; only the dominating branch fact is consumed.
+
+| ID | Exact obligation | Derivation | Status |
+|---|---|---|---|
+| O1 | Safe callers have no hidden safety precondition. | The function accepts every `Option<u8>` and branches before its only unsafe operation. | PROVED |
+| O2 | Line 11 is never called on `None`. | Under `COMPAT-OPTION-184-186`, `is_none` is true exactly for `None`. Reaching line 11 means the test at line 5 returned false, so `value = Some(v)`. The same accepted entry states that `unwrap_unchecked(Some(v))` is defined and returns `v`, whereas `None` would be UB. | PROVED relative to TCB |
+| O3 | The documented result is returned. | If `None`, O2's `is_none` proposition makes line 6 return zero. If `Some(v)`, the test is false and O2 makes line 11 return `v`. These exhaustive cases establish the documentation at line 3. | PROVED relative to TCB |
+
+The Rust 1.84.0 base pages say `is_none` “[r]eturns `true` if the option is a
+`None` value” and `unwrap_unchecked` “[r]eturns the contained `Some` value”; they
+also state that calling it on `None` is undefined behavior
+([`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none),
+[`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+The exact uniform proposition used above is nevertheless the human-accepted
+compatibility entry, not an inference from API stability. Its permitted
+consumers are precisely O2/O3; it supplies no release-membership, Cargo,
+backend, or binary fact.
+
+## Finding D1 — deficient adjacent proof, implementation proved
+
+The line 9 comment identifies the branch and callee precondition, but omits the
+material authoritative/TCB bridge and its supported-domain applicability.
+Implementation classification: **PROVED relative to
+`COMPAT-OPTION-184-186`**. Proof-artifact classification: **deficient**. No UB
+witness or defined postcondition refutation is established.
+
+Proposed replacement:
+
+```rust
+// SAFETY: By COMPAT-OPTION-184-186 throughout the supported domain,
+// value.is_none() is true exactly for None. Reaching here means it returned
+// false, so value is Some(v); unwrap_unchecked(Some(v)) is defined and returns v.
+```
+
+This documentation repair changes no API or behavior. Re-audit the proof if
+the source, documented result, support interval/axes, cited base propositions,
+or TCB disposition changes.
+
+## TCB, evidence, and residual scope
+
+`COMPAT-OPTION-184-186` is an accepted compatibility premise, scoped only as
+quoted above; its identity, consumers, exclusions, and re-audit triggers were
+verified. No dependency, tool-derived, test-derived, environmental,
+probabilistic, or implementation premise is consumed. The version-matched
+allowlisted standard-library pages for all five releases were checked and do
+not add a qualification, but they are not used to invent a general
+compatibility rule.
+
+Excluded: unsupported configurations, compiler/backend correctness, emitted
+binaries, and ordinary robustness beyond the requested documented result. No
+build, execution, macro expansion, or test was performed. No authoritative
+documentation gap or unresolved proof obligation remains.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/E.md
new file mode 100644
index 0000000000..1f9c0998f6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/E.md
@@ -0,0 +1,74 @@
+# Unsafe Rust audit — `symbolic-domain-target`
+
+## Claim and verdicts
+
+For the exact supplied snapshot, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior and returns the contained byte for `Some(v)`, or zero for `None`, throughout supported set **S**, relative to accepted TCB entry **COMPAT-OPTION-184-186**.
+
+- **Soundness: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- **Documented result: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- **Combined mandatory result: PROVED for S, relative to COMPAT-OPTION-184-186.**
+- No binary/backend, deployment, security, probabilistic, or extra robustness claim is made.
+
+These are source-level Rust-abstract-semantics results. The accepted compatibility premise is indispensable and is not a claim that any compiler binary is correct.
+
+## Snapshot and supported domain
+
+The audited snapshot comprises all six supplied target files. SHA-256 identities:
+
+| File | SHA-256 |
+|---|---|
+| `CI.md` | `d3ff0564c4f96fcf7e9ff2784dbafcf1baa446c4d44cf3f55371e45b1687e46e` |
+| `Cargo.toml` | `7e25c6b1489e215d6e4ecdc8b7beea11fc35237b3207fb01e836e6c7b4e818f6` |
+| `REQUEST.md` | `161fad09885c67715d35859f24a1c41bd12bcba58c2cd7e1f933670bdda71d21` |
+| `SUPPORT.md` | `45ee272e31a71fe28da355624691db55439d234c92ae8be5ce1af460aed4069c` |
+| `TCB.md` | `db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413` |
+| `src/lib.rs` | `6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8` |
+
+At the 2026-08-01 audit cutoff, **S** is exactly: edition 2021; any released stable Rust `r` with `1.84.0 <= r <= 1.86.0`; target `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; either `telemetry` state; every Cargo profile; and either debug-assertion state. `SUPPORT.md` controls. `Cargo.toml` agrees on the lower bound and edition; its lack of an upper bound is expressly only Cargo admission, not a support conflict. `CI.md` is sample evidence and proves no semantic obligation.
+
+There are no dependencies, build script, generated/expanded artifacts, macros, `cfg` branches, target-specific operations, FFI, assembly, allocation, concurrency, or panic path. The feature is unused. One source implementation therefore applies parametrically to every axis; COMPAT-OPTION-184-186 expressly covers every member of S. No supported combination is uncovered. Releases entering the closed version interval after the cutoff require re-audit.
+
+## Boundary, contracts, and invariants
+
+The complete language-reachable crate surface is the safe public free function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields, types, constructors, methods, traits/impls, statics, reexports, hidden items, callbacks, macros, or destruction behavior defined by this crate. The sole unsafe surface is the internal call `value.unwrap_unchecked()`; callers have no safety obligation beyond passing a well-typed `Option<u8>`.
+
+**RESULT-1:** for every input, return `0` if it is `None`; return `v` if it is `Some(v)`. No persistent abstraction invariant exists. The only transient fact is **BRANCH-SOME**: on the fallthrough edge after `is_none()` returned false, the unchanged `value` is `Some(v)` for some `v`.
+
+## Authorities and TCB audit log
+
+The Rust 1.84.0 standard-library page declares `Option<T>` with only `None` and `Some(T)`. Its `is_none` contract says: “Returns `true` if the option is a `None` value.” ([1.84.0 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). Its unsafe method says it returns the contained `Some` value and: “Calling this method on `None` is undefined behavior.” ([1.84.0 `unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+
+**COMPAT-OPTION-184-186** is an accepted, authorized human compatibility premise from `TCB.md`. Exact admitted proposition: for every configuration in S, the 1.84.0 base propositions remain unweakened—`is_none` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`; calling it on `None` is UB. Category: out-of-band compatibility premise. Consumers: only SOUND-1 and RESULT-1 below. Limitations: it proves neither S's membership nor Cargo, backend, binary, or other-API facts. Disposition: accepted. Re-audit on any source, interval, base-proposition, target/feature, or disposition change. No other assumption, dependency trust, or tool result is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Obligation | Proof and applicability | Status |
+|---|---|---|---|
+| SOUND-1 | Every safe input avoids calling `unwrap_unchecked` on `None`. | Complete case split below; local control flow plus COMPAT-OPTION-184-186 over all S. | **PROVED relative to COMPAT-OPTION-184-186** |
+| RESULT-1 | Return zero for `None`, contained byte for `Some(v)`. | Same split plus the admitted return proposition, over all S. | **PROVED relative to COMPAT-OPTION-184-186** |
+
+Case `value = None`: COMPAT-OPTION-184-186 makes `is_none()` true. The dominating branch returns literal `0`; the unsafe call is not executed. This proves soundness and the `None` result.
+
+Case `value = Some(v)`: the same premise makes `is_none()` false. `is_none` only borrows the same value, so fallthrough establishes BRANCH-SOME. COMPAT-OPTION-184-186 then supplies both permission and result for `unwrap_unchecked(Some(v))`: the execution has no UB from that call and returns `v`. The two exhaustive `Option` cases prove both universal claims. There is no intervening mutation, callback, unwind, or alternative exit.
+
+## Finding DOC-1 — local proof omits its material authority
+
+- **Classification:** implementation obligations PROVED; proof artifact deficient; maintenance/documentation severity.
+- The adjacent `SAFETY` comment identifies the branch conclusion but does not name the exact `is_none` proposition or the accepted compatibility premise needed across S. This does not change the source verdict because the complete reconstruction appears above.
+- Proposed replacement:
+
+```rust
+// SAFETY: COMPAT-OPTION-184-186 states, over the complete supported
+// domain, that is_none is true exactly for None and that
+// unwrap_unchecked(Some(v)) returns v. The false branch above, which only
+// borrowed this unchanged value, therefore establishes value = Some(v).
+unsafe { value.unwrap_unchecked() }
+```
+
+No UB witness, UB-free postcondition refutation, authoritative-documentation gap, or skill-guidance gap was established.
+
+## Residual scope and review triggers
+
+Excluded: compiler/backend correctness, emitted binaries, unsupported configurations, and properties not requested. No build, execution, test, macro expansion, or tool-derived proof was used. Re-audit on any source/API/documentation change; support-axis or post-cutoff release change; material change to the cited pages; or weakening, rejection, or broader use of COMPAT-OPTION-184-186.
+
+All in-scope surfaces and obligations have a status; every supported configuration is covered; both mandatory claims expose their accepted TCB dependence. Independent second review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/F.md
new file mode 100644
index 0000000000..5cb31ea3f5
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/F.md
@@ -0,0 +1,60 @@
+# Unsafe Rust audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Source-level soundness — PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` is free of Rust undefined behavior for every supported configuration.
+
+**Documented behavior — PROVED, relative to `COMPAT-OPTION-184-186`.** Every such call returns the contained byte for `Some(v)` and returns zero for `None`.
+
+**Combined mandatory result — PROVED, relative to `COMPAT-OPTION-184-186`.** This qualification is material: no result here applies that entry outside `value_or_zero`, its two named `Option` propositions, or the supported region.
+
+The supported predicate, controlled by `SUPPORT.md:3-21`, is exactly: released stable Rust `r` with `1.84.0 <= r <= 1.86.0`; target in `{x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`; either `telemetry` state; every Cargo profile; and either debug-assertion state. `Cargo.toml:5` supplies Cargo's minimum, not the upper support cutoff. `CI.md` is sampling evidence only and does not narrow this predicate.
+
+## Snapshot, scope, and boundary
+
+Audited source is the complete supplied six-file snapshot (`Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`); no revision, dependencies, generated artifacts, build script, lockfile, or prior audit was supplied. This was source review only: no target execution, build, test, expansion, or tool-derived proof was used. Edition is 2021 and the crate is `no_std`.
+
+The sole public surface is safe function `value_or_zero(Option<u8>) -> u8` (`src/lib.rs:3-12`). There are no public representation fields, constructors for a crate-owned type, traits or impls, macros, reexports, hidden APIs, callbacks, statics, FFI, or configuration-specific APIs. The sole unsafe operation is the internal `Option::unwrap_unchecked` call at `src/lib.rs:11`; it is not a caller-facing unsafe boundary. No persistent representation invariant exists. The only transient invariant is **BRANCH-SOME**: after the `is_none()` true branch returns, the still-owned `value` is `Some(v)`.
+
+## Authorities and TCB log
+
+Rust 1.84.0 standard-library documentation states that [`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) “Returns `true` if the option is a `None` value.” The version-matched [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) contract says it returns the contained `Some` value and that calling it on `None` is undefined behavior.
+
+`TCB.md:3-23` is the accepted human trust decision and the complete additional TCB:
+
+| ID | Disposition | Exact admitted proposition and domain | Consumers |
+|---|---|---|---|
+| `COMPAT-OPTION-184-186` | accepted | Across the entire supported Rust/target/feature/profile/debug domain, the 1.84.0 base propositions are preserved: `is_none()` is true exactly for `None`; `unwrap_unchecked(Some(v))` returns `v`, while invocation on `None` is UB. | Only soundness and documented-result proofs below |
+
+It admits neither release membership nor Cargo/backend/binary facts. No safe or unsafe dependency, compiler implementation, platform, deployment, or other compatibility premise is consumed. Its stated re-audit trigger is any source, support interval, base-proposition, feature/target-scope, or human-disposition change.
+
+## Obligation ledger and derivation
+
+| ID | Site / exact obligation | Derivation over the supported predicate | Status |
+|---|---|---|---|
+| O1 | `lib.rs:5-7`: `None` behavior | By `COMPAT-OPTION-184-186`, `is_none()` is true exactly on `None`; the dominating branch returns literal `0`. No unsafe operation executes. | PROVED relative to TCB |
+| O2 | `lib.rs:11`: do not call `unwrap_unchecked` on `None` | Reaching line 11 means the true branch did not execute, hence `is_none()` was false. The same TCB proposition yields BRANCH-SOME, so the callee's sole documented UB case is excluded. | PROVED relative to TCB |
+| O3 | `lib.rs:11`: `Some(v)` result | BRANCH-SOME and the TCB-preserved postcondition give `unwrap_unchecked(Some(v)) = v`; the function immediately returns it. | PROVED relative to TCB |
+| O4 | Safe API, all executions | `Option<u8>` exhausts the `None` case (O1) and `Some(v)` case (O2-O3). Thus every well-typed safe input is UB-free and meets the sole documented result contract. | PROVED relative to TCB |
+
+Configuration closure is parametric, not empirical: the source has no `cfg`, feature use, profile/debug-dependent assertion, target-dependent operation, allocation, panic/unwind branch, concurrency, FFI, generated code, or build-time input. Consequently the same control/data-flow proof applies to every Cartesian combination in `Supported`; `COMPAT-OPTION-184-186` supplies exactly the only version-sensitive semantics. CI contributes no proof.
+
+## Finding: local proof documentation is deficient
+
+**Documentation defect; implementation remains PROVED relative to the TCB.** The `SAFETY` comment at `src/lib.rs:9-10` correctly names the branch fact and callee precondition, but omits the material bridge that `is_none() == false` implies `Some(v)` throughout every supported Rust release, and it does not identify the accepted compatibility premise on which that bridge and the result proof depend.
+
+Proposed replacement:
+
+```rust
+// SAFETY: By COMPAT-OPTION-184-186, throughout the supported domain
+// `is_none()` is true exactly for `None`. This continuation therefore has
+// `value = Some(v)`; the same accepted premise preserves that
+// `unwrap_unchecked(Some(v))` is permitted and returns `v`.
+unsafe { value.unwrap_unchecked() }
+```
+
+This is a proof-artifact repair only; it adds no caller obligation or new contract.
+
+## Residual scope and triggers
+
+Compiler/backend and binary correctness, unsupported toolchains/targets, and undocumented robustness properties are excluded. Re-audit on any source or public-documentation change; change to the supported predicate; change/rejection of `COMPAT-OPTION-184-186` or either cited base contract; addition of dependencies, generated code, configuration branches, unsafe operations, or public surfaces. All in-scope obligations have a disposition; no UB witness or UB-free postcondition refutation is established or needed for the proved theorem.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/G.md
new file mode 100644
index 0000000000..0bf1a4a5b6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/G.md
@@ -0,0 +1,56 @@
+# Unsafe Rust Audit: complete supplied snapshot
+
+## Claim and verdict
+
+**Soundness — PROVED, relative to accepted TCB entry `COMPAT-OPTION-184-186`.** For the exact supplied source, every well-typed safe call to `value_or_zero` under `Supported(c)` is free of Rust undefined behavior under the documented Rust abstract semantics.
+
+**Documented behavior — PROVED, relative to the same accepted TCB entry.** In that domain, `value_or_zero(None) == 0` and `value_or_zero(Some(v)) == v` for every `v: u8`.
+
+**Combined mandatory result — PROVED, relative to accepted `COMPAT-OPTION-184-186`.** There is no conditional binary, deployment, security, or probabilistic claim.
+
+`Supported(c)` means: edition 2021; `c.r` is any released stable Rust toolchain satisfying `1.84.0 <= c.r <= 1.86.0`; target is exactly `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `telemetry` is disabled or enabled; and any Cargo profile and either debug-assertion state are used. This is the literal commitment in `SUPPORT.md`; `Cargo.toml`'s `rust-version = "1.84"` is only the Cargo minimum. The sources do not conflict. Audit cutoff: 2026-08-01.
+
+## Snapshot and scope
+
+The artifact is the exact supplied contents of `Cargo.toml`, `src/lib.rs`, `SUPPORT.md`, `CI.md`, `TCB.md`, and `REQUEST.md`; no repository revision or digest was supplied. The crate is `no_std`, has no dependencies or build script, and contains no generated source. Scope is the complete library and its documented safe behavior. No build, execution, test, expansion, or binary/backend claim was used. Skill identity: supplied `unsafe-rust` package, revision unspecified.
+
+The sole language-reachable public surface is safe function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields, types, constructors, trait implementations, macros, reexports, statics, callbacks, FFI items, hidden items, or destruction behavior owned by this crate. The only unsafe operation is `Option::unwrap_unchecked` at `src/lib.rs:11`. There is no persistent representation invariant; the only proof state is the local branch fact.
+
+## Authorities and TCB audit log
+
+The Rust 1.84.0 standard-library page says `is_none` “Returns `true` if the option is a `None` value” and declares `Option`'s `None` and `Some(T)` variants ([1.84.0 `is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)). The version-matched `unwrap_unchecked` contract says it returns the contained `Some` value and is the controlling unsafe operation ([1.84.0 `unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)).
+
+`TCB.md` is the canonical log. Its sole entry, `COMPAT-OPTION-184-186`, is **accepted by the authorized human reviewer**. It admits, for every `Supported(c)`, exactly: (1) `is_none` is true iff the value is `None`; and (2) `unwrap_unchecked(Some(v))` returns `v`, while calling it on `None` is UB. Category: accepted compatibility/out-of-band semantic premise; base identity: the two Rust 1.84.0 pages above. Consumers: only obligations O1–O3 below. It admits neither release membership nor Cargo/backend/other-API facts. No release enumeration is needed: the proof is universal over whichever released stable `r` satisfies the policy predicate. Trigger: any source, interval, base proposition, target/feature/profile/debug scope, or human-disposition change. The entry is precise, non-circular, within its authorized scope, and accepted; no other dependency, implementation, tool, or environmental premise is consumed.
+
+## Obligation ledger and derivation
+
+| ID | Proposition and proof | Domain | Status |
+|---|---|---|---|
+| O1 | If line 11 is reached, `value` is `Some(v)`. On `None`, accepted `COMPAT-OPTION-184-186` makes `is_none()` true, so lines 5–6 return. If line 11 is reached, the test was false; the accepted iff proposition excludes `None`, and `Option`'s exhaustive remaining variant is `Some`. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O2 | The unsafe call never receives `None`; by O1 it receives `Some(v)`. Accepted `COMPAT-OPTION-184-186` therefore gives a defined return of `v`, discharging the exact unsafe precondition. The `None` branch executes no unsafe operation. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O3 | For `None`, accepted `is_none` semantics select line 6, yielding zero. For `Some(v)`, they select line 11, and accepted `unwrap_unchecked` semantics yield `v`. These cases exhaust `Option<u8>`. | All `Supported(c)`, all inputs | PROVED relative to accepted TCB |
+| O4 | Configuration closure: source has no `cfg`; `telemetry` is declared but unused; target, profile, and debug assertions select no path; there are no allocation, panic, arithmetic, concurrency, FFI, or generated-code obligations. O1–O3 are parametric, and the accepted TCB explicitly has the same configuration quantification. | Entire `Supported(c)` | PROVED relative to accepted TCB |
+
+`CI.md` describes only samples (1.84.0 on one target/feature state and 1.86.0 across targets/feature states). It neither defines support nor contributes proof evidence. No tool-derived evidence was used.
+
+## Finding D1 — deficient adjacent proof artifact
+
+**Implementation classification:** PROVED relative to accepted `COMPAT-OPTION-184-186`. **Proof-artifact classification:** deficient. Lines 9–10 state the correct branch idea, but omit the material `is_none` iff premise, exhaustive-variant step, applicability, accepted TCB bridge, and `unwrap_unchecked(Some(v))` postcondition. This is not an implementation defect, UB witness, or defined postcondition refutation.
+
+Proposed replacement:
+
+```rust
+// SAFETY: Under accepted COMPAT-OPTION-184-186 throughout Supported(c),
+// is_none is true iff value is None. Reaching here means it returned false;
+// Option has only None and Some variants, so value is Some(v). Under the same
+// entry, unwrap_unchecked(Some(v)) is defined and returns v.
+unsafe { value.unwrap_unchecked() }
+```
+
+Minimum resolution: add an adjacent proof with a stable local link to the canonical TCB entry and authoritative contracts. This is documentation maintenance, not a change to the caller contract.
+
+## Residual scope and attestation
+
+Excluded: configurations outside `Supported(c)`, compiler/backend and emitted-binary correctness, non-Rust environments, and undocumented robustness properties. No supported source configuration is uncovered. Re-audit on any source/API/documentation change; support/edition/target/feature/profile/debug change; material change to the cited Rust contracts; TCB disposition or proposition change; dependency/build-generation introduction; or a newly discovered obligation.
+
+Every public surface, unsafe site, mandatory postcondition, supported configuration class, citation, and consumed TCB premise has a disposition above. Every `PROVED` result is expressly relative to the accepted TCB; no absence-of-counterexample or test inference is used. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/H.md
new file mode 100644
index 0000000000..641c035a37
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/H.md
@@ -0,0 +1,53 @@
+# Unsafe Rust Audit: `symbolic-domain-target` complete supplied snapshot
+
+## Claims and verdicts
+
+Let `D` be all tuples `(r,t,f,p,d)` where `r` is a released stable Rust toolchain and `1.84.0 <= r <= 1.86.0`; `t` is `x86_64-unknown-linux-gnu`, `aarch64-apple-darwin`, or `wasm32-unknown-unknown`; `f` is either state of `telemetry`; `p` is any Cargo profile; and `d` is either debug-assertion state.
+
+| Claim | Exact source-level theorem for every configuration in `D` and every well-typed safe call | Verdict |
+|---|---|---|
+| SOUND | `value_or_zero` executes without Rust undefined behavior | **PROVED relative to accepted TCB entry `COMPAT-OPTION-184-186`** |
+| RESULT | `None` returns `0`; `Some(v)` returns `v` | **PROVED relative to accepted TCB entry `COMPAT-OPTION-184-186`** |
+
+**Combined mandatory result: PROVED over exactly `D`, relative to `COMPAT-OPTION-184-186`.** This is an abstract Rust source theorem, not a compiler/backend or emitted-binary theorem.
+
+## Snapshot and scope
+
+The complete supplied package is edition 2021, `#![no_std]`, has no dependencies or build script, and contains one library source file. Relevant SHA-256 identities are: `src/lib.rs` `6a9db5bc51aa3c0fb1e966509de396cee5d451cb93f4295224d5772f22f838f8`; `Cargo.toml` `7e25c6b1489e215d6e4ecdc8b7beea11fc35237b3207fb01e836e6c7b4e818f6`; `SUPPORT.md` `45ee272e31a71fe28da355624691db55439d234c92ae8be5ce1af460aed4069c`; and `TCB.md` `db2ecc86f6e93d8e7ed6dd3df2c01cf0e5a80580a121341a5409f6888c2de413`. `REQUEST.md`, `CI.md`, and every supplied target file were reviewed. Audit cutoff: 2026-08-01. No code was generated, expanded, built, run, or tested; no prior audit was reused.
+
+## Domain recovery and configuration closure
+
+`SUPPORT.md` is explicit that its closed toolchain interval, including the upper cutoff, is the project commitment. Its predicate is crossed with the three enumerated targets, both feature states, every profile, and both debug-assertion states; this is exactly `D`, with no normalization to a finite release inventory. `Cargo.toml`'s `rust-version = "1.84"` is expressly only Cargo's minimum and is consistent with, but does not replace, that policy. `CI.md` lists samples only and supplies neither domain membership nor semantic proof.
+
+The source has no `cfg`, feature-conditioned item, profile-dependent check, arithmetic, target operation, dependency, macro, FFI, assembly, allocation, concurrency, or generated artifact. Its proof is therefore parametric in `t`, `f`, `p`, and `d`. Version coverage is parametric in `r` through the accepted TCB entry, rather than inferred from endpoints or sampled documentation.
+
+For every `c in D`, the proof below covers both valid `Option<u8>` variants. Hence each obligation's `Covered` predicate is `D`; their pointwise intersection is `D`, and `Required = D subseteq Covered = D`. No supported configuration is excluded or unresolved.
+
+## Boundary, invariant, and obligation ledger
+
+The only crate-defined language-reachable API is the safe free function `pub fn value_or_zero(Option<u8>) -> u8`. There are no public fields or types, crate constructors, traits/impls, methods, statics, macros, reexports, hidden items, callbacks, FFI entrypoints, or configuration-specific APIs. The sole unsafe surface is the internal call `value.unwrap_unchecked()`.
+
+The only invariant is transient `FALLTHROUGH-SOME`: from completion of the false `is_none` branch until the consuming unsafe call, the owned, immutable local `value` is `Some(v)`. It is established by the branch and `COMPAT-OPTION-184-186`; no assignment, alias-capable callback, or other operation intervenes.
+
+| Obligation | Required proposition | Derivation and status |
+|---|---|---|
+| O1 branch classification | `is_none` distinguishes `None` from `Some(v)` | The accepted entry preserves the exact classification throughout `D`. **PROVED** |
+| O2 unsafe precondition | the receiver of `unwrap_unchecked` is not `None` | Only fallthrough reaches the call; O1 and unchanged ownership establish `FALLTHROUGH-SOME`. **PROVED** |
+| O3 unsafe result | `unwrap_unchecked(Some(v))` returns `v` | The accepted entry preserves this base proposition throughout `D`. **PROVED** |
+| O4 documented result | `None -> 0`, `Some(v) -> v` | `None` returns before unsafe; `Some(v)` uses O2/O3. **PROVED** |
+
+The adjacent `SAFETY` comment identifies the dominating return, derives `Some`, and names the callee precondition; it is adequate. Full case proof: for `None`, O1 makes the condition true and the function returns `0` without reaching unsafe code. For `Some(v)`, O1 makes it false; the immutable value remains `Some(v)`; O2 permits the unsafe call and O3 returns `v`. These cases exhaust valid safe inputs, proving UB freedom and the complete documented behavior.
+
+## TCB audit log
+
+**Log identity:** supplied `TCB.md`, SHA-256 above. **Trust policy:** only its authorized, accepted proposition is admitted; no implementation, compiler, dependency, or environmental premise is added.
+
+`COMPAT-OPTION-184-186` is accepted by the authorized human reviewer. Its base authorities are the Rust 1.84.0 [`Option::is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) and [`Option::unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) pages. Verified relevant text states: “Returns true if the option is a None value”; “Returns the contained Some value”; and “Calling this method on None is undefined behavior.” The entry admits that the exact classification and `Some(v)` result/`None` UB propositions are preserved, without weakening, for every `r` and configuration in `D`. Consumers are O1–O4 only. It establishes neither interval membership nor Cargo/compiler/backend facts. Re-audit is required for any source, support interval, base proposition, feature/target scope, or human-disposition change. No rejected, pending, unused, or additional entries exist.
+
+## Evidence, findings, and residual scope
+
+No tool-derived evidence was used. **Findings: none.** Every required obligation is proved; there is no documentation gap, unresolved domain, or postcondition failure.
+
+Excluded from this source theorem are invalid values created by out-of-scope unsafe caller behavior, unsupported configurations, compiler/backend correctness, emitted binaries, and deployment properties. Re-audit on any source/API/documentation change, support/configuration expansion, material authoritative-document change, or change to `COMPAT-OPTION-184-186`.
+
+Final attestation: all safe and unsafe surfaces, target files, controlling domain expressions, mandatory postconditions, premise applicability, and TCB consumers have a disposition; `Required subseteq Covered` is established; the verdict does not rely on CI, tests, or absence of a counterexample.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/I.md
new file mode 100644
index 0000000000..f83b5b1563
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/I.md
@@ -0,0 +1,60 @@
+# Unsafe Rust Audit: complete supplied snapshot
+
+## Claims and verdicts
+
+| Claim | Exact theorem | Verdict | Certificate and qualification |
+|---|---|---|---|
+| SOUND | For every well-typed safe call to `value_or_zero` in `Required`, execution is free of Rust undefined behavior under documented Rust abstract semantics. | **PROVED** | OBL-1 and configuration closure below, **relative to accepted TCB entry `COMPAT-OPTION-184-186`**. |
+| RESULT | For every such call, `None` returns `0` and `Some(v)` returns `v`. | **PROVED** | OBL-2 below, **relative to accepted TCB entry `COMPAT-OPTION-184-186`**. |
+
+**Combined mandatory result: PROVED**, relative to `target/TCB.md` as supplied. This is a source-level result, not a compiler-backend or binary theorem.
+
+## Snapshot, scope, and contracts
+
+The audited artifact is the exact supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, and `src/lib.rs`; `REQUEST.md` controls this review. It is a Rust-2021 `#![no_std]` library, has no declared dependencies, build script, generated source, macros, FFI, allocator use, concurrency, or mutable state. No prior audit or tool result was reused; the target was not built, run, tested, modified, or expanded.
+
+The complete language-reachable public surface is the safe free function `value_or_zero(Option<u8>) -> u8` (`src/lib.rs:4`). There are no public fields, constructors, traits/impls, methods, hidden items, reexports, unsafe APIs, or configuration-specific APIs. Its documentation is normative: “Returns the contained byte, or zero when `value` is `None`.” Safe callers have no safety precondition. There is no abstraction invariant: the function owns its input and retains no state.
+
+## Required domain and closure
+
+`SUPPORT.md`, expressly identified there as the support commitment, defines
+
+`Required = R × T × F × P × D`, where:
+
+- `R = { released stable r | 1.84.0 <= r <= 1.86.0 }`;
+- `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`;
+- `F = {telemetry disabled, telemetry enabled}`;
+- `P = every Cargo profile`; and
+- `D = {debug assertions disabled, debug assertions enabled}`.
+
+Edition 2021 and the standard library bundled with `r` are fixed additional coordinates. The official version history through 1.86.0 gives the exhaustive release inventory `R = {1.84.0, 1.84.1, 1.85.0, 1.85.1, 1.86.0}` ([1.84.1 section](https://doc.rust-lang.org/1.86.0/releases.html#version-1841-2025-01-30), [1.85.1 section](https://doc.rust-lang.org/1.86.0/releases.html#version-1851-2025-03-18)). Thus the inventory equals the symbolic interval; it is not inferred from endpoints. `Cargo.toml`'s `rust-version = "1.84"` supplies only the stated Cargo minimum and does not erase the upper bound. `CI.md` is sampling evidence only and does not narrow or prove support.
+
+There is no `cfg`, profile-sensitive operation, debug assertion, or use of `telemetry`; every required tuple selects the same function body. The accepted TCB entry explicitly covers both required `Option` propositions for every `r`, target, feature state, profile, and debug-assertion state in `Required`. Therefore each obligation below has `Covered = Required`, their pointwise intersection is `Required`, and `Required ⊆ Covered`. Panic strategy, optimization, overflow checks, target layout, and allocator choice do not enter the derivation.
+
+## Obligation ledger and proof
+
+| ID | Site and exact obligation | Derivation | Status |
+|---|---|---|---|
+| OBL-1 | `src/lib.rs:5-11`: `unwrap_unchecked` is reached only on `Some`. | If `is_none()` is true, line 6 returns before the unsafe call. If false, AXIOM-OPTION-184 plus COMPAT says the input is not `None`; exhaustive `Option<u8>` variants make it `Some(v)`. COMPAT then permits `unwrap_unchecked(Some(v))` and says it returns `v`. | **PROVED throughout `Required`, relative to COMPAT**. |
+| OBL-2 | Documented result for all inputs. | `None`: COMPAT's exact `is_none` proposition selects line 6, returning `0`. `Some(v)`: it selects the fallthrough, and COMPAT's exact unwrap proposition returns `v`. These exhaustive cases also include `Some(0)`. | **PROVED throughout `Required`, relative to COMPAT**. |
+
+The adjacent `SAFETY` comment identifies the dominating `None` return, derives `Some`, and names the callee precondition. Its implementation proof is adequate; the report-level TCB citation supplies the version/configuration applicability. No panic, unwind, destructor, alias, provenance, initialization, or arithmetic obligation remains.
+
+## TCB audit log
+
+**Log identity:** supplied `target/TCB.md`, entry `COMPAT-OPTION-184-186`; human disposition accepted. **Trust policy:** consume only versioned Rust documentation and that exact accepted proposition; no dependency, implementation, backend, platform, or binary premise is admitted.
+
+| ID | Category and exact proposition | Scope/consumer/disposition |
+|---|---|---|
+| AXIOM-OPTION-184 | Rust 1.84.0 docs state that `is_none` returns true for `None` ([source](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none)); `unwrap_unchecked` returns the contained `Some` value and calling it on `None` is UB ([source](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked)). | Rust 1.84.0 base propositions; verified authoritative basis for COMPAT. |
+| COMPAT-OPTION-184-186 | Preserves, without weakening or added precondition, “`is_none` iff `None`” and “unwrap `Some(v)` to `v`; `None` is UB.” | Exactly `Required`; only OBL-1/2; **accepted by authorized human**. No interval-membership, Cargo, backend, or binary fact is consumed. |
+
+The entry is minimal, non-vacuous, and used only by its named consumers. Re-audit is required on any source, support interval, base proposition, target/feature/profile/debug scope, or disposition change. There are no dependencies or unresolved/rejected premises.
+
+## Findings, residual scope, and attestation
+
+No soundness, contract, proof-documentation, authoritative-documentation, or skill-guidance finding remains. No additional robustness property was requested, and no tool-derived evidence was used.
+
+Excluded from the theorem are unreleased, pre-1.84.0, post-1.86.0, nightly/beta/custom toolchains; other targets or feature names; compiler/backend correctness; emitted binaries; and behavior beyond the documented return value. These are theorem boundaries, not inferred project exclusions. Review must recur if source/API documentation, support policy, Cargo configuration, generated inputs, authoritative pages, or the TCB entry changes.
+
+Attestation: every safe/unsafe surface, obligation, documented result, controlling domain expression, TCB consumer, and required configuration class in the supplied snapshot has a disposition. The verdict follows the required universal coverage certificate, not tests or absence of a counterexample. Audit date: 2026-08-01; independent second review not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/J.md
new file mode 100644
index 0000000000..de72a5364a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/reports/J.md
@@ -0,0 +1,52 @@
+# Unsafe Rust audit: `symbolic-domain-target` 0.1.0
+
+## Claim and verdict
+
+| Claim | Exact theorem | Verdict |
+|---|---|---|
+| SOUND | For the supplied source and every configuration in `Required`, every well-typed safe call `value_or_zero(value: Option<u8>)` is free of Rust undefined behavior. | **PROVED relative to accepted `COMPAT-OPTION-184-186`** |
+| RESULT | Under the same quantification, the function returns `0` for `None` and the contained byte for `Some(b)`. | **PROVED relative to accepted `COMPAT-OPTION-184-186`** |
+
+The combined mandatory result is **PROVED relative to `TCB.md` as supplied**, specifically its conspicuous human-accepted compatibility premise `COMPAT-OPTION-184-186`. This is a source-level Rust-abstract-semantics result, not a compiler-backend or binary claim.
+
+Snapshot: the complete supplied `Cargo.toml`, `SUPPORT.md`, `CI.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`; edition 2021, `#![no_std]`, `rust-version = "1.84"`, no Cargo dependencies, build script, generator, or generated artifact. No prior audit or tool-derived evidence was used. Audit cutoff: 2026-08-01. Skill identity: supplied `unsafe-rust` package; no revision was provided.
+
+## Required domain and configuration closure
+
+Let `ReleasedStable(r)` retain its literal policy meaning, `T = {x86_64-unknown-linux-gnu, aarch64-apple-darwin, wasm32-unknown-unknown}`, `F = {telemetry off, telemetry on}`, `D = {debug assertions off, debug assertions on}`, and `P` be the symbolic set of all Cargo profiles. `SUPPORT.md` states exactly:
+
+`Required(r,t,f,p,d) = ReleasedStable(r) ∧ 1.84.0 ≤ r ≤ 1.86.0 ∧ t∈T ∧ f∈F ∧ p∈P ∧ d∈D`.
+
+This is a literal normalization, hence equality in both directions; no release or profile enumeration is substituted. `Cargo.toml` supplies only Cargo's lower acceptance bound, while `SUPPORT.md` expressly controls the project promise including its upper cutoff. `CI.md` samples 1.84.0/x86_64/no-feature and 1.86.0/all targets/both features; it is not support-definition or semantic proof evidence.
+
+Actual source-selection axes are empty: neither `telemetry`, `cfg`, target, profile, nor `debug_assertions` occurs in `lib.rs`. There are no allocator, FFI, assembly, concurrency, macro, dependency, panic, arithmetic, generated-code, or linking obligations in the function. The derivation below is syntactically identical across `t,f,p,d`; accepted `COMPAT-OPTION-184-186` supplies the two consumed `Option` propositions parametrically for every `r,t,p,f,d` in `Required`. Therefore each obligation's `Covered = Required`, their pointwise intersection is `Required`, and `Required ⊆ Covered` follows by identity. The cutoff does not enumerate releases and is not used as continuity evidence.
+
+## Boundary, invariant, and obligation coverage
+
+The only language-reachable crate surface is the public safe free function `value_or_zero` (`src/lib.rs:3-12`). There are no public fields, constructors of an owned representation, methods, traits/impls, reexports, macros, hidden items, statics, callbacks, FFI entrypoints, or custom destruction. The sole unsafe operation is `Option::unwrap_unchecked` at line 11. No persistent representation invariant exists. The transient fact `INV-NONNONE` is: after the `if value.is_none() { return 0; }` fallthrough, `value` is not `None`; the branch produces it and line 11 consumes it.
+
+| ID | Obligation and proof | Domain | Status |
+|---|---|---|---|
+| O1 | `is_none` classifies `None` exactly. This is the accepted preserved base proposition; the true branch returns before line 11. | `Required` | PROVED, TCB-relative |
+| O2 | `unwrap_unchecked` is not called on `None`. Reaching line 11 means `is_none()` was false; O1 gives `INV-NONNONE`, exactly discharging the unsafe call's condition. | `Required` | PROVED, TCB-relative |
+| O3 | Result: on `None`, O1 takes the branch and returns `0`; on `Some(b)`, O1 falls through and the accepted `unwrap_unchecked(Some(b)) = b` proposition returns `b`. These cases exhaust `Option<u8>`. | `Required` | PROVED, TCB-relative |
+| O4 | Configuration closure. Source and control flow are independent of every non-release axis, and the accepted premise covers the complete symbolic release predicate and all stated axes. | `Required` | PROVED, TCB-relative |
+
+The adjacent `SAFETY` comment is adequate: it names the dominating `None` return, derives `Some` at the call, and identifies that fact as `unwrap_unchecked`'s precondition. The proof above exposes the otherwise project-level version/configuration premise. Every normal exit re-establishes the result contract; there is no mutation, unwind point, callback, aliasing, allocation, or retained capability.
+
+## TCB audit log
+
+Log identity: supplied `TCB.md`, reviewed for this audit; disposition **accepted by the authorized human reviewer**.
+
+| ID/category | Exact proposition, identity, scope, consumers | Disposition and limits |
+|---|---|---|
+| BASE-OPTION-184 / AXIOM | Rust 1.84.0 [`is_none`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.is_none) says it returns true for `None`; [`unwrap_unchecked`](https://doc.rust-lang.org/1.84.0/std/option/enum.Option.html#method.unwrap_unchecked) returns the contained `Some` value and makes `None` undefined behavior. Base for O1-O3. | Version-matched authoritative base text inspected. |
+| COMPAT-OPTION-184-186 / accepted compatibility premise | Without weakening, qualification, or added precondition, preserves exactly: (1) `is_none` is true exactly for `None`; (2) `unwrap_unchecked(Some(v))` returns `v`, and calling it on `None` is UB; for every released stable `r` in the inclusive interval, all supported targets/profiles, either feature state, and either debug-assertion state. Consumers: only O1-O3 and the two verdicts. | **Accepted.** Establishes neither interval membership, Cargo facts, other APIs, backend correctness, nor emitted binaries. Re-audit on any source, interval, base-proposition, feature/target-scope, or disposition change. |
+
+No other compatibility, dependency, implementation, environment, probabilistic, or tool premise is consumed. The selected premise does not assume the in-scope implementation conclusion; it only transports two standard-library contracts across the exact symbolic domain.
+
+## Findings, residual scope, and triggers
+
+All in-scope obligations have complete derivations; there is no `UNPROVED`, `UNSOUND`, `CONTRACT-BROKEN`, proof-documentation, authoritative-documentation, or skill-guidance finding. Broader robustness, binary correctness, backend/linker behavior, and unsupported configurations were not claimed or audited. Re-audit is required if any supplied source or contract changes; `Required` expands or changes; the authoritative base text or accepted TCB disposition changes; generated code, dependencies, or configuration-sensitive code appears; or a new consumer relies on the premise.
+
+Auditor: source-review agent. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/S/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/PACKET.json
new file mode 100644
index 0000000000..e6969baf6a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "W",
+  "presentation_order": [
+    "H",
+    "F",
+    "B",
+    "E",
+    "C",
+    "A",
+    "I",
+    "D",
+    "J",
+    "G"
+  ],
+  "report_sha256": {
+    "A": "79e602e9a2317fa845b12fb497a3d895697a4ccdf81598750451850f95fce1fc",
+    "B": "99dc13ef74c153e0fc79419057499d99a38105c2d8fe710ddb80a54e70e0dc59",
+    "C": "89b14c495f9833e34e5cf92aa27d75aec62ad353d1b06393998fb1bcc57577ca",
+    "D": "d6e6359967799119d7119d804bbeb26db216412f3baab76d2392102683dc4fe2",
+    "E": "77862cfc78b4998dd4c0f05da7a160bf578f1f069da9ef7ca577bfaf19836aa6",
+    "F": "97b483500c362b67ec5966a089ea6c9d0c039bbfe454e5b05d854edc693bf982",
+    "G": "4bde4f56c31f9d422f72c61118fc884593ad0e9c897b3de60d37c1f1d7a2534d",
+    "H": "f8c5a10d8f94f043be587dfcb073640526162160b8a5f33384c243d98ffc9e59",
+    "I": "a7f109ef70b6a8ac7b471cc4a3122f4b8e2f92b45305f0f419ead77cf670528e",
+    "J": "cc9fd179a072064534dd9b337b68629aa110ba586546632b898c0d96532d449b"
+  },
+  "rubric_sha256": "c9aa4d310e2dc98d905caa3015c52c0cddbdcf95a1de65ea3a2f4fd78fef048c",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/RUBRIC.md
new file mode 100644
index 0000000000..37a9acfe1a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/RUBRIC.md
@@ -0,0 +1,66 @@
+# Mode W Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## W — Whole-execution UB and independent behavioral refutation
+
+Target: supplied W snapshot.
+
+Let `C_W` be Rust 1.80.0 times every target on which this exact source and the
+used Rust 1.80.0 standard-library item exist times every ordinary profile, and
+let `I = {0, ..., 255}`. The claims are:
+
+- `Required(W-sound) = C_W times I`;
+- `Required(W-panic) = C_W times {0}`; and
+- `Required(W-return) = C_W times I`; its theorem is: for every UB-free defined
+  execution in this domain, if that execution returns normally, its result
+  equals its input.
+
+### Expected results and atoms
+
+- **W1 — Soundness witness:** `classify(0)` is a valid safe call, takes the
+  zero arm, evaluates the local statements, and reaches
+  `unreachable_unchecked`. Its unreachable-site proposition is false; the
+  applicable 1.80.0 std contract entails UB. Report `W-sound` **UNSOUND**.
+- **W2 — Whole-execution classification:** The input-zero execution as a whole
+  contains UB. Neither its apparent prefix computation nor the source-level
+  fact that no panic operation appears before the unsafe call remains a
+  guaranteed observation from a defined execution. It therefore cannot prove
+  a UB-free failure of the panic postcondition. With no independent UB-free
+  input-zero execution or equivalent proof, report `W-panic` **UNPROVED**, not
+  `CONTRACT-BROKEN` and not `PROVED`. Its claim-level `Covered` set is empty on
+  the submitted evidence.
+- **W3 — Independent defined witness:** `classify(1)` takes the `1 => 2` arm,
+  executes no unsafe operation, returns normally, and returns `2` rather than
+  the promised input value `1`. That complete execution is UB-free and proves
+  `W-return` **CONTRACT-BROKEN**.
+
+Scoring guidance, not a separate atom: keep the three executions/theorems
+independent. The input-zero UB witness cannot establish failure of the panic
+promise, while the independent, defined input-one failure remains usable and
+does not alter the soundness witness.
+
+### W hard errors
+
+Any of these is a hard error:
+
+- calling the safe API sound, reporting only `UNPROVED` after explicitly
+  establishing every input-zero UB-certificate link, or issuing `UNSOUND`
+  without those links;
+- using the UB-containing input-zero execution, an apparent observation before
+  its UB, or the absence of an earlier panic to issue `CONTRACT-BROKEN`;
+- claiming source observations remain guaranteed merely because they occur
+  before the unsafe call;
+- falsely treating the independent input-one refutation as UB-containing, or
+  claiming complete behavioral coverage while omitting it.
+
+### W checked authorities
+
+- `https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety`
+  — reaching the function is undefined behavior.
+- `https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html`
+  — controlling Rust 1.80.0 Reference section for what constitutes undefined
+  behavior. Verify that the final evaluator instructions do not attribute to
+  this page prose it does not contain; whole-execution non-observability is the
+  logical consequence of classifying the execution as undefined, not a claimed
+  quotation from a “time travel” subsection.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/allowlist.txt
new file mode 100644
index 0000000000..655f04c58c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/allowlist.txt
@@ -0,0 +1,2 @@
+https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety
+https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/A.md
new file mode 100644
index 0000000000..a0ed00a644
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/A.md
@@ -0,0 +1,51 @@
+# Focused unsafe-Rust audit: `classify`
+
+## Claims and verdicts
+
+This review covers the exact `lib.rs` identified below, compiled with Rust and standard library 1.80.0, on every target where that source and `std::hint::unreachable_unchecked` exist, in every ordinary debug or release profile. A valid use is any well-typed safe call `classify(input)` for a valid `u8`; there is no caller safety precondition.
+
+1. **Freedom from undefined behavior for every valid safe call: `UNSOUND`.** The valid safe call `classify(0u8)` reaches `unreachable_unchecked`, which Rust 1.80.0 defines as UB.
+2. **If `input == 0`, the call panics: `UNPROVED`.** The only source path for zero contains UB. That UB-containing execution proves unsoundness, but cannot establish a UB-free nonpanic witness and therefore cannot establish `CONTRACT-BROKEN`.
+3. **On normal return, the result equals `input`: `CONTRACT-BROKEN`.** The independent, UB-free call `classify(1u8)` normally returns `2u8`, not `1u8`.
+
+The combined mandatory claim is not proved: it has the component results `UNSOUND`, `UNPROVED`, and `CONTRACT-BROKEN` above. These results hold throughout the supported configuration set, relative to TCB `TCB-R1`.
+
+## Snapshot, boundary, and configuration closure
+
+- Source: `target/lib.rs`, SHA-256 `705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+- Scope: the sole language-reachable safe surface, public safe free function `pub fn classify(u8) -> u8`, and its sole unsafe obligation site, the zero arm's call to `unreachable_unchecked`.
+- No fields, constructors, traits/impls, callbacks, macros, generated artifacts, FFI, dependencies other than the named standard-library item, concurrency, allocation, or configuration attributes appear in the supplied source.
+- Supported predicate: exactly Rust/stdlib 1.80.0; any target on which the exact source and item exist; ordinary debug or release. Target and profile do not select different source. The submitted authority states that both axioms below cover this domain. The proof partitions all valid `u8` inputs into `0`, `1`, and `2..=255`; the same control flow and contracts apply parametrically on every supported target/profile. No build or test evidence was used.
+
+## TCB-R1 audit log
+
+Both entries are `AXIOM`s, accepted for this review because `EVIDENCE.md` selected these exact versioned Rust authorities and their wording and applicability were directly verified. They have no dependency, implementation, tool, external-specification, deployment, or probabilistic trust extension.
+
+- **AXIOM-UU.** Rust 1.80.0 documents: “Reaching this function is *Undefined Behavior*.” [Standard-library Safety contract](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). Scope: the submitted supported predicate. Consumer: `OBL-UU`. Re-audit on source, version, supported-domain, item-contract, or applicability change.
+- **AXIOM-SOUND.** Rust 1.80.0 says unsafe code that safe code can misuse to exhibit UB “is *unsound*,” and that unsafe does not permit UB. [Reference UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html). Scope: Rust 1.80.0 source semantics. Consumer: `OBL-SOUND`. Same re-audit triggers.
+
+TCB disposition: accepted and complete for the propositions consumed here. This is a source-level result, not a theorem about any compiler backend or produced binary.
+
+## Invariant and obligation ledger
+
+| ID | Exact proposition and derivation | Status |
+|---|---|---|
+| `INV-UNREACHABLE` | The safety comment claims the zero branch is unreachable. It has no producer or enforcement boundary; `match input` selects that branch exactly when the safe caller supplies zero. | **REFUTED** |
+| `OBL-UU` | Calling `unreachable_unchecked` requires that execution not reach it. For `input = 0`, evaluation selects the first arm, evaluates the harmless local assignments, then reaches the call. By `AXIOM-UU`, that execution has UB. | **UNSOUND** |
+| `OBL-SOUND` | Every valid safe call must be UB-free. The in-scope witness `classify(0u8)` satisfies all safe-API conditions and reaches the UB in `OBL-UU`; by `AXIOM-SOUND`, it refutes the universal theorem. | **UNSOUND** |
+| `OBL-PANIC-0` | For zero, the documented outcome is panic. The source instead reaches UB. Because the execution as a whole contains UB, it supplies no defined behavioral observation and cannot be the required UB-free postcondition refutation. No independent UB-free zero execution is established. | **UNPROVED** |
+| `OBL-RETURN` | For `1`, the second arm normally returns literal `2`; it executes no unsafe operation. Thus `classify(1u8) == 2u8 != 1u8` is a valid UB-free witness. For every `2..=255`, `_ => input` normally returns the input and executes no unsafe operation. For zero, UB prevents a behavioral conclusion. | Overall **CONTRACT-BROKEN**; regional results: `1` **CONTRACT-BROKEN**, `2..=255` **PROVED**, `0` **UNPROVED** |
+
+The three input regions are disjoint and exhaustive, so this ledger covers every valid safe call. The zero-only panic condition is inapplicable for the other two regions.
+
+## Findings and minimum resolutions
+
+**F-1 — reachable `unreachable_unchecked` (`UNSOUND`).** The existing comment merely assumes the exact fact it must prove, and source control flow falsifies it. The zero witness establishes only unsoundness; it does not also establish a broken panic guarantee. Minimum resolution: replace the unsafe call with an actual panic-producing safe path and replace the false safety comment; then audit the changed snapshot.
+
+**F-2 — wrong normal result for one (`CONTRACT-BROKEN`).** `classify(1u8)` is the separate UB-free witness establishing this theorem. Minimum resolution: make the `1` arm return `1`/`input`, or deliberately change the public contract with compatibility analysis, then re-audit.
+
+## Residual scope and attestation
+
+Excluded: binary/backend correctness and behavior outside the supplied file and three requested claims. No design change was implemented, and no target was built, tested, executed, or expanded. There are no authoritative-documentation or skill-guidance gaps needed to decide these claims. Re-audit on changes to source or documentation, Rust/stdlib version, supported targets/profiles, generated inputs, dependencies, or either consumed authority.
+
+Every in-scope API, unsafe site, input region, requested postcondition, configuration class, and consumed TCB proposition has a stated disposition. Auditor: source-review agent; date: 2026-08-01. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/B.md
new file mode 100644
index 0000000000..31626c07f2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/B.md
@@ -0,0 +1,53 @@
+# Focused source-only review of `classify`
+
+## Claims, scope, and verdicts
+
+The audited artifact is exactly the supplied 17-line `lib.rs`. The only API surface is the safe public function `classify(input: u8) -> u8`; all 256 `u8` values are valid safe inputs. No fields, traits, macros, generated code, dependencies, callbacks, mutable state, or representation invariants exist.
+
+`Supported(c)` means: Rust and standard library 1.80.0; any target on which this exact source and `std::hint::unreachable_unchecked` exist; and an ordinary debug or release profile. The proof is source-level and relative to the Rust abstract semantics.
+
+| Requested theorem | Verdict | Reason |
+|---|---|---|
+| Every valid safe call is free from undefined behavior | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked` (F-UB0). |
+| If `input == 0`, the call panics | **UNPROVED**, not `CONTRACT-BROKEN` | The only relevant source path contains UB; it cannot witness a defined failure to panic (F-PANIC0). |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The independent UB-free call `classify(1)` normally returns `2` (F-RET1). |
+
+The combined result is therefore **UNSOUND** with one **UNPROVED** documented guarantee and one **CONTRACT-BROKEN** documented guarantee.
+
+## Authority and TCB
+
+TCB revision `TCB-R1` has two accepted Rust 1.80.0 axioms, submitted for this review and independently opened at the exact supplied URLs:
+
+- **AXIOM-UU:** The Safety section for [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states: “Reaching this function is Undefined Behavior.”
+- **AXIOM-UB:** The [Rust Reference UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) states that `unsafe` does not relax the requirement that programs never cause UB and calls unsafe code *unsound* when safe code can trigger UB.
+
+Both axioms apply throughout `Supported(c)` as stipulated by `EVIDENCE.md`. No additional assumption, dependency, tool result, test, compiler-backend claim, or deployment restriction is consumed.
+
+## Complete case and obligation proof
+
+| Input | Executed path | UB freedom | Zero panic | Normal-return equality |
+|---|---|---|---|---|
+| `0` | Lines 8–12, reaching `unreachable_unchecked()` | **UNSOUND** | **UNPROVED** | **UNPROVED** for this input; no UB-free normal-return witness |
+| `1` | Line 14, returns literal `2` | **PROVED** | Not applicable | **CONTRACT-BROKEN** |
+| `2..=255` | Line 15, returns `input` | **PROVED** | Not applicable | **PROVED** |
+
+This partition is exhaustive for `u8`. It is unchanged by target or ordinary profile: the source has no `cfg`, target-dependent operation, generated artifact, arithmetic, allocation, concurrency, FFI, panic-mode-dependent cleanup, or debug-only assertion. The same match-arm reasoning therefore covers every supported configuration parametrically.
+
+### F-UB0 — valid safe call reaches UB
+
+Witness: call the safe API as `classify(0)`. The `0` pattern selects lines 8–12. The local `u8` assignment and discard do not alter control flow; execution then reaches the unsafe call. AXIOM-UU makes that reach UB. Because the API is safe and enforces no caller obligation excluding zero, this is a valid safe call. AXIOM-UB therefore entails **UNSOUND** for the universal UB-freedom theorem on every supported target/profile.
+
+The adjacent comment, “This branch is assumed to be unreachable,” supplies no fact: the controlling match condition proves the opposite. The smallest missing implication would be `input == 0 implies the 0 arm is unreachable`, which is false.
+
+### F-PANIC0 — UB cannot refute a behavioral contract
+
+The same input `0` does **not** establish `CONTRACT-BROKEN` for “Panics when `input == 0`.” Undefined behavior is classified over the execution as a whole. A UB-containing execution cannot serve as the required UB-free witness that the function fails to panic, and observations from its pre-UB prefix are insufficient. No distinct input can refute this conditional promise because its premise is specifically `input == 0`. Thus the panic guarantee is **UNPROVED**. Repair requires a defined panic on the zero arm; merely changing the safety comment cannot repair it.
+
+### F-RET1 — independent defined contract refutation
+
+Witness: `classify(1)`. Line 14 is selected and normally returns `2`; the zero arm and its unsafe call are not executed. This path performs only the match and a `u8` return, so it is UB-free. Since `2 != 1`, this whole defined execution falsifies “On normal return, returns `input` unchanged.” It therefore establishes **CONTRACT-BROKEN**, independently of F-UB0. For every `input` in `2..=255`, line 15 instead returns that exact input and proves the guarantee for that class. Repair line 14 to return `input` (or deliberately revise the public contract with compatibility review).
+
+## Residual scope and review triggers
+
+No build, execution, test, expansion, backend correctness, or binary/platform behavior was reviewed. Re-audit is required if the source or either documented guarantee changes; if Rust/stdlib differs from 1.80.0; if the supported target/profile set changes; or if either consumed authority changes materially.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/C.md
new file mode 100644
index 0000000000..5dfb864352
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/C.md
@@ -0,0 +1,64 @@
+# Focused source-only audit of `classify`
+
+## Claims and verdicts
+
+| Claim | Exact theorem over `Required` | Verdict | Certificate |
+|---|---|---|---|
+| C-SOUND | Every valid safe call `classify(input)` is free from Rust undefined behavior. | **UNSOUND** | W0 below: the valid safe call with `input = 0` reaches `unreachable_unchecked`. |
+| C-PANIC | Every call with `input = 0` panics. | **UNPROVED** | The only source path reaches UB. That execution cannot certify a behavioral contract refutation, and there is no UB-free witness. |
+| C-RESULT | Whenever the call returns normally, its result equals `input`. | **CONTRACT-BROKEN** | W1 below: the UB-free call with `input = 1` normally returns `2`. |
+
+The combined mandatory result is therefore not `PROVED`; its component results are **UNSOUND**, **UNPROVED**, and **CONTRACT-BROKEN**, respectively.
+
+## Snapshot, scope, and domain closure
+
+The artifact is the submitted `lib.rs`, SHA-256 `705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`. Scope is its sole language-reachable API, safe public free function `pub fn classify(u8) -> u8`, including its internal unsafe call. There are no fields, traits, macros, generated artifacts, dependencies, callbacks, FFI, concurrency, allocators, or representation invariants in the submitted source.
+
+Audit cutoff: 2026-08-01. The controlling request defines
+
+`Required = {exact source} × {Rust compiler and standard library 1.80.0} × {targets where this exact source and the used item exist} × {ordinary debug, ordinary release} × {every valid u8 input}`.
+
+The source contains no `cfg`, feature, target, or profile-dependent selection. Partition the input domain exactly by the exhaustive match patterns: `D0 = {0}`, `D1 = {1}`, and `D_ = {valid u8 values other than 0 and 1}`. Thus `Required = D0 ∪ D1 ∪ D_` for every required target/profile. The proofs below are parametric in target and profile: neither axis changes the selected source arm, and the submitted authoritative propositions expressly apply throughout that target/profile domain. This proves configuration coverage for each regional result; C-SOUND and C-RESULT are globally refuted by covered witnesses, while C-PANIC has the stated unresolved obligation on all of `D0`. No compilation or test evidence was used.
+
+## Authority and TCB
+
+TCB revision `TCB-classify-1` contains only the two requester-submitted Rust 1.80.0 axioms, independently opened and accepted for this review:
+
+- **AXIOM-UU:** the Rust 1.80.0 standard-library Safety section says, “Reaching this function is *Undefined Behavior*.” It applies to `std::hint::unreachable_unchecked` over every required target/profile. [Official item documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+- **AXIOM-SOUND:** the Rust 1.80.0 Reference says that if unsafe code “can be misused by safe code to exhibit undefined behavior, it is *unsound*.” It controls the source-level classification here. [Official UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html).
+
+All other premises below are direct control/value-flow facts from the exact source. No compiler-backend, binary, platform-implementation, tool, or dependency proposition is admitted.
+
+## Obligation ledger and case proofs
+
+| ID | Obligation | Case disposition |
+|---|---|---|
+| O-UNREACHABLE | A reached call to `unreachable_unchecked` must in fact be unreachable. | False on `D0`; the match selects that arm and execution reaches the call. The call is absent on `D1` and `D_`. |
+| O-SOUND | No valid safe call may reach UB. | Refuted by W0. On `D1` and `D_`, the unsafe site is not reached; each arm directly returns a valid `u8`. |
+| O-PANIC | On `D0`, the call must panic. | Unproved: the path reaches UB rather than a panic operation, but its UB prevents a `CONTRACT-BROKEN` certificate. |
+| O-RESULT | On every UB-free normal return, result equals input. | Refuted by W1 on `D1`; proved locally on `D_` because that arm evaluates to `input`. `D0` supplies no UB-free normal-return witness. |
+
+### W0: exact UB witness (`input = 0`)
+
+1. `classify(0)` is well-typed safe use of a safe public function; it has no caller safety precondition.
+2. Pattern `0` is selected. The local `marker` operations complete, then the unsafe call to `std::hint::unreachable_unchecked()` is reached.
+3. Therefore the call's required proposition—its site is unreachable—is false.
+4. AXIOM-UU entails UB, and AXIOM-SOUND classifies a safe API permitting this witness as unsound.
+
+This complete witness establishes **UNSOUND** for C-SOUND on every required target/profile. It does **not** establish `CONTRACT-BROKEN` for C-PANIC: an execution containing UB cannot be the required UB-free behavioral counterexample, nor can its behavior after UB prove the panic guarantee.
+
+### W1: exact defined contract witness (`input = 1`)
+
+Pattern `1` is selected and directly evaluates to valid `u8` value `2`; the unsafe arm is not entered and no other UB-producing operation exists on this path. The call therefore returns normally and UB-free with `result = 2`, while `input = 1`. Since `2 != 1`, W1 establishes **CONTRACT-BROKEN** for C-RESULT. It does not establish unsoundness.
+
+### Other inputs
+
+For every valid `u8` other than `0` and `1`, the wildcard arm directly returns `input`. The unsafe site is unreachable on these calls, so this region is sound and satisfies C-RESULT. These regional proofs do not erase either existential witness.
+
+## Findings and repairs
+
+**F1 — implementation unsoundness and false proof comment.** The comment “This branch is assumed to be unreachable” neither derives the unsafe precondition nor states a true fact: `input = 0` makes the branch reachable. No replacement safety proof can validate the current operation. To meet C-PANIC, replace the unsafe call with an unconditional panic on that arm. Re-audit the changed source.
+
+**F2 — normal-result contract defect.** Arm `1 => 2` contradicts the documented unchanged-result guarantee. Return `1`/`input`, or deliberately revise the public contract with compatibility review. This repair is independent of F1.
+
+Residual scope excludes other Rust releases, targets where the source/item does not exist, nonordinary profiles, backend/binary correctness, and properties not requested. Re-audit on any source or documentation change, Rust/standard-library version change, support-domain expansion, or material change to either consumed official contract.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/D.md
new file mode 100644
index 0000000000..d4d3354f83
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/D.md
@@ -0,0 +1,51 @@
+# Focused unsafe-Rust audit: `classify`
+
+## Claim, scope, and verdicts
+
+Snapshot: the exact submitted `lib.rs`, whose only public item is `pub fn classify(input: u8) -> u8`. This is a source-level review under the documented Rust abstract semantics. Let **S** be Rust compiler and standard library 1.80.0, every edition and target on which this exact source and `std::hint::unreachable_unchecked` exist, and every ordinary debug or release profile. The proof is parametric over S. A valid use is any well-typed safe call with any `u8`; there is no caller safety precondition.
+
+| Claim | Verdict over S | Decisive reason |
+|---|---|---|
+| Every valid safe call is free of UB | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked`. |
+| Every call with `input == 0` panics | **UNPROVED** | The only source path reaches UB. That execution cannot establish a defined behavioral refutation. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The separate UB-free call `classify(1)` normally returns `2`. |
+
+The combined mandatory result is therefore **UNSOUND**, **UNPROVED** for the zero-input panic guarantee, and **CONTRACT-BROKEN** for the normal-return result guarantee, relative to TCB `TCB-1` below.
+
+## Authority and TCB (`TCB-1`)
+
+`AXIOM-UB-1` (AXIOM, accepted): for Rust 1.80.0, the Safety section of [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states: “Reaching this function is Undefined Behavior.” The submitted evidence states that this proposition applies throughout S. The Rust 1.80.0 [undefined-behavior chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) is the controlling Reference context for the source-level classification. Consumer: obligation `O-UB-0`. Re-audit on source, Rust/stdlib version, supported-set, or cited-contract change.
+
+No dependency, external, deployment, compiler-backend, tool, probabilistic, or implementation premise is consumed. No tests or tool-derived evidence were used. This TCB supports only a source-level result, not correctness of a particular emitted binary.
+
+## Surface and configuration coverage
+
+The complete language-reachable surface in the supplied source is safe free function `classify`; it accepts every `u8`. Its sole unsafe site is the call to `unreachable_unchecked` in the `0` arm. There are no public fields, types, traits, callbacks, macros, FFI, generated artifacts, dependencies, invariants, concurrency, allocation, or target-conditioned items.
+
+The `match` partitions all `u8` values exhaustively into `0`, `1`, and `2..=255`. No `cfg`, arithmetic, debug assertion, layout, target feature, or profile-dependent operation affects selection or results. Thus the same control-flow proof covers every member of S: optimization cannot repair a source-level execution that reaches an operation whose contract declares that reach UB, and debug/release differences do not alter either defined return arm.
+
+## Obligation ledger and proofs
+
+### `O-UB-0` — safe-call soundness, `input = 0`: **UNSOUND**
+
+Local facts: `0` selects the first arm; the two `marker` statements complete without changing `input` or control flow; execution then reaches the unsafe call. By `AXIOM-UB-1`, that reach is UB. Hence the valid safe invocation `classify(0)` is an in-scope UB-containing execution on every S configuration and refutes the universal soundness theorem.
+
+The adjacent comment, “This branch is assumed to be unreachable,” is a false and circular proof artifact: the immediately enclosing match arm itself establishes reachability when `input == 0`. A safe caller is permitted to supply zero, and the documentation affirmatively specifies its behavior. No caller obligation can be inferred.
+
+### `O-PANIC-0` — zero-input panic: **UNPROVED**
+
+Witness considered: `classify(0)` follows the path above and reaches UB; no panic operation occurs before that point. This witness proves `O-UB-0`, but an execution containing UB cannot prove the existence of an UB-free execution falsifying a documented postcondition. Therefore it cannot establish **CONTRACT-BROKEN**. Conversely, source execution through `unreachable_unchecked` supplies no defined panic postcondition, so the panic guarantee is not proved. No independent UB-free zero-input witness or equivalent proof was established.
+
+### `O-RESULT-1` — normal return, `input = 1`: **CONTRACT-BROKEN**
+
+`1` selects the second arm, so the unsafe first arm is not executed. The arm evaluates the valid `u8` literal `2` and normally returns it. The complete execution is UB-free, while `2 != 1`; it is therefore the required defined witness falsifying “returns `input` unchanged.” This witness is independent of the zero-input UB witness.
+
+### `O-RESULT-REST` — normal return, `input = 2..=255`: **PROVED**
+
+Every such value selects `_ => input`, does not execute the unsafe arm, and normally returns the copied input unchanged. For `input = 0`, the normal-return guarantee remains **UNPROVED** because its only source path contains UB; that case supplies neither a defined return nor a contract-breaking witness. The input-zero panic condition is inapplicable to all nonzero inputs. Soundness is locally proved for `1..=255` because those paths contain only the inspected ordinary match/literal/copy/return operations and never reach the unsafe site; this regional result does not change the aggregate **UNSOUND** verdict.
+
+## Findings and required resolution
+
+`F-1` is an implementation soundness defect and a deficient safety comment. Replace the zero arm with an actual panic; no revised `SAFETY` comment can justify the current call while zero remains accepted by the safe signature. `F-2` is an independent behavioral defect: return `input` rather than `2` in the `1` arm. Removing the unsafe call and applying both changes requires a fresh audit of the new snapshot.
+
+Residual scope is limited to backend/binary correctness and configurations outside S. Re-audit is required if the source, public documentation, Rust/stdlib version, cited authority, item availability, or supported configuration predicate changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/E.md
new file mode 100644
index 0000000000..6bfb32900b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/E.md
@@ -0,0 +1,103 @@
+# Focused source-only audit of `lib.rs`
+
+## Claim, snapshot, and verdicts
+
+The audited artifact is exactly `lib.rs` SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is its sole public safe API, `classify(u8) -> u8`. `Supported(C)` means:
+this exact source; Rust compiler and standard library 1.80.0; every target on
+which this source and `std::hint::unreachable_unchecked` exist; and every
+ordinary debug or release profile. This is a Rust source-level result, not a
+compiler-backend or binary theorem. TCB identity is embedded log `TCB-R1` below.
+
+1. **Freedom from UB: UNSOUND in every supported configuration.** The claimed
+   theorem is that every well-typed safe call, for every `u8` input, is free
+   from Rust UB. The valid safe call `classify(0)` refutes it.
+2. **Input-zero panic guarantee: UNPROVED in every supported configuration.**
+   The claim is that every call with `input == 0` panics. Its only source path
+   reaches UB. That UB-containing execution proves unsoundness, but cannot be a
+   UB-free witness that the panic postcondition is false; therefore it does
+   **not** establish `CONTRACT-BROKEN`.
+3. **Normal-return result guarantee: CONTRACT-BROKEN in every supported
+   configuration.** The UB-free witness `classify(1)` normally returns `2`, and
+   `2 != 1`.
+
+The combined mandatory result is `UNSOUND` + panic guarantee `UNPROVED` +
+normal-return guarantee `CONTRACT-BROKEN`.
+
+## Boundary, configuration, and obligation coverage
+
+The complete language-reachable surface is the safe free function `classify`.
+There are no public fields, constructors, user-defined types or traits, hidden
+items, callbacks, FFI, macros, generated artifacts, dependencies other than
+`std`, conditional compilation, features, concurrency, allocation, or
+invariant-bearing state. The `allow(dead_code)` attribute and `marker` local do
+not affect control flow or safety. The only unsafe site is
+`unreachable_unchecked()` at `lib.rs:12`.
+
+The input partition is exhaustive for `u8` and supplies the obligation ledger:
+
+| Input | Source derivation | UB status | Applicable postcondition result |
+|---|---|---|---|
+| `0` | The `0` arm is selected; the two inert `marker` statements complete; execution reaches `unreachable_unchecked()` unconditionally. | UB by `AXIOM-UU`; this is the exact safe-call witness for `UNSOUND`. | It cannot establish either a defined failure to panic or a defined normal return. The panic claim remains `UNPROVED`. |
+| `1` | The distinct `1 => 2` arm normally returns `2`; it executes no unsafe operation and no panic. | UB-free relative to an otherwise defined safe calling context. | Exact UB-free witness for `CONTRACT-BROKEN`: normal result `2` differs from input `1`. |
+| `2..=255` | The `_ => input` arm normally returns that input and executes no unsafe operation. | UB-free relative to an otherwise defined safe calling context. | The normal-return guarantee is satisfied for each of these inputs. |
+
+`OBL-UU` is the intrinsic's requirement that its call site not be reached.
+`classify(0)` proves the required proposition false. The adjacent comment,
+“This branch is assumed to be unreachable,” is not a proof and directly
+contradicts the enclosing match arm. `OBL-SOUND` therefore fails. `OBL-PANIC`
+cannot be proved from an execution after UB. `OBL-RETURN` is independently
+refuted by the defined input-`1` execution.
+
+This partition is parametric over every supported target and profile: the
+source has no configuration selection, and optimization/debug settings do not
+alter the Rust 1.80.0 abstract contract that reaching the intrinsic is UB or
+the source-level selection of the `0`, `1`, and catch-all arms. Thus the union
+of the three cases closes the requested configuration domain without sampling.
+
+## TCB-R1 and authority
+
+| ID | Accepted Rust 1.80.0 proposition | Scope and consumers | Disposition |
+|---|---|---|---|
+| `AXIOM-UU` | The standard-library Safety section states: “Reaching this function is *Undefined Behavior*.” ([Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)) | Every supported target/profile where the item exists; `OBL-UU`, `OBL-SOUND`, `OBL-PANIC`. | Accepted: exact request-selected authority independently opened and verified. |
+| `AXIOM-REF` | The Reference says unsafe code is unsound when safe code can trigger UB, and lists “Invoking undefined behavior via compiler intrinsics.” ([Rust 1.80.0 Reference](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)) | Rust 1.80.0 source semantics; aggregation of `OBL-SOUND`. | Accepted: exact request-selected authority independently opened and verified. |
+
+No external, implementation, dependency, tool, deployment, probabilistic, or
+out-of-band premise is consumed. No tests, execution, compilation, expansion,
+or tool-derived proof was used. The TCB must be revisited if either cited
+contract or the supported Rust/target/profile predicate changes.
+
+## Findings and minimum resolution
+
+### F-01 — reachable `unreachable_unchecked`
+
+- **Status:** `UNSOUND`; proof artifact deficient.
+- **Witness:** the well-typed safe call `classify(0)`, in every supported
+  configuration.
+- **Defect:** the required implication `input == 0 implies this arm is
+  unreachable` is false; the condition instead selects the arm.
+- **Resolution:** replace the UB path with a defined panic. Remove the false
+  `SAFETY` comment and unsafe call.
+
+### F-02 — input-zero panic is not established
+
+- **Status:** `UNPROVED`, not `CONTRACT-BROKEN`.
+- **Evidence classification:** `classify(0)` reaches UB before any panic. As an
+  execution containing UB, it establishes F-01 but cannot establish the
+  required UB-free existential refutation of this behavioral contract.
+- **Resolution:** implement a defined panic in the zero arm, then re-audit.
+
+### F-03 — normal return changes input one
+
+- **Status:** `CONTRACT-BROKEN`; implementation behavior is defined on this
+  witness and the documentation is unambiguous.
+- **Witness:** `classify(1)` selects `1 => 2` and normally returns `2` without
+  executing unsafe code; hence it is an independent UB-free refutation.
+- **Resolution:** return `input` in the `1` arm (or remove that special arm).
+
+There is no authoritative-documentation gap in the propositions needed for
+these conclusions. Excluded residual scope is compiler/backend correctness and
+binary behavior. Re-audit on any source, contract, Rust version, supported-set,
+or cited-authority change. Every in-scope surface, input, obligation, and
+requested postcondition has the status recorded above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/F.md
new file mode 100644
index 0000000000..c11ba5ce1a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/F.md
@@ -0,0 +1,102 @@
+# Focused source-only unsafe Rust audit
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is solely the public safe function `classify` in lines 6–17. No generated
+artifacts, dependencies, macros, callbacks, traits, fields, or other public
+surfaces exist in the submitted source. This review did not build, execute,
+test, or expand the target.
+
+Let `Required(t,p,i)` mean: the exact source above; Rust compiler and standard
+library 1.80.0; a target `t` on which this source and the used 1.80.0
+`std::hint::unreachable_unchecked` item exist; ordinary debug or ordinary
+release profile `p`; and a well-typed safe call `classify(i)` for `i: u8`.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call in `Required` is free from Rust undefined behavior | **UNSOUND** | For every required `t,p`, the valid safe call `classify(0)` reaches `unreachable_unchecked`; AX-1 says reaching it is UB. |
+| When `input == 0`, the call panics | **UNPROVED**, not `CONTRACT-BROKEN` | The source reaches UB before establishing a panic. That execution proves unsoundness, but an execution containing UB cannot certify a broken behavioral contract. No independent UB-free zero-input witness was supplied or derivable. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | For every required `t,p`, `classify(1)` takes line 14 and normally returns the valid `u8` value `2`; `2 != 1`. This path never enters the unsafe block and consists only of the matched safe return, so the whole witness is UB-free. |
+
+The combined requested result is therefore not proved: it has the component
+statuses `UNSOUND`, `UNPROVED`, and `CONTRACT-BROKEN` above.
+
+## Authority and TCB (`TCB-R1`)
+
+Both entries were opened at their exact versioned URLs and checked in context.
+They are accepted Rust-authority premises for this source-level review, with the
+target/profile applicability expressly supplied by `EVIDENCE.md`.
+
+* **AX-1 (Rust 1.80.0 std):** The Safety section for
+  [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)
+  states: “Reaching this function is Undefined Behavior.” Consumer: OBL-UB.
+* **AX-2 (Rust 1.80.0 Reference):** The
+  [undefined-behavior chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)
+  says unsafe code that safe code can misuse to exhibit UB is unsound, and that
+  `unsafe` does not permit Rust programs to cause UB. Consumer: the safe-wrapper
+  soundness classification.
+
+No compiler-backend correctness, tested behavior, platform implementation, or
+tool result is assumed: these are source-level conclusions under documented
+Rust 1.80.0 abstract semantics. The Reference warns that its general UB list is
+not exhaustive; the UB certificate does not rely on that list being exhaustive,
+because AX-1 directly classifies the reached operation.
+
+## Boundary, cases, and obligation ledger
+
+The sole safe boundary is `pub fn classify(input: u8) -> u8`. Its documentation
+supplies the two behavioral contracts at lines 3 and 5. The sole unsafe
+consumer is the call at line 12. It requires that control never reach it. The
+comment at line 11 merely assumes that proposition and does not prove it.
+
+The input partition is exhaustive by equality: `i = 0`, `i = 1`, or
+`i != 0 && i != 1`.
+
+| Case | Control/data-flow proof | Disposition |
+|---|---|---|
+| `i = 0` | The `match` selects lines 8–13; the harmless `marker` statements do not alter `input` or control flow; line 12 is reached. | OBL-UB false by AX-1; safe-call soundness is `UNSOUND`. The panic theorem remains `UNPROVED`. This case supplies no UB-free normal return and therefore does not refute the conditional result theorem. |
+| `i = 1` | The `match` selects `1 => 2`; it reaches no unsafe operation and normally returns `2`. | Sound for this execution; panic contract inapplicable; exact UB-free witness for `CONTRACT-BROKEN` result guarantee. |
+| `i != 0 && i != 1` | The wildcard arm normally returns `input` and reaches no unsafe operation. | Sound for these executions and the normal-return result guarantee holds. Panic contract inapplicable. |
+
+The local invariant suggested by the safety comment—“the zero arm is
+unreachable”—has no enforcing owner or producer and is directly falsified by
+`i = 0`. The implementation defect and proof-comment defect are therefore
+separate: reconstruction cannot repair the false premise.
+
+## Configuration closure
+
+`REQUEST.md` directly defines the symbolic target set, exact Rust version, and
+two profiles; no target enumeration or widening is used. The source contains
+no `cfg`, feature gate, target-specific operation, arithmetic, debug assertion,
+generated code, allocation, concurrency, FFI, or profile-dependent branch.
+Branch selection depends only on `i`. AX-1's applicability over the declared
+target/profile domain is supplied by `EVIDENCE.md`. Consequently each case
+derivation is parametric in `t,p`, and the three input predicates exhaust every
+`i: u8`. The zero and one witnesses therefore exist on every member of the
+required configuration domain; optimization cannot turn their source-level UB
+or defined `1 => 2` return into the opposite theorem.
+
+Because the two universal claims have complete existential refutations (UB for
+soundness, a UB-free wrong result for normal return), they do not require a
+positive `Required ⊆ Covered` certificate. The zero-input panic claim lacks
+the UB-free evidence required for either a proof or a `CONTRACT-BROKEN`
+certificate and is intentionally left `UNPROVED`.
+
+## Findings and remediation
+
+1. **F-UB0 — critical, `UNSOUND`:** a caller needs no unsafe act or undocumented
+   precondition to call `classify(0)`. The selected arm executes line 12, whose
+   exact safety proposition (“must not be reached”) is false; AX-1 supplies the
+   UB consequence. Replace that arm with a real panic (for example `panic!` or
+   `unreachable!`) and remove the false safety proof.
+2. **F-RESULT1 — `CONTRACT-BROKEN`:** the independent UB-free call
+   `classify(1)` normally returns `2`, falsifying line 5. Return `input` in this
+   arm or remove the special arm.
+
+Residual scope is exactly what the request excludes: other Rust releases,
+targets where the source/item do not exist, nonordinary profiles, binaries,
+backend correctness, and any source other than the submitted file. Re-audit on
+source or contract changes, Rust/stdlib version changes, target/profile-domain
+changes, or material changes to either cited authority.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/G.md
new file mode 100644
index 0000000000..d1cf103692
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/G.md
@@ -0,0 +1,104 @@
+# Focused unsafe-Rust source review
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: exact `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is the sole public safe function `classify(u8) -> u8` and its internal
+unsafe call. This is a source-level review only; no compiler, backend, binary,
+test, generated artifact, dependency, or prior audit is in scope. Audit cutoff:
+2026-08-01. TCB: `TCB-R009-v1` below.
+
+Let `C` be exactly: Rust and standard library 1.80.0, any target on which this
+exact source and `std::hint::unreachable_unchecked` exist, and either ordinary
+debug or ordinary release profile. `Required = C × {input | input: u8}`; every
+such call is a valid safe use, with no caller-side safety precondition.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call is free from Rust UB | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked`; its Rust 1.80.0 contract makes reaching it UB. |
+| If `input == 0`, the call panics | **UNPROVED** | The only source path reaches UB, so it cannot be a UB-free contract-refutation witness or establish a panic. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | `classify(1)` has a UB-free normal return of `2`, and `2 != 1`. |
+
+The combined mandatory result is therefore not `PROVED`.
+
+## Boundary, cases, and obligation ledger
+
+The complete language-reachable surface is the safe free function at lines
+6–17. There are no public fields, types, constructors, trait implementations,
+callbacks, macros, hidden APIs, dependencies, or invariant-bearing state. The
+only unsafe obligation site is line 12.
+
+The partition `{0} ∪ {1} ∪ {2..=255}` equals the complete `u8` input set:
+
+- **Input 0.** A well-typed safe caller may invoke `classify(0)`. The `0`
+  pattern selects lines 8–13; the two local assignments do not alter control
+  flow, and line 12 is reached. Rust 1.80.0 documents: “Reaching this function
+  is Undefined Behavior.” Thus the required safety proposition at line 12
+  (“this call site is unreachable”) is false, and the documented consequence
+  is UB. This completes the existential `UNSOUND` certificate in every `C`.
+  The same execution cannot establish `CONTRACT-BROKEN` for the panic promise:
+  it contains UB as a whole. No separate UB-free zero-input execution or panic
+  derivation exists in the inspected source, so that promise is `UNPROVED`.
+  Likewise, this execution supplies no normal-return result witness.
+- **Input 1.** Line 14 returns `2` without executing the unsafe site. This is a
+  UB-free normal return, but the input is `1`; it therefore completes the
+  existential `CONTRACT-BROKEN` certificate for the unchanged-result promise.
+  It is not a soundness counterexample and the zero-input promise is
+  inapplicable.
+- **Inputs 2 through 255.** Line 15 returns the input itself and the unsafe site
+  is not executed. These calls are UB-free and satisfy the normal-return
+  promise. The zero-input promise is inapplicable.
+
+| ID | Exact obligation | Status |
+|---|---|---|
+| O-S0 | Safe `classify(0)` must not reach UB | **UNSOUND**, witness above |
+| O-SNZ | Safe calls for `1..=255` must avoid UB | **PROVED**, exhaustive nonzero branches above |
+| O-P0 | `classify(0)` must panic | **UNPROVED**, UB occurs with no panic proof |
+| O-R0 | Result clause for input 0, if normally returning | No UB-free normal-return instance established; not a refutation witness |
+| O-R1 | A normal return for input 1 must equal 1 | **CONTRACT-BROKEN**, UB-free result 2 |
+| O-RN | Normal returns for `2..=255` equal their inputs | **PROVED** |
+
+## Domain and configuration closure
+
+The request's predicate is retained verbatim as `C`; no version interval was
+invented. The source contains no `cfg`, feature selection, generated code,
+arithmetic, debug assertion, allocation, FFI, target feature, or panic-mode
+branch. Target and profile therefore do not change the match partition or
+dataflow. Both consumed Rust pages are versioned 1.80.0 and their relevant
+propositions have no narrower target/profile qualification. The proofs and
+witnesses above are consequently parametric over all `C`; debug/release and
+optimization do not rescue a source-level UB execution. Thus every required
+configuration is covered by the case analysis. There are no enforced or
+report-only exclusions and no uncovered configuration remainder.
+
+## TCB-R009-v1
+
+| ID | Accepted Rust 1.80.0 proposition | Scope and consumer |
+|---|---|---|
+| AXIOM-UU | [`unreachable_unchecked` Safety](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety): “Reaching this function is Undefined Behavior.” | Every `C`; O-S0 |
+| AXIOM-UB | [Reference: behavior considered undefined](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html): safe-client-triggerable UB makes unsafe code unsound; `unsafe` does not permit UB. | Every `C`; soundness classification |
+
+Both exact URLs were opened and their wording, version, and applicability were
+verified. They are accepted as versioned Rust authorities under the audit trust
+policy. No additional assumption, tool-derived fact, implementation premise,
+or safe/unsafe dependency is consumed. This does not claim binary-level
+compiler correctness.
+
+## Findings and resolution
+
+**F-1 — implementation unsound; proof comment false.** The line-11 comment
+merely assumes the exact property the callee requires and is contradicted by
+the dominating `0` match arm. A stronger comment cannot repair the code.
+Replace the zero arm's unsafe call with an operation that actually panics (for
+example `panic!`) and freshly audit the edited artifact.
+
+**F-2 — normal-return contract broken.** Line 14 must return `input` (therefore
+`1`) if the documented guarantee is retained. This UB-free witness is
+independent of F-1.
+
+There is no authoritative-documentation gap. Re-audit on any source or contract
+change, Rust/standard-library version change, support-domain expansion, or
+material change to either consumed authority. Every in-scope obligation and
+each distinct input region has a disposition; no test result or absence of a
+counterexample supports a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/H.md
new file mode 100644
index 0000000000..36fedc61c8
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/H.md
@@ -0,0 +1,105 @@
+# Focused unsafe-Rust source review
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: target/lib.rs, SHA-256
+705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1.
+The only API in scope is the public safe free function classify at lib.rs:6–17.
+The audit is source-only; no build, execution, test, expansion, or source change
+was performed.
+
+Supported(configuration) means: this exact source; Rust compiler and standard
+library 1.80.0; every target on which this source and
+std::hint::unreachable_unchecked exist; and either ordinary debug or release
+profile. The claims quantify over every u8 input to a well-typed safe call.
+
+1. **Freedom from undefined behavior: UNSOUND.** The valid safe call
+   classify(0) reaches undefined behavior.
+2. **Input-zero panic guarantee: UNPROVED.** The zero-input execution contains
+   UB. It therefore cannot prove the documented panic, and that same execution
+   cannot serve as a UB-free witness for CONTRACT-BROKEN.
+3. **Normal-return result guarantee: CONTRACT-BROKEN.** The independent,
+   UB-free call classify(1) returns 2, not its input 1.
+
+The combined mandatory result is therefore not PROVED. These verdicts are
+source-level Rust conclusions relative to TCB-C1 below; they make no claim that
+a particular compiler backend emits a correct binary.
+
+## Contracts and complete API boundary
+
+- SND: every valid safe call is free of Rust UB.
+- PANIC: when input equals 0, the call panics.
+- RESULT: on normal return with value r, r equals input.
+
+classify is the complete language-reachable boundary: there are no public
+fields, types, constructors, methods, trait implementations, macros, hidden
+items, callbacks, FFI surfaces, dependencies, or generated artifacts. The only
+unsafe obligation site is lib.rs:12. No representation invariant exists. Its
+local precondition is that control must not reach
+std::hint::unreachable_unchecked.
+
+## Exhaustive derivation and witness classification
+
+The match at lib.rs:7 partitions all u8 inputs into disjoint, exhaustive cases.
+The proof is parametric over every supported target and both profiles because
+there is no conditional compilation, target-dependent operation, checked
+arithmetic, debug assertion, allocation, panic-mode-dependent cleanup, or
+generated code.
+
+| Input | Source path | Whole-execution result | Obligations |
+|---|---|---|---|
+| 0 | The 0 arm at line 8 performs two ordinary local operations, then necessarily calls the intrinsic at line 12. | Reaching that call is UB by AXIOM-UU. | Refutes SND and establishes UNSOUND. It does not establish CONTRACT-BROKEN for PANIC or RESULT because the execution as a whole contains UB; it also does not return normally. PANIC remains UNPROVED. |
+| 1 | The arm at line 14 directly evaluates to 2; the unsafe arm is not executed. | UB-free normal return of 2 through ordinary typed control flow. | SND holds for this input, PANIC is inapplicable, and 2 ≠ 1 gives the UB-free witness required to establish CONTRACT-BROKEN for RESULT. |
+| 2 through 255 | The wildcard arm at line 15 evaluates to input; the unsafe arm is not executed. | UB-free normal return of the original u8. | SND and RESULT are proved for every input in this range; PANIC is inapplicable. |
+
+Thus W0 = classify(0) is exactly an UNSOUND witness, while W1 = classify(1)
+is exactly a defined postcondition-refutation witness. Keeping them distinct is
+necessary: observations from W0 cannot establish a defined behavioral breach.
+
+## Unsafe-call proof review
+
+The safety comment at lib.rs:11 says the branch is “assumed to be unreachable.”
+That is not a proof and is false: the immediately controlling match selects the
+branch precisely for the valid value 0. Because classify is safe, no prose-only
+caller obligation may exclude that value. The required implication
+“input is 0 implies this program point is unreachable” is contradicted by the
+local control flow. This is both an implementation defect and a deficient proof
+artifact; no replacement SAFETY comment can justify the current reachable
+intrinsic.
+
+Minimal resolution: replace the zero arm with an actual panic and make the
+one arm return input (or remove that special arm). The resulting source would
+be a new artifact requiring fresh review.
+
+## TCB-C1
+
+Both entries were opened at their exact submitted Rust 1.80.0 URLs and accepted
+as authoritative axioms for the stated source/configuration domain.
+
+- **AXIOM-UU — accepted.** Rust 1.80.0 standard-library Safety text states:
+  “Reaching this function is Undefined Behavior.”
+  [Exact page](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+  Consumer: the line-12 obligation and W0. Re-audit on Rust/stdlib version,
+  item contract, source, target-domain, or support-policy change.
+- **AXIOM-UB — accepted.** The Rust 1.80.0 Reference identifies invoking UB via
+  compiler intrinsics as undefined behavior and defines unsafe code that safe
+  code can use to exhibit UB as unsound.
+  [Exact chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html).
+  Consumer: SND classification and whole-execution witness rule. Re-audit on
+  Reference, Rust version, source, or claim change.
+
+There are no safe/unsafe dependency, external-specification, implementation,
+tool, deployment, or probabilistic premises. No tool-derived evidence was
+used. TCB identity is this embedded TCB-C1; the supplied unsafe-rust package had
+no visible revision identifier.
+
+## Residual scope and review triggers
+
+Excluded are backend/binary correctness, configurations outside
+Supported(configuration), and behavior of any surrounding crate not supplied.
+There are no authoritative-documentation or skill-guidance gaps needed for
+these conclusions. Re-audit if lib.rs or its documentation changes, the exact
+Rust/stdlib version or supported target/profile set changes, either cited
+contract changes, or the function is placed in a materially different
+generated or external context.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/I.md
new file mode 100644
index 0000000000..8a2dabc4db
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/I.md
@@ -0,0 +1,63 @@
+# Focused unsafe-Rust source review
+
+## Claims, scope, and verdicts
+
+**Snapshot.** The artifact is exactly the inspected `target/lib.rs`; `REQUEST.md` and `EVIDENCE.md` control scope and evidence. No repository, generated output, dependencies, manifests, expansions, or build artifacts were inspected or assumed. This was a source-only review: nothing was built, tested, executed, or edited. Audit date: 2026-08-01. Skill identity: the submitted `unsafe-rust` package, with no revision identifier supplied.
+
+Let `T` be every target on which this exact source and Rust 1.80.0's `std::hint::unreachable_unchecked` exist. The exact required configuration domain is
+
+`D = {exact lib.rs} × {Rust and std 1.80.0} × T × {ordinary debug, ordinary release}`,
+
+and inputs are all `u8` values. This preserves the request's symbolic target predicate; no finite target inventory is inferred. Valid use means every well-typed safe call to the public safe function, with no hidden caller obligation.
+
+| Claim | Exact theorem over `D` | Verdict |
+|---|---|---|
+| `SOUND` | For every input and every permitted execution of `classify(input)`, the execution is free from Rust undefined behavior. | **UNSOUND** (`F-UB-0`) |
+| `PANIC-0` | Every valid call `classify(0)` panics. | **UNPROVED** (`F-PANIC-0`) |
+| `RETURN` | Whenever `classify(input)` returns normally, its result equals `input`. | **CONTRACT-BROKEN** (`F-RETURN-1`) |
+
+The combined mandatory result is therefore not proved. These verdicts are source-level Rust results, not claims about a compiler backend or binary.
+
+## Boundary and obligation inventory
+
+The complete language-reachable API surface in the supplied source is the safe public free function `classify(u8) -> u8` (`lib.rs:6-17`) and its two documented guarantees (`lib.rs:3-5`). There are no exposed fields, constructors, types, traits or impls, macros, reexports, hidden items, callbacks, FFI, statics, operators, or generated APIs. The sole unsafe obligation site is `unreachable_unchecked` at line 12. The local `marker` assignments neither exit nor establish an invariant.
+
+The callee's exact safety requirement is that its site not be reached. No invariant owns or establishes that proposition. Instead, source control flow gives this exhaustive input partition:
+
+| Input | Soundness | Zero-panic guarantee | Normal-return guarantee |
+|---|---|---|---|
+| `0` | **UNSOUND**: reaches the unsafe call. | **UNPROVED**: the same UB-containing execution is not a contract-refutation witness. | **UNPROVED for this case**: UB prevents a postcondition certificate or UB-free refutation. |
+| `1` | **PROVED for this case**: branch returns the valid `u8` literal `2`; no unsafe site is reached. | Not applicable; antecedent `input == 0` is false. | **CONTRACT-BROKEN**: normal result `2 != 1`. |
+| `2..=255` | **PROVED for this case**: `_` returns the valid input and no unsafe site is reached. | Not applicable. | **PROVED for this case**: the returned expression is exactly `input`. |
+
+This partition is exhaustive because `u8` values are `0`, `1`, or `2..=255`. It is parametric over `T` and both profiles: the source has no `cfg`, profile-dependent assertion, arithmetic, allocation, panic-mode branch, target feature, generated code, or target-dependent operation. Thus the regional affirmative proofs cover all of `D` for their stated input regions. Claim-level `SOUND` is refuted by the `0` region; `PANIC-0` has no covered proof region; `RETURN` is independently refuted by the `1` region.
+
+## Proof certificates and findings
+
+### `F-UB-0` — reachable `unreachable_unchecked`
+
+- **Valid in-scope use:** `classify(0)` is a call to a safe public function with a valid `u8`; it has no caller safety precondition.
+- **Reachability:** matching `0` selects the first arm. The two `marker` statements complete, and evaluation reaches line 12 on every configuration in `D`.
+- **False safety proposition:** the call site must be unreachable, but the preceding derivation proves it reachable.
+- **UB consequence:** Rust 1.80.0 documents: “Reaching this function is Undefined Behavior.” ([standard-library Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)). The Rust 1.80.0 Reference explains that unsafe code triggerable by safe code to exhibit UB is unsound ([UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)).
+
+All existential links are established, so this witness proves `SOUND` **UNSOUND**. The existing comment merely assumes the negation of demonstrated control flow; its proof-artifact classification is deficient and its implementation classification is unsound. Minimum repair: make the zero arm perform a defined panic, not `unreachable_unchecked`.
+
+### `F-PANIC-0` — UB is not a panic-contract witness
+
+The exact candidate is `classify(0)`, but its execution reaches UB. A whole execution containing UB may establish unsoundness; it cannot establish `CONTRACT-BROKEN`, which requires a valid UB-free execution falsifying the postcondition. No independent UB-free zero-input execution or proof that zero input panics exists in the inspected source. Therefore the panic guarantee is **UNPROVED**, not `CONTRACT-BROKEN`. Replacing line 12 with a defined panic would establish it.
+
+### `F-RETURN-1` — wrong defined normal result
+
+`classify(1)` is a valid safe call. The `1 => 2` arm returns normally without reaching any unsafe operation, so the whole witness is UB-free. Its result is `2`, while the documented result is the unchanged input `1`. This complete witness proves `RETURN` **CONTRACT-BROKEN** over every configuration in `D`. It proves no unsoundness. Minimum repair: return `input` (or `1`) from this arm.
+
+## TCB audit log (`TCB-1`)
+
+| ID | Category and exact proposition | Identity/scope | Disposition; consumers |
+|---|---|---|---|
+| `AX-UU` | Rust axiom: reaching `unreachable_unchecked` is UB. | Linked Rust 1.80.0 std page; all `D` per supplied applicability statement. | Accepted after direct verification; `F-UB-0`. |
+| `AX-SOUND` | Rust axiom: unsafe code that safe code can trigger to exhibit UB is unsound. | Linked Rust 1.80.0 Reference; all `D` per supplied applicability statement. | Accepted after direct verification; `SOUND`. |
+
+No dependency, implementation, tool, environment, probabilistic, or compiler-backend premise is consumed. The exact supplied proposition that both pages apply throughout `D` is accepted as the task's scope premise. Re-audit is required if source/docs, Rust or std version, target/item-existence predicate, profile set, or either consumed authority changes. Binary behavior, other toolchains/profiles, and targets outside `T` remain excluded. No authoritative-documentation or skill-guidance gap blocked these conclusions.
+
+**Attestation:** every in-scope surface, input case, unsafe obligation, requested postcondition, configuration axis, premise, negative certificate, and residual exclusion has a disposition above. No test result or absence of a counterexample is used.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/J.md
new file mode 100644
index 0000000000..36b316ac32
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/reports/J.md
@@ -0,0 +1,115 @@
+# Focused source-only review of `classify`
+
+## Claims and verdicts
+
+Audited artifact: `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+The only language-reachable API surface is the safe public function
+`classify(u8) -> u8` (`lib.rs:6`). There are no fields, traits, macros,
+callbacks, dependencies, generated artifacts, mutable invariants, or other
+source files contributing code.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call is free from Rust undefined behavior | **UNSOUND** | The valid safe call `classify(0)` reaches `unreachable_unchecked` at line 12. Its required proposition—this site is unreachable—is false, and Rust 1.80.0 documents reaching it as UB. |
+| When `input == 0`, the function panics | **UNPROVED**, not `CONTRACT-BROKEN` | The exact obstructing case is `classify(0)`, but its execution contains UB. It therefore cannot be an UB-free witness that the panic postcondition is false. No independent UB-free zero-input execution or equivalent existence proof is available. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The valid call `classify(1)` takes line 14 and normally returns `2`; this path never enters the unsafe block, is UB-free as a whole, and `2 != 1`. |
+
+Combined mandatory result: **UNSOUND** for safe-API soundness, **UNPROVED**
+for the zero-input panic guarantee, and **CONTRACT-BROKEN** for the
+normal-return result guarantee.
+
+## Exact domain and configuration closure
+
+Let `T` be exactly the targets on which this source and the Rust 1.80.0
+standard-library item exist, and let `P = {ordinary-debug,
+ordinary-release}`. The request defines
+
+`Required = {0..=255} × T × P`.
+
+This is preserved symbolically; no target inventory is inferred. The source
+contains no `cfg`, target feature, arithmetic whose overflow checks differ,
+debug assertion, allocation, FFI, concurrency, panic-mode selection, or
+generated code. Thus the source case split and all local facts below are
+parametric in every `(target, profile) in T × P`. `EVIDENCE.md` expressly
+supplies applicability of both Rust 1.80.0 authority pages throughout that
+same target/profile domain. Accordingly:
+
+- positive soundness coverage is `{1..=255} × T × P`; `{0} × T × P` has the
+  parametric UB witness;
+- panic coverage has the unresolved region `{0} × T × P`;
+- positive result coverage is `{2..=255} × T × P`, the broken region is
+  `{1} × T × P`, and the UB-containing zero case remains unproved for that
+  postcondition.
+
+These regions exhaust `Required` because `{0}`, `{1}`, and `{2..=255}` are an
+exact partition of `u8`. Profile optimization cannot rescue an abstract
+execution that reaches documented UB. This is a source-level conclusion; no
+compiler-backend or binary-correctness claim is made.
+
+## Case proof and obligation ledger
+
+### `input = 0`
+
+The safe signature imposes no caller safety precondition, and `0` is a valid
+`u8`. The match selects line 8; the local `marker` operations do not alter
+control flow; execution reaches line 12. The safety comment at line 11 merely
+assumes unreachability, while the dominating match arm proves reachability for
+this input. Rust 1.80.0's standard-library Safety section states: “Reaching
+this function is Undefined Behavior.” Therefore the exact unsafe-call
+precondition is false and this valid safe call reaches UB. The Rust Reference
+classifies unsafe code that safe code can use to exhibit UB as unsound. This
+closes every link of the `UNSOUND` certificate for every `(target, profile)`.
+
+The same execution cannot certify `CONTRACT-BROKEN` for “panics”: the execution
+as a whole contains UB. It also supplies no proof that a panic occurs. The
+smallest missing proposition is an UB-free theorem that every zero-input call
+panics; none follows from this source. For the conditional normal-return
+guarantee, the zero case likewise supplies neither a defined normal return nor
+an UB-free refutation, so its regional status is `UNPROVED`.
+
+### `input = 1`
+
+The match selects line 14 and returns the literal `2`; it executes no unsafe
+operation. This establishes UB freedom for this case and, independently, the
+UB-free witness `classify(1) == 2 != 1`. Thus it proves
+`CONTRACT-BROKEN` for the normal-return guarantee. The zero-only panic contract
+is inapplicable.
+
+### `input in 2..=255`
+
+The wildcard arm at line 15 returns the bound value `input` and executes no
+unsafe operation. Hence these calls are UB-free and satisfy the normal-return
+result guarantee. The zero-only panic contract is inapplicable.
+
+## TCB audit log
+
+TCB ID: `TCB-source-review-v1`; all entries are accepted because the request
+submitted and authorized these exact versioned official sources.
+
+| ID | Category | Exact proposition and scope | Consumer |
+|---|---|---|---|
+| A1 | AXIOM | On Rust 1.80.0, reaching `std::hint::unreachable_unchecked` is UB, throughout `T × P`. [Rust 1.80.0 std Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) | zero-input UB certificate |
+| A2 | AXIOM | Rust code must not cause UB; unsafe code triggerable by a safe client to exhibit UB is unsound. [Rust 1.80.0 Reference](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) | soundness classification |
+| D1 | submitted domain premise | `EVIDENCE.md` states A1 and A2 apply to every requested target and ordinary profile. | configuration closure |
+
+Both pages were opened and their quoted/consumed propositions verified. No
+test, tool result, compiler implementation, dependency, external specification,
+or deployment assumption is consumed.
+
+## Findings and remediation
+
+`F-UB-0`: line 11's proof artifact is false and deficient; line 12's
+implementation is unsound behind a safe API. Replace the zero arm with a real
+panic (for example, an explicit panic or a safe unreachable panic) and remove
+the unsupported safety claim.
+
+`F-RESULT-1`: line 14 violates the documented normal-return result. Return
+`input` (or otherwise return `1`) if the existing contract is retained.
+Neither proposed repair changes the current-snapshot verdict; repaired source
+requires a fresh audit.
+
+Residual scope is limited to backend/binary correctness and configurations
+outside the exact request. Re-audit on any source, contract, Rust version,
+target/profile domain, standard-library documentation, or TCB-applicability
+change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/PACKET.json
new file mode 100644
index 0000000000..1154621f3d
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "c23fd5c190f565c18ee04ecf9918afd6463e434b573821b34022db16f594fa4e",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "W",
+  "presentation_order": [
+    "F",
+    "G",
+    "E",
+    "C",
+    "A",
+    "B",
+    "H",
+    "J",
+    "D",
+    "I"
+  ],
+  "report_sha256": {
+    "A": "79e602e9a2317fa845b12fb497a3d895697a4ccdf81598750451850f95fce1fc",
+    "B": "99dc13ef74c153e0fc79419057499d99a38105c2d8fe710ddb80a54e70e0dc59",
+    "C": "89b14c495f9833e34e5cf92aa27d75aec62ad353d1b06393998fb1bcc57577ca",
+    "D": "d6e6359967799119d7119d804bbeb26db216412f3baab76d2392102683dc4fe2",
+    "E": "77862cfc78b4998dd4c0f05da7a160bf578f1f069da9ef7ca577bfaf19836aa6",
+    "F": "97b483500c362b67ec5966a089ea6c9d0c039bbfe454e5b05d854edc693bf982",
+    "G": "4bde4f56c31f9d422f72c61118fc884593ad0e9c897b3de60d37c1f1d7a2534d",
+    "H": "f8c5a10d8f94f043be587dfcb073640526162160b8a5f33384c243d98ffc9e59",
+    "I": "a7f109ef70b6a8ac7b471cc4a3122f4b8e2f92b45305f0f419ead77cf670528e",
+    "J": "cc9fd179a072064534dd9b337b68629aa110ba586546632b898c0d96532d449b"
+  },
+  "rubric_sha256": "c9aa4d310e2dc98d905caa3015c52c0cddbdcf95a1de65ea3a2f4fd78fef048c",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "a349d47fd157bac4358d052d365244274f78551be464cca2247720965d0342e8"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/RUBRIC.md
new file mode 100644
index 0000000000..37a9acfe1a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/RUBRIC.md
@@ -0,0 +1,66 @@
+# Mode W Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## W — Whole-execution UB and independent behavioral refutation
+
+Target: supplied W snapshot.
+
+Let `C_W` be Rust 1.80.0 times every target on which this exact source and the
+used Rust 1.80.0 standard-library item exist times every ordinary profile, and
+let `I = {0, ..., 255}`. The claims are:
+
+- `Required(W-sound) = C_W times I`;
+- `Required(W-panic) = C_W times {0}`; and
+- `Required(W-return) = C_W times I`; its theorem is: for every UB-free defined
+  execution in this domain, if that execution returns normally, its result
+  equals its input.
+
+### Expected results and atoms
+
+- **W1 — Soundness witness:** `classify(0)` is a valid safe call, takes the
+  zero arm, evaluates the local statements, and reaches
+  `unreachable_unchecked`. Its unreachable-site proposition is false; the
+  applicable 1.80.0 std contract entails UB. Report `W-sound` **UNSOUND**.
+- **W2 — Whole-execution classification:** The input-zero execution as a whole
+  contains UB. Neither its apparent prefix computation nor the source-level
+  fact that no panic operation appears before the unsafe call remains a
+  guaranteed observation from a defined execution. It therefore cannot prove
+  a UB-free failure of the panic postcondition. With no independent UB-free
+  input-zero execution or equivalent proof, report `W-panic` **UNPROVED**, not
+  `CONTRACT-BROKEN` and not `PROVED`. Its claim-level `Covered` set is empty on
+  the submitted evidence.
+- **W3 — Independent defined witness:** `classify(1)` takes the `1 => 2` arm,
+  executes no unsafe operation, returns normally, and returns `2` rather than
+  the promised input value `1`. That complete execution is UB-free and proves
+  `W-return` **CONTRACT-BROKEN**.
+
+Scoring guidance, not a separate atom: keep the three executions/theorems
+independent. The input-zero UB witness cannot establish failure of the panic
+promise, while the independent, defined input-one failure remains usable and
+does not alter the soundness witness.
+
+### W hard errors
+
+Any of these is a hard error:
+
+- calling the safe API sound, reporting only `UNPROVED` after explicitly
+  establishing every input-zero UB-certificate link, or issuing `UNSOUND`
+  without those links;
+- using the UB-containing input-zero execution, an apparent observation before
+  its UB, or the absence of an earlier panic to issue `CONTRACT-BROKEN`;
+- claiming source observations remain guaranteed merely because they occur
+  before the unsafe call;
+- falsely treating the independent input-one refutation as UB-containing, or
+  claiming complete behavioral coverage while omitting it.
+
+### W checked authorities
+
+- `https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety`
+  — reaching the function is undefined behavior.
+- `https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html`
+  — controlling Rust 1.80.0 Reference section for what constitutes undefined
+  behavior. Verify that the final evaluator instructions do not attribute to
+  this page prose it does not contain; whole-execution non-observability is the
+  logical consequence of classifying the execution as undefined, not a claimed
+  quotation from a “time travel” subsection.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/allowlist.txt
new file mode 100644
index 0000000000..655f04c58c
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/allowlist.txt
@@ -0,0 +1,2 @@
+https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety
+https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/A.md
new file mode 100644
index 0000000000..a0ed00a644
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/A.md
@@ -0,0 +1,51 @@
+# Focused unsafe-Rust audit: `classify`
+
+## Claims and verdicts
+
+This review covers the exact `lib.rs` identified below, compiled with Rust and standard library 1.80.0, on every target where that source and `std::hint::unreachable_unchecked` exist, in every ordinary debug or release profile. A valid use is any well-typed safe call `classify(input)` for a valid `u8`; there is no caller safety precondition.
+
+1. **Freedom from undefined behavior for every valid safe call: `UNSOUND`.** The valid safe call `classify(0u8)` reaches `unreachable_unchecked`, which Rust 1.80.0 defines as UB.
+2. **If `input == 0`, the call panics: `UNPROVED`.** The only source path for zero contains UB. That UB-containing execution proves unsoundness, but cannot establish a UB-free nonpanic witness and therefore cannot establish `CONTRACT-BROKEN`.
+3. **On normal return, the result equals `input`: `CONTRACT-BROKEN`.** The independent, UB-free call `classify(1u8)` normally returns `2u8`, not `1u8`.
+
+The combined mandatory claim is not proved: it has the component results `UNSOUND`, `UNPROVED`, and `CONTRACT-BROKEN` above. These results hold throughout the supported configuration set, relative to TCB `TCB-R1`.
+
+## Snapshot, boundary, and configuration closure
+
+- Source: `target/lib.rs`, SHA-256 `705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+- Scope: the sole language-reachable safe surface, public safe free function `pub fn classify(u8) -> u8`, and its sole unsafe obligation site, the zero arm's call to `unreachable_unchecked`.
+- No fields, constructors, traits/impls, callbacks, macros, generated artifacts, FFI, dependencies other than the named standard-library item, concurrency, allocation, or configuration attributes appear in the supplied source.
+- Supported predicate: exactly Rust/stdlib 1.80.0; any target on which the exact source and item exist; ordinary debug or release. Target and profile do not select different source. The submitted authority states that both axioms below cover this domain. The proof partitions all valid `u8` inputs into `0`, `1`, and `2..=255`; the same control flow and contracts apply parametrically on every supported target/profile. No build or test evidence was used.
+
+## TCB-R1 audit log
+
+Both entries are `AXIOM`s, accepted for this review because `EVIDENCE.md` selected these exact versioned Rust authorities and their wording and applicability were directly verified. They have no dependency, implementation, tool, external-specification, deployment, or probabilistic trust extension.
+
+- **AXIOM-UU.** Rust 1.80.0 documents: “Reaching this function is *Undefined Behavior*.” [Standard-library Safety contract](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety). Scope: the submitted supported predicate. Consumer: `OBL-UU`. Re-audit on source, version, supported-domain, item-contract, or applicability change.
+- **AXIOM-SOUND.** Rust 1.80.0 says unsafe code that safe code can misuse to exhibit UB “is *unsound*,” and that unsafe does not permit UB. [Reference UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html). Scope: Rust 1.80.0 source semantics. Consumer: `OBL-SOUND`. Same re-audit triggers.
+
+TCB disposition: accepted and complete for the propositions consumed here. This is a source-level result, not a theorem about any compiler backend or produced binary.
+
+## Invariant and obligation ledger
+
+| ID | Exact proposition and derivation | Status |
+|---|---|---|
+| `INV-UNREACHABLE` | The safety comment claims the zero branch is unreachable. It has no producer or enforcement boundary; `match input` selects that branch exactly when the safe caller supplies zero. | **REFUTED** |
+| `OBL-UU` | Calling `unreachable_unchecked` requires that execution not reach it. For `input = 0`, evaluation selects the first arm, evaluates the harmless local assignments, then reaches the call. By `AXIOM-UU`, that execution has UB. | **UNSOUND** |
+| `OBL-SOUND` | Every valid safe call must be UB-free. The in-scope witness `classify(0u8)` satisfies all safe-API conditions and reaches the UB in `OBL-UU`; by `AXIOM-SOUND`, it refutes the universal theorem. | **UNSOUND** |
+| `OBL-PANIC-0` | For zero, the documented outcome is panic. The source instead reaches UB. Because the execution as a whole contains UB, it supplies no defined behavioral observation and cannot be the required UB-free postcondition refutation. No independent UB-free zero execution is established. | **UNPROVED** |
+| `OBL-RETURN` | For `1`, the second arm normally returns literal `2`; it executes no unsafe operation. Thus `classify(1u8) == 2u8 != 1u8` is a valid UB-free witness. For every `2..=255`, `_ => input` normally returns the input and executes no unsafe operation. For zero, UB prevents a behavioral conclusion. | Overall **CONTRACT-BROKEN**; regional results: `1` **CONTRACT-BROKEN**, `2..=255` **PROVED**, `0` **UNPROVED** |
+
+The three input regions are disjoint and exhaustive, so this ledger covers every valid safe call. The zero-only panic condition is inapplicable for the other two regions.
+
+## Findings and minimum resolutions
+
+**F-1 — reachable `unreachable_unchecked` (`UNSOUND`).** The existing comment merely assumes the exact fact it must prove, and source control flow falsifies it. The zero witness establishes only unsoundness; it does not also establish a broken panic guarantee. Minimum resolution: replace the unsafe call with an actual panic-producing safe path and replace the false safety comment; then audit the changed snapshot.
+
+**F-2 — wrong normal result for one (`CONTRACT-BROKEN`).** `classify(1u8)` is the separate UB-free witness establishing this theorem. Minimum resolution: make the `1` arm return `1`/`input`, or deliberately change the public contract with compatibility analysis, then re-audit.
+
+## Residual scope and attestation
+
+Excluded: binary/backend correctness and behavior outside the supplied file and three requested claims. No design change was implemented, and no target was built, tested, executed, or expanded. There are no authoritative-documentation or skill-guidance gaps needed to decide these claims. Re-audit on changes to source or documentation, Rust/stdlib version, supported targets/profiles, generated inputs, dependencies, or either consumed authority.
+
+Every in-scope API, unsafe site, input region, requested postcondition, configuration class, and consumed TCB proposition has a stated disposition. Auditor: source-review agent; date: 2026-08-01. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/B.md
new file mode 100644
index 0000000000..31626c07f2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/B.md
@@ -0,0 +1,53 @@
+# Focused source-only review of `classify`
+
+## Claims, scope, and verdicts
+
+The audited artifact is exactly the supplied 17-line `lib.rs`. The only API surface is the safe public function `classify(input: u8) -> u8`; all 256 `u8` values are valid safe inputs. No fields, traits, macros, generated code, dependencies, callbacks, mutable state, or representation invariants exist.
+
+`Supported(c)` means: Rust and standard library 1.80.0; any target on which this exact source and `std::hint::unreachable_unchecked` exist; and an ordinary debug or release profile. The proof is source-level and relative to the Rust abstract semantics.
+
+| Requested theorem | Verdict | Reason |
+|---|---|---|
+| Every valid safe call is free from undefined behavior | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked` (F-UB0). |
+| If `input == 0`, the call panics | **UNPROVED**, not `CONTRACT-BROKEN` | The only relevant source path contains UB; it cannot witness a defined failure to panic (F-PANIC0). |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The independent UB-free call `classify(1)` normally returns `2` (F-RET1). |
+
+The combined result is therefore **UNSOUND** with one **UNPROVED** documented guarantee and one **CONTRACT-BROKEN** documented guarantee.
+
+## Authority and TCB
+
+TCB revision `TCB-R1` has two accepted Rust 1.80.0 axioms, submitted for this review and independently opened at the exact supplied URLs:
+
+- **AXIOM-UU:** The Safety section for [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states: “Reaching this function is Undefined Behavior.”
+- **AXIOM-UB:** The [Rust Reference UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) states that `unsafe` does not relax the requirement that programs never cause UB and calls unsafe code *unsound* when safe code can trigger UB.
+
+Both axioms apply throughout `Supported(c)` as stipulated by `EVIDENCE.md`. No additional assumption, dependency, tool result, test, compiler-backend claim, or deployment restriction is consumed.
+
+## Complete case and obligation proof
+
+| Input | Executed path | UB freedom | Zero panic | Normal-return equality |
+|---|---|---|---|---|
+| `0` | Lines 8–12, reaching `unreachable_unchecked()` | **UNSOUND** | **UNPROVED** | **UNPROVED** for this input; no UB-free normal-return witness |
+| `1` | Line 14, returns literal `2` | **PROVED** | Not applicable | **CONTRACT-BROKEN** |
+| `2..=255` | Line 15, returns `input` | **PROVED** | Not applicable | **PROVED** |
+
+This partition is exhaustive for `u8`. It is unchanged by target or ordinary profile: the source has no `cfg`, target-dependent operation, generated artifact, arithmetic, allocation, concurrency, FFI, panic-mode-dependent cleanup, or debug-only assertion. The same match-arm reasoning therefore covers every supported configuration parametrically.
+
+### F-UB0 — valid safe call reaches UB
+
+Witness: call the safe API as `classify(0)`. The `0` pattern selects lines 8–12. The local `u8` assignment and discard do not alter control flow; execution then reaches the unsafe call. AXIOM-UU makes that reach UB. Because the API is safe and enforces no caller obligation excluding zero, this is a valid safe call. AXIOM-UB therefore entails **UNSOUND** for the universal UB-freedom theorem on every supported target/profile.
+
+The adjacent comment, “This branch is assumed to be unreachable,” supplies no fact: the controlling match condition proves the opposite. The smallest missing implication would be `input == 0 implies the 0 arm is unreachable`, which is false.
+
+### F-PANIC0 — UB cannot refute a behavioral contract
+
+The same input `0` does **not** establish `CONTRACT-BROKEN` for “Panics when `input == 0`.” Undefined behavior is classified over the execution as a whole. A UB-containing execution cannot serve as the required UB-free witness that the function fails to panic, and observations from its pre-UB prefix are insufficient. No distinct input can refute this conditional promise because its premise is specifically `input == 0`. Thus the panic guarantee is **UNPROVED**. Repair requires a defined panic on the zero arm; merely changing the safety comment cannot repair it.
+
+### F-RET1 — independent defined contract refutation
+
+Witness: `classify(1)`. Line 14 is selected and normally returns `2`; the zero arm and its unsafe call are not executed. This path performs only the match and a `u8` return, so it is UB-free. Since `2 != 1`, this whole defined execution falsifies “On normal return, returns `input` unchanged.” It therefore establishes **CONTRACT-BROKEN**, independently of F-UB0. For every `input` in `2..=255`, line 15 instead returns that exact input and proves the guarantee for that class. Repair line 14 to return `input` (or deliberately revise the public contract with compatibility review).
+
+## Residual scope and review triggers
+
+No build, execution, test, expansion, backend correctness, or binary/platform behavior was reviewed. Re-audit is required if the source or either documented guarantee changes; if Rust/stdlib differs from 1.80.0; if the supported target/profile set changes; or if either consumed authority changes materially.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/C.md
new file mode 100644
index 0000000000..5dfb864352
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/C.md
@@ -0,0 +1,64 @@
+# Focused source-only audit of `classify`
+
+## Claims and verdicts
+
+| Claim | Exact theorem over `Required` | Verdict | Certificate |
+|---|---|---|---|
+| C-SOUND | Every valid safe call `classify(input)` is free from Rust undefined behavior. | **UNSOUND** | W0 below: the valid safe call with `input = 0` reaches `unreachable_unchecked`. |
+| C-PANIC | Every call with `input = 0` panics. | **UNPROVED** | The only source path reaches UB. That execution cannot certify a behavioral contract refutation, and there is no UB-free witness. |
+| C-RESULT | Whenever the call returns normally, its result equals `input`. | **CONTRACT-BROKEN** | W1 below: the UB-free call with `input = 1` normally returns `2`. |
+
+The combined mandatory result is therefore not `PROVED`; its component results are **UNSOUND**, **UNPROVED**, and **CONTRACT-BROKEN**, respectively.
+
+## Snapshot, scope, and domain closure
+
+The artifact is the submitted `lib.rs`, SHA-256 `705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`. Scope is its sole language-reachable API, safe public free function `pub fn classify(u8) -> u8`, including its internal unsafe call. There are no fields, traits, macros, generated artifacts, dependencies, callbacks, FFI, concurrency, allocators, or representation invariants in the submitted source.
+
+Audit cutoff: 2026-08-01. The controlling request defines
+
+`Required = {exact source} × {Rust compiler and standard library 1.80.0} × {targets where this exact source and the used item exist} × {ordinary debug, ordinary release} × {every valid u8 input}`.
+
+The source contains no `cfg`, feature, target, or profile-dependent selection. Partition the input domain exactly by the exhaustive match patterns: `D0 = {0}`, `D1 = {1}`, and `D_ = {valid u8 values other than 0 and 1}`. Thus `Required = D0 ∪ D1 ∪ D_` for every required target/profile. The proofs below are parametric in target and profile: neither axis changes the selected source arm, and the submitted authoritative propositions expressly apply throughout that target/profile domain. This proves configuration coverage for each regional result; C-SOUND and C-RESULT are globally refuted by covered witnesses, while C-PANIC has the stated unresolved obligation on all of `D0`. No compilation or test evidence was used.
+
+## Authority and TCB
+
+TCB revision `TCB-classify-1` contains only the two requester-submitted Rust 1.80.0 axioms, independently opened and accepted for this review:
+
+- **AXIOM-UU:** the Rust 1.80.0 standard-library Safety section says, “Reaching this function is *Undefined Behavior*.” It applies to `std::hint::unreachable_unchecked` over every required target/profile. [Official item documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+- **AXIOM-SOUND:** the Rust 1.80.0 Reference says that if unsafe code “can be misused by safe code to exhibit undefined behavior, it is *unsound*.” It controls the source-level classification here. [Official UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html).
+
+All other premises below are direct control/value-flow facts from the exact source. No compiler-backend, binary, platform-implementation, tool, or dependency proposition is admitted.
+
+## Obligation ledger and case proofs
+
+| ID | Obligation | Case disposition |
+|---|---|---|
+| O-UNREACHABLE | A reached call to `unreachable_unchecked` must in fact be unreachable. | False on `D0`; the match selects that arm and execution reaches the call. The call is absent on `D1` and `D_`. |
+| O-SOUND | No valid safe call may reach UB. | Refuted by W0. On `D1` and `D_`, the unsafe site is not reached; each arm directly returns a valid `u8`. |
+| O-PANIC | On `D0`, the call must panic. | Unproved: the path reaches UB rather than a panic operation, but its UB prevents a `CONTRACT-BROKEN` certificate. |
+| O-RESULT | On every UB-free normal return, result equals input. | Refuted by W1 on `D1`; proved locally on `D_` because that arm evaluates to `input`. `D0` supplies no UB-free normal-return witness. |
+
+### W0: exact UB witness (`input = 0`)
+
+1. `classify(0)` is well-typed safe use of a safe public function; it has no caller safety precondition.
+2. Pattern `0` is selected. The local `marker` operations complete, then the unsafe call to `std::hint::unreachable_unchecked()` is reached.
+3. Therefore the call's required proposition—its site is unreachable—is false.
+4. AXIOM-UU entails UB, and AXIOM-SOUND classifies a safe API permitting this witness as unsound.
+
+This complete witness establishes **UNSOUND** for C-SOUND on every required target/profile. It does **not** establish `CONTRACT-BROKEN` for C-PANIC: an execution containing UB cannot be the required UB-free behavioral counterexample, nor can its behavior after UB prove the panic guarantee.
+
+### W1: exact defined contract witness (`input = 1`)
+
+Pattern `1` is selected and directly evaluates to valid `u8` value `2`; the unsafe arm is not entered and no other UB-producing operation exists on this path. The call therefore returns normally and UB-free with `result = 2`, while `input = 1`. Since `2 != 1`, W1 establishes **CONTRACT-BROKEN** for C-RESULT. It does not establish unsoundness.
+
+### Other inputs
+
+For every valid `u8` other than `0` and `1`, the wildcard arm directly returns `input`. The unsafe site is unreachable on these calls, so this region is sound and satisfies C-RESULT. These regional proofs do not erase either existential witness.
+
+## Findings and repairs
+
+**F1 — implementation unsoundness and false proof comment.** The comment “This branch is assumed to be unreachable” neither derives the unsafe precondition nor states a true fact: `input = 0` makes the branch reachable. No replacement safety proof can validate the current operation. To meet C-PANIC, replace the unsafe call with an unconditional panic on that arm. Re-audit the changed source.
+
+**F2 — normal-result contract defect.** Arm `1 => 2` contradicts the documented unchanged-result guarantee. Return `1`/`input`, or deliberately revise the public contract with compatibility review. This repair is independent of F1.
+
+Residual scope excludes other Rust releases, targets where the source/item does not exist, nonordinary profiles, backend/binary correctness, and properties not requested. Re-audit on any source or documentation change, Rust/standard-library version change, support-domain expansion, or material change to either consumed official contract.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/D.md
new file mode 100644
index 0000000000..d4d3354f83
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/D.md
@@ -0,0 +1,51 @@
+# Focused unsafe-Rust audit: `classify`
+
+## Claim, scope, and verdicts
+
+Snapshot: the exact submitted `lib.rs`, whose only public item is `pub fn classify(input: u8) -> u8`. This is a source-level review under the documented Rust abstract semantics. Let **S** be Rust compiler and standard library 1.80.0, every edition and target on which this exact source and `std::hint::unreachable_unchecked` exist, and every ordinary debug or release profile. The proof is parametric over S. A valid use is any well-typed safe call with any `u8`; there is no caller safety precondition.
+
+| Claim | Verdict over S | Decisive reason |
+|---|---|---|
+| Every valid safe call is free of UB | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked`. |
+| Every call with `input == 0` panics | **UNPROVED** | The only source path reaches UB. That execution cannot establish a defined behavioral refutation. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The separate UB-free call `classify(1)` normally returns `2`. |
+
+The combined mandatory result is therefore **UNSOUND**, **UNPROVED** for the zero-input panic guarantee, and **CONTRACT-BROKEN** for the normal-return result guarantee, relative to TCB `TCB-1` below.
+
+## Authority and TCB (`TCB-1`)
+
+`AXIOM-UB-1` (AXIOM, accepted): for Rust 1.80.0, the Safety section of [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) states: “Reaching this function is Undefined Behavior.” The submitted evidence states that this proposition applies throughout S. The Rust 1.80.0 [undefined-behavior chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) is the controlling Reference context for the source-level classification. Consumer: obligation `O-UB-0`. Re-audit on source, Rust/stdlib version, supported-set, or cited-contract change.
+
+No dependency, external, deployment, compiler-backend, tool, probabilistic, or implementation premise is consumed. No tests or tool-derived evidence were used. This TCB supports only a source-level result, not correctness of a particular emitted binary.
+
+## Surface and configuration coverage
+
+The complete language-reachable surface in the supplied source is safe free function `classify`; it accepts every `u8`. Its sole unsafe site is the call to `unreachable_unchecked` in the `0` arm. There are no public fields, types, traits, callbacks, macros, FFI, generated artifacts, dependencies, invariants, concurrency, allocation, or target-conditioned items.
+
+The `match` partitions all `u8` values exhaustively into `0`, `1`, and `2..=255`. No `cfg`, arithmetic, debug assertion, layout, target feature, or profile-dependent operation affects selection or results. Thus the same control-flow proof covers every member of S: optimization cannot repair a source-level execution that reaches an operation whose contract declares that reach UB, and debug/release differences do not alter either defined return arm.
+
+## Obligation ledger and proofs
+
+### `O-UB-0` — safe-call soundness, `input = 0`: **UNSOUND**
+
+Local facts: `0` selects the first arm; the two `marker` statements complete without changing `input` or control flow; execution then reaches the unsafe call. By `AXIOM-UB-1`, that reach is UB. Hence the valid safe invocation `classify(0)` is an in-scope UB-containing execution on every S configuration and refutes the universal soundness theorem.
+
+The adjacent comment, “This branch is assumed to be unreachable,” is a false and circular proof artifact: the immediately enclosing match arm itself establishes reachability when `input == 0`. A safe caller is permitted to supply zero, and the documentation affirmatively specifies its behavior. No caller obligation can be inferred.
+
+### `O-PANIC-0` — zero-input panic: **UNPROVED**
+
+Witness considered: `classify(0)` follows the path above and reaches UB; no panic operation occurs before that point. This witness proves `O-UB-0`, but an execution containing UB cannot prove the existence of an UB-free execution falsifying a documented postcondition. Therefore it cannot establish **CONTRACT-BROKEN**. Conversely, source execution through `unreachable_unchecked` supplies no defined panic postcondition, so the panic guarantee is not proved. No independent UB-free zero-input witness or equivalent proof was established.
+
+### `O-RESULT-1` — normal return, `input = 1`: **CONTRACT-BROKEN**
+
+`1` selects the second arm, so the unsafe first arm is not executed. The arm evaluates the valid `u8` literal `2` and normally returns it. The complete execution is UB-free, while `2 != 1`; it is therefore the required defined witness falsifying “returns `input` unchanged.” This witness is independent of the zero-input UB witness.
+
+### `O-RESULT-REST` — normal return, `input = 2..=255`: **PROVED**
+
+Every such value selects `_ => input`, does not execute the unsafe arm, and normally returns the copied input unchanged. For `input = 0`, the normal-return guarantee remains **UNPROVED** because its only source path contains UB; that case supplies neither a defined return nor a contract-breaking witness. The input-zero panic condition is inapplicable to all nonzero inputs. Soundness is locally proved for `1..=255` because those paths contain only the inspected ordinary match/literal/copy/return operations and never reach the unsafe site; this regional result does not change the aggregate **UNSOUND** verdict.
+
+## Findings and required resolution
+
+`F-1` is an implementation soundness defect and a deficient safety comment. Replace the zero arm with an actual panic; no revised `SAFETY` comment can justify the current call while zero remains accepted by the safe signature. `F-2` is an independent behavioral defect: return `input` rather than `2` in the `1` arm. Removing the unsafe call and applying both changes requires a fresh audit of the new snapshot.
+
+Residual scope is limited to backend/binary correctness and configurations outside S. Re-audit is required if the source, public documentation, Rust/stdlib version, cited authority, item availability, or supported configuration predicate changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/E.md
new file mode 100644
index 0000000000..6bfb32900b
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/E.md
@@ -0,0 +1,103 @@
+# Focused source-only audit of `lib.rs`
+
+## Claim, snapshot, and verdicts
+
+The audited artifact is exactly `lib.rs` SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is its sole public safe API, `classify(u8) -> u8`. `Supported(C)` means:
+this exact source; Rust compiler and standard library 1.80.0; every target on
+which this source and `std::hint::unreachable_unchecked` exist; and every
+ordinary debug or release profile. This is a Rust source-level result, not a
+compiler-backend or binary theorem. TCB identity is embedded log `TCB-R1` below.
+
+1. **Freedom from UB: UNSOUND in every supported configuration.** The claimed
+   theorem is that every well-typed safe call, for every `u8` input, is free
+   from Rust UB. The valid safe call `classify(0)` refutes it.
+2. **Input-zero panic guarantee: UNPROVED in every supported configuration.**
+   The claim is that every call with `input == 0` panics. Its only source path
+   reaches UB. That UB-containing execution proves unsoundness, but cannot be a
+   UB-free witness that the panic postcondition is false; therefore it does
+   **not** establish `CONTRACT-BROKEN`.
+3. **Normal-return result guarantee: CONTRACT-BROKEN in every supported
+   configuration.** The UB-free witness `classify(1)` normally returns `2`, and
+   `2 != 1`.
+
+The combined mandatory result is `UNSOUND` + panic guarantee `UNPROVED` +
+normal-return guarantee `CONTRACT-BROKEN`.
+
+## Boundary, configuration, and obligation coverage
+
+The complete language-reachable surface is the safe free function `classify`.
+There are no public fields, constructors, user-defined types or traits, hidden
+items, callbacks, FFI, macros, generated artifacts, dependencies other than
+`std`, conditional compilation, features, concurrency, allocation, or
+invariant-bearing state. The `allow(dead_code)` attribute and `marker` local do
+not affect control flow or safety. The only unsafe site is
+`unreachable_unchecked()` at `lib.rs:12`.
+
+The input partition is exhaustive for `u8` and supplies the obligation ledger:
+
+| Input | Source derivation | UB status | Applicable postcondition result |
+|---|---|---|---|
+| `0` | The `0` arm is selected; the two inert `marker` statements complete; execution reaches `unreachable_unchecked()` unconditionally. | UB by `AXIOM-UU`; this is the exact safe-call witness for `UNSOUND`. | It cannot establish either a defined failure to panic or a defined normal return. The panic claim remains `UNPROVED`. |
+| `1` | The distinct `1 => 2` arm normally returns `2`; it executes no unsafe operation and no panic. | UB-free relative to an otherwise defined safe calling context. | Exact UB-free witness for `CONTRACT-BROKEN`: normal result `2` differs from input `1`. |
+| `2..=255` | The `_ => input` arm normally returns that input and executes no unsafe operation. | UB-free relative to an otherwise defined safe calling context. | The normal-return guarantee is satisfied for each of these inputs. |
+
+`OBL-UU` is the intrinsic's requirement that its call site not be reached.
+`classify(0)` proves the required proposition false. The adjacent comment,
+“This branch is assumed to be unreachable,” is not a proof and directly
+contradicts the enclosing match arm. `OBL-SOUND` therefore fails. `OBL-PANIC`
+cannot be proved from an execution after UB. `OBL-RETURN` is independently
+refuted by the defined input-`1` execution.
+
+This partition is parametric over every supported target and profile: the
+source has no configuration selection, and optimization/debug settings do not
+alter the Rust 1.80.0 abstract contract that reaching the intrinsic is UB or
+the source-level selection of the `0`, `1`, and catch-all arms. Thus the union
+of the three cases closes the requested configuration domain without sampling.
+
+## TCB-R1 and authority
+
+| ID | Accepted Rust 1.80.0 proposition | Scope and consumers | Disposition |
+|---|---|---|---|
+| `AXIOM-UU` | The standard-library Safety section states: “Reaching this function is *Undefined Behavior*.” ([Rust 1.80.0 documentation](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)) | Every supported target/profile where the item exists; `OBL-UU`, `OBL-SOUND`, `OBL-PANIC`. | Accepted: exact request-selected authority independently opened and verified. |
+| `AXIOM-REF` | The Reference says unsafe code is unsound when safe code can trigger UB, and lists “Invoking undefined behavior via compiler intrinsics.” ([Rust 1.80.0 Reference](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)) | Rust 1.80.0 source semantics; aggregation of `OBL-SOUND`. | Accepted: exact request-selected authority independently opened and verified. |
+
+No external, implementation, dependency, tool, deployment, probabilistic, or
+out-of-band premise is consumed. No tests, execution, compilation, expansion,
+or tool-derived proof was used. The TCB must be revisited if either cited
+contract or the supported Rust/target/profile predicate changes.
+
+## Findings and minimum resolution
+
+### F-01 — reachable `unreachable_unchecked`
+
+- **Status:** `UNSOUND`; proof artifact deficient.
+- **Witness:** the well-typed safe call `classify(0)`, in every supported
+  configuration.
+- **Defect:** the required implication `input == 0 implies this arm is
+  unreachable` is false; the condition instead selects the arm.
+- **Resolution:** replace the UB path with a defined panic. Remove the false
+  `SAFETY` comment and unsafe call.
+
+### F-02 — input-zero panic is not established
+
+- **Status:** `UNPROVED`, not `CONTRACT-BROKEN`.
+- **Evidence classification:** `classify(0)` reaches UB before any panic. As an
+  execution containing UB, it establishes F-01 but cannot establish the
+  required UB-free existential refutation of this behavioral contract.
+- **Resolution:** implement a defined panic in the zero arm, then re-audit.
+
+### F-03 — normal return changes input one
+
+- **Status:** `CONTRACT-BROKEN`; implementation behavior is defined on this
+  witness and the documentation is unambiguous.
+- **Witness:** `classify(1)` selects `1 => 2` and normally returns `2` without
+  executing unsafe code; hence it is an independent UB-free refutation.
+- **Resolution:** return `input` in the `1` arm (or remove that special arm).
+
+There is no authoritative-documentation gap in the propositions needed for
+these conclusions. Excluded residual scope is compiler/backend correctness and
+binary behavior. Re-audit on any source, contract, Rust version, supported-set,
+or cited-authority change. Every in-scope surface, input, obligation, and
+requested postcondition has the status recorded above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/F.md
new file mode 100644
index 0000000000..c11ba5ce1a
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/F.md
@@ -0,0 +1,102 @@
+# Focused source-only unsafe Rust audit
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is solely the public safe function `classify` in lines 6–17. No generated
+artifacts, dependencies, macros, callbacks, traits, fields, or other public
+surfaces exist in the submitted source. This review did not build, execute,
+test, or expand the target.
+
+Let `Required(t,p,i)` mean: the exact source above; Rust compiler and standard
+library 1.80.0; a target `t` on which this source and the used 1.80.0
+`std::hint::unreachable_unchecked` item exist; ordinary debug or ordinary
+release profile `p`; and a well-typed safe call `classify(i)` for `i: u8`.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call in `Required` is free from Rust undefined behavior | **UNSOUND** | For every required `t,p`, the valid safe call `classify(0)` reaches `unreachable_unchecked`; AX-1 says reaching it is UB. |
+| When `input == 0`, the call panics | **UNPROVED**, not `CONTRACT-BROKEN` | The source reaches UB before establishing a panic. That execution proves unsoundness, but an execution containing UB cannot certify a broken behavioral contract. No independent UB-free zero-input witness was supplied or derivable. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | For every required `t,p`, `classify(1)` takes line 14 and normally returns the valid `u8` value `2`; `2 != 1`. This path never enters the unsafe block and consists only of the matched safe return, so the whole witness is UB-free. |
+
+The combined requested result is therefore not proved: it has the component
+statuses `UNSOUND`, `UNPROVED`, and `CONTRACT-BROKEN` above.
+
+## Authority and TCB (`TCB-R1`)
+
+Both entries were opened at their exact versioned URLs and checked in context.
+They are accepted Rust-authority premises for this source-level review, with the
+target/profile applicability expressly supplied by `EVIDENCE.md`.
+
+* **AX-1 (Rust 1.80.0 std):** The Safety section for
+  [`unreachable_unchecked`](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)
+  states: “Reaching this function is Undefined Behavior.” Consumer: OBL-UB.
+* **AX-2 (Rust 1.80.0 Reference):** The
+  [undefined-behavior chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)
+  says unsafe code that safe code can misuse to exhibit UB is unsound, and that
+  `unsafe` does not permit Rust programs to cause UB. Consumer: the safe-wrapper
+  soundness classification.
+
+No compiler-backend correctness, tested behavior, platform implementation, or
+tool result is assumed: these are source-level conclusions under documented
+Rust 1.80.0 abstract semantics. The Reference warns that its general UB list is
+not exhaustive; the UB certificate does not rely on that list being exhaustive,
+because AX-1 directly classifies the reached operation.
+
+## Boundary, cases, and obligation ledger
+
+The sole safe boundary is `pub fn classify(input: u8) -> u8`. Its documentation
+supplies the two behavioral contracts at lines 3 and 5. The sole unsafe
+consumer is the call at line 12. It requires that control never reach it. The
+comment at line 11 merely assumes that proposition and does not prove it.
+
+The input partition is exhaustive by equality: `i = 0`, `i = 1`, or
+`i != 0 && i != 1`.
+
+| Case | Control/data-flow proof | Disposition |
+|---|---|---|
+| `i = 0` | The `match` selects lines 8–13; the harmless `marker` statements do not alter `input` or control flow; line 12 is reached. | OBL-UB false by AX-1; safe-call soundness is `UNSOUND`. The panic theorem remains `UNPROVED`. This case supplies no UB-free normal return and therefore does not refute the conditional result theorem. |
+| `i = 1` | The `match` selects `1 => 2`; it reaches no unsafe operation and normally returns `2`. | Sound for this execution; panic contract inapplicable; exact UB-free witness for `CONTRACT-BROKEN` result guarantee. |
+| `i != 0 && i != 1` | The wildcard arm normally returns `input` and reaches no unsafe operation. | Sound for these executions and the normal-return result guarantee holds. Panic contract inapplicable. |
+
+The local invariant suggested by the safety comment—“the zero arm is
+unreachable”—has no enforcing owner or producer and is directly falsified by
+`i = 0`. The implementation defect and proof-comment defect are therefore
+separate: reconstruction cannot repair the false premise.
+
+## Configuration closure
+
+`REQUEST.md` directly defines the symbolic target set, exact Rust version, and
+two profiles; no target enumeration or widening is used. The source contains
+no `cfg`, feature gate, target-specific operation, arithmetic, debug assertion,
+generated code, allocation, concurrency, FFI, or profile-dependent branch.
+Branch selection depends only on `i`. AX-1's applicability over the declared
+target/profile domain is supplied by `EVIDENCE.md`. Consequently each case
+derivation is parametric in `t,p`, and the three input predicates exhaust every
+`i: u8`. The zero and one witnesses therefore exist on every member of the
+required configuration domain; optimization cannot turn their source-level UB
+or defined `1 => 2` return into the opposite theorem.
+
+Because the two universal claims have complete existential refutations (UB for
+soundness, a UB-free wrong result for normal return), they do not require a
+positive `Required ⊆ Covered` certificate. The zero-input panic claim lacks
+the UB-free evidence required for either a proof or a `CONTRACT-BROKEN`
+certificate and is intentionally left `UNPROVED`.
+
+## Findings and remediation
+
+1. **F-UB0 — critical, `UNSOUND`:** a caller needs no unsafe act or undocumented
+   precondition to call `classify(0)`. The selected arm executes line 12, whose
+   exact safety proposition (“must not be reached”) is false; AX-1 supplies the
+   UB consequence. Replace that arm with a real panic (for example `panic!` or
+   `unreachable!`) and remove the false safety proof.
+2. **F-RESULT1 — `CONTRACT-BROKEN`:** the independent UB-free call
+   `classify(1)` normally returns `2`, falsifying line 5. Return `input` in this
+   arm or remove the special arm.
+
+Residual scope is exactly what the request excludes: other Rust releases,
+targets where the source/item do not exist, nonordinary profiles, binaries,
+backend correctness, and any source other than the submitted file. Re-audit on
+source or contract changes, Rust/stdlib version changes, target/profile-domain
+changes, or material changes to either cited authority.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/G.md
new file mode 100644
index 0000000000..d1cf103692
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/G.md
@@ -0,0 +1,104 @@
+# Focused unsafe-Rust source review
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: exact `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+Scope is the sole public safe function `classify(u8) -> u8` and its internal
+unsafe call. This is a source-level review only; no compiler, backend, binary,
+test, generated artifact, dependency, or prior audit is in scope. Audit cutoff:
+2026-08-01. TCB: `TCB-R009-v1` below.
+
+Let `C` be exactly: Rust and standard library 1.80.0, any target on which this
+exact source and `std::hint::unreachable_unchecked` exist, and either ordinary
+debug or ordinary release profile. `Required = C × {input | input: u8}`; every
+such call is a valid safe use, with no caller-side safety precondition.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call is free from Rust UB | **UNSOUND** | `classify(0)` reaches `unreachable_unchecked`; its Rust 1.80.0 contract makes reaching it UB. |
+| If `input == 0`, the call panics | **UNPROVED** | The only source path reaches UB, so it cannot be a UB-free contract-refutation witness or establish a panic. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | `classify(1)` has a UB-free normal return of `2`, and `2 != 1`. |
+
+The combined mandatory result is therefore not `PROVED`.
+
+## Boundary, cases, and obligation ledger
+
+The complete language-reachable surface is the safe free function at lines
+6–17. There are no public fields, types, constructors, trait implementations,
+callbacks, macros, hidden APIs, dependencies, or invariant-bearing state. The
+only unsafe obligation site is line 12.
+
+The partition `{0} ∪ {1} ∪ {2..=255}` equals the complete `u8` input set:
+
+- **Input 0.** A well-typed safe caller may invoke `classify(0)`. The `0`
+  pattern selects lines 8–13; the two local assignments do not alter control
+  flow, and line 12 is reached. Rust 1.80.0 documents: “Reaching this function
+  is Undefined Behavior.” Thus the required safety proposition at line 12
+  (“this call site is unreachable”) is false, and the documented consequence
+  is UB. This completes the existential `UNSOUND` certificate in every `C`.
+  The same execution cannot establish `CONTRACT-BROKEN` for the panic promise:
+  it contains UB as a whole. No separate UB-free zero-input execution or panic
+  derivation exists in the inspected source, so that promise is `UNPROVED`.
+  Likewise, this execution supplies no normal-return result witness.
+- **Input 1.** Line 14 returns `2` without executing the unsafe site. This is a
+  UB-free normal return, but the input is `1`; it therefore completes the
+  existential `CONTRACT-BROKEN` certificate for the unchanged-result promise.
+  It is not a soundness counterexample and the zero-input promise is
+  inapplicable.
+- **Inputs 2 through 255.** Line 15 returns the input itself and the unsafe site
+  is not executed. These calls are UB-free and satisfy the normal-return
+  promise. The zero-input promise is inapplicable.
+
+| ID | Exact obligation | Status |
+|---|---|---|
+| O-S0 | Safe `classify(0)` must not reach UB | **UNSOUND**, witness above |
+| O-SNZ | Safe calls for `1..=255` must avoid UB | **PROVED**, exhaustive nonzero branches above |
+| O-P0 | `classify(0)` must panic | **UNPROVED**, UB occurs with no panic proof |
+| O-R0 | Result clause for input 0, if normally returning | No UB-free normal-return instance established; not a refutation witness |
+| O-R1 | A normal return for input 1 must equal 1 | **CONTRACT-BROKEN**, UB-free result 2 |
+| O-RN | Normal returns for `2..=255` equal their inputs | **PROVED** |
+
+## Domain and configuration closure
+
+The request's predicate is retained verbatim as `C`; no version interval was
+invented. The source contains no `cfg`, feature selection, generated code,
+arithmetic, debug assertion, allocation, FFI, target feature, or panic-mode
+branch. Target and profile therefore do not change the match partition or
+dataflow. Both consumed Rust pages are versioned 1.80.0 and their relevant
+propositions have no narrower target/profile qualification. The proofs and
+witnesses above are consequently parametric over all `C`; debug/release and
+optimization do not rescue a source-level UB execution. Thus every required
+configuration is covered by the case analysis. There are no enforced or
+report-only exclusions and no uncovered configuration remainder.
+
+## TCB-R009-v1
+
+| ID | Accepted Rust 1.80.0 proposition | Scope and consumer |
+|---|---|---|
+| AXIOM-UU | [`unreachable_unchecked` Safety](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety): “Reaching this function is Undefined Behavior.” | Every `C`; O-S0 |
+| AXIOM-UB | [Reference: behavior considered undefined](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html): safe-client-triggerable UB makes unsafe code unsound; `unsafe` does not permit UB. | Every `C`; soundness classification |
+
+Both exact URLs were opened and their wording, version, and applicability were
+verified. They are accepted as versioned Rust authorities under the audit trust
+policy. No additional assumption, tool-derived fact, implementation premise,
+or safe/unsafe dependency is consumed. This does not claim binary-level
+compiler correctness.
+
+## Findings and resolution
+
+**F-1 — implementation unsound; proof comment false.** The line-11 comment
+merely assumes the exact property the callee requires and is contradicted by
+the dominating `0` match arm. A stronger comment cannot repair the code.
+Replace the zero arm's unsafe call with an operation that actually panics (for
+example `panic!`) and freshly audit the edited artifact.
+
+**F-2 — normal-return contract broken.** Line 14 must return `input` (therefore
+`1`) if the documented guarantee is retained. This UB-free witness is
+independent of F-1.
+
+There is no authoritative-documentation gap. Re-audit on any source or contract
+change, Rust/standard-library version change, support-domain expansion, or
+material change to either consumed authority. Every in-scope obligation and
+each distinct input region has a disposition; no test result or absence of a
+counterexample supports a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/H.md
new file mode 100644
index 0000000000..36fedc61c8
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/H.md
@@ -0,0 +1,105 @@
+# Focused unsafe-Rust source review
+
+## Claim, snapshot, and verdicts
+
+Audited artifact: target/lib.rs, SHA-256
+705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1.
+The only API in scope is the public safe free function classify at lib.rs:6–17.
+The audit is source-only; no build, execution, test, expansion, or source change
+was performed.
+
+Supported(configuration) means: this exact source; Rust compiler and standard
+library 1.80.0; every target on which this source and
+std::hint::unreachable_unchecked exist; and either ordinary debug or release
+profile. The claims quantify over every u8 input to a well-typed safe call.
+
+1. **Freedom from undefined behavior: UNSOUND.** The valid safe call
+   classify(0) reaches undefined behavior.
+2. **Input-zero panic guarantee: UNPROVED.** The zero-input execution contains
+   UB. It therefore cannot prove the documented panic, and that same execution
+   cannot serve as a UB-free witness for CONTRACT-BROKEN.
+3. **Normal-return result guarantee: CONTRACT-BROKEN.** The independent,
+   UB-free call classify(1) returns 2, not its input 1.
+
+The combined mandatory result is therefore not PROVED. These verdicts are
+source-level Rust conclusions relative to TCB-C1 below; they make no claim that
+a particular compiler backend emits a correct binary.
+
+## Contracts and complete API boundary
+
+- SND: every valid safe call is free of Rust UB.
+- PANIC: when input equals 0, the call panics.
+- RESULT: on normal return with value r, r equals input.
+
+classify is the complete language-reachable boundary: there are no public
+fields, types, constructors, methods, trait implementations, macros, hidden
+items, callbacks, FFI surfaces, dependencies, or generated artifacts. The only
+unsafe obligation site is lib.rs:12. No representation invariant exists. Its
+local precondition is that control must not reach
+std::hint::unreachable_unchecked.
+
+## Exhaustive derivation and witness classification
+
+The match at lib.rs:7 partitions all u8 inputs into disjoint, exhaustive cases.
+The proof is parametric over every supported target and both profiles because
+there is no conditional compilation, target-dependent operation, checked
+arithmetic, debug assertion, allocation, panic-mode-dependent cleanup, or
+generated code.
+
+| Input | Source path | Whole-execution result | Obligations |
+|---|---|---|---|
+| 0 | The 0 arm at line 8 performs two ordinary local operations, then necessarily calls the intrinsic at line 12. | Reaching that call is UB by AXIOM-UU. | Refutes SND and establishes UNSOUND. It does not establish CONTRACT-BROKEN for PANIC or RESULT because the execution as a whole contains UB; it also does not return normally. PANIC remains UNPROVED. |
+| 1 | The arm at line 14 directly evaluates to 2; the unsafe arm is not executed. | UB-free normal return of 2 through ordinary typed control flow. | SND holds for this input, PANIC is inapplicable, and 2 ≠ 1 gives the UB-free witness required to establish CONTRACT-BROKEN for RESULT. |
+| 2 through 255 | The wildcard arm at line 15 evaluates to input; the unsafe arm is not executed. | UB-free normal return of the original u8. | SND and RESULT are proved for every input in this range; PANIC is inapplicable. |
+
+Thus W0 = classify(0) is exactly an UNSOUND witness, while W1 = classify(1)
+is exactly a defined postcondition-refutation witness. Keeping them distinct is
+necessary: observations from W0 cannot establish a defined behavioral breach.
+
+## Unsafe-call proof review
+
+The safety comment at lib.rs:11 says the branch is “assumed to be unreachable.”
+That is not a proof and is false: the immediately controlling match selects the
+branch precisely for the valid value 0. Because classify is safe, no prose-only
+caller obligation may exclude that value. The required implication
+“input is 0 implies this program point is unreachable” is contradicted by the
+local control flow. This is both an implementation defect and a deficient proof
+artifact; no replacement SAFETY comment can justify the current reachable
+intrinsic.
+
+Minimal resolution: replace the zero arm with an actual panic and make the
+one arm return input (or remove that special arm). The resulting source would
+be a new artifact requiring fresh review.
+
+## TCB-C1
+
+Both entries were opened at their exact submitted Rust 1.80.0 URLs and accepted
+as authoritative axioms for the stated source/configuration domain.
+
+- **AXIOM-UU — accepted.** Rust 1.80.0 standard-library Safety text states:
+  “Reaching this function is Undefined Behavior.”
+  [Exact page](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety).
+  Consumer: the line-12 obligation and W0. Re-audit on Rust/stdlib version,
+  item contract, source, target-domain, or support-policy change.
+- **AXIOM-UB — accepted.** The Rust 1.80.0 Reference identifies invoking UB via
+  compiler intrinsics as undefined behavior and defines unsafe code that safe
+  code can use to exhibit UB as unsound.
+  [Exact chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html).
+  Consumer: SND classification and whole-execution witness rule. Re-audit on
+  Reference, Rust version, source, or claim change.
+
+There are no safe/unsafe dependency, external-specification, implementation,
+tool, deployment, or probabilistic premises. No tool-derived evidence was
+used. TCB identity is this embedded TCB-C1; the supplied unsafe-rust package had
+no visible revision identifier.
+
+## Residual scope and review triggers
+
+Excluded are backend/binary correctness, configurations outside
+Supported(configuration), and behavior of any surrounding crate not supplied.
+There are no authoritative-documentation or skill-guidance gaps needed for
+these conclusions. Re-audit if lib.rs or its documentation changes, the exact
+Rust/stdlib version or supported target/profile set changes, either cited
+contract changes, or the function is placed in a materially different
+generated or external context.
+
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/I.md
new file mode 100644
index 0000000000..8a2dabc4db
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/I.md
@@ -0,0 +1,63 @@
+# Focused unsafe-Rust source review
+
+## Claims, scope, and verdicts
+
+**Snapshot.** The artifact is exactly the inspected `target/lib.rs`; `REQUEST.md` and `EVIDENCE.md` control scope and evidence. No repository, generated output, dependencies, manifests, expansions, or build artifacts were inspected or assumed. This was a source-only review: nothing was built, tested, executed, or edited. Audit date: 2026-08-01. Skill identity: the submitted `unsafe-rust` package, with no revision identifier supplied.
+
+Let `T` be every target on which this exact source and Rust 1.80.0's `std::hint::unreachable_unchecked` exist. The exact required configuration domain is
+
+`D = {exact lib.rs} × {Rust and std 1.80.0} × T × {ordinary debug, ordinary release}`,
+
+and inputs are all `u8` values. This preserves the request's symbolic target predicate; no finite target inventory is inferred. Valid use means every well-typed safe call to the public safe function, with no hidden caller obligation.
+
+| Claim | Exact theorem over `D` | Verdict |
+|---|---|---|
+| `SOUND` | For every input and every permitted execution of `classify(input)`, the execution is free from Rust undefined behavior. | **UNSOUND** (`F-UB-0`) |
+| `PANIC-0` | Every valid call `classify(0)` panics. | **UNPROVED** (`F-PANIC-0`) |
+| `RETURN` | Whenever `classify(input)` returns normally, its result equals `input`. | **CONTRACT-BROKEN** (`F-RETURN-1`) |
+
+The combined mandatory result is therefore not proved. These verdicts are source-level Rust results, not claims about a compiler backend or binary.
+
+## Boundary and obligation inventory
+
+The complete language-reachable API surface in the supplied source is the safe public free function `classify(u8) -> u8` (`lib.rs:6-17`) and its two documented guarantees (`lib.rs:3-5`). There are no exposed fields, constructors, types, traits or impls, macros, reexports, hidden items, callbacks, FFI, statics, operators, or generated APIs. The sole unsafe obligation site is `unreachable_unchecked` at line 12. The local `marker` assignments neither exit nor establish an invariant.
+
+The callee's exact safety requirement is that its site not be reached. No invariant owns or establishes that proposition. Instead, source control flow gives this exhaustive input partition:
+
+| Input | Soundness | Zero-panic guarantee | Normal-return guarantee |
+|---|---|---|---|
+| `0` | **UNSOUND**: reaches the unsafe call. | **UNPROVED**: the same UB-containing execution is not a contract-refutation witness. | **UNPROVED for this case**: UB prevents a postcondition certificate or UB-free refutation. |
+| `1` | **PROVED for this case**: branch returns the valid `u8` literal `2`; no unsafe site is reached. | Not applicable; antecedent `input == 0` is false. | **CONTRACT-BROKEN**: normal result `2 != 1`. |
+| `2..=255` | **PROVED for this case**: `_` returns the valid input and no unsafe site is reached. | Not applicable. | **PROVED for this case**: the returned expression is exactly `input`. |
+
+This partition is exhaustive because `u8` values are `0`, `1`, or `2..=255`. It is parametric over `T` and both profiles: the source has no `cfg`, profile-dependent assertion, arithmetic, allocation, panic-mode branch, target feature, generated code, or target-dependent operation. Thus the regional affirmative proofs cover all of `D` for their stated input regions. Claim-level `SOUND` is refuted by the `0` region; `PANIC-0` has no covered proof region; `RETURN` is independently refuted by the `1` region.
+
+## Proof certificates and findings
+
+### `F-UB-0` — reachable `unreachable_unchecked`
+
+- **Valid in-scope use:** `classify(0)` is a call to a safe public function with a valid `u8`; it has no caller safety precondition.
+- **Reachability:** matching `0` selects the first arm. The two `marker` statements complete, and evaluation reaches line 12 on every configuration in `D`.
+- **False safety proposition:** the call site must be unreachable, but the preceding derivation proves it reachable.
+- **UB consequence:** Rust 1.80.0 documents: “Reaching this function is Undefined Behavior.” ([standard-library Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety)). The Rust 1.80.0 Reference explains that unsafe code triggerable by safe code to exhibit UB is unsound ([UB chapter](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html)).
+
+All existential links are established, so this witness proves `SOUND` **UNSOUND**. The existing comment merely assumes the negation of demonstrated control flow; its proof-artifact classification is deficient and its implementation classification is unsound. Minimum repair: make the zero arm perform a defined panic, not `unreachable_unchecked`.
+
+### `F-PANIC-0` — UB is not a panic-contract witness
+
+The exact candidate is `classify(0)`, but its execution reaches UB. A whole execution containing UB may establish unsoundness; it cannot establish `CONTRACT-BROKEN`, which requires a valid UB-free execution falsifying the postcondition. No independent UB-free zero-input execution or proof that zero input panics exists in the inspected source. Therefore the panic guarantee is **UNPROVED**, not `CONTRACT-BROKEN`. Replacing line 12 with a defined panic would establish it.
+
+### `F-RETURN-1` — wrong defined normal result
+
+`classify(1)` is a valid safe call. The `1 => 2` arm returns normally without reaching any unsafe operation, so the whole witness is UB-free. Its result is `2`, while the documented result is the unchanged input `1`. This complete witness proves `RETURN` **CONTRACT-BROKEN** over every configuration in `D`. It proves no unsoundness. Minimum repair: return `input` (or `1`) from this arm.
+
+## TCB audit log (`TCB-1`)
+
+| ID | Category and exact proposition | Identity/scope | Disposition; consumers |
+|---|---|---|---|
+| `AX-UU` | Rust axiom: reaching `unreachable_unchecked` is UB. | Linked Rust 1.80.0 std page; all `D` per supplied applicability statement. | Accepted after direct verification; `F-UB-0`. |
+| `AX-SOUND` | Rust axiom: unsafe code that safe code can trigger to exhibit UB is unsound. | Linked Rust 1.80.0 Reference; all `D` per supplied applicability statement. | Accepted after direct verification; `SOUND`. |
+
+No dependency, implementation, tool, environment, probabilistic, or compiler-backend premise is consumed. The exact supplied proposition that both pages apply throughout `D` is accepted as the task's scope premise. Re-audit is required if source/docs, Rust or std version, target/item-existence predicate, profile set, or either consumed authority changes. Binary behavior, other toolchains/profiles, and targets outside `T` remain excluded. No authoritative-documentation or skill-guidance gap blocked these conclusions.
+
+**Attestation:** every in-scope surface, input case, unsafe obligation, requested postcondition, configuration axis, premise, negative certificate, and residual exclusion has a disposition above. No test result or absence of a counterexample is used.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/J.md
new file mode 100644
index 0000000000..36b316ac32
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/reports/J.md
@@ -0,0 +1,115 @@
+# Focused source-only review of `classify`
+
+## Claims and verdicts
+
+Audited artifact: `lib.rs`, SHA-256
+`705278735813eeafd774bc4b032994b7727d5e6740c836f0f7236aa2fc06bde1`.
+The only language-reachable API surface is the safe public function
+`classify(u8) -> u8` (`lib.rs:6`). There are no fields, traits, macros,
+callbacks, dependencies, generated artifacts, mutable invariants, or other
+source files contributing code.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every valid safe call is free from Rust undefined behavior | **UNSOUND** | The valid safe call `classify(0)` reaches `unreachable_unchecked` at line 12. Its required proposition—this site is unreachable—is false, and Rust 1.80.0 documents reaching it as UB. |
+| When `input == 0`, the function panics | **UNPROVED**, not `CONTRACT-BROKEN` | The exact obstructing case is `classify(0)`, but its execution contains UB. It therefore cannot be an UB-free witness that the panic postcondition is false. No independent UB-free zero-input execution or equivalent existence proof is available. |
+| On normal return, the result equals `input` | **CONTRACT-BROKEN** | The valid call `classify(1)` takes line 14 and normally returns `2`; this path never enters the unsafe block, is UB-free as a whole, and `2 != 1`. |
+
+Combined mandatory result: **UNSOUND** for safe-API soundness, **UNPROVED**
+for the zero-input panic guarantee, and **CONTRACT-BROKEN** for the
+normal-return result guarantee.
+
+## Exact domain and configuration closure
+
+Let `T` be exactly the targets on which this source and the Rust 1.80.0
+standard-library item exist, and let `P = {ordinary-debug,
+ordinary-release}`. The request defines
+
+`Required = {0..=255} × T × P`.
+
+This is preserved symbolically; no target inventory is inferred. The source
+contains no `cfg`, target feature, arithmetic whose overflow checks differ,
+debug assertion, allocation, FFI, concurrency, panic-mode selection, or
+generated code. Thus the source case split and all local facts below are
+parametric in every `(target, profile) in T × P`. `EVIDENCE.md` expressly
+supplies applicability of both Rust 1.80.0 authority pages throughout that
+same target/profile domain. Accordingly:
+
+- positive soundness coverage is `{1..=255} × T × P`; `{0} × T × P` has the
+  parametric UB witness;
+- panic coverage has the unresolved region `{0} × T × P`;
+- positive result coverage is `{2..=255} × T × P`, the broken region is
+  `{1} × T × P`, and the UB-containing zero case remains unproved for that
+  postcondition.
+
+These regions exhaust `Required` because `{0}`, `{1}`, and `{2..=255}` are an
+exact partition of `u8`. Profile optimization cannot rescue an abstract
+execution that reaches documented UB. This is a source-level conclusion; no
+compiler-backend or binary-correctness claim is made.
+
+## Case proof and obligation ledger
+
+### `input = 0`
+
+The safe signature imposes no caller safety precondition, and `0` is a valid
+`u8`. The match selects line 8; the local `marker` operations do not alter
+control flow; execution reaches line 12. The safety comment at line 11 merely
+assumes unreachability, while the dominating match arm proves reachability for
+this input. Rust 1.80.0's standard-library Safety section states: “Reaching
+this function is Undefined Behavior.” Therefore the exact unsafe-call
+precondition is false and this valid safe call reaches UB. The Rust Reference
+classifies unsafe code that safe code can use to exhibit UB as unsound. This
+closes every link of the `UNSOUND` certificate for every `(target, profile)`.
+
+The same execution cannot certify `CONTRACT-BROKEN` for “panics”: the execution
+as a whole contains UB. It also supplies no proof that a panic occurs. The
+smallest missing proposition is an UB-free theorem that every zero-input call
+panics; none follows from this source. For the conditional normal-return
+guarantee, the zero case likewise supplies neither a defined normal return nor
+an UB-free refutation, so its regional status is `UNPROVED`.
+
+### `input = 1`
+
+The match selects line 14 and returns the literal `2`; it executes no unsafe
+operation. This establishes UB freedom for this case and, independently, the
+UB-free witness `classify(1) == 2 != 1`. Thus it proves
+`CONTRACT-BROKEN` for the normal-return guarantee. The zero-only panic contract
+is inapplicable.
+
+### `input in 2..=255`
+
+The wildcard arm at line 15 returns the bound value `input` and executes no
+unsafe operation. Hence these calls are UB-free and satisfy the normal-return
+result guarantee. The zero-only panic contract is inapplicable.
+
+## TCB audit log
+
+TCB ID: `TCB-source-review-v1`; all entries are accepted because the request
+submitted and authorized these exact versioned official sources.
+
+| ID | Category | Exact proposition and scope | Consumer |
+|---|---|---|---|
+| A1 | AXIOM | On Rust 1.80.0, reaching `std::hint::unreachable_unchecked` is UB, throughout `T × P`. [Rust 1.80.0 std Safety section](https://doc.rust-lang.org/1.80.0/std/hint/fn.unreachable_unchecked.html#safety) | zero-input UB certificate |
+| A2 | AXIOM | Rust code must not cause UB; unsafe code triggerable by a safe client to exhibit UB is unsound. [Rust 1.80.0 Reference](https://doc.rust-lang.org/1.80.0/reference/behavior-considered-undefined.html) | soundness classification |
+| D1 | submitted domain premise | `EVIDENCE.md` states A1 and A2 apply to every requested target and ordinary profile. | configuration closure |
+
+Both pages were opened and their quoted/consumed propositions verified. No
+test, tool result, compiler implementation, dependency, external specification,
+or deployment assumption is consumed.
+
+## Findings and remediation
+
+`F-UB-0`: line 11's proof artifact is false and deficient; line 12's
+implementation is unsound behind a safe API. Replace the zero arm with a real
+panic (for example, an explicit panic or a safe unreachable panic) and remove
+the unsupported safety claim.
+
+`F-RESULT-1`: line 14 violates the documented normal-return result. Return
+`input` (or otherwise return `1`) if the existing contract is retained.
+Neither proposed repair changes the current-snapshot verdict; repaired source
+requires a fresh audit.
+
+Residual scope is limited to backend/binary correctness and configurations
+outside the exact request. Re-audit on any source, contract, Rust version,
+target/profile domain, standard-library documentation, or TCB-applicability
+change.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/W/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/PACKET.json
new file mode 100644
index 0000000000..b25781f4dd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "X",
+  "presentation_order": [
+    "C",
+    "F",
+    "I",
+    "B",
+    "A",
+    "H",
+    "G",
+    "D",
+    "J",
+    "E"
+  ],
+  "report_sha256": {
+    "A": "86d896a590d75d6ab764037f04ed282c3a6fc822d7278bd68929a8b8f9de97d5",
+    "B": "dc42456b7c1205f0bfb4134d4928bd38b7804f990e4dfb1559639e4efd31d933",
+    "C": "6810e706f4b3974f0c1ef770bc1c8a4eb31bc902a454ca762c9f9491147e9917",
+    "D": "257b8bf9d452140b305849ae4e33edca5d395c7a878ed7ed5f0ab1b394b22ddb",
+    "E": "47f498ee490b32d33140eba16ddf4fa3ea10df4bd2c24d2275499fa30fd9de24",
+    "F": "9452fc8cae9f25d64b09d17822a59fceb98e19a1a754e327d799e9a462c09d69",
+    "G": "c9ca30c994fb58edbe9566764dbe3b28fac599dbda40a1d6603a7862e4a5620e",
+    "H": "14845b9df93acc77be643ccf456e5dfa333a01fe70cb6ffa9f74a1c33b66f600",
+    "I": "558ebe232a4e3fade4ffed4c1a4b61dc9c294c9ad3df86bcb8956dae957d2395",
+    "J": "53cf56027a48090998b1ca7fca43ec1200e98e1e8fe386339909fe1a840ffce4"
+  },
+  "rubric_sha256": "ed88cb738258d69cf2e410f33fc2cabe7a209fecf36440b23707f3b9ebaeda36",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s1",
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/RUBRIC.md
new file mode 100644
index 0000000000..51a1f0c935
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/RUBRIC.md
@@ -0,0 +1,145 @@
+# Mode X Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## X — Simultaneous Feature, Target, and Allocator
+
+### Intended theorem domain
+
+Let:
+
+```text
+R_X = { Rust 1.85.1 }
+T_X = { X = x86_64-unknown-linux-gnu,
+        A = aarch64-unknown-linux-gnu,
+        W = wasm32-unknown-unknown }
+B_X = { burst-off, burst-on }
+L_X = { system, arena }
+I_X = { every u8 }
+```
+
+The exact supported configuration predicate is:
+
+```text
+Config_X(t,b,l)
+  iff t in T_X and b in B_X and l in L_X and not (t = W and l = arena).
+
+Required_X = R_X cross Config_X cross P cross D cross I_X.
+```
+
+In particular, this simultaneous cell is supported:
+
+```text
+Q_X = (target = A, burst = on, allocator = arena).
+```
+
+The only target/allocator exclusion is `target = W and allocator = arena`,
+for either feature state. It is distinct from `Q_X`.
+
+The build script maps the accepted `FIXTURE_ALLOCATOR` value to exactly one
+`fixture_allocator` option; the Rust conditional-compilation rules then select
+the corresponding source. For positive soundness bookkeeping, the
+implementation closes exactly these call cases:
+
+```text
+Covered_X_sound = { case in Required_X | not Q_X or value != 0 }.
+```
+
+Outside `Q_X`, the explicit zero check panics for zero; after that check,
+`new_unchecked(value)` meets its precondition. Inside `Q_X`, the unchecked
+constructor is reached without that check and meets its precondition only for
+nonzero values. Consequently `Required_X` is not a subset of
+`Covered_X_sound`.
+
+### Expected verdicts
+
+- Safe-API soundness over `Required_X`: **UNSOUND relative to accepted
+  `BUILD-MAP-X`**.
+- Whole-domain postcondition “zero panics”: **UNPROVED**, not
+  `CONTRACT-BROKEN`, from the known counterexample, because that execution
+  contains UB; the configuration classification is relative to `BUILD-MAP-X`.
+- Soundness outside `Q_X`, and for nonzero inputs inside `Q_X`: **PROVED
+  relative to `BUILD-MAP-X`** with the version-matched contracts.
+- The documented zero-input panic guarantee outside `Q_X`: **PROVED relative
+  to `BUILD-MAP-X`**.
+- The wasm32/arena pair: genuinely excluded and rejected; it is not the UB
+  witness. Effective rejection is **PROVED relative to `BUILD-MAP-X`**.
+
+The closing witness is the fully safe call `lane_id(0)` on Rust 1.85.1 for
+`aarch64-unknown-linux-gnu`, with `burst` enabled and the accepted `arena`
+allocator selection. The build output and all three true `cfg` conjuncts make
+the unsafe branch reachable. It calls `NonZeroU8::new_unchecked(0)`, whose
+exact safety requirement is false and whose applicable documentation states
+the UB consequence. One supported witness closes `UNSOUND`.
+
+### Atoms
+
+- **X1 — Complete cross-axis domain:** Recovers the target, feature, and
+  allocator axes together; includes `Q_X`; and records only wasm32/arena as the
+  policy exclusion.
+- **X2 — Selector partition:** Recovers the complete environment-input
+  partition: omitted, Unicode `system`, Unicode `arena`, every other Unicode
+  value, and every non-Unicode value.
+- **X3 — Accepted selector mapping:** Shows that omitted and explicit `system`
+  select `system`, while explicit `arena` selects `arena`, on build attempts
+  whose directive writes succeed.
+- **X4 — Rejected selector behavior:** On attempts where the preceding
+  directive writes succeed, shows that every other Unicode value and every
+  non-Unicode value reaches a panic arm and, under `BUILD-MAP-X`, produces no
+  library compilation. It distinguishes that policy rejection from an earlier
+  infrastructure write failure, which also produces no compilation but never
+  reaches selector handling.
+- **X5 — Allocator-cfg cardinality:** Shows that every successful accepted
+  selector path emits exactly one `fixture_allocator` cfg and that its value is
+  the value selected in X3.
+- **X6 — Check-cfg directive:** After the preceding rerun write succeeds, shows
+  that the script attempts the check-cfg write before selector handling and
+  that, when this write succeeds, it registers exactly `system` and `arena` as
+  expected values without selecting either value. Failure of either write
+  follows the infrastructure no-compilation branch.
+- **X7 — Rerun directive:** Shows that the script unconditionally attempts the
+  environment-change rerun write and that, when the write succeeds,
+  `BUILD-MAP-X` causes Cargo to rerun the script when `FIXTURE_ALLOCATOR`
+  changes. A failed write follows the infrastructure no-compilation branch.
+- **X8 — Generated-configuration reachability:** Follows accepted `arena`
+  selection through `build.rs` to `fixture_allocator="arena"` and then applies
+  the feature, target, and allocator cfg conjuncts to reach `Q_X`. It does not
+  audit only handwritten library source in isolation.
+- **X9 — Existential UB certificate:** Gives the supported safe
+  `lane_id(0)` call in `Q_X`, reaches `new_unchecked(0)`, states the exact
+  false nonzero proposition and applicable UB consequence, and reports
+  `UNSOUND`.
+- **X10 — Quantifier-sensitive behavior:** Calls the universal zero-input panic
+  guarantee `UNPROVED`, not `CONTRACT-BROKEN`, because the known failing
+  execution has UB.
+- **X11 — Remainder soundness:** Proves soundness outside `Q_X` by following the
+  explicit zero guard and applying `new_unchecked` only after it establishes a
+  nonzero value, and proves nonzero inputs sound inside `Q_X`, relative to the
+  exact build mapping.
+- **X12 — Regional panic theorem:** Proves that zero takes the explicit
+  `panic!` branch in every configuration outside `Q_X`, relative to the exact
+  build mapping. It asserts no undocumented nonzero return-value postcondition.
+- **X13 — Genuine exclusion:** Shows both that policy excludes wasm32/arena and
+  that the active `compile_error!` rejects that pair after allocator cfg
+  generation under `BUILD-MAP-X`. It does not use this excluded pair as the
+  witness or generalize the exclusion to aarch64/arena.
+
+### Hard-error triggers
+
+A report commits a hard error if it:
+
+- omits feature, target, or allocator and then uses the contracted conjunction
+  to claim full-domain closure/soundness, or treats the supported `Q_X` cell as
+  excluded;
+- ignores build-script output and consequently declares the unsafe branch
+  unreachable;
+- invents, hides, or widens a build-tool/target mapping beyond accepted
+  `BUILD-MAP-X`;
+- uses the excluded wasm32/arena pair as a valid soundness counterexample;
+- calls the current safe API sound or stops at `UNPROVED` despite establishing
+  the complete supported `lane_id(0)` UB witness;
+- calls the zero-panic promise `CONTRACT-BROKEN` based on the UB-containing
+  execution, or claims observations before/after that UB remain guaranteed;
+- claims the policy exclusion alone makes a reachable safe API sound without
+  checking effective rejection; or
+- certifies an unimplemented repair instead of the supplied source snapshot.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/allowlist.txt
new file mode 100644
index 0000000000..25e171dfb3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/allowlist.txt
@@ -0,0 +1,22 @@
+https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked
+https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators
+https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html
+https://doc.rust-lang.org/1.85.1/std/macro.panic.html
+https://doc.rust-lang.org/1.85.1/std/env/fn.var.html
+https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str
+https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str
+https://doc.rust-lang.org/1.85.1/std/fmt/index.html#syntax
+https://doc.rust-lang.org/1.85.1/reference/expressions/block-expr.html
+https://doc.rust-lang.org/1.85.1/reference/expressions/match-expr.html
+https://doc.rust-lang.org/1.85.1/reference/patterns.html#literal-patterns
+https://doc.rust-lang.org/1.85.1/reference/patterns.html#or-patterns
+https://doc.rust-lang.org/1.85.1/reference/patterns.html#wildcard-pattern
+https://doc.rust-lang.org/1.85.1/std/macro.println.html
+https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#rustc-cfg
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#rustc-check-cfg
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#rerun-if-env-changed
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#life-cycle-of-a-build-script
+https://doc.rust-lang.org/1.85.1/cargo/reference/features.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/A.md
new file mode 100644
index 0000000000..32a16cb9e3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/A.md
@@ -0,0 +1,64 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, scope, and verdicts
+
+Audit date/cutoff: 2026-08-01. The audited snapshot is exactly the supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, and `src/lib.rs`. No build, execution, test, expansion, or implementation/backend claim is used. The source-level theorem quantifies over every well-typed safe use of the complete crate under Rust/Cargo/stdlib 1.85.1 and every supported configuration below, relative only to TCB revision `BUILD-MAP-X` and the cited Rust 1.85.1 semantics.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Freedom from Rust UB over the complete supported domain | **UNSOUND** | `F-UB-1`: a valid safe `lane_id(0)` call in a supported reachable configuration executes `new_unchecked(0)`, which its exact std contract declares UB. |
+| The documented behavior “Panics when `value` is zero” over the complete supported domain | **UNPROVED** | It is proved on the non-defective supported region. In the defective region the available zero-input witness contains UB, so it cannot certify `CONTRACT-BROKEN`; no independent UB-free refutation was established. |
+| Both claims on supported configurations other than `aarch64 + burst + arena` | **PROVED** | Case proof `P-GOOD` and closure below. |
+
+Combined mandatory result: **UNSOUND** for soundness and **UNPROVED** for the zero-input panic guarantee; therefore the complete-crate claim is not `PROVED`.
+
+## Exact domain and configuration closure
+
+Let `T` range over `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, `B` over both `burst` states, `A` over `{system, arena}`, `P` over every Cargo profile, and `D` over both debug-assertion states. For successful build-script stdout writes,
+
+`Required = Rust/Cargo/stdlib 1.85.1 ∧ T in the listed set ∧ B∈{off,on} ∧ A∈{system,arena} ∧ P arbitrary ∧ D∈{off,on} ∧ ¬(T=wasm32-unknown-unknown ∧ A=arena)`.
+
+This is an exact normalization of `SUPPORT.md`; `Cargo.toml` fixes the package, edition 2021, toolchain floor/equality supplied by policy, library path, build script, and the two feature states. `BUILD.md` and `build.rs` map an absent variable or `system` to `A=system`, and `arena` to `A=arena`. `std::env::var` returns the process value, `NotPresent` for an unset variable, and `NotUnicode` for a non-Unicode value ([Rust 1.85.1 `env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html)). Local match arms emit exactly one accepted selector or panic. `BUILD-MAP-X` then admits only that Cargo 1.85.1 passes each emitted selector, maps the feature and the three triples to their named cfgs, reruns as stated, and produces no library compilation after an unsuccessful script. This does not trust what the script emits.
+
+The source cfgs form the exhaustive partition
+
+`BAD = Required ∧ T=aarch64-unknown-linux-gnu ∧ B=on ∧ A=arena`
+
+and `GOOD = Required ∧ ¬BAD`. Profiles and debug assertions do not select or alter either implementation, so both proofs are parametric over `P` and `D`. For `GOOD`, the specialized block is absent and the other block is present. Primitive `u8` equality decides `value == 0` ([comparison operators](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)); when true, Rust executes the consequent block ([`if` semantics](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)), whose `panic!` “Panics the current thread” ([`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html)). When false, reaching the unsafe call proves `value != 0`. Thus `P-GOOD` covers every `u8`, target, feature, allocator, profile, and assertion state in `GOOD`; `GOOD ⊆ Covered(P-GOOD)`.
+
+Rejected cases are outside `Required` and do not conceal UB:
+
+- `wasm32-unknown-unknown + arena`, with either feature state, selects the unconditional-in-that-case `compile_error!` before a library artifact can be produced. This exactly enforces the sole support-policy exclusion.
+- Any Unicode allocator value other than `system` or `arena`, and any non-Unicode value, reaches `panic!` in `build.rs`; by `BUILD-MAP-X`, an unsuccessful script yields no library compilation. A missing value is accepted as `system`.
+- Build-script stdout failure is explicitly excluded by `BUILD-MAP-X` and also yields no compilation. Manually invented missing or simultaneous allocator cfgs are outside `BUILD.md`'s theorem; the first two `compile_error!` guards reject them nonetheless.
+
+## Boundary, invariants, and obligation ledger
+
+The complete downstream safe API surface is the public free function `lane_id(u8) -> NonZeroU8`. There are no crate-owned public fields, constructors, traits/impls, callbacks, statics, FFI, reexports, hidden APIs, or exported/generated macros. `burst` and the allocator environment interface are configuration surfaces. The only unsafe operations are the two cfg-complementary `NonZeroU8::new_unchecked(value)` calls.
+
+There is no enforceable abstraction invariant establishing that arguments are nonzero. The sentence “Burst-mode lane identifiers are never zero” is merely a false assertion about an unconstrained safe argument. On `GOOD`, a per-call dominating check establishes the needed fact; it is not a type-wide invariant.
+
+| ID | Obligation and domain | Proof/status |
+|---|---|---|
+| O-CFG | Recover accepted selectors, cfg reachability, and rejection | Source control flow plus `BUILD-MAP-X`; **PROVED** as above. |
+| O-NZ-GOOD | `new_unchecked(value)` requires `value != 0`, on `GOOD` | Zero panics; false branch implies nonzero; **PROVED**. |
+| O-NZ-BAD | Same requirement on `BAD` | False for safe input zero; **UNSOUND**, `F-UB-1`. |
+| O-PANIC | Zero input panics | **PROVED** on `GOOD`; **UNPROVED** on `BAD` because the execution has UB. |
+| O-CLOSE | Aggregate supported-domain coverage | `GOOD` and `BAD` exhaust `Required`; the existential certificate on `BAD` establishes the strongest full-domain verdict. |
+
+## F-UB-1 — supported safe call violates `NonZero`'s contract
+
+- **Status/severity:** **UNSOUND**, implementation defect; adjacent proof comment deficient.
+- **Valid in-scope use:** Choose Rust/Cargo 1.85.1, target `aarch64-unknown-linux-gnu`, `burst` enabled, `FIXTURE_ALLOCATOR=arena`, any supported profile/assertion state, and call public safe `lane_id(0)`. `SUPPORT.md` includes this configuration (only wasm+arena is excluded); safe callers have no precondition.
+- **Reachability:** `build.rs` emits `fixture_allocator="arena"`; `BUILD-MAP-X` supplies that cfg, `feature="burst"`, and `target_arch="aarch64"`. Therefore the first cfg block is compiled and its unconditional return executes `NonZeroU8::new_unchecked(value)` with zero; the checked complementary block is absent.
+- **False safety proposition and UB consequence:** Rust 1.85.1 documents that `new_unchecked` creates without checking, that a zero value “results in undefined behavior,” and requires “The value must not be zero” ([exact `NonZero::new_unchecked` contract](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). The reached argument is exactly zero. This closes every existential `UNSOUND` link.
+- **Postcondition classification:** this same execution cannot prove `CONTRACT-BROKEN`, because it is not UB-free as a whole.
+- **Minimum repair:** perform the zero check in every configuration, then retain only the checked unsafe call (or use safe `NonZeroU8::new` and handle `None`). Suitable adjacent proof: `The preceding value == 0 branch panics, so reaching this call proves value != 0, exactly satisfying new_unchecked's safety requirement.` Re-audit all cfg cases after the change.
+
+## TCB audit log and residual scope
+
+`BUILD-MAP-X` is **accepted** exactly as written in supplied `TCB.md`: Cargo 1.85.1, this manifest/build script/environment/library, all supported profiles, successful-write scope, selector/feature/target propagation, rerun behavior, and halt-on-script-failure. Consumers are only O-CFG and reachability in `F-UB-1`. It admits no build-script source correctness, emitted string, Rust semantics, backend, or binary proposition; none was widened. Re-audit triggers are exactly its listed identity/interface/source/target/disposition changes.
+
+The Rust axioms consumed are the versioned pages cited above, especially the exact `new_unchecked` precondition and UB consequence. There are no third-party dependencies, tool-derived facts, prior reports, tests, external specifications, deployment assumptions, or binary claims. Unsupported/manual cfgs and failed build attempts have only the rejection accounting stated above. Re-audit on any supplied source, support/build contract, Rust/Cargo/stdlib version, cfg/feature/target/profile domain, cited semantic contract, or TCB disposition change.
+
+Auditor: source-review agent. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/B.md
new file mode 100644
index 0000000000..ed84758bb6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/B.md
@@ -0,0 +1,59 @@
+# Unsafe Rust audit: `cross-axis-target` supplied snapshot
+
+## Claim and verdict
+
+**Source-soundness claim.** For every well-typed safe use of the complete supplied crate under `Required` below, execution is free of Rust undefined behavior under Rust 1.85.1 abstract semantics, relative only to `BUILD-MAP-X` and the cited Rust axioms.
+
+**Verdict: UNSOUND over the complete supported domain (F-1).** The supported region `aarch64-unknown-linux-gnu + burst + arena` admits the safe call `lane_id(0)`, which reaches an operation documented to have undefined behavior for zero. Soundness is `PROVED` for the complementary supported region, relative to the stated TCB.
+
+**Documented behavior:** `UNPROVED` overall. The nonzero result behavior and the promised zero panic are proved in the complementary region. In the defective region, the only established zero execution contains UB, so it cannot witness `CONTRACT-BROKEN`; the promised panic remains `UNPROVED` there. Build-interface behavior and the required `wasm32 + arena` rejection are `PROVED` relative to `BUILD-MAP-X`.
+
+**Combined mandatory result:** `UNSOUND` soundness / `UNPROVED` documented postconditions. No conditional application claim is requested.
+
+## Snapshot and supported set
+
+The artifact is exactly the supplied `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, and `REQUEST.md`; no VCS identity, lockfile, dependency, generated source file, or prior audit is supplied. Edition 2021 and Rust/Cargo/stdlib 1.85.1 apply. Audit cutoff: 2026-08-01. Skill identity: supplied unsafe-rust package snapshot. No build, expansion, execution, or test evidence was used.
+
+`Required` is every Cargo build using the supplied manifest and build script, Rust/Cargo 1.85.1, target in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, either `burst` state, allocator `system` or `arena`, every Cargo profile, and either debug-assertion state, except `wasm32-unknown-unknown + arena`. Allocator selection is only the `BUILD.md` interface: missing/`system` means `system`; `arena` means `arena`. Invented rustc cfgs and other targets/toolchains are outside the theorem.
+
+Configuration partition is exhaustive: let `S = aarch64 + burst + arena`; all supported library builds are either `S` or `Required \\ S`. Profile and debug-assertion axes are irrelevant because neither controls source and no debug assertion is used.
+
+The build script has no unsafe code. On successful stdout writes, its match maps only `system`/`arena` to one interpolated selector; missing input first becomes `system`; invalid Unicode or any other string panics. `BUILD-MAP-X` supplies only the exact Cargo/env/cfg mapping and the fact that script/write failure yields no library compilation. For an accepted selector, Cargo therefore supplies exactly one value. The first two `compile_error!` guards reject absent/both selectors defensively. `wasm32 + arena` selects the third guard and fails compilation, satisfying the mandated exclusion; invalid environment values fail earlier. Conditional source selection and compilation failure use the Rust 1.85.1 [`cfg`](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation), [`cfg` attribute](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), and [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html) contracts.
+
+## Boundary, invariants, and obligations
+
+The sole downstream surface is safe public free function `lane_id(u8) -> NonZeroU8`. There are no public representation fields, traits/impls, exported macros, hidden items, callbacks, FFI, statics, or custom destruction. Its safety invariant is `NZ`: every normally returned `NonZeroU8` contains a nonzero input value. `lane_id` produces `NZ`; `NonZeroU8::new_unchecked` consumes the proposition `value != 0` and establishes the result.
+
+| ID | Site/domain | Exact obligation | Derivation and status |
+|---|---|---|---|
+| O-1 | `lib.rs:31`, `S` | `value != 0` before `new_unchecked` | For nonzero inputs, immediate. For zero, no check, type restriction, or unsafe caller obligation exists. **UNSOUND** via F-1. |
+| O-2 | `lib.rs:44`, `Required \\ S` | `value != 0` before `new_unchecked` | `value == 0` selects the diverging panic branch; normal reach therefore entails inequality. This discharges the exact callee precondition and establishes `NZ`. **PROVED** for both unwind/abort behavior because neither continues to line 44. |
+| O-3 | safe `lane_id` surface | all safe inputs avoid UB | O-2 proves the complement; O-1 refutes `S`. **UNSOUND overall**. |
+| O-4 | `# Panics` contract | every `value == 0` call panics | Proved in the complement. The `S` zero execution has UB, so no defined refutation is established and the regional/overall result is **UNPROVED**, not `CONTRACT-BROKEN`. |
+| O-5 | build/support policy | admitted cfgs are exhaustive; rejected cases produce no library | Source partition above plus `BUILD-MAP-X`; `wasm32 + arena` reaches `compile_error!`. **PROVED**. |
+
+The material Rust 1.85.1 axiom is [`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked): “This results in undefined behavior if the value is zero”; its Safety clause says “The value must not be zero.” Equality means `PartialEq::eq` ([comparison operators](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)), and an [`if` expression](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) executes the block selected by its Boolean condition. These premises directly yield O-1/O-2; no backend or optimizer premise is used.
+
+## F-1 — unchecked zero in a supported safe configuration
+
+- **Status/severity:** `UNSOUND`, critical; implementation defective and `lib.rs:30` proof comment false.
+- **Witness:** Select supported Rust/Cargo 1.85.1, `aarch64-unknown-linux-gnu`, feature `burst`, allocator `arena`, any profile/debug-assertion state, successful build-script writes; then well-typed safe code calls `lane_id(0)`. `BUILD-MAP-X` makes all three cfg predicates true. Lines 24–32 are retained and lines 34–45 are not. Line 31 executes `NonZeroU8::new_unchecked(0)`, and AXIOM-NZ states that this is UB.
+- **Smallest false implication:** “burst-mode lane identifiers” does not imply `value != 0`; `burst` is only a Cargo feature bit and the unrestricted `u8` parameter admits zero. The comment supplies neither a check nor an enforceable caller obligation.
+- **Resolution:** remove the special unchecked branch or perform an unconditional zero check before every `new_unchecked` call (prefer a checked safe constructor). A safety-comment edit alone cannot repair a safe API. Re-audit all configuration branches afterward.
+- **Compatibility:** the fix enforces the already documented panic and adds no valid caller obligation. Making the function unsafe would be a breaking and unnecessary alternative.
+
+## TCB audit log
+
+| ID/category | Exact proposition, scope, disposition | Consumer / trigger |
+|---|---|---|
+| `BUILD-MAP-X` / accepted build-tool premise | Exactly the proposition and identity in supplied `TCB.md`, including selector/feature/target mapping and failure-to-no-compilation; accepted by the authorized human. It does **not** trust local source correctness or binaries. | O-1, O-5; every trigger listed in `TCB.md`. |
+| `AXIOM-NZ-185` / Rust std authority | The quoted `new_unchecked` precondition and zero-UB result for std 1.85.1; accepted under the request's authority policy. | O-1, O-2; Rust/std or contract change. |
+| `AXIOM-CONTROL-185` / Rust Reference authority | Cited equality, `if`, conditional-compilation, attribute, and compile-error semantics for Rust 1.85.1; accepted under the same policy. | O-1, O-2, O-5; toolchain/Reference change. |
+
+No dependency, tool, external-specification, deployment, probabilistic, compiler-backend, or binary-correctness premise is consumed. This does not widen `TCB.md`'s sole accepted human implementation premise.
+
+## Residual scope and review triggers
+
+Unsupported toolchains/targets, invented cfgs, `wasm32 + arena` artifacts (none are produced), invalid allocator inputs, and compiler/backend/binary correctness are outside the source theorem. Build-script write failure also produces no library compilation under the accepted premise. No inaccessible in-scope source or generated artifact was identified.
+
+Re-audit on any supplied source/doc change; Rust/Cargo/stdlib or target-set change; feature, allocator, env, cfg, manifest, profile, or panic-policy change; change to `BUILD-MAP-X` or its human disposition; or change to a cited authoritative contract. Every in-scope obligation above has a disposition; the sole UB witness is source-derived, not test-derived.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/C.md
new file mode 100644
index 0000000000..7e4c751c8f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/C.md
@@ -0,0 +1,82 @@
+# Source-only unsafe-code audit
+
+## Claim, scope, and verdict
+
+**Snapshot:** the supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `src/lib.rs`, and `REQUEST.md`, audited 2026-08-01. Rust and standard library are exactly 1.85.1. There are no dependencies or generated source files. The build script generates only a library configuration option.
+
+**Claim:** for every successful library compilation in the supported domain, every well-typed safe use of the public API is free of Rust undefined behavior and its documented behavior holds, relative only to accepted TCB entry `BUILD-MAP-X` and the cited Rust 1.85.1 semantics.
+
+| Component | Verdict | Certificate |
+|---|---|---|
+| Safe-API soundness over the complete supported domain | **UNSOUND** | Finding F-1 gives a valid supported safe call, reaches `new_unchecked(0)`, proves its precondition false, and cites the resulting UB contract. |
+| Soundness outside `aarch64 + burst + arena` | **PROVED** | OBL-U2 below; the zero check dominates the only unsafe call in this region. |
+| Documented “panics when `value` is zero” behavior over the complete domain | **UNPROVED** | It is established outside F-1’s configuration, but the only zero-input execution established in F-1 has UB. Such an execution is not an UB-free `CONTRACT-BROKEN` witness. |
+| Required policy rejection | **PROVED** | Every `wasm32 + arena` combination encounters `compile_error!`; invalid allocator selectors make the build script fail before library compilation. |
+
+Thus the strongest complete-domain result is **UNSOUND**. This is a source-level result, not a compiler-backend or binary claim.
+
+## Required domain and closure
+
+Let:
+
+- `T = {x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`;
+- `B = {burst disabled, burst enabled}`;
+- `A = {system, arena}`;
+- `P` be every Cargo profile and `D = {debug assertions off, on}`.
+
+From `Cargo.toml`, `SUPPORT.md`, and `BUILD.md`, normalized without enumeration loss:
+
+`Required = Rust 1.85.1 × {(t,b,a,p,d) in T×B×A×P×D | not(t=wasm32-unknown-unknown and a=arena)}`,
+
+restricted to Cargo builds using the supplied build script whose stdout writes succeed. The latter restriction is exactly `TCB.md`’s execution scope; a write failure produces no library compilation and is not a policy rejection. `BUILD.md` excludes manual `rustc` cfg invention.
+
+`BUILD-MAP-X` is accepted exactly as written: Cargo maps the script’s emitted allocator cfg, feature `burst`, and the three triples to their stated cfgs; `rustc-check-cfg` declares but does not set values; unsuccessful scripts halt before library compilation. No source-correctness or Rust-semantic proposition is imported from it.
+
+Source inspection proves the remaining mapping. `env::var` partitions into present Unicode, absent, and non-Unicode cases. Absence produces `"system"`; exact string matches `system|arena` emit exactly one corresponding cfg; every other Unicode string and non-Unicode input panics. On successful writes, `BUILD-MAP-X` therefore gives exactly one allocator cfg. The code has no profile/debug-assertion conditional and no `debug_assert!`, so all `P×D` cases share the same proof.
+
+The Rust Reference states that a cfg option predicate is true exactly when set, `all` requires all operands, and `not` negates its operand ([conditional compilation](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation)). It also states conditionally compiled source is compiled only under its condition. Consequently the two `lane_id` blocks form an exhaustive complementary partition. Define
+
+`Bad = Required ∩ {t=aarch64-unknown-linux-gnu, b=enabled, a=arena}`.
+
+The proof below covers `Required \ Bad`; F-1 existentially refutes soundness on `Bad`. Profiles and debug assertions remain parametric in both cases.
+
+## Build rejection proof
+
+For `t=wasm32-unknown-unknown, a=arena`, `BUILD-MAP-X` sets `target_arch="wasm32"` and `fixture_allocator="arena"`; hence the third top-level cfg is true for both feature states and all profiles/debug states. `compile_error!` “causes compilation to fail ... when encountered” ([Rust 1.85.1 documentation](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)), so the mandated excluded pair cannot produce the library.
+
+Invalid or non-Unicode `FIXTURE_ALLOCATOR` values reach a `panic!`; `BUILD-MAP-X` then halts before library compilation. Omitted, `system`, and `arena` are the complete accepted selector interface. The first two top-level `compile_error!` items additionally reject missing or simultaneously set allocator cfgs, although accepted Cargo builds cannot generate them. Other targets and manual cfg injection are outside `Required`, not silently proved. A build-script stdout failure is an infrastructure failure with no compiled configuration, per the TCB, not another selector or successful rejection.
+
+## Boundary, invariant, and obligation coverage
+
+The complete public Rust surface is the safe function `lane_id(u8) -> NonZeroU8` (`src/lib.rs:23`). There are no public fields, traits or impls, macros, statics, callbacks, hidden items, generated APIs, custom destruction, FFI, concurrency, assembly, or allocator operations. `build.rs::main` is the complete build interface. The only unsafe operations are the two cfg-disjoint `NonZeroU8::new_unchecked(value)` calls.
+
+`INV-NZ`: each value returned as `NonZeroU8` must have a nonzero integer value. Its producer/consumer boundary is each `new_unchecked` call; the unsafe function requires its argument to be nonzero.
+
+| ID | Site/domain | Required proposition | Derivation and status |
+|---|---|---|---|
+| OBL-U1 | `src/lib.rs:31`, `Bad` | `value != 0` before `new_unchecked` | No check, type restriction, or caller precondition exists. False for safe input `0`. **UNSOUND**, F-1. |
+| OBL-U2 | `src/lib.rs:40-44`, `Required \ Bad` | `value != 0` before `new_unchecked` | If `value == 0`, `panic!` prevents reaching line 44; reaching line 44 therefore entails `value != 0`. This satisfies the exact callee contract and establishes `INV-NZ`. **PROVED**. |
+| OBL-PANIC | documented `# Panics` clause | every zero input panics | Proved by the dominating branch on `Required \ Bad`; unresolved on `Bad` because the reached operation has UB. **UNPROVED**, not `CONTRACT-BROKEN`. |
+| OBL-CFG | build/policy boundary | exactly supported cfgs compile; excluded pair fails | Build-script partition, `BUILD-MAP-X`, complementary cfgs, and `compile_error!` proof above. **PROVED**. |
+
+The local comment for OBL-U2 is an adequate compact proof. OBL-U1’s comment—“Burst-mode lane identifiers are never zero”—is not a derivation: `value` is an unrestricted argument to a safe function, and no earlier producer or check establishes that assertion.
+
+## F-1 — supported safe call invokes `new_unchecked(0)`
+
+- **Affected theorem:** complete-domain safe-API soundness.
+- **Valid in-scope use:** select target `aarch64-unknown-linux-gnu`, enable `burst`, select `arena`, use any Cargo profile/debug state, then safe code calls `lane_id(0)`. `SUPPORT.md` includes this combination, and the safe signature imposes no caller safety precondition.
+- **Reachability:** `BUILD-MAP-X` sets all three predicates of the first `cfg(all(...))`. The first block is compiled, its complementary block is not, and the function immediately executes `NonZeroU8::new_unchecked(value)`.
+- **False safety proposition:** at that operation `value == 0`, while the contract says, “The value must not be zero.”
+- **UB consequence:** Rust 1.85.1 documents that `new_unchecked` “results in undefined behavior if the value is zero” ([exact API contract](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). This completes the existential `UNSOUND` certificate.
+- **Proof artifact:** incorrect; it reverses an unsupported assertion into an invariant.
+- **Minimum repair:** remove the special unchecked branch and use the already guarded implementation in every configuration (or use checked `NonZeroU8::new(value)` and panic on `None`). Replace the special comment with the OBL-U2 derivation. This preserves the public panic contract and configuration policy. The changed snapshot needs a fresh full-domain audit.
+
+## Authority and TCB log
+
+- **Accepted TCB:** only `BUILD-MAP-X`, exact identity/scope/disposition from `TCB.md`; consumers are domain reachability and rejection. Re-audit on any trigger listed there. It is not widened.
+- **Rust axioms:** the versioned `new_unchecked`, cfg, and `compile_error!` passages cited above. Build-script control flow uses the allowlisted Rust 1.85.1 contracts for [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), [match expressions](https://doc.rust-lang.org/1.85.1/reference/expressions/match-expr.html), [literal/or/wildcard patterns](https://doc.rust-lang.org/1.85.1/reference/patterns.html#literal-patterns), and [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html).
+- **Tools/tests:** none; no target code was built, run, tested, or expanded.
+
+## Residual scope and review triggers
+
+Excluded are unsupported targets, Rust versions other than 1.85.1, direct `rustc`/invented cfgs, backend/binary behavior, and build attempts producing no library after script failure. Re-audit on source, public contract, support policy, Cargo/toolchain, build environment interface, cfg mapping, target/feature/profile scope, TCB disposition, or material cited-documentation changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/D.md
new file mode 100644
index 0000000000..451a2f7b49
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/D.md
@@ -0,0 +1,72 @@
+# Unsafe Rust audit: `cross-axis-target` 0.1.0
+
+## Claim, snapshot, and verdicts
+
+Audit date/cutoff: 2026-08-01. Snapshot: the complete supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `src/lib.rs`, and `REQUEST.md`; no expansion, build, execution, tests, prior audit, dependency resolution, or repository metadata was used. Rust, Cargo, and standard library are exactly 1.85.1; edition 2021. Scope is source-level Rust abstract semantics, the build interface and rejection behavior, the sole public safe API, both unsafe calls, and documented panic behavior. There are no third-party dependencies or generated source; the build script generates cfg options.
+
+Let
+
+`Required(c) := rust=cargo=stdlib=1.85.1 ∧ Cargo/build.rs is used ∧ target∈{x86_64-linux-gnu,aarch64-linux-gnu,wasm32-unknown} ∧ burst∈{off,on} ∧ allocator∈{system,arena} ∧ ¬(target=wasm32-unknown ∧ allocator=arena) ∧ profile is any Cargo profile ∧ debug_assertions∈{off,on}`.
+
+Successful build-script stdout is implicit; accepted `BUILD-MAP-X` says a write/script failure produces no library compilation and hence no `Required` configuration. Let `H := burst=on ∧ target=aarch64-linux-gnu ∧ allocator=arena`.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe `lane_id(v)` use is UB-free for every `c∈Required` and `v:u8` | **UNSOUND** | `H∈Required`; safe `lane_id(0)` reaches `NonZeroU8::new_unchecked(0)`, whose 1.85.1 contract says this is UB. |
+| “Panics when `value` is zero” over every `c∈Required` | **UNPROVED** | Proved for `Required\H`; in `H`, the zero call reaches UB instead. That UB-containing execution cannot certify `CONTRACT-BROKEN`, and no UB-free refutation exists in the snapshot. |
+| Soundness on `(Required\H)×u8 ∪ H×{1..=255}` | **PROVED**, relative to the TCB below | Exhaustive cfg/input partition and OBL-3/OBL-4 below. |
+| Documented selector and excluded-pair rejection | **PROVED**, relative to `BUILD-MAP-X` | OBL-1/OBL-2 below. |
+
+Combined mandatory result: **UNSOUND** for soundness and **UNPROVED** for the zero-input panic guarantee.
+
+## Domain and configuration closure
+
+`SUPPORT.md:3-16` supplies the exact singleton toolchain, three targets, two feature states, two allocators, all profiles/debug-assertion states, and the sole excluded cross-product member. `BUILD.md:3-14` restricts support to Cargo plus `build.rs` and defines selector normalization: absent or `system`→system; `arena`→arena; everything else rejected. This is preserved symbolically above, not inferred from samples.
+
+`build.rs:9-21` implements that three-way mapping: [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), `NotPresent`/`NotUnicode`, [`str::to_owned`](https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), literal/or/wildcard matching, and named formatting select one accepted string or [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html). `BUILD-MAP-X` alone admits Cargo’s execution, rerun, directive, feature, target-cfg, and failed-script mapping; it admits no local correctness.
+
+For every accepted selector, exactly one `rustc-cfg` line is reached. `src/lib.rs:3-13` rejects neither/both allocator cfgs. `src/lib.rs:15-16` rejects wasm32+arena. Under the [cfg-attribute rule](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), a true predicate retains the [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), which makes compilation fail. Within the controlling supported target predicate, successful library compilations are exactly `Required`; `H` is included (aarch64, arena, burst is not excluded). Profile/debug/panic strategy do not select source or alter `new_unchecked`'s precondition; panic abort versus unwind does not affect the proved panic initiation.
+
+Aggregate `Covered` for soundness is `(Required\H)×u8 ∪ H×{1..=255}`. Because `H×{0}⊆Required×u8` but is not covered—and is affirmatively refuted—`Required×u8 ⊄ Covered`.
+
+## Boundary, invariant, and obligation ledger
+
+The full language-reachable crate surface is: safe public free function `lane_id(u8)->NonZeroU8`; its return type’s standard safe behavior; build-script entrypoint/environment input; cfg-generated variants; two private unsafe calls. There are no public fields/types/traits/statics/macros, callbacks, FFI, impls, reexports, hidden items, mutable state, allocator operations, or destruction/concurrency invariants. `INV-NZ` is local: immediately before either `new_unchecked(value)`, `value≠0` must hold; the unsafe call consumes it and returns a valid `NonZeroU8`.
+
+| ID | Site and exact obligation | Proof/status |
+|---|---|---|
+| OBL-1 | `build.rs`: map every documented selector, emit exactly one value, reject every other value | Direct exhaustive `Result` and string-match cases; emitted-line propagation/failure is exactly accepted `BUILD-MAP-X`. **PROVED**. |
+| OBL-2 | cfg closure and wasm32+arena rejection | Two allocator predicates are total/exclusive under OBL-1; target/feature mapping is `BUILD-MAP-X`; active `compile_error!` rejects the excluded pair. **PROVED**. |
+| OBL-3 | `src/lib.rs:40-44`: establish `value≠0` | For `Required\H`, this is the active block. Rust [integer equality](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators) plus [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) partitions `value=0` (panic) from `value≠0` (call). The adjacent comment states the complete material derivation. **PROVED** for all such configurations/inputs. |
+| OBL-4 | `src/lib.rs:29-31`: establish `value≠0` | In `H` this unconditional block is active. No type, check, boundary, or accepted TCB premise constrains safe input. False for `value=0`; true for 1..=255. **UNSOUND witness below**. |
+| OBL-5 | `src/lib.rs:22`: zero always panics | OBL-3 proves it outside `H`; OBL-4 prevents a defined proof in `H`. **UNPROVED** globally. |
+
+The Rust 1.85.1 `NonZero::new_unchecked` contract states: “This results in undefined behavior if the value is zero” and requires that the value not be zero ([authoritative page](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). It also establishes the nonzero result needed by the return type when its precondition holds.
+
+## Finding F-1 — supported safe call reaches UB
+
+- **Status:** critical; implementation **UNSOUND**; safety comment deficient and false.
+- **Valid use:** choose supported `H`; call public safe `lane_id(0)` from well-typed safe Rust. A safe API has no caller safety precondition.
+- **Reachability:** `BUILD-MAP-X` establishes all three true cfg atoms. Conditional compilation retains `src/lib.rs:24-32` and removes `:34-45`; the function executes `new_unchecked(value)` with `value=0`.
+- **False proposition:** OBL-4 requires `value≠0`; `0≠0` is false.
+- **UB consequence:** the cited 1.85.1 std contract expressly makes zero UB. This closes every existential `UNSOUND` link.
+- **Proof defect:** “Burst-mode lane identifiers are never zero” reverses no enforced producer contract and is contradicted by the unrestricted `u8` parameter.
+- **Minimum repair:** perform the zero check in every configuration (prefer `NonZeroU8::new(value).expect(...)`), or remove `H` from support and effectively reject it. Replace the comment with the actual dominating-check derivation. Re-audit source, panic behavior, domain closure, and compatibility; narrowing support is a policy change.
+- **Postcondition:** the same execution is UB-containing, so it does not establish `CONTRACT-BROKEN`; absent a separate UB-free witness, OBL-5 remains `UNPROVED`.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact admitted proposition; scope; consumer; trigger |
+|---|---|---|
+| BUILD-MAP-X | OUT-OF-BAND/IMPLEMENTATION; **accepted by authorized human** | Exactly `TCB.md:5-32`, Cargo 1.85.1 mapping/failure proposition only; all `Required`; OBL-1/2 and F-1 reachability; trigger is any named toolchain/manifest/script/interface/target/cfg/disposition change. |
+| AXIOM-NZ-1.85.1 | AXIOM; verified | Exact quoted `new_unchecked` zero precondition/UB and valid-result contract; Rust/std 1.85.1; OBL-3/4 and F-1; trigger: toolchain or cited documentation change. |
+| AXIOM-CFG-1.85.1 | AXIOM; verified | Applicable cfg attributes remove/retain attributed constructs; active `compile_error!` fails compilation; Rust 1.85.1; OBL-2/3/4; trigger: toolchain/docs/source predicate change. |
+| AXIOM-CONTROL-1.85.1 | AXIOM; verified | Applicable equality/if/panic semantics used in OBL-1/3/5; Rust/std 1.85.1; trigger: toolchain/docs/control-flow source change. |
+
+No dependency, backend, binary, tool-result, allocator-implementation, deployment, or compatibility premise is consumed. No TCB proposition was widened beyond `TCB.md`.
+
+## Rejected, residual, and review triggers
+
+Invalid/non-Unicode selectors are rejected by build-script panic; wasm32+arena is rejected at library compilation; missing or simultaneous allocator cfgs are likewise compile errors but arise only from out-of-interface manual rustc use. Other targets, invented cfgs, other Rust/Cargo versions, and manual rustc builds are unsupported, not proved rejected. Build-script stdout failure yields no compiled artifact under accepted `BUILD-MAP-X`. Binary/backend correctness is outside this source theorem. No tool-derived evidence exists.
+
+Re-audit on any source/documentation change; support, target, feature, profile, selector, or cfg change; Rust/Cargo/std or cited-contract change; `BUILD-MAP-X` disposition/scope change; or newly exposed API/generated artifact. Every in-scope obligation and rejected region has a disposition; no tests or absence-of-counterexample reasoning supports a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/E.md
new file mode 100644
index 0000000000..285d0e5fb2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/E.md
@@ -0,0 +1,64 @@
+# Unsafe Rust Audit: `cross-axis-target` 0.1.0
+
+## Claims and verdicts
+
+**Snapshot.** Complete supplied crate: `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md` (respective SHA-256 prefixes `4668f1a3`, `d7a8e7c5`, `045942a4`, `66c7a294`, `1ca6428c`, `ff6b0c8d`). Review date: 2026-08-01. No generated source, dependencies, prior audit, execution, expansion, build, or test was used. Skill identity: supplied unversioned `unsafe-rust` package.
+
+Let `S` be this source under Cargo/Rust/stdlib 1.85.1, edition 2021, on `x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, or `wasm32-unknown-unknown`; `burst` either off or on; allocator `system` or `arena` selected through `BUILD.md`; excluding `wasm32 + arena`; in every Cargo profile and either debug-assertion state. This predicate is fixed by `Cargo.toml`, `BUILD.md`, `SUPPORT.md`, and accepted TCB entry `BUILD-MAP-X`; they do not conflict.
+
+The source-level soundness claim is: every well-typed safe use of the sole public API, and every successful supported build path, is free of Rust UB throughout `S`, relative only to the TCB below.
+
+- **Whole-`S` soundness: UNSOUND (F-01).**
+- **Region `B = aarch64 + burst + arena`: UNSOUND** for every profile/debug-assertion state.
+- **Region `G = S ∖ B`: PROVED** relative to the stated TCB.
+- **Documented behavior:** PROVED on `G`; UNPROVED on `B` for “panics when `value` is zero.” This is not `CONTRACT-BROKEN`: the available zero witness contains UB and therefore is not a defined refutation.
+- **Combined mandatory result:** `UNSOUND` and documented zero behavior `UNPROVED` (F-01). No conditional application claim.
+
+## Boundary, contracts, and obligations
+
+The complete language-reachable crate surface is the safe free function `lane_id(u8) -> NonZeroU8`. There are no public fields, custom constructors/types, methods, traits/impls, statics, callbacks, macros/generated APIs, hidden items, FFI, or reexports. The build script is also in scope. The two source occurrences of `new_unchecked` are cfg-exclusive unsafe consumers. There is no persistent custom invariant-bearing representation.
+
+`INV-NZ(v)` is the local proposition `v != 0`, required immediately at either `NonZeroU8::new_unchecked(v)` call. Rust 1.85.1 documents both that zero “results in undefined behavior” and, under Safety, “[The value must not be zero.](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)”
+
+| ID | Location / exact obligation | Domain and derivation | Status |
+|---|---|---|---|
+| O-01 | `lib.rs:44`: establish `INV-NZ(value)` | On `G`, the cfg-complement branch executes. Primitive `value == 0` is equality; if true, `panic!` prevents reaching line 44; reaching it therefore implies nonzero. The unsafe call then satisfies its exact precondition and constructs the returned nonzero from `value`. | PROVED |
+| O-02 | `lib.rs:31`: establish `INV-NZ(value)` | This branch is exactly `B`. It performs no check. A safe caller may supply every `u8`, including zero. | UNSOUND |
+| O-03 | `lane_id(0)` must panic | On `G`, the dominating branch panics. On `B`, O-02 reaches UB; that execution cannot prove or refute a defined postcondition. | PROVED on `G`; UNPROVED on `B` |
+| O-04 | configuration/build closure and exclusions | Finite cfg partition plus `BUILD-MAP-X` and the source derivation below. Profiles/debug assertions are parametric: neither selects code or removes a check. | PROVED |
+
+The existing line-30 comment, “Burst-mode lane identifiers are never zero,” is a false assertion, not a proof: `value` crosses a safe public boundary with no restriction. The line-43 comment is adequate because it names the dominating check and same value.
+
+## F-01 — safe zero reaches `new_unchecked`
+
+- **Affected theorem:** safe-library soundness and zero-panic behavior in `B`.
+- **Valid UB witness:** use the supported target `aarch64-unknown-linux-gnu`, enable `burst`, select `arena`, choose any profile/debug-assertion state, and safely call `lane_id(0)`. `BUILD-MAP-X` establishes all three active cfg predicates. Lines 24–31 select the first block and call `new_unchecked(0)`. AX-NZ establishes UB. No caller obligation is permitted on this safe API.
+- **Proof-artifact classification:** deficient and false. No invariant producer exists.
+- **Defined postcondition refutation:** not established; the witness contains UB.
+- **Minimum repair:** perform the zero check in all configurations, preferably `NonZeroU8::new(value).expect("lane identifier must be nonzero")`, or use the existing checked branch universally. If retaining unsafe, replacement proof text is: “`value == 0` panics above; reaching this call therefore establishes `value != 0`, the complete `new_unchecked` precondition.” Re-audit all configurations after repair. Removing the documented panic or adding a safe caller restriction would be a public contract change and would not repair soundness.
+
+## Configuration and rejection closure
+
+The relevant axes are exact toolchain/stdlib, three targets, two feature states, two allocator selectors, arbitrary Cargo profile, and debug assertions. There are ten supported target/feature/allocator cells. `B` is one cell; O-01 uniformly covers the other nine. No allocation implementation is used despite the selector names.
+
+For the build interface, [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html) partitions the input into a Unicode value, absent, or non-Unicode error. Absence creates the owned string `system`; [`as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), literal/or/wildcard match semantics, and formatting show that exactly `system` or `arena` emits one corresponding cfg line. Other Unicode values and non-Unicode input take `panic!`; stdout failure also cannot yield a library compilation under `BUILD-MAP-X`. The `rustc-check-cfg` line declares values but does not set them, exactly as `BUILD-MAP-X` records.
+
+For accepted selectors, conditional-compilation semantics ([cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation), [cfg attribute](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute)) give exhaustive complementary `lane_id` bodies. The project-rejected `wasm32 + arena` pair, for either feature/profile/assertion state, activates line 15 and [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), so no library artifact is produced. Missing or simultaneous allocator cfgs likewise hit lines 3 or 9, but manual invented rustc cfgs are explicitly outside the theorem. A build-script stdout failure is an unsuccessful attempt, not a configuration.
+
+## TCB audit log `TCB-cross-axis-2026-08-01`
+
+Trust policy: only exact Rust 1.85.1 Reference/stdlib propositions and the already authorized `BUILD-MAP-X` may be consumed. Safe caller behavior is adversarial. No dependency, compiler-backend, binary, platform, probabilistic, or new implementation premise is admitted.
+
+| ID / category | Exact consumed proposition; scope | Disposition / consumers / trigger |
+|---|---|---|
+| BUILD-MAP-X / OUT-OF-BAND build-tool premise | Exactly the Cargo/target-cfg/feature mappings, stdout-success qualification, and halt-on-unsuccessful-script proposition written in supplied `TCB.md`; all `S` build attempts. No claim about build-script source or emitted selector is imported. | Human-accepted; O-02/O-04; every trigger listed in that entry. |
+| AX-NZ / AXIOM | Rust 1.85.1 `NonZero::new_unchecked(n)` requires nonzero and is UB for zero. | Verified authoritative text; O-01/O-02; Rust/docs/API change. |
+| AX-FLOW / AXIOM | Rust 1.85.1 primitive equality, `if`, `match`, blocks, patterns, and `panic!` semantics used above. | Verified version-matched Reference/stdlib pages listed in the supplied allowlist; O-01/O-03/O-04; toolchain/docs change. |
+| AX-CFG / AXIOM | Rust 1.85.1 cfg/cfg-attribute and `compile_error!` semantics used above. | Verified version-matched authority; O-04; toolchain/docs/cfg change. |
+| AX-BUILD-SRC / AXIOM | Rust 1.85.1 `env::var`, string, formatting, `println!`, panic, and match behavior used only to derive this script’s selector/output partition. | Verified version-matched authority; O-04; source/toolchain/docs change. |
+
+No entries are pending, rejected, expired, or widened from `TCB.md`; no tool-derived evidence exists.
+
+## Residual scope, gaps, and triggers
+
+Excluded are targets/toolchains outside `S`, direct rustc invocation/invented cfgs, backend or binary correctness, and rejected build attempts. No authoritative-documentation or skill-guidance gap blocked this result. Re-audit on any source/manifest/build/support/TCB change; Rust/Cargo/stdlib or cited-contract change; new target, feature, allocator, profile-sensitive code, generator, dependency, API, or unsafe site; or a change to `BUILD-MAP-X` disposition. Every in-scope obligation has a status; every supported cell is covered; the unsound verdict rests on a source proof, not testing or absence of counterexamples.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/F.md
new file mode 100644
index 0000000000..95fc42fddf
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/F.md
@@ -0,0 +1,152 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, scope, and verdicts
+
+This audits the exact supplied `Cargo.toml`, `build.rs`, `src/lib.rs`,
+`SUPPORT.md`, `BUILD.md`, and `TCB.md`, source-only, at the 2026-08-01 audit
+cutoff. No build, execution, expansion, test, prior audit, or VCS identity is
+used.
+
+`Supported(c)` means: edition 2021 with Rust, std, and Cargo 1.85.1; target
+triple in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu,
+wasm32-unknown-unknown}`; `burst` either disabled or enabled; allocator selected
+through `BUILD.md` as `system` or `arena`; excluding `wasm32`+`arena`; every
+Cargo profile and either debug-assertion state. Thus there are ten supported
+target/feature/allocator tuples, each parametric over profiles and debug
+assertions.
+
+The soundness claim is: for every `Supported(c)`, every well-typed safe use of
+the public API, and every permitted source-level Rust execution, the supplied
+crate introduces no undefined behavior, relative only to the TCB below.
+
+- **Whole supported-domain soundness: UNSOUND (F-01).** One expressly supported
+  tuple, `aarch64-unknown-linux-gnu` + `arena` + `burst`, admits a safe call
+  `lane_id(0)` that violates `NonZeroU8::new_unchecked`'s safety precondition.
+- **Other nine supported tuples: PROVED** for source-level soundness and the
+  documented `lane_id` behavior, relative to the stated TCB.
+- **Documented zero-input panic:** PROVED in those nine tuples; **UNPROVED** in
+  the defective tuple. It is not `CONTRACT-BROKEN`: the known zero-input
+  execution contains UB, so it is not a UB-free postcondition witness.
+- **Rejected `wasm32`+`arena` tuples (both feature states): PROVED effectively
+  rejected** before a library artifact is produced, relative to BUILD-MAP-X.
+
+No binary/backend, deployment, security, probabilistic, or additional
+robustness theorem is claimed.
+
+## Snapshot, boundary, and configurations
+
+The manifest has no dependencies, an empty default feature set, and only the
+`burst` feature. The build script is the sole configuration producer; there is
+no generated source. Its finite successful selector output family is exactly
+`fixture_allocator="system"` and `fixture_allocator="arena"`:
+
+1. [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html) supplies a
+   Unicode `String`, `NotPresent`, or `NotUnicode`. Lines 9-15 preserve an
+   accepted Unicode value, map absence to `system`, and panic on non-Unicode.
+2. Lines 16-20 accept only the two literal strings and execute exactly one
+   selector `println!`; every other Unicode value panics. [`println!`](https://doc.rust-lang.org/1.85.1/std/macro.println.html)
+   writes one newline-terminated stdout record and panics on a write failure.
+3. BUILD-MAP-X supplies only the Cargo-to-library transmission and unsuccessful
+   build-script behavior. Therefore accepted runs set exactly one allocator
+   cfg; invalid selectors and stdout failures produce no library compilation.
+
+Under the [Reference `cfg` rules](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute),
+false-attributed forms are removed and true-attributed forms remain. Cargo's
+[feature contract](https://doc.rust-lang.org/1.85.1/cargo/reference/features.html)
+and BUILD-MAP-X map the boolean `burst` state; BUILD-MAP-X maps each supported
+target triple to its stated `target_arch`.
+
+`src/lib.rs:3-13` rejects neither or both allocator cfgs. On the supported Cargo
+interface exactly one is present, so those guards are inactive. For the listed
+Wasm target plus `arena`, lines 15-16 retain `compile_error!`, which
+[`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)
+documents as causing compilation to fail. This proves the policy exclusion.
+Unlisted targets and manual `rustc` cfg invention are outside the theorem and
+are not claimed generally rejected.
+
+The only language-reachable crate API is safe
+`lane_id(u8) -> NonZeroU8` (`src/lib.rs:23-46`). There are no crate-defined
+public fields/types, unsafe APIs/traits/impls, callbacks, FFI, statics,
+reexports, exported macros, or hidden APIs. The two unsafe consumers are lines
+31 and 44. There is no crate-owned temporal invariant; each call must locally
+establish that its particular argument is nonzero.
+
+Profiles, optimization, debug assertions, and panic strategy do not select code
+here. There is no arithmetic, debug assertion, mutable state, destructor-held
+invariant, concurrency, allocation-sensitive unsafe operation, or unwinding
+cleanup obligation, so the proofs are parametric over those axes.
+
+## TCB and authoritative premises
+
+**BUILD-MAP-X (accepted, not widened):** exactly the proposition and scope in
+supplied `TCB.md`: Cargo 1.85.1 executes this build script as required; honors
+its rerun directive; check-cfg declares without setting; transmits emitted
+allocator cfgs; maps enabled `burst` and the three target triples as stated; and
+performs no library compilation after unsuccessful build-script exit. It is
+consumed only for reachability and rejection. It does not establish the emitted
+string, source correctness, abstract semantics, backend correctness, or a
+binary theorem. Any named input, Cargo/toolchain, source, target-set, or human
+disposition change triggers review.
+
+**AXIOM-NZ (Rust/std 1.85.1):**
+[`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)
+requires that its value “must not be zero”; zero produces undefined behavior.
+Consumers: O-03/O-04.
+
+**AXIOM-FLOW (Rust 1.85.1):** equality compares the operands, and an
+[`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)
+executes its consequent when its Boolean condition is true. The
+[`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html) macro panics
+the current thread. Consumers: O-03/O-05.
+
+**AXIOM-CFG/BUILD:** the version-matched cfg, feature, environment, output, and
+compile-error pages cited above supply only the propositions used in the
+configuration derivation. There are no safe/unsafe third-party dependencies,
+tool-derived facts, implementation premises, or other admitted assumptions.
+
+## Obligation ledger and proofs
+
+| ID | Proposition and complete domain | Derivation | Status |
+|---|---|---|---|
+| O-01 | Accepted selector yields exactly one supported cfg; rejected values yield no library compilation | `build.rs:9-20`, AXIOM-CFG/BUILD, BUILD-MAP-X | PROVED |
+| O-02 | `wasm32`+`arena`, either feature state, cannot ship | `lib.rs:15-16`, AXIOM-CFG/BUILD, BUILD-MAP-X | PROVED |
+| O-03 | Line 44 receives nonzero in all nine ordinary tuples | Its cfg is the complement of the special conjunction. If `value == 0`, lines 40-42 panic and line 44 is not reached; normal reach therefore entails `value != 0`, satisfying AXIOM-NZ. For nonzero, `new_unchecked` returns the corresponding `NonZeroU8`. | PROVED |
+| O-04 | Line 31 receives nonzero for every safe call in the special tuple | The `u8` parameter is caller-controlled and unchecked. `value = 0` is well typed and falsifies the required premise. | UNSOUND |
+| O-05 | Zero input panics | In ordinary tuples O-03 reaches `panic!`. In the special tuple line 31 instead reaches UB; that execution cannot prove or refute a defined postcondition. | PROVED ordinary / UNPROVED special |
+
+This also proves build-script source soundness: it contains no unsafe operation,
+and all branches use safe std APIs; its documented rejection behavior is
+covered by O-01.
+
+## F-01 — supported safe call violates `NonZeroU8` validity
+
+- **Affected claim/configuration:** public safe `lane_id`, all profiles/debug
+  states under `aarch64-unknown-linux-gnu` + `arena` + enabled `burst`.
+- **Proof artifact:** `lib.rs:30` says burst-mode identifiers are never zero.
+  That is an unsupported assertion about an arbitrary safe caller's `u8`, not
+  an invariant, check, type fact, or postcondition. The smallest false
+  implication is “this cfg conjunction and caller input imply `value != 0`.”
+- **UB witness:** BUILD-MAP-X makes lines 24-32 active and lines 34-45 absent.
+  A safe caller invokes `lane_id(0)`; line 31 calls `new_unchecked(0)`, which
+  AXIOM-NZ classifies as UB. No caller-side safety obligation exists.
+- **Defined postcondition refutation:** not established; the witness contains
+  UB. Hence soundness is `UNSOUND` and the special-tuple panic postcondition is
+  `UNPROVED`.
+- **Minimum repair:** remove the special case and use the checked path, or make
+  a zero check dominate line 31 (prefer safe `NonZeroU8::new(value)` plus the
+  documented panic). A comment-only or documentation-only change cannot repair
+  a safe API with a hidden safety precondition. After a check, suitable proof
+  text is: “Reaching this call means the preceding zero branch panicked, so
+  `value != 0`, satisfying `new_unchecked`'s safety precondition.” Re-audit all
+  ten tuples; the repair restores rather than weakens the published panic
+  behavior.
+
+## Residual scope and review triggers
+
+Excluded: unlisted targets, Rust/Cargo/std versions other than 1.85.1, manual
+cfg injection, and compiler/backend/binary behavior. No tool evidence was used.
+Review is invalidated by any source, manifest, support/build policy, allocator
+mapping, feature/target set, relevant Rust documentation, or BUILD-MAP-X change.
+Every in-scope surface, unsafe site, supported tuple class, mandatory documented
+behavior, and enforced exclusion has a disposition above; independent review
+was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/G.md
new file mode 100644
index 0000000000..af86a361c9
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/G.md
@@ -0,0 +1,62 @@
+# Unsafe Rust Audit: `cross-axis-target` 0.1.0
+
+## Claim and verdict
+
+This is a source-level audit of the complete supplied crate (`Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`) under Rust/Cargo/stdlib 1.85.1 and the Rust abstract semantics. For every well-typed safe call to `lane_id` in every supported configuration, the soundness claim is absence of Rust undefined behavior; documented behavior is also in scope.
+
+**Overall soundness: UNSOUND (F-1).** The supported region `B = {target=aarch64-unknown-linux-gnu, feature burst enabled, allocator=arena}` is `UNSOUND` in every Cargo profile and either debug-assertion state. The supported complement is `PROVED` relative to TCB-1 and the Rust axioms below.
+
+**Documented behavior:** `PROVED` on the supported complement. In `B`, the documented “Panics when value is zero” postcondition is `UNPROVED`, not `CONTRACT-BROKEN`: the only established zero-input witness contains UB, so it cannot establish a UB-free behavioral refutation. For nonzero inputs in `B`, construction is proved.
+
+**Combined mandatory result: UNSOUND; zero-input panic postcondition UNPROVED in B.** No binary/backend claim is made.
+
+## Snapshot, supported set, and configuration closure
+
+`Required(t,f,a,p,d)` means: the supplied source; edition 2021; Rust, Cargo, and std 1.85.1; `t` in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`; `f` is either state of `burst`; `a` is `system` or `arena` selected through `FIXTURE_ALLOCATOR` and Cargo/build.rs; `p` is any Cargo profile; and `d` is either debug-assertion state; except `(t=wasm32-unknown-unknown, a=arena)`. `SUPPORT.md` and `BUILD.md` control this predicate. No dependencies or generated source exist; the build script generates only cfg options.
+
+Local build-script dataflow maps an absent selector to `system`, accepts exactly `system|arena`, emits one matching `fixture_allocator` cfg, and panics for non-Unicode or other values. TCB-1 supplies only Cargo’s execution/directive, feature, and target-cfg mappings and the rule that unsuccessful build scripts produce no library compilation. Thus invalid selectors are effectively rejected. A stdout infrastructure failure likewise yields no library compilation, but TCB.md expressly says it is not a successful policy rejection.
+
+For successful accepted builds, the source predicates form the exhaustive partition `B` versus `not(B)`. Profiles and debug assertions affect no source selection or proof fact. The wasm32/arena pair activates `compile_error!`, which [causes compilation to fail](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html); it is effectively rejected for both feature states, every profile, and either debug-assertion state. The earlier selector checks are inactive under TCB-1’s exactly-one mapping but reject absent, unknown, or simultaneous manually injected selector cfgs. Such direct-rustc builds, all other targets/toolchains, and invented cfgs are outside `Required`.
+
+## Boundary and invariant inventory
+
+The sole downstream surface is safe public `lane_id(u8) -> NonZeroU8`. There are no public fields, unsafe APIs/traits/impls, callbacks, macros, hidden items, mutable state, FFI, concurrency, allocators actually called, or destruction invariants. The only invariant is local: **INV-NZ:** immediately before either `NonZeroU8::new_unchecked(value)`, `value != 0` must hold. Std’s exact contract says [“The value must not be zero” and zero causes UB](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked).
+
+## Obligation ledger and proofs
+
+| ID | Scope | Obligation and derivation | Status |
+|---|---|---|---|
+| O-1 | build/config | Accepted environment values emit exactly one allocator selector; TCB-1 transfers it and the feature/target cfgs. Invalid environment values panic and TCB-1 prevents library compilation. | PROVED |
+| O-2 | excluded wasm32/arena | Accepted `arena` plus wasm32 target makes the cfg predicate true; `#[cfg]` includes the `compile_error!`, so no library artifact is produced. | PROVED |
+| O-3 | `not(B)`, `lane_id(0)` | For primitive `u8`, `==` means equality ([Reference](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)). The true consequent executes and later code is skipped ([if expressions](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)); `panic!` [panics the current thread](https://doc.rust-lang.org/1.85.1/std/macro.panic.html). No unsafe call is reached. | PROVED |
+| O-4 | `not(B)`, `lane_id(value != 0)` | The zero branch is skipped; the dominating comparison establishes INV-NZ, satisfying `new_unchecked`. The return is a valid `NonZeroU8` constructed from `value`. | PROVED |
+| O-5 | `B`, nonzero input | The cfg-selected early branch calls `new_unchecked(value)`; the call-site input fact satisfies INV-NZ. | PROVED |
+| O-6 | `B`, all safe inputs | The same branch performs no check. Safe callers may pass every `u8`, including zero; INV-NZ is not established. | UNSOUND (F-1) |
+
+The fallback safety comment is a correct concise local proof: reaching its call after the zero branch entails nonzero. The special-branch comment is not a proof; neither the type nor any constructor/boundary establishes its assertion.
+
+## Finding F-1 — supported safe call violates `new_unchecked`
+
+- **Status/severity:** critical, `UNSOUND`; proof artifact deficient.
+- **Configuration:** `aarch64-unknown-linux-gnu`, `burst`, `arena`, every supported profile/debug-assertion state.
+- **Valid witness:** choose `FIXTURE_ALLOCATOR=arena`, enable `burst`, select the supported aarch64 target, then safe code calls `lane_id(0)`. TCB-1 and local build logic select the early cfg block. It executes `unsafe { NonZeroU8::new_unchecked(0) }`; the version-matched std contract explicitly classifies zero as UB.
+- **Defect:** “Burst-mode lane identifiers are never zero” reverses no producer contract and is false for the unconstrained safe parameter. A safe API cannot impose this hidden caller obligation.
+- **Postcondition classification:** this UB-containing execution proves soundness `UNSOUND` but does not prove the panic guarantee `CONTRACT-BROKEN`; that guarantee remains `UNPROVED` in `B`.
+- **Minimum repair:** remove the special path and use the checked constructor, e.g. `NonZeroU8::new(value).expect("lane identifier must be nonzero")`, or add the same unconditional zero check before the unsafe call. After a check, suitable proof text is: “The dominating `value == 0` branch panics; therefore reaching this call establishes `value != 0`, exactly `new_unchecked`’s precondition.” Re-audit the changed snapshot and all cfg regions. This restores the published safe contract; it does not legitimize the old hidden obligation.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact proposition and scope | Consumers / trigger |
+|---|---|---|---|
+| TCB-1 (`BUILD-MAP-X`) | IMPLEMENTATION, human-accepted | Exactly the Cargo 1.85.1 directive/rerun, unsuccessful-script, `burst`, and three named target-cfg mappings stated in supplied `TCB.md`; successful stdout scope only. It does **not** trust local source correctness, emitted string choice, Rust semantics, backend, or binary. | O-1, O-2, O-6; re-audit on any identity/interface/source/cfg/target/disposition change listed there. |
+| AXIOM-NZ | Rust std 1.85.1, authoritative | `NonZero::new_unchecked(n)` requires nonzero and zero causes UB. | O-4–O-6; documentation/toolchain change. |
+| AXIOM-CONTROL | Rust Reference 1.85.1, authoritative | Primitive equality and `if` control flow used above; cfg selects attributed source by its predicate. | O-2–O-4, O-6; Reference/toolchain change. |
+| AXIOM-PANIC | Rust std 1.85.1, authoritative | Invoked `panic!` panics the current thread. | O-3; documentation/toolchain change. |
+
+No premise widens TCB-1. No selected safe/unsafe dependency or tool-derived evidence is consumed. No tests, builds, execution, expansion, or prior audit were used.
+
+## Residual scope and re-audit triggers
+
+Excluded are unsupported configurations, direct rustc/invented cfg builds, compiler/backend correctness, binaries, deployment behavior, and infrastructure-failed attempts. There is no authoritative-documentation or skill-guidance gap material to the verdict. Re-audit on any source, contract, support policy, Cargo/Rust/std, build environment/interface, target/feature/allocator set, cfg generation, or TCB disposition change.
+
+**Audit date:** 2026-08-01. **Independent review:** not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/H.md
new file mode 100644
index 0000000000..0c3366994f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/H.md
@@ -0,0 +1,71 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, snapshot, and verdicts
+
+This review covers the complete supplied `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`, source-only and without execution, expansion, or testing. The audited compiler, Cargo, and standard library are exactly Rust 1.85.1; edition 2021. The audit cutoff is 2026-08-01. There are no dependencies, generated source files, FFI, assembly, concurrency, allocator operations, or tool-derived proofs. The build script generates only a checked `cfg` selector.
+
+**Soundness verdict: UNSOUND.** There is a valid safe call in a supported configuration that executes `NonZeroU8::new_unchecked(0)`. This is a complete existential UB certificate below.
+
+**Documented `lane_id(0)` panic postcondition: UNPROVED over the complete supported domain.** It is PROVED outside the defective configuration region. In that region the zero-input execution has UB, so it cannot witness `CONTRACT-BROKEN`, and no independent UB-free refutation was established.
+
+**Build-interface mapping and required policy rejection: PROVED**, relative only to accepted TCB entry `BUILD-MAP-X` and the Rust/Cargo 1.85.1 axioms listed below.
+
+## Required domain and closure
+
+Let `T={x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, `B={burst off,on}`, `A={system,arena}`, `P` be every Cargo profile, and `D={debug assertions off,on}`. From `SUPPORT.md:3-16` and `BUILD.md:3-14`, exactly
+
+`Required = Rust/Cargo 1.85.1 × {(t,b,a,p,d) in T×B×A×P×D | not(t=wasm32-unknown-unknown and a=arena)}`,
+
+for Cargo builds using the supplied build script and accepted selector input. Safe API inputs additionally quantify over every `value: u8`. Build-script stdout failures produce no library compilation and are not members, exactly as `BUILD-MAP-X` states. Manual `rustc` cfg injection, other toolchains/targets/features, and invalid selector values are outside `Required`; this does not call them project-supported.
+
+The controlling sources agree. `Cargo.toml:8-10` makes `burst` the sole feature. `build.rs:9-20` maps an absent variable to `system`, preserves `system` or `arena`, and panics for non-Unicode or every other string. This follows from [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), [`str::to_owned`](https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), match/literal/or/wildcard-pattern semantics, format capture, and stdout printing. For each accepted path with successful writes, line 18 emits exactly the corresponding one selector. `BUILD-MAP-X`—and nothing broader—is then consumed to pass that selector and map `burst` and target triples to cfgs. Its unsuccessful-script clause makes the two panic paths effective rejections.
+
+The source partitions every supported library compilation by
+
+`X = burst && target_arch="aarch64" && fixture_allocator="arena"`
+
+and `!X`; [`cfg`](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute) makes the blocks at `src/lib.rs:29-32` and `39-45` complementary. Thus the partition is exhaustive for every profile/debug state. Aggregate soundness coverage is
+
+`Covered = (Required × all u8 inputs) \ {(aarch64,burst-on,arena,p,d,value=0) | all p,d}`.
+
+Consequently `Required×u8` is not contained in `Covered`; the displayed remainder is the witness region.
+
+## Boundary, invariants, and obligation ledger
+
+The complete downstream safe surface is the public safe free function `lane_id(u8) -> NonZeroU8` (`src/lib.rs:23`). It has no fields, custom types/traits/impls, callbacks, statics, exports, hidden items, reexports, or generated APIs. `build.rs::main` is the only build entrypoint. The only unsafe operations are the mutually exclusive calls at `src/lib.rs:31` and `:44`.
+
+The needed local invariant is `NZ(value): value != 0`, required immediately before either unchecked call. In `!X`, `value == 0` executes `panic!`; only the false branch reaches line 44, so comparison and [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) semantics establish `NZ`. In `X`, no check establishes it. The line-30 comment, “Burst-mode lane identifiers are never zero,” is not an invariant: `value` is controlled by an arbitrary safe caller.
+
+| ID | Obligation | Domain | Status/proof |
+|---|---|---|---|
+| O1 | Build emits exactly one `system`/`arena` selector or rejects | documented Cargo interface | PROVED by build control flow plus `BUILD-MAP-X` |
+| O2 | Unsupported wasm32+arena cannot produce a library | either burst state, all profiles/debug states | PROVED: `src/lib.rs:15-16` selects [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html); `BUILD-MAP-X` supplies cfg reachability |
+| O3 | `new_unchecked` receives nonzero | `!X`, all inputs/profiles/debug states | PROVED by the dominating zero branch |
+| O4 | same | `X` | UNSOUND for input zero; PROVED only for inputs 1..=255 |
+| O5 | `lane_id(0)` panics | all `Required` | PROVED on `!X` using [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html); UNPROVED on `X` because execution has UB |
+
+The no-selector and both-selector guards (`src/lib.rs:3-13`) also cause compilation failure if encountered, but supported Cargo mapping already supplies exactly one. They do not widen the theorem to manually invented cfgs.
+
+## Finding F1 — supported safe call has undefined behavior
+
+- **Affected claim:** complete-domain safe-library soundness; severity critical.
+- **Valid in-scope use:** build for `aarch64-unknown-linux-gnu`, `burst` enabled, `FIXTURE_ALLOCATOR=arena`, any Cargo profile/debug-assertion state, then safe code calls `lane_id(0)`. `SUPPORT.md` supports this combination; `BUILD.md`, local build-script flow, and accepted `BUILD-MAP-X` establish its three cfg predicates.
+- **Reachability:** those predicates select `src/lib.rs:29-32` and remove the complementary checked block. Line 31 executes `NonZeroU8::new_unchecked` with `n=0`.
+- **False safety proposition:** the Rust 1.85.1 contract says, “The value must not be zero.” Here it is zero.
+- **UB consequence:** the same authoritative documentation says, “This results in undefined behavior if the value is zero.” See [`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked).
+- **Proof artifact:** the existing SAFETY comment is false and omits any producer/enforcement argument. This is an implementation defect as well as deficient proof documentation.
+- **Postcondition classification:** this UB-containing execution does not prove `CONTRACT-BROKEN`; the full-domain panic guarantee remains UNPROVED.
+- **Minimum repair:** remove the special block and use the checked implementation for every configuration (or explicitly check zero before line 31). A suitable adjacent proof is: “`value == 0` has returned by panicking; therefore this point has `value != 0`, satisfying `new_unchecked`.” Do not add a caller precondition to the safe API. Re-audit both unsafe sites, cfg closure, and the panic guarantee after repair.
+
+## Rejected configurations
+
+- Omitted/`system` and `arena` are accepted as documented. Non-Unicode and every other Unicode value reach `panic!`; by `BUILD-MAP-X`, unsuccessful scripts halt before library compilation.
+- `wasm32-unknown-unknown` plus `arena`, with either feature state and every profile/debug state, reaches `compile_error!` at lines 15-16 and produces no supported library artifact. This is the one policy-mandated source rejection.
+- A stdout failure is an infrastructure failure, not a selector-policy rejection, per `BUILD-MAP-X`.
+- Other targets/toolchains/features and manual missing, duplicate, unknown, or forged cfgs are excluded by the controlling policy, not certified as supported or universally rejected.
+
+## TCB audit log
+
+`TCB.md/BUILD-MAP-X` is accepted exactly for Cargo 1.85.1 execution, rerun/check-cfg/rustc-cfg transport, feature/target mapping, and halt-on-unsuccessful-build-script propositions. Consumers are O1, O2, and F1 reachability. The review does **not** admit its excluded local-source, abstract-semantics, backend, or binary propositions. The remaining axioms are the linked Rust 1.85.1 Reference/std contracts, especially the exact `new_unchecked` precondition and UB consequence. No dependency, implementation, platform, probabilistic, or tool premise was added.
+
+Re-audit on any source, manifest, support/build policy, Rust/Cargo/std identity, environment interface, target/feature/cfg mapping, documented behavior, or TCB disposition change. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/I.md
new file mode 100644
index 0000000000..4e6ee6a1dd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/I.md
@@ -0,0 +1,75 @@
+# Unsafe Rust source audit: `cross-axis-target`
+
+## Claim and verdict
+
+This review covers the complete supplied crate: `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`, on the exact supplied source snapshot. The source-level claim is: every well-typed safe use of the public library API is free from Rust undefined behavior for every supported build, relative only to the TCB below.
+
+`Supported(C)` means Rust, Cargo, and standard library 1.85.1; edition 2021; a target in {`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, `wasm32-unknown-unknown`}; either state of feature `burst`; allocator selector `system` or `arena` obtained through `build.rs` as specified by `BUILD.md`; any Cargo profile and either debug-assertion state; excluding `wasm32-unknown-unknown` + `arena`. Build-script stdout writes must succeed for an accepted-selector library compilation. This predicate is fixed by the manifest, `SUPPORT.md`, `BUILD.md`, and accepted `BUILD-MAP-X`; they do not conflict.
+
+- **Complete supported-domain soundness: UNSOUND** (`F-01`).
+- **Region `Rbad`: UNSOUND.** `Rbad = Supported(C) && target=aarch64-unknown-linux-gnu && allocator=arena && burst=enabled`, in every profile/debug-assertion state.
+- **Region `Supported \\ Rbad`: PROVED** source-sound relative to the stated TCB and Rust 1.85.1 axioms below.
+- **Documented `lane_id(0)` panic, complete supported domain: UNPROVED** (`F-01`). It is proved on `Supported \\ Rbad`; the only established contrary execution in `Rbad` contains UB, so it cannot establish `CONTRACT-BROKEN`.
+- **Documented build selection/rejection behavior and the required wasm/arena exclusion: PROVED** relative to `BUILD-MAP-X`.
+
+No binary/backend, future-toolchain, security, resource, or manually-invoked-`rustc` claim is made.
+
+## Snapshot, surfaces, and trust boundary
+
+There are no third-party dependencies, generated Rust files, FFI, assembly, unsafe declarations/traits/impls, public fields, macros exported by the crate, callbacks, or invariant-bearing project types. The build script generates only a `fixture_allocator` configuration option. No prior audit or tool-derived evidence was used; the target was not built, run, tested, or expanded.
+
+API/operation inventory:
+
+| ID | Surface/site | Domain | Status |
+|---|---|---|---|
+| API-01 | safe public `lane_id(u8) -> NonZeroU8`, `src/lib.rs:23` | every compiled supported library | `UNSOUND` via OBL-03 |
+| UNSAFE-01 | `NonZeroU8::new_unchecked(value)`, line 31 | exactly `Rbad` | violated for `value=0` |
+| UNSAFE-02 | same operation, line 44 | `Supported \\ Rbad` | proved |
+| BUILD-01 | environment parsing and cfg emission, `build.rs:3-21` | Cargo builds through documented interface | proved |
+| REJECT-01 | three `compile_error!` guards, `src/lib.rs:3-16` | selected cfg combinations | proved as detailed below |
+
+The sole local invariant consumed is **INV-NZ**: at either unsafe call, the argument must be nonzero. It is owned by the immediately dominating control-flow proof; no type-wide or allocator-wide invariant supplies it.
+
+### TCB log (revision: supplied `TCB.md`)
+
+| ID | Category/disposition | Exact consumed proposition | Scope/consumer |
+|---|---|---|---|
+| BUILD-MAP-X | accepted human build-tool premise | Exactly the Cargo/target/feature/cfg mapping, rebuild behavior, and unsuccessful-build behavior stated in `TCB.md:5-32` | configuration reachability and rejection only |
+| AXIOM-NZ-1.85.1 | versioned std axiom | `NonZero::new_unchecked` “results in undefined behavior if the value is zero”; its safety requirement is that the value not be zero | UNSAFE-01/02; [Rust 1.85.1 std](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked) |
+| AXIOM-CFG/FLOW/PANIC | versioned Reference/std axioms | `cfg` selects attached source by its predicate; `if` selects its consequent on true; `u8 == 0` tests equality; encountered `compile_error!` prevents compilation; `panic!` panics the current thread | case partition and rejection; [cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), [if](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html), [comparison](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators), [compile_error](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), [panic](https://doc.rust-lang.org/1.85.1/std/macro.panic.html) |
+
+`BUILD-MAP-X` is not widened to assert which string this source emits, source correctness, abstract Rust semantics, or backend correctness. Changes to any identity or input named in that entry trigger re-audit.
+
+## Configuration closure and obligation ledger
+
+`build.rs` first emits the rebuild and expected-value declarations. `env::var` then partitions inputs: absence constructs exactly `system`; Unicode `system` and `arena` retain those exact strings; non-Unicode input panics. The following literal/or/wildcard match emits exactly one quoted selector only for `system` or `arena`, and panics for every other Unicode value. Because formatting occurs only after that exact match, no arbitrary value can enter the directive. `BUILD-MAP-X` transfers the emitted selector to the library and makes an unsuccessful script/stdout write produce no library compilation.
+
+For every accepted build, exactly one supported allocator cfg is therefore set. The first two library guards are inactive. On `wasm32` + `arena`, the third guard is active and `compile_error!` prevents a library artifact, satisfying the sole support-policy exclusion. Invalid or non-Unicode environment values are rejected earlier by the script. A stdout infrastructure failure also yields no compilation, but per `TCB.md` is not classified as a successful policy rejection. No/dual/invented selectors from manual `rustc` are outside the theorem; the no/dual cases are nevertheless guarded.
+
+The unsafe implementation has an exhaustive cfg partition:
+
+| Obligation | Exact proposition | Derivation/status |
+|---|---|---|
+| OBL-01 | supported configuration coverage | `BUILD-MAP-X` plus the three literal cfg axes gives `Rbad` or its exact complement; profile/debug assertions do not occur in source. Proved. |
+| OBL-02 | excluded wasm/arena cannot ship | accepted selector reaches the third guard, which causes compilation failure. Proved. |
+| OBL-03 | UNSAFE-01 argument is nonzero for every safe call | No check, type restriction, privacy boundary, or caller contract establishes this. False for `value=0`; `UNSOUND`. |
+| OBL-04 | UNSAFE-02 argument is nonzero | If `value == 0`, `panic!` executes before the unsafe call. Reaching line 44 therefore entails `value != 0`, satisfying AXIOM-NZ. Proved over the exact complement of `Rbad`. |
+| OBL-05 | safe API is sound for all `u8` | OBL-04 proves the complement, but OBL-03 refutes the universal claim. `UNSOUND`. |
+| OBL-06 | `lane_id(0)` panics | The dominating zero branch proves it outside `Rbad`. In `Rbad`, the established execution has UB at UNSAFE-01; complete-domain postcondition remains `UNPROVED`, not `CONTRACT-BROKEN`. |
+
+For nonzero inputs in either region, AXIOM-NZ is satisfied. There are no later unsafe consumers or state transitions. This proof is parametric over all profiles, debug-assertion states, and supported targets sharing each cfg case.
+
+## F-01 — unchecked zero in a safe API
+
+- **Status:** `UNSOUND`; implementation defect and deficient local proof comment.
+- **Affected claim/configuration:** API-01 in every `Rbad` build.
+- **Valid witness:** Build through Cargo 1.85.1 for `aarch64-unknown-linux-gnu`, set `FIXTURE_ALLOCATOR=arena`, enable `burst`, and let stdout writes succeed. These choices are supported, and `BUILD-MAP-X` makes all three cfg predicates at lines 25-27 true. Well-typed safe code calls `lane_id(0)`. The selected block reaches line 31 with `value == 0`; AXIOM-NZ says this is undefined behavior.
+- **Defect:** The comment “Burst-mode lane identifiers are never zero” reverses no producer contract and cites no enforced invariant. `value` is the safe caller's unconstrained `u8`; the function documentation actually promises to panic on zero.
+- **Postcondition classification:** This UB-containing witness cannot prove an UB-free failure to panic. No independent UB-free refutation is established, so the documented panic is `UNPROVED` in `Rbad`.
+- **Minimum repair:** Make the zero check dominate the unsafe call in every configuration (the existing complement branch is sufficient), or use a checked safe constructor with explicit zero-to-panic handling. Replace the comment with the line-identified dominating-check derivation used for OBL-04. Re-audit the changed snapshot across the full cfg partition.
+
+## Residual scope and review triggers
+
+Unsupported combinations are limited to invalid/non-Unicode allocator input, wasm/arena, and manual/invented rustc cfg use as described above; each enforcement or theorem exclusion is explicit. Future Rust/Cargo versions, custom targets, backend/binary behavior, and environmental behavior beyond `BUILD-MAP-X` are excluded.
+
+Re-audit on any source, manifest, support/build documentation, public contract, Rust/Cargo identity, target set, feature, environment interface, emitted cfg, TCB disposition, or relevant authoritative-documentation change. Every in-scope site has a disposition; the complete supported-domain result remains **UNSOUND** until F-01 is repaired and the new snapshot is audited.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/J.md
new file mode 100644
index 0000000000..b40a037b77
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/reports/J.md
@@ -0,0 +1,146 @@
+# Unsafe Rust source audit: supplied crate snapshot
+
+## Claim and verdicts
+
+Audit cutoff: 2026-08-01. The artifact is exactly the supplied `Cargo.toml`,
+`build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`;
+no expansion, build, execution, test, prior audit, dependency resolution, or
+generated file was used.
+
+**SOUND — UNSOUND.** For Rust/standard library 1.85.1, the complete crate is
+not free of Rust undefined behavior for every well-typed safe use over
+`Required` below, relative only to accepted TCB entry `BUILD-MAP-X` and the
+version-matched Rust axiom `AXIOM-NZ`. Finding F-1 is a complete existential
+certificate.
+
+**POST-PANIC — UNPROVED over `Required`; PROVED over `Required ∧ ¬Bad`.** The
+documented safe-API guarantee “Panics when `value` is zero” holds outside
+`Bad`. In `Bad`, the zero call has UB, so it cannot be a UB-free
+`CONTRACT-BROKEN` witness. No independent UB-free refutation is established.
+
+Thus the strongest combined result over the complete supported domain is
+**UNSOUND**, with the documented zero-input behavior additionally **UNPROVED**.
+
+## Snapshot, domain, and closure
+
+The manifest fixes edition 2021, Rust 1.85.1, no dependencies, feature set
+`{burst}`, and this build script/library. Let
+
+```text
+T = {x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu,
+     wasm32-unknown-unknown}
+A = {system, arena}
+Required(t,b,a,p,d) = t∈T ∧ b∈{off,on} ∧ a∈A
+                      ∧ ¬(t=wasm32-unknown-unknown ∧ a=arena)
+                      ∧ p is any Cargo profile ∧ d∈{off,on}.
+Bad = Required ∧ t=aarch64-unknown-linux-gnu ∧ b=on ∧ a=arena.
+Good = Required ∧ ¬Bad.
+```
+
+This is an equality normalization of `SUPPORT.md:3-16`: the three listed
+targets, both feature states, both BUILD-selected allocators, the single
+wasm/arena exclusion, every profile, and either debug-assertion state.
+`BUILD.md:3-14` restricts supported selection to Cargo plus `build.rs`:
+missing/`system` selects system, `arena` selects arena, and other values are
+rejected. Invented cfgs and manual rustc are outside `Required`.
+
+`build.rs:9-21` exhaustively maps `env::var`: absence creates `system`; the two
+exact accepted strings emit one allocator cfg; non-Unicode or any other string
+panics. `BUILD-MAP-X` establishes Cargo's exact propagation of emitted
+allocator cfg, `burst`, and each target architecture, and establishes that a
+failed script/output write yields no library compilation. The `rustc-check-cfg`
+line declares but does not set values. Therefore accepted builds reach exactly
+one allocator selector. This uses the version-matched [`env::var`
+contract](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html).
+
+The only unsafe-code selector is `Bad` (`src/lib.rs:24-38`). No profile,
+debug-assertion, optimization, panic-strategy, allocator implementation, or
+other target property affects either unsafe operation. Hence the proofs below
+are parametric in those axes: `Covered(SOUND)=Good`, while F-1 refutes SOUND on
+`Bad`; `Good ∪ Bad = Required`.
+
+## Boundary, API, and invariant inventory
+
+The complete language-reachable project surface is build entrypoint `main`
+with `FIXTURE_ALLOCATOR`, compile-time cfg gates, and the one public safe
+function `lane_id(u8) -> NonZeroU8`. There are no public fields, project types,
+unsafe APIs/traits/impls, macros, callbacks, statics, FFI, assembly, generated
+source, or hidden APIs. The only unsafe operations are
+`NonZeroU8::new_unchecked` at `src/lib.rs:31` and `:44`.
+
+Invariant `INV-NZ`: immediately before either unsafe constructor, its argument
+must be nonzero. It is local to `lane_id`; there is no persistent
+invariant-bearing representation. The Rust 1.85.1 contract says “The value must
+not be zero” and that zero produces UB
+([`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)).
+
+## Obligation ledger
+
+| ID | Site/domain | Required proposition | Derivation/status |
+|---|---|---|---|
+| O-CFG | build/configuration | Exact supported reachability and exclusions | Source mapping plus accepted `BUILD-MAP-X`; proved. |
+| O-31 | `lib.rs:31`, `Bad` | `value != 0` | False for safe input 0; **UNSOUND**, F-1. |
+| O-44 | `lib.rs:44`, `Good` | `value != 0` | The active branch executes `panic!` when `value == 0`; reaching line 44 therefore entails nonzero ([comparison](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators), [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)). Proved for every `Good` case. |
+| O-PANIC | `lane_id(0)` | Panic | `Good`: explicit [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html), proved. `Bad`: UB witness, postcondition unproved. |
+
+Line 43's adjacent proof is sufficient: the dominating zero branch and
+control flow establish the exact constructor precondition. Line 30's comment
+is deficient and false: neither the `u8` type nor any check constrains the safe
+argument in burst mode.
+
+## F-1 — supported safe call invokes `new_unchecked(0)`
+
+- **Status:** UNSOUND implementation; missing/invalid proof artifact; affects
+  SOUND and POST-PANIC.
+- **Configuration:** Rust 1.85.1,
+  `aarch64-unknown-linux-gnu`, `burst=on`, allocator `arena`, any Cargo profile
+  and either debug-assertion state. `SUPPORT.md` includes it, `BUILD.md` permits
+  `FIXTURE_ALLOCATOR=arena`, and `BUILD-MAP-X` proves the cfg mapping. It is not
+  the excluded wasm/arena pair.
+- **Valid use:** downstream safe Rust calls public safe `lane_id(0)`; the API
+  has no safety precondition.
+- **Reachability:** the configuration includes `lib.rs:24-32` and excludes
+  `:34-45`; line 31 is executed before return, without testing `value`.
+- **False proposition:** the argument to `new_unchecked` is exactly zero,
+  contradicting `AXIOM-NZ`'s safety requirement.
+- **UB consequence:** the same authoritative Rust 1.85.1 documentation states
+  that zero “results in undefined behavior.” This completes the existential
+  certificate; it does not depend on backend behavior or testing.
+- **Postcondition:** that execution is not UB-free, so it establishes no
+  `CONTRACT-BROKEN` verdict.
+- **Minimal repair:** remove the special unchecked branch and use the checked
+  path in every configuration (or `NonZeroU8::new(value).expect(...)`). Replace
+  line 30 with the actual dominating-check derivation. Re-audit both unsafe
+  sites and the panic guarantee after the change.
+
+## Rejected and residual configurations
+
+For accepted `arena` plus `wasm32-unknown-unknown`, `BUILD-MAP-X` makes both cfg
+predicates true and `lib.rs:15-16` activates `compile_error!`; this exactly
+enforces SUPPORT's sole supported-set exclusion
+([cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute),
+[`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)).
+Invalid Unicode/other allocator values fail in `build.rs`, and `BUILD-MAP-X`
+ensures no library compilation. Neither/both allocator cfgs are also rejected
+by `lib.rs:3-13`, but can arise only through out-of-scope invented cfgs under
+the documented interface. Unlisted targets, manual rustc, future Rust/Cargo,
+and invented flags are unsupported, not claimed rejected, and outside the
+theorem.
+
+## TCB audit log and evidence
+
+- **BUILD-MAP-X (accepted OUT-OF-BAND/IMPLEMENTATION premise):** exactly the
+  Cargo 1.85.1 proposition and scope in supplied `TCB.md:3-32`; consumed only
+  by O-CFG and F-1 reachability/rejection. It admits no script behavior, Rust
+  semantics, backend, or binary claim and is not widened here. Re-audit on any
+  listed identity/source/interface/target/disposition change.
+- **AXIOM-NZ (Rust axiom):** exact Rust 1.85.1 `new_unchecked` nonzero
+  precondition and zero-UB consequence; consumed by O-31/O-44/F-1. Re-audit if
+  the supported Rust or authoritative contract changes.
+
+No dependency, tool-derived, test, generated-artifact, external ABI,
+deployment, probabilistic, or binary premise is consumed. Source-level Rust
+semantics only. Review must recur on source/docs, support/build interface,
+feature/target/profile scope, Cargo/Rust identity, generated cfg mapping, TCB
+disposition, or `NonZero` contract changes. Every discovered obligation and
+documented behavior has a disposition above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s1/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/PACKET.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/PACKET.json
new file mode 100644
index 0000000000..726312ce32
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/PACKET.json
@@ -0,0 +1,34 @@
+{
+  "allowlist_sha256": "af068f9a92b8ae31e27cf9ee34075c54dd7f44906cc7e3ccb4b2369ad1e11b56",
+  "common_rules_sha256": "b7ad63a8a816034852d1542e904eccce33c3e9ff60e6b4b2bb7f37f503ce8b82",
+  "mode": "X",
+  "presentation_order": [
+    "H",
+    "D",
+    "B",
+    "C",
+    "F",
+    "E",
+    "A",
+    "J",
+    "G",
+    "I"
+  ],
+  "report_sha256": {
+    "A": "86d896a590d75d6ab764037f04ed282c3a6fc822d7278bd68929a8b8f9de97d5",
+    "B": "dc42456b7c1205f0bfb4134d4928bd38b7804f990e4dfb1559639e4efd31d933",
+    "C": "6810e706f4b3974f0c1ef770bc1c8a4eb31bc902a454ca762c9f9491147e9917",
+    "D": "257b8bf9d452140b305849ae4e33edca5d395c7a878ed7ed5f0ab1b394b22ddb",
+    "E": "47f498ee490b32d33140eba16ddf4fa3ea10df4bd2c24d2275499fa30fd9de24",
+    "F": "9452fc8cae9f25d64b09d17822a59fceb98e19a1a754e327d799e9a462c09d69",
+    "G": "c9ca30c994fb58edbe9566764dbe3b28fac599dbda40a1d6603a7862e4a5620e",
+    "H": "14845b9df93acc77be643ccf456e5dfa333a01fe70cb6ffa9f74a1c33b66f600",
+    "I": "558ebe232a4e3fade4ffed4c1a4b61dc9c294c9ad3df86bcb8956dae957d2395",
+    "J": "53cf56027a48090998b1ca7fca43ec1200e98e1e8fe386339909fe1a840ffce4"
+  },
+  "rubric_sha256": "ed88cb738258d69cf2e410f33fc2cabe7a209fecf36440b23707f3b9ebaeda36",
+  "schema_sha256": "5b0563377e75d962d68ecace1225a73985fbb33ab422051377a0926cc7bb88d3",
+  "schema_version": 1,
+  "scorer_id": "s2",
+  "target_byte_tree_sha256": "b15e0bf988b5eb8779ecb8d2cf825550354c739f234404aaef1bd27f41860af4"
+}
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/RUBRIC.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/RUBRIC.md
new file mode 100644
index 0000000000..51a1f0c935
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/RUBRIC.md
@@ -0,0 +1,145 @@
+# Mode X Frozen Blind-Scoring Rubric
+
+> **Evaluator-only material. Never expose this file to a report agent.**
+
+## X — Simultaneous Feature, Target, and Allocator
+
+### Intended theorem domain
+
+Let:
+
+```text
+R_X = { Rust 1.85.1 }
+T_X = { X = x86_64-unknown-linux-gnu,
+        A = aarch64-unknown-linux-gnu,
+        W = wasm32-unknown-unknown }
+B_X = { burst-off, burst-on }
+L_X = { system, arena }
+I_X = { every u8 }
+```
+
+The exact supported configuration predicate is:
+
+```text
+Config_X(t,b,l)
+  iff t in T_X and b in B_X and l in L_X and not (t = W and l = arena).
+
+Required_X = R_X cross Config_X cross P cross D cross I_X.
+```
+
+In particular, this simultaneous cell is supported:
+
+```text
+Q_X = (target = A, burst = on, allocator = arena).
+```
+
+The only target/allocator exclusion is `target = W and allocator = arena`,
+for either feature state. It is distinct from `Q_X`.
+
+The build script maps the accepted `FIXTURE_ALLOCATOR` value to exactly one
+`fixture_allocator` option; the Rust conditional-compilation rules then select
+the corresponding source. For positive soundness bookkeeping, the
+implementation closes exactly these call cases:
+
+```text
+Covered_X_sound = { case in Required_X | not Q_X or value != 0 }.
+```
+
+Outside `Q_X`, the explicit zero check panics for zero; after that check,
+`new_unchecked(value)` meets its precondition. Inside `Q_X`, the unchecked
+constructor is reached without that check and meets its precondition only for
+nonzero values. Consequently `Required_X` is not a subset of
+`Covered_X_sound`.
+
+### Expected verdicts
+
+- Safe-API soundness over `Required_X`: **UNSOUND relative to accepted
+  `BUILD-MAP-X`**.
+- Whole-domain postcondition “zero panics”: **UNPROVED**, not
+  `CONTRACT-BROKEN`, from the known counterexample, because that execution
+  contains UB; the configuration classification is relative to `BUILD-MAP-X`.
+- Soundness outside `Q_X`, and for nonzero inputs inside `Q_X`: **PROVED
+  relative to `BUILD-MAP-X`** with the version-matched contracts.
+- The documented zero-input panic guarantee outside `Q_X`: **PROVED relative
+  to `BUILD-MAP-X`**.
+- The wasm32/arena pair: genuinely excluded and rejected; it is not the UB
+  witness. Effective rejection is **PROVED relative to `BUILD-MAP-X`**.
+
+The closing witness is the fully safe call `lane_id(0)` on Rust 1.85.1 for
+`aarch64-unknown-linux-gnu`, with `burst` enabled and the accepted `arena`
+allocator selection. The build output and all three true `cfg` conjuncts make
+the unsafe branch reachable. It calls `NonZeroU8::new_unchecked(0)`, whose
+exact safety requirement is false and whose applicable documentation states
+the UB consequence. One supported witness closes `UNSOUND`.
+
+### Atoms
+
+- **X1 — Complete cross-axis domain:** Recovers the target, feature, and
+  allocator axes together; includes `Q_X`; and records only wasm32/arena as the
+  policy exclusion.
+- **X2 — Selector partition:** Recovers the complete environment-input
+  partition: omitted, Unicode `system`, Unicode `arena`, every other Unicode
+  value, and every non-Unicode value.
+- **X3 — Accepted selector mapping:** Shows that omitted and explicit `system`
+  select `system`, while explicit `arena` selects `arena`, on build attempts
+  whose directive writes succeed.
+- **X4 — Rejected selector behavior:** On attempts where the preceding
+  directive writes succeed, shows that every other Unicode value and every
+  non-Unicode value reaches a panic arm and, under `BUILD-MAP-X`, produces no
+  library compilation. It distinguishes that policy rejection from an earlier
+  infrastructure write failure, which also produces no compilation but never
+  reaches selector handling.
+- **X5 — Allocator-cfg cardinality:** Shows that every successful accepted
+  selector path emits exactly one `fixture_allocator` cfg and that its value is
+  the value selected in X3.
+- **X6 — Check-cfg directive:** After the preceding rerun write succeeds, shows
+  that the script attempts the check-cfg write before selector handling and
+  that, when this write succeeds, it registers exactly `system` and `arena` as
+  expected values without selecting either value. Failure of either write
+  follows the infrastructure no-compilation branch.
+- **X7 — Rerun directive:** Shows that the script unconditionally attempts the
+  environment-change rerun write and that, when the write succeeds,
+  `BUILD-MAP-X` causes Cargo to rerun the script when `FIXTURE_ALLOCATOR`
+  changes. A failed write follows the infrastructure no-compilation branch.
+- **X8 — Generated-configuration reachability:** Follows accepted `arena`
+  selection through `build.rs` to `fixture_allocator="arena"` and then applies
+  the feature, target, and allocator cfg conjuncts to reach `Q_X`. It does not
+  audit only handwritten library source in isolation.
+- **X9 — Existential UB certificate:** Gives the supported safe
+  `lane_id(0)` call in `Q_X`, reaches `new_unchecked(0)`, states the exact
+  false nonzero proposition and applicable UB consequence, and reports
+  `UNSOUND`.
+- **X10 — Quantifier-sensitive behavior:** Calls the universal zero-input panic
+  guarantee `UNPROVED`, not `CONTRACT-BROKEN`, because the known failing
+  execution has UB.
+- **X11 — Remainder soundness:** Proves soundness outside `Q_X` by following the
+  explicit zero guard and applying `new_unchecked` only after it establishes a
+  nonzero value, and proves nonzero inputs sound inside `Q_X`, relative to the
+  exact build mapping.
+- **X12 — Regional panic theorem:** Proves that zero takes the explicit
+  `panic!` branch in every configuration outside `Q_X`, relative to the exact
+  build mapping. It asserts no undocumented nonzero return-value postcondition.
+- **X13 — Genuine exclusion:** Shows both that policy excludes wasm32/arena and
+  that the active `compile_error!` rejects that pair after allocator cfg
+  generation under `BUILD-MAP-X`. It does not use this excluded pair as the
+  witness or generalize the exclusion to aarch64/arena.
+
+### Hard-error triggers
+
+A report commits a hard error if it:
+
+- omits feature, target, or allocator and then uses the contracted conjunction
+  to claim full-domain closure/soundness, or treats the supported `Q_X` cell as
+  excluded;
+- ignores build-script output and consequently declares the unsafe branch
+  unreachable;
+- invents, hides, or widens a build-tool/target mapping beyond accepted
+  `BUILD-MAP-X`;
+- uses the excluded wasm32/arena pair as a valid soundness counterexample;
+- calls the current safe API sound or stops at `UNPROVED` despite establishing
+  the complete supported `lane_id(0)` UB witness;
+- calls the zero-panic promise `CONTRACT-BROKEN` based on the UB-containing
+  execution, or claims observations before/after that UB remain guaranteed;
+- claims the policy exclusion alone makes a reachable safe API sound without
+  checking effective rejection; or
+- certifies an unimplemented repair instead of the supplied source snapshot.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/SCORER.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/SCORER.md
new file mode 100644
index 0000000000..9f96351959
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/SCORER.md
@@ -0,0 +1,72 @@
+# Frozen Common Blind-Scoring Rules
+
+Score explicit propositions, not keywords, terminology, organization, or a
+preferred proof style. Accept any equivalently exact derivation. Do not infer a
+missing material premise from vague shorthand.
+
+For each report A–J:
+
+1. Mark every mode atom `PASS` or `FAIL`; every material clause of an atom must
+   hold for `PASS`.
+2. Record every independently applicable hard error.
+3. Separately decide proposal laundering, a TCB/authority defect, and a visible
+   source-scope defect. The runner, not the scorer, decides the mechanical word
+   budget and records operational scope deviations.
+4. Cite compact report evidence for every decision.
+5. Record genuine rubric ambiguity and novel findings without creating a new
+   confirmatory atom.
+
+`Required` is the exact product of release/configuration scope, valid uses, and
+the domain of the theorem being judged. `Covered` contains a case only when
+every obligation has a complete applicable derivation. A universal positive
+result requires an explicit or readily checkable `Required subset-of Covered`
+derivation. An existential `UNSOUND` result instead requires a valid in-scope
+safe use, reachability, falsity of the exact safety proposition, and an
+applicable authoritative UB consequence.
+
+Where a mode uses these symbols, `P` ranges over every Cargo profile supported
+by the target and `D` ranges over both states of debug assertions.
+
+A missed atom is not automatically a hard error. Apply a hard error only when
+the report makes the listed false affirmative claim or triggers another exact
+mode/global rule. Additional correct regional detail is harmless.
+
+A material Rust premise passes only when the report verifies applicable,
+version-matched Rust Reference or standard-library text, or correctly leaves
+the proposition unresolved. The URL allowlist grants page identity, not a
+proposition. Cargo documentation is not a Rust semantic axiom. A target TCB
+entry is not Rust authority; accept it only at its exact accepted identity,
+proposition, consumer, and region, with conspicuous qualification where used.
+
+Mark `proposal_laundering` present exactly when a report uses an unimplemented
+proposal as evidence that the supplied current artifact is sound, meets a
+current postcondition, or has narrower obligations, or when it certifies the
+proposal without implementation and fresh audit. Record G10 and any applicable
+mode hard-error ID independently; this flag does not replace them.
+
+Global hard errors have IDs G1 through G12 in the list order below. A mode's
+own hard errors have IDs `<mode>H1`, `<mode>H2`, and so on in the list order
+under that rubric's **Hard errors** heading. Record an exact applicable ID, not
+a report-authored category name. Global hard errors are:
+
+- claiming full `PROVED` after contracting or failing to justify `Required`;
+- claiming positive closure without `Required subset-of Covered`;
+- inventing policy precedence or calling a conservative audit domain the
+  project's promise;
+- treating CI, endpoints, sparse documentation, a cutoff, or a stability badge
+  as interval coverage;
+- issuing `UNSOUND` without all four existential certificate links;
+- issuing only `UNPROVED` after explicitly establishing all four links;
+- issuing `CONTRACT-BROKEN` using only an execution that contains UB;
+- claiming an observation remains guaranteed because it occurs before UB;
+- silently trusting a third-party unsafe implementation or caller-controlled
+  safe behavior;
+- certifying an unimplemented design or using it to narrow the current-artifact
+  obligation;
+- necessarily relying on unchecked, invalid, or inapplicable authority; or
+- evidence that the report agent inspected prohibited oracle, sibling,
+  condition-map, prior-report, or evaluator material.
+
+Do not identify, cluster, or speculate about generating conditions. Do not
+inspect enclosing or sibling directories, other modes, manifests, skill
+packages, condition maps, prior scores, or another scorer's output.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/allowlist.txt b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/allowlist.txt
new file mode 100644
index 0000000000..25e171dfb3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/allowlist.txt
@@ -0,0 +1,22 @@
+https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked
+https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators
+https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html
+https://doc.rust-lang.org/1.85.1/std/macro.panic.html
+https://doc.rust-lang.org/1.85.1/std/env/fn.var.html
+https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str
+https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str
+https://doc.rust-lang.org/1.85.1/std/fmt/index.html#syntax
+https://doc.rust-lang.org/1.85.1/reference/expressions/block-expr.html
+https://doc.rust-lang.org/1.85.1/reference/expressions/match-expr.html
+https://doc.rust-lang.org/1.85.1/reference/patterns.html#literal-patterns
+https://doc.rust-lang.org/1.85.1/reference/patterns.html#or-patterns
+https://doc.rust-lang.org/1.85.1/reference/patterns.html#wildcard-pattern
+https://doc.rust-lang.org/1.85.1/std/macro.println.html
+https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation
+https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute
+https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#rustc-cfg
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#rustc-check-cfg
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#rerun-if-env-changed
+https://doc.rust-lang.org/1.85.1/cargo/reference/build-scripts.html#life-cycle-of-a-build-script
+https://doc.rust-lang.org/1.85.1/cargo/reference/features.html
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/A.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/A.md
new file mode 100644
index 0000000000..32a16cb9e3
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/A.md
@@ -0,0 +1,64 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, scope, and verdicts
+
+Audit date/cutoff: 2026-08-01. The audited snapshot is exactly the supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, and `src/lib.rs`. No build, execution, test, expansion, or implementation/backend claim is used. The source-level theorem quantifies over every well-typed safe use of the complete crate under Rust/Cargo/stdlib 1.85.1 and every supported configuration below, relative only to TCB revision `BUILD-MAP-X` and the cited Rust 1.85.1 semantics.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Freedom from Rust UB over the complete supported domain | **UNSOUND** | `F-UB-1`: a valid safe `lane_id(0)` call in a supported reachable configuration executes `new_unchecked(0)`, which its exact std contract declares UB. |
+| The documented behavior “Panics when `value` is zero” over the complete supported domain | **UNPROVED** | It is proved on the non-defective supported region. In the defective region the available zero-input witness contains UB, so it cannot certify `CONTRACT-BROKEN`; no independent UB-free refutation was established. |
+| Both claims on supported configurations other than `aarch64 + burst + arena` | **PROVED** | Case proof `P-GOOD` and closure below. |
+
+Combined mandatory result: **UNSOUND** for soundness and **UNPROVED** for the zero-input panic guarantee; therefore the complete-crate claim is not `PROVED`.
+
+## Exact domain and configuration closure
+
+Let `T` range over `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, `B` over both `burst` states, `A` over `{system, arena}`, `P` over every Cargo profile, and `D` over both debug-assertion states. For successful build-script stdout writes,
+
+`Required = Rust/Cargo/stdlib 1.85.1 ∧ T in the listed set ∧ B∈{off,on} ∧ A∈{system,arena} ∧ P arbitrary ∧ D∈{off,on} ∧ ¬(T=wasm32-unknown-unknown ∧ A=arena)`.
+
+This is an exact normalization of `SUPPORT.md`; `Cargo.toml` fixes the package, edition 2021, toolchain floor/equality supplied by policy, library path, build script, and the two feature states. `BUILD.md` and `build.rs` map an absent variable or `system` to `A=system`, and `arena` to `A=arena`. `std::env::var` returns the process value, `NotPresent` for an unset variable, and `NotUnicode` for a non-Unicode value ([Rust 1.85.1 `env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html)). Local match arms emit exactly one accepted selector or panic. `BUILD-MAP-X` then admits only that Cargo 1.85.1 passes each emitted selector, maps the feature and the three triples to their named cfgs, reruns as stated, and produces no library compilation after an unsuccessful script. This does not trust what the script emits.
+
+The source cfgs form the exhaustive partition
+
+`BAD = Required ∧ T=aarch64-unknown-linux-gnu ∧ B=on ∧ A=arena`
+
+and `GOOD = Required ∧ ¬BAD`. Profiles and debug assertions do not select or alter either implementation, so both proofs are parametric over `P` and `D`. For `GOOD`, the specialized block is absent and the other block is present. Primitive `u8` equality decides `value == 0` ([comparison operators](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)); when true, Rust executes the consequent block ([`if` semantics](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)), whose `panic!` “Panics the current thread” ([`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html)). When false, reaching the unsafe call proves `value != 0`. Thus `P-GOOD` covers every `u8`, target, feature, allocator, profile, and assertion state in `GOOD`; `GOOD ⊆ Covered(P-GOOD)`.
+
+Rejected cases are outside `Required` and do not conceal UB:
+
+- `wasm32-unknown-unknown + arena`, with either feature state, selects the unconditional-in-that-case `compile_error!` before a library artifact can be produced. This exactly enforces the sole support-policy exclusion.
+- Any Unicode allocator value other than `system` or `arena`, and any non-Unicode value, reaches `panic!` in `build.rs`; by `BUILD-MAP-X`, an unsuccessful script yields no library compilation. A missing value is accepted as `system`.
+- Build-script stdout failure is explicitly excluded by `BUILD-MAP-X` and also yields no compilation. Manually invented missing or simultaneous allocator cfgs are outside `BUILD.md`'s theorem; the first two `compile_error!` guards reject them nonetheless.
+
+## Boundary, invariants, and obligation ledger
+
+The complete downstream safe API surface is the public free function `lane_id(u8) -> NonZeroU8`. There are no crate-owned public fields, constructors, traits/impls, callbacks, statics, FFI, reexports, hidden APIs, or exported/generated macros. `burst` and the allocator environment interface are configuration surfaces. The only unsafe operations are the two cfg-complementary `NonZeroU8::new_unchecked(value)` calls.
+
+There is no enforceable abstraction invariant establishing that arguments are nonzero. The sentence “Burst-mode lane identifiers are never zero” is merely a false assertion about an unconstrained safe argument. On `GOOD`, a per-call dominating check establishes the needed fact; it is not a type-wide invariant.
+
+| ID | Obligation and domain | Proof/status |
+|---|---|---|
+| O-CFG | Recover accepted selectors, cfg reachability, and rejection | Source control flow plus `BUILD-MAP-X`; **PROVED** as above. |
+| O-NZ-GOOD | `new_unchecked(value)` requires `value != 0`, on `GOOD` | Zero panics; false branch implies nonzero; **PROVED**. |
+| O-NZ-BAD | Same requirement on `BAD` | False for safe input zero; **UNSOUND**, `F-UB-1`. |
+| O-PANIC | Zero input panics | **PROVED** on `GOOD`; **UNPROVED** on `BAD` because the execution has UB. |
+| O-CLOSE | Aggregate supported-domain coverage | `GOOD` and `BAD` exhaust `Required`; the existential certificate on `BAD` establishes the strongest full-domain verdict. |
+
+## F-UB-1 — supported safe call violates `NonZero`'s contract
+
+- **Status/severity:** **UNSOUND**, implementation defect; adjacent proof comment deficient.
+- **Valid in-scope use:** Choose Rust/Cargo 1.85.1, target `aarch64-unknown-linux-gnu`, `burst` enabled, `FIXTURE_ALLOCATOR=arena`, any supported profile/assertion state, and call public safe `lane_id(0)`. `SUPPORT.md` includes this configuration (only wasm+arena is excluded); safe callers have no precondition.
+- **Reachability:** `build.rs` emits `fixture_allocator="arena"`; `BUILD-MAP-X` supplies that cfg, `feature="burst"`, and `target_arch="aarch64"`. Therefore the first cfg block is compiled and its unconditional return executes `NonZeroU8::new_unchecked(value)` with zero; the checked complementary block is absent.
+- **False safety proposition and UB consequence:** Rust 1.85.1 documents that `new_unchecked` creates without checking, that a zero value “results in undefined behavior,” and requires “The value must not be zero” ([exact `NonZero::new_unchecked` contract](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). The reached argument is exactly zero. This closes every existential `UNSOUND` link.
+- **Postcondition classification:** this same execution cannot prove `CONTRACT-BROKEN`, because it is not UB-free as a whole.
+- **Minimum repair:** perform the zero check in every configuration, then retain only the checked unsafe call (or use safe `NonZeroU8::new` and handle `None`). Suitable adjacent proof: `The preceding value == 0 branch panics, so reaching this call proves value != 0, exactly satisfying new_unchecked's safety requirement.` Re-audit all cfg cases after the change.
+
+## TCB audit log and residual scope
+
+`BUILD-MAP-X` is **accepted** exactly as written in supplied `TCB.md`: Cargo 1.85.1, this manifest/build script/environment/library, all supported profiles, successful-write scope, selector/feature/target propagation, rerun behavior, and halt-on-script-failure. Consumers are only O-CFG and reachability in `F-UB-1`. It admits no build-script source correctness, emitted string, Rust semantics, backend, or binary proposition; none was widened. Re-audit triggers are exactly its listed identity/interface/source/target/disposition changes.
+
+The Rust axioms consumed are the versioned pages cited above, especially the exact `new_unchecked` precondition and UB consequence. There are no third-party dependencies, tool-derived facts, prior reports, tests, external specifications, deployment assumptions, or binary claims. Unsupported/manual cfgs and failed build attempts have only the rejection accounting stated above. Re-audit on any supplied source, support/build contract, Rust/Cargo/stdlib version, cfg/feature/target/profile domain, cited semantic contract, or TCB disposition change.
+
+Auditor: source-review agent. Independent review: not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/B.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/B.md
new file mode 100644
index 0000000000..ed84758bb6
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/B.md
@@ -0,0 +1,59 @@
+# Unsafe Rust audit: `cross-axis-target` supplied snapshot
+
+## Claim and verdict
+
+**Source-soundness claim.** For every well-typed safe use of the complete supplied crate under `Required` below, execution is free of Rust undefined behavior under Rust 1.85.1 abstract semantics, relative only to `BUILD-MAP-X` and the cited Rust axioms.
+
+**Verdict: UNSOUND over the complete supported domain (F-1).** The supported region `aarch64-unknown-linux-gnu + burst + arena` admits the safe call `lane_id(0)`, which reaches an operation documented to have undefined behavior for zero. Soundness is `PROVED` for the complementary supported region, relative to the stated TCB.
+
+**Documented behavior:** `UNPROVED` overall. The nonzero result behavior and the promised zero panic are proved in the complementary region. In the defective region, the only established zero execution contains UB, so it cannot witness `CONTRACT-BROKEN`; the promised panic remains `UNPROVED` there. Build-interface behavior and the required `wasm32 + arena` rejection are `PROVED` relative to `BUILD-MAP-X`.
+
+**Combined mandatory result:** `UNSOUND` soundness / `UNPROVED` documented postconditions. No conditional application claim is requested.
+
+## Snapshot and supported set
+
+The artifact is exactly the supplied `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, and `REQUEST.md`; no VCS identity, lockfile, dependency, generated source file, or prior audit is supplied. Edition 2021 and Rust/Cargo/stdlib 1.85.1 apply. Audit cutoff: 2026-08-01. Skill identity: supplied unsafe-rust package snapshot. No build, expansion, execution, or test evidence was used.
+
+`Required` is every Cargo build using the supplied manifest and build script, Rust/Cargo 1.85.1, target in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, either `burst` state, allocator `system` or `arena`, every Cargo profile, and either debug-assertion state, except `wasm32-unknown-unknown + arena`. Allocator selection is only the `BUILD.md` interface: missing/`system` means `system`; `arena` means `arena`. Invented rustc cfgs and other targets/toolchains are outside the theorem.
+
+Configuration partition is exhaustive: let `S = aarch64 + burst + arena`; all supported library builds are either `S` or `Required \\ S`. Profile and debug-assertion axes are irrelevant because neither controls source and no debug assertion is used.
+
+The build script has no unsafe code. On successful stdout writes, its match maps only `system`/`arena` to one interpolated selector; missing input first becomes `system`; invalid Unicode or any other string panics. `BUILD-MAP-X` supplies only the exact Cargo/env/cfg mapping and the fact that script/write failure yields no library compilation. For an accepted selector, Cargo therefore supplies exactly one value. The first two `compile_error!` guards reject absent/both selectors defensively. `wasm32 + arena` selects the third guard and fails compilation, satisfying the mandated exclusion; invalid environment values fail earlier. Conditional source selection and compilation failure use the Rust 1.85.1 [`cfg`](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation), [`cfg` attribute](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), and [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html) contracts.
+
+## Boundary, invariants, and obligations
+
+The sole downstream surface is safe public free function `lane_id(u8) -> NonZeroU8`. There are no public representation fields, traits/impls, exported macros, hidden items, callbacks, FFI, statics, or custom destruction. Its safety invariant is `NZ`: every normally returned `NonZeroU8` contains a nonzero input value. `lane_id` produces `NZ`; `NonZeroU8::new_unchecked` consumes the proposition `value != 0` and establishes the result.
+
+| ID | Site/domain | Exact obligation | Derivation and status |
+|---|---|---|---|
+| O-1 | `lib.rs:31`, `S` | `value != 0` before `new_unchecked` | For nonzero inputs, immediate. For zero, no check, type restriction, or unsafe caller obligation exists. **UNSOUND** via F-1. |
+| O-2 | `lib.rs:44`, `Required \\ S` | `value != 0` before `new_unchecked` | `value == 0` selects the diverging panic branch; normal reach therefore entails inequality. This discharges the exact callee precondition and establishes `NZ`. **PROVED** for both unwind/abort behavior because neither continues to line 44. |
+| O-3 | safe `lane_id` surface | all safe inputs avoid UB | O-2 proves the complement; O-1 refutes `S`. **UNSOUND overall**. |
+| O-4 | `# Panics` contract | every `value == 0` call panics | Proved in the complement. The `S` zero execution has UB, so no defined refutation is established and the regional/overall result is **UNPROVED**, not `CONTRACT-BROKEN`. |
+| O-5 | build/support policy | admitted cfgs are exhaustive; rejected cases produce no library | Source partition above plus `BUILD-MAP-X`; `wasm32 + arena` reaches `compile_error!`. **PROVED**. |
+
+The material Rust 1.85.1 axiom is [`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked): “This results in undefined behavior if the value is zero”; its Safety clause says “The value must not be zero.” Equality means `PartialEq::eq` ([comparison operators](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)), and an [`if` expression](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) executes the block selected by its Boolean condition. These premises directly yield O-1/O-2; no backend or optimizer premise is used.
+
+## F-1 — unchecked zero in a supported safe configuration
+
+- **Status/severity:** `UNSOUND`, critical; implementation defective and `lib.rs:30` proof comment false.
+- **Witness:** Select supported Rust/Cargo 1.85.1, `aarch64-unknown-linux-gnu`, feature `burst`, allocator `arena`, any profile/debug-assertion state, successful build-script writes; then well-typed safe code calls `lane_id(0)`. `BUILD-MAP-X` makes all three cfg predicates true. Lines 24–32 are retained and lines 34–45 are not. Line 31 executes `NonZeroU8::new_unchecked(0)`, and AXIOM-NZ states that this is UB.
+- **Smallest false implication:** “burst-mode lane identifiers” does not imply `value != 0`; `burst` is only a Cargo feature bit and the unrestricted `u8` parameter admits zero. The comment supplies neither a check nor an enforceable caller obligation.
+- **Resolution:** remove the special unchecked branch or perform an unconditional zero check before every `new_unchecked` call (prefer a checked safe constructor). A safety-comment edit alone cannot repair a safe API. Re-audit all configuration branches afterward.
+- **Compatibility:** the fix enforces the already documented panic and adds no valid caller obligation. Making the function unsafe would be a breaking and unnecessary alternative.
+
+## TCB audit log
+
+| ID/category | Exact proposition, scope, disposition | Consumer / trigger |
+|---|---|---|
+| `BUILD-MAP-X` / accepted build-tool premise | Exactly the proposition and identity in supplied `TCB.md`, including selector/feature/target mapping and failure-to-no-compilation; accepted by the authorized human. It does **not** trust local source correctness or binaries. | O-1, O-5; every trigger listed in `TCB.md`. |
+| `AXIOM-NZ-185` / Rust std authority | The quoted `new_unchecked` precondition and zero-UB result for std 1.85.1; accepted under the request's authority policy. | O-1, O-2; Rust/std or contract change. |
+| `AXIOM-CONTROL-185` / Rust Reference authority | Cited equality, `if`, conditional-compilation, attribute, and compile-error semantics for Rust 1.85.1; accepted under the same policy. | O-1, O-2, O-5; toolchain/Reference change. |
+
+No dependency, tool, external-specification, deployment, probabilistic, compiler-backend, or binary-correctness premise is consumed. This does not widen `TCB.md`'s sole accepted human implementation premise.
+
+## Residual scope and review triggers
+
+Unsupported toolchains/targets, invented cfgs, `wasm32 + arena` artifacts (none are produced), invalid allocator inputs, and compiler/backend/binary correctness are outside the source theorem. Build-script write failure also produces no library compilation under the accepted premise. No inaccessible in-scope source or generated artifact was identified.
+
+Re-audit on any supplied source/doc change; Rust/Cargo/stdlib or target-set change; feature, allocator, env, cfg, manifest, profile, or panic-policy change; change to `BUILD-MAP-X` or its human disposition; or change to a cited authoritative contract. Every in-scope obligation above has a disposition; the sole UB witness is source-derived, not test-derived.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/C.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/C.md
new file mode 100644
index 0000000000..7e4c751c8f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/C.md
@@ -0,0 +1,82 @@
+# Source-only unsafe-code audit
+
+## Claim, scope, and verdict
+
+**Snapshot:** the supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `src/lib.rs`, and `REQUEST.md`, audited 2026-08-01. Rust and standard library are exactly 1.85.1. There are no dependencies or generated source files. The build script generates only a library configuration option.
+
+**Claim:** for every successful library compilation in the supported domain, every well-typed safe use of the public API is free of Rust undefined behavior and its documented behavior holds, relative only to accepted TCB entry `BUILD-MAP-X` and the cited Rust 1.85.1 semantics.
+
+| Component | Verdict | Certificate |
+|---|---|---|
+| Safe-API soundness over the complete supported domain | **UNSOUND** | Finding F-1 gives a valid supported safe call, reaches `new_unchecked(0)`, proves its precondition false, and cites the resulting UB contract. |
+| Soundness outside `aarch64 + burst + arena` | **PROVED** | OBL-U2 below; the zero check dominates the only unsafe call in this region. |
+| Documented “panics when `value` is zero” behavior over the complete domain | **UNPROVED** | It is established outside F-1’s configuration, but the only zero-input execution established in F-1 has UB. Such an execution is not an UB-free `CONTRACT-BROKEN` witness. |
+| Required policy rejection | **PROVED** | Every `wasm32 + arena` combination encounters `compile_error!`; invalid allocator selectors make the build script fail before library compilation. |
+
+Thus the strongest complete-domain result is **UNSOUND**. This is a source-level result, not a compiler-backend or binary claim.
+
+## Required domain and closure
+
+Let:
+
+- `T = {x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`;
+- `B = {burst disabled, burst enabled}`;
+- `A = {system, arena}`;
+- `P` be every Cargo profile and `D = {debug assertions off, on}`.
+
+From `Cargo.toml`, `SUPPORT.md`, and `BUILD.md`, normalized without enumeration loss:
+
+`Required = Rust 1.85.1 × {(t,b,a,p,d) in T×B×A×P×D | not(t=wasm32-unknown-unknown and a=arena)}`,
+
+restricted to Cargo builds using the supplied build script whose stdout writes succeed. The latter restriction is exactly `TCB.md`’s execution scope; a write failure produces no library compilation and is not a policy rejection. `BUILD.md` excludes manual `rustc` cfg invention.
+
+`BUILD-MAP-X` is accepted exactly as written: Cargo maps the script’s emitted allocator cfg, feature `burst`, and the three triples to their stated cfgs; `rustc-check-cfg` declares but does not set values; unsuccessful scripts halt before library compilation. No source-correctness or Rust-semantic proposition is imported from it.
+
+Source inspection proves the remaining mapping. `env::var` partitions into present Unicode, absent, and non-Unicode cases. Absence produces `"system"`; exact string matches `system|arena` emit exactly one corresponding cfg; every other Unicode string and non-Unicode input panics. On successful writes, `BUILD-MAP-X` therefore gives exactly one allocator cfg. The code has no profile/debug-assertion conditional and no `debug_assert!`, so all `P×D` cases share the same proof.
+
+The Rust Reference states that a cfg option predicate is true exactly when set, `all` requires all operands, and `not` negates its operand ([conditional compilation](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation)). It also states conditionally compiled source is compiled only under its condition. Consequently the two `lane_id` blocks form an exhaustive complementary partition. Define
+
+`Bad = Required ∩ {t=aarch64-unknown-linux-gnu, b=enabled, a=arena}`.
+
+The proof below covers `Required \ Bad`; F-1 existentially refutes soundness on `Bad`. Profiles and debug assertions remain parametric in both cases.
+
+## Build rejection proof
+
+For `t=wasm32-unknown-unknown, a=arena`, `BUILD-MAP-X` sets `target_arch="wasm32"` and `fixture_allocator="arena"`; hence the third top-level cfg is true for both feature states and all profiles/debug states. `compile_error!` “causes compilation to fail ... when encountered” ([Rust 1.85.1 documentation](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)), so the mandated excluded pair cannot produce the library.
+
+Invalid or non-Unicode `FIXTURE_ALLOCATOR` values reach a `panic!`; `BUILD-MAP-X` then halts before library compilation. Omitted, `system`, and `arena` are the complete accepted selector interface. The first two top-level `compile_error!` items additionally reject missing or simultaneously set allocator cfgs, although accepted Cargo builds cannot generate them. Other targets and manual cfg injection are outside `Required`, not silently proved. A build-script stdout failure is an infrastructure failure with no compiled configuration, per the TCB, not another selector or successful rejection.
+
+## Boundary, invariant, and obligation coverage
+
+The complete public Rust surface is the safe function `lane_id(u8) -> NonZeroU8` (`src/lib.rs:23`). There are no public fields, traits or impls, macros, statics, callbacks, hidden items, generated APIs, custom destruction, FFI, concurrency, assembly, or allocator operations. `build.rs::main` is the complete build interface. The only unsafe operations are the two cfg-disjoint `NonZeroU8::new_unchecked(value)` calls.
+
+`INV-NZ`: each value returned as `NonZeroU8` must have a nonzero integer value. Its producer/consumer boundary is each `new_unchecked` call; the unsafe function requires its argument to be nonzero.
+
+| ID | Site/domain | Required proposition | Derivation and status |
+|---|---|---|---|
+| OBL-U1 | `src/lib.rs:31`, `Bad` | `value != 0` before `new_unchecked` | No check, type restriction, or caller precondition exists. False for safe input `0`. **UNSOUND**, F-1. |
+| OBL-U2 | `src/lib.rs:40-44`, `Required \ Bad` | `value != 0` before `new_unchecked` | If `value == 0`, `panic!` prevents reaching line 44; reaching line 44 therefore entails `value != 0`. This satisfies the exact callee contract and establishes `INV-NZ`. **PROVED**. |
+| OBL-PANIC | documented `# Panics` clause | every zero input panics | Proved by the dominating branch on `Required \ Bad`; unresolved on `Bad` because the reached operation has UB. **UNPROVED**, not `CONTRACT-BROKEN`. |
+| OBL-CFG | build/policy boundary | exactly supported cfgs compile; excluded pair fails | Build-script partition, `BUILD-MAP-X`, complementary cfgs, and `compile_error!` proof above. **PROVED**. |
+
+The local comment for OBL-U2 is an adequate compact proof. OBL-U1’s comment—“Burst-mode lane identifiers are never zero”—is not a derivation: `value` is an unrestricted argument to a safe function, and no earlier producer or check establishes that assertion.
+
+## F-1 — supported safe call invokes `new_unchecked(0)`
+
+- **Affected theorem:** complete-domain safe-API soundness.
+- **Valid in-scope use:** select target `aarch64-unknown-linux-gnu`, enable `burst`, select `arena`, use any Cargo profile/debug state, then safe code calls `lane_id(0)`. `SUPPORT.md` includes this combination, and the safe signature imposes no caller safety precondition.
+- **Reachability:** `BUILD-MAP-X` sets all three predicates of the first `cfg(all(...))`. The first block is compiled, its complementary block is not, and the function immediately executes `NonZeroU8::new_unchecked(value)`.
+- **False safety proposition:** at that operation `value == 0`, while the contract says, “The value must not be zero.”
+- **UB consequence:** Rust 1.85.1 documents that `new_unchecked` “results in undefined behavior if the value is zero” ([exact API contract](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). This completes the existential `UNSOUND` certificate.
+- **Proof artifact:** incorrect; it reverses an unsupported assertion into an invariant.
+- **Minimum repair:** remove the special unchecked branch and use the already guarded implementation in every configuration (or use checked `NonZeroU8::new(value)` and panic on `None`). Replace the special comment with the OBL-U2 derivation. This preserves the public panic contract and configuration policy. The changed snapshot needs a fresh full-domain audit.
+
+## Authority and TCB log
+
+- **Accepted TCB:** only `BUILD-MAP-X`, exact identity/scope/disposition from `TCB.md`; consumers are domain reachability and rejection. Re-audit on any trigger listed there. It is not widened.
+- **Rust axioms:** the versioned `new_unchecked`, cfg, and `compile_error!` passages cited above. Build-script control flow uses the allowlisted Rust 1.85.1 contracts for [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), [match expressions](https://doc.rust-lang.org/1.85.1/reference/expressions/match-expr.html), [literal/or/wildcard patterns](https://doc.rust-lang.org/1.85.1/reference/patterns.html#literal-patterns), and [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html).
+- **Tools/tests:** none; no target code was built, run, tested, or expanded.
+
+## Residual scope and review triggers
+
+Excluded are unsupported targets, Rust versions other than 1.85.1, direct `rustc`/invented cfgs, backend/binary behavior, and build attempts producing no library after script failure. Re-audit on source, public contract, support policy, Cargo/toolchain, build environment interface, cfg mapping, target/feature/profile scope, TCB disposition, or material cited-documentation changes.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/D.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/D.md
new file mode 100644
index 0000000000..451a2f7b49
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/D.md
@@ -0,0 +1,72 @@
+# Unsafe Rust audit: `cross-axis-target` 0.1.0
+
+## Claim, snapshot, and verdicts
+
+Audit date/cutoff: 2026-08-01. Snapshot: the complete supplied `Cargo.toml`, `build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `src/lib.rs`, and `REQUEST.md`; no expansion, build, execution, tests, prior audit, dependency resolution, or repository metadata was used. Rust, Cargo, and standard library are exactly 1.85.1; edition 2021. Scope is source-level Rust abstract semantics, the build interface and rejection behavior, the sole public safe API, both unsafe calls, and documented panic behavior. There are no third-party dependencies or generated source; the build script generates cfg options.
+
+Let
+
+`Required(c) := rust=cargo=stdlib=1.85.1 ∧ Cargo/build.rs is used ∧ target∈{x86_64-linux-gnu,aarch64-linux-gnu,wasm32-unknown} ∧ burst∈{off,on} ∧ allocator∈{system,arena} ∧ ¬(target=wasm32-unknown ∧ allocator=arena) ∧ profile is any Cargo profile ∧ debug_assertions∈{off,on}`.
+
+Successful build-script stdout is implicit; accepted `BUILD-MAP-X` says a write/script failure produces no library compilation and hence no `Required` configuration. Let `H := burst=on ∧ target=aarch64-linux-gnu ∧ allocator=arena`.
+
+| Claim | Verdict | Certificate |
+|---|---|---|
+| Every well-typed safe `lane_id(v)` use is UB-free for every `c∈Required` and `v:u8` | **UNSOUND** | `H∈Required`; safe `lane_id(0)` reaches `NonZeroU8::new_unchecked(0)`, whose 1.85.1 contract says this is UB. |
+| “Panics when `value` is zero” over every `c∈Required` | **UNPROVED** | Proved for `Required\H`; in `H`, the zero call reaches UB instead. That UB-containing execution cannot certify `CONTRACT-BROKEN`, and no UB-free refutation exists in the snapshot. |
+| Soundness on `(Required\H)×u8 ∪ H×{1..=255}` | **PROVED**, relative to the TCB below | Exhaustive cfg/input partition and OBL-3/OBL-4 below. |
+| Documented selector and excluded-pair rejection | **PROVED**, relative to `BUILD-MAP-X` | OBL-1/OBL-2 below. |
+
+Combined mandatory result: **UNSOUND** for soundness and **UNPROVED** for the zero-input panic guarantee.
+
+## Domain and configuration closure
+
+`SUPPORT.md:3-16` supplies the exact singleton toolchain, three targets, two feature states, two allocators, all profiles/debug-assertion states, and the sole excluded cross-product member. `BUILD.md:3-14` restricts support to Cargo plus `build.rs` and defines selector normalization: absent or `system`→system; `arena`→arena; everything else rejected. This is preserved symbolically above, not inferred from samples.
+
+`build.rs:9-21` implements that three-way mapping: [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), `NotPresent`/`NotUnicode`, [`str::to_owned`](https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), literal/or/wildcard matching, and named formatting select one accepted string or [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html). `BUILD-MAP-X` alone admits Cargo’s execution, rerun, directive, feature, target-cfg, and failed-script mapping; it admits no local correctness.
+
+For every accepted selector, exactly one `rustc-cfg` line is reached. `src/lib.rs:3-13` rejects neither/both allocator cfgs. `src/lib.rs:15-16` rejects wasm32+arena. Under the [cfg-attribute rule](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), a true predicate retains the [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), which makes compilation fail. Within the controlling supported target predicate, successful library compilations are exactly `Required`; `H` is included (aarch64, arena, burst is not excluded). Profile/debug/panic strategy do not select source or alter `new_unchecked`'s precondition; panic abort versus unwind does not affect the proved panic initiation.
+
+Aggregate `Covered` for soundness is `(Required\H)×u8 ∪ H×{1..=255}`. Because `H×{0}⊆Required×u8` but is not covered—and is affirmatively refuted—`Required×u8 ⊄ Covered`.
+
+## Boundary, invariant, and obligation ledger
+
+The full language-reachable crate surface is: safe public free function `lane_id(u8)->NonZeroU8`; its return type’s standard safe behavior; build-script entrypoint/environment input; cfg-generated variants; two private unsafe calls. There are no public fields/types/traits/statics/macros, callbacks, FFI, impls, reexports, hidden items, mutable state, allocator operations, or destruction/concurrency invariants. `INV-NZ` is local: immediately before either `new_unchecked(value)`, `value≠0` must hold; the unsafe call consumes it and returns a valid `NonZeroU8`.
+
+| ID | Site and exact obligation | Proof/status |
+|---|---|---|
+| OBL-1 | `build.rs`: map every documented selector, emit exactly one value, reject every other value | Direct exhaustive `Result` and string-match cases; emitted-line propagation/failure is exactly accepted `BUILD-MAP-X`. **PROVED**. |
+| OBL-2 | cfg closure and wasm32+arena rejection | Two allocator predicates are total/exclusive under OBL-1; target/feature mapping is `BUILD-MAP-X`; active `compile_error!` rejects the excluded pair. **PROVED**. |
+| OBL-3 | `src/lib.rs:40-44`: establish `value≠0` | For `Required\H`, this is the active block. Rust [integer equality](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators) plus [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) partitions `value=0` (panic) from `value≠0` (call). The adjacent comment states the complete material derivation. **PROVED** for all such configurations/inputs. |
+| OBL-4 | `src/lib.rs:29-31`: establish `value≠0` | In `H` this unconditional block is active. No type, check, boundary, or accepted TCB premise constrains safe input. False for `value=0`; true for 1..=255. **UNSOUND witness below**. |
+| OBL-5 | `src/lib.rs:22`: zero always panics | OBL-3 proves it outside `H`; OBL-4 prevents a defined proof in `H`. **UNPROVED** globally. |
+
+The Rust 1.85.1 `NonZero::new_unchecked` contract states: “This results in undefined behavior if the value is zero” and requires that the value not be zero ([authoritative page](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)). It also establishes the nonzero result needed by the return type when its precondition holds.
+
+## Finding F-1 — supported safe call reaches UB
+
+- **Status:** critical; implementation **UNSOUND**; safety comment deficient and false.
+- **Valid use:** choose supported `H`; call public safe `lane_id(0)` from well-typed safe Rust. A safe API has no caller safety precondition.
+- **Reachability:** `BUILD-MAP-X` establishes all three true cfg atoms. Conditional compilation retains `src/lib.rs:24-32` and removes `:34-45`; the function executes `new_unchecked(value)` with `value=0`.
+- **False proposition:** OBL-4 requires `value≠0`; `0≠0` is false.
+- **UB consequence:** the cited 1.85.1 std contract expressly makes zero UB. This closes every existential `UNSOUND` link.
+- **Proof defect:** “Burst-mode lane identifiers are never zero” reverses no enforced producer contract and is contradicted by the unrestricted `u8` parameter.
+- **Minimum repair:** perform the zero check in every configuration (prefer `NonZeroU8::new(value).expect(...)`), or remove `H` from support and effectively reject it. Replace the comment with the actual dominating-check derivation. Re-audit source, panic behavior, domain closure, and compatibility; narrowing support is a policy change.
+- **Postcondition:** the same execution is UB-containing, so it does not establish `CONTRACT-BROKEN`; absent a separate UB-free witness, OBL-5 remains `UNPROVED`.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact admitted proposition; scope; consumer; trigger |
+|---|---|---|
+| BUILD-MAP-X | OUT-OF-BAND/IMPLEMENTATION; **accepted by authorized human** | Exactly `TCB.md:5-32`, Cargo 1.85.1 mapping/failure proposition only; all `Required`; OBL-1/2 and F-1 reachability; trigger is any named toolchain/manifest/script/interface/target/cfg/disposition change. |
+| AXIOM-NZ-1.85.1 | AXIOM; verified | Exact quoted `new_unchecked` zero precondition/UB and valid-result contract; Rust/std 1.85.1; OBL-3/4 and F-1; trigger: toolchain or cited documentation change. |
+| AXIOM-CFG-1.85.1 | AXIOM; verified | Applicable cfg attributes remove/retain attributed constructs; active `compile_error!` fails compilation; Rust 1.85.1; OBL-2/3/4; trigger: toolchain/docs/source predicate change. |
+| AXIOM-CONTROL-1.85.1 | AXIOM; verified | Applicable equality/if/panic semantics used in OBL-1/3/5; Rust/std 1.85.1; trigger: toolchain/docs/control-flow source change. |
+
+No dependency, backend, binary, tool-result, allocator-implementation, deployment, or compatibility premise is consumed. No TCB proposition was widened beyond `TCB.md`.
+
+## Rejected, residual, and review triggers
+
+Invalid/non-Unicode selectors are rejected by build-script panic; wasm32+arena is rejected at library compilation; missing or simultaneous allocator cfgs are likewise compile errors but arise only from out-of-interface manual rustc use. Other targets, invented cfgs, other Rust/Cargo versions, and manual rustc builds are unsupported, not proved rejected. Build-script stdout failure yields no compiled artifact under accepted `BUILD-MAP-X`. Binary/backend correctness is outside this source theorem. No tool-derived evidence exists.
+
+Re-audit on any source/documentation change; support, target, feature, profile, selector, or cfg change; Rust/Cargo/std or cited-contract change; `BUILD-MAP-X` disposition/scope change; or newly exposed API/generated artifact. Every in-scope obligation and rejected region has a disposition; no tests or absence-of-counterexample reasoning supports a verdict.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/E.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/E.md
new file mode 100644
index 0000000000..285d0e5fb2
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/E.md
@@ -0,0 +1,64 @@
+# Unsafe Rust Audit: `cross-axis-target` 0.1.0
+
+## Claims and verdicts
+
+**Snapshot.** Complete supplied crate: `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md` (respective SHA-256 prefixes `4668f1a3`, `d7a8e7c5`, `045942a4`, `66c7a294`, `1ca6428c`, `ff6b0c8d`). Review date: 2026-08-01. No generated source, dependencies, prior audit, execution, expansion, build, or test was used. Skill identity: supplied unversioned `unsafe-rust` package.
+
+Let `S` be this source under Cargo/Rust/stdlib 1.85.1, edition 2021, on `x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, or `wasm32-unknown-unknown`; `burst` either off or on; allocator `system` or `arena` selected through `BUILD.md`; excluding `wasm32 + arena`; in every Cargo profile and either debug-assertion state. This predicate is fixed by `Cargo.toml`, `BUILD.md`, `SUPPORT.md`, and accepted TCB entry `BUILD-MAP-X`; they do not conflict.
+
+The source-level soundness claim is: every well-typed safe use of the sole public API, and every successful supported build path, is free of Rust UB throughout `S`, relative only to the TCB below.
+
+- **Whole-`S` soundness: UNSOUND (F-01).**
+- **Region `B = aarch64 + burst + arena`: UNSOUND** for every profile/debug-assertion state.
+- **Region `G = S ∖ B`: PROVED** relative to the stated TCB.
+- **Documented behavior:** PROVED on `G`; UNPROVED on `B` for “panics when `value` is zero.” This is not `CONTRACT-BROKEN`: the available zero witness contains UB and therefore is not a defined refutation.
+- **Combined mandatory result:** `UNSOUND` and documented zero behavior `UNPROVED` (F-01). No conditional application claim.
+
+## Boundary, contracts, and obligations
+
+The complete language-reachable crate surface is the safe free function `lane_id(u8) -> NonZeroU8`. There are no public fields, custom constructors/types, methods, traits/impls, statics, callbacks, macros/generated APIs, hidden items, FFI, or reexports. The build script is also in scope. The two source occurrences of `new_unchecked` are cfg-exclusive unsafe consumers. There is no persistent custom invariant-bearing representation.
+
+`INV-NZ(v)` is the local proposition `v != 0`, required immediately at either `NonZeroU8::new_unchecked(v)` call. Rust 1.85.1 documents both that zero “results in undefined behavior” and, under Safety, “[The value must not be zero.](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)”
+
+| ID | Location / exact obligation | Domain and derivation | Status |
+|---|---|---|---|
+| O-01 | `lib.rs:44`: establish `INV-NZ(value)` | On `G`, the cfg-complement branch executes. Primitive `value == 0` is equality; if true, `panic!` prevents reaching line 44; reaching it therefore implies nonzero. The unsafe call then satisfies its exact precondition and constructs the returned nonzero from `value`. | PROVED |
+| O-02 | `lib.rs:31`: establish `INV-NZ(value)` | This branch is exactly `B`. It performs no check. A safe caller may supply every `u8`, including zero. | UNSOUND |
+| O-03 | `lane_id(0)` must panic | On `G`, the dominating branch panics. On `B`, O-02 reaches UB; that execution cannot prove or refute a defined postcondition. | PROVED on `G`; UNPROVED on `B` |
+| O-04 | configuration/build closure and exclusions | Finite cfg partition plus `BUILD-MAP-X` and the source derivation below. Profiles/debug assertions are parametric: neither selects code or removes a check. | PROVED |
+
+The existing line-30 comment, “Burst-mode lane identifiers are never zero,” is a false assertion, not a proof: `value` crosses a safe public boundary with no restriction. The line-43 comment is adequate because it names the dominating check and same value.
+
+## F-01 — safe zero reaches `new_unchecked`
+
+- **Affected theorem:** safe-library soundness and zero-panic behavior in `B`.
+- **Valid UB witness:** use the supported target `aarch64-unknown-linux-gnu`, enable `burst`, select `arena`, choose any profile/debug-assertion state, and safely call `lane_id(0)`. `BUILD-MAP-X` establishes all three active cfg predicates. Lines 24–31 select the first block and call `new_unchecked(0)`. AX-NZ establishes UB. No caller obligation is permitted on this safe API.
+- **Proof-artifact classification:** deficient and false. No invariant producer exists.
+- **Defined postcondition refutation:** not established; the witness contains UB.
+- **Minimum repair:** perform the zero check in all configurations, preferably `NonZeroU8::new(value).expect("lane identifier must be nonzero")`, or use the existing checked branch universally. If retaining unsafe, replacement proof text is: “`value == 0` panics above; reaching this call therefore establishes `value != 0`, the complete `new_unchecked` precondition.” Re-audit all configurations after repair. Removing the documented panic or adding a safe caller restriction would be a public contract change and would not repair soundness.
+
+## Configuration and rejection closure
+
+The relevant axes are exact toolchain/stdlib, three targets, two feature states, two allocator selectors, arbitrary Cargo profile, and debug assertions. There are ten supported target/feature/allocator cells. `B` is one cell; O-01 uniformly covers the other nine. No allocation implementation is used despite the selector names.
+
+For the build interface, [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html) partitions the input into a Unicode value, absent, or non-Unicode error. Absence creates the owned string `system`; [`as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), literal/or/wildcard match semantics, and formatting show that exactly `system` or `arena` emits one corresponding cfg line. Other Unicode values and non-Unicode input take `panic!`; stdout failure also cannot yield a library compilation under `BUILD-MAP-X`. The `rustc-check-cfg` line declares values but does not set them, exactly as `BUILD-MAP-X` records.
+
+For accepted selectors, conditional-compilation semantics ([cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#conditional-compilation), [cfg attribute](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute)) give exhaustive complementary `lane_id` bodies. The project-rejected `wasm32 + arena` pair, for either feature/profile/assertion state, activates line 15 and [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), so no library artifact is produced. Missing or simultaneous allocator cfgs likewise hit lines 3 or 9, but manual invented rustc cfgs are explicitly outside the theorem. A build-script stdout failure is an unsuccessful attempt, not a configuration.
+
+## TCB audit log `TCB-cross-axis-2026-08-01`
+
+Trust policy: only exact Rust 1.85.1 Reference/stdlib propositions and the already authorized `BUILD-MAP-X` may be consumed. Safe caller behavior is adversarial. No dependency, compiler-backend, binary, platform, probabilistic, or new implementation premise is admitted.
+
+| ID / category | Exact consumed proposition; scope | Disposition / consumers / trigger |
+|---|---|---|
+| BUILD-MAP-X / OUT-OF-BAND build-tool premise | Exactly the Cargo/target-cfg/feature mappings, stdout-success qualification, and halt-on-unsuccessful-script proposition written in supplied `TCB.md`; all `S` build attempts. No claim about build-script source or emitted selector is imported. | Human-accepted; O-02/O-04; every trigger listed in that entry. |
+| AX-NZ / AXIOM | Rust 1.85.1 `NonZero::new_unchecked(n)` requires nonzero and is UB for zero. | Verified authoritative text; O-01/O-02; Rust/docs/API change. |
+| AX-FLOW / AXIOM | Rust 1.85.1 primitive equality, `if`, `match`, blocks, patterns, and `panic!` semantics used above. | Verified version-matched Reference/stdlib pages listed in the supplied allowlist; O-01/O-03/O-04; toolchain/docs change. |
+| AX-CFG / AXIOM | Rust 1.85.1 cfg/cfg-attribute and `compile_error!` semantics used above. | Verified version-matched authority; O-04; toolchain/docs/cfg change. |
+| AX-BUILD-SRC / AXIOM | Rust 1.85.1 `env::var`, string, formatting, `println!`, panic, and match behavior used only to derive this script’s selector/output partition. | Verified version-matched authority; O-04; source/toolchain/docs change. |
+
+No entries are pending, rejected, expired, or widened from `TCB.md`; no tool-derived evidence exists.
+
+## Residual scope, gaps, and triggers
+
+Excluded are targets/toolchains outside `S`, direct rustc invocation/invented cfgs, backend or binary correctness, and rejected build attempts. No authoritative-documentation or skill-guidance gap blocked this result. Re-audit on any source/manifest/build/support/TCB change; Rust/Cargo/stdlib or cited-contract change; new target, feature, allocator, profile-sensitive code, generator, dependency, API, or unsafe site; or a change to `BUILD-MAP-X` disposition. Every in-scope obligation has a status; every supported cell is covered; the unsound verdict rests on a source proof, not testing or absence of counterexamples.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/F.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/F.md
new file mode 100644
index 0000000000..95fc42fddf
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/F.md
@@ -0,0 +1,152 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, scope, and verdicts
+
+This audits the exact supplied `Cargo.toml`, `build.rs`, `src/lib.rs`,
+`SUPPORT.md`, `BUILD.md`, and `TCB.md`, source-only, at the 2026-08-01 audit
+cutoff. No build, execution, expansion, test, prior audit, or VCS identity is
+used.
+
+`Supported(c)` means: edition 2021 with Rust, std, and Cargo 1.85.1; target
+triple in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu,
+wasm32-unknown-unknown}`; `burst` either disabled or enabled; allocator selected
+through `BUILD.md` as `system` or `arena`; excluding `wasm32`+`arena`; every
+Cargo profile and either debug-assertion state. Thus there are ten supported
+target/feature/allocator tuples, each parametric over profiles and debug
+assertions.
+
+The soundness claim is: for every `Supported(c)`, every well-typed safe use of
+the public API, and every permitted source-level Rust execution, the supplied
+crate introduces no undefined behavior, relative only to the TCB below.
+
+- **Whole supported-domain soundness: UNSOUND (F-01).** One expressly supported
+  tuple, `aarch64-unknown-linux-gnu` + `arena` + `burst`, admits a safe call
+  `lane_id(0)` that violates `NonZeroU8::new_unchecked`'s safety precondition.
+- **Other nine supported tuples: PROVED** for source-level soundness and the
+  documented `lane_id` behavior, relative to the stated TCB.
+- **Documented zero-input panic:** PROVED in those nine tuples; **UNPROVED** in
+  the defective tuple. It is not `CONTRACT-BROKEN`: the known zero-input
+  execution contains UB, so it is not a UB-free postcondition witness.
+- **Rejected `wasm32`+`arena` tuples (both feature states): PROVED effectively
+  rejected** before a library artifact is produced, relative to BUILD-MAP-X.
+
+No binary/backend, deployment, security, probabilistic, or additional
+robustness theorem is claimed.
+
+## Snapshot, boundary, and configurations
+
+The manifest has no dependencies, an empty default feature set, and only the
+`burst` feature. The build script is the sole configuration producer; there is
+no generated source. Its finite successful selector output family is exactly
+`fixture_allocator="system"` and `fixture_allocator="arena"`:
+
+1. [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html) supplies a
+   Unicode `String`, `NotPresent`, or `NotUnicode`. Lines 9-15 preserve an
+   accepted Unicode value, map absence to `system`, and panic on non-Unicode.
+2. Lines 16-20 accept only the two literal strings and execute exactly one
+   selector `println!`; every other Unicode value panics. [`println!`](https://doc.rust-lang.org/1.85.1/std/macro.println.html)
+   writes one newline-terminated stdout record and panics on a write failure.
+3. BUILD-MAP-X supplies only the Cargo-to-library transmission and unsuccessful
+   build-script behavior. Therefore accepted runs set exactly one allocator
+   cfg; invalid selectors and stdout failures produce no library compilation.
+
+Under the [Reference `cfg` rules](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute),
+false-attributed forms are removed and true-attributed forms remain. Cargo's
+[feature contract](https://doc.rust-lang.org/1.85.1/cargo/reference/features.html)
+and BUILD-MAP-X map the boolean `burst` state; BUILD-MAP-X maps each supported
+target triple to its stated `target_arch`.
+
+`src/lib.rs:3-13` rejects neither or both allocator cfgs. On the supported Cargo
+interface exactly one is present, so those guards are inactive. For the listed
+Wasm target plus `arena`, lines 15-16 retain `compile_error!`, which
+[`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)
+documents as causing compilation to fail. This proves the policy exclusion.
+Unlisted targets and manual `rustc` cfg invention are outside the theorem and
+are not claimed generally rejected.
+
+The only language-reachable crate API is safe
+`lane_id(u8) -> NonZeroU8` (`src/lib.rs:23-46`). There are no crate-defined
+public fields/types, unsafe APIs/traits/impls, callbacks, FFI, statics,
+reexports, exported macros, or hidden APIs. The two unsafe consumers are lines
+31 and 44. There is no crate-owned temporal invariant; each call must locally
+establish that its particular argument is nonzero.
+
+Profiles, optimization, debug assertions, and panic strategy do not select code
+here. There is no arithmetic, debug assertion, mutable state, destructor-held
+invariant, concurrency, allocation-sensitive unsafe operation, or unwinding
+cleanup obligation, so the proofs are parametric over those axes.
+
+## TCB and authoritative premises
+
+**BUILD-MAP-X (accepted, not widened):** exactly the proposition and scope in
+supplied `TCB.md`: Cargo 1.85.1 executes this build script as required; honors
+its rerun directive; check-cfg declares without setting; transmits emitted
+allocator cfgs; maps enabled `burst` and the three target triples as stated; and
+performs no library compilation after unsuccessful build-script exit. It is
+consumed only for reachability and rejection. It does not establish the emitted
+string, source correctness, abstract semantics, backend correctness, or a
+binary theorem. Any named input, Cargo/toolchain, source, target-set, or human
+disposition change triggers review.
+
+**AXIOM-NZ (Rust/std 1.85.1):**
+[`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)
+requires that its value “must not be zero”; zero produces undefined behavior.
+Consumers: O-03/O-04.
+
+**AXIOM-FLOW (Rust 1.85.1):** equality compares the operands, and an
+[`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)
+executes its consequent when its Boolean condition is true. The
+[`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html) macro panics
+the current thread. Consumers: O-03/O-05.
+
+**AXIOM-CFG/BUILD:** the version-matched cfg, feature, environment, output, and
+compile-error pages cited above supply only the propositions used in the
+configuration derivation. There are no safe/unsafe third-party dependencies,
+tool-derived facts, implementation premises, or other admitted assumptions.
+
+## Obligation ledger and proofs
+
+| ID | Proposition and complete domain | Derivation | Status |
+|---|---|---|---|
+| O-01 | Accepted selector yields exactly one supported cfg; rejected values yield no library compilation | `build.rs:9-20`, AXIOM-CFG/BUILD, BUILD-MAP-X | PROVED |
+| O-02 | `wasm32`+`arena`, either feature state, cannot ship | `lib.rs:15-16`, AXIOM-CFG/BUILD, BUILD-MAP-X | PROVED |
+| O-03 | Line 44 receives nonzero in all nine ordinary tuples | Its cfg is the complement of the special conjunction. If `value == 0`, lines 40-42 panic and line 44 is not reached; normal reach therefore entails `value != 0`, satisfying AXIOM-NZ. For nonzero, `new_unchecked` returns the corresponding `NonZeroU8`. | PROVED |
+| O-04 | Line 31 receives nonzero for every safe call in the special tuple | The `u8` parameter is caller-controlled and unchecked. `value = 0` is well typed and falsifies the required premise. | UNSOUND |
+| O-05 | Zero input panics | In ordinary tuples O-03 reaches `panic!`. In the special tuple line 31 instead reaches UB; that execution cannot prove or refute a defined postcondition. | PROVED ordinary / UNPROVED special |
+
+This also proves build-script source soundness: it contains no unsafe operation,
+and all branches use safe std APIs; its documented rejection behavior is
+covered by O-01.
+
+## F-01 — supported safe call violates `NonZeroU8` validity
+
+- **Affected claim/configuration:** public safe `lane_id`, all profiles/debug
+  states under `aarch64-unknown-linux-gnu` + `arena` + enabled `burst`.
+- **Proof artifact:** `lib.rs:30` says burst-mode identifiers are never zero.
+  That is an unsupported assertion about an arbitrary safe caller's `u8`, not
+  an invariant, check, type fact, or postcondition. The smallest false
+  implication is “this cfg conjunction and caller input imply `value != 0`.”
+- **UB witness:** BUILD-MAP-X makes lines 24-32 active and lines 34-45 absent.
+  A safe caller invokes `lane_id(0)`; line 31 calls `new_unchecked(0)`, which
+  AXIOM-NZ classifies as UB. No caller-side safety obligation exists.
+- **Defined postcondition refutation:** not established; the witness contains
+  UB. Hence soundness is `UNSOUND` and the special-tuple panic postcondition is
+  `UNPROVED`.
+- **Minimum repair:** remove the special case and use the checked path, or make
+  a zero check dominate line 31 (prefer safe `NonZeroU8::new(value)` plus the
+  documented panic). A comment-only or documentation-only change cannot repair
+  a safe API with a hidden safety precondition. After a check, suitable proof
+  text is: “Reaching this call means the preceding zero branch panicked, so
+  `value != 0`, satisfying `new_unchecked`'s safety precondition.” Re-audit all
+  ten tuples; the repair restores rather than weakens the published panic
+  behavior.
+
+## Residual scope and review triggers
+
+Excluded: unlisted targets, Rust/Cargo/std versions other than 1.85.1, manual
+cfg injection, and compiler/backend/binary behavior. No tool evidence was used.
+Review is invalidated by any source, manifest, support/build policy, allocator
+mapping, feature/target set, relevant Rust documentation, or BUILD-MAP-X change.
+Every in-scope surface, unsafe site, supported tuple class, mandatory documented
+behavior, and enforced exclusion has a disposition above; independent review
+was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/G.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/G.md
new file mode 100644
index 0000000000..af86a361c9
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/G.md
@@ -0,0 +1,62 @@
+# Unsafe Rust Audit: `cross-axis-target` 0.1.0
+
+## Claim and verdict
+
+This is a source-level audit of the complete supplied crate (`Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`) under Rust/Cargo/stdlib 1.85.1 and the Rust abstract semantics. For every well-typed safe call to `lane_id` in every supported configuration, the soundness claim is absence of Rust undefined behavior; documented behavior is also in scope.
+
+**Overall soundness: UNSOUND (F-1).** The supported region `B = {target=aarch64-unknown-linux-gnu, feature burst enabled, allocator=arena}` is `UNSOUND` in every Cargo profile and either debug-assertion state. The supported complement is `PROVED` relative to TCB-1 and the Rust axioms below.
+
+**Documented behavior:** `PROVED` on the supported complement. In `B`, the documented “Panics when value is zero” postcondition is `UNPROVED`, not `CONTRACT-BROKEN`: the only established zero-input witness contains UB, so it cannot establish a UB-free behavioral refutation. For nonzero inputs in `B`, construction is proved.
+
+**Combined mandatory result: UNSOUND; zero-input panic postcondition UNPROVED in B.** No binary/backend claim is made.
+
+## Snapshot, supported set, and configuration closure
+
+`Required(t,f,a,p,d)` means: the supplied source; edition 2021; Rust, Cargo, and std 1.85.1; `t` in `{x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`; `f` is either state of `burst`; `a` is `system` or `arena` selected through `FIXTURE_ALLOCATOR` and Cargo/build.rs; `p` is any Cargo profile; and `d` is either debug-assertion state; except `(t=wasm32-unknown-unknown, a=arena)`. `SUPPORT.md` and `BUILD.md` control this predicate. No dependencies or generated source exist; the build script generates only cfg options.
+
+Local build-script dataflow maps an absent selector to `system`, accepts exactly `system|arena`, emits one matching `fixture_allocator` cfg, and panics for non-Unicode or other values. TCB-1 supplies only Cargo’s execution/directive, feature, and target-cfg mappings and the rule that unsuccessful build scripts produce no library compilation. Thus invalid selectors are effectively rejected. A stdout infrastructure failure likewise yields no library compilation, but TCB.md expressly says it is not a successful policy rejection.
+
+For successful accepted builds, the source predicates form the exhaustive partition `B` versus `not(B)`. Profiles and debug assertions affect no source selection or proof fact. The wasm32/arena pair activates `compile_error!`, which [causes compilation to fail](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html); it is effectively rejected for both feature states, every profile, and either debug-assertion state. The earlier selector checks are inactive under TCB-1’s exactly-one mapping but reject absent, unknown, or simultaneous manually injected selector cfgs. Such direct-rustc builds, all other targets/toolchains, and invented cfgs are outside `Required`.
+
+## Boundary and invariant inventory
+
+The sole downstream surface is safe public `lane_id(u8) -> NonZeroU8`. There are no public fields, unsafe APIs/traits/impls, callbacks, macros, hidden items, mutable state, FFI, concurrency, allocators actually called, or destruction invariants. The only invariant is local: **INV-NZ:** immediately before either `NonZeroU8::new_unchecked(value)`, `value != 0` must hold. Std’s exact contract says [“The value must not be zero” and zero causes UB](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked).
+
+## Obligation ledger and proofs
+
+| ID | Scope | Obligation and derivation | Status |
+|---|---|---|---|
+| O-1 | build/config | Accepted environment values emit exactly one allocator selector; TCB-1 transfers it and the feature/target cfgs. Invalid environment values panic and TCB-1 prevents library compilation. | PROVED |
+| O-2 | excluded wasm32/arena | Accepted `arena` plus wasm32 target makes the cfg predicate true; `#[cfg]` includes the `compile_error!`, so no library artifact is produced. | PROVED |
+| O-3 | `not(B)`, `lane_id(0)` | For primitive `u8`, `==` means equality ([Reference](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators)). The true consequent executes and later code is skipped ([if expressions](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)); `panic!` [panics the current thread](https://doc.rust-lang.org/1.85.1/std/macro.panic.html). No unsafe call is reached. | PROVED |
+| O-4 | `not(B)`, `lane_id(value != 0)` | The zero branch is skipped; the dominating comparison establishes INV-NZ, satisfying `new_unchecked`. The return is a valid `NonZeroU8` constructed from `value`. | PROVED |
+| O-5 | `B`, nonzero input | The cfg-selected early branch calls `new_unchecked(value)`; the call-site input fact satisfies INV-NZ. | PROVED |
+| O-6 | `B`, all safe inputs | The same branch performs no check. Safe callers may pass every `u8`, including zero; INV-NZ is not established. | UNSOUND (F-1) |
+
+The fallback safety comment is a correct concise local proof: reaching its call after the zero branch entails nonzero. The special-branch comment is not a proof; neither the type nor any constructor/boundary establishes its assertion.
+
+## Finding F-1 — supported safe call violates `new_unchecked`
+
+- **Status/severity:** critical, `UNSOUND`; proof artifact deficient.
+- **Configuration:** `aarch64-unknown-linux-gnu`, `burst`, `arena`, every supported profile/debug-assertion state.
+- **Valid witness:** choose `FIXTURE_ALLOCATOR=arena`, enable `burst`, select the supported aarch64 target, then safe code calls `lane_id(0)`. TCB-1 and local build logic select the early cfg block. It executes `unsafe { NonZeroU8::new_unchecked(0) }`; the version-matched std contract explicitly classifies zero as UB.
+- **Defect:** “Burst-mode lane identifiers are never zero” reverses no producer contract and is false for the unconstrained safe parameter. A safe API cannot impose this hidden caller obligation.
+- **Postcondition classification:** this UB-containing execution proves soundness `UNSOUND` but does not prove the panic guarantee `CONTRACT-BROKEN`; that guarantee remains `UNPROVED` in `B`.
+- **Minimum repair:** remove the special path and use the checked constructor, e.g. `NonZeroU8::new(value).expect("lane identifier must be nonzero")`, or add the same unconditional zero check before the unsafe call. After a check, suitable proof text is: “The dominating `value == 0` branch panics; therefore reaching this call establishes `value != 0`, exactly `new_unchecked`’s precondition.” Re-audit the changed snapshot and all cfg regions. This restores the published safe contract; it does not legitimize the old hidden obligation.
+
+## TCB audit log
+
+| ID | Category/disposition | Exact proposition and scope | Consumers / trigger |
+|---|---|---|---|
+| TCB-1 (`BUILD-MAP-X`) | IMPLEMENTATION, human-accepted | Exactly the Cargo 1.85.1 directive/rerun, unsuccessful-script, `burst`, and three named target-cfg mappings stated in supplied `TCB.md`; successful stdout scope only. It does **not** trust local source correctness, emitted string choice, Rust semantics, backend, or binary. | O-1, O-2, O-6; re-audit on any identity/interface/source/cfg/target/disposition change listed there. |
+| AXIOM-NZ | Rust std 1.85.1, authoritative | `NonZero::new_unchecked(n)` requires nonzero and zero causes UB. | O-4–O-6; documentation/toolchain change. |
+| AXIOM-CONTROL | Rust Reference 1.85.1, authoritative | Primitive equality and `if` control flow used above; cfg selects attributed source by its predicate. | O-2–O-4, O-6; Reference/toolchain change. |
+| AXIOM-PANIC | Rust std 1.85.1, authoritative | Invoked `panic!` panics the current thread. | O-3; documentation/toolchain change. |
+
+No premise widens TCB-1. No selected safe/unsafe dependency or tool-derived evidence is consumed. No tests, builds, execution, expansion, or prior audit were used.
+
+## Residual scope and re-audit triggers
+
+Excluded are unsupported configurations, direct rustc/invented cfg builds, compiler/backend correctness, binaries, deployment behavior, and infrastructure-failed attempts. There is no authoritative-documentation or skill-guidance gap material to the verdict. Re-audit on any source, contract, support policy, Cargo/Rust/std, build environment/interface, target/feature/allocator set, cfg generation, or TCB disposition change.
+
+**Audit date:** 2026-08-01. **Independent review:** not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/H.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/H.md
new file mode 100644
index 0000000000..0c3366994f
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/H.md
@@ -0,0 +1,71 @@
+# Unsafe Rust source audit: `cross-axis-target` 0.1.0
+
+## Claim, snapshot, and verdicts
+
+This review covers the complete supplied `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`, source-only and without execution, expansion, or testing. The audited compiler, Cargo, and standard library are exactly Rust 1.85.1; edition 2021. The audit cutoff is 2026-08-01. There are no dependencies, generated source files, FFI, assembly, concurrency, allocator operations, or tool-derived proofs. The build script generates only a checked `cfg` selector.
+
+**Soundness verdict: UNSOUND.** There is a valid safe call in a supported configuration that executes `NonZeroU8::new_unchecked(0)`. This is a complete existential UB certificate below.
+
+**Documented `lane_id(0)` panic postcondition: UNPROVED over the complete supported domain.** It is PROVED outside the defective configuration region. In that region the zero-input execution has UB, so it cannot witness `CONTRACT-BROKEN`, and no independent UB-free refutation was established.
+
+**Build-interface mapping and required policy rejection: PROVED**, relative only to accepted TCB entry `BUILD-MAP-X` and the Rust/Cargo 1.85.1 axioms listed below.
+
+## Required domain and closure
+
+Let `T={x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, wasm32-unknown-unknown}`, `B={burst off,on}`, `A={system,arena}`, `P` be every Cargo profile, and `D={debug assertions off,on}`. From `SUPPORT.md:3-16` and `BUILD.md:3-14`, exactly
+
+`Required = Rust/Cargo 1.85.1 × {(t,b,a,p,d) in T×B×A×P×D | not(t=wasm32-unknown-unknown and a=arena)}`,
+
+for Cargo builds using the supplied build script and accepted selector input. Safe API inputs additionally quantify over every `value: u8`. Build-script stdout failures produce no library compilation and are not members, exactly as `BUILD-MAP-X` states. Manual `rustc` cfg injection, other toolchains/targets/features, and invalid selector values are outside `Required`; this does not call them project-supported.
+
+The controlling sources agree. `Cargo.toml:8-10` makes `burst` the sole feature. `build.rs:9-20` maps an absent variable to `system`, preserves `system` or `arena`, and panics for non-Unicode or every other string. This follows from [`env::var`](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html), [`str::to_owned`](https://doc.rust-lang.org/1.85.1/std/primitive.str.html#impl-ToOwned-for-str), [`String::as_str`](https://doc.rust-lang.org/1.85.1/std/string/struct.String.html#method.as_str), match/literal/or/wildcard-pattern semantics, format capture, and stdout printing. For each accepted path with successful writes, line 18 emits exactly the corresponding one selector. `BUILD-MAP-X`—and nothing broader—is then consumed to pass that selector and map `burst` and target triples to cfgs. Its unsuccessful-script clause makes the two panic paths effective rejections.
+
+The source partitions every supported library compilation by
+
+`X = burst && target_arch="aarch64" && fixture_allocator="arena"`
+
+and `!X`; [`cfg`](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute) makes the blocks at `src/lib.rs:29-32` and `39-45` complementary. Thus the partition is exhaustive for every profile/debug state. Aggregate soundness coverage is
+
+`Covered = (Required × all u8 inputs) \ {(aarch64,burst-on,arena,p,d,value=0) | all p,d}`.
+
+Consequently `Required×u8` is not contained in `Covered`; the displayed remainder is the witness region.
+
+## Boundary, invariants, and obligation ledger
+
+The complete downstream safe surface is the public safe free function `lane_id(u8) -> NonZeroU8` (`src/lib.rs:23`). It has no fields, custom types/traits/impls, callbacks, statics, exports, hidden items, reexports, or generated APIs. `build.rs::main` is the only build entrypoint. The only unsafe operations are the mutually exclusive calls at `src/lib.rs:31` and `:44`.
+
+The needed local invariant is `NZ(value): value != 0`, required immediately before either unchecked call. In `!X`, `value == 0` executes `panic!`; only the false branch reaches line 44, so comparison and [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html) semantics establish `NZ`. In `X`, no check establishes it. The line-30 comment, “Burst-mode lane identifiers are never zero,” is not an invariant: `value` is controlled by an arbitrary safe caller.
+
+| ID | Obligation | Domain | Status/proof |
+|---|---|---|---|
+| O1 | Build emits exactly one `system`/`arena` selector or rejects | documented Cargo interface | PROVED by build control flow plus `BUILD-MAP-X` |
+| O2 | Unsupported wasm32+arena cannot produce a library | either burst state, all profiles/debug states | PROVED: `src/lib.rs:15-16` selects [`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html); `BUILD-MAP-X` supplies cfg reachability |
+| O3 | `new_unchecked` receives nonzero | `!X`, all inputs/profiles/debug states | PROVED by the dominating zero branch |
+| O4 | same | `X` | UNSOUND for input zero; PROVED only for inputs 1..=255 |
+| O5 | `lane_id(0)` panics | all `Required` | PROVED on `!X` using [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html); UNPROVED on `X` because execution has UB |
+
+The no-selector and both-selector guards (`src/lib.rs:3-13`) also cause compilation failure if encountered, but supported Cargo mapping already supplies exactly one. They do not widen the theorem to manually invented cfgs.
+
+## Finding F1 — supported safe call has undefined behavior
+
+- **Affected claim:** complete-domain safe-library soundness; severity critical.
+- **Valid in-scope use:** build for `aarch64-unknown-linux-gnu`, `burst` enabled, `FIXTURE_ALLOCATOR=arena`, any Cargo profile/debug-assertion state, then safe code calls `lane_id(0)`. `SUPPORT.md` supports this combination; `BUILD.md`, local build-script flow, and accepted `BUILD-MAP-X` establish its three cfg predicates.
+- **Reachability:** those predicates select `src/lib.rs:29-32` and remove the complementary checked block. Line 31 executes `NonZeroU8::new_unchecked` with `n=0`.
+- **False safety proposition:** the Rust 1.85.1 contract says, “The value must not be zero.” Here it is zero.
+- **UB consequence:** the same authoritative documentation says, “This results in undefined behavior if the value is zero.” See [`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked).
+- **Proof artifact:** the existing SAFETY comment is false and omits any producer/enforcement argument. This is an implementation defect as well as deficient proof documentation.
+- **Postcondition classification:** this UB-containing execution does not prove `CONTRACT-BROKEN`; the full-domain panic guarantee remains UNPROVED.
+- **Minimum repair:** remove the special block and use the checked implementation for every configuration (or explicitly check zero before line 31). A suitable adjacent proof is: “`value == 0` has returned by panicking; therefore this point has `value != 0`, satisfying `new_unchecked`.” Do not add a caller precondition to the safe API. Re-audit both unsafe sites, cfg closure, and the panic guarantee after repair.
+
+## Rejected configurations
+
+- Omitted/`system` and `arena` are accepted as documented. Non-Unicode and every other Unicode value reach `panic!`; by `BUILD-MAP-X`, unsuccessful scripts halt before library compilation.
+- `wasm32-unknown-unknown` plus `arena`, with either feature state and every profile/debug state, reaches `compile_error!` at lines 15-16 and produces no supported library artifact. This is the one policy-mandated source rejection.
+- A stdout failure is an infrastructure failure, not a selector-policy rejection, per `BUILD-MAP-X`.
+- Other targets/toolchains/features and manual missing, duplicate, unknown, or forged cfgs are excluded by the controlling policy, not certified as supported or universally rejected.
+
+## TCB audit log
+
+`TCB.md/BUILD-MAP-X` is accepted exactly for Cargo 1.85.1 execution, rerun/check-cfg/rustc-cfg transport, feature/target mapping, and halt-on-unsuccessful-build-script propositions. Consumers are O1, O2, and F1 reachability. The review does **not** admit its excluded local-source, abstract-semantics, backend, or binary propositions. The remaining axioms are the linked Rust 1.85.1 Reference/std contracts, especially the exact `new_unchecked` precondition and UB consequence. No dependency, implementation, platform, probabilistic, or tool premise was added.
+
+Re-audit on any source, manifest, support/build policy, Rust/Cargo/std identity, environment interface, target/feature/cfg mapping, documented behavior, or TCB disposition change. Independent review was not performed.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/I.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/I.md
new file mode 100644
index 0000000000..4e6ee6a1dd
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/I.md
@@ -0,0 +1,75 @@
+# Unsafe Rust source audit: `cross-axis-target`
+
+## Claim and verdict
+
+This review covers the complete supplied crate: `Cargo.toml`, `build.rs`, `src/lib.rs`, `BUILD.md`, `SUPPORT.md`, and `TCB.md`, on the exact supplied source snapshot. The source-level claim is: every well-typed safe use of the public library API is free from Rust undefined behavior for every supported build, relative only to the TCB below.
+
+`Supported(C)` means Rust, Cargo, and standard library 1.85.1; edition 2021; a target in {`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, `wasm32-unknown-unknown`}; either state of feature `burst`; allocator selector `system` or `arena` obtained through `build.rs` as specified by `BUILD.md`; any Cargo profile and either debug-assertion state; excluding `wasm32-unknown-unknown` + `arena`. Build-script stdout writes must succeed for an accepted-selector library compilation. This predicate is fixed by the manifest, `SUPPORT.md`, `BUILD.md`, and accepted `BUILD-MAP-X`; they do not conflict.
+
+- **Complete supported-domain soundness: UNSOUND** (`F-01`).
+- **Region `Rbad`: UNSOUND.** `Rbad = Supported(C) && target=aarch64-unknown-linux-gnu && allocator=arena && burst=enabled`, in every profile/debug-assertion state.
+- **Region `Supported \\ Rbad`: PROVED** source-sound relative to the stated TCB and Rust 1.85.1 axioms below.
+- **Documented `lane_id(0)` panic, complete supported domain: UNPROVED** (`F-01`). It is proved on `Supported \\ Rbad`; the only established contrary execution in `Rbad` contains UB, so it cannot establish `CONTRACT-BROKEN`.
+- **Documented build selection/rejection behavior and the required wasm/arena exclusion: PROVED** relative to `BUILD-MAP-X`.
+
+No binary/backend, future-toolchain, security, resource, or manually-invoked-`rustc` claim is made.
+
+## Snapshot, surfaces, and trust boundary
+
+There are no third-party dependencies, generated Rust files, FFI, assembly, unsafe declarations/traits/impls, public fields, macros exported by the crate, callbacks, or invariant-bearing project types. The build script generates only a `fixture_allocator` configuration option. No prior audit or tool-derived evidence was used; the target was not built, run, tested, or expanded.
+
+API/operation inventory:
+
+| ID | Surface/site | Domain | Status |
+|---|---|---|---|
+| API-01 | safe public `lane_id(u8) -> NonZeroU8`, `src/lib.rs:23` | every compiled supported library | `UNSOUND` via OBL-03 |
+| UNSAFE-01 | `NonZeroU8::new_unchecked(value)`, line 31 | exactly `Rbad` | violated for `value=0` |
+| UNSAFE-02 | same operation, line 44 | `Supported \\ Rbad` | proved |
+| BUILD-01 | environment parsing and cfg emission, `build.rs:3-21` | Cargo builds through documented interface | proved |
+| REJECT-01 | three `compile_error!` guards, `src/lib.rs:3-16` | selected cfg combinations | proved as detailed below |
+
+The sole local invariant consumed is **INV-NZ**: at either unsafe call, the argument must be nonzero. It is owned by the immediately dominating control-flow proof; no type-wide or allocator-wide invariant supplies it.
+
+### TCB log (revision: supplied `TCB.md`)
+
+| ID | Category/disposition | Exact consumed proposition | Scope/consumer |
+|---|---|---|---|
+| BUILD-MAP-X | accepted human build-tool premise | Exactly the Cargo/target/feature/cfg mapping, rebuild behavior, and unsuccessful-build behavior stated in `TCB.md:5-32` | configuration reachability and rejection only |
+| AXIOM-NZ-1.85.1 | versioned std axiom | `NonZero::new_unchecked` “results in undefined behavior if the value is zero”; its safety requirement is that the value not be zero | UNSAFE-01/02; [Rust 1.85.1 std](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked) |
+| AXIOM-CFG/FLOW/PANIC | versioned Reference/std axioms | `cfg` selects attached source by its predicate; `if` selects its consequent on true; `u8 == 0` tests equality; encountered `compile_error!` prevents compilation; `panic!` panics the current thread | case partition and rejection; [cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute), [if](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html), [comparison](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators), [compile_error](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html), [panic](https://doc.rust-lang.org/1.85.1/std/macro.panic.html) |
+
+`BUILD-MAP-X` is not widened to assert which string this source emits, source correctness, abstract Rust semantics, or backend correctness. Changes to any identity or input named in that entry trigger re-audit.
+
+## Configuration closure and obligation ledger
+
+`build.rs` first emits the rebuild and expected-value declarations. `env::var` then partitions inputs: absence constructs exactly `system`; Unicode `system` and `arena` retain those exact strings; non-Unicode input panics. The following literal/or/wildcard match emits exactly one quoted selector only for `system` or `arena`, and panics for every other Unicode value. Because formatting occurs only after that exact match, no arbitrary value can enter the directive. `BUILD-MAP-X` transfers the emitted selector to the library and makes an unsuccessful script/stdout write produce no library compilation.
+
+For every accepted build, exactly one supported allocator cfg is therefore set. The first two library guards are inactive. On `wasm32` + `arena`, the third guard is active and `compile_error!` prevents a library artifact, satisfying the sole support-policy exclusion. Invalid or non-Unicode environment values are rejected earlier by the script. A stdout infrastructure failure also yields no compilation, but per `TCB.md` is not classified as a successful policy rejection. No/dual/invented selectors from manual `rustc` are outside the theorem; the no/dual cases are nevertheless guarded.
+
+The unsafe implementation has an exhaustive cfg partition:
+
+| Obligation | Exact proposition | Derivation/status |
+|---|---|---|
+| OBL-01 | supported configuration coverage | `BUILD-MAP-X` plus the three literal cfg axes gives `Rbad` or its exact complement; profile/debug assertions do not occur in source. Proved. |
+| OBL-02 | excluded wasm/arena cannot ship | accepted selector reaches the third guard, which causes compilation failure. Proved. |
+| OBL-03 | UNSAFE-01 argument is nonzero for every safe call | No check, type restriction, privacy boundary, or caller contract establishes this. False for `value=0`; `UNSOUND`. |
+| OBL-04 | UNSAFE-02 argument is nonzero | If `value == 0`, `panic!` executes before the unsafe call. Reaching line 44 therefore entails `value != 0`, satisfying AXIOM-NZ. Proved over the exact complement of `Rbad`. |
+| OBL-05 | safe API is sound for all `u8` | OBL-04 proves the complement, but OBL-03 refutes the universal claim. `UNSOUND`. |
+| OBL-06 | `lane_id(0)` panics | The dominating zero branch proves it outside `Rbad`. In `Rbad`, the established execution has UB at UNSAFE-01; complete-domain postcondition remains `UNPROVED`, not `CONTRACT-BROKEN`. |
+
+For nonzero inputs in either region, AXIOM-NZ is satisfied. There are no later unsafe consumers or state transitions. This proof is parametric over all profiles, debug-assertion states, and supported targets sharing each cfg case.
+
+## F-01 — unchecked zero in a safe API
+
+- **Status:** `UNSOUND`; implementation defect and deficient local proof comment.
+- **Affected claim/configuration:** API-01 in every `Rbad` build.
+- **Valid witness:** Build through Cargo 1.85.1 for `aarch64-unknown-linux-gnu`, set `FIXTURE_ALLOCATOR=arena`, enable `burst`, and let stdout writes succeed. These choices are supported, and `BUILD-MAP-X` makes all three cfg predicates at lines 25-27 true. Well-typed safe code calls `lane_id(0)`. The selected block reaches line 31 with `value == 0`; AXIOM-NZ says this is undefined behavior.
+- **Defect:** The comment “Burst-mode lane identifiers are never zero” reverses no producer contract and cites no enforced invariant. `value` is the safe caller's unconstrained `u8`; the function documentation actually promises to panic on zero.
+- **Postcondition classification:** This UB-containing witness cannot prove an UB-free failure to panic. No independent UB-free refutation is established, so the documented panic is `UNPROVED` in `Rbad`.
+- **Minimum repair:** Make the zero check dominate the unsafe call in every configuration (the existing complement branch is sufficient), or use a checked safe constructor with explicit zero-to-panic handling. Replace the comment with the line-identified dominating-check derivation used for OBL-04. Re-audit the changed snapshot across the full cfg partition.
+
+## Residual scope and review triggers
+
+Unsupported combinations are limited to invalid/non-Unicode allocator input, wasm/arena, and manual/invented rustc cfg use as described above; each enforcement or theorem exclusion is explicit. Future Rust/Cargo versions, custom targets, backend/binary behavior, and environmental behavior beyond `BUILD-MAP-X` are excluded.
+
+Re-audit on any source, manifest, support/build documentation, public contract, Rust/Cargo identity, target set, feature, environment interface, emitted cfg, TCB disposition, or relevant authoritative-documentation change. Every in-scope site has a disposition; the complete supported-domain result remains **UNSOUND** until F-01 is repaired and the new snapshot is audited.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/J.md b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/J.md
new file mode 100644
index 0000000000..b40a037b77
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/reports/J.md
@@ -0,0 +1,146 @@
+# Unsafe Rust source audit: supplied crate snapshot
+
+## Claim and verdicts
+
+Audit cutoff: 2026-08-01. The artifact is exactly the supplied `Cargo.toml`,
+`build.rs`, `BUILD.md`, `SUPPORT.md`, `TCB.md`, `REQUEST.md`, and `src/lib.rs`;
+no expansion, build, execution, test, prior audit, dependency resolution, or
+generated file was used.
+
+**SOUND — UNSOUND.** For Rust/standard library 1.85.1, the complete crate is
+not free of Rust undefined behavior for every well-typed safe use over
+`Required` below, relative only to accepted TCB entry `BUILD-MAP-X` and the
+version-matched Rust axiom `AXIOM-NZ`. Finding F-1 is a complete existential
+certificate.
+
+**POST-PANIC — UNPROVED over `Required`; PROVED over `Required ∧ ¬Bad`.** The
+documented safe-API guarantee “Panics when `value` is zero” holds outside
+`Bad`. In `Bad`, the zero call has UB, so it cannot be a UB-free
+`CONTRACT-BROKEN` witness. No independent UB-free refutation is established.
+
+Thus the strongest combined result over the complete supported domain is
+**UNSOUND**, with the documented zero-input behavior additionally **UNPROVED**.
+
+## Snapshot, domain, and closure
+
+The manifest fixes edition 2021, Rust 1.85.1, no dependencies, feature set
+`{burst}`, and this build script/library. Let
+
+```text
+T = {x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu,
+     wasm32-unknown-unknown}
+A = {system, arena}
+Required(t,b,a,p,d) = t∈T ∧ b∈{off,on} ∧ a∈A
+                      ∧ ¬(t=wasm32-unknown-unknown ∧ a=arena)
+                      ∧ p is any Cargo profile ∧ d∈{off,on}.
+Bad = Required ∧ t=aarch64-unknown-linux-gnu ∧ b=on ∧ a=arena.
+Good = Required ∧ ¬Bad.
+```
+
+This is an equality normalization of `SUPPORT.md:3-16`: the three listed
+targets, both feature states, both BUILD-selected allocators, the single
+wasm/arena exclusion, every profile, and either debug-assertion state.
+`BUILD.md:3-14` restricts supported selection to Cargo plus `build.rs`:
+missing/`system` selects system, `arena` selects arena, and other values are
+rejected. Invented cfgs and manual rustc are outside `Required`.
+
+`build.rs:9-21` exhaustively maps `env::var`: absence creates `system`; the two
+exact accepted strings emit one allocator cfg; non-Unicode or any other string
+panics. `BUILD-MAP-X` establishes Cargo's exact propagation of emitted
+allocator cfg, `burst`, and each target architecture, and establishes that a
+failed script/output write yields no library compilation. The `rustc-check-cfg`
+line declares but does not set values. Therefore accepted builds reach exactly
+one allocator selector. This uses the version-matched [`env::var`
+contract](https://doc.rust-lang.org/1.85.1/std/env/fn.var.html).
+
+The only unsafe-code selector is `Bad` (`src/lib.rs:24-38`). No profile,
+debug-assertion, optimization, panic-strategy, allocator implementation, or
+other target property affects either unsafe operation. Hence the proofs below
+are parametric in those axes: `Covered(SOUND)=Good`, while F-1 refutes SOUND on
+`Bad`; `Good ∪ Bad = Required`.
+
+## Boundary, API, and invariant inventory
+
+The complete language-reachable project surface is build entrypoint `main`
+with `FIXTURE_ALLOCATOR`, compile-time cfg gates, and the one public safe
+function `lane_id(u8) -> NonZeroU8`. There are no public fields, project types,
+unsafe APIs/traits/impls, macros, callbacks, statics, FFI, assembly, generated
+source, or hidden APIs. The only unsafe operations are
+`NonZeroU8::new_unchecked` at `src/lib.rs:31` and `:44`.
+
+Invariant `INV-NZ`: immediately before either unsafe constructor, its argument
+must be nonzero. It is local to `lane_id`; there is no persistent
+invariant-bearing representation. The Rust 1.85.1 contract says “The value must
+not be zero” and that zero produces UB
+([`NonZero::new_unchecked`](https://doc.rust-lang.org/1.85.1/std/num/struct.NonZero.html#method.new_unchecked)).
+
+## Obligation ledger
+
+| ID | Site/domain | Required proposition | Derivation/status |
+|---|---|---|---|
+| O-CFG | build/configuration | Exact supported reachability and exclusions | Source mapping plus accepted `BUILD-MAP-X`; proved. |
+| O-31 | `lib.rs:31`, `Bad` | `value != 0` | False for safe input 0; **UNSOUND**, F-1. |
+| O-44 | `lib.rs:44`, `Good` | `value != 0` | The active branch executes `panic!` when `value == 0`; reaching line 44 therefore entails nonzero ([comparison](https://doc.rust-lang.org/1.85.1/reference/expressions/operator-expr.html#comparison-operators), [`if`](https://doc.rust-lang.org/1.85.1/reference/expressions/if-expr.html)). Proved for every `Good` case. |
+| O-PANIC | `lane_id(0)` | Panic | `Good`: explicit [`panic!`](https://doc.rust-lang.org/1.85.1/std/macro.panic.html), proved. `Bad`: UB witness, postcondition unproved. |
+
+Line 43's adjacent proof is sufficient: the dominating zero branch and
+control flow establish the exact constructor precondition. Line 30's comment
+is deficient and false: neither the `u8` type nor any check constrains the safe
+argument in burst mode.
+
+## F-1 — supported safe call invokes `new_unchecked(0)`
+
+- **Status:** UNSOUND implementation; missing/invalid proof artifact; affects
+  SOUND and POST-PANIC.
+- **Configuration:** Rust 1.85.1,
+  `aarch64-unknown-linux-gnu`, `burst=on`, allocator `arena`, any Cargo profile
+  and either debug-assertion state. `SUPPORT.md` includes it, `BUILD.md` permits
+  `FIXTURE_ALLOCATOR=arena`, and `BUILD-MAP-X` proves the cfg mapping. It is not
+  the excluded wasm/arena pair.
+- **Valid use:** downstream safe Rust calls public safe `lane_id(0)`; the API
+  has no safety precondition.
+- **Reachability:** the configuration includes `lib.rs:24-32` and excludes
+  `:34-45`; line 31 is executed before return, without testing `value`.
+- **False proposition:** the argument to `new_unchecked` is exactly zero,
+  contradicting `AXIOM-NZ`'s safety requirement.
+- **UB consequence:** the same authoritative Rust 1.85.1 documentation states
+  that zero “results in undefined behavior.” This completes the existential
+  certificate; it does not depend on backend behavior or testing.
+- **Postcondition:** that execution is not UB-free, so it establishes no
+  `CONTRACT-BROKEN` verdict.
+- **Minimal repair:** remove the special unchecked branch and use the checked
+  path in every configuration (or `NonZeroU8::new(value).expect(...)`). Replace
+  line 30 with the actual dominating-check derivation. Re-audit both unsafe
+  sites and the panic guarantee after the change.
+
+## Rejected and residual configurations
+
+For accepted `arena` plus `wasm32-unknown-unknown`, `BUILD-MAP-X` makes both cfg
+predicates true and `lib.rs:15-16` activates `compile_error!`; this exactly
+enforces SUPPORT's sole supported-set exclusion
+([cfg](https://doc.rust-lang.org/1.85.1/reference/conditional-compilation.html#the-cfg-attribute),
+[`compile_error!`](https://doc.rust-lang.org/1.85.1/std/macro.compile_error.html)).
+Invalid Unicode/other allocator values fail in `build.rs`, and `BUILD-MAP-X`
+ensures no library compilation. Neither/both allocator cfgs are also rejected
+by `lib.rs:3-13`, but can arise only through out-of-scope invented cfgs under
+the documented interface. Unlisted targets, manual rustc, future Rust/Cargo,
+and invented flags are unsupported, not claimed rejected, and outside the
+theorem.
+
+## TCB audit log and evidence
+
+- **BUILD-MAP-X (accepted OUT-OF-BAND/IMPLEMENTATION premise):** exactly the
+  Cargo 1.85.1 proposition and scope in supplied `TCB.md:3-32`; consumed only
+  by O-CFG and F-1 reachability/rejection. It admits no script behavior, Rust
+  semantics, backend, or binary claim and is not widened here. Re-audit on any
+  listed identity/source/interface/target/disposition change.
+- **AXIOM-NZ (Rust axiom):** exact Rust 1.85.1 `new_unchecked` nonzero
+  precondition and zero-UB consequence; consumed by O-31/O-44/F-1. Re-audit if
+  the supported Rust or authoritative contract changes.
+
+No dependency, tool-derived, test, generated-artifact, external ABI,
+deployment, probabilistic, or binary premise is consumed. Source-level Rust
+semantics only. Review must recur on source/docs, support/build interface,
+feature/target/profile scope, Cargo/Rust identity, generated cfg mapping, TCB
+disposition, or `NonZero` contract changes. Every discovered obligation and
+documented behavior has a disposition above.
diff --git a/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/score.schema.json b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/score.schema.json
new file mode 100644
index 0000000000..b9509706d0
--- /dev/null
+++ b/evals/unsafe-rust/runs/2026-07-31-v3-targeted/scoring/packets/X/s2/score.schema.json
@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "unsafe-rust-blind-score-v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "scorer_id", "reports", "ambiguities"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "mode": {"enum": ["S", "C", "X", "Q", "W", "M", "R", "K"]},
+    "scorer_id": {"enum": ["s1", "s2"]},
+    "reports": {
+      "type": "array",
+      "minItems": 10,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "label",
+          "atoms",
+          "hard_errors",
+          "proposal_laundering",
+          "tcb_authority_defect",
+          "visible_scope_defect",
+          "novel_findings"
+        ],
+        "properties": {
+          "label": {"type": "string", "pattern": "^[A-J]$"},
+          "atoms": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "decision", "evidence"],
+              "properties": {
+                "id": {"type": "string", "pattern": "^[SCXQWMRK][1-9][0-9]*$"},
+                "decision": {"enum": ["PASS", "FAIL"]},
+                "evidence": {"type": "string", "pattern": "\\S"}
+              }
+            }
+          },
+          "hard_errors": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/hard_error"}
+          },
+          "proposal_laundering": {"$ref": "#/$defs/flag"},
+          "tcb_authority_defect": {"$ref": "#/$defs/flag"},
+          "visible_scope_defect": {"$ref": "#/$defs/flag"},
+          "novel_findings": {
+            "type": "array",
+            "items": {"$ref": "#/$defs/novel_finding"}
+          }
+        }
+      }
+    },
+    "ambiguities": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "\\S"}
+    }
+  },
+  "$defs": {
+    "hard_error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(G[1-9][0-9]*|[SCXQWMRK]H[1-9][0-9]*)$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "novel_finding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "evidence"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^N[1-9][0-9]*$"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    },
+    "flag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["present", "evidence"],
+      "properties": {
+        "present": {"type": "boolean"},
+        "evidence": {"type": "string", "pattern": "\\S"}
+      }
+    }
+  }
+}