Record validated public mixed source8 read API checkpoint

2026-09-24 21:39:52 -07:00
parent 57f07c83c4
commit d4d50f061b
12 changed files with 4164 additions and 0 deletions
@@ -757,3 +757,35 @@ three-line migration-test correction. Verify the entire successor diff and every
 other declared input, rerun the affected target plus all-target Clippy/format, and
 identify each tested code version. No Linux, GUI or release qualification follows
 from these core/CLI results. Publication remains blocked by server disk exhaustion.
+
+## 2026-09-25 — expose complete mixed validation through a borrowed read-only result
+
+Select `language::check_mixed_bundle` with an opaque non-Clone result borrowing
+the caller's complete explicit-ID SourceBundle. Retain the real resolved owner
+and return immutable Project/warning views; do not substitute a bare model or an
+incomplete editable index. The [contract](analysis-public-read-contract-20260925.md)
+records alternatives, policy and bounds. Fresh input selects both existing
+producer modes with zero carried ownership, followed by complete resolution and
+admission under the exact caller policy. Internal entry ceilings remain separate
+from final-model record limits.
+
+Promote only the required parser/resolver dependency cone to production; private
+index/edit machinery stays test-only. Normal-library tests are required because
+the production Parser layout changes even when ordinary callers select no mixed
+mode. That build exposed a missed semantic-row initializer, fixed at its source;
+two actual compiler warnings received narrow cfg/import corrections.
+
+[Windows evidence](experiments/analysis-public-read-20260925/README.md) at bab6f96
+checks complete independently authored OA/SA models, exact warnings and refusals,
+source conservation, constructor policy, source lifetimes, prior workflows and
+actual ordinary CLI behavior. All 299 core and 75 selected integration cases pass.
+Rustdoc's two compile-fail runtime names append a suffix absent from its listing:
+preserve the recorder refusal and reconcile exactly those two names against the
+successful three-case raw run. No generic name normalization or rerun is needed.
+
+This developer-facing API does not enable mixed file discovery in the CLI or
+graphical editing. Add those through explicit subsequent contracts, retaining
+filesystem safety and complete model/index ownership. Do not route a nominal
+mixed check through the ordinary loader, which currently rejects typed syntax
+and constructs editable compilation. Source/evidence are local-only pending
+confirmed publication; no release or Linux qualification follows.
@@ -57,6 +57,31 @@ preserved. [Packaged GUI evidence](reviews/prerelease37-native-gui-20260924.md),
 their bounded reviewed scopes. State label congestion, explicit transition-form
 Cancel and the preserved launcher refusals remain described in final validation.

+## Local public mixed source8 read API — 2026-09-25
+
+Source **bab6f96a5b05b37f2b5d67a430aed0f67d783e73** on
+`codex/analysis-public-read-956atf-20260925` exposes
+`language::check_mixed_bundle(&SourceBundle, ProjectLimits)`. The result borrows
+the complete explicit-ID input and exposes only its admitted Project and located
+warnings. It retains the existing syntax, storage and admission evidence; no
+editable index, save permission or CLI discovery is implied.
+
+The [contract](analysis-public-read-contract-20260925.md) and
+[Windows evidence](experiments/analysis-public-read-20260925/README.md) record
+299 core passes, ten new normal-library integration passes, 65 existing ordinary
+integration passes, three documentation cases, strict core Clippy and actual
+ordinary CLI check/rename-preview success at this exact source. All 298 prior
+core outcomes and the named small-stack controls pass. Format retains identical
+pre-existing differences. The first missing production initializer, subsequent
+warning cleanup and exact rustdoc recorder-name reconciliation are preserved.
+
+Source and evidence remain local-only: Gitea reads work, but issue comments still
+fail and the last confirmed Git publication failure was server disk exhaustion.
+The released preview is unchanged. Mixed CLI discovery, graphical/editor adoption,
+typed saving/history and the broader application remain unfinished. Existing
+depth qualification and full-pipeline small-stack limitations remain; Linux/WSL
+checks remain user-deferred.
+
 ## Local ordinary source8 compatibility — 2026-09-25

 Source **7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd** on
