diff --git a/harness/DECISIONS.md b/harness/DECISIONS.md index 4ed432e6..8a3a8bb2 100644 --- a/harness/DECISIONS.md +++ b/harness/DECISIONS.md @@ -707,3 +707,29 @@ Additional scalar state changes compiler frames, so old stack controls and actual prologues remain evidence requirements; a logical slot is not a native stack byte. Remaining independently bounded parser scratch requires an explicit scope decision, not an inferred universal heap-metering requirement. + +## 2026-09-25 — accept actual emitted bytes into one owning result + +The [acceptance contract](analysis-mixed-acceptance-contract-20260925.md) selects +a shared borrow of the complete sealed PendingRename as carried authority, +rather than bare counters, duplicated policy or a new heap wrapper. Compile-time +covariance permits the short verification borrow. Use both selected parser +producer modes, complete resolution/admission and full actual-left Project +PartialEq; reserve the actual expression arena count, not original provenance. + +Move the actual model and mapped warnings with the accepted source. This preserves +diagnostic/source identity without reparsing or substituting the desired model. +Warnings already occupy the resolver ledger: exhaustively count their surviving +inventory without charging twice, verify final O+W as a bounded subset while all +verification owners remain live, then drop syntax/guards and move the bundle. +No mutable extraction, history installation or repeated carried edit is implied. + +Retain independently bounded traversal/delimiter/Pratt/duplicate-name scratch as +an explicit separate domain. File/source-byte bounds do not tightly bound copied +path bytes. This selected logical accounting is not universal heap accounting. +The [finite Windows evidence](experiments/analysis-output-acceptance-20260925/README.md) +checks exact inherited limits, real returned models/warnings, lifetime and stack +behavior. Preserve the initial two incorrect empty-warning expectations and their +independent full-warning correction. A raw build-target path spelling difference +requires only a named exact-pair checker amendment, not weakened failure or source +comparison. All earlier outcomes remain preserved; public integration is next. diff --git a/harness/STATE.md b/harness/STATE.md index 2357b282..892a5972 100644 --- a/harness/STATE.md +++ b/harness/STATE.md @@ -57,7 +57,20 @@ 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 private parser-producer checkpoints — 2026-09-25 +## Local private parser and output acceptance checkpoints — 2026-09-25 + +Source **edf096cd33350865ecfc3c65ec266a6c0d3c4000** on +`codex/analysis-mixed-acceptance-956atf-20260925` connects real emitted output to +combined parser producers, full model admission/equality and an owning result +containing the actual bundle, model and mapped warnings. +[Windows evidence](experiments/analysis-output-acceptance-20260925/README.md) +records eleven new passes, strict core Clippy and all 281 prior outcomes preserved: +the full 292-name run gives 276 passes/16 inherited failures. All 16 failure bodies remain +identical after numeric thread-identifier normalization; format is unchanged. +Ten inherited stack controls and new scoped 128 KiB verification/drop pass. Initial +nine-pass/two-failure warning-oracle corrections and the exact build-target path +spelling exception are preserved. Source and evidence remain local-only; public +source8, installation/history and repeated carried editing remain incomplete. The subsequent **29417130c71f70c4eaefe8ed4c879efba78eb72c** on `codex/analysis-entry-producers-956atf-20260925` adds the reviewed @@ -68,7 +81,8 @@ passes six new cases and strict core Clippy. Full library remains failed at bodies (numeric thread identifiers only normalized) and all ten stack controls. Formatting is unchanged. Initial test-only compilation failure is preserved. This source and packet also remain local-only under the server-storage publication blocker. -Actual output verification/accepted ownership and public editing remain open. +Actual output verification/accepted ownership is supplied by the later checkpoint +above; public editing remains open. Source **97a8703adc75467a7f8e75f5c6cb00ca542b707c** on `codex/analysis-text-producers-956atf-20260925` adds the separate private @@ -82,8 +96,9 @@ are preserved. Format remains the same inherited failure. Failure output is This source and evidence are local-only: Gitea rejected publication for server disk exhaustion. The last confirmed remote evidence commit is `b2ef3f54`; emission source `8d52dab9` is published separately. This checkpoint does not -change the integrated preview. Remaining scratch policy and actual output -verification/accepted ownership are still incomplete. +change the integrated preview. The later acceptance contract explicitly selects +the remaining scratch domain and implements actual output verification/ownership; +its exclusions and public-integration limits remain material. ## Earlier local contribution checkpoint and evidence diff --git a/harness/experiments/analysis-output-acceptance-20260925/.gitattributes b/harness/experiments/analysis-output-acceptance-20260925/.gitattributes new file mode 100644 index 00000000..2070f9ee --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/.gitattributes @@ -0,0 +1,4 @@ +*.md -text +*.py -text +*.txt -text +*.json -text diff --git a/harness/experiments/analysis-output-acceptance-20260925/ACCEPTANCE-RUNTIME-READBACK.json b/harness/experiments/analysis-output-acceptance-20260925/ACCEPTANCE-RUNTIME-READBACK.json new file mode 100644 index 00000000..c3d808ab --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/ACCEPTANCE-RUNTIME-READBACK.json @@ -0,0 +1,115 @@ +{ + "source": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "baseline": "29417130c71f70c4eaefe8ed4c879efba78eb72c", + "baseline_archive_sha256": "19a87583a8dc4c22f35999044de5cac2c2c97b04fb457d2c3df3f6d2c054c865", + "checker_sha256": "8fdf8c0ba848d8f61cb09739961239c316fdb0eb17e4b64b88ae34274cce0f53", + "inputs": 559, + "unchanged_old_outcomes": 281, + "added_passed": 11, + "added_names": [ + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::actual_expression_arena_controls_equality_reservation", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::actual_minimal_bytes_full_model_and_late_decode_boundary", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::actual_warning_mapping_boundary_and_final_transfer", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::equal_byte_wrong_models_malformed_and_admission_failure_are_distinct", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::four_file_cross_family_swap_preserves_entire_untouched_file_and_comments", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::internal_warning_shape_and_destination_inventory_faults", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::owning_result_survives_all_inputs_and_preserves_every_policy_field", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::rich_oa_sa_swaps_unicode_crlf_complete_actual_bytes_and_models", + "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::acceptance::tests::signed_zero_geometry_scalar_and_historical_equality_moves_actual_model", + "language::analysis_source::mixed::project::ordinary_index::rename::emission::acceptance::tests::zero_actual_expression_rejects_large_target_only_variants" + ], + "full_passed": 276, + "full_failed": 16, + "identical_failure_blocks_after_pid_only_normalization": 16, + "identical_fmt_sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\oa_core-416e35542925bed6.exe", + "bytes": 43066880, + "sha256": "7bc17993f265bdf7dc79b7ea5191401dd853f1dd47517235663113e4571031bb" + }, + "environment": { + "CARGO_TARGET_DIR": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913", + "CARGO_BUILD_JOBS": "1", + "CARGO_INCREMENTAL": "0", + "CARGO_HOME": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\toolchain\\cargo", + "RUSTUP_HOME": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\toolchain\\rustup", + "RUSTFLAGS": null, + "RUSTC": null, + "RUSTUP_TOOLCHAIN": null, + "ARCADIA_CODEC_LIFECYCLE_PHASE": null, + "RUST_MIN_STACK": null + }, + "baseline_environment": { + "CARGO_TARGET_DIR": "C:/Users/User/Documents/Git/ARCADIA-Studio/.local/analysis-checked-save-target-20260913", + "CARGO_BUILD_JOBS": "1", + "CARGO_INCREMENTAL": "0", + "CARGO_HOME": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\toolchain\\cargo", + "RUSTUP_HOME": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\toolchain\\rustup", + "RUSTFLAGS": null, + "RUSTC": null, + "RUSTUP_TOOLCHAIN": null, + "ARCADIA_CODEC_LIFECYCLE_PHASE": null, + "RUST_MIN_STACK": null + }, + "environment_exception": { + "field": "CARGO_TARGET_DIR", + "old_raw": "C:/Users/User/Documents/Git/ARCADIA-Studio/.local/analysis-checked-save-target-20260913", + "new_raw": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913", + "verified_absolute_target": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913", + "scope": "Only this exact slash spelling pair; every other environment field exact" + }, + "receipts": { + "acceptance-focused-edf096c-1": { + "source": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "exit": 0, + "outcomes": 11, + "listing": 0, + "log_sha256": "796a8fb992d5b50e2c3df81c8fa3ddd62d459ce88ff8b3939f1913f968a29b28", + "result_sha256": "f9fcb8771f0baf38f0221302e7b112a915054da31cdaf466ede46c91f46185d2", + "inputs_sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "launcher_sha256": "a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce" + }, + "acceptance-full-edf096c-1": { + "source": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "exit": 101, + "outcomes": 292, + "listing": 0, + "log_sha256": "5df6602c3d62c776720aa97916f0bf740de5488773d25601600aea8de27515e2", + "result_sha256": "abf9e8ab5befe76f9be41d126a6015a9754bd9d13716ffedb3699b7f8a8b294b", + "inputs_sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "launcher_sha256": "a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce" + }, + "acceptance-list-edf096c-1": { + "source": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "exit": 0, + "outcomes": 0, + "listing": 292, + "log_sha256": "9ac3a152c7c2a98a161875b8088372d836162a7520f46d8a6a96f984d75207d7", + "result_sha256": "717927d836c541f0855038ad3f4acd456fa00012784c006e2c012dc9a8524534", + "inputs_sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "launcher_sha256": "a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce" + }, + "acceptance-clippy-edf096c-1": { + "source": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "exit": 0, + "outcomes": 0, + "listing": 0, + "log_sha256": "83248e15864952f5d00a212d9a8ac3e6fc136cec5ff0b927328c20b022c7fff5", + "result_sha256": "76bf8724819de7d1ffad9ad7033e0230835a321062a60f6129c6413d9644bd14", + "inputs_sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "launcher_sha256": "a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce" + }, + "acceptance-fmt-edf096c-1": { + "source": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "exit": 1, + "outcomes": 0, + "listing": 0, + "log_sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d", + "result_sha256": "de9058d04aadc9734fb465061540600945c4c96b41c7b41a497715de3daac340", + "inputs_sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "launcher_sha256": "a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce" + } + }, + "scope": "Committed declared inputs, pinned baseline archive, raw logs and current artifact bytes; no Cargo/executable execution. Launcher semantics require independent source review." +} diff --git a/harness/experiments/analysis-output-acceptance-20260925/CHECKER-NOTE.md b/harness/experiments/analysis-output-acceptance-20260925/CHECKER-NOTE.md new file mode 100644 index 00000000..2b52a128 --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/CHECKER-NOTE.md @@ -0,0 +1,20 @@ +# Exact target-path spelling exception + +First final readback invoked strict inspect_runtime.py SHA256 `5ea98b7c5f46c09f434c040f37495f43536fd79fb6b61c8ba111dd5716936c8e`, args `edf096cd33350865ecfc3c65ec266a6c0d3c4000 edf096c 11`. It failed before creating JSON: + +```text +File "C:\Users\User\Documents\Git\ARCADIA-Studio\.local\analysis-output-acceptance-review-20260925\inspect_runtime.py", line 140, in + assert data['cwd'] == str(root) and data['environment'] == expected_env +AssertionError +``` + +Original bytes remain unchanged as inspect_runtime_strict_original.py. All five current receipts differ from baseline only in the literal CARGO_TARGET_DIR separator spelling: + +``` +old: C:/Users/User/Documents/Git/ARCADIA-Studio/.local/analysis-checked-save-target-20260913 +new: C:\Users\User\Documents\Git\ARCADIA-Studio\.local\analysis-checked-save-target-20260913 +``` + +Parent approved only this exact pair after resolution to the expected absolute workspace target. The amended checker hardcodes both raw strings, asserts baseline old spelling, resolves both equal to the explicit workspace target, then requires the complete new environment dictionary exactly. All other fields and all five current raw spellings must match. It does not normalize unknown paths, relax source/artifact matching or normalize failure bodies beyond numeric thread identifiers. Parent attributes the spelling to Join-Path setup; no gate rerun was performed to change evidence. + +Amended helper SHA256 `8fdf8c0ba848d8f61cb09739961239c316fdb0eb17e4b64b88ae34274cce0f53` completed the entire readback with exit0. JSON preserves both raw environment dictionaries plus the explicit exception. This documented evidence-format correction is not a source/test repair and does not erase the initial strict refusal. diff --git a/harness/experiments/analysis-output-acceptance-20260925/PACKAGE-READBACK.md b/harness/experiments/analysis-output-acceptance-20260925/PACKAGE-READBACK.md new file mode 100644 index 00000000..1e28eaad --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/PACKAGE-READBACK.md @@ -0,0 +1,17 @@ +# Independent final packet readback + +Disposition: no material packet-integrity or README-scope discrepancy found. This readback is separate from the runtime checker and did not execute archived code, launchers, binaries, compiler or debugger. It does not establish remote publication. Packet members were not modified; this report is outside the ZIP. + +Verified `evidence.zip`:529,018 bytes,67 members, SHA256 `2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4`. ZIP CRC validation passes. Names are unique, relative, use forward separators and contain no parent traversal. Manifest member set exactly equals the ZIP set; all67 uncompressed lengths/SHA256 pins match. The manifest source is final `edf096cd33350865ecfc3c65ec266a6c0d3c4000`. + +Independently compared every member to actual local originals, using the builder only as a reviewed mapping guide, never executing it: gate/diagnostic captures to the acceptance gate folder; baseline records to entry gates; reviews to current review originals; contracts/designs to root source documents; toolchain note and builder to exact source files. Both archived patches match fresh read-only `git --no-replace-objects diff --no-ext-diff --no-textconv` from2941713 to4872141 andedf096c. All ten external readable mirrors exactly match their archive members and review originals, including both checker versions, readback JSON and CHECKER-NOTE. + +All nine included receipts have matching raw log/input-manifest/captured-launcher hashes, identical before/after source/helper pins, no changed inputs or verification failures. Independently compared manifest content hashes and sizes to immutable Git blobs for all declared paths:557 inputs at2941713,559 at4872141,559 atedf096c. The separate completed runtime review checked current final disk bytes; this packet audit also rehashed the actual current final executable:43,066,880 bytes, SHA256 `7bc17993f265bdf7dc79b7ea5191401dd853f1dd47517235663113e4571031bb`. It matches final focused/full/list receipts and README; the ZIP correctly does not claim to embed that executable. Historical artifact identities are recorded evidence, not a claim that those overwritten binaries remain locally present. + +README claims agree with captured records and scoped reviews: final11focused passes,292name full/list inventory,276pass/16inheritedfail, strictClippy0 and unchanged format1. All281 prior outcomes and16 failure bodies remain unchanged with only numeric thread identifier replacement. Initial487 source9pass/2fail remains included, with raw empty-warning assertion failures and subsequent independent two-warning correction; source patches substantiate test/note-only repair. The source is private and local-only, with public source8/history/GUI/repeated-edit work and parser-scratch limitations still explicit. + +The original strict checker SHA256 `5ea98b7c5f46c09f434c040f37495f43536fd79fb6b61c8ba111dd5716936c8e`, its preserved refusal, amended checker `8fdf8c0ba848d8f61cb09739961239c316fdb0eb17e4b64b88ae34274cce0f53` and JSON `88cb21bc89a1337b32f74ec2fe8adc6dc2835ccea17bb313b5a7e2433fce4fd2` all match originals. The sole environment exception is the exact old/new CARGO_TARGET_DIR slash-spelling pair, resolving to the same explicit target; other raw environment fields remain exact. No generalized normalization or test rerun is hidden by the packet. + +All local README links resolve, including selected contract and readable reviews. Root STATE/DECISIONS links point to this packet and retain local/private scope. Stack claims distinguish ten inherited controls and five new scoped workers, separate prerequisites and phase prologues, preserve prior limits and avoid total-headroom claims. Final stack supplement is included byte-identically with its original. + +This audit covers the currently unstaged local packet. No staged/committed Git-byte or remote-upload readback is claimed; parent owns any subsequent staging, commit and publication. A later byte change requires rebinding the archive/manifest; this report itself does not alter the67-member archive. diff --git a/harness/experiments/analysis-output-acceptance-20260925/README.md b/harness/experiments/analysis-output-acceptance-20260925/README.md new file mode 100644 index 00000000..08aa5245 --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/README.md @@ -0,0 +1,107 @@ +# Private actual-output acceptance — Windows evidence + +Final source **edf096cd33350865ecfc3c65ec266a6c0d3c4000**, branch +`codex/analysis-mixed-acceptance-956atf-20260925`, extends baseline +`29417130c71f70c4eaefe8ed4c879efba78eb72c`. Source and this packet remain +**local-only**: Gitea rejected Git publication for exhausted server storage and +subsequently rejected the checkpoint comment. No peer-accessible commit link is +claimed. The published Windows preview and its artifacts are unchanged; Linux +remains user-deferred. + +The [selected contract](../../analysis-mixed-acceptance-contract-20260925.md) +connects real emitted PendingRename ownership to both parser producer modes, +actual complete resolution/admission and full Project equality. AcceptedRename +owns the actual bundle, actual resolved model, mapped warnings, inherited policy +and final O+W inventory. Equality reserves the actual parsed expression count; +warning storage is counted once, and destination checks precede temporary-owner +destruction. There is no borrowed desired model in the accepted result. + +## Observed gates + +Windows Rust/Cargo 1.98.1 with LLVM-MinGW 20260908 gnullvm; one compiler job, +incremental disabled, locked/offline commands. All final gates bind 559 unchanged +declared inputs, clean source before/after and one captured launcher. + +| Gate | Result | +| --- | --- | +| New acceptance tests | 11 passed, 281 filtered | +| Complete core library | 292 names: 276 passed, 16 inherited failures | +| Core all-target strict Clippy | Passed | +| Workspace format | Inherited exit 1; raw output byte-identical | +| Regression readback | All 281 prior outcomes and 16 failure bodies unchanged, normalizing numeric thread identifiers only | + +The final executable is 43,066,880 bytes, SHA256 +`7bc17993f265bdf7dc79b7ea5191401dd853f1dd47517235663113e4571031bb`. +Input-manifest SHA256 is +`6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028`. +The executable is identified in the receipts, not embedded in this archive. +Full core and format are **not** all-green gates: public schema8 dispatch remains +unavailable, and the known failures remain obligations for later integration. + +Actual tests establish the independently specified unchanged-profile boundaries: +152 bytes accepts the minimal complete rename and 151 refuses during output UUID +decoding; 161 accepts the unnamed warning and 160 refuses its mapping at the full +header span. Whole returned models/bytes, exact warning records, all policy +fields, separate verification work, source/desired lifetime independence, +admissible wrong output, malformed/model-invalid output, actual expression-bound +provenance and signed-zero semantic equality are checked. Rich OA/SA Unicode/CRLF +swaps and a four-file untouched-file case retain both real architecture warnings. + +Initial source `4872141c036c16825f1c098bd7cf44709897e814` compiled but its focused +run had nine passes and two failed empty-warning assumptions. The repair changes +only new tests and the implementation note; production is byte-identical. +[The independent correction](WARNING-FIX-ORACLE.md) derives both ordered warnings, +locations and final storage from source and authored literals. Initial logs, +artifact identity and review omissions are preserved rather than replaced. + +## Stack and evaluator scope + +All ten exact inherited stack controls pass. The new scoped test performs actual +verification and result destruction in five 128 KiB workers: deep/wide success, +deep/wide mismatch and the genuine 151-byte late refusal. Prerequisites are built +outside these workers. Deep name mismatch can short-circuit; deep success performs +the expression comparison. Older separately unrerun full-pipeline setup limits +remain distinct. + +[Stack observations](STACK-OBSERVATIONS.md) bind raw initial/final prologues. +The 17 selected old stack/active reservations are unchanged. New verification +reserves 8,648 bytes in its prologue; the carried parser wrapper changes from +536 to 568. Parsing, resolution, equality and destination checks have distinct +phases; these observations are not a whole-stack or headroom bound. + +The first strict readback refused a raw CARGO_TARGET_DIR slash-spelling difference. +[The checker note](CHECKER-NOTE.md) preserves that refusal and original checker. +The amended checker accepts only the exact recorded old/new spellings after both +resolve to the same explicit workspace target. Every other environment field is +exact; failure comparison and source/artifact checks are unchanged. Both raw +environments are retained in [the readback](ACCEPTANCE-RUNTIME-READBACK.json). + +## Evidence and reproduction + +[evidence.zip](evidence.zip): **529,018 bytes, 67 members**, SHA256 +`2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4`. +[manifest.json](manifest.json) pins every member. The archive includes initial +and final receipts/logs/manifests, captured launchers, actual Git diffs, baseline +records, both checker versions, selected prologues, contract/oracles and raw review +mirrors. Read the [source](SOURCE-REVIEW.md), [test](TEST-REVIEW.md) and +[runtime](RUNTIME-REVIEW.md) reviews with their exact source/hash bindings. +The separate [package audit](PACKAGE-READBACK.md) checks every member against +originals and Git blobs without executing archived code. + +From the identified source on the documented Windows toolchain, use one compiler +job and incremental disabled: + +```text +cargo test --locked --offline -p oa-core --lib acceptance -- --test-threads=1 +cargo test --locked --offline -p oa-core --lib -- --test-threads=1 +cargo test --locked --offline -p oa-core --lib -- --list +cargo clippy --locked --offline -p oa-core --all-targets -- -D warnings +cargo fmt --all -- --check +``` + +Private acceptance grants no public source8, installation/history, repeated +carried editing or GUI integration. Independently bounded parser scratch, +numeric/decoder internals, model/validator allocation, allocator overhead and +native stack retain their explicit separate domains. In particular, source/file +bounds do not tightly bound copied traversal-path bytes. No universal memory or +before-every-allocation guarantee follows from this evidence. diff --git a/harness/experiments/analysis-output-acceptance-20260925/RUNTIME-REVIEW.md b/harness/experiments/analysis-output-acceptance-20260925/RUNTIME-REVIEW.md new file mode 100644 index 00000000..6db04833 --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/RUNTIME-REVIEW.md @@ -0,0 +1,41 @@ +# Independent actual-output acceptance runtime review + +Final source `edf096cd33350865ecfc3c65ec266a6c0d3c4000` satisfies the selected finite regression readback after one explicitly approved target-path spelling exception. All16 inherited failure bodies remain byte-identical after replacing numeric thread identifiers only; no failure-body exception exists. Full core tests still have16 failures and workspace format still exits1. No compiler, test executable, debugger or archived launcher was executed by this reviewer. + +## Gates and bindings + +Prepared read-only checker was run using bundled Python `-I -B`, args `edf096cd33350865ecfc3c65ec266a6c0d3c4000 edf096c 11`. Original strict helper refused exact environment comparison; CHECKER-NOTE.md preserves the refusal and original helper. Amended helper SHA256 `8fdf8c0ba848d8f61cb09739961239c316fdb0eb17e4b64b88ae34274cce0f53` then completed all checks and exclusively wrote ACCEPTANCE-RUNTIME-READBACK.json. + +Readback JSON SHA256 `88cb21bc89a1337b32f74ec2fe8adc6dc2835ccea17bb313b5a7e2433fce4fd2`. + +| Gate | Exit | Actual result | +| --- | ---: | --- | +| Focused |0|11 new acceptance tests passed;281 filtered | +| Full |101|292 names:276 passed,16 failed, zero ignored | +| List |0|292 unique names, exactly full runtime inventory | +| Strict core all-target Clippy |0|Locked/offline `-D warnings` completed | +| Workspace format |1|Exact prior raw output retained | + +All281 predecessor outcomes are unchanged. Focused is exactly the11 added names and every new result is passed. Independently compared raw failure blocks as well as the checker result:16 match after replacement of numeric thread identifiers only, including whitespace and framework lines. Format SHA256 remains `c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d`. + +Baseline2941713 full/list/fmt raw logs and receipts match the locally committed entry evidence ZIP SHA256 `19a87583a8dc4c22f35999044de5cac2c2c97b04fb457d2c3df3f6d2c054c865`. No remote publication claim is made here. + +All five receipts bind current clean source,559 declared inputs and actual Git blob/disk byte equality, unchanged inputs through each run, exact commands and one captured launcher. Input manifest SHA256 `6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028`. Current focused/full/list executable is43,066,880 bytes, SHA256 `7bc17993f265bdf7dc79b7ea5191401dd853f1dd47517235663113e4571031bb`; checker reread actual bytes. Full raw log SHA256 `5df6602c3d62c776720aa97916f0bf740de5488773d25601600aea8de27515e2`; Clippy raw SHA256 `83248e15864952f5d00a212d9a8ac3e6fc136cec5ff0b927328c20b022c7fff5`. Exact per-gate raw/receipt pins are in the JSON. + +Actual captured launcher SHA256 `a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce` differs from previously reviewed entry launcher only by source pin/description and output directory. It preserves exact source-before/after checks, unfiltered merged process logs, actual exit codes, helper capture and Cargo-reported artifact hashing. Reviewer inspected this delta without running the launcher. Jobs1, incremental0 and all other recorded environment values are exact baseline matches; stack/lifecycle/compiler overrides remain absent. Only CARGO_TARGET_DIR forward slash versus backslash changes, with both exact strings resolving to the same required target. See CHECKER-NOTE; this is not generalized path normalization. + +These checks establish declared-input/recorded-artifact concordance, not independently reproducible compiler provenance or coverage of undeclared/untracked dependencies. + +## Initial failed attempt and correction + +Preserved initial source `4872141c036c16825f1c098bd7cf44709897e814` focused run exited101:9 passed/2 failed. Both failures were explicit empty-warning assumptions in rich OA/SA and four-file tests. Raw log SHA256 `b26d046e8b6284b5080ecbd6486c04f5556e1866292d5ac52f27893e69906371`, receipt `ff17f718a831784334443438ff444f6cc441a96ddd896fb1afd8e5602d9ed21a`; independently confirmed receipt/log match and counts. Initial artifact43,060,224 bytes, SHA256 `cba18de5758cac531dd166c95081fdcb390c2ceb295c06e09a26f3aa998e073c` is its own recorded identity, not the final artifact. + +Final diff changes only new test expectations/helper and implementation note. Production unchanged. WARNING-FIX-ORACLE derives both legitimate ordered diagnostics and W227/W221 from validator/mapper source and literal expected bytes, not runtime diagnostic output. Final tests SHA256 `e42fd54b157a47a69c8de2ea379b375b797a971b5bb604be572ea1f45b55b73d` require complete warnings and final rich/four-file inventories. Earlier review's missed empty-warning assumption remains explicitly recorded in TEST-REVIEW. + +## Scope of runtime and frame evidence + +Final full log has eleven stack-named passing tests:ten inherited controls and the new scoped acceptance test. The latter contains five workers:deep128-node success and mismatch, wide129-node success and mismatch, plus real inherited151-byte late refusal; setup outside workers, actual verify/assert/destruction inside128KiB workers. Deep name mismatch may short-circuit before expression equality; deep success traverses actual expressions. These finite results do not establish universal stack headroom or whole predecessor setup on128KiB. + +Read initial/final captured acceptance prologues: production verify8648, parse_entry_producers568, equal_target312, warning_inventory776, check_destination456 selected reservation bytes are unchanged by the test-only repair. Final capture has135 records versus initial125, including test/generic machinery, not135 live frames. Existing stack/active phase observations and separate source review retain their own scope. Explicit subtractions exclude pushes/caller overhead/uncaptured callees; captured64-byte ranges may cross symbol boundaries, so no whole-stack bound is inferred. Parsing, resolution and equality/destination transfer are sequential verification phases; summing all phase reservations as simultaneously live is invalid. + +Finite actual-output admission, owning model/warnings, exact152/151 and161/160 behavior, nonvacuous actual-E fault control and corrected rich whole-byte/model/warning assertions passed on this artifact. Internal fault controls are not authentic emitted histories or real late-cap proofs. This remains private acceptance, not public source8, installation/history, GUI integration, repeated carried-source editing, all-heap accounting or closure of declared scratch exclusions. diff --git a/harness/experiments/analysis-output-acceptance-20260925/SOURCE-REVIEW.md b/harness/experiments/analysis-output-acceptance-20260925/SOURCE-REVIEW.md new file mode 100644 index 00000000..ec32d3fc --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/SOURCE-REVIEW.md @@ -0,0 +1,43 @@ +# Private actual-output acceptance — independent source review + +No correctness blocker found in the reviewed production source. This is source review, not compile/runtime acceptance. The selected root contract committed locally at `b86c8dbc`, `harness/analysis-mixed-acceptance-contract-20260925.md`, has SHA256 `a8b6d7792661b3c71d3340cb3885501af8d1313a5406acaf93abdcef2650f2ec`. Final source is committed locally at `4872141c036c16825f1c098bd7cf44709897e814` on `codex/analysis-mixed-acceptance-956atf-20260925`, based on `29417130c71f70c4eaefe8ed4c879efba78eb72c`. HEAD, clean tracked worktree and all three committed production blobs were independently verified at final rebind. Publication remains blocked by the reported Gitea server-storage failure. No compiler, executable or archived helper was run by this reviewer. Source, tests and root documents were not edited. + +Reviewed committed production files, relative to `crates/oa-core/src/language/analysis_source/`: + +| File | SHA256 | +| --- | --- | +| `mixed/carried.rs` | `01031a34e69dd55a119fbdaeba19b8bb3a4c410497980701db87a4e3dc3fa347` | +| `mixed/project/ordinary_index/rename/emission.rs` | `e78dac0004d4310bffa08245c643be0b105c8a194530708019b77d176c1f2cf1` | +| `mixed/project/ordinary_index/rename/emission/acceptance.rs` | `736e11f783cf171cd75311c6453874f766ef47f8d2568a2d58dc7913b1a4b1c0` | + +## Authority, policy and lifetime + +`carried.rs:43` accepts only a reference to the complete opaque PendingRename, with an explicit desired-lifetime outlives bound. Both private backing and guard variants retain that complete reference. `into_parts` derives the actual bundle and both captured policies from this same owner; `slots` derives its retained O. No independently supplied bundle, policy or counters can replace one of these components through the new API. Covariance is structurally consistent with PendingRename's immutable desired reference, but actual Rust compilation must establish the chosen shortening and borrow termination. + +`parse_entry_producers` selects both stronger modes with the derived policy and guard. Existing fixture constructors and old parser routes are unchanged. The pointer-only new guard variant does not duplicate policy or add a heap owner. Emission still constructs PendingRename only after authenticated output sizing/copying and old-owner destruction; its unchanged no-op and carried-source rejection rules remain in force. The accepted object has private owned bundle/model/warnings and scalar policy/accounting fields, only immutable views, and no syntax or desired lifetime. No public source8 activation or repeated carried emission is introduced. + +## Actual model equality and accounting + +`acceptance.rs:49` parses the real pending bytes and consumes the result through existing complete resolution/admission. Existing `project.rs:452` seeds O once, inventories syntax once, and retains mapped warning storage. `equal_target` at line106 reserves `resolved.expressions.len()` against this full live ledger before calling `resolved.project.eq(desired)`. It never uses the original pending expression count or the planner's name-exempt matcher. The local equality frontier is released on both true and false returns, after PartialEq's temporary has dropped; failed reservation cannot invoke equality. + +The previously reviewed E proof remains applicable: the model/analysis/lowering sources have no diff from18073a6 to29417130, and this patch does not modify them. Actual calculation bodies, property bases, case overrides and check predicates are lowered into the actual arena. In `analysis/expression_lifecycle.rs:170`, pending comparison pairs address distinct actual-left tree nodes, with shape checks before list/call children; each root comparison finishes before another root starts. Parent variant/map/option comparisons cannot invent a missing actual Expr root. Thus E_actual0 cannot reach the allocating Expr comparator. Whole Project PartialEq preserves names, non-name content, historical payload comparison and existing signed-zero semantics; it introduces no bespoke matcher. This proof must be reconsidered if model carriers, lowering or equality change. + +`warning_inventory` at line134 exhaustively destructures both diagnostic structs, counts one record and every currently owned string using checked additions, and rejects nonempty related locations or Error severity. Its count matches the existing mapper in `project.rs:590..655`, which already reserves the strings and record. `check_destination` at line119 checks all three components of O+W against live storage, then checks the inherited Budget ceilings. It neither reserves W again nor releases syntax early. The borrowed warning loop adds no allocation frontier. + +## Ownership transfer and failure behavior + +Only after equality and destination checks succeed are the actual Project and warning vector moved out of the resolved owner. Expression/occurrence vectors and syntax/guard then explicitly drop before the pending bundle is moved into AcceptedRename. No model, warning, path or vector clone is added. Final retained counts describe O+W; scalar verification Usage and numeric units come from this actual parse and remain distinct from the original snapshot's work. Catalog owners have already been released by successful resolution. The full ledger remains unchanged through the destination checks; the destination scalar is not an early release of live coexistence. + +Parse failures retain their existing located diagnostics; resolver failures propagate. Equality mismatch uses a static invalid_source message at the entry/default0..0 span. Reservation/inventory failures use the same safe default attribution. All failures destroy the consumed pending owner and temporary verification state; no accepted authority escapes. Diagnostic rejection transport remains the established exception, not successful retained storage. + +## Changes and remaining gates + +The helper extraction from draft acceptance SHA `e24295f0e79d0a7254a502eb2a240ce555aa0d169f17e0308ee96419ce3d93ff` to reviewed `736e11f7` preserves reserve→whole compare→release ordering and enables a direct ledger-fault test without widening inherited policy. The emission module header was corrected to describe its verification child. The final carried hash supersedes reviewed `44de0108670f5c96c6b385f0c42b215297127c9e4235920d7697b8729aaa5cb3` solely through the requested module-header clarification; independently reconstructing the old header reproduced that exact old hash. No production logic changed at final rebind, and no source finding remains open. + +Tests are committed and reviewed separately; they are not accepted by this source report. Required parent gates include lifetime/privacy compilation, full-target and greater-actual-E cases, independent whole bytes/model/warning expectations, exact inherited limits, failure/drop/lifetime cases, unchanged old outcomes, strict lint/format disposition and meaningful scoped stack controls. This code adds by-value owner/result locals and a comparison helper; source review cannot quantify compiler frames or promise128KiB success. Parser scratch, numeric/decoder/model/validator allocation and native stack retain the contract's explicit domain exclusions. Final compilation/runtime and publication remain parent-owned and pending. + +## Supplemental binding — test-oracle repair edf096cd + +Independently verified clean tracked HEAD `edf096cd33350865ecfc3c65ec266a6c0d3c4000`. The exact4872141c→edf096cd diff changes only the new `acceptance/tests.rs` and its implementation note. All three production files have zero Git diff and retain the hashes in the table above; the source-review conclusion therefore applies to both initial487 and repairededf. Both commits remain local-only. + +The test diff replaces incorrect empty-warning assertions in two rich fixtures with complete literal ordered diagnostics for `unallocated_leaf` and `work_without_behavior_context`, and updates final retained O+W counts. It preserves actual bundle/model assertions, inherited policies, existing tests and scoped stack worker bodies. The initial487 compilation succeeded and focused execution completed9 passes/2 failures at those empty-warning assertions; its original evidence and initial stack observations remain preserved. Independent oracle validation belongs to the separate test review. Correctededf compilation/full runtime/artifact and prologue readback remain pending at this supplement; no newer pass or unchanged compiled-frame claim is inferred from unchanged production source. diff --git a/harness/experiments/analysis-output-acceptance-20260925/STACK-OBSERVATIONS.md b/harness/experiments/analysis-output-acceptance-20260925/STACK-OBSERVATIONS.md new file mode 100644 index 00000000..5c15d605 --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/STACK-OBSERVATIONS.md @@ -0,0 +1,69 @@ +# Initial actual-output acceptance — selected Windows prologues + +Initial observations are preserved below. The final edf096cd artifact and runtime-control rebind follows in the last section. + +This read-only review concerns initial source `4872141c036c16825f1c098bd7cf44709897e814`, not a later repaired test artifact. Its focused receipt identifies a **43,060,224-byte** executable, SHA256 `cba18de5758cac531dd166c95081fdcb390c2ceb295c06e09a26f3aa998e073c`. The unoptimized Windows test build completed; the initial focused run **failed:9 passed,2 failed**, exit101. Both failures were empty-warning assertions in the rich and four-file fixtures. Their independent expectation correction remains separate; this report does not erase those failures or establish final acceptance. + +Read the captured JSON disassemblies and capture-helper source without running helpers, disassemblers, compilers or binaries. Final-source rebinding is pending. The helpers verify executable size/hash against the gate receipt before querying symbol addresses and64-byte entry disassembly. Every reviewed record's source/artifact/helper binding and selected address range agrees with its enclosing capture. Baseline is29417130, executable42,898,944 bytes/SHA256 `adb0bd907f614c512bc3883dfe9a88ca0e4268638d85f4899ad07a5c1d3ec4e9`. Its copied stack/active records equal the original entry checkpoint bytes; the new three-symbol baseline acceptance capture is additional evidence for this checkpoint. + +| Selected explicit reservation | Baseline2941713 | Initial4872141 | +| --- | ---: | ---: | +| `PendingRename::verify` | absent |8648| +| `carried::parse_entry_producers` |536|568| +| `mixed::parse_impl` |12888|12888| +| `project::resolve` |12072|12072| +| `acceptance::equal_target` | absent |312| +| `acceptance::warning_inventory` | absent |776| +| `acceptance::check_destination` | absent |456| + +The seven original stack-symbol records and ten active-symbol records have identical selected reservation values versus294. These include parse_with_profile216, parse280, accepted1608, indexed1608, the actual old ordinary-index worker7368 and its distinct test shim56. Parser::unit12456, State::parse_typed6952, declarations::parse22664, binding2520, prefix11720, continuation13416, Exact::parse_decimal2296, Exact::parse_literal952, Budget::exact632 and Cursor::exact_literal776 remain unchanged. + +The125-record acceptance capture includes production routines, generic adapters, tests and thread machinery; it is not125 simultaneously live frames. The new deep/wide worker is the nested `{closure#0}::{closure#0}` at address `0x140ada030`, reservation2888, whose capture visibly calls verify. The separate late-refusal worker `{closure#1}::{closure#0}` reserves792. The56-byte same-named test shim calls the outer test; host scope closures reserve600/552, and the outer test reserves9864. These host routines prepare/spawn work and must not be substituted for, or simply added to, the spawned worker's call stack. Captured40-byte thread vtable adapters are another distinct layer; these observations are not a complete thread-start inventory. + +Source and raw results establish five finite128KiB workers inside the passed `scoped_small_stack_actual_deep_wide_verification_and_drop` test:128-node deep and129-node wide actual-byte verification/drop, corresponding target-only mismatch refusals, and genuine inherited151-byte-profile parser refusal. Authored/indexed/planned/emitted prerequisites are prepared outside each worker. The two successful cases also compare whole expected bytes and models before accepted destruction. This initial focused run does not rerun the ten old stack controls; unchanged prologue values alone do not establish their runtime result at487. + +Verify remains on the stack while parsing, then while resolving, then while comparing/checking/transferring. Parse and resolve are sequential phases, and equality/warning/destination checks follow resolution; summing all those bodies as one live chain is wrong. Likewise Pratt prefix and continuation are alternatives. Reported values are explicit entry stack reservations, excluding other pushes, ABI/caller overhead, uncaptured callees and runtime effects. They are neither a measured stack trace nor a total headroom bound or universal128KiB guarantee.64-byte captures can cross a symbol boundary: for example `AcceptedRename::bundle` has no explicit subtraction before returning, while the following `policy` symbol reserves168. Read each named symbol's own body rather than taking an arbitrary later immediate. + +Evidence in `.local/analysis-output-acceptance-gates-20260925`: + +| File | SHA256 | +| --- | --- | +| `acceptance-focused-4872141-1.acceptance-frames.json` | `e1f1fceaba2a2f8371777966457dbcbd0e20aaad497fdaa3e0b88adcaeaccdab` | +| `acceptance-focused-4872141-1.stack-frames.json` | `8d8711560725d91d2646b3ccd96188844e46a2b6de74f94ab680a029c60ee072` | +| `acceptance-focused-4872141-1.active-frames.json` | `2563e8b8f0a1aa0957995f2997e9abab2da3894fa2765a4503bd45019be3f2b8` | +| `prior-2941713.acceptance-frames.json` | `e4e5d4aedc946cf27b5b1c7715f12540998a376642279f7a8042966788cf6c4d` | +| `acceptance-focused-4872141-1.result.json` | `ff17f718a831784334443438ff444f6cc441a96ddd896fb1afd8e5602d9ed21a` | +| `acceptance-focused-4872141-1.log` | `b26d046e8b6284b5080ecbd6486c04f5556e1866292d5ac52f27893e69906371` | + +## Final artifact and controls — edf096cd + +Independently rebound to final source `edf096cd33350865ecfc3c65ec266a6c0d3c4000`, artifact **43,066,880 bytes**, SHA256 `7bc17993f265bdf7dc79b7ea5191401dd853f1dd47517235663113e4571031bb`. The current executable bytes were independently reread and matched this identity without execution. Final focused/full receipts and all three final frame captures bind the same source/artifact. Their helper hashes and every recorded symbol/address range agree. This supplements the initial487 artifact; it does not replace its nine-pass/two-failure history. + +All17 original stack/active selected reservations match both487 and294. Within the acceptance capture, all125 initial records' symbol identities remain represented; the only changed existing explicit reservations are the two corrected ordinary-harness tests: four-file7016→7384 (+368) and rich6312→6760 (+448). Ten added records belong to the new expected-warning helper and its array-map adapters. The final135 records therefore do not signify ten added production frames. All seven production reservations in the table remain unchanged from487: verify8648, combined route568, parse_impl12888, resolve12072, equal_target312, warning_inventory776 and destination456. The route remains32 bytes larger than294's536. The new actual worker2888, late-refusal worker792, host/test closures and shim retain their initial values. Extraction was restricted to each first named symbol body, avoiding the neighboring-symbol issue above. + +Final focused raw output and receipt agree on **11/11 passed**, exit0. Final full raw output/receipt agree on292 unique outcomes: **276 passed/16 failed**, exit101. The final full run includes the new scoped acceptance control as passed. To verify the inherited controls, matched these exact names from the actual294 baseline listing and full log to the final full raw log and receipt; all ten remain `ok`: + +```text +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::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 +``` + +This is finite runtime concordance for the recorded tests, not a summed-frame headroom estimate or a broader pipeline/setup guarantee. The phase separation, excluded stack costs and prior-source limits above remain applicable. Full failure-body/input/compiler-gate reconciliation belongs to the separate runtime review; no archived checker, compiler or executable was run for this supplement. + +| Final evidence file | SHA256 | +| --- | --- | +| `acceptance-focused-edf096c-1.acceptance-frames.json` | `82dafc72bedd30781e783337d607299467ff8e5df0f52ebb2c7c2f4f9cdf4adb` | +| `acceptance-focused-edf096c-1.stack-frames.json` | `00bf93f10060160a3adc38109ae512d698a07d8313b02258fc0859d8ec3fb601` | +| `acceptance-focused-edf096c-1.active-frames.json` | `b0c8ec63791c165e03d8c77a29e07bd7e624848ca83bea05929ef6a1c76196ed` | +| `acceptance-focused-edf096c-1.result.json` | `f9fcb8771f0baf38f0221302e7b112a915054da31cdaf466ede46c91f46185d2` | +| `acceptance-focused-edf096c-1.log` | `796a8fb992d5b50e2c3df81c8fa3ddd62d459ce88ff8b3939f1913f968a29b28` | +| `acceptance-full-edf096c-1.result.json` | `abf9e8ab5befe76f9be41d126a6015a9754bd9d13716ffedb3699b7f8a8b294b` | +| `acceptance-full-edf096c-1.log` | `5df6602c3d62c776720aa97916f0bf740de5488773d25601600aea8de27515e2` | diff --git a/harness/experiments/analysis-output-acceptance-20260925/TEST-CHECKLIST.md b/harness/experiments/analysis-output-acceptance-20260925/TEST-CHECKLIST.md new file mode 100644 index 00000000..eab51402 --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/TEST-CHECKLIST.md @@ -0,0 +1,37 @@ +# Independent accepted-output test review checklist + +Prepared before implementation/test handoff from root commitb86c8dbc's `harness/analysis-mixed-acceptance-contract-20260925.md`, baseline2941713, ACCEPTANCE-ORACLE and WARNING-ORACLE. No compiler/source edits or execution. This is a review rubric, not a new contract or passing result. The selected contract supersedes the older proposal's bundle-only destination: accepted success now also moves actual Project/warnings. + +## Essential positive and negative controls + +- Minimal real p→next path must use one unchanged inherited entries17/bytes152 policy from original parse through verification. Compare the entire literal bundle and entire independently expected Project, empty warnings, final Slots(1,0,105), exact Limits/ProjectLimits and verification Usage. Expected verification work is bytes81, raw tokens19, entries1, references0, deepest_frame0, numeric0; original work remains separately bytes78. Merely checking aliasnext or equality with a Project obtained by reparsing the emitted output is circular. +- The corresponding original bytes151 policy must demonstrably reach genuine emitted PendingRename before verify refuses at main37..38, line2column27, exact byte-limit error. It must not mutate the pending policy. Entries16 rejects emission first and cannot be called a verification entry boundary. +- Warning-bearing real path uses entries18/bytes161, complete literal returned Project and exactly the independently expected unnamed warning, including object ID, fieldname, message, path, relatedempty, severity,11..69 span and line2column1. Final inventory must be(2,0,157), not O alone or live syntax+W. Original warning11..66 must not be returned as output evidence. Same-path bytes160 must reach verification then refuse mapping at full11..69; a generic is_err or parser one-byte span is inadequate. +- Reuse real OA/SA/all-file Unicode/CRLF/swap fixtures with previously independent expected bytes and complete desired models. Compare all files including untouched files, entry/key set, returned whole model and warnings. Tests must exercise the actual consuming verification method, not repeat emitter-only assertions after bypassing it. + +## Equality tests that actually discriminate + +- On a fresh real pending result, equal-byte aliasnext→nope and nameProject→Changed preserve O and remain admissible; verifier must reject at the exact semantic-mismatch0..0 diagnostic. If tests cannot establish actual admission, a generic failure may only be a parser/model failure. Add a narrowly observable stage or an independent admitted fixture control, not a second permissive production verifier. +- Malformed version-byte corruption must refuse before equality, separately from model-invalid but parseable output. A model-invalid fixture needs the specific admission diagnostic, not the semantic mismatch message. Keep these cases distinct. +- ActualE1→3 corruption `10000`→`1 + 2` uses equal-length literal bytes and original policy4096. Assert the *actual reservation amount* or narrow test observation is3, not merely that verification rejects. Both old-E and actual-E implementations can reject the changed root variant; mismatch alone cannot prove provenance of the bound. The fixture is an injected corruption, never claimed authentic emitter output. +- Wide/deep positives and target-only shape mismatch must reach equality. Arrange a common admitted actual left model and independently authored unequal desired target; identify list/call-size checks versus child traversal. Root-type inequality alone does not prove a large live frontier. Never infer a required equality cap-minus-one from E if earlier lowering dominates that same unchanged cap. +- Signed-zero checks must reach whole-Project comparison while semantic fields otherwise agree, and expect the established PartialEq behavior. A no-op returning before verify or comparing a model to itself is vacuous evidence. +- Any length-changing corruption must have an explicit current-inventory rejection or independently constructed actual-O fault provenance. Do not silently update retained scalars after mutating bytes, then call that a real inherited owner. Test helper mutability must remain cfg(test), with no arbitrary production bundle/model/policy/Slots constructor. + +## Ownership, transfer and warning accounting + +- Return AcceptedRename outside a lexical scope that drops original bundle, original source witness and desired Project, then inspect bundle/model/warnings. A success variable merely used before those inputs drop does not prove owning lifetime. Compile-time borrow restrictions should prevent pending move/mutation while its carried guard exists; runtime counters alone cannot prove this. +- Verify actual resolved Project is moved into the result rather than desired cloned into it; source review is necessary because equality makes successful values observationally equivalent. Likewise warning/model cloning cannot be reliably excluded by value-equality tests alone. +- Warning inventory controls cover checked sums, non-Error severity and empty related; unexpected-shape/overflow tests are labeled internal faults. Do not manufacture a real late finalO+W refusal when the larger earlier resolver/equality peak already prevents reaching it. +- Full resolver live inventory must include warnings throughout equality; finalO+W is checked as a subset without resetting live storage before actual drops. Tests may use narrow transition observations, but cannot substitute artificial counter rewrites for source-backed lifecycle review. +- Failed verify must return only diagnostics, no accepted/usable partial output, and preserve original source/desired values. Small static mismatch diagnostics must not recursively format large models. Returning a borrowed accepted type or separately mutable model/bundle access violates the selected contract despite passing value assertions. +- Compare exact inherited policy fields, including model/traversal and numeric controls, not just entries/bytes. New snapshot Usage is independent; no original+verification work sum is claimed. Accepted retained slots exclude temporary syntax/equality arenas and include all mapped warnings. + +## Stack and evaluator boundaries + +- Scoped128KiB verify/drop tests prepare legitimate predecessors outside the worker. Worker still performs actual verify, assertions and accepted/result destruction for meaningful deep/wide inputs and a late refusal. Do not replace it with an already accepted value move, discard the returned value outside the worker, enlarge the stack, or silently route a failure around the intended phase. +- Preserve old test bodies/limits and source-pin all new results. Inspect added representation/prologue cost; a few scalar fields or nonrecursive code do not prove harmless stack use. Ordinary-harness success alone is not128KiB evidence. +- Keep exact-cap syntax checks separate from existing inventory-walker scratch. The prior entry review caught that a full-cap syntax witness cannot necessarily run a later scratch-charging recount. A roomy separate same-literal recount is valid; raising the original boundary to accommodate the evaluator changes the claimed test. +- Initial compilation/runtime failures must remain visible. Build gates and source reviews establish different facts; read-only precompile review is not a compiler pass. Final readback must preserve prior281 outcomes,16 failure bodies normalized only for numeric thread identifiers, format bytes and artifact/source concordance unless a separately justified explicit change is selected. + +At handoff, bind TEST-REVIEW to final test/source hashes, identify which assertions implement each discriminating boundary above, and report concrete omissions rather than expanding into universal parser-scratch or physical-memory testing. New accepted-output tests do not by themselves establish public source8, installation/history, repeated carried editing or GUI integration. diff --git a/harness/experiments/analysis-output-acceptance-20260925/TEST-REVIEW.md b/harness/experiments/analysis-output-acceptance-20260925/TEST-REVIEW.md new file mode 100644 index 00000000..1ad3bcde --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/TEST-REVIEW.md @@ -0,0 +1,47 @@ +# Independent actual-output acceptance test review + +Reviewed eleven new tests in `crates/oa-core/src/language/analysis_source/mixed/project/ordinary_index/rename/emission/acceptance/tests.rs`, SHA256 `64fb048f228487be0f86e06033836cdd420dd1ca3ae5b23939c1c47245cbc7a0`, against selected contractb86c8dbc, ACCEPTANCE-ORACLE, WARNING-ORACLE and TEST-CHECKLIST. Relevant source baseline2941713; new code is locally pending. No compiler, parser, test binary or debugger executed by this reviewer. + +Disposition: no concrete precompile evaluator blocker found in these bytes. Ready for parent formatting/compiler/runtime gates, with the scope qualifications below. This is not a compile guarantee or runtime acceptance. + +## Literal boundaries and predecessor provenance + +Minimal entries17/bytes152 and151 are installed before original parsing and survive real parse/resolve/index/plan/emission into consuming verify. Pending bytes compare with independent NEXT before verify. Success compares complete one-file bundle, complete literal Project, empty warnings, final Slots(1,0,105), exact verification Usage81/19/1/0/0 and numeric0, and all policy fields. Negative pins main37..38, byte-limit message and line2column27. Original bytes78 are separately asserted and source/desired remain unchanged. There is no fabricated late entry16 control. + +Warning entries18/bytes161 and160 likewise follow the actual predecessor path. The original is now the independently authored exact71-byte empty-name literal. Parent caught an earlier pre-execution draft offset deletion21..28 instead of content22..29; that draft defect is repaired before these reviewed bytes and is not a runtime failure. Original warning11..66 and returned warning11..69 are explicitly distinguished. Positive compares whole literal Project, exact complete warning including severity/object ID/field/related/message/path/line/column, final Slots(2,0,157), work74/19/1/0/0 and policy. Negative checks mapper full11..69, not the parser's one-byte transport. Byte caps are unchanged through emission; no final-only retention cap is invented. + +The warning success checks its sole expected file's bytes rather than reconstructing the whole bundle assertion in that test. Minimal and rich/four-file tests separately check entire bundle identity, while the warning-specific test discriminates W retention and output diagnostic positions. This is adequate combined coverage, not an extra independent all-file warning fixture claim. + +## Equality and genuine ownership evidence + +Equal-byte alias/name corruptions first parse and resolve the actual mutated pending bundle, proving they are admissible wrong models, then require the exact semantic mismatch0..0 from verify. Version corruption is separately a scanner refusal. Parent self-reference corruption first establishes grammar validity and then requires containment_cycle, distinguishing model rejection from equality rejection. All mutation is confined to private test access; no unchecked production constructor is introduced by these tests. + +ActualE1→3 preserves195 output text bytes and derives actual arena3 from the freshly resolved output. It calls the same equal_target helper used by verify, verifies successful reservation/release restores the real ledger, then labels the4094-entry ledger injection under unchanged4096 policy. OldE1 would fit that state; actualE3 must refuse and leave it unchanged. This is a useful discriminating internal provenance test, not a genuine late-cap pipeline or a demonstration that root-variant comparison itself uses a frontier larger than1. Dropping that fault-injected resolver and checking actual verify mismatch preserves the normal-path evidence separately. + +The accepted value escapes a lexical block that owns original input and desired; subsequent access compares model/source/warnings and custom policy. This materially checks owning lifetime at compilation, unlike a use before desired drops. All five Limits fields plus numeric policy and all seven ProjectLimits/model fields are compared with deliberately nondefault values. + +Warning shape controls reject related locations and Error severity; destination controls distinguish all three subset components; checked arithmetic faults are labeled. They do not claim an impossible real final-onlyO+W threshold. Source review still owns proof of move-without-clone, full-ledger coexistence until actual drops, and complete pending guard authority; value comparisons alone cannot establish those properties. + +## Rich files, semantic equality and stack scope + +Rich OA/SA cases use the previously independently authored complete byte strings and rich_model-derived independent desired alias/parameter changes. They cover global/scoped swaps, reordered/repeated call arguments, Unicode comments, whole-file CRLF transforms and all-file retained text totals. The four-file case adds cross-family swaps and an entirely untouched comment file; expected bytes are complete literals, not generated by the production edit iterator. Source/desired cloning in test setup is allowed and does not weaken the production no-clone requirement. + +Signed-zero geometry compares entire returned Project and asserts actual returned positive-zero bits while desired has negative zero: this would detect substitution of desired for actual. Scalar/default and historical carriers use the established valid fixture and semantic PartialEq, with additional positive-zero checks for returned scalar/default values. Historical carrier equality is exercised but its returned bit pattern is not separately asserted; the geometry/scalar checks already discriminate actual-model retention. + +Scoped128KiB tests prepare original authored owner, desired, target fault and pending emission outside each worker. Worker actually parses/resolves/verifies, checks success or mismatch and destroys accepted/failure state inside its scope. Deep128-node and wide129-node positives compare complete models and output bytes. Wide mismatch removes one target-only list member. Deep mismatch changes the project name and may short-circuit before Expr comparison; do not describe it as a deep expression mismatch walk. Deep success performs the real expression comparison. A separate real151-policy worker reaches the late grammar refusal. This is faithful scoped verification/drop coverage, not full predecessor setup on128KiB. + +Zero-actualE fixtures with unbound actual bodies and large target-only expression variants test rejection without needing an actual Expr frontier. They deliberately run on the normal test thread and are not small-stack evidence. No test changes original small-stack allowances or claims additional process repetitions. + +## Remaining gate boundaries + +All reviewed Result error extraction avoids the earlier EditDeclaration Debug unwrap_err problem. I found no obvious fixture grammar/privacy/type-shape issue by inspection; compiler remains authoritative. Subsequent formatting or edits require final hash rebinding. Runtime review must preserve the existing281-name disposition and16 failure bodies, format output and source/artifact identity, while separately recording any new compile/runtime failure. This suite does not establish public source8, GUI/history installation, repeated carried emission, universal memory bounds or untested equality payload extensions. + +Final source freeze supplied by implementer: `4872141c036c16825f1c098bd7cf44709897e814`; test SHA64fb048f228487be0f86e06033836cdd420dd1ca3ae5b23939c1c47245cbc7a0 unchanged. Eleven focused tests. Compiler/runtime gate disposition remains pending. + +## Initial runtime disproves two warning assumptions + +Parent's initial4872141 focused attempt reports9 passed/2 failed: rich OA/SA and four-file tests incorrectly required empty warnings. My initial review missed the known unallocated-leaf and behavior-context warnings. The earlier ready disposition is superseded for those evaluator expectations, not erased. WARNING-FIX-ORACLE.md now derives both ordered complete diagnostics, locations and finalO+W from source/literal bytes independently of runtime diagnostic output. Await corrected test bytes and final gates; no production change or cap relaxation is justified by these failures. + +Read back repaired test SHA256 `e42fd54b157a47a69c8de2ea379b375b797a971b5bb604be572ea1f45b55b73d`: only the two warning expectations and retained inventories change, with a literal helper returning both exact ordered records. Rich uses main338..403 line6 or351..416 line7, W227/entries2; four-file uses b25..90 line2, W221/entries2. Fields, messages, ID2, severityWarning, relatedempty and column1 match the independent oracle. Complete expected models/bytes, caps and production remain unchanged. Ready for parent's repair commit and rerun; no passing result inferred. + +Final repaired source `edf096cd33350865ecfc3c65ec266a6c0d3c4000`, same e42fd54b test hash, now has independently reconciled focused11pass and full276pass/16inheritedfail,292 listed names, strictClippy0 and unchanged format1. RUNTIME-REVIEW.md records exact bindings and the separately documented target-path separator exception in the readback evaluator. Original4879/2 failure and this review's initial miss remain preserved. No tests or compilers were executed by this reviewer. diff --git a/harness/experiments/analysis-output-acceptance-20260925/WARNING-FIX-ORACLE.md b/harness/experiments/analysis-output-acceptance-20260925/WARNING-FIX-ORACLE.md new file mode 100644 index 00000000..e1d6364e --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/WARNING-FIX-ORACLE.md @@ -0,0 +1,53 @@ +# Independent correction: rich/four-file retained warnings + +Initial4872141 focused evidence reports9 passes and two failing empty-warning expectations. These are evaluator errors; my precompile review also missed them. Preserve that attempt, original reviewed hash and failed assertions. This correction is derived from validator/mapper source and independently authored expected output literals, not from runtime diagnostic contents. No parser/test/compiler executed for the oracle. + +## Exactly two ordered warnings + +Both fixture families contain one unallocated leaf Work, ID`00000000-0000-0000-0000-000000000002`, with no same-kind child, allocation, process/chain or scenario inclusion. Rich SA additionally contains a system, so missing_system does not apply. All names are nonempty; calculations/properties do not introduce another work element; no capabilities/missions/exchanges/scenarios exist. Diagrams do not count as behavior inclusion. + +`validation.rs:434–445` emits the ordinary leaf allocation warning. Then, after successful structural validation, `validation.rs:1043–1045` invokes coverage.validate. `validation/coverage.rs:65–77` emits the advisory behavior-context warning for the same ungrouped/unincluded work. This second warning must not be omitted. `validation.rs:30–33` converts its empty field argument to None. Existing `project/tests.rs:167+` independently retains both warnings for these same work-model semantics, corroborating rather than replacing this source derivation. + +Expected warning array order: + +| Position | code | field | exact message | +| --- | --- | --- | --- | +|0|unallocated_leaf|Some("allocation")|Allocate leaf 'Work' to a performer.| +|1|work_without_behavior_context|None|Include this leaf activity/function in a process/chain or scenario through a work action or exchange occurrence.| + +Both have severityWarning, object_idSome(ID2), empty related, and the same complete ordinary Work declaration location listed below. They are not sorted alphabetically. Mapper field_span falls back to owner.span because allocation is not authored; None also uses owner.span (`mixed/project.rs:668–687`). The ordinary span includes the closing brace, but excludes following line ending. Renaming aliases does not change the warning's display-name Work. + +## Exact output locations + +| Expected literal family | path | span | line | column | +| --- | --- | --- | ---: | ---: | +| Rich OA LF |main.arcadia|338..403|6|1| +| Rich SA LF |main.arcadia|338..403|6|1| +| Rich OA Unicode/CRLF |main.arcadia|351..416|7|1| +| Rich SA Unicode/CRLF |main.arcadia|351..416|7|1| +| Four-file cross-family swap |b.arcadia|25..90|2|1| + +Rich work line is exactly `oa_activity p "Work" id "00000000-0000-0000-0000-000000000002" {}` or the equal-length `sa_function` variant. Unicode mode prepends `// 雨\r\n` (8 UTF-8 bytes) and converts every LF toCRLF. Five preceding LF replacements plus the8-byte prefix shift the work start by13 and line by1. Four-file b begins `// f and w are comments\r\n` (25 bytes), followed by the65-byte activity declaration with aliasf, thenCRLF. Positions were independently checked by raw-byte substring arithmetic on the expected literals, not a production token scanner. + +## Exact W and final O+W + +First warning: code16 + field10 + message36 =62 bytes before path. Second: code29 + field0 + message112 =141 bytes before path. Each owns its own path string, even though both paths are equal. + +- Rich: path12 each; W.text=(12+62)+(12+141)=227, W.entries2, occurrences0. +- Four-file: path9 each; W.text=(9+62)+(9+141)=221, W.entries2, occurrences0. + +| Family | Existing actual output O | New expected final accepted O+W | +| --- | --- | --- | +| OA LF |(3,0,942)=900+42 text|(5,0,1169)| +| OA Unicode/CRLF |(3,0,985)=943+42|(5,0,1212)| +| SA LF |(3,0,1016)=974+42|(5,0,1243)| +| SA Unicode/CRLF |(3,0,1059)=1017+42|(5,0,1286)| +| Four files |(4,0,526)|(6,0,747)| + +These are destination retained counts, not resolver/equality peaks. Roomy inherited policies in these tests already distinguish this content correction from a new boundary selection. No production change or cap increase is justified by empty-warning assertion failures. + +## Required test correction + +Replace emptiness assertions with the entire ordered two-element SourceDiagnostic array, including every owned/scalar field and exact literal locations. Update final retained counts by W above. Keep full expected bundle/model/source preservation assertions unchanged, and preserve the initial9/2 attempt. Do not merely assert warning count/code or use actual validator output to build expected warnings. A helper may construct these two independently authored records from fixed path/span/line arguments. + +The first proposed one-warning correction would still be incomplete: it would omit coverage's second advisory diagnostic and undercount each destination by one entry plus153 rich/150 four-file bytes. This oracle explicitly rejects that alternative before any repair run. diff --git a/harness/experiments/analysis-output-acceptance-20260925/evidence.zip b/harness/experiments/analysis-output-acceptance-20260925/evidence.zip new file mode 100644 index 00000000..700b082e Binary files /dev/null and b/harness/experiments/analysis-output-acceptance-20260925/evidence.zip differ diff --git a/harness/experiments/analysis-output-acceptance-20260925/inspect_runtime.py b/harness/experiments/analysis-output-acceptance-20260925/inspect_runtime.py new file mode 100644 index 00000000..8f33ad71 --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/inspect_runtime.py @@ -0,0 +1,212 @@ +"""Read-only output acceptance gate reconciliation. Run only after the final five gates. + +Usage: python -I -B inspect_runtime.py FULL_SOURCE_SHA PIN7 EXPECTED_NEW_COUNT +Only Git read commands are executed; Cargo, launchers and binaries are never run. +""" +from pathlib import Path +import hashlib +import io +import json +import re +import subprocess +import sys +import zipfile + +if sys.flags.optimize: + raise SystemExit('Optimized Python forbidden: verification uses assertions') +assert len(sys.argv) == 4 +source, stem, expected_added = sys.argv[1], sys.argv[2], int(sys.argv[3]) +assert re.fullmatch(r'[0-9a-f]{40}', source) +assert stem == source[:7] +assert 1 <= expected_added <= 100 +base = Path(__file__).resolve().parents[2] +root = base / '.local/as3batch' +directory = base / '.local/analysis-output-acceptance-gates-20260925' +prior = base / '.local/analysis-entry-producer-gates-20260925' +destination = Path(__file__).with_name('ACCEPTANCE-RUNTIME-READBACK.json') +assert not destination.exists(), 'Preserve prior readback; do not overwrite' +BASELINE = '29417130c71f70c4eaefe8ed4c879efba78eb72c' +ARCHIVE_SHA = '19a87583a8dc4c22f35999044de5cac2c2c97b04fb457d2c3df3f6d2c054c865' +sha = lambda raw: hashlib.sha256(raw).hexdigest() + + +def git(*args): + return subprocess.check_output(['git', '--no-replace-objects', *args], cwd=root) + + +def within(folder, relative): + candidate = (folder / relative).resolve() + assert candidate.is_relative_to(folder.resolve()), relative + return candidate + + +def receipt(folder, name): + raw_receipt = (folder / (name + '.result.json')).read_bytes() + data = json.loads(raw_receipt) + raw = (folder / (name + '.log')).read_bytes() + assert data['log_sha256'] == sha(raw) + return data, raw, raw_receipt + + +def outcomes(raw): + rows = re.findall(r'^test ([^\r\n]+) \.\.\. (ok|FAILED|ignored)\r?$', raw.decode(), re.M) + assert len(rows) == len(dict(rows)), 'Duplicate runtime name' + return rows + + +def members(raw): + names = re.findall(r'^([^\r\n]+): test\r?$', raw.decode(), re.M) + assert len(names) == len(set(names)), 'Duplicate listing name' + return names + + +def failure_blocks(raw): + # Preserve every byte of block whitespace/body except the numeric thread PID. + rows = re.findall(rb'^---- ([^\r\n]+) stdout ----\r?\n(.*?)(?=^---- |^failures:|\Z)', + raw, re.M | re.S) + assert len(rows) == len(dict(rows)), 'Duplicate failure block' + return {name.decode(): re.sub(rb"(?m)^(thread '[^\r\n]*') \(\d+\) panicked", + rb'\1 () panicked', body) for name, body in rows} + + +# Anchor baseline local full/list/fmt logs AND receipts to the immutable locally committed ZIP (server publication is blocked). +archive_raw = (base / 'harness/experiments/analysis-entry-producer-20260925/evidence.zip').read_bytes() +assert sha(archive_raw) == ARCHIVE_SHA +baseline = {} +with zipfile.ZipFile(io.BytesIO(archive_raw)) as archive: + names = archive.namelist() + assert len(names) == len(set(names)) + for mode in ('full', 'list', 'fmt'): + name = f'entry-{mode}-2941713-1' + data, raw, raw_receipt = receipt(prior, name) + assert data['source'] == data['head_after'] == BASELINE + for suffix, content in [('.log', raw), ('.result.json', raw_receipt)]: + matches = [n for n in names if n == name + suffix or n.endswith('/' + name + suffix)] + assert len(matches) == 1, (name, suffix, matches) + assert archive.read(matches[0]) == content + baseline[mode] = (data, raw) +old, old_raw = baseline['full'] +old_rows = outcomes(old_raw) +assert old_rows == [tuple(x) for x in old['outcomes']] +assert len(old_rows) == 281 and old['exit'] == 101 +assert sum(v == 'ok' for _, v in old_rows) == 265 +assert sum(v == 'FAILED' for _, v in old_rows) == 16 +old_out = dict(old_rows) +old_listing = members(baseline['list'][1]) +assert old_listing == baseline['list'][0]['listing_members'] +assert baseline['list'][0]['exit'] == 0 and set(old_listing) == set(old_out) +assert baseline['fmt'][0]['exit'] == 1 + +assert git('rev-parse', 'HEAD').decode().strip() == source +assert not git('status', '--porcelain', '--untracked-files=no').strip() +scope = ['Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', '.cargo', 'build', 'crates', + 'assets', 'docs', 'examples', 'harness/fixtures', 'vendor'] +paths = git('ls-tree', '-r', '--name-only', source, *scope).decode().splitlines() +blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root, + input=''.join(f'{source}:{p}\n' for p in paths).encode()) +offset, expected_inputs = 0, [] +for path in paths: + end = blobs.index(b'\n', offset) + _, kind, count = blobs[offset:end].split() + count = int(count) + raw = blobs[end + 1:end + 1 + count] + assert kind == b'blob' and within(root, path).read_bytes() == raw, path + expected_inputs.append({'path': path, 'bytes': count, 'sha256': sha(raw)}) + offset = end + count + 2 +assert offset == len(blobs) + +prefix = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--lib'] +commands = { + 'focused': prefix + ['acceptance', '--', '--test-threads=1'], + 'full': prefix + ['--', '--test-threads=1'], + 'list': prefix + ['--', '--list'], + 'clippy': ['cargo', 'clippy', '--locked', '--offline', '-p', 'oa-core', '--all-targets', '--', '-D', 'warnings'], + 'fmt': ['cargo', 'fmt', '--all', '--', '--check'], +} +expected_env = baseline['full'][0]['environment'] +assert expected_env['CARGO_BUILD_JOBS'] == '1' and expected_env['CARGO_INCREMENTAL'] == '0' +for key in ('RUSTFLAGS', 'RUSTC', 'RUSTUP_TOOLCHAIN', 'ARCADIA_CODEC_LIFECYCLE_PHASE', 'RUST_MIN_STACK'): + assert expected_env[key] is None +# Explicitly selected single spelling delta; all other environment bytes remain exact. +old_target = 'C:/Users/User/Documents/Git/ARCADIA-Studio/.local/analysis-checked-save-target-20260913' +new_target = r'C:\Users\User\Documents\Git\ARCADIA-Studio\.local\analysis-checked-save-target-20260913' +assert expected_env['CARGO_TARGET_DIR'] == old_target +assert Path(old_target).resolve() == Path(new_target).resolve() == (base / '.local/analysis-checked-save-target-20260913').resolve() +current_env = dict(expected_env, CARGO_TARGET_DIR=new_target) +verified, all_receipts, raw_logs = {}, {}, {} +artifact_identity = launcher_identity = None +for mode, command in commands.items(): + name = f'acceptance-{mode}-{stem}-1' + data, raw, receipt_raw = receipt(directory, name) + assert data['source'] == data['head_after'] == source + assert data['mode'] == mode and data['command'] == command + assert data['invocation'] == 'cargo' and data['test_target'] is None + assert data['filter'] == ('acceptance' if mode == 'focused' else '') + assert not data['changed_inputs'] and not data['verification_failures'] + assert data['cwd'] == str(root) and data['environment'] == current_env + manifest_raw = within(directory, data['inputs']).read_bytes() + assert sha(manifest_raw) == data['inputs_sha256'] + assert json.loads(manifest_raw) == {'source': source, 'inputs': expected_inputs} + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] + assert source.encode() in launcher + if launcher_identity is None: + launcher_identity = sha(launcher) + assert sha(launcher) == launcher_identity, 'Unexpected mixed launchers: review explicitly' + rows = outcomes(raw) + assert rows == [tuple(x) for x in data['outcomes']] + listing = members(raw) if mode == 'list' else [] + assert listing == data['listing_members'] and len(listing) == data['listing_count'] + if mode in ('focused', 'full'): + counts = tuple(sum(v == state for _, v in rows) for state in ('ok', 'FAILED', 'ignored')) + summary = re.findall(r'^test result: (ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) + assert len(summary) == 1 and tuple(map(int, summary[0][1:4])) == counts + assert summary[0][0] == ('FAILED' if counts[1] else 'ok') + assert int(summary[0][4]) == (281 if mode == 'focused' else 0) + else: + assert not rows + assert data['exit'] == {'focused': 0, 'full': 101, 'list': 0, 'clippy': 0, 'fmt': 1}[mode] + assert len(data['artifacts']) == (1 if mode in ('focused', 'full', 'list') else 0) + for artifact in data['artifacts']: + path = Path(artifact['path']) + assert path.resolve().is_relative_to(Path(expected_env['CARGO_TARGET_DIR']).resolve()) + actual = path.read_bytes() + assert len(actual) == artifact['bytes'] and sha(actual) == artifact['sha256'] + assert str(path).replace('\\', '/') in raw.decode().replace('\\', '/') + if artifact_identity is None: + artifact_identity = artifact + assert artifact == artifact_identity, 'Test/list artifact mismatch' + all_receipts[mode], raw_logs[mode] = data, raw + verified[name] = {'source': source, 'exit': data['exit'], 'outcomes': len(rows), + 'listing': len(listing), 'log_sha256': sha(raw), 'result_sha256': sha(receipt_raw), + 'inputs_sha256': sha(manifest_raw), 'launcher_sha256': sha(launcher)} + +new_out = dict(all_receipts['full']['outcomes']) +assert len(new_out) == 281 + expected_added +assert all(new_out.get(k) == v for k, v in old_out.items()) +added = set(new_out) - set(old_out) +assert len(added) == expected_added +assert all(new_out[k] == 'ok' and 'acceptance' in k for k in added) +assert set(dict(all_receipts['focused']['outcomes'])) == added +assert all(status == 'ok' for _, status in all_receipts['focused']['outcomes']) +assert set(all_receipts['list']['listing_members']) == set(new_out) +old_blocks, new_blocks = failure_blocks(old_raw), failure_blocks(raw_logs['full']) +assert len(old_blocks) == len(new_blocks) == 16 +assert set(old_blocks) == {k for k, v in old_out.items() if v == 'FAILED'} +assert old_blocks == new_blocks, 'Failure bodies differ beyond thread PID' +assert raw_logs['fmt'] == baseline['fmt'][1] + +result = {'source': source, 'baseline': BASELINE, 'baseline_archive_sha256': ARCHIVE_SHA, + 'checker_sha256': sha(Path(__file__).read_bytes()), 'inputs': len(expected_inputs), + 'unchanged_old_outcomes': 281, 'added_passed': expected_added, 'added_names': sorted(added), + 'full_passed': sum(v == 'ok' for v in new_out.values()), 'full_failed': 16, + 'identical_failure_blocks_after_pid_only_normalization': 16, + 'identical_fmt_sha256': sha(raw_logs['fmt']), 'artifact': artifact_identity, + 'environment': current_env, 'baseline_environment': expected_env, + 'environment_exception': {'field': 'CARGO_TARGET_DIR', 'old_raw': old_target, 'new_raw': new_target, + 'verified_absolute_target': str(Path(new_target).resolve()), + 'scope': 'Only this exact slash spelling pair; every other environment field exact'}, 'receipts': verified, + 'scope': 'Committed declared inputs, pinned baseline archive, raw logs and current artifact bytes; no Cargo/executable execution. Launcher semantics require independent source review.'} +with destination.open('x', encoding='utf-8', newline='\n') as stream: + stream.write(json.dumps(result, indent=2) + '\n') +print(json.dumps(result, indent=2)) diff --git a/harness/experiments/analysis-output-acceptance-20260925/inspect_runtime_strict_original.py b/harness/experiments/analysis-output-acceptance-20260925/inspect_runtime_strict_original.py new file mode 100644 index 00000000..b8993ca7 --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/inspect_runtime_strict_original.py @@ -0,0 +1,203 @@ +"""Read-only output acceptance gate reconciliation. Run only after the final five gates. + +Usage: python -I -B inspect_runtime.py FULL_SOURCE_SHA PIN7 EXPECTED_NEW_COUNT +Only Git read commands are executed; Cargo, launchers and binaries are never run. +""" +from pathlib import Path +import hashlib +import io +import json +import re +import subprocess +import sys +import zipfile + +if sys.flags.optimize: + raise SystemExit('Optimized Python forbidden: verification uses assertions') +assert len(sys.argv) == 4 +source, stem, expected_added = sys.argv[1], sys.argv[2], int(sys.argv[3]) +assert re.fullmatch(r'[0-9a-f]{40}', source) +assert stem == source[:7] +assert 1 <= expected_added <= 100 +base = Path(__file__).resolve().parents[2] +root = base / '.local/as3batch' +directory = base / '.local/analysis-output-acceptance-gates-20260925' +prior = base / '.local/analysis-entry-producer-gates-20260925' +destination = Path(__file__).with_name('ACCEPTANCE-RUNTIME-READBACK.json') +assert not destination.exists(), 'Preserve prior readback; do not overwrite' +BASELINE = '29417130c71f70c4eaefe8ed4c879efba78eb72c' +ARCHIVE_SHA = '19a87583a8dc4c22f35999044de5cac2c2c97b04fb457d2c3df3f6d2c054c865' +sha = lambda raw: hashlib.sha256(raw).hexdigest() + + +def git(*args): + return subprocess.check_output(['git', '--no-replace-objects', *args], cwd=root) + + +def within(folder, relative): + candidate = (folder / relative).resolve() + assert candidate.is_relative_to(folder.resolve()), relative + return candidate + + +def receipt(folder, name): + raw_receipt = (folder / (name + '.result.json')).read_bytes() + data = json.loads(raw_receipt) + raw = (folder / (name + '.log')).read_bytes() + assert data['log_sha256'] == sha(raw) + return data, raw, raw_receipt + + +def outcomes(raw): + rows = re.findall(r'^test ([^\r\n]+) \.\.\. (ok|FAILED|ignored)\r?$', raw.decode(), re.M) + assert len(rows) == len(dict(rows)), 'Duplicate runtime name' + return rows + + +def members(raw): + names = re.findall(r'^([^\r\n]+): test\r?$', raw.decode(), re.M) + assert len(names) == len(set(names)), 'Duplicate listing name' + return names + + +def failure_blocks(raw): + # Preserve every byte of block whitespace/body except the numeric thread PID. + rows = re.findall(rb'^---- ([^\r\n]+) stdout ----\r?\n(.*?)(?=^---- |^failures:|\Z)', + raw, re.M | re.S) + assert len(rows) == len(dict(rows)), 'Duplicate failure block' + return {name.decode(): re.sub(rb"(?m)^(thread '[^\r\n]*') \(\d+\) panicked", + rb'\1 () panicked', body) for name, body in rows} + + +# Anchor baseline local full/list/fmt logs AND receipts to the immutable locally committed ZIP (server publication is blocked). +archive_raw = (base / 'harness/experiments/analysis-entry-producer-20260925/evidence.zip').read_bytes() +assert sha(archive_raw) == ARCHIVE_SHA +baseline = {} +with zipfile.ZipFile(io.BytesIO(archive_raw)) as archive: + names = archive.namelist() + assert len(names) == len(set(names)) + for mode in ('full', 'list', 'fmt'): + name = f'entry-{mode}-2941713-1' + data, raw, raw_receipt = receipt(prior, name) + assert data['source'] == data['head_after'] == BASELINE + for suffix, content in [('.log', raw), ('.result.json', raw_receipt)]: + matches = [n for n in names if n == name + suffix or n.endswith('/' + name + suffix)] + assert len(matches) == 1, (name, suffix, matches) + assert archive.read(matches[0]) == content + baseline[mode] = (data, raw) +old, old_raw = baseline['full'] +old_rows = outcomes(old_raw) +assert old_rows == [tuple(x) for x in old['outcomes']] +assert len(old_rows) == 281 and old['exit'] == 101 +assert sum(v == 'ok' for _, v in old_rows) == 265 +assert sum(v == 'FAILED' for _, v in old_rows) == 16 +old_out = dict(old_rows) +old_listing = members(baseline['list'][1]) +assert old_listing == baseline['list'][0]['listing_members'] +assert baseline['list'][0]['exit'] == 0 and set(old_listing) == set(old_out) +assert baseline['fmt'][0]['exit'] == 1 + +assert git('rev-parse', 'HEAD').decode().strip() == source +assert not git('status', '--porcelain', '--untracked-files=no').strip() +scope = ['Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', '.cargo', 'build', 'crates', + 'assets', 'docs', 'examples', 'harness/fixtures', 'vendor'] +paths = git('ls-tree', '-r', '--name-only', source, *scope).decode().splitlines() +blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root, + input=''.join(f'{source}:{p}\n' for p in paths).encode()) +offset, expected_inputs = 0, [] +for path in paths: + end = blobs.index(b'\n', offset) + _, kind, count = blobs[offset:end].split() + count = int(count) + raw = blobs[end + 1:end + 1 + count] + assert kind == b'blob' and within(root, path).read_bytes() == raw, path + expected_inputs.append({'path': path, 'bytes': count, 'sha256': sha(raw)}) + offset = end + count + 2 +assert offset == len(blobs) + +prefix = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--lib'] +commands = { + 'focused': prefix + ['acceptance', '--', '--test-threads=1'], + 'full': prefix + ['--', '--test-threads=1'], + 'list': prefix + ['--', '--list'], + 'clippy': ['cargo', 'clippy', '--locked', '--offline', '-p', 'oa-core', '--all-targets', '--', '-D', 'warnings'], + 'fmt': ['cargo', 'fmt', '--all', '--', '--check'], +} +expected_env = baseline['full'][0]['environment'] +assert expected_env['CARGO_BUILD_JOBS'] == '1' and expected_env['CARGO_INCREMENTAL'] == '0' +for key in ('RUSTFLAGS', 'RUSTC', 'RUSTUP_TOOLCHAIN', 'ARCADIA_CODEC_LIFECYCLE_PHASE', 'RUST_MIN_STACK'): + assert expected_env[key] is None +verified, all_receipts, raw_logs = {}, {}, {} +artifact_identity = launcher_identity = None +for mode, command in commands.items(): + name = f'acceptance-{mode}-{stem}-1' + data, raw, receipt_raw = receipt(directory, name) + assert data['source'] == data['head_after'] == source + assert data['mode'] == mode and data['command'] == command + assert data['invocation'] == 'cargo' and data['test_target'] is None + assert data['filter'] == ('acceptance' if mode == 'focused' else '') + assert not data['changed_inputs'] and not data['verification_failures'] + assert data['cwd'] == str(root) and data['environment'] == expected_env + manifest_raw = within(directory, data['inputs']).read_bytes() + assert sha(manifest_raw) == data['inputs_sha256'] + assert json.loads(manifest_raw) == {'source': source, 'inputs': expected_inputs} + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] + assert source.encode() in launcher + if launcher_identity is None: + launcher_identity = sha(launcher) + assert sha(launcher) == launcher_identity, 'Unexpected mixed launchers: review explicitly' + rows = outcomes(raw) + assert rows == [tuple(x) for x in data['outcomes']] + listing = members(raw) if mode == 'list' else [] + assert listing == data['listing_members'] and len(listing) == data['listing_count'] + if mode in ('focused', 'full'): + counts = tuple(sum(v == state for _, v in rows) for state in ('ok', 'FAILED', 'ignored')) + summary = re.findall(r'^test result: (ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) + assert len(summary) == 1 and tuple(map(int, summary[0][1:4])) == counts + assert summary[0][0] == ('FAILED' if counts[1] else 'ok') + assert int(summary[0][4]) == (281 if mode == 'focused' else 0) + else: + assert not rows + assert data['exit'] == {'focused': 0, 'full': 101, 'list': 0, 'clippy': 0, 'fmt': 1}[mode] + assert len(data['artifacts']) == (1 if mode in ('focused', 'full', 'list') else 0) + for artifact in data['artifacts']: + path = Path(artifact['path']) + assert path.resolve().is_relative_to(Path(expected_env['CARGO_TARGET_DIR']).resolve()) + actual = path.read_bytes() + assert len(actual) == artifact['bytes'] and sha(actual) == artifact['sha256'] + assert str(path).replace('\\', '/') in raw.decode().replace('\\', '/') + if artifact_identity is None: + artifact_identity = artifact + assert artifact == artifact_identity, 'Test/list artifact mismatch' + all_receipts[mode], raw_logs[mode] = data, raw + verified[name] = {'source': source, 'exit': data['exit'], 'outcomes': len(rows), + 'listing': len(listing), 'log_sha256': sha(raw), 'result_sha256': sha(receipt_raw), + 'inputs_sha256': sha(manifest_raw), 'launcher_sha256': sha(launcher)} + +new_out = dict(all_receipts['full']['outcomes']) +assert len(new_out) == 281 + expected_added +assert all(new_out.get(k) == v for k, v in old_out.items()) +added = set(new_out) - set(old_out) +assert len(added) == expected_added +assert all(new_out[k] == 'ok' and 'acceptance' in k for k in added) +assert set(dict(all_receipts['focused']['outcomes'])) == added +assert all(status == 'ok' for _, status in all_receipts['focused']['outcomes']) +assert set(all_receipts['list']['listing_members']) == set(new_out) +old_blocks, new_blocks = failure_blocks(old_raw), failure_blocks(raw_logs['full']) +assert len(old_blocks) == len(new_blocks) == 16 +assert set(old_blocks) == {k for k, v in old_out.items() if v == 'FAILED'} +assert old_blocks == new_blocks, 'Failure bodies differ beyond thread PID' +assert raw_logs['fmt'] == baseline['fmt'][1] + +result = {'source': source, 'baseline': BASELINE, 'baseline_archive_sha256': ARCHIVE_SHA, + 'checker_sha256': sha(Path(__file__).read_bytes()), 'inputs': len(expected_inputs), + 'unchanged_old_outcomes': 281, 'added_passed': expected_added, 'added_names': sorted(added), + 'full_passed': sum(v == 'ok' for v in new_out.values()), 'full_failed': 16, + 'identical_failure_blocks_after_pid_only_normalization': 16, + 'identical_fmt_sha256': sha(raw_logs['fmt']), 'artifact': artifact_identity, + 'environment': expected_env, 'receipts': verified, + 'scope': 'Committed declared inputs, pinned baseline archive, raw logs and current artifact bytes; no Cargo/executable execution. Launcher semantics require independent source review.'} +with destination.open('x', encoding='utf-8', newline='\n') as stream: + stream.write(json.dumps(result, indent=2) + '\n') +print(json.dumps(result, indent=2)) diff --git a/harness/experiments/analysis-output-acceptance-20260925/manifest.json b/harness/experiments/analysis-output-acceptance-20260925/manifest.json new file mode 100644 index 00000000..fb5a71ba --- /dev/null +++ b/harness/experiments/analysis-output-acceptance-20260925/manifest.json @@ -0,0 +1,279 @@ +{ + "source": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "scope": "Private actual emitted-output acceptance; no public source8 activation, adoption/history integration or universal parser allocation guarantee. Full library and formatter retain documented baseline failures.", + "archive": { + "file": "evidence.zip", + "bytes": 529018, + "sha256": "2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4" + }, + "members": { + "baseline/entry-fmt-2941713-1.inputs.json": { + "bytes": 104264, + "sha256": "3453c4b85aa27e79fa602e491e333ddeb42914228bb6e3dda8efbabbbe14f02c" + }, + "baseline/entry-fmt-2941713-1.log": { + "bytes": 6446, + "sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d" + }, + "baseline/entry-fmt-2941713-1.result.json": { + "bytes": 1879, + "sha256": "a7f1c7ec70ec4a6872dc8a387d1a8c5b3b424f125d21a59a6320b3c2ac17c772" + }, + "baseline/entry-full-2941713-1.inputs.json": { + "bytes": 104264, + "sha256": "3453c4b85aa27e79fa602e491e333ddeb42914228bb6e3dda8efbabbbe14f02c" + }, + "baseline/entry-full-2941713-1.log": { + "bytes": 45776, + "sha256": "47fef6f46d136be0e53f48f8ff03a96be73635fc4c3f57350c1e641ad44b01c4" + }, + "baseline/entry-full-2941713-1.result.json": { + "bytes": 41913, + "sha256": "0bbf4cc28d8832e0cdc4e674296db0b71c7da38a0ac1e3c7ecf34e9d19ab6a62" + }, + "baseline/entry-list-2941713-1.inputs.json": { + "bytes": 104264, + "sha256": "3453c4b85aa27e79fa602e491e333ddeb42914228bb6e3dda8efbabbbe14f02c" + }, + "baseline/entry-list-2941713-1.log": { + "bytes": 32280, + "sha256": "4552e8512731a2fb3dbaba02b671c32837018298b5d8b52057af7fa372f2f50e" + }, + "baseline/entry-list-2941713-1.result.json": { + "bytes": 34534, + "sha256": "5374aea8aba0790bcfb6fa4dee179a4c5ddc0df2efd602e876acbc8c84ae59d1" + }, + "baseline/launchers/43a25f27b417cc66f81ec1714c57eb079a9923995bdadbe79440b00836ac73fc.py": { + "bytes": 7668, + "sha256": "43a25f27b417cc66f81ec1714c57eb079a9923995bdadbe79440b00836ac73fc" + }, + "contracts/ACCEPTANCE-ORACLE.md": { + "bytes": 7617, + "sha256": "36b14b538d35d62a03fb569ab74d8d988530da3a850aca22659037a1c317285f" + }, + "contracts/ACCEPTANCE-PROPOSAL.md": { + "bytes": 5514, + "sha256": "b59ca190e3cde85611158542ccf86e67c210b853b09a1fd0354daf57d4304509" + }, + "contracts/ACCEPTANCE-SOURCE-CRITIQUE.md": { + "bytes": 6908, + "sha256": "7704b562f5ef5d2102e5c0595e4c3c66e9905adaf6ffa6258ca90d42c911ffdf" + }, + "contracts/ACCEPTED-CONTENTS-CRITIQUE.md": { + "bytes": 8140, + "sha256": "5342fbff307f57750e443b15d1d9bbf09fa53626abf0456a476ef4da51f68f69" + }, + "contracts/DOMAIN-DECISION-CRITIQUE.md": { + "bytes": 9454, + "sha256": "7f7107d6286232d6cd29305d11661c20a295f0628399af6f95575d3d80fc953d" + }, + "contracts/OWNERSHIP-SOURCE-MAP.md": { + "bytes": 5797, + "sha256": "2644a74230f867edbd472e2fd9dcbe8f66f4c78db97511445ce164bc8e75398c" + }, + "contracts/WARNING-ORACLE.md": { + "bytes": 6382, + "sha256": "883d0278c20c3cfbe5712e604c5559062336b17e315ed9bc95e9169d5ae8f283" + }, + "contracts/analysis-mixed-acceptance-contract-20260925.md": { + "bytes": 9889, + "sha256": "a8b6d7792661b3c71d3340cb3885501af8d1313a5406acaf93abdcef2650f2ec" + }, + "diagnostics/acceptance-focused-4872141-1.acceptance-frames.json": { + "bytes": 304988, + "sha256": "e1f1fceaba2a2f8371777966457dbcbd0e20aaad497fdaa3e0b88adcaeaccdab" + }, + "diagnostics/acceptance-focused-4872141-1.active-frames.json": { + "bytes": 15060, + "sha256": "2563e8b8f0a1aa0957995f2997e9abab2da3894fa2765a4503bd45019be3f2b8" + }, + "diagnostics/acceptance-focused-4872141-1.stack-frames.json": { + "bytes": 13197, + "sha256": "8d8711560725d91d2646b3ccd96188844e46a2b6de74f94ab680a029c60ee072" + }, + "diagnostics/acceptance-focused-edf096c-1.acceptance-frames.json": { + "bytes": 330604, + "sha256": "82dafc72bedd30781e783337d607299467ff8e5df0f52ebb2c7c2f4f9cdf4adb" + }, + "diagnostics/acceptance-focused-edf096c-1.active-frames.json": { + "bytes": 15060, + "sha256": "b0c8ec63791c165e03d8c77a29e07bd7e624848ca83bea05929ef6a1c76196ed" + }, + "diagnostics/acceptance-focused-edf096c-1.stack-frames.json": { + "bytes": 13197, + "sha256": "00bf93f10060160a3adc38109ae512d698a07d8313b02258fc0859d8ec3fb601" + }, + "diagnostics/entry-focused-2941713-1.active-frames.json": { + "bytes": 15060, + "sha256": "920985da2a4d8f15fed04e8c5677d531c479e8679df0b063b2b12b2c1614317a" + }, + "diagnostics/entry-focused-2941713-1.projector-frames.json": { + "bytes": 37226, + "sha256": "6580c158c71539e5a6d7299ea029b1fceb0a4a13e60ebb5dc555b7232d3332ee" + }, + "diagnostics/entry-focused-2941713-1.stack-frames.json": { + "bytes": 13197, + "sha256": "aeb7a50375058828c9e61c12328b2b9ef1714286ec5ea623b6a499d2ec9920ad" + }, + "diagnostics/inspect_acceptance_frames.py": { + "bytes": 2003, + "sha256": "8be157ed62addd99564f07cfc2c119567ee7ab0e76b6f79ee41d70e046d912ec" + }, + "diagnostics/inspect_acceptance_frames_baseline.py": { + "bytes": 2010, + "sha256": "a9958c21193c58241ba4ce573d2eb3ffa54cf32fb05aab35253cc5b9f1388578" + }, + "diagnostics/inspect_projector_frames.py": { + "bytes": 1929, + "sha256": "ae54298c811294bfbf863ed6db54159c4b176b9115534ba057e461e2d70074f0" + }, + "diagnostics/inspect_repaired_active_frames.py": { + "bytes": 2236, + "sha256": "684dfbbebe3cf3d5deeefd7792ef4a3c205c166390c171da48acefc8d1ee9428" + }, + "diagnostics/inspect_stack_frames.py": { + "bytes": 1889, + "sha256": "80372b64f336b73570c1ee790c41646d0d7765e781d3489a4aa682b07515a1a6" + }, + "diagnostics/prior-2941713.acceptance-frames.json": { + "bytes": 4992, + "sha256": "e4e5d4aedc946cf27b5b1c7715f12540998a376642279f7a8042966788cf6c4d" + }, + "diffs/2941713-to-4872141.patch": { + "bytes": 45500, + "sha256": "7970965987a31f88fa2457df56aa4b94e21dcca4f6ac3870811d816eff924536" + }, + "diffs/2941713-to-edf096c.patch": { + "bytes": 48943, + "sha256": "70f66a2eda93e80b9b460e7b50e6b7f1822926ce6280983a28d0e9d49c120730" + }, + "gates/acceptance-clippy-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028" + }, + "gates/acceptance-clippy-edf096c-1.log": { + "bytes": 165, + "sha256": "83248e15864952f5d00a212d9a8ac3e6fc136cec5ff0b927328c20b022c7fff5" + }, + "gates/acceptance-clippy-edf096c-1.result.json": { + "bytes": 1978, + "sha256": "76bf8724819de7d1ffad9ad7033e0230835a321062a60f6129c6413d9644bd14" + }, + "gates/acceptance-fmt-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028" + }, + "gates/acceptance-fmt-edf096c-1.log": { + "bytes": 6446, + "sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d" + }, + "gates/acceptance-fmt-edf096c-1.result.json": { + "bytes": 1892, + "sha256": "de9058d04aadc9734fb465061540600945c4c96b41c7b41a497715de3daac340" + }, + "gates/acceptance-focused-4872141-1.inputs.json": { + "bytes": 104745, + "sha256": "0e2fda8178aae16c917ddcb566dcb99d7c66ab3c89c285facf0638113db21574" + }, + "gates/acceptance-focused-4872141-1.log": { + "bytes": 3893, + "sha256": "b26d046e8b6284b5080ecbd6486c04f5556e1866292d5ac52f27893e69906371" + }, + "gates/acceptance-focused-4872141-1.result.json": { + "bytes": 4382, + "sha256": "ff17f718a831784334443438ff444f6cc441a96ddd896fb1afd8e5602d9ed21a" + }, + "gates/acceptance-focused-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028" + }, + "gates/acceptance-focused-edf096c-1.log": { + "bytes": 2312, + "sha256": "796a8fb992d5b50e2c3df81c8fa3ddd62d459ce88ff8b3939f1913f968a29b28" + }, + "gates/acceptance-focused-edf096c-1.result.json": { + "bytes": 4372, + "sha256": "f9fcb8771f0baf38f0221302e7b112a915054da31cdaf466ede46c91f46185d2" + }, + "gates/acceptance-full-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028" + }, + "gates/acceptance-full-edf096c-1.log": { + "bytes": 47640, + "sha256": "5df6602c3d62c776720aa97916f0bf740de5488773d25601600aea8de27515e2" + }, + "gates/acceptance-full-edf096c-1.result.json": { + "bytes": 44019, + "sha256": "abf9e8ab5befe76f9be41d126a6015a9754bd9d13716ffedb3699b7f8a8b294b" + }, + "gates/acceptance-list-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028" + }, + "gates/acceptance-list-edf096c-1.log": { + "bytes": 34079, + "sha256": "9ac3a152c7c2a98a161875b8088372d836162a7520f46d8a6a96f984d75207d7" + }, + "gates/acceptance-list-edf096c-1.result.json": { + "bytes": 36356, + "sha256": "717927d836c541f0855038ad3f4acd456fa00012784c006e2c012dc9a8524534" + }, + "gates/launchers/0bd16293306c08011be30908d8bc92004cc24fd37d638d7ecac6e31daa176dbe.py": { + "bytes": 7681, + "sha256": "0bd16293306c08011be30908d8bc92004cc24fd37d638d7ecac6e31daa176dbe" + }, + "gates/launchers/a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce.py": { + "bytes": 7681, + "sha256": "a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce" + }, + "launchers/package_evidence.py": { + "bytes": 4945, + "sha256": "ea10ce44cb53dc5bc1047040691ce025a8fd740c0ea6548d635b10a03638d2de" + }, + "notes/prior-toolchain.txt": { + "bytes": 536, + "sha256": "1f101518dd1f90bc2cba8d26570a762832aba6debebbbe6aa50f97a944590610" + }, + "reviews/ACCEPTANCE-RUNTIME-READBACK.json": { + "bytes": 7098, + "sha256": "88cb21bc89a1337b32f74ec2fe8adc6dc2835ccea17bb313b5a7e2433fce4fd2" + }, + "reviews/CHECKER-NOTE.md": { + "bytes": 1795, + "sha256": "82d50c9bafdc8a15c043b7fa283705586dc544816850b46fa6aab65a510ad816" + }, + "reviews/RUNTIME-REVIEW.md": { + "bytes": 6503, + "sha256": "a54e7577c425261e867c1d946fd81bde80fc57c5fb82d800c998d4e4887d5156" + }, + "reviews/SOURCE-REVIEW.md": { + "bytes": 8581, + "sha256": "35074c4af86ec7abba3b087056ff571739cf9207523dc2fcbc6c98f1228435c8" + }, + "reviews/STACK-OBSERVATIONS.md": { + "bytes": 9702, + "sha256": "b73f9fecb216f5cb8fb75c7de3f4de868277000c8e74db22c68a4e192e78c61b" + }, + "reviews/TEST-CHECKLIST.md": { + "bytes": 7990, + "sha256": "3a8a33b92a9e29b894eaf0b39de83d80c92498ef90f72aa1e33adeff7d733530" + }, + "reviews/TEST-REVIEW.md": { + "bytes": 9291, + "sha256": "b5a883ec8edfb85f4623bcae4650296748d79543174c40b75306e0b0e2a12e98" + }, + "reviews/WARNING-FIX-ORACLE.md": { + "bytes": 4984, + "sha256": "7311c6597a643506d3bd5ec5fa66b251e6fd2cc9aade7497fba6b03ad55f665d" + }, + "reviews/inspect_runtime.py": { + "bytes": 11280, + "sha256": "8fdf8c0ba848d8f61cb09739961239c316fdb0eb17e4b64b88ae34274cce0f53" + }, + "reviews/inspect_runtime_strict_original.py": { + "bytes": 10433, + "sha256": "5ea98b7c5f46c09f434c040f37495f43536fd79fb6b61c8ba111dd5716936c8e" + } + } +}