@@ -0,0 +1,5 @@
+*.md -text
+*.py -text
+*.txt -text
+*.json -text
+*.log -text
@@ -0,0 +1,22 @@
+# Public mixed-read launcher review
+
+Read-only pre-execution review. Gate helper SHA256 `fcc8bc586a0fe708fb0af958b8523e14ab71db503d1e107013ce5dac884a5edd`; CLI helper SHA256 `25ec9ab5aa22d7364169772eae2cc10d508415fada9845a5fb7f115e7dd3f3e0`. Both were parsed as Python AST without execution and compared with the actually used ordinary checkpoint helpers `c0126c93...` and `308fdd08...`. The gate source pin remains the deliberately unusable pending marker; no source/artifact/runtime acceptance is implied.
+
+## Narrow finding
+
+The gate now checks tracked and nonignored untracked cleanliness before Cargo, but its post-run checks cover only declared existing-file hashes, HEAD and helper bytes. A new nonignored source file created during the run would not enter `changed_inputs`, so the receipt could appear clean. The CLI helper does check full status again at the end. Record post-run `git status --porcelain --untracked-files=all` and make a nonempty result a gate verification/exit failure before claiming full clean-source binding throughout the run. This is a bounded orchestration correction, not an observed source change or application defect. Sent to parent before execution.
+
+## Reviewed behavior
+
+- The new external target `mixed_source8_read` runs as a normal Cargo integration test, with actual nonzero unique listing, exact same-source runtime names, all outcomes passing and the same Cargo-reported target artifact. Seven ordinary target/filter pairs remain unchanged; source7 selection is exact. Removed obsolete ad hoc integration mode is not part of the selected gate plan.
+- Doc listing must be nonempty and unique. Doc execution must produce precisely that name set, no ignored/failed outcome, and successful group summaries whose passed counts sum to the exact unique outcome count. Multiple rustdoc groups are permitted without accepting missing or duplicated names. No imaginary persistent doctest executable is required; Cargo/rustdoc source/input/toolchain/environment/raw output supplies this gate's binding. The actual installed rustdoc listing/output spelling still needs observation during the first parent run; a mismatch must be investigated rather than silently normalized.
+- `RUSTDOC`, `RUSTDOCFLAGS` and `CARGO_ENCODED_RUSTDOCFLAGS` must be absent and are recorded alongside the prior environment. CLI compares its whole environment to its checked build receipt, inheriting these absent settings. Jobs1 is enforced; the caller still supplies and final review verifies the established incremental0/toolchain environment. No larger stack or lifecycle override is permitted.
+- Every declared input is read against immutable Git bytes before launch and rehashed afterward; source/head and exact captured helper bytes are bound. CLI verifies its build manifest/log hashes, actual single binary bytes and declared input bytes before/between/after operations. Assertions, malformed output, timeout or missing files can terminate without a complete receipt; such a termination remains failed/incomplete evidence, never a pass.
+- CLI changes from its verified predecessor are confined to output folder/stems and full-clean checks. Its independent three-file UTF-8/CRLF literals, complete expected before/after reports and unchanged filesystem checks are unchanged. Actual commands remain ordinary `check` and rename preview, neither with `--write`; no public mixed CLI support is established. The standalone public-API whole-model test remains distinct from CLI JSON reports.
+- New gate doc modes and existing integration modes perform count/inventory checks themselves. Core list/focused/full still record rather than fully reconcile acceptance expectations; final independent runtime review must compare all prior names, intended new names, complete outcomes and actual artifacts. Format exit1 must retain its explicit inherited disposition rather than being reported as passing.
+
+Disposition: suitable after the narrow post-run cleanliness correction and reviewed source pin. No helper, compiler, test, product executable or network operation was run by this review.
+
+## Corrected recorder binding
+
+Revised gate SHA256 `9088952ca3fabf56ab4434273bf55c6ec6eb6139bc2452a7be7c66a4409e420d` now captures full post-Cargo porcelain status, records `source_status_after`, and exits nonzero if it is nonempty. AST parsing succeeds without executing the helper. The reported finding is resolved; final runtime reconciliation must require this field to be empty. CLI helper remains exact `25ec9ab5...`. Source pin is still pending; the recorders are suitable to bind to the reviewed committed source before parent execution.
@@ -0,0 +1,86 @@
+# Public mixed source8 read API: Windows evidence
+
+Final source **bab6f96a5b05b37f2b5d67a430aed0f67d783e73** on
+`codex/analysis-public-read-956atf-20260925`, based on ordinary compatibility
+source7b06b8e. Source and evidence are **local-only**, not an integrated release
+or a confirmed Gitea publication.
+
+The [selected contract](../../analysis-public-read-contract-20260925.md) exposes
+`language::check_mixed_bundle(&SourceBundle, ProjectLimits)`. It validates complete
+explicit-ID mixed ordinary/typed source8 input and returns immutable model and
+located-warning views borrowing that input. It retains actual syntax, accounting
+and admission evidence. Existing ordinary editing APIs remain separate.
+
+[evidence.zip](evidence.zip): **1,130,273 bytes, 151 members**, SHA256
+`1c20b7bffdaee9b1139b0e922d4366f6ac739f8567040e8f4723dc19e3974656`.
+[manifest.json](manifest.json) pins every member and its origin. Creation checked
+CRC, exact inventory and every unpacked member byte. The archive includes all
+27 actual Cargo receipts, two CLI receipts and original inputs, captured launchers,
+relevant baseline records, contracts, source patches, independent oracles and
+reviews. It references the audited ordinary archive rather than duplicating it.
+
+## Verified result
+
+- **299 core tests pass:** all 298 previous names/outcomes plus one new constructor
+  policy test. The focused constructor run also passes.
+- **Ten external integration tests pass** against the normal library: complete
+  independently authored OA/SA models, all located warnings, scoped identities,
+  cross-file references, explicit-ID requirements, malformed input, include/path
+  restrictions, limits, Unicode locations and unchanged source bytes.
+- **65 existing integration tests pass:** source_project33, identity_updates3,
+  nested_updates12, source_files8, r3_migration5, selected checked_save3 and one
+  exact source7 migration case. These rerun against the promoted production parser.
+- **Three documentation cases pass:** actual usage and two compile-fail lifetime
+  examples. The recorder's naming discrepancy is preserved and reconciled below.
+- **Strict core all-target Clippy passes.** Format exits1 with the unchanged raw
+  baseline SHA256 `c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d`;
+  formatting is not reported as passing.
+- The rebuilt ordinary CLI passes `check ENTRY --json` and
+  `rename-alias ENTRY team rescue_team --json`. Exact cross-file preview text and
+  unchanged complete Unicode/CRLF input inventory are checked; neither uses
+  `--write`. These are ordinary CLI regression checks, not mixed CLI support.
+
+All final gates bind this source and its 562 declared Git inputs. Core executable
+SHA256 is `01a051033bb53512a2747c2ef87e366e9b189c14df060d24284db437d39ff96a`;
+CLI executable SHA256 is `10302f9a0c17e82b57ab6498e2d76c47d6f68388888855b89397660825caac5c`.
+Executables are not duplicated in the evidence archive.
+
+## Preserved findings and independent readback
+
+Initial ddf823a production compilation failed with E0063: a semantic-row Parser
+initializer still gated `mixed: None` under cfg(test). Source8555e41 removes that
+stale attribute. Its ten external tests pass, with two warnings. Final bab6f96
+gates a test-only policy observer and removes a redundant test import; no model
+oracle, diagnostic expectation or semantic policy is weakened.
+
+Rustdoc lists the two CheckedMixed examples without a suffix, but prints
+` - compile fail` in their execution names. All three tests and Cargo pass; the
+recorder rejects exact name equality. [RUNTIME-REVIEW.md](RUNTIME-REVIEW.md) and
+the readback preserve that verdict and map only those two complete names at
+source lines36/50, with the positive example unchanged. No generic normalization
+or runtime rerun was used.
+
+[SOURCE-REVIEW.md](SOURCE-REVIEW.md), [LAUNCHER-REVIEW.md](LAUNCHER-REVIEW.md),
+[RUNTIME-PLAN.md](RUNTIME-PLAN.md) and [RUNTIME-REVIEW.md](RUNTIME-REVIEW.md)
+define the reviewed scope. [PUBLIC-READ-RUNTIME-READBACK.json](PUBLIC-READ-RUNTIME-READBACK.json)
+has SHA256 `8cf8a233b3ab3f0383251fe627d0cb443d0248371313661dcdcef4235e74c4ee`.
+Its [data-only checker](inspect_runtime.py) ran successfully once; it reads Git,
+logs and artifact bytes, requires the original workspace layout and refuses
+overwrite. It does not rerun archived helpers or product code.
+
+## Reproduction and limits
+
+On the recorded Windows Rust/Cargo1.98.1 gnullvm toolchain, use one compiler job
+with incremental compilation disabled. Exact commands and environment are in each
+receipt. Principal commands are `cargo test --locked --offline -p oa-core --lib`,
+`cargo test --locked --offline -p oa-core --test mixed_source8_read`,
+`cargo test --locked --offline -p oa-core --doc` and
+`cargo clippy --locked --offline -p oa-core --all-targets -- -D warnings`.
+The integration receipts preserve exact selected targets and filters.
+
+Eleven named core stack controls and the existing deep structural-writeback
+integration case pass. This does not resolve the separately documented full-pipeline
+small-stack limitation or qualify every depth/platform. Preserve
+`DEPTH_128_VALIDATED=false` and logical-accounting exclusions. Mixed CLI discovery,
+graphical editing, typed save/history integration and application completion remain
+separate work. Linux/WSL checks remain user-deferred; the published preview is unchanged.
@@ -0,0 +1,41 @@
+# Public mixed-read runtime readback plan
+
+Data-only reconciliation; parent owns all Cargo/compiler/CLI execution. Baseline is the audited ordinary packet ZIP SHA256 `879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378`, final source7b06 with explicitly reused core/other integration/CLI runs at0c07. Read baseline evidence from the immutable archive, not overwritten binaries. Current initial public-read source is ddf823a, with the separately reviewed8555e4 compile repair; bind final execution source only after parent freezes it. No archive helper or application is executed by this plan.
+
+## Exact required records
+
+- Core listing, focused `public_read`, full run, strict all-target Clippy and formatting. Full expected299: all298 old names/outcomes unchanged plus exactly `language::analysis_source::mixed::carried::public_read::public_read_fresh_constructor_keeps_zero_carry_both_modes_and_exact_policy`. Focused expected1, full0 failures/ignored. Preserve any newly observed failure before changing an oracle.
+- External `mixed_source8_read` list/run must contain the exact ten authored `public_mixed_read_*` names, all passing, with one actual normal-library integration executable. Do not count these as library tests or treat successful unit compilation as production coverage.
+- Same seven ordinary integration list/run pairs as the accepted packet: source_project33, source_identity_updates3, source_nested_updates12, source_files8, r3_migration5, review_regressions checked_save_3, source7_contract exact selected migration1. Compare exact old name sets, not only65 totals. Run these again because public Parser layout changed.
+- Doc list/run: nonzero unique identical actual names, all passing and nonignored; successful group summary counts must sum to that exact set. Require the three authored public API examples among the listing, including both lifetime compile-fail cases and the positive usage example. Multiple rustdoc groups are allowed; unavailable persistent doc artifacts are not invented. Preserve actual compiler/runner spelling before any normalization decision.
+- Actual non-test ordinary CLI build, check and cross-file rename preview on the unchanged explicit-ID Unicode/CRLF literals. Same independent complete before/after text and model-oracle boundary as baseline. Exact argv, reports, binary/source binding and unchanged complete directory bytes; no --write and no mixed CLI claim.
+
+## Source, artifact and receipt binding
+
+Every final receipt must bind exact source/head, complete declared immutable Git inputs and current raw bytes, actual command/filter/target, captured launcher hash, unchanged inputs, empty post-run porcelain status, raw log hash and process exit. Verify final helper differs from reviewed gate9088952c only by source pin unless a separately reviewed change is recorded. Verify CLI helper25ec9ab5. Require jobs1/incremental0 and the same toolchain/target environment, with stack/lifecycle/Rustdoc override variables absent. Artifacts must originate in actual Cargo Running/compiler-artifact output; compare list/run identities and current file bytes. Historical overwritten artifacts remain recorded identities only.
+
+Compare format bytes exactly with baseline `c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d`; retain its nonzero disposition. Strict Clippy must exit0; passing count summaries never override a process failure. Reconcile full raw names with listings and recorded outcomes, preserving failures/ignored results rather than normalizing them away. Final checker output must refuse overwrite and record its own hash.
+
+## Exact old stack controls
+
+The baseline298 inventory contains eleven named core stack controls, not an assumed ten total. Require each actual final outcome to pass:
+
+- `language::analysis_source::index::tests::deep_parse_index_plan_and_failed_build_cleanup_on_128k_stack`
+- `language::analysis_source::index::tests::maximum_index_paths_compare_lookup_debug_and_drop_on_128k_stack`
+- `language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::scoped_small_stack_actual_deep_wide_verification_and_drop`
+- `language::analysis_source::mixed::project::ordinary_index::rename::emission::tests::scoped_small_stack_changed_unchanged_and_failure_drop`
+- `language::analysis_source::mixed::project::ordinary_index::rename::tests::deep_and_wide_equality_and_late_refusal_drop_on_small_stack`
+- `language::analysis_source::mixed::project::ordinary_index::tests::small_stack_success_and_late_header_failure_leave_no_partial_owner`
+- `language::analysis_source::mixed::project::tests::index_tests::success_and_late_failure_drop_on_small_stack`
+- `language::analysis_source::mixed::project::tests::inherited_storage_failure_and_success_drop_deep_syntax_on_128k_stack`
+- `language::analysis_source::mixed::tests::mixed_deep_typed_success_and_rejection_cleanup_on_128k_stack`
+- `language::analysis_source::tests::every_parent_shape_rejects_depth129_and_cleans_children_on_128k_stack`
+- `language::nesting_tests::deep_declaration_parsing_and_positions_use_a_bounded_rust_stack`
+
+Also require `deep_structural_writeback_runs_on_a_small_thread_stack` in actual source_nested_updates integration results. These establish their finite exercised scopes; no universal stack headroom, setup-stack qualification or Linux/depth128 claim follows. Any parent-captured static frame evidence is supplemental and bound to its actual binary, not substituted for worker execution.
+
+## Initial actual failure to preserve
+
+`public-read-integration-list-mixed_source8_read-ddf823a-1` exited101 at E0063 in semantic_source.rs191, missing mixed initializer. Exact raw log SHA256 `3acdd5b0cf1dbd40c08c7e1c6feacd582ac152f3e911018223551d4e718aba51`; launcher `37b26d4224405fb25b7078389ab28f22a2fec87875cfafd53a043eb384aac16e`; input manifest `4d88617c743ca093cfdaff90fb1defd3984aeb1a3fba15fa8368d09567403bc4`. No artifact, listed name or test outcome exists. The receipt correctly records both missing-list/artifact verification failures and empty post-run source status. This was a missed production cfg initializer, not a runtime fixture or model failure. The reviewed8555e4 repair removes only that cfg attribute plus an explanatory note. No old or external tests are changed by this repair.
+
+Missing receipts are concrete incomplete gates, never inferred passes. Parent may choose a justified component reuse only after exact input/diff proof; no automatic reuse across the present production cfg changes. Public API acceptance remains local-only and excludes editor/save/history integration and user-deferred Linux work.
@@ -0,0 +1,43 @@
+# Public mixed read: runtime evidence review
+
+Read-only evidence reconciliation completed. Final source is locally committed `bab6f96a5b05b37f2b5d67a430aed0f67d783e73`. Parent executed the independently authored data-only checker once, exit0; this reviewer inspected the resulting immutable readback and recorded logs without running the checker again. No compiler, test or CLI was executed by this reviewer.
+
+## Final result and binding
+
+Checker SHA256 `132729db90aab52ce9fc1e225dbed8dc53338372bd7f0212efd847131efde919`; `PUBLIC-READ-RUNTIME-READBACK.json` SHA256 `8cf8a233b3ab3f0383251fe627d0cb443d0248371313661dcdcef4235e74c4ee`. Baseline is the accepted ordinary packet ZIP `879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378`, with its explicit0c07/7b06 component provenance retained.
+
+All562 declared final inputs match immutable Git and current source bytes. Final receipts bind unchanged source/head, empty post-run porcelain status, exact argv, input/log/launcher hashes and actual artifacts. Environment retains jobs1/incremental0, established toolchain/target settings, and absent stack/lifecycle/Rustdoc overrides. No test-name renaming or failure-body normalization is needed for the old library inventory.
+
+- Core listing/full agree at299 actual passes: all298 prior named passes preserved plus the one real public-constructor bridge. Focused public_read passes exactly that bridge.
+- Normal-library mixed_source8_read integration passes all ten independently authored external cases, with identical actual list/run names and artifact.
+- Seven ordinary integration pairs pass65 total: source_project33, identity3, nested12, source_files8, r3_migration5, checked_save_3, selected source7 migration1. Exact prior name sets agree; these were rerun at bab6 rather than reused across the production Parser change.
+- All three rustdoc cases actually pass under the exact reconciliation below. The recorder's name-mismatch failure remains preserved.
+- Both ordinary non-test CLI commands pass with the same independently authored complete preview bytes, no write, and unchanged original directory/files. This is ordinary CLI regression evidence, not a mixed CLI feature.
+- Strict core all-target Clippy exits0. Format exits1 with exact inherited bytes/hash `c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d`; it is not reported as passing.
+
+Core executable:43,348,480 bytes, SHA256 `01a051033bb53512a2747c2ef87e366e9b189c14df060d24284db437d39ff96a`. Non-test CLI executable:22,534,656 bytes, SHA256 `10302f9a0c17e82b57ab6498e2d76c47d6f68388888855b89397660825caac5c`. Current bytes were checked by the successful readback. Full raw log SHA256 `159e94ce159fcde7314abf45383419fa1199519e54fe2a223b222f25e2e81adb`; external raw log `45c09bf0a65b71f9e23aa96d4cdcfbf7fe8f04ee841c8e38f8fd479b5e4a2bfd`; Clippy raw log `4061235dd23ba634e9275fc8237a9ccd9f78540980ff740accdf68760c96bb79`.
+
+External mixed-source consumer executable:20,148,736 bytes, SHA256 `2b8c1f7ca484ce21f94da2d0b0fee7d082474244ebe1f212acad868d8564da22`. Full core receipt SHA256 `e54b77e90bf965f155a148440449df04929ba1ba063c190a2d29093a1093d058`. Readback contains24 final Cargo gate receipts, three preserved historical Cargo attempts, and two actual CLI receipts.
+
+## Preserved attempts and finite stack scope
+
+Initial ddf823a non-test integration listing exited101 at E0063 in semantic_source.rs191: the shared Parser initializer omitted mixed outside cfg(test). It produced no artifact, listing or test outcome. Initial source review missed that initializer. The raw failure, unchanged-input manifest, captured launcher and both recorder verification failures remain;8555e4 corrected only the missing initializer's cfg plus note.
+
+At8555e4 the external listing contained ten names and all ten actually passed. Compiler warnings identified unused Budget::limits and the redundant language self import; bab6 gates follow the reviewed test-only observer/import cleanup, without changing API, policy or expected models/diagnostics. The old8555 artifacts are recorded historical identities, not falsely equated to final overwritten binaries.
+
+Final full results include all eleven explicitly named baseline core stack controls in RUNTIME-PLAN.md: ten private analysis controls and the ordinary deep-declaration/positions control. The actual non-test source_nested_updates suite also passes deep_structural_writeback_runs_on_a_small_thread_stack. These support their finite exercised worker/cleanup scopes. No universal headroom bound, full-pipeline setup qualification, JSON depth128 switch or Linux evidence is inferred.
+
+## Actual rustdoc spelling discrepancy
+
+Inspected `public-read-doc-list-bab6f96-1.log`, SHA256 `d4b5207694f0bcbf061cc230057c2015adac6bb0754b5727c825e5eaa0d8378f`, and `public-read-doc-suite-bab6f96-1.log`, SHA256 `c93d7bfc96884dcbfb54aa2a36ba2294fd48bab036fb676931c54b7b8fd806d2`, with the original suite receipt. Cargo exits0; all three actual cases pass in groups1+2 with zero failures/ignored/filtered cases. The recorder nevertheless records `Doc runtime names must exactly match the prior nonzero listing` and therefore refuses its own verification. That evaluator verdict is retained, not rewritten as a successful recorder run.
+
+Rustdoc lists CheckedMixed at source lines36 and50 without a suffix, then executes them with exactly ` - compile fail` appended. The positive check_mixed_bundle example at line87 has identical names in both records. Independent checker reconciliation therefore maps only these two complete actual names:
+
+- `crates\oa-core\src\language\analysis_source\mixed\project.rs - language::analysis_source::mixed::project::CheckedMixed (line 36) - compile fail` → the same complete name without the suffix.
+- `crates\oa-core\src\language\analysis_source\mixed\project.rs - language::analysis_source::mixed::project::CheckedMixed (line 50) - compile fail` → the same complete name without the suffix.
+
+No generic suffix stripping, path normalization, name exclusion or extra tolerated recorder failure is introduced. The exception binds exact source bab6f96 and raw suite-log hash; it requires the exact three listing names, exact three runtime names/statuses, unchanged positive example, two compile-fail cases, the precise1+2 successful group summaries, Cargo exit0 and the sole preserved recorder failure. The checker output records raw names, explicit mapping and original verifier failures separately.
+
+This is an evaluator spelling correction, not a product/test change or permission to rerun and overwrite historical evidence. Original launchers, listing, log and receipt remain unchanged. The completed independent readback accepts actual successful rustdoc execution under this exact exception while retaining the unsuccessful recorder verdict.
+
+Final disposition: evidence supports the selected borrowed, explicit-ID complete-bundle Rust read API and preserved ordinary behavior. No unresolved runtime evidence discrepancy remains. Public editing/formatting/save/history adoption, mixed CLI discovery, universal allocation guarantees, depth128 qualification and user-deferred Linux work remain outside this checkpoint. Source and evidence are local-only until publication is independently confirmed; parent owns integration and publication.
@@ -0,0 +1,64 @@
+# Public mixed source8 read: independent source review
+
+Reviewed selected root contract committed locally at `bcddaba399b27bb99ff8142b9e9498785d029e0e`, SHA256 `e0b90e2b46a0c8f0693467b0585c87cd14ba258b772201b33b501a826f50ab12`, and its three design/oracle records. Production baseline is `7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd`. Independently confirmed the exact12-file committed production/docs/internal-test diff at `042e25efc25e0b73e4a39e1e794b48f88d4765bf`; all reviewed committed blobs match working bytes. External test binding appears below. No compiler, test, executable, source edit or remote operation was performed by this review.
+
+**Disposition: no source correctness, authority or lifetime blocker found.** Compilation, production-only lints, exact runtime oracles, doctests and stack behavior remain parent-owned pending gates. Local commits are not published deliverables.
+
+## Authority, policy and retained ownership
+
+`CheckedMixed` is defined beside the resolver with exactly one private resolved-owner field. Only the type and `check_mixed_bundle` are reexported through otherwise private modules. Its two accessors return immutable references; no Clone, mutable access, ownership extraction, index, arbitrary constructor or editable-compilation conversion is added. The constructor consumes the result of the actual fresh parser through complete existing resolution/admission; it never substitutes a Project or parses a second model. Original source, syntax, occurrences, expressions, ledger and static-admission evidence remain retained together.
+
+`CarriedInput::fresh` accepts only the actual borrowed bundle and caller ProjectLimits. It derives the existing internal policy and captures exact caller policy; no public Slots/profile authority exists. `parse_fresh` selects `parse_entry_producers`, which transfers policy and passes Some(guard),true,true into the unchanged parse body. Fresh guard slots are zero. The new Borrowed guard's `_bundle` reference preserves its real lifetime when Pending/Retained variants are absent in production; it adds no owned allocation or duplicate policy. C=0 is fresh caller-owned input accounting, not release/reset of a live verifier-owned carry.
+
+Derived bytes/tokens/references retain caller restrictions and hard ceilings; auxiliary entries remain262144 independently of final-model max_records. Exact ProjectLimits survive into traversal and final model admission. Existing token/text/entry producer checks, independent inventory reconciliation, resolver single seeding, complete validation, warning ordering and ownership cleanup remain unchanged. Full file traversal still rejects detached supplied files. Missing project/ordinary IDs refuse at the current parser token; typed/parameter missing IDs refuse at the owning typed declaration. Public-facing wording changes only schema/UUID requirement messages. Existing initial index/output-byte refusal precedes Traversal and retains its invalid_source/one-character transport; no diagnostic taxonomy or precedence is rewritten.
+
+## Dependency boundary and ordinary callers
+
+Production now compiles the shared parse/declarations/lower/resolve cone privately. Standalone expression fixture parsing, legacy typed-only lower adapter, index/update/write modules, ordinary-index/rename/emission/acceptance chain, pending/retained authority and fixture constructors remain cfg(test). Test-only numeric observation/cursor-end methods are gated individually. Public signatures expose no private syntax, ledger, profile or carried types.
+
+Ordinary parse_document/parse_unit still initialize mixed=None. Their grammar, migration, ID-generation, formatter/index/updater/save and caller integrations are not redirected. Shared hooks now compile in the normal library, so production Parser layout and surrounding frames change even though None branches preserve intended behavior. The prior test-only runtime cannot qualify those frames: actual non-test integration/ordinary CLI and stack gates remain necessary. No depth64/typed128 change, JSON qualification switch, heap guarantee or platform claim is inferred.
+
+Field-level non-test dead-code allowances retain accounted FileSyntax tokens/lexical owners and resolved syntax/expression/occurrence/storage/static-admission evidence. They do not suppress a module or struct, change accounting, add fake reads or expose lint-only APIs. The initially unnecessary State.lexical_owners allowance was removed after review because that field is actively moved/read. Exact additional compiler findings must be assessed individually rather than preemptively widening suppression.
+
+Documentation accurately limits the feature to a complete-bundle explicit-ID Rust checker. A missing reST section separator was corrected; the generated HTML diff is the same bounded17-line section, with broader conformance content retained. Three rustdoc examples share valid real public imports/source: one positive execution and two compile-fail cases force later witness use after attempted source mutation or destruction. This avoids nonlexical-lifetime false negatives; actual rustdoc must establish those compile outcomes.
+
+## Test and oracle fidelity
+
+The new internal bridge test invokes the exact production fresh helper and observes Some(Borrowed), zero slots, both producer inventories, all derived/caller policy fields and their hard ceilings. It distinguishes internal entries262144 from caller model records1, then checks whole empty model/warnings and legacy Usage/numeric parity without mutating a live policy. This is constructor-wiring evidence, not a public producer-cap refusal. Existing discriminatory private producer tests and298 old library tests are untouched.
+
+Independently read the external ten-test file, formatted SHA256 `f0404325dcdecb0da5167d3a1d10cce81be10c8f9dfc8067d6cda7cd73c6e15b`. It invokes only the public checker/model APIs. Parent-authorized reuse of `model_oracle.rs` via a path module imports independently constructed public model values; it does not import a private parser/writer/index or enable cfg(test) in the linked library. Substantial OA/SA two-file fixtures match that existing whole-model oracle, deliberately reverse textual call arguments, preserve nested Work ownership and vary Unicode/CRLF. The explicit SA System prevents an unrelated missing_system issue. Receive/Dispatch UUID order supports both allocation warnings followed by both behavior-coverage warnings; complete located warnings are asserted, not assumed empty.
+
+Separate whole-model literals cover scoped parameter IDs reused across calculations and the project UUID, ordinary nested-parent parity and exact Unicode span76..141/line2/column60. Negative cases remove each required ID class from otherwise valid input and distinguish early syntax from resolver full-span diagnostics. E78/77 and chain132/131 are correctly input-byte controls; files3/2, edges2/1 and depth2/1 use distinct actual limiter locations. Nested final records4/3 admit both declarations before model refusal; graph1/0 and reference1/0 are separate checks. Path/cycle/detached, malformed expression, duplicate globals/scopes, unresolved/wrong-domain references and long-form refusal preserve full input bytes. Exact diagnostic/model expectations remain hypotheses until the real normal-library integration run; source review found no concrete setup or privacy blocker.
+
+## Reviewed production/document hashes
+
+| File | SHA256 |
+| --- | --- |
+| `crates/oa-core/src/language.rs` | `990b7f3a4eb7a2b9b8463ac237d7b95446dbdc04da5b053098428f5ecb12937f` |
+| `crates/oa-core/src/language/analysis_source.rs` | `f287f066e7b947f8bf65b25595a3002296f5b4e1b51d47ed0496541d758f8fb0` |
+| `crates/oa-core/src/language/analysis_source/budget.rs` | `559378e7fa3ef2a10dc739e7316a552e61bd0d7fe4497c914f2acc5c33389124` |
+| `crates/oa-core/src/language/analysis_source/cursor.rs` | `23ee53f926b4d2cb7b25a2db8f2ed01cf219ef688cb8768dbe81e115f4ffadcd` |
+| `crates/oa-core/src/language/analysis_source/lower.rs` | `c03a1c3639c0d506b5ed92ecb27887c302f17c5286061450518bd2acb9bfea8e` |
+| `crates/oa-core/src/language/analysis_source/mixed.rs` | `d1ccafcefb2e2c90fd79b30b44ca6566f25ed14ea954c2ebf0e30fec54bf9830` |
+| `crates/oa-core/src/language/analysis_source/mixed/carried.rs` | `5ad965ca219bf70747f412a430fb391caf411023e81f4849bcf512967fbb4f23` |
+| `crates/oa-core/src/language/analysis_source/mixed/carried/public_read.rs` | `4529442687f12038821bf3482123ceacd37ae6b5beed3e2343e7a6bc6128afbe` |
+| `crates/oa-core/src/language/analysis_source/mixed/project.rs` | `9a1f122b8463eeee41a8455517a9c898a676678ab8e40676a97c71724910ef75` |
+| `docs/language.html` | `a09757e1fa74d97165510e743a92726edd930a4744fae7a1302239b46ba7a66a` |
+| `docs/language.rst` | `7babf10e5db51cecdcedd0d6246b2191a7d6bdfb3090cbe29a5805c3f62e28b6` |
+| `harness/analysis-public-read-implementation-20260925.md` | `b5f437af4c6694d1b35dc0def912f846d5908cfd678d665eed609d21b972e0bd` |
+
+Compiler/runtime acceptance is pending; there is no unchanged-stack or production-lint-clean claim from this source-only binding.
+
+Final combined source binding: independently confirmed clean HEAD `ddf823a3d358050b3aedc711f6ec04669e59e772`. Its only delta from042e25ef is the external integration test file with exact reviewed `f0404325...` SHA256 above. All production/docs/internal-test bindings remain unchanged. The combined13-file checkpoint is source-review ready for parent-owned compilation; no runtime result is implied.
+
+## Actual non-test compile failure and narrow repair
+
+The first ddf823a external integration listing stopped at compilation with E0063: `language/semantic_source.rs:191` initialized the shared Parser but still gated mixed:None under cfg(test). Initial source review missed this separate initializer. The raw log SHA256 `3acdd5b0cf1dbd40c08c7e1c6feacd582ac152f3e911018223551d4e718aba51`, receipt, inputs and launcher remain preserved as a genuine compile failure; there were no tests or artifact/list results.
+
+Independently confirmed clean repair commit `8555e417ee840e681b55ba355fc359aac00db01d`. Its only code delta removes that cfg attribute so the ordinary semantic-facet row-key reader supplies mixed:None in production; the implementation note is the only other changed file. semantic_source.rs SHA256 `4040e93cb407813468fe757b1a6336a8ac9249f2d5d70b22ff56cb79a590b3f1`. Inventory of Parser initializers confirms language.rs ordinary entry points and mixed.rs are already coherent; language::legacy's initializer belongs to its distinct Parser type. No authority, parsing policy or test oracle changes. This fixes the concrete source omission; repaired compilation/runtime remains parent-owned and pending.
+
+## Actual external passes and final warning-only binding
+
+Read the actual8555e4 external-suite log: all ten authored tests passed, with compilation warnings about unused Budget::limits and the redundant language self import shadowing a public glob. This finite normal-library success does not imply subsequent full/lint/doc gates passed.
+
+Independently confirmed clean successor `bab6f96a5b05b37f2b5d67a430aed0f67d783e73`. Exact8555→bab scope is Budget::limits receiving cfg(test), external test import dropping only self, and the implementation note. All actual limits-observer callers are fixture/test/edit-chain callers; the live public parser reads its policy directly, so no runtime policy or authority is removed. The test's model/byte/diagnostic expectations are unchanged. Final budget.rs SHA256 `86b960ef3cc7aadab2deff4163c843da2f214c1571cdf440331025e75e0320b6`; external test SHA256 `a3be9489c3c038ddae76923046c12eb9e09dcddb35a52b531d661130441225e3`; note SHA256 `154384778c38d03ca866c3e7b630f34cebac99bbcbfc70a9d3d2f503c4fa9d0a`. All other previously reviewed hashes remain unchanged. No source-review blocker; final runtime evidence is a separate pending audit.
@@ -0,0 +1,346 @@
+"""Data-only public-read reconciliation; run only after parent freezes all gates.
+
+Usage: python -I -B inspect_runtime.py REVIEWED_FINAL_SOURCE_SHA
+Runs only read-only Git commands, never Cargo, archived helpers or executables.
+"""
+from pathlib import Path
+import ast
+import hashlib
+import io
+import json
+import re
+import subprocess
+import sys
+import zipfile
+
+assert not sys.flags.optimize
+assert len(sys.argv) == 2
+source = sys.argv[1]
+assert re.fullmatch(r'[0-9a-f]{40}', source)
+base = Path(__file__).resolve().parents[2]
+root = base / '.local/as3batch'
+folder = base / '.local/analysis-public-read-gates-20260925'
+destination = Path(__file__).with_name('PUBLIC-READ-RUNTIME-READBACK.json')
+assert not destination.exists(), 'Preserve prior readback; no overwrite'
+sha = lambda b: hashlib.sha256(b).hexdigest()
+GATE_TEMPLATE = '9088952ca3fabf56ab4434273bf55c6ec6eb6139bc2452a7be7c66a4409e420d'
+CLI_HASH = '25ec9ab5aa22d7364169772eae2cc10d508415fada9845a5fb7f115e7dd3f3e0'
+ARCHIVE_HASH = '879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378'
+BASELINE = '7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd'
+DOC_SOURCE = 'bab6f96a5b05b37f2b5d67a430aed0f67d783e73'
+DOC_LOG = 'c93d7bfc96884dcbfb54aa2a36ba2294fd48bab036fb676931c54b7b8fd806d2'
+DOC_PREFIX = (r'crates\oa-core\src\language\analysis_source\mixed\project.rs - '
+              'language::analysis_source::mixed::project::')
+DOC_POSITIVE = DOC_PREFIX + 'check_mixed_bundle (line 87)'
+DOC_MAPPING = {
+    DOC_PREFIX + 'CheckedMixed (line 36) - compile fail': DOC_PREFIX + 'CheckedMixed (line 36)',
+    DOC_PREFIX + 'CheckedMixed (line 50) - compile fail': DOC_PREFIX + 'CheckedMixed (line 50)',
+}
+DOC_RECORDER_FAILURE = ['Doc runtime names must exactly match the prior nonzero listing']
+BRIDGE = ('language::analysis_source::mixed::carried::public_read::'
+          'public_read_fresh_constructor_keeps_zero_carry_both_modes_and_exact_policy')
+EXTERNAL = {
+    'public_mixed_read_complete_oa_sa_models_and_all_located_warnings',
+    'public_mixed_read_scoped_uuid_reuse_and_cross_file_call_are_not_global_collisions',
+    'public_mixed_read_explicit_identity_classes_versions_and_long_forms',
+    'public_mixed_read_exact_input_file_edge_and_depth_boundaries',
+    'public_mixed_read_paths_missing_cycles_and_detached_files_are_errors',
+    'public_mixed_read_final_nested_model_limit_is_distinct_from_syntax_entries',
+    'public_mixed_read_typed_reference_caller_allowance_has_a_real_positive_control',
+    'public_mixed_read_malformed_duplicate_and_wrong_domain_references',
+    'public_mixed_read_unicode_columns_are_not_utf8_byte_columns',
+    'public_mixed_read_ordinary_parity_uses_an_independent_complete_model',
+}
+SCOPE = ['Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', '.cargo', 'build', 'crates',
+         'assets', 'docs', 'examples', 'harness/fixtures', 'vendor']
+
+
+def git(*args, data=None):
+    return subprocess.check_output(['git', '--no-replace-objects', *args], cwd=root, input=data)
+
+
+def within(parent, name):
+    p = (parent / name).resolve()
+    assert p.is_relative_to(parent.resolve()), name
+    return p
+
+
+def rows(raw):
+    result = re.findall(r'^test ([^\r\n]+) \.\.\. (ok|FAILED|ignored)\r?$', raw.decode('utf8'), re.M)
+    assert len(result) == len(dict(result)), 'Duplicate runtime name'
+    return result
+
+
+def names(raw):
+    result = re.findall(r'^([^\r\n]+): test\r?$', raw.decode('utf8'), re.M)
+    assert len(result) == len(set(result)), 'Duplicate listed name'
+    return result
+
+
+def all_passed(raw, count, grouped=False):
+    actual = rows(raw)
+    assert len(actual) == count and all(status == 'ok' for _, status in actual)
+    summaries = re.findall(r'^test result: ok\. (\d+) passed; 0 failed; 0 ignored; 0 measured; (\d+) filtered out;', raw.decode('utf8'), re.M)
+    assert summaries and sum(int(x[0]) for x in summaries) == count
+    if not grouped:
+        assert len(summaries) == 1
+    return {name for name, _ in actual}
+
+
+archive_raw = (base / 'harness/experiments/ordinary-source8-20260925/evidence.zip').read_bytes()
+assert sha(archive_raw) == ARCHIVE_HASH
+archive = zipfile.ZipFile(io.BytesIO(archive_raw))
+assert archive.testzip() is None
+
+
+def prior(stem):
+    r = archive.read('gates/' + stem + '.result.json')
+    d = json.loads(r)
+    log = archive.read('gates/' + stem + '.log')
+    assert sha(log) == d['log_sha256']
+    assert rows(log) == [tuple(x) for x in d['outcomes']]
+    return d, log
+
+
+old, old_log = prior('ordinary-full-0c07f53-1')
+old_names = all_passed(old_log, 298)
+old_listing, old_list_log = prior('ordinary-list-0c07f53-1')
+assert set(names(old_list_log)) == old_names
+old_fmt, old_fmt_log = prior('ordinary-fmt-7b06b8e-1')
+assert old_fmt['exit'] == 1 and sha(old_fmt_log) == 'c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d'
+environment = dict(old['environment'])
+environment.update(RUSTDOC=None, RUSTDOCFLAGS=None, CARGO_ENCODED_RUSTDOCFLAGS=None)
+assert environment['CARGO_BUILD_JOBS'] == '1' and environment['CARGO_INCREMENTAL'] == '0'
+for key in ['RUSTFLAGS', 'RUSTC', 'RUSTUP_TOOLCHAIN', 'ARCADIA_CODEC_LIFECYCLE_PHASE',
+            'RUST_MIN_STACK', 'RUSTDOC', 'RUSTDOCFLAGS', 'CARGO_ENCODED_RUSTDOCFLAGS']:
+    assert environment[key] is None
+assert git('rev-parse', 'HEAD').decode().strip() == source
+assert not git('status', '--porcelain', '--untracked-files=all').strip()
+input_cache = {}
+
+
+def inputs_at(commit):
+    if commit in input_cache:
+        return input_cache[commit]
+    paths = git('ls-tree', '-r', '--name-only', commit, *SCOPE).decode().splitlines()
+    data = git('cat-file', '--batch', data=''.join(f'{commit}:{p}\n' for p in paths).encode())
+    stream = io.BytesIO(data)
+    result = []
+    for path in paths:
+        header = stream.readline().split()
+        assert header[1] == b'blob'
+        raw = stream.read(int(header[2]))
+        assert stream.read(1) == b'\n'
+        if commit == source:
+            assert within(root, path).read_bytes() == raw, path
+        result.append({'path': path, 'bytes': len(raw), 'sha256': sha(raw)})
+    assert stream.read() == b''
+    input_cache[commit] = result
+    return result
+
+
+expected_inputs = inputs_at(source)
+verified = {}
+
+
+def read_gate(stem, *, current=True):
+    receipt_raw = (folder / (stem + '.result.json')).read_bytes()
+    d = json.loads(receipt_raw)
+    raw = (folder / (stem + '.log')).read_bytes()
+    assert sha(raw) == d['log_sha256']
+    assert d['source'] == d['head_after']
+    assert d['cwd'] == str(root) and d['invocation'] == 'cargo'
+    assert d['environment'] == environment
+    assert not d['changed_inputs'] and d['source_status_after'] == ''
+    manifest = within(folder, d['inputs']).read_bytes()
+    assert sha(manifest) == d['inputs_sha256']
+    assert json.loads(manifest) == {'source': d['source'], 'inputs': inputs_at(d['source'])}
+    launcher = within(folder, d['launcher_copy']).read_bytes()
+    assert sha(launcher) == d['launcher_sha256'] == d['launcher_sha256_after']
+    assert launcher.count(d['source'].encode()) == 1
+    assert sha(launcher.replace(d['source'].encode(), b'PENDING_REVIEWED_PUBLIC_READ_SOURCE')) == GATE_TEMPLATE
+    assert rows(raw) == [tuple(x) for x in d['outcomes']]
+    listing = names(raw) if d['mode'] in ('list', 'integration-list', 'doc-list') else []
+    assert listing == d['listing_members'] and len(listing) == d['listing_count']
+    if current:
+        assert d['source'] == source
+        if stem == 'public-read-doc-suite-bab6f96-1':
+            # Exact observed rustdoc spelling only; retain the recorder's refusal.
+            assert source == DOC_SOURCE and sha(raw) == DOC_LOG and d['exit'] == 0
+            assert d['verification_failures'] == DOC_RECORDER_FAILURE
+        else:
+            assert not d['verification_failures']
+        for artifact in d['artifacts']:
+            path = Path(artifact['path'])
+            assert path.resolve().is_relative_to(Path(environment['CARGO_TARGET_DIR']).resolve())
+            binary = path.read_bytes()
+            assert len(binary) == artifact['bytes'] and sha(binary) == artifact['sha256']
+    verified[stem] = {'source': d['source'], 'exit': d['exit'], 'receipt_sha256': sha(receipt_raw),
+                      'log_sha256': sha(raw), 'inputs_sha256': sha(manifest),
+                      'launcher_sha256': sha(launcher), 'outcomes': d['outcomes'],
+                      'listing': listing, 'artifacts': d['artifacts'],
+                      'verification_failures': d['verification_failures']}
+    return d, raw
+
+
+def current_gate(mode, command, target=None, selected_filter='', artifact_count=1):
+    stem = 'public-read-' + mode + ('-' + target if target else '') + '-' + source[:7] + '-1'
+    d, raw = read_gate(stem)
+    assert d['mode'] == mode and d['command'] == command
+    assert d['test_target'] == target and d['filter'] == selected_filter
+    assert d['exit'] == (1 if mode == 'fmt' else 0)
+    assert len(d['artifacts']) == artifact_count
+    if artifact_count and mode != 'cli-build':
+        running = re.findall(r'Running [^\r\n]+ \(([^\r\n]+\.exe)\)', raw.decode())
+        assert len(running) == artifact_count
+        assert [(root / n).resolve() for n in running] == [Path(a['path']).resolve() for a in d['artifacts']]
+    return d, raw
+
+
+prefix = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--lib']
+listing, listing_log = current_gate('list', prefix + ['--', '--list'])
+focused, focused_log = current_gate('focused', prefix + ['public_read', '--', '--test-threads=1'], selected_filter='public_read')
+full, full_log = current_gate('full', prefix + ['--', '--test-threads=1'])
+assert all_passed(full_log, 299) == old_names | {BRIDGE}
+assert set(listing['listing_members']) == old_names | {BRIDGE}
+assert all_passed(focused_log, 1) == {BRIDGE}
+assert listing['artifacts'] == focused['artifacts'] == full['artifacts']
+clippy, _ = current_gate('clippy', ['cargo', 'clippy', '--locked', '--offline', '-p', 'oa-core', '--all-targets', '--', '-D', 'warnings'], artifact_count=0)
+fmt, fmt_log = current_gate('fmt', ['cargo', 'fmt', '--all', '--', '--check'], artifact_count=0)
+assert fmt_log == old_fmt_log
+
+suites = {'mixed_source8_read': '', 'source_project': '', 'source_identity_updates': '',
+          'source_nested_updates': '', 'source_files': '', 'r3_migration': '',
+          'review_regressions': 'checked_save_',
+          'source7_contract': 'source7_source_bundle_migration_is_token_only_and_new_link_stays_with_caller'}
+integration = {}
+for target, selected_filter in suites.items():
+    pair = {}
+    for mode in ('integration-list', 'integration-suite'):
+        command = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--test', target]
+        if selected_filter:
+            command.append(selected_filter)
+        command += ['--', '--list' if mode == 'integration-list' else '--test-threads=1']
+        if target == 'source7_contract':
+            command.append('--exact')
+        pair[mode] = current_gate(mode, command, target, selected_filter)
+    l, s = pair['integration-list'][0], pair['integration-suite'][0]
+    assert l['artifacts'] == s['artifacts']
+    assert Path(s['artifacts'][0]['path']).name.startswith(target + '-')
+    if target == 'mixed_source8_read':
+        expected = EXTERNAL
+    else:
+        checkpoint = '7b06b8e' if target == 'r3_migration' else '0c07f53'
+        previous, previous_log = prior(f'ordinary-integration-suite-{target}-{checkpoint}-1')
+        expected = all_passed(previous_log, len(previous['outcomes']))
+    assert set(l['listing_members']) == expected
+    assert all_passed(pair['integration-suite'][1], len(expected)) == expected
+    integration[target] = sorted(expected)
+assert sum(len(v) for k, v in integration.items() if k != 'mixed_source8_read') == 65
+assert 'deep_structural_writeback_runs_on_a_small_thread_stack' in integration['source_nested_updates']
+
+doc_prefix = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--doc']
+doc_list, _ = current_gate('doc-list', doc_prefix + ['--', '--list'], artifact_count=0)
+doc_suite, doc_log = current_gate('doc-suite', doc_prefix + ['--', '--test-threads=1'], artifact_count=0)
+doc_names = set(doc_list['listing_members'])
+assert source == DOC_SOURCE
+assert doc_names == {DOC_POSITIVE, *DOC_MAPPING.values()}
+doc_runtime_names = all_passed(doc_log, 3, grouped=True)
+assert doc_runtime_names == {DOC_POSITIVE, *DOC_MAPPING}
+assert {DOC_MAPPING.get(n, n) for n in doc_runtime_names} == doc_names
+assert re.findall(r'^test result: ok\. (\d+) passed; 0 failed; 0 ignored; 0 measured; (\d+) filtered out;', doc_log.decode('utf8'), re.M) == [('1', '0'), ('2', '0')]
+assert doc_suite['verification_failures'] == DOC_RECORDER_FAILURE
+public_docs = {n for n in doc_names if 'CheckedMixed' in n or 'check_mixed_bundle' in n}
+assert len(public_docs) == 3, public_docs
+
+build, build_log = current_gate('cli-build', ['cargo', 'build', '--locked', '--offline', '-p', 'oa-cli', '--bin', 'arcadia', '--message-format=json'])
+emitted = []
+for line in build_log.splitlines():
+    try:
+        row = json.loads(line)
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        continue
+    if row.get('reason') == 'compiler-artifact' and row.get('target', {}).get('name') == 'arcadia' and row.get('executable'):
+        assert row['target']['kind'] == ['bin'] and not row['profile']['test']
+        emitted.append(row['executable'])
+assert len(emitted) == 1 and Path(emitted[0]).resolve() == Path(build['artifacts'][0]['path']).resolve()
+original = {name: archive.read('cli/original-inputs/' + name).decode('utf8')
+            for name in ['project.arcadia', 'participants.arcadia', 'children.arcadia']}
+after = {'participants.arcadia': original['participants.arcadia'].replace('oa_entity team ', 'oa_entity rescue_team '),
+         'children.arcadia': original['children.arcadia'].replace('parent @team;', 'parent @rescue_team;')}
+inventory = {name: {'bytes': len(text.encode('utf8')), 'sha256': sha(text.encode('utf8'))} for name, text in original.items()}
+fixture = folder / ('cli-fixture-' + source[:7])
+assert sorted(p.relative_to(fixture).as_posix() for p in fixture.rglob('*')) == sorted(original)
+for name, text in original.items():
+    assert (fixture / name).read_bytes() == text.encode('utf8')
+for operation in ('check', 'rename-alias'):
+    stem = f'public-read-cli-{operation}-{source[:7]}-1'
+    receipt_raw = (folder / (stem + '.cli.json')).read_bytes()
+    d = json.loads(receipt_raw)
+    stdout = (folder / (stem + '.stdout.json')).read_bytes()
+    stderr = (folder / (stem + '.stderr.txt')).read_bytes()
+    assert d['source'] == source and d['build_artifact'] == build['artifacts'][0]
+    assert d['cwd'] == str(root) and d['environment'] == environment
+    assert d['inputs'] == build['inputs'] and d['inputs_sha256'] == build['inputs_sha256']
+    assert not d['changed_inputs'] and not d['verification_failures'] and d['exit'] == 0
+    assert d['stdout_sha256'] == sha(stdout) and d['stderr_sha256'] == sha(stderr) and stderr == b''
+    assert d['expected_input_inventory'] == d['after_inventory'] == inventory
+    launcher = within(folder, d['launcher_copy']).read_bytes()
+    assert sha(launcher) == d['launcher_sha256'] == CLI_HASH
+    entry = str(fixture / 'project.arcadia')
+    argv = [build['artifacts'][0]['path'], operation, entry]
+    if operation == 'rename-alias':
+        argv += ['team', 'rescue_team']
+    assert d['argv'] == argv + ['--json']
+    report = json.loads(stdout)
+    for key, value in {'format_version': 1, 'entry': entry, 'operation': operation,
+                       'status': 'checked' if operation == 'check' else 'preview',
+                       'exit_code': 0, 'written': False, 'diagnostics': [],
+                       'identities_to_stabilize': 0, 'migration': None}.items():
+        assert report[key] == value
+    if operation == 'check':
+        assert report['changes'] == []
+    else:
+        assert [v['path'] for v in report['changes']] == ['children.arcadia', 'participants.arcadia']
+        for v in report['changes']:
+            assert v['before'] == original[v['path']] and v['after'] == after[v['path']]
+    verified[stem] = {'receipt_sha256': sha(receipt_raw), 'stdout_sha256': sha(stdout),
+                      'stderr_sha256': sha(stderr), 'launcher_sha256': sha(launcher)}
+
+# Preserve all actual earlier gate attempts without calling overwritten artifacts current.
+historical = {}
+for path in sorted(folder.glob('*.result.json')):
+    if path.stem.removesuffix('.result') in verified:
+        continue
+    stem = path.name.removesuffix('.result.json')
+    d, raw = read_gate(stem, current=False)
+    historical[stem] = verified[stem]
+initial = historical['public-read-integration-list-mixed_source8_read-ddf823a-1']
+assert initial['exit'] == 101 and not initial['outcomes'] and not initial['artifacts'] and not initial['listing']
+assert initial['log_sha256'] == '3acdd5b0cf1dbd40c08c7e1c6feacd582ac152f3e911018223551d4e718aba51'
+assert initial['verification_failures'] == ['Expected nonzero unique target listing', 'Expected exactly one requested integration target executable']
+
+# Exact stack names were independently enumerated in RUNTIME-PLAN; no inference of headroom.
+plan = Path(__file__).with_name('RUNTIME-PLAN.md').read_text(encoding='utf8')
+stack_names = re.findall(r'^- `(language::[^`]+)`$', plan, re.M)
+assert len(stack_names) == len(set(stack_names)) == 11
+assert set(stack_names) <= old_names and all(dict(full['outcomes'])[n] == 'ok' for n in stack_names)
+assert git('rev-parse', 'HEAD').decode().strip() == source
+assert not git('status', '--porcelain', '--untracked-files=all').strip()
+result = {'source': source, 'baseline': BASELINE, 'baseline_archive_sha256': ARCHIVE_HASH,
+          'checker_sha256': sha(Path(__file__).read_bytes()), 'plan_sha256': sha(Path(__file__).with_name('RUNTIME-PLAN.md').read_bytes()),
+          'inputs': len(expected_inputs), 'prior_passes_preserved': 298, 'new_bridge': BRIDGE,
+          'full_passed': 299, 'external_names': sorted(EXTERNAL), 'integration': integration,
+          'doc_names': sorted(doc_names), 'doc_runtime_names': sorted(doc_runtime_names),
+          'doc_exact_mapping': DOC_MAPPING, 'doc_recorder_verification_failures': DOC_RECORDER_FAILURE,
+          'public_docs': sorted(public_docs), 'stack_controls': stack_names,
+          'core_artifact': full['artifacts'][0], 'cli_artifact': build['artifacts'][0],
+          'environment': environment, 'inherited_fmt_sha256': sha(fmt_log),
+          'verified': verified, 'historical': historical,
+          'scope': 'Data/Git readback only; no compiler/helper/product execution. Local-only Windows evidence; no Linux/depth128 or public mixed CLI qualification.'}
+with destination.open('x', encoding='utf8', newline='\n') as stream:
+    json.dump(result, stream, indent=2)
+    stream.write('\n')
+print(json.dumps({'source': source, 'full_passed': 299, 'external_passed': 10,
+                  'ordinary_integration_passed': 65, 'doctests': len(doc_names),
+                  'readback_sha256': sha(destination.read_bytes())}))
@@ -0,0 +1,780 @@
+{
+  "source": "bab6f96a5b05b37f2b5d67a430aed0f67d783e73",
+  "baseline": "7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd",
+  "baseline_archive_sha256": "879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378",
+  "readback": {
+    "file": "PUBLIC-READ-RUNTIME-READBACK.json",
+    "sha256": "8cf8a233b3ab3f0383251fe627d0cb443d0248371313661dcdcef4235e74c4ee"
+  },
+  "scope": "Public read-only complete mixed-bundle API evidence. No mixed CLI, editing/save/history, depth128 qualification or Linux claim; local-only until publication is confirmed.",
+  "archive": {
+    "file": "evidence.zip",
+    "bytes": 1130273,
+    "sha256": "1c20b7bffdaee9b1139b0e922d4366f6ac739f8567040e8f4723dc19e3974656"
+  },
+  "mirrors": [
+    "inspect_runtime.py",
+    "LAUNCHER-REVIEW.md",
+    "PUBLIC-READ-RUNTIME-READBACK.json",
+    "RUNTIME-PLAN.md",
+    "RUNTIME-REVIEW.md",
+    "SOURCE-REVIEW.md"
+  ],
+  "members": {
+    "baseline/ANCHOR.json": {
+      "bytes": 343,
+      "sha256": "bdc840cddb2fe91b1209ae41713af43d65e932439f32e5788efaa69867c1a1d1",
+      "origin": "fixed audited ordinary evidence anchor"
+    },
+    "baseline/ordinary-fmt-7b06b8e-1.log": {
+      "bytes": 6446,
+      "sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-fmt-7b06b8e-1.log"
+    },
+    "baseline/ordinary-fmt-7b06b8e-1.result.json": {
+      "bytes": 1890,
+      "sha256": "2ed4803758e5e1808566f250b7a6b0a36dbca9fe2970f92f33433c9cc549f740",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-fmt-7b06b8e-1.result.json"
+    },
+    "baseline/ordinary-full-0c07f53-1.log": {
+      "bytes": 36561,
+      "sha256": "d9901deda399bcc3187f345b332fd5f2ba0c594113821f96f27681af4b6ed05d",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-full-0c07f53-1.log"
+    },
+    "baseline/ordinary-full-0c07f53-1.result.json": {
+      "bytes": 44717,
+      "sha256": "1e949b275a3f3fbae6717f697d211b42509cafe0d51d6ac1c4c1dfe4ca60ecdb",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-full-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-list-r3_migration-7b06b8e-1.log": {
+      "bytes": 724,
+      "sha256": "3bf954f21c81ffc733d406175171beb6b3a2ac685f64b6c3b0a340017b443965",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-r3_migration-7b06b8e-1.log"
+    },
+    "baseline/ordinary-integration-list-r3_migration-7b06b8e-1.result.json": {
+      "bytes": 2674,
+      "sha256": "e8a28ac312d2193aa2a6a5846037f1729d5470d7a730d0a3d5a6edcf490ea1c3",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-r3_migration-7b06b8e-1.result.json"
+    },
+    "baseline/ordinary-integration-list-review_regressions-0c07f53-1.log": {
+      "bytes": 597,
+      "sha256": "cccc9047f0abd98b2919a7e8513c94dfe26a7889405ee6b7f881864105e6f5e1",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-review_regressions-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-list-review_regressions-0c07f53-1.result.json": {
+      "bytes": 2590,
+      "sha256": "2b3cb4d29cd681099a559c23309ca7568759ab144fcfd59331ec2d24c686ba9d",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-review_regressions-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-list-source7_contract-0c07f53-1.log": {
+      "bytes": 448,
+      "sha256": "ba4e0c42ad375ef974ecebba3562d829156f938056824473d0d7671e49f2f8ba",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source7_contract-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-list-source7_contract-0c07f53-1.result.json": {
+      "bytes": 2578,
+      "sha256": "e89ca824de90c2585249ce496a031ce7f7210a99f0dbb5c08418d0ac7b3fbe6b",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source7_contract-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-list-source_files-0c07f53-1.log": {
+      "bytes": 923,
+      "sha256": "5703de5b7ea97bf4a03a2768910406ef506c8c9f2537ae87862b5493a7a0cce7",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_files-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-list-source_files-0c07f53-1.result.json": {
+      "bytes": 2876,
+      "sha256": "7d71114234578f043a53f582bd1ab450c42e5dff5635702fa7de8008ef6132d3",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_files-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-list-source_identity_updates-0c07f53-1.log": {
+      "bytes": 600,
+      "sha256": "1297c9929d8d17f900f129e3a3358cea4ed61a9527144b336788bbe1dfebec08",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_identity_updates-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-list-source_identity_updates-0c07f53-1.result.json": {
+      "bytes": 2570,
+      "sha256": "d3cc5dd44a8dc6017aacfbc383caa4105dd4eaa814efb7c1f6e4e5bc6335ff4a",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_identity_updates-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-list-source_nested_updates-0c07f53-1.log": {
+      "bytes": 1303,
+      "sha256": "4b34e9e9776a1bc5ffdcf1211d2937ed3c33c2ba45a7a9635d5e088489d8870c",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_nested_updates-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-list-source_nested_updates-0c07f53-1.result.json": {
+      "bytes": 3279,
+      "sha256": "a98808c798b1f3b56c7489c4afdcb51039b2483cefc21faef57f62809c213216",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_nested_updates-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-list-source_project-0c07f53-1.log": {
+      "bytes": 2975,
+      "sha256": "02bdebb9395c835d9069bdf8c97920c9b3e6fec8e037a44be8ec3e3496edaa7c",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_project-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-list-source_project-0c07f53-1.result.json": {
+      "bytes": 4943,
+      "sha256": "8a9a13020b38064a6f188c391f646a29cccdbdb35c220ff29e4b5ef22d13bc00",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-list-source_project-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-suite-r3_migration-7b06b8e-1.log": {
+      "bytes": 740,
+      "sha256": "821552f251b3dcaf21a09aff01a1ca65eda2fcb0c64f124cd7ae14e816789997",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-r3_migration-7b06b8e-1.log"
+    },
+    "baseline/ordinary-integration-suite-r3_migration-7b06b8e-1.result.json": {
+      "bytes": 2817,
+      "sha256": "080e795d747e2c396bbb1a718fd26f7fb3be917e752aa2556bf807040979d463",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-r3_migration-7b06b8e-1.result.json"
+    },
+    "baseline/ordinary-integration-suite-review_regressions-0c07f53-1.log": {
+      "bytes": 602,
+      "sha256": "c2a46ec6f199507c124c5f373fb52c8fe1bb226dcdd58e3b9c8990623814b5c3",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-review_regressions-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-suite-review_regressions-0c07f53-1.result.json": {
+      "bytes": 2682,
+      "sha256": "451ca27563d7b6aaf2d4a3ed4c52f21564ea3c0fb57e02d3db4b470e443580a4",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-review_regressions-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-suite-source7_contract-0c07f53-1.log": {
+      "bytes": 441,
+      "sha256": "629afa19abcee2630b9c8a1f645d9b863b81e0452f5da32c431495557096b91b",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source7_contract-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-suite-source7_contract-0c07f53-1.result.json": {
+      "bytes": 2617,
+      "sha256": "bec965b3342b6715d96151299df2a57c91e0fc92d1360d0aebe207662f590b4d",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source7_contract-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-suite-source_files-0c07f53-1.log": {
+      "bytes": 957,
+      "sha256": "8ac702b98b8e518650baef1982da1cdc1efba0bdd77eaffaff9e3b562fd4bcce",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_files-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-suite-source_files-0c07f53-1.result.json": {
+      "bytes": 3097,
+      "sha256": "8be7fda52cd333f863da47ae2ecb23697cbd8465016d47f1f4d067fa79b41394",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_files-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-suite-source_identity_updates-0c07f53-1.log": {
+      "bytes": 604,
+      "sha256": "9f09d1c72f70ed41509a821417fdf8e3e3f6df334a54e510b0f9ed9c876e5309",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_identity_updates-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-suite-source_identity_updates-0c07f53-1.result.json": {
+      "bytes": 2661,
+      "sha256": "e8369317900600cb985a106ea9950ea6fd6b98fa0915037f2b1f615b481b42c8",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_identity_updates-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-suite-source_nested_updates-0c07f53-1.log": {
+      "bytes": 1362,
+      "sha256": "d0fcb9be9a0a75b4113e7c3abf7bcc3eea6533e9adde2c8f290106ef79be4a7c",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_nested_updates-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-suite-source_nested_updates-0c07f53-1.result.json": {
+      "bytes": 3602,
+      "sha256": "e1cf6cea7613ffd7343b07e125259431f96d7916ff398c9fb4d2236093f0fe8f",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_nested_updates-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-integration-suite-source_project-0c07f53-1.log": {
+      "bytes": 3159,
+      "sha256": "5f24b9b6ee1e7cabd72365698adccfe32037bca99e6978b93a629ad0d177d9ca",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_project-0c07f53-1.log"
+    },
+    "baseline/ordinary-integration-suite-source_project-0c07f53-1.result.json": {
+      "bytes": 5826,
+      "sha256": "da321481bcb17cba7603052aac4c874c59104bc51ef80491bd0bd4eadd404af3",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-integration-suite-source_project-0c07f53-1.result.json"
+    },
+    "baseline/ordinary-list-0c07f53-1.log": {
+      "bytes": 34680,
+      "sha256": "22d4cfd1ef02f8c7adff8ce705efe56a7fe9a2e271951fed52aed687c626d06b",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-list-0c07f53-1.log"
+    },
+    "baseline/ordinary-list-0c07f53-1.result.json": {
+      "bytes": 36961,
+      "sha256": "e00ac1b86aadae7b2573d6b21551469263311a2a7b1f4eb7e5c69f495b347ddd",
+      "origin": "ordinary evidence.zip SHA256 879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378:gates/ordinary-list-0c07f53-1.result.json"
+    },
+    "contracts/ACCEPTANCE-REVIEW.md": {
+      "bytes": 12950,
+      "sha256": "fe2b42f9215ae9aa4a66758e62ece42d1676571196a942f194e01a37a3e9d78f",
+      "origin": "harness/analysis-public-read-design-20260925/ACCEPTANCE-REVIEW.md"
+    },
+    "contracts/CRITIQUE.md": {
+      "bytes": 11549,
+      "sha256": "70c98c3b0af6f0833687370c6d2b366abd8b73c3383a3333b5b67e49f0b38231",
+      "origin": "harness/analysis-public-read-design-20260925/CRITIQUE.md"
+    },
+    "contracts/IMPLEMENTATION-MAP.md": {
+      "bytes": 19644,
+      "sha256": "77c40ee2729a4b9289dc10ede8f8c6fd561e0c1bb846beede9fd95a10afff749",
+      "origin": "harness/analysis-public-read-design-20260925/IMPLEMENTATION-MAP.md"
+    },
+    "contracts/analysis-public-read-contract-20260925.md": {
+      "bytes": 7004,
+      "sha256": "e0b90e2b46a0c8f0693467b0585c87cd14ba258b772201b33b501a826f50ab12",
+      "origin": "harness/analysis-public-read-contract-20260925.md"
+    },
+    "diffs/7b06b8e-to-8555e41.patch": {
+      "bytes": 65080,
+      "sha256": "efff444a79e5827c59ab7cccc5c11bbb17675bce1ce73e8f5d3469dbe26e960f",
+      "origin": "git diff --no-ext-diff --no-textconv 7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd 8555e417ee840e681b55ba355fc359aac00db01d"
+    },
+    "diffs/7b06b8e-to-bab6f96.patch": {
+      "bytes": 66072,
+      "sha256": "edbe9222d221c36ced638c5c3ee2fa3050b7b03ceead52bbf3bcc1426d463d2b",
+      "origin": "git diff --no-ext-diff --no-textconv 7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd bab6f96a5b05b37f2b5d67a430aed0f67d783e73"
+    },
+    "diffs/7b06b8e-to-ddf823a.patch": {
+      "bytes": 63957,
+      "sha256": "ce074c7cebf601eca957a6272f70a43f25aad5ad57eaa422f4f69ea79ec7b531",
+      "origin": "git diff --no-ext-diff --no-textconv 7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd ddf823a3d358050b3aedc711f6ec04669e59e772"
+    },
+    "gates/cli-fixture-bab6f96/children.arcadia": {
+      "bytes": 85,
+      "sha256": "db0a26ff2aba33d7eec4fecae4d0a7ce2f380a2bb4f2bea3de44d29c99f75907",
+      "origin": ".local/analysis-public-read-gates-20260925/cli-fixture-bab6f96/children.arcadia"
+    },
+    "gates/cli-fixture-bab6f96/participants.arcadia": {
+      "bytes": 106,
+      "sha256": "462f7771f9c91fe28ff863aec2ffcb37e8d9a99753da6609fb0da4b45eb69c23",
+      "origin": ".local/analysis-public-read-gates-20260925/cli-fixture-bab6f96/participants.arcadia"
+    },
+    "gates/cli-fixture-bab6f96/project.arcadia": {
+      "bytes": 149,
+      "sha256": "b176dfe8ed8b2ef9905955846a2996f91093ec55e5ffdb91e6e31c2d0161a806",
+      "origin": ".local/analysis-public-read-gates-20260925/cli-fixture-bab6f96/project.arcadia"
+    },
+    "gates/launchers/25ec9ab5aa22d7364169772eae2cc10d508415fada9845a5fb7f115e7dd3f3e0.py": {
+      "bytes": 8480,
+      "sha256": "25ec9ab5aa22d7364169772eae2cc10d508415fada9845a5fb7f115e7dd3f3e0",
+      "origin": ".local/analysis-public-read-gates-20260925/launchers/25ec9ab5aa22d7364169772eae2cc10d508415fada9845a5fb7f115e7dd3f3e0.py"
+    },
+    "gates/launchers/37b26d4224405fb25b7078389ab28f22a2fec87875cfafd53a043eb384aac16e.py": {
+      "bytes": 10916,
+      "sha256": "37b26d4224405fb25b7078389ab28f22a2fec87875cfafd53a043eb384aac16e",
+      "origin": ".local/analysis-public-read-gates-20260925/launchers/37b26d4224405fb25b7078389ab28f22a2fec87875cfafd53a043eb384aac16e.py"
+    },
+    "gates/launchers/b197c49002be7d0e185fce2b2f3c9a568e18493b3b3a4fbbc8652ed358935f87.py": {
+      "bytes": 10916,
+      "sha256": "b197c49002be7d0e185fce2b2f3c9a568e18493b3b3a4fbbc8652ed358935f87",
+      "origin": ".local/analysis-public-read-gates-20260925/launchers/b197c49002be7d0e185fce2b2f3c9a568e18493b3b3a4fbbc8652ed358935f87.py"
+    },
+    "gates/launchers/caea90bda6be17d0def8f5d51e81be3006233383e89f5b468b8550c3fdd1ce36.py": {
+      "bytes": 10916,
+      "sha256": "caea90bda6be17d0def8f5d51e81be3006233383e89f5b468b8550c3fdd1ce36",
+      "origin": ".local/analysis-public-read-gates-20260925/launchers/caea90bda6be17d0def8f5d51e81be3006233383e89f5b468b8550c3fdd1ce36.py"
+    },
+    "gates/public-read-cli-build-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-build-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-cli-build-bab6f96-1.log": {
+      "bytes": 58614,
+      "sha256": "75d0c76e56ef43089aa44643688e8746bf82eaea7274fc36c1aee850d3185951",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-build-bab6f96-1.log"
+    },
+    "gates/public-read-cli-build-bab6f96-1.result.json": {
+      "bytes": 2355,
+      "sha256": "9bc60cfade0bd983dd447d5da404fafa09c322039fefd84185257882ea435d06",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-build-bab6f96-1.result.json"
+    },
+    "gates/public-read-cli-check-bab6f96-1.cli.json": {
+      "bytes": 3064,
+      "sha256": "4b4b745325e2f2cf7a29de2d2bf4af79cdd5001117fb921588a607ffdb697ced",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-check-bab6f96-1.cli.json"
+    },
+    "gates/public-read-cli-check-bab6f96-1.stderr.txt": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-check-bab6f96-1.stderr.txt"
+    },
+    "gates/public-read-cli-check-bab6f96-1.stdout.json": {
+      "bytes": 747,
+      "sha256": "2dcb809df93a8537b9ea0ba7a139bafb6c67163d557f692b8f7c7a882bbe2a78",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-check-bab6f96-1.stdout.json"
+    },
+    "gates/public-read-cli-rename-alias-bab6f96-1.cli.json": {
+      "bytes": 3102,
+      "sha256": "bdb3199153cf6f95d219dd84170c20f2f5b708765f1df5eafcba99cb1b4bde52",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-rename-alias-bab6f96-1.cli.json"
+    },
+    "gates/public-read-cli-rename-alias-bab6f96-1.stderr.txt": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-rename-alias-bab6f96-1.stderr.txt"
+    },
+    "gates/public-read-cli-rename-alias-bab6f96-1.stdout.json": {
+      "bytes": 2164,
+      "sha256": "2445398fe49ba900381e851d37bce518757423b71887faae9e54bc41fdd6c9ec",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-cli-rename-alias-bab6f96-1.stdout.json"
+    },
+    "gates/public-read-clippy-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-clippy-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-clippy-bab6f96-1.log": {
+      "bytes": 165,
+      "sha256": "4061235dd23ba634e9275fc8237a9ccd9f78540980ff740accdf68760c96bb79",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-clippy-bab6f96-1.log"
+    },
+    "gates/public-read-clippy-bab6f96-1.result.json": {
+      "bytes": 2095,
+      "sha256": "fdc970815698aef295e53cb944cc681e1e3eb87e9e8fc21061f00639da7ce410",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-clippy-bab6f96-1.result.json"
+    },
+    "gates/public-read-doc-list-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-doc-list-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-doc-list-bab6f96-1.log": {
+      "bytes": 538,
+      "sha256": "d4b5207694f0bcbf061cc230057c2015adac6bb0754b5727c825e5eaa0d8378f",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-doc-list-bab6f96-1.log"
+    },
+    "gates/public-read-doc-list-bab6f96-1.result.json": {
+      "bytes": 2510,
+      "sha256": "036a9354fd9a623e3ca7fb5bbe0fca7de2716a29006a32dfe6b04db315a4c1ab",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-doc-list-bab6f96-1.result.json"
+    },
+    "gates/public-read-doc-suite-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-doc-suite-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-doc-suite-bab6f96-1.log": {
+      "bytes": 832,
+      "sha256": "c93d7bfc96884dcbfb54aa2a36ba2294fd48bab036fb676931c54b7b8fd806d2",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-doc-suite-bab6f96-1.log"
+    },
+    "gates/public-read-doc-suite-bab6f96-1.result.json": {
+      "bytes": 2702,
+      "sha256": "cd9cd709b8152536070c2ef21e05e8b80ade116d769db0368713f2f603a919b8",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-doc-suite-bab6f96-1.result.json"
+    },
+    "gates/public-read-fmt-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-fmt-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-fmt-bab6f96-1.log": {
+      "bytes": 6446,
+      "sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-fmt-bab6f96-1.log"
+    },
+    "gates/public-read-fmt-bab6f96-1.result.json": {
+      "bytes": 2009,
+      "sha256": "b7509fef36f44bfa1776f63a346e6f213e5b96e015eb044a601df0e3cd001ca7",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-fmt-bab6f96-1.result.json"
+    },
+    "gates/public-read-focused-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-focused-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-focused-bab6f96-1.log": {
+      "bytes": 482,
+      "sha256": "1e7bb75052210629570b57061d56a858bb8f29de6421e93ea40e4b703660073a",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-focused-bab6f96-1.log"
+    },
+    "gates/public-read-focused-bab6f96-1.result.json": {
+      "bytes": 2560,
+      "sha256": "f02798e8fffbbfd7663c126abcec0178cea4cada88d1bdd5b53e2ae04e791c27",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-focused-bab6f96-1.result.json"
+    },
+    "gates/public-read-full-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-full-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-full-bab6f96-1.log": {
+      "bytes": 36703,
+      "sha256": "159e94ce159fcde7314abf45383419fa1199519e54fe2a223b222f25e2e81adb",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-full-bab6f96-1.log"
+    },
+    "gates/public-read-full-bab6f96-1.result.json": {
+      "bytes": 44985,
+      "sha256": "e54b77e90bf965f155a148440449df04929ba1ba063c190a2d29093a1093d058",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-full-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-8555e41-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "64216eb2e644c1042ce1db919f7c29902b2da105b43a2c2f2699928a1957e34d",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-8555e41-1.inputs.json"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-8555e41-1.log": {
+      "bytes": 2226,
+      "sha256": "7f1f79a5ee41b2a9a675ed87a2f771c21a7e94b3596332e5863d2d5e6b112b6a",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-8555e41-1.log"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-8555e41-1.result.json": {
+      "bytes": 3211,
+      "sha256": "35f037a6075b5107258f7997b9f025a05d8c8bf5da64ecf3ba8a32ab03368fc6",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-8555e41-1.result.json"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-bab6f96-1.log": {
+      "bytes": 1126,
+      "sha256": "472184c5f064e84b9c188a35d9ea8cc4ef383629175fd6493eccb32e5345d2f9",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-bab6f96-1.result.json": {
+      "bytes": 3211,
+      "sha256": "bdc37fb521607feb2e86afa790be2c3c0cd73b467844494b1ac2d0088ce182e5",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-ddf823a-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "4d88617c743ca093cfdaff90fb1defd3984aeb1a3fba15fa8368d09567403bc4",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-ddf823a-1.inputs.json"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-ddf823a-1.log": {
+      "bytes": 468,
+      "sha256": "3acdd5b0cf1dbd40c08c7e1c6feacd582ac152f3e911018223551d4e718aba51",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-ddf823a-1.log"
+    },
+    "gates/public-read-integration-list-mixed_source8_read-ddf823a-1.result.json": {
+      "bytes": 2274,
+      "sha256": "b9636049d7e11d61f22093e3cf81b71c822ea150a5de3a8ad88bbd3a50c9fc3c",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-mixed_source8_read-ddf823a-1.result.json"
+    },
+    "gates/public-read-integration-list-r3_migration-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-r3_migration-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-r3_migration-bab6f96-1.log": {
+      "bytes": 724,
+      "sha256": "f45db4fc3dfa24fa1388183f0a15cf4373dd9cff7b6fc015496984aec577a88a",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-r3_migration-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-r3_migration-bab6f96-1.result.json": {
+      "bytes": 2794,
+      "sha256": "d3bede6b9d959663a939cfe5f530cbd3e35c7bcdedf6a5e5fd0a29400eb638da",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-r3_migration-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-review_regressions-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-review_regressions-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-review_regressions-bab6f96-1.log": {
+      "bytes": 597,
+      "sha256": "49dfff6b8cdfe1e64382f22e9dc31471195e27433152e67ebde9008a60577e0e",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-review_regressions-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-review_regressions-bab6f96-1.result.json": {
+      "bytes": 2710,
+      "sha256": "dca167381aa59a984ee3dbb7936cd77d510ebbb27fc370b9246756e1f23ac3b8",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-review_regressions-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-source7_contract-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source7_contract-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-source7_contract-bab6f96-1.log": {
+      "bytes": 448,
+      "sha256": "420a9765afd8f9a69b347b2451fef6dbb036fc23caf9ac7a758d376812e0467d",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source7_contract-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-source7_contract-bab6f96-1.result.json": {
+      "bytes": 2685,
+      "sha256": "7f20420c133a6d5dd0c28ce876362de6bd93836d0fe41df869de4b2ebc4f3346",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source7_contract-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-source_files-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_files-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-source_files-bab6f96-1.log": {
+      "bytes": 923,
+      "sha256": "4942d3131beb3e512542638b46343f62bbdd3a31b1f986adef510607fedabdc6",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_files-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-source_files-bab6f96-1.result.json": {
+      "bytes": 2996,
+      "sha256": "ee16bfd3d79fb7d12be47b9b3af509ea9bd395d5b86b1ec73e686dd9019a9e58",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_files-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-source_identity_updates-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_identity_updates-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-source_identity_updates-bab6f96-1.log": {
+      "bytes": 600,
+      "sha256": "b6d659e6616023bede3feacf3085ba7f0b77079a70c06c278664e994b026aa1f",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_identity_updates-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-source_identity_updates-bab6f96-1.result.json": {
+      "bytes": 2690,
+      "sha256": "c00d4183a1e30dee11d5c08f1fe70bb03368ad4d12c9a3a9d7c0425bbe504629",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_identity_updates-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-source_nested_updates-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_nested_updates-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-source_nested_updates-bab6f96-1.log": {
+      "bytes": 1303,
+      "sha256": "68e247c4ca4d9297eec54939d9605100cdcdd85fa98083d2acfde9f929db8d19",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_nested_updates-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-source_nested_updates-bab6f96-1.result.json": {
+      "bytes": 3398,
+      "sha256": "471bbf515da032ca3b05de3566108f366a99e5784b2ff89796d70d92beb3f6b7",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_nested_updates-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-list-source_project-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_project-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-list-source_project-bab6f96-1.log": {
+      "bytes": 2974,
+      "sha256": "6a411075574c6a81482f2dbf59c4dbf997b6927dd51eec6c2f5d10af37dc7d16",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_project-bab6f96-1.log"
+    },
+    "gates/public-read-integration-list-source_project-bab6f96-1.result.json": {
+      "bytes": 5062,
+      "sha256": "27c02c33bb96ce73ceda9ddd3e4f8a64e823a5b75e60d19e51f7331c78b78ef5",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-list-source_project-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-mixed_source8_read-8555e41-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "64216eb2e644c1042ce1db919f7c29902b2da105b43a2c2f2699928a1957e34d",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-mixed_source8_read-8555e41-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-mixed_source8_read-8555e41-1.log": {
+      "bytes": 2272,
+      "sha256": "4e73f3bfe86b441768c7d435c290ebec23bbb02ea6f015439fad7838f1c0ecd0",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-mixed_source8_read-8555e41-1.log"
+    },
+    "gates/public-read-integration-suite-mixed_source8_read-8555e41-1.result.json": {
+      "bytes": 3483,
+      "sha256": "487e7f4236df6825ebe550a7d22c09191a1de1283e38fe18cec96258597c3fd5",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-mixed_source8_read-8555e41-1.result.json"
+    },
+    "gates/public-read-integration-suite-mixed_source8_read-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-mixed_source8_read-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-mixed_source8_read-bab6f96-1.log": {
+      "bytes": 1172,
+      "sha256": "45c09bf0a65b71f9e23aa96d4cdcfbf7fe8f04ee841c8e38f8fd479b5e4a2bfd",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-mixed_source8_read-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-mixed_source8_read-bab6f96-1.result.json": {
+      "bytes": 3483,
+      "sha256": "65abe894d2985cb27667ff35ba0ede8fb9db27f5be6fd21b96955bf737909ffe",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-mixed_source8_read-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-r3_migration-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-r3_migration-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-r3_migration-bab6f96-1.log": {
+      "bytes": 740,
+      "sha256": "58465a3bc7f41b3e9a59e3399900809b508c6e5561c6cc43d32ef299e57ac2a1",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-r3_migration-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-r3_migration-bab6f96-1.result.json": {
+      "bytes": 2937,
+      "sha256": "b5ab5d14011c483180421a813da385582b026533562558c4c6e8d2c4586aa25a",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-r3_migration-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-review_regressions-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-review_regressions-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-review_regressions-bab6f96-1.log": {
+      "bytes": 602,
+      "sha256": "1e6c891a1d5e4a0b9702a9160184c1bbeffb4e22f25b9f711c5f683db83b2f1a",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-review_regressions-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-review_regressions-bab6f96-1.result.json": {
+      "bytes": 2801,
+      "sha256": "cf506065aa0d16a129d90ce4bbfb5270143d59446a6fac1db5243eeb6f1e5552",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-review_regressions-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-source7_contract-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source7_contract-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-source7_contract-bab6f96-1.log": {
+      "bytes": 441,
+      "sha256": "ca8a36184a6edef469fdb2b2a83f965f6c5658165142d99199cea3c1a067151e",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source7_contract-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-source7_contract-bab6f96-1.result.json": {
+      "bytes": 2736,
+      "sha256": "1fec99210a59fb110dd03fd4db7c764109e14721e6d9d6a89eb135fa517b3a71",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source7_contract-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-source_files-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_files-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-source_files-bab6f96-1.log": {
+      "bytes": 957,
+      "sha256": "6515dd09b377cee624fbc7d2c1e76b1eae9beb32765e0cc51937479616961b93",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_files-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-source_files-bab6f96-1.result.json": {
+      "bytes": 3216,
+      "sha256": "5cc92ff3f4fe975a9b7ed89d9dab8541b02c73db02992dce49d4f5de6ed04288",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_files-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-source_identity_updates-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_identity_updates-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-source_identity_updates-bab6f96-1.log": {
+      "bytes": 604,
+      "sha256": "df9a24308d5bc7828a45751b67edd8e920c4d82f788434794799c6a2072f8bec",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_identity_updates-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-source_identity_updates-bab6f96-1.result.json": {
+      "bytes": 2765,
+      "sha256": "e05c60304fc480648493bccf525de23faf496226d3cc69452f7eeaf81be11623",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_identity_updates-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-source_nested_updates-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_nested_updates-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-source_nested_updates-bab6f96-1.log": {
+      "bytes": 1362,
+      "sha256": "96d24ff2a7870605f6d66cc28d9971cbf7da250e7afe80ade138b6c548969960",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_nested_updates-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-source_nested_updates-bab6f96-1.result.json": {
+      "bytes": 3720,
+      "sha256": "41351a22c3d9c00a8893f3f98dd2296ab34b63b649024f0ceb65738420515161",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_nested_updates-bab6f96-1.result.json"
+    },
+    "gates/public-read-integration-suite-source_project-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_project-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-integration-suite-source_project-bab6f96-1.log": {
+      "bytes": 3159,
+      "sha256": "9ebfb4046456f573bf3adb04232c344357e81a34f21e7f04e310f7fe6d89665d",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_project-bab6f96-1.log"
+    },
+    "gates/public-read-integration-suite-source_project-bab6f96-1.result.json": {
+      "bytes": 5932,
+      "sha256": "e5deb86359044c89d2ae5ce440e63b5df370633081c3ef732985927ba0cbc9e6",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-integration-suite-source_project-bab6f96-1.result.json"
+    },
+    "gates/public-read-list-bab6f96-1.inputs.json": {
+      "bytes": 105319,
+      "sha256": "c3d6c2d8b028a4e945ab8b7e0a38765a6bfe6f8851e96adc7a982949407767aa",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-list-bab6f96-1.inputs.json"
+    },
+    "gates/public-read-list-bab6f96-1.log": {
+      "bytes": 34922,
+      "sha256": "9ae7c668cc38c9076f90449d2f321b7b5501b1bb10d3437f6696a0c696135273",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-list-bab6f96-1.log"
+    },
+    "gates/public-read-list-bab6f96-1.result.json": {
+      "bytes": 37218,
+      "sha256": "eeb1c32480da861a3e9f9a9791f78d594618e5339478209fc7898ff395289f9d",
+      "origin": ".local/analysis-public-read-gates-20260925/public-read-list-bab6f96-1.result.json"
+    },
+    "launchers/package_evidence.py": {
+      "bytes": 9513,
+      "sha256": "848293266a7745fd6437ffe812bd0b6383be9a46bf5af44c7dee85c988f9b25b",
+      "origin": ".local/package-analysis-public-read-20260925.py"
+    },
+    "notes/EXTERNAL-TEST-NOTE.md": {
+      "bytes": 3088,
+      "sha256": "b36225564ebcaa113e705d058b410804b08d7517b27c481b594baf572ef1be9b",
+      "origin": ".local/analysis-public-read-design-20260925/EXTERNAL-TEST-NOTE.md"
+    },
+    "notes/prior-toolchain.txt": {
+      "bytes": 536,
+      "sha256": "1f101518dd1f90bc2cba8d26570a762832aba6debebbbe6aa50f97a944590610",
+      "origin": ".local/analysis-mixed-index-gates-20260924/toolchain.txt"
+    },
+    "oracles/crates/oa-core/src/language/analysis_source/lower/fixtures/ordinary-oa.arcadia": {
+      "bytes": 351,
+      "sha256": "3ce29eca105ba9fc0d8b051a0c133768c9d1deef49e463c87437881e74f7b98f",
+      "origin": "bab6f96a5b05b37f2b5d67a430aed0f67d783e73:crates/oa-core/src/language/analysis_source/lower/fixtures/ordinary-oa.arcadia"
+    },
+    "oracles/crates/oa-core/src/language/analysis_source/lower/fixtures/ordinary-sa.arcadia": {
+      "bytes": 351,
+      "sha256": "30fed013e76d944847836a2ba1eb317258ccd048547d46a2c8f728dbd575b072",
+      "origin": "bab6f96a5b05b37f2b5d67a430aed0f67d783e73:crates/oa-core/src/language/analysis_source/lower/fixtures/ordinary-sa.arcadia"
+    },
+    "oracles/crates/oa-core/src/language/analysis_source/lower/fixtures/typed-oa.arcadia": {
+      "bytes": 2097,
+      "sha256": "0d984364f412363abdbd92ca851ef472002604f6695329df26491dcbd4e2b76c",
+      "origin": "bab6f96a5b05b37f2b5d67a430aed0f67d783e73:crates/oa-core/src/language/analysis_source/lower/fixtures/typed-oa.arcadia"
+    },
+    "oracles/crates/oa-core/src/language/analysis_source/lower/fixtures/typed-sa.arcadia": {
+      "bytes": 2097,
+      "sha256": "5e4958765288165d8c3c72f0cc01395c07273de3cb089babca26780aca2dffb6",
+      "origin": "bab6f96a5b05b37f2b5d67a430aed0f67d783e73:crates/oa-core/src/language/analysis_source/lower/fixtures/typed-sa.arcadia"
+    },
+    "oracles/crates/oa-core/src/language/analysis_source/model_oracle.rs": {
+      "bytes": 8451,
+      "sha256": "fa8bcf0a327debb219b145939601da4636cf85ddf7744a4e34c359542dfe6fb1",
+      "origin": "bab6f96a5b05b37f2b5d67a430aed0f67d783e73:crates/oa-core/src/language/analysis_source/model_oracle.rs"
+    },
+    "reviews/LAUNCHER-REVIEW.md": {
+      "bytes": 4645,
+      "sha256": "d735facf4b1c5d3a0ccf6896c5aab34a2ce32f8751fcbf3fcc748203a6c75e82",
+      "origin": ".local/analysis-public-read-review-20260925/LAUNCHER-REVIEW.md"
+    },
+    "reviews/PUBLIC-READ-RUNTIME-READBACK.json": {
+      "bytes": 143386,
+      "sha256": "8cf8a233b3ab3f0383251fe627d0cb443d0248371313661dcdcef4235e74c4ee",
+      "origin": ".local/analysis-public-read-review-20260925/PUBLIC-READ-RUNTIME-READBACK.json"
+    },
+    "reviews/RUNTIME-PLAN.md": {
+      "bytes": 6646,
+      "sha256": "054c3ba8ffb74d88cd61c1f4662920413cfab53ef2a59c4e17e4dd168ccef5b7",
+      "origin": ".local/analysis-public-read-review-20260925/RUNTIME-PLAN.md"
+    },
+    "reviews/RUNTIME-REVIEW.md": {
+      "bytes": 7300,
+      "sha256": "d38ce7870b1520191693766c34588eb6beef9c74fc2ec1dd3aac85e60309da94",
+      "origin": ".local/analysis-public-read-review-20260925/RUNTIME-REVIEW.md"
+    },
+    "reviews/SOURCE-REVIEW.md": {
+      "bytes": 11866,
+      "sha256": "a633e8ccb82d82fd02f7607148ec527474b236ebf3a999592ea2c183b58f79ca",
+      "origin": ".local/analysis-public-read-review-20260925/SOURCE-REVIEW.md"
+    },
+    "reviews/inspect_runtime.py": {
+      "bytes": 19052,
+      "sha256": "132729db90aab52ce9fc1e225dbed8dc53338372bd7f0212efd847131efde919",
+      "origin": ".local/analysis-public-read-review-20260925/inspect_runtime.py"
+    },
+    "source-notes/harness/analysis-public-read-implementation-20260925.md": {
+      "bytes": 4159,
+      "sha256": "154384778c38d03ca866c3e7b630f34cebac99bbcbfc70a9d3d2f503c4fa9d0a",
+      "origin": "bab6f96a5b05b37f2b5d67a430aed0f67d783e73:harness/analysis-public-read-implementation-20260925.md"
+    }
+  }
+}