diff --git a/harness/DECISIONS.md b/harness/DECISIONS.md index 8a3a8bb2..d0c7d1d7 100644 --- a/harness/DECISIONS.md +++ b/harness/DECISIONS.md @@ -733,3 +733,27 @@ behavior. Preserve the initial two incorrect empty-warning expectations and thei 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. + +## 2026-09-25 — restore ordinary schema8 compatibility before mixed adoption + +Current formatters already emit schema8, while the ordinary reader previously +rejected it. Admit that version through the existing ordinary grammar and model +validation, preserving migration, complete source indexes, identity stabilization, +updates and checked saves. Keep typed and long analysis-constructor refusals; +ordinary acceptance does not qualify missing typed formatting or mixed editing. +The [contract and independent comparison](ordinary-source8-compatibility-contract-20260925.md) +reject replacing compile_bundle with an incomplete read-only index. + +[Windows evidence](experiments/ordinary-source8-20260925/README.md) exercises the +previously blocked nested/transaction workflows, complete ordinary OA/SA and +historical trace round trips, relevant integration tests and actual read-only CLI +commands. Preserve the initial example-trace assumption failure, four obsolete +private header-rejection assertions and the historical JSON oracle's missing +empty definitions catalog. Correct their expectations explicitly while retaining +whole-model and typed-refusal checks; two test renames have exact inventory maps. + +Reuse the source-identical core, other integration and CLI evidence after the last +three-line migration-test correction. Verify the entire successor diff and every +other declared input, rerun the affected target plus all-target Clippy/format, and +identify each tested code version. No Linux, GUI or release qualification follows +from these core/CLI results. Publication remains blocked by server disk exhaustion. diff --git a/harness/STATE.md b/harness/STATE.md index 892a5972..ea2b78df 100644 --- a/harness/STATE.md +++ b/harness/STATE.md @@ -57,7 +57,27 @@ 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 and output acceptance checkpoints — 2026-09-25 +## Local ordinary source8 compatibility — 2026-09-25 + +Source **7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd** on +`codex/ordinary-source8-956atf-20260925` restores public ordinary parsing of the +schema8 files already emitted by current formatters. Versions3–7 still migrate; +typed analysis declarations remain explicitly unsupported by ordinary APIs. +The [contract](ordinary-source8-compatibility-contract-20260925.md) and +[Windows evidence](experiments/ordinary-source8-20260925/README.md) distinguish +this compatibility repair from full mixed-source editing. + +The unchanged implementation at **0c07f53ab517626f536f79dbaa2885a587bf1db7** +passes all298 core tests, including the16 formerly header-blocked workflows, +and60 selected integration tests. Actual CLI check and cross-file rename preview +pass with exact reported changes and unchanged input files. The successor only +repairs a historical JSON expectation and its note; its five migration tests and +strict core all-target Clippy pass. Format retains identical pre-existing +differences. Evidence preserves all three failed evaluator stages, two explicit +test-name mappings and exact component-version reuse. These commits are local-only +under the Gitea server-storage publication blocker; the published preview is unchanged. + +## Earlier private parser and output acceptance checkpoints — 2026-09-25 Source **edf096cd33350865ecfc3c65ec266a6c0d3c4000** on `codex/analysis-mixed-acceptance-956atf-20260925` connects real emitted output to @@ -70,9 +90,10 @@ 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. +typed source8, installation/history and repeated carried editing remain incomplete. +Ordinary source8 compatibility is supplied by the later checkpoint above. -The subsequent **29417130c71f70c4eaefe8ed4c879efba78eb72c** on +The earlier **29417130c71f70c4eaefe8ed4c879efba78eb72c** on `codex/analysis-entry-producers-956atf-20260925` adds the reviewed [retained-entry producer route](analysis-entry-producer-contract-20260925.md). Its [Windows evidence](experiments/analysis-entry-producer-20260925/README.md) diff --git a/harness/experiments/ordinary-source8-20260925/.gitattributes b/harness/experiments/ordinary-source8-20260925/.gitattributes new file mode 100644 index 00000000..965ca633 --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/.gitattributes @@ -0,0 +1,5 @@ +*.md -text +*.py -text +*.txt -text +*.log -text +*.json -text diff --git a/harness/experiments/ordinary-source8-20260925/CHECKER-NOTE.md b/harness/experiments/ordinary-source8-20260925/CHECKER-NOTE.md new file mode 100644 index 00000000..a4a74463 --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/CHECKER-NOTE.md @@ -0,0 +1,13 @@ +# Checker encoding correction + +The first actual data-only checker run refused at `inspect_runtime.py:354`, `assert (fixture / name).read_bytes() == text.encode()`. Exit1; no successful readback JSON was written. The unchanged CLI project fixture was149bytes, whereas the executed checker incorrectly expected153bytes. Participants106bytes and children85bytes matched. + +`checker-first-refusal.log` preserves the actual traceback text returned by exec for that run (transcribed from the tool result, not a separately redirected raw stderr file and not a replay). The preserved original checker was actually executed and refused; it is not an unrun predecessor. + +This was an evaluator authoring defect: a Windows default-encoding `read_text()` source rewrite turned the intended literal `雨` into mojibake. Actual fixture bytes were UTF-8 `e9 9b a8`; the executed checker literal contained `c3 a9 e2 80 ba c2 a8` (`雨`). Python reads its source as UTF-8, and parsing the preserved raw checker bytes confirms153bytes. The actual CLI fixture and captured original/after inventories remained correct. No product/source/fixture or runtime receipt changed. + +Independent packet audit corrected an error in the first version of this note: it had claimed161bytes and a second encoding expansion. That result came from the author's secondary diagnostic probe, which called `ast.parse(p.read_text())` using Windows default encoding on the already corrupt UTF-8 checker file. Repeating that exact data-only probe yields161bytes and prefix `c3 83 c2 a9 c3 a2 e2 82 ac c2 ba c3 82 c2 a8`; it is not what Python executed. Parsing `raw.decode('utf-8')` instead yields the correct153-byte account above. The first packet candidate is preserved locally; its note is superseded by this explicit correction. Original failed checker, refusal transcript, corrected checker, successful readback and application evidence are unchanged. + +Preserved failed checker bytes as `inspect_runtime_encoding_original.py`, SHA256 `b544cdb20dc8f5cf1b5d29c5ab78791dd3ac6701a4c1f7f7229f0d73dac7b81e`. The only correction replaced that project-comment literal with Python's explicit `\u96e8` escape using an explicit UTF-8 read/write. Corrected checker SHA256 `db853cc7677421e1abc13e59ca7d181fdcf7bcb45033164e51e09f13ca51c172` then exited0 and produced `ORDINARY-RUNTIME-READBACK.json`, SHA256 `3ee36b331431736062db7ea9fa94876795f61711d44820f5b5093e97cc515db5`. + +No comparisons were removed or normalized; complete expected UTF-8 bytes still must match. Only Git and data reads ran, never Cargo or product executables. diff --git a/harness/experiments/ordinary-source8-20260925/LAUNCHER-REVIEW.md b/harness/experiments/ordinary-source8-20260925/LAUNCHER-REVIEW.md new file mode 100644 index 00000000..e60ba6c6 --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/LAUNCHER-REVIEW.md @@ -0,0 +1,34 @@ +# Ordinary source8 launchers: pre-execution review + +Read-only review; no launcher, compiler or application executed. Reviewed gate recorder SHA256 `6e56f7429b6ac376f4ef83e724398a00000d092d7c72a6748f328f3845e7ad6e` and CLI recorder SHA256 `3013da90a1d9c958c8c025718d7dfc4a8de358be74f10329dd78b4de245adf8e`. Paths are `.local/run-ordinary-source8-{gate,cli}-20260925.py`. Gate source is deliberately pending and cannot yet authorize a run. + +## Finding requiring correction + +CLI recorder verifies selected build receipt fields and actual binary size/hash, but does not verify that receipt's raw input manifest/log hashes or recheck current declared input bytes. Tracked-clean Git status alone does not establish raw equality because Git can normalize line endings. Recheck the bound manifest and each declared raw input before and after the CLI commands; verify build log hash and carry the build receipt/manifest identity into the CLI receipt. Record relevant runtime environment and enforce absent `ARCADIA_CODEC_LIFECYCLE_PHASE` and `RUST_MIN_STACK`, consistent with the gate recorder. This is a provenance gap, not evidence that the current binary or source differs. Sent directly to parent before execution. + +## Checked semantics + +- Gate integration mapping matches the seven selected targets/filters in VERIFICATION-PLAN. The source7 single test is exact; checked-save selects its three-name prefix. Listing must be nonzero/unique; suite outcomes must exactly match same-source listing, identical input-manifest hash and identical actual executable record. Every selected integration outcome must pass, with one complete all-pass summary. Failed compiler/test process exit remains failure even if a partial transcript looks successful. +- Source inputs are compared byte-for-byte against immutable Git blobs before Cargo, then hashed afterward. Source/head and launcher changes produce nonzero exit. Artifact bytes come from actual Cargo `Running` paths, not a guessed filename. CLI build uses actual Cargo JSON `compiler-artifact`, selects target `arcadia` and requires exactly one executable under the configured target directory. Review the raw target metadata during final readback; this is not a blanket workspace-artifact claim. +- CLI commands match actual `arguments()` and `main.rs`: `check ENTRY --json` and `rename-alias ENTRY team rescue_team --json`. Neither selects `--write`; main returns `Prepared::into_report()`. Process exit and empty stderr are checked separately from report exit. +- The three complete CRLF/Unicode/explicit-ID input literals match the independent plan. Report common fields, exact two ordered changed paths, complete before/after texts, zero stabilization and no migration are checked. Declaration and reference edits preserve quoted/comment `@team`. Diff checks only require the expected changed lines; that is intentionally weaker than a complete diff oracle, while complete candidate-file equality is decisive. `unified_diff()` prefixes the original CRLF lines, so substring checks against Python splitlines' content are valid. +- Each operation checks full original bytes, file hash inventory and complete directory-entry inventory after execution. Captures reside outside the fixture. No reported change to entry is allowed. Final executable and launcher hashes/head are also checked. New fixture and capture paths refuse overwrite. +- Whole Project equality is explicitly delegated to the separate public-API fixture test; JSON contains no Project. This separation is honest and must remain in final evidence. + +Malformed JSON shape or timeout can terminate this simple recorder before producing a normal receipt; such a termination is failure/incomplete evidence, never a pass. The gate recorder's ordinary list/focused/full modes record rather than reconcile their expected counts; final readback must still perform prior-name/outcome and exact-filter reconciliation. It records incremental/environment values but does not itself enforce all of them; parent must use and verify the established gate environment. + +Disposition: command/report/inventory semantics are suitable; complete the narrow CLI provenance correction and pin the reviewed candidate before execution. No runtime acceptance, platform expansion or publication is established by this review. + +## Corrected recorder readback + +Read the revised CLI recorder in full, SHA256 `308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d`. Gate recorder remains exactly `6e56f7429b6ac376f4ef83e724398a00000d092d7c72a6748f328f3845e7ad6e`, still pending source pin. The concrete provenance finding is resolved: build manifest/log hashes and manifest source are verified; each declared path must resolve within source root and match exact size/hash before both operations and after each; runtime environment equals the build record with stack/lifecycle overrides expressly absent; binary hashes are rechecked around each invocation; receipts include environment, manifest pin and changed-input list. Missing input files and nonobject JSON reports/change rows now produce refusal rather than accidental success. Existing byte/report expectations are unchanged. + +Final pre-execution disposition: suitable to pin and run under parent control. Any assertion/timeout/unhandled malformed-value termination still means incomplete/failed evidence, not a normal passing receipt. No launchers were executed by this review. + +## Source pin and integration-name correction + +Parent's initial captured gate recorder is `6e2fad2fff3066861a42f85ab6c3ada8b4c8954075fb402e555c5f686dae840b`: pins initial source33b86a4 and permits underscores in receipt names, required for the reviewed integration-target stems. Final current recorder `59104b1acd39b3981b7339e585af9bd7f9cb87865ee82ffb763f0e7ce527713c` pins repaired source520e50ce62f067dff69f03760c8b12929df9b920. This review's prepared read-only `inspect_runtime.py` requires the final recorder hash and separately preserves the initial recorder/failure. The CLI recorder pin remains308fdd08…. Checker is prepared and AST-parsed only, not executed; it awaits all final library/integration/build/CLI receipts. It requires all 292 old names to pass, six new passes, exact listing/artifact/source/environment concordance, baseline-identical format bytes, all seven selected integration suites and actual two CLI commands with complete literal bytes and independent on-disk readback. It introduces no inherited failure-body normalization exception: final full outcomes must have no failures. + +After the four-test reconciliation, reviewed final gate recorder hash is `ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765`, pinning0c07f53ab517626f536f79dbaa2885a587bf1db7. Parent changed only that source pin from the520 recorder. Checker pin now matches it and explicitly preserves520focused/list/full records, in addition to33focused failure. Exact two-name mapping is recorded in TEST-REVIEW and enforced in the checker; no arbitrary rename/exclusion is admitted. Checker still has not been executed. + +Final migration-only successor7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd uses recorder `c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8`, again only a source-pin change. Reconciliation checks its migration pair/Clippy/fmt separately from reused0c07 evidence; exact two-file Git delta and sole declared-input change are enforced. Read-only checker was subsequently executed; its narrow encoding defect, actual refusal and successful correction are in CHECKER-NOTE. This paragraph supersedes the earlier unrun status, without changing historical launcher-review facts. diff --git a/harness/experiments/ordinary-source8-20260925/ORDINARY-RUNTIME-READBACK.json b/harness/experiments/ordinary-source8-20260925/ORDINARY-RUNTIME-READBACK.json new file mode 100644 index 00000000..1806548f --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/ORDINARY-RUNTIME-READBACK.json @@ -0,0 +1,375 @@ +{ + "source": "7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd", + "baseline": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "baseline_archive_sha256": "2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4", + "checker_sha256": "db853cc7677421e1abc13e59ca7d181fdcf7bcb45033164e51e09f13ca51c172", + "inputs": 560, + "focused_passed": 7, + "focused_existing_renamed_control": "language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls", + "prior_passes_preserved": 276, + "prior_failures_now_passed": 16, + "added_passed": 6, + "added_names": [ + "language::ordinary_source8::cli_preview_literals_compile_to_independent_complete_projects", + "language::ordinary_source8::current_formatter_roundtrips_complete_ordinary_examples_and_history", + "language::ordinary_source8::included_nested_omitted_ids_keep_actual_index_and_unicode_crlf", + "language::ordinary_source8::public_checked_save_reopens_ordinary_source_and_json_but_refuses_lost_definition", + "language::ordinary_source8::typed_analysis_future_headers_and_limits_still_refuse", + "language::ordinary_source8::versions_three_through_seven_migrate_to_idempotent_ordinary_eight" + ], + "full_passed": 298, + "full_failed": 0, + "former_failure_names": [ + "language::nesting_tests::checked_in_example_supports_cross_file_reparent_without_changing_allocations", + "language::nesting_tests::checked_in_nested_example_has_stable_ids_typed_exchanges_and_three_clear_views", + "language::nesting_tests::nested_elements_infer_only_parent_and_keep_typed_fields_and_allocations_explicit", + "language::nesting_tests::nested_fragment_id_stabilization_preserves_comments_and_indexes_real_bytes", + "language::nesting_tests::non_elements_includes_and_declarations_inside_typed_values_are_rejected", + "language::nesting_tests::normative_nested_ownership_example_compiles_as_a_source_fragment", + "source_files::transaction_tests::interrupted_publication_without_write_marker_never_rolls_back_external_matching_bytes", + "source_files::transaction_tests::interrupted_save_and_interrupted_recovery_can_both_be_resumed", + "source_files::transaction_tests::malformed_v2_write_marker_refuses_recovery_without_changing_source_bytes", + "source_files::transaction_tests::partial_save_failures_restore_every_original_and_write_entry_last", + "source_files::transaction_tests::recovery_before_any_write_accepts_v2_marker_and_keeps_v1_rollback_compatibility", + "source_files::transaction_tests::recovery_rechecks_external_changes_between_restorations", + "source_files::transaction_tests::recovery_rejects_untrusted_escape_paths_before_touching_files", + "source_files::transaction_tests::rollback_refuses_external_edits_even_in_an_unchanged_dependency", + "source_files::transaction_tests::rollback_removes_only_our_new_file_and_retains_detached_files", + "source_files::transaction_tests::unwritten_journal_never_rolls_back_a_completed_writer_with_identical_after_bytes" + ], + "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": 43324928, + "sha256": "b2261dd9168eaa582d478d4989610b37a5c13cec3f42ec93b5c651c2f3c190e9" + }, + "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 + }, + "receipts": { + "ordinary-focused-0c07f53-1": { + "source": "0c07f53ab517626f536f79dbaa2885a587bf1db7", + "exit": 0, + "outcomes": 7, + "listing": 0, + "log_sha256": "4bb20f728dc29c0f3119a7eedba6e1298bcaeec662b977e95877c44e1a457cbc", + "result_sha256": "d68ef427bf5d85668cf3480f8b21a16cf6d4b23aa1521282ba004f7284b27b25", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "launcher_sha256": "ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765" + }, + "ordinary-full-0c07f53-1": { + "source": "0c07f53ab517626f536f79dbaa2885a587bf1db7", + "exit": 0, + "outcomes": 298, + "listing": 0, + "log_sha256": "d9901deda399bcc3187f345b332fd5f2ba0c594113821f96f27681af4b6ed05d", + "result_sha256": "1e949b275a3f3fbae6717f697d211b42509cafe0d51d6ac1c4c1dfe4ca60ecdb", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "launcher_sha256": "ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765" + }, + "ordinary-list-0c07f53-1": { + "source": "0c07f53ab517626f536f79dbaa2885a587bf1db7", + "exit": 0, + "outcomes": 0, + "listing": 298, + "log_sha256": "22d4cfd1ef02f8c7adff8ce705efe56a7fe9a2e271951fed52aed687c626d06b", + "result_sha256": "e00ac1b86aadae7b2573d6b21551469263311a2a7b1f4eb7e5c69f495b347ddd", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "launcher_sha256": "ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765" + }, + "ordinary-clippy-0c07f53-1": { + "source": "0c07f53ab517626f536f79dbaa2885a587bf1db7", + "exit": 0, + "outcomes": 0, + "listing": 0, + "log_sha256": "3f18ecfb5fac754c6660d217d1f87752ee99a321fff525a6113ff7deb6ee2baa", + "result_sha256": "fcaef9f2ce8c1667cbdf47c7893ba6a4aebe6b7309a4a725153feb9257f0fc5c", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "launcher_sha256": "ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765" + }, + "ordinary-fmt-0c07f53-1": { + "source": "0c07f53ab517626f536f79dbaa2885a587bf1db7", + "exit": 1, + "outcomes": 0, + "listing": 0, + "log_sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d", + "result_sha256": "38c5c4e68f0aaa29a1829aac8bd4eac131f04b4011d80fa747dca1d86a3650c2", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "launcher_sha256": "ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765" + }, + "ordinary-integration-list-source_project-0c07f53-1": { + "result_sha256": "8a9a13020b38064a6f188c391f646a29cccdbdb35c220ff29e4b5ef22d13bc00", + "log_sha256": "02bdebb9395c835d9069bdf8c97920c9b3e6fec8e037a44be8ec3e3496edaa7c", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_project-026f3b0b53c16b7a.exe", + "bytes": 28188160, + "sha256": "5d352fd58782bfc07a35516e22b9e5a606f224d7a35882bd8f3df1a4ceeaa17c" + } + }, + "ordinary-integration-suite-source_project-0c07f53-1": { + "result_sha256": "da321481bcb17cba7603052aac4c874c59104bc51ef80491bd0bd4eadd404af3", + "log_sha256": "5f24b9b6ee1e7cabd72365698adccfe32037bca99e6978b93a629ad0d177d9ca", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_project-026f3b0b53c16b7a.exe", + "bytes": 28188160, + "sha256": "5d352fd58782bfc07a35516e22b9e5a606f224d7a35882bd8f3df1a4ceeaa17c" + } + }, + "ordinary-integration-list-source_identity_updates-0c07f53-1": { + "result_sha256": "d3cc5dd44a8dc6017aacfbc383caa4105dd4eaa814efb7c1f6e4e5bc6335ff4a", + "log_sha256": "1297c9929d8d17f900f129e3a3358cea4ed61a9527144b336788bbe1dfebec08", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_identity_updates-1b58007b00a7b809.exe", + "bytes": 16481792, + "sha256": "7560b5d9c4df9b10fb6b21a6f82d72bda496bbda949ed4523ad36708c42d5d5a" + } + }, + "ordinary-integration-suite-source_identity_updates-0c07f53-1": { + "result_sha256": "e8369317900600cb985a106ea9950ea6fd6b98fa0915037f2b1f615b481b42c8", + "log_sha256": "9f09d1c72f70ed41509a821417fdf8e3e3f6df334a54e510b0f9ed9c876e5309", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_identity_updates-1b58007b00a7b809.exe", + "bytes": 16481792, + "sha256": "7560b5d9c4df9b10fb6b21a6f82d72bda496bbda949ed4523ad36708c42d5d5a" + } + }, + "ordinary-integration-list-source_nested_updates-0c07f53-1": { + "result_sha256": "a98808c798b1f3b56c7489c4afdcb51039b2483cefc21faef57f62809c213216", + "log_sha256": "4b34e9e9776a1bc5ffdcf1211d2937ed3c33c2ba45a7a9635d5e088489d8870c", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_nested_updates-4bd51bbecfecb6b4.exe", + "bytes": 18934272, + "sha256": "a6b08120c20988d7d24e770a84578fe95244999376cc4077bc60b3d62fc04d7e" + } + }, + "ordinary-integration-suite-source_nested_updates-0c07f53-1": { + "result_sha256": "e1cf6cea7613ffd7343b07e125259431f96d7916ff398c9fb4d2236093f0fe8f", + "log_sha256": "d0fcb9be9a0a75b4113e7c3abf7bcc3eea6533e9adde2c8f290106ef79be4a7c", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_nested_updates-4bd51bbecfecb6b4.exe", + "bytes": 18934272, + "sha256": "a6b08120c20988d7d24e770a84578fe95244999376cc4077bc60b3d62fc04d7e" + } + }, + "ordinary-integration-list-source_files-0c07f53-1": { + "result_sha256": "7d71114234578f043a53f582bd1ab450c42e5dff5635702fa7de8008ef6132d3", + "log_sha256": "5703de5b7ea97bf4a03a2768910406ef506c8c9f2537ae87862b5493a7a0cce7", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_files-4512b0a519460d9e.exe", + "bytes": 15673856, + "sha256": "5289fa6aeba5fe4185c557f5a256940146d7eb9916b1bdb335b7b8939542657a" + } + }, + "ordinary-integration-suite-source_files-0c07f53-1": { + "result_sha256": "8be7fda52cd333f863da47ae2ecb23697cbd8465016d47f1f4d067fa79b41394", + "log_sha256": "8ac702b98b8e518650baef1982da1cdc1efba0bdd77eaffaff9e3b562fd4bcce", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source_files-4512b0a519460d9e.exe", + "bytes": 15673856, + "sha256": "5289fa6aeba5fe4185c557f5a256940146d7eb9916b1bdb335b7b8939542657a" + } + }, + "ordinary-integration-list-r3_migration-7b06b8e-1": { + "result_sha256": "e8a28ac312d2193aa2a6a5846037f1729d5470d7a730d0a3d5a6edcf490ea1c3", + "log_sha256": "3bf954f21c81ffc733d406175171beb6b3a2ac685f64b6c3b0a340017b443965", + "inputs_sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\r3_migration-5b5e9112e2def00c.exe", + "bytes": 24090112, + "sha256": "985adfe5edf24dd0f5e052bb1f978dd221bbaf2d2f976f6b08c2003fc397ca36" + } + }, + "ordinary-integration-suite-r3_migration-7b06b8e-1": { + "result_sha256": "080e795d747e2c396bbb1a718fd26f7fb3be917e752aa2556bf807040979d463", + "log_sha256": "821552f251b3dcaf21a09aff01a1ca65eda2fcb0c64f124cd7ae14e816789997", + "inputs_sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\r3_migration-5b5e9112e2def00c.exe", + "bytes": 24090112, + "sha256": "985adfe5edf24dd0f5e052bb1f978dd221bbaf2d2f976f6b08c2003fc397ca36" + } + }, + "ordinary-integration-list-review_regressions-0c07f53-1": { + "result_sha256": "2b3cb4d29cd681099a559c23309ca7568759ab144fcfd59331ec2d24c686ba9d", + "log_sha256": "cccc9047f0abd98b2919a7e8513c94dfe26a7889405ee6b7f881864105e6f5e1", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\review_regressions-a8d79a61793828a0.exe", + "bytes": 30372864, + "sha256": "c7231966bc81a4d227edd4433d029f660442c6e633bf6f3d1d38c534f0daf713" + } + }, + "ordinary-integration-suite-review_regressions-0c07f53-1": { + "result_sha256": "451ca27563d7b6aaf2d4a3ed4c52f21564ea3c0fb57e02d3db4b470e443580a4", + "log_sha256": "c2a46ec6f199507c124c5f373fb52c8fe1bb226dcdd58e3b9c8990623814b5c3", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\review_regressions-a8d79a61793828a0.exe", + "bytes": 30372864, + "sha256": "c7231966bc81a4d227edd4433d029f660442c6e633bf6f3d1d38c534f0daf713" + } + }, + "ordinary-integration-list-source7_contract-0c07f53-1": { + "result_sha256": "e89ca824de90c2585249ce496a031ce7f7210a99f0dbb5c08418d0ac7b3fbe6b", + "log_sha256": "ba4e0c42ad375ef974ecebba3562d829156f938056824473d0d7671e49f2f8ba", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source7_contract-96987110c9536d30.exe", + "bytes": 28692992, + "sha256": "853e0bea614b24bd1c1b357b5a0eb4b4dab08cfeac59a58bfb5d302eef643953" + } + }, + "ordinary-integration-suite-source7_contract-0c07f53-1": { + "result_sha256": "bec965b3342b6715d96151299df2a57c91e0fc92d1360d0aebe207662f590b4d", + "log_sha256": "629afa19abcee2630b9c8a1f645d9b863b81e0452f5da32c431495557096b91b", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\source7_contract-96987110c9536d30.exe", + "bytes": 28692992, + "sha256": "853e0bea614b24bd1c1b357b5a0eb4b4dab08cfeac59a58bfb5d302eef643953" + } + }, + "ordinary-integration-list-r3_migration-0c07f53-1": { + "result_sha256": "9d04bd9317852febb8f4ed16f64fb2697bcc76e52a31fcd263829949222ad1cc", + "log_sha256": "d655440440dbfd3df061c871da9ee96c8a7c8b7628fba1a8a930beb5193b6328", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\r3_migration-5b5e9112e2def00c.exe", + "bytes": 24089088, + "sha256": "454db1eb65764dd7d6a223bdda8064a8b77051092069194d6ffdb2d107005d70" + } + }, + "ordinary-integration-suite-r3_migration-0c07f53-1": { + "result_sha256": "8a2ea478ed00f2f55ecee5da89376d169f8ab99fab40065fd56fcc8dd73792f8", + "log_sha256": "ee55320de5e208beb921ce219afb38db7b27c86cd64d176837c952b803a48582", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\r3_migration-5b5e9112e2def00c.exe", + "bytes": 24089088, + "sha256": "454db1eb65764dd7d6a223bdda8064a8b77051092069194d6ffdb2d107005d70" + } + }, + "ordinary-clippy-7b06b8e-1": { + "result_sha256": "b8f59ee6cbebabfd31cb2aa2228481336245a403e086931e5f2cb80960718b91", + "log_sha256": "84ff5001a15bb4c99a168286ee4816a48ca0cc6119386c198c8ca716ca54a824", + "inputs_sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "artifact": null + }, + "ordinary-fmt-7b06b8e-1": { + "result_sha256": "2ed4803758e5e1808566f250b7a6b0a36dbca9fe2970f92f33433c9cc549f740", + "log_sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d", + "inputs_sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "artifact": null + }, + "ordinary-cli-build-0c07f53-1": { + "result_sha256": "9001d42d915ce1bfe14c695a927befd16119e82ac91f11e625468c2b15ba56d6", + "log_sha256": "fda7cc4a13707a8f861be4f1b1db590cec7f94e5e04e354390b3583800289b28", + "inputs_sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\arcadia.exe", + "bytes": 22081536, + "sha256": "46b2d1324aaff0ba5a95345d667063aa36e4362281bd6b6f0fdcce6e0c98cb81" + } + }, + "ordinary-cli-check-0c07f53-1": { + "receipt_sha256": "796dd000f421569fc964bef8fe1e2afa95a20ca9c89c99b53041dfd9c3d6432c", + "stdout_sha256": "23e8366945c023bd5b589a644062956d897ee27278633c0ef1a373f5a31accba", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "launcher_sha256": "308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d" + }, + "ordinary-cli-rename-alias-0c07f53-1": { + "receipt_sha256": "55ac982e3edb6abfc09ff15964b4a5b7e4b9513e0c751edb04f1ece4f48d1565", + "stdout_sha256": "7977240a636b697bc5596c8d27c263a5971b2ee945844832807463d370e9d222", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "launcher_sha256": "308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d" + } + }, + "integration_pass_counts": { + "source_project": 33, + "source_identity_updates": 3, + "source_nested_updates": 12, + "source_files": 8, + "r3_migration": 5, + "review_regressions": 3, + "source7_contract": 1 + }, + "component_source": "0c07f53ab517626f536f79dbaa2885a587bf1db7", + "reused_component_inputs": 560, + "successor_only_declared_delta": "crates/oa-core/tests/r3_migration.rs", + "old_r3_recorded_artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\r3_migration-5b5e9112e2def00c.exe", + "bytes": 24089088, + "sha256": "454db1eb65764dd7d6a223bdda8064a8b77051092069194d6ffdb2d107005d70" + }, + "cli_artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\arcadia.exe", + "bytes": 22081536, + "sha256": "46b2d1324aaff0ba5a95345d667063aa36e4362281bd6b6f0fdcce6e0c98cb81" + }, + "initial_failed_run": { + "source": "33b86a4d6b4bc1b156a93ae3596fe0ad7b4dbbe5", + "receipt_sha256": "8d28d7d9c162f6fdd759ef9ffe1526393f56c0116691a353eae40f986889e195", + "log_sha256": "16787e1fe74e7c867352badf8dedc5516c50dc5295958d27d5c5f128d1c2f5c5", + "passed": 5, + "failed": 1 + }, + "exact_authorized_name_mapping": { + "language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public8": "language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public_typed8", + "language::analysis_source::tests::public_source_headers_and_existing_numeric_token_controls_are_unchanged": "language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls" + }, + "intermediate_520_records": { + "ordinary-focused-520e50c-1": { + "receipt_sha256": "1aa7d7f7f38543a27db6be289126f484598a3aa89e45915f0219eccd3696822d", + "log_sha256": "c6dd4a5563e6b087072f76ca53e147f2df63b2c184077b3b736826c0085f71f2", + "inputs_sha256": "00f9b5454d499ed6bf47dfca1f765ee083dff1e3993d466faa1175846663bb70", + "exit": 0 + }, + "ordinary-full-520e50c-1": { + "receipt_sha256": "69ec1a47ba13ebaee80b090369b89b51cf2033bf1a02292e3f3e7bc6b9438079", + "log_sha256": "84b9e7a3a43e9f829a594a660e32faf574008718d7df46b87ac1d9661865fdd3", + "inputs_sha256": "00f9b5454d499ed6bf47dfca1f765ee083dff1e3993d466faa1175846663bb70", + "exit": 101 + }, + "ordinary-list-520e50c-1": { + "receipt_sha256": "68a912f426aeb33bd9379aacaa219968ba61678f3057925d7e3de705769ca357", + "log_sha256": "326452c7ccb98b85a06333cfdcedebdff83b75e68a6a0c9768ddf24d4a058420", + "inputs_sha256": "00f9b5454d499ed6bf47dfca1f765ee083dff1e3993d466faa1175846663bb70", + "exit": 0 + } + }, + "intermediate_recorded_artifact": { + "path": "C:\\Users\\User\\Documents\\Git\\ARCADIA-Studio\\.local\\analysis-checked-save-target-20260913\\debug\\deps\\oa_core-416e35542925bed6.exe", + "bytes": 43312640, + "sha256": "df81e34bd3900bbe9adbc2468099e94ae5fc98063c3f793051ca03ff20503c9b" + }, + "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/ordinary-source8-20260925/PACKAGE-READBACK.md b/harness/experiments/ordinary-source8-20260925/PACKAGE-READBACK.md new file mode 100644 index 00000000..ccc0f3bb --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/PACKAGE-READBACK.md @@ -0,0 +1,38 @@ +# Independent packet readback + +Read-only audit of the frozen ordinary-source8 packet. Only Git/data inspection and independently written inspection snippets were used; no archived helper, compiler, application, CLI or debugger was executed. This report is outside the ZIP. + +## First candidate binding (superseded by the final binding below) + +- ZIP: 1,220,467 bytes,128 unique members, SHA256 `7b1b46745fb2bbae01cec8b78041fb1c09436f6594fc4b08ffcffd917341df9c`. +- Manifest SHA256 `1f1c5280f863edcc873209f3ac6ebe9596451ad96606e4cd0101277ff8ff6a71`; inspected README SHA256 `b2bad07c5688c846405eadd39a5d278a8f68da400e7848512ab28d65aec9ea01`. +- Successful runtime readback SHA256 `3ee36b331431736062db7ea9fa94876795f61711d44820f5b5093e97cc515db5`. +- Final local source `7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd`; reused component source `0c07f53ab517626f536f79dbaa2885a587bf1db7`. + +## Verified evidence + +All ZIP CRCs, exact member names, sizes and SHA256 values pass.123 members match their original local files; four patches match actual immutable Git diffs; the implementation note matches its final Git blob. All ten readable review/checker mirrors match archive/original bytes. The nine baseline full/list/fmt members also match the prior immutable acceptance ZIP, SHA256 `2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4`. + +Independently checked2,799 declared Git blobs across five source input sets: baseline559, and560 each at33b86,520e50,0c07 and7b06. All560 final working input files match final Git bytes. The entire0c07→7b06 Git delta is exactly r3_migration.rs plus its implementation note; among declared inputs only the migration test differs. Component reuse is therefore accurately distinguished from rerunning all gates at final HEAD. + +All31 Cargo receipts (three baseline plus28 new) bind their raw logs, input manifests, captured launchers and unchanged source/head. Parsed raw outcomes equal recorded outcomes. The historical failed r3 receipt retains its two expected launcher verification failures; it is not treated as successful. Final core raw/list inventories agree at298 passes:276 prior passes preserved,16 former failures now passing and six added tests, using only the two authorized exact name mappings. Focused7 includes six new tests plus one renamed existing control. + +Selected integration list/outcome/artifact pairs agree:60 passes across six targets at0c07 and five r3 passes at7b06. Current core, selected integration and CLI artifact bytes match their actual receipt hashes. Core artifact is43,324,928 bytes, SHA256 `b2261dd9168eaa582d478d4989610b37a5c13cec3f42ec93b5c651c2f3c190e9`. Both actual CLI receipts bind exact stdout/stderr and unchanged input inventories. Independently reconstructed complete preview bytes by the two literal declaration/reference replacements; only children.arcadia and participants.arcadia change in the report, with comments/quoted references retained. No write invocation is claimed. + +Strict Clippy exits0; both format logs remain byte-identical to inherited `c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d` and are correctly reported as failures. Initial33focused5/1,520full294/4 and0c07r3four/one are preserved with actual logs/receipts. README/STATE/DECISIONS correctly limit claims to ordinary compatibility, explicitly describe local-only status and component reuse, and leave typed adoption, depth128 and Linux qualification open.114 relative links in packet Markdown plus STATE/DECISIONS resolved before adding this report. + +## Initial documentation finding (resolved below) + +The archived failed checker bytes and their hash are preserved, and their sole difference from the corrected checker is the project-comment literal. However, CHECKER-NOTE states that the failed literal was161 bytes with double-mojibake prefix `c383c2a9c3a2e282acc2bac382c2a8`. Independent `ast.parse` of the actual archived UTF-8 Python bytes, without executing the checker, yields153 bytes and prefix `c3a9e280bac2a8` (the three characters U+00E9, U+203A, U+00A8). The corrected escaped literal yields the actual149 bytes and `e99ba8` Unicode prefix. + +This discrepancy concerns the diagnosis narrative or identification of the executed predecessor, not the successful current fixture comparisons. Parent and evidence author were notified. Before final packet acceptance, reconcile whether the preserved source is the actual executed predecessor and explicitly correct the153/161/prefix statement. Preserve the frozen ZIP and the initial failure; do not relabel the transcribed traceback as redirected raw stderr. All other checks above pass. Final acceptance is pending only this evidence-description clarification. + +## Final corrected packet — accepted + +The author confirmed that the preserved failed checker is the actual executed predecessor. The153-byte literal is correct;161 came from a later default-encoding diagnostic read, not Python execution. Corrected CHECKER-NOTE explicitly preserves and explains this mistake. The parent selected a replacement packet; the entire first candidate, including its ZIP/manifest/README and this initial readback, remains under `.local/ordinary-source8-packet-first-candidate-20260925`. No runtime checker or product was rerun for this correction. + +Final ZIP is1,220,828 bytes,128 members, SHA256 `879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378`. Final manifest SHA256 `9349551c4bbffadd055abc4d385970967804772a3c91e9dc4fc4d86a8b56e611`; README SHA256 `3c76ec9d87de98cf082bef5e7589c3dbd7accd8df0d032c3a86d99a0f242c15e`; corrected CHECKER-NOTE SHA256 `e3c2875629a2c76b7ce4bc55c6fa8471ed0d2ea713d97eab638b474275080878`. + +Independently compared both archives: identical128-member inventories; exactly one payload changed, `reviews/CHECKER-NOTE.md`. All127 other payloads, including source patches, raw gates, failed/current checker bytes and successful readback, are byte-identical. Rechecked final CRCs, all member sizes/hashes and ten readable mirrors; corrected note also matches its original review file. README changes only archive binding and explicit erratum. The evidence checks above therefore carry to this corrected packet without a broader rerun. + +Disposition: **packet audit passes; no unresolved finding**. This accepts evidence integrity and accurate scope, not new runtime/platform/publication claims. Parent retains integration and publication ownership. diff --git a/harness/experiments/ordinary-source8-20260925/README.md b/harness/experiments/ordinary-source8-20260925/README.md new file mode 100644 index 00000000..a32805e0 --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/README.md @@ -0,0 +1,40 @@ +# Ordinary source8 compatibility evidence + +Local-only evidence packet for selected ordinary source8 compatibility. Final source `7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd`; baseline `edf096cd33350865ecfc3c65ec266a6c0d3c4000`. This is neither a runnable release nor confirmation of remote publication. + +[evidence.zip](evidence.zip):1,220,828bytes,128members, SHA256 `879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378`. [manifest.json](manifest.json) pins every member's byte count/hash and records its original local file or immutable Git-diff source. ZIP CRC/member readback passed during creation. The [independent final packet audit](PACKAGE-READBACK.md) passes with no unresolved finding. + +## Result and exact source boundary + +Core execution at `0c07f53ab517626f536f79dbaa2885a587bf1db7` passes298/298, including all16 former schema-refusal failures and six new tests. Only two explicitly recorded existing test names change. Focused filter passes7: six new tests plus one renamed existing control; it is not seven added tests. + +Six selected integration targets at0c07 pass60tests: source_project33, source_identity_updates3, source_nested_updates12, source_files8, review_regressions checked_save_3 and source7_contract selected migration1. Final r3_migration at7b06 passes5, totaling65 selected integration passes. Each target's nonzero actual list and runtime inventory/artifact agree. The checked-save functions reach source then JSON. Windows cfg-excluded Unix cases are not claimed. + +Final7b06 differs from0c07 only in the r3_migration test oracle and its implementation note. Among560 declared inputs only that test changes; other559 are byte-identical, including production, core library tests and CLI sources. Final migration suite, strict core all-target Clippy and format were rerun. Unaffected core/six integration/CLI evidence is reused honestly from0c07, not presented as full rerun at finalHEAD. Both Clippy runs exit0. Format exits1 with exactly inherited raw hash `c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d`; it did not pass. + +Actual non-test CLI built at0c07 passes `check ENTRY --json` and `rename-alias ENTRY team rescue_team --json`. Explicit-ID three-file Unicode/CRLF fixture, full expected preview texts, exact two changed-file reports and complete unchanged disk inventory/bytes are checked. The independent complete-Project public-API test provides the model oracle; CLI JSON has no Project field. No `--write` invocation was used. CLI executable22,081,536bytes SHA256 `46b2d1324aaff0ba5a95345d667063aa36e4362281bd6b6f0fdcce6e0c98cb81`; core executable43,324,928bytes SHA256 `b2261dd9168eaa582d478d4989610b37a5c13cec3f42ec93b5c651c2f3c190e9`. Executable bytes are not duplicated in this evidence ZIP. + +## Preserved failures + +- Initial33b86 focused5pass/1fail: new fixture assertion incorrectly assumed existing example traces. Explicit authored trace coverage replaces the assumption. +- Intermediate520 focused6pass, list298 and full294pass/4fail: four old private tests still expected ordinary8 header refusal. Narrow version assertions reconcile with selected compatibility while preserving substantive typed/model/numeric checks; two exact names are updated. +- 0c07 r3_migration4pass/1fail: expected migrated JSON omitted current required empty `definitions:{}`. Final oracle adds exactly that empty map after asserting original absence/decoded emptiness; production remains unchanged. +- First independent checker exits1 due to its own Windows text-decoding corruption of the intended Unicode comment literal. [CHECKER-NOTE.md](CHECKER-NOTE.md), [executed failed checker](inspect_runtime_encoding_original.py) and [observed traceback](checker-first-refusal.log) preserve this evaluator defect. Traceback is transcribed from the actual exec tool result, not separately redirected raw stderr. Correction changes only that literal to explicit `\u96e8`; no source, fixture or receipt changes. Corrected checker completes successfully. + +Historical failed binaries are recorded by their original hashes; they are not falsely compared to later overwritten files. All initial logs, receipts, declared-input manifests and exact launcher copies remain in the archive. + +## Navigation and reproduction + +Read [RUNTIME-REVIEW.md](RUNTIME-REVIEW.md), [SOURCE-REVIEW.md](SOURCE-REVIEW.md), [TEST-REVIEW.md](TEST-REVIEW.md), [LAUNCHER-REVIEW.md](LAUNCHER-REVIEW.md) and [VERIFICATION-PLAN.md](VERIFICATION-PLAN.md). [ORDINARY-RUNTIME-READBACK.json](ORDINARY-RUNTIME-READBACK.json) pins the independently reconciled records; [inspect_runtime.py](inspect_runtime.py) is the data-only checker. Its original checkout invocation was: + +```text +python -I -B .local/ordinary-source8-review-20260925/inspect_runtime.py 7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd 7b06b8e 6 +``` + +The checker requires original local layout, immutable Git objects and current artifacts and refuses to overwrite an existing result. It is not a portable test runner. Raw source-bound launchers record exact Cargo argv/environment; no archived code needs execution to inspect this packet. Archive contains28Cargo gate records,2CLI receipts with stdout/stderr,3original CLI input files, exact launchers, baselineEDF full/list/fmt anchored to prior immutable ZIP `2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4`, four baseline-to-checkpoint Git patches, implementation note, toolchain evidence, contracts/design and review records. The10 readable review/checker mirrors use `-text` attributes to preserve raw bytes. + +Selected [contract](../../ordinary-source8-compatibility-contract-20260925.md) and [adoption map](../../ordinary-source8-design-20260925/ADOPTION-MAP.md)/[critique](../../ordinary-source8-design-20260925/ADOPTION-CRITIQUE.md) remain authoritative. This result admits supported ordinary records at schema8; it does not enable public typed source, complete typed formatting, adoption/history integration, universal allocation guarantees or depth128 qualification. Preserve `DEPTH_128_VALIDATED=false`, the documented full-pipeline small-stack limitation and user-deferred Linux work. + +## Packet narrative correction + +Independent audit found that the first CHECKER-NOTE conflated the executed checker's153-byte corrupted literal with a161-byte secondary diagnostic probe that used Windows default decoding. The corrected note distinguishes both observations and the actual149-byte fixture. The first packet candidate is preserved locally; only the CHECKER-NOTE member changed in this replacement packet. All raw application evidence, both checker versions and successful readback remain byte-identical. See CHECKER-NOTE for the exact byte account. diff --git a/harness/experiments/ordinary-source8-20260925/RUNTIME-REVIEW.md b/harness/experiments/ordinary-source8-20260925/RUNTIME-REVIEW.md new file mode 100644 index 00000000..a000a14b --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/RUNTIME-REVIEW.md @@ -0,0 +1,37 @@ +# Ordinary source8 independent runtime evidence readback + +Read-only reconciliation succeeded with checker `db853cc7677421e1abc13e59ca7d181fdcf7bcb45033164e51e09f13ca51c172`. Result `ORDINARY-RUNTIME-READBACK.json` SHA256 `3ee36b331431736062db7ea9fa94876795f61711d44820f5b5093e97cc515db5`. Reviewer ran only Git/data inspection; no compiler, tests, CLI application or debugger. A first checker refusal and exact encoding repair are preserved in CHECKER-NOTE and the original checker. + +## Tested source boundary + +Final source is `7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd`; reused core, six integration targets and CLI evidence was actually run at `0c07f53ab517626f536f79dbaa2885a587bf1db7`. Immutable Git diff contains exactly `crates/oa-core/tests/r3_migration.rs` and its implementation note. Of560 declared inputs, only that migration-test file changes; the other559, including all production/library-test/CLI sources, are byte-identical. Current final disk bytes match all final Git inputs. The migration test is rerun at final source, as are strict Clippy and format. Do not claim all gates reran at final HEAD. + +Baseline292names/276passes/16failures comes from immutable acceptance archive `2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4`, with full/list/fmt raw logs and receipts matched exactly. Only the two explicitly authorized private-test renames are mapped. Final core inventory contains298unique names: all276 prior passes remain passes, all16 former schema-refusal failures now pass, and all6 added tests pass. Full result298pass/0fail/0ignore; focused7pass/291filtered is six new tests plus the renamed existing public-header control. Raw list and runtime sets match exactly. + +Core executable43,324,928bytes SHA256 `b2261dd9168eaa582d478d4989610b37a5c13cec3f42ec93b5c651c2f3c190e9`, current bytes verified. Core full log `d9901deda399bcc3187f345b332fd5f2ba0c594113821f96f27681af4b6ed05d`; receipt `1e949b275a3f3fbae6717f697d211b42509cafe0d51d6ac1c4c1dfe4ca60ecdb`. Component input manifest hash `7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2`; final manifest `6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba`. + +## Integration and real CLI evidence + +| Target | Actual passes | Tested source | +| --- | ---: | --- | +| source_project | 33 | 0c07f53 | +| source_identity_updates | 3 | 0c07f53 | +| source_nested_updates | 12 | 0c07f53 | +| source_files | 8 | 0c07f53 | +| review_regressions checked_save_ | 3 | 0c07f53 | +| source7_contract selected migration | 1 | 0c07f53 | +| r3_migration | 5 | 7b06b8e | + +All65 selected integration outcomes are actual passes, with exact nonzero list/suite name and artifact equality. Each historical checked-save function loops through source then JSON, so those three passes reach both formats. Windows excludes the source_files Unix-only cases; they are not claimed. Final migration executable24,090,112bytes SHA256 `985adfe5edf24dd0f5e052bb1f978dd221bbaf2d2f976f6b08c2003fc397ca36`; final migration log `821552f251b3dcaf21a09aff01a1ca65eda2fcb0c64f124cd7ae14e816789997`. + +Actual Cargo JSON binds non-test arcadia.exe22,081,536bytes SHA256 `46b2d1324aaff0ba5a95345d667063aa36e4362281bd6b6f0fdcce6e0c98cb81`, built at0c07f53. Both actual commands exit0 with empty stderr: `check ENTRY --json` and `rename-alias ENTRY team rescue_team --json`. Exact argv, environment, build input hashes, source/binary/launcher binding and reports verified. Check has no changes; preview has precisely children.arcadia and participants.arcadia in order, with complete independently authored before/after texts. Quoted/comment references remain untouched. All three actual fixture files and directory inventory still match original bytes, and each command's captured after inventory matches too. The separate passed whole-Project literal test supplies the model oracle; CLI JSON itself contains no model. + +Strict core all-target Clippy exits0 at both0c07 and final7b06. Final Clippy log SHA256 `84ff5001a15bb4c99a168286ee4816a48ca0cc6119386c198c8ca716ca54a824`. Format exits1 at both, with raw bytes identical to inherited baseline hash `c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d`; formatting is not reported as passing. Environment is exact baseline, including jobs1/incremental0 and absent stack/lifecycle overrides. Captured gate launchers match reviewed hashes; final7b06 launcher `c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8` differs from0c07 only in source pin. + +## Preserved failures and limitations + +Initial33b86 focused5pass/1fail assumed the example had traces.520focused6pass/list298/full294pass4fail exposed four obsolete public8-refusal assertions; all old16 already passed there. Both stages' raw receipts/logs, immutable source manifests and recorded artifacts remain. Those historical artifacts are recorded identities, not asserted equal to the later overwritten executable. Exact two-name mapping and test corrections are detailed in TEST-REVIEW. + +0c07 r3_migration records4pass/1fail, log `ee55320de5e208beb921ce219afb38db7b27c86cd64d176837c952b803a48582`, because its expected migrated JSON omitted the current required empty `definitions` map. Final correction asserts old fixture lacks that field, decoded definitions are empty, then adds precisely `{}` to expected JSON, retaining complete JSON equality and historical/reopen assertions. Recorded old binary24,089,088bytes SHA256 `454db1eb65764dd7d6a223bdda8064a8b77051092069194d6ffdb2d107005d70` is preserved as a historical identity; final binary is checked separately. No migration semantics changed. + +Evidence supports selected ordinary source8 compatibility and retained typed refusal only. It does not establish full source8 typed formatting/adoption, universal parser allocation bounds, depth128 qualification, or Linux support. Preserve `DEPTH_128_VALIDATED=false` and the prior full-pipeline small-stack limitation. All commits/artifacts remain local-only until parent independently confirms publication. diff --git a/harness/experiments/ordinary-source8-20260925/SOURCE-REVIEW.md b/harness/experiments/ordinary-source8-20260925/SOURCE-REVIEW.md new file mode 100644 index 00000000..11f5bf9f --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/SOURCE-REVIEW.md @@ -0,0 +1,65 @@ +# Ordinary source8 compatibility — independent source review + +No production blocker found in the bounded draft. Reviewed against root contract committed locally at `fb9b0c5c`, `harness/ordinary-source8-compatibility-contract-20260925.md`, SHA256 `e3b24beb14ce7c1c506666aceb18233df90a09fc849cf59eb862f6eb48e08f76`. Source base is `edf096cd33350865ecfc3c65ec266a6c0d3c4000` on `codex/ordinary-source8-956atf-20260925`; working `crates/oa-core/src/language.rs` SHA256 is `d0ba16e05c80ede859506de84dab0d54ba8ca97996b2db020e5f0e0d7771dcf1`. This is read-only source review; no compiler or application was executed and no implementation was edited. Final commit, test review and runtime gates remain pending. + +The sole production behavior change at `language.rs:1548..1556` adds the exact token8 to the ordinary accepted-version list and updates the unsupported-version diagnostic. Existing exact matches still reject malformed/future versions. The private mixed branch still requires exactly8. The other edits clarify public ordinary versus private mixed scope and register a cfg(test) child module. + +Current-version ordinary resolution already takes the unchanged `resolve_declarations` path at `language.rs:2130..2149`: caller model checks precede `DecodeResult { migration: None }`. Versions3–7 retain their earlier explicit migration paths, including source migration and recompilation at current8. The new gate therefore repairs the writer/current-reader mismatch without installing a second resolver or changing conversion semantics. Whether every formerly masked assertion succeeds requires actual execution. + +Caller ParseLimits/ProjectLimits, strict tokens, location mapping, generated/explicit UUID handling, nested lexical ownership, SourceIndex construction and compilation re-indexing are unchanged. `compile_bundle` still stabilizes missing IDs, reparses returned bytes and migrates older source. The patch does not alter the updater's stale bundle/model/index checks or its final complete-model equality check; checked save continues to recompile before filesystem staging. No private AcceptedRename is substituted for CompiledSourceProject and no incomplete index is fabricated. + +Both analysis refusal mechanisms remain present. Short source8 analysis words have no ordinary declaration kind and refuse in the ordinary parser; long ordinary analysis constructors may parse syntax but `construct_declarations` still rejects `kind.is_analysis()` at `language.rs:1861`. Reaching that latter branch should be tested with an otherwise syntactically valid declaration so another error cannot mask it. Existing public formatter omissions and unsupported typed output remain limitations, not made safe or complete by this gate change. + +No cfg(test) mixed hook is promoted; Parser state layout, budget/producers and lifetimes are untouched. Generic values retain depth64, typed expressions retain logical128, and no codec qualification, DEPTH_128_VALIDATED flag, limits or stack size is changed. Runtime obligations include all292 prior core names, the16 previously schema-blocked tests' actual assertions, source/JSON checked saves, relevant integration suites, and a non-test CLI check/rename preview. Passing only the new gate test would not establish those outcomes. + +## Committed binding — 33b86a4d + +Confirmed clean tracked HEAD `33b86a4d6b4bc1b156a93ae3596fe0ad7b4dbbe5`, committed locally. The exact baseline→candidate diff contains four files: `language.rs`, new `language_ordinary_source8_tests.rs`, existing integration test `tests/source7_contract.rs`, and `harness/ordinary-source8-compatibility-implementation-20260925.md`. No existing core-library test body changed. Production remains the exact `d0ba16e0` hash above; contract provenance remains local `fb9b0c5c`, not a remote publication. + +New test file SHA256 `59e1afe4f61f7e1c80a283c6ad8bbbe26d46ca16c624c1125f3d2b5d4115de95` has six tests. Source review confirms substantive model/bundle/index comparisons, versions3–7 idempotence, included/nested omitted IDs and CRLF, current limits/stale-input refusal, real source/JSON checked-save calls and a genuinely formatter-lost definition refusal. The CLI literal test authors complete independent before/after models and exact bytes; it does not itself execute the CLI. Root's actual CLI run remains required. + +The authorized source7 evaluator correction, SHA256 `f6385ee7716b3431e4b0fc4073531ef0337917b3a1ae62a715b5dc9250e65880`, is confined to `source7_source_bundle_migration_is_token_only_and_new_link_stays_with_caller`: assert writer-produced8, replace that actual token with the existing commented6 fixture, verify replacement occurred, and expect migration to8. The old replacement searched nonexistent7 and could not manufacture the intended old-version input. All later byte/module/model/update assertions and the test name remain unchanged. This repairs the evaluator without redefining migration behavior. + +One concrete new-test coverage finding was sent to parent/implementer: the short refusal table uses `oa_case`/`sa_case`, whereas the actual private short case words are `oa_analysis`/`sa_analysis`. Rejection of those invalid spellings does not independently cover the two actual short case forms. Add the actual spellings before claiming all nine short forms are individually covered; long ordinary analysis constructors already assert the specific conversion-refusal message. This is a test-coverage correction, not an observed production failure. Compiler/runtime acceptance remains parent-owned and pending at this binding. + +## Initial focused failure and reviewed repair + +Initial33b86a4d compiled and its focused run finished5 passed/1 failed. The failure is the new example fixture's `!example.traces.is_empty()` assertion, not a production parser/save refusal. The six-file example has no trace declarations. The original focused raw log and receipt remain in `.local/ordinary-source8-gates-20260925/ordinary-focused-33b86a4-1.*`; no later correction replaces this outcome. + +Reviewed repaired new-test file SHA256 `e85ce6c793f59be6991f76d297363e709bc3ab4dd30b99b66ee1a40354b8d80e`. It explicitly adds a Participant trace to the compiled example before the unchanged whole-model format/parse and bundle round trips. Its fixed endpoints are actual OA Entity rescue_team (`00000000-0000-4000-8000-000000000102`) and SA System rescue_system (`00000000-0000-4000-8000-000000000301`); these match the source fixtures and `validation::trace_permits` at2718. The test asserts endpoint kinds, insertion into an empty ID slot and the complete authored trace. This establishes actual trace coverage instead of weakening the missing-fixture assertion. Both actual short words `oa_analysis`/`sa_analysis` are added; the coverage finding above is resolved. Production remains unchanged at `d0ba16e0`. + +Independently inspected the unchanged historical fixture `tests/fixtures/v4-reviewed-prose.json`, SHA256 `2808088afcc165f4bd6da5129151143411c997041c3de61d600ab76e05d24a47`. It contains exactly one Item trace, ID `40000000-0000-4000-8000-000000000004`, linking OA/SA datatype IDs ending002/003. Its historical baseline stores OA name `Approved OA name`, OA description `Approved OA\nprose`, SA name `Approved SA name` and SA description `Approved SA prose`, deliberately distinct from current prose. There is no semantic-facet snapshot. Existing `tests/r3_migration.rs:9..38` independently asserts migration from4, those historical fields, semantic=None and equality with the original JSON except its schema version. The new whole-model roundtrip over this migrated fixture therefore exercises retained prose history; it must not be described as semantic-facet coverage. No additional decoder/runtime execution was performed for this readback. Corrected runtime results and repair commit binding remain pending. + +Final repair binding: independently confirmed clean tracked HEAD `520e50ce62f067dff69f03760c8b12929df9b920`. Its exact33b86→520e diff contains only the reviewed new test file and implementation note; language production and the authorized source7 evaluator are unchanged. The test retains the `e85ce6c7` hash above. This is a local commit, not a publication claim. No source-review finding remains open; parent-owned corrected runtime/integration/CLI acceptance remains pending at this binding. + +## Four inherited expectation conflicts exposed by the full run + +The initial full520 run finished298 tests:294 passed/four failed. All16 previously schema-blocked ordinary tests passed. Four private analysis tests still asserted that an empty or ordinary schema8 document must be rejected. Those expectations contradicted the selected ordinary compatibility contract; the initial review did not identify them before execution. This was a missed evaluator dependency, not evidence that accepting ordinary8 is a production defect. Preserve the full raw log `ordinary-full-520e50c-1.log`, SHA256 `84b9e7a3a43e9f829a594a660e32faf574008718d7df46b87ac1d9661865fdd3`, and its original names/results. + +Reviewed the narrow follow-up patch: ordinary8 must succeed without migration, complete ordinary fixed-ID OA/SA projects must equal their migrated predecessor models, and actual typed bodies/canonical typed output still refuse through public parsing. The declarations negative loop now includes versions3..=8. All existing numeric token checks, contextual-name/root constraints, complete independent17-UUID lowering comparisons, reference/expression invariants, semantic admission and canonical typed roundtrips remain. Production `language.rs` remains exact `d0ba16e0`. + +Reviewed repaired test hashes relative to `crates/oa-core/src/language/analysis_source/`: + +| File | SHA256 | +| --- | --- | +| `declarations/tests.rs` | `41051822b4954441a2ff94c923ae734f391269d9335d312b113e9bf4ddceeb00` | +| `lower/tests.rs` | `257f3e82380a33ba783d9aedb738283ff5d6f2bd4e943680030b42536bb56f15` | +| `tests.rs` | `d1a98ccd213e31496c1163c7ed3ee82bd910547bfe22b5fd72862555ec859fd3` | +| `write/tests.rs` | `b366b684776cd83ab39cf4391a14ec378465f15b6a54e4ece396c84bf1f17084` | + +Only the two parent-authorized evaluator names change: + +- `inherited_version_root_and_short_word_contracts_do_not_enable_public8` → `inherited_version_root_and_short_word_contracts_do_not_enable_public_typed8`. +- `public_source_headers_and_existing_numeric_token_controls_are_unchanged` → `public_ordinary_source8_preserves_typed_refusal_and_numeric_controls`. + +The lower/write test names remain unchanged. Final inventories must use this exact two-name correspondence, not drop unmatched cases or normalize arbitrary names. No source-review blocker was found in this patch. The initial33b86a4d five-pass/one-failure and520e50ce294-pass/four-failure outcomes remain historical failures, not rewritten passes. + +Final expectation-repair binding: independently confirmed clean tracked HEAD `0c07f53ab517626f536f79dbaa2885a587bf1db7`. Exact520→0c07 scope is the four test files above plus the implementation note; all four test hashes and unchanged production hash were reread. The amended root contract is committed locally at `69c784f2`, SHA256 `4f6b308842fb240fdbcc22a4787ba1123f2432c92ddf08b978ae61b4e38204bb`, explicitly authorizing the expectation alignment and exact name mapping. No publication or repaired-runtime claim follows from this source binding. + +## Historical JSON oracle correction + +The initial0c07 `r3_migration` integration run finished four passes/one failure, preserved in `ordinary-integration-suite-r3_migration-0c07f53-1.log`. The failed whole-JSON comparison differs by the current top-level `definitions: {}` field. `model.rs:1652..1661` derives Serialize for this unconditional field; `migration_v4.rs:66..78` explicitly constructs an empty definitions map when converting the old model. This is the current schema's empty catalog, not a fabricated historical review or analysis definition. The earlier paragraph's description of the r3 oracle as changing only the schema version described its then-stale expectation; this checkpoint explicitly supersedes that expectation. + +Independently confirmed clean tracked HEAD `7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd`. Exact0c07→7b scope is only `crates/oa-core/tests/r3_migration.rs` and the implementation note. The test adds three lines: assert the frozen fixture lacks definitions, assert the migrated project catalog is empty, and add the literal empty object to expected current JSON. It retains full JSON equality for both JSON/source decoding, all migration and historical trace assertions, semantic=None, and whole-model reopen equality. Neither production nor the fixture changes. No source-review blocker was found; repaired runtime remains parent-owned. + +Final test SHA256 `a8ad8d6edaae8f0583595098eb27022331fe0e69ee27cfa78835bfa1753feb96`; implementation note SHA256 `7d2b34649625cbefca46aa9ea837de6bc9784c1299aa293240782261a1dbddcf`. These are local commit bindings, not publication or new execution claims. diff --git a/harness/experiments/ordinary-source8-20260925/TEST-REVIEW.md b/harness/experiments/ordinary-source8-20260925/TEST-REVIEW.md new file mode 100644 index 00000000..5d34a388 --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/TEST-REVIEW.md @@ -0,0 +1,41 @@ +# Ordinary source8 tests: independent pre-execution review + +Reviewed all six functions in `crates/oa-core/src/language_ordinary_source8_tests.rs`, SHA256 `59e1afe4f61f7e1c80a283c6ad8bbbe26d46ca16c624c1125f3d2b5d4115de95`, and the authorized single-test correction in `crates/oa-core/tests/source7_contract.rs`, file SHA256 `f6385ee7716b3431e4b0fc4073531ef0337917b3a1ae62a715b5dc9250e65880`. Baseline is edf096cd33350865ecfc3c65ec266a6c0d3c4000; final candidate commit was not yet supplied. No compiler or executable was run. + +No concrete precompile test blocker found within the selected compatibility scope. + +- Current direct-parser and bundle roundtrips cover the existing six-file OA/SA example plus genuine historical baseline fixture. They compare whole Project, current no-migration status, exact bundle/index and repeat diagnostics; caller input remains unchanged. These are substantial regression roundtrips based on existing decoded semantic fixtures, not independently authored full expected models. The separate CLI test supplies a small independent whole-model oracle. +- Source3–7 tests exercise direct and bundle admission, current schema8 output, no-migration second compile, whole model/index/bundle stability and unchanged original input. They assert migration presence rather than every migration-report field; the selected historical integration tests retain detailed source-version/byte assertions. +- Nested omitted-ID test inspects actual stabilized declaration spans in returned bytes, UUID presence, semantic and lexical parent, Unicode description, CRLF consistency, unchanged comments and exact repeat index/model. It also exercises stale compiled-model refusal. Span prefix/suffix assertions are not a full independent coordinate table; existing source-project location integration checks remain required. +- Typed/analysis refusal test uses both public entry points and included-fragment path/span/code attribution. Long analysis constructors require the specific conversion refusal message, so their empty bodies cannot merely pass by failing an unrelated body-validation check. Short typed names, malformed/future versions and byte/record limits remain negative controls. +- Checked-save test reaches both source and JSON, verifies returned/disk bytes and whole decoded model, then repeat-save bytes. A genuinely populated QuantityKind definition exercises exact whole-model-loss refusal while preserving external sentinel bytes and directory count. This complements, rather than replaces, the three historical source-first/JSON-second checked-save integration tests and full transaction suite. +- `cli_preview_literals_compile_to_independent_complete_projects` copies the independent three-file CRLF/Unicode before/after literals exactly. It constructs the whole expected Project from fixed IDs 1/2/3, named OA Entity bodies and parent ID2, with only ID2's alias changed for the second case. Both compiled bundles must equal the authored literals, with no migration or warnings. Actual CLI recorder equality against those literals plus this test establishes the intended transitive model oracle; this test alone does not prove a CLI process ran or left files unchanged. +- Source7 correction now asserts formatter schema8, downgrades that actual header to commented schema6, proves the downgrade occurred and expects only the schema6→8 token replacement. Existing whole-model, per-file exact bytes, relation ownership and update/recompile assertions remain. The inherited newline replacement can produce an extra CR before the injected header newline; preservation assertions use the exact authored bytes, and the correction makes no clean-CRLF claim for this legacy fixture. This is a static evaluator correction, not a reported runtime failure. + +Remaining acceptance is execution on the frozen source: six focused tests, all 292 prior library names and newly reached former failures, selected integration inventory/outcomes, strict Clippy/fmt disposition and actual CLI receipt/byte checks. Do not infer JSON or transaction success from an earlier source failure. No depth128/platform qualification, full typed source support, runtime pass or publication claim is made here. + +## Initial failure and test-only repair + +Initial source `33b86a4d6b4bc1b156a93ae3596fe0ad7b4dbbe5` focused execution recorded five passes and one failure: the existing example has no traces, contradicting the new nonempty-traces assertion. The preceding static review missed this fixture assumption. Preserve the actual failed receipt/log (`16787e1fe74e7c867352badf8dedc5516c50dc5295958d27d5c5f128d1c2f5c5` log SHA256); the initial review is not runtime acceptance. + +Reviewed test delta to `520e50ce62f067dff69f03760c8b12929df9b920`, final test hash `e85ce6c793f59be6991f76d297363e709bc3ab4dd30b99b66ee1a40354b8d80e`. It explicitly authors a Participant trace with fixed ID and known OA Entity/SA System endpoints, asserts endpoint kinds and collision-free insertion, and retains the existing complete roundtrip assertions. Trace coverage is added deliberately rather than removed. The genuine historical-baseline fixture remains separate. The refusal vocabulary also now includes actual short `oa_analysis` and `sa_analysis` spellings. Parent reports this successor changes only the test and implementation note; no runtime result for the repaired candidate is claimed here. + +## Newly exposed obsolete private-test expectations + +The520 full raw transcript records294passes/4failures, while the six focused tests pass and listing contains298names. All16 former schema-refusal failures now pass. Four old private tests still assert that ordinary schema8 is refused: declarations inherited-version/root/short-word controls, staged lowering's complete17-ID oracle, public-header/numeric controls, and typed writer canonical roundtrips. Their version assertions conflict with the selected compatibility contract. The earlier readiness review did not catch these four existing assumptions; retain this as a review miss and preserve the full failed run, not as accepted final evidence. + +Parent authorized only two exact name changes: `language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public8` to `language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public_typed8`; and `language::analysis_source::tests::public_source_headers_and_existing_numeric_token_controls_are_unchanged` to `language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls`. Prepared checker maps precisely those names and requires all other prior names intact, all298passing, and the same six new names. Pending test corrections must retain substantive typed refusal/model/numeric assertions and are not yet approved by this paragraph. + +## Reviewed final four-test reconciliation + +Read immutable diff520e50c→`0c07f53ab517626f536f79dbaa2885a587bf1db7`: only four existing test files and the implementation note change. No production edit. The exact two authorized name changes above are present. The declaration test now admits ordinary8 with no migration/schema/name/alias assertions and extends short typed refusal through version8; its inherited-version/root/contextual-word controls remain. The public header test similarly checks ordinary8 and adds actual `calculation` refusal, retaining numeric-token controls. Lowering and canonical-writer tests retain complete independently authored typed model equality, while adding OA/SA ordinary8 no-migration and whole-Project equality against the same legacy ordinary fixture, plus public typed-fragment rejection. Typed fixtures are declaration fragments, so the inserted outer header/project does not cause a duplicate-header rejection. No concrete blocker in this bounded repair. + +Final file SHA256 values: declarations/tests.rs `41051822b4954441a2ff94c923ae734f391269d9335d312b113e9bf4ddceeb00`; lower/tests.rs `257f3e82380a33ba783d9aedb738283ff5d6f2bd4e943680030b42536bb56f15`; analysis_source/tests.rs `d1a98ccd213e31496c1163c7ed3ee82bd910547bfe22b5fd72862555ec859fd3`; write/tests.rs `b366b684776cd83ab39cf4391a14ec378465f15b6a54e4ece396c84bf1f17084`. New six-test file remains e85ce6c7…. Final gate results remain a separate pending readback. + +## Exact focused-filter expansion + +Parent reports final0c07 focused execution has7passes/291filtered: authorized renamed existing test `language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls` now also contains the literal `ordinary_source8` filter. This is six new tests plus one existing renamed control, not a seventh new test. The effect was foreseeable from the rename and was missed by the earlier parent/reviewer focused-count expectation. Checker now requires precisely those seven names and291filtered, with no generic count relaxation or rerun. Initial33focused remains5/1;520focused remains6/0 with292filtered. Full final inventory remains298 with exactly six added names and two explicit old-name mappings. + +## Final migration-oracle successor + +Reviewed0c07→`7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd`: only r3_migration.rs and implementation note change. The old frozen-v4 expected JSON omitted required current `definitions:{}`. Repair asserts its original absence and the decoded map's emptiness, adds only that empty map to the authored expected JSON, then keeps complete JSON/model/history/reopen checks. Initial0c07 r3 result4pass/1fail remains preserved. Final affected migration suite5passes is independently reconciled; unchanged0c07 library/integration/CLI runs are reused with exact component-source disclosure, not reported as rerun at7b06. See RUNTIME-REVIEW for completed results. diff --git a/harness/experiments/ordinary-source8-20260925/VERIFICATION-PLAN.md b/harness/experiments/ordinary-source8-20260925/VERIFICATION-PLAN.md new file mode 100644 index 00000000..52ade1ed --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/VERIFICATION-PLAN.md @@ -0,0 +1,63 @@ +# Ordinary source8 compatibility: independent verification plan + +Read-only source review against private baseline `edf096cd33350865ecfc3c65ec266a6c0d3c4000` and selected root contract `harness/ordinary-source8-compatibility-contract-20260925.md` (parent identifies root `fb9b0c5c`). Implementation is currently uncommitted; this is a plan, not execution evidence. No compiler, application, CLI, or archived evaluator was run for this review. + +## Smallest useful gate set + +Parent owns serial execution, source/artifact pins and available disk space. Reuse the existing target directory, jobs=1 and incremental=0 environment. Do not build the workspace. First list each selected target/filter and retain the actual nonzero name inventory; subsequent execution must cover those exact names. Commands below run from `.local/as3batch`; append `-- --list` instead of the execution harness arguments for inventory. + +1. Run the new focused ordinary-source8 tests, the full core library, strict core all-target Clippy and the existing format gate. Preserve all 292 prior core names and compare actual outcomes, rather than merely subtracting the old 16 failures. The six `language::nesting_tests` and ten `source_files::transaction_tests` formerly stopped at schema admission; their newly reached assertions matter. Transactions are a **library module**, not a separate integration target. Keep all private acceptance and existing stack controls in the full library suite. Existing `persistence::source_save_tests` must continue refusing malformed, lossy and migrating generated output before staging. +2. Run these existing complete integration targets, each with `cargo test --locked --offline -p oa-core --test TARGET -- --test-threads=1`: `source_project`, `source_identity_updates`, `source_nested_updates`, `source_files`, and `r3_migration`. +3. Run `cargo test --locked --offline -p oa-core --test review_regressions checked_save_ -- --test-threads=1`. Inventory must contain exactly the three checked-save functions below. The rest of that large integration target is not required just to establish this compatibility repair. +4. Run the named source7 migration/update test below after repairing its stale fixture assumption, using `--test source7_contract source7_source_bundle_migration_is_token_only_and_new_link_stays_with_caller -- --exact --test-threads=1` after the common Cargo prefix. +5. Build only the actual non-test consumer with `cargo build --locked --offline -p oa-cli --bin arcadia`, then perform the read-only commands below. `crates/oa-cli/Cargo.toml` defines binary `arcadia`; do not guess an `oa-cli.exe` filename. Record the resulting executable's actual path/hash and source/environment binding. + +These targets are Cargo's ordinary `tests/*.rs` integration targets; core Cargo.toml does not require a special feature. Selecting complete related targets avoids silently omitting newly reached assertions while limiting separate test binaries. The CLI integration target `source_cli` is useful existing coverage but is not a prerequisite for this minimal set: its tests also perform saves. It is not a substitute for the requested actual read-only schema8 consumer invocation. + +## What the integration targets establish + +| Target | Source-backed discriminating names and purpose | +| --- | --- | +| `source_project` | `cross_file_typed_ports_global_forward_references_and_stable_ids`; `advisory_lint_locations_refer_to_raw_drafts_before_identity_stabilization`; `source_errors_keep_exact_fragment_unicode_positions`; `generated_id_insertion_handles_adjacent_header_tokens_and_remains_exactly_indexed`; `model_updates_rewrite_cross_file_alias_uses_preserve_ownership_and_untouched_comments`; `failed_update_preserves_candidate_and_rejects_stale_index`; `scalar_header_guard_and_project_edits_preserve_exact_crlf_trivia_and_escape_spelling`; `alias_updates_touch_only_header_and_reference_tokens_even_with_comments_after_at`. Also covers includes, aggregate admission, canonical export and whole-model updates. | +| `source_identity_updates` | All three: `identity_and_alias_edit_keep_authored_file_and_reference_rationale`, `identity_swap_and_reorder_keep_both_declarations_and_item_comments_with_origin`, `provenance_cannot_merge_records_or_cross_record_classes`. | +| `source_nested_updates` | Includes `nested_scalar_edits_touch_only_authored_tokens`, `cross_file_move_carries_attached_comments_and_subtree_but_leaves_gap_notes`, `nested_uuid_alias_swap_and_cross_file_move_follow_command_provenance`, `nested_typed_reference_list_updates_keep_item_rationale_while_port_moves`, `crlf_moved_and_new_children_preserve_authored_and_destination_line_endings`, and `deep_structural_writeback_runs_on_a_small_thread_stack`; other cases cover reparenting, deletion, lexical ownership and nonoverlapping edits. | +| `source_files` | `loading_keeps_original_no_uuid_bytes_and_saving_stabilizes_exactly_once`; `discovery_never_refreshes_drafts_and_preserves_detached_buffers`; `unchanged_dependency_edits_and_deletions_block_save_before_any_write`; `new_destinations_require_explicit_missing_expectations_and_reject_collisions`; `forged_compiled_model_or_index_cannot_be_saved`; actual aggregate/path/hard-link safeguards. Unix-only symlink, named-pipe and permission tests are excluded by cfg on Windows: do not claim they ran. | +| `r3_migration` | In particular `authored_v4_modules_upgrade_only_the_version_and_preserve_nested_comments`, which recompiles migrated bytes idempotently and preserves the caller's draft; `frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics`; `older_headers_cannot_admit_new_semantic_baselines`; `original_v1_v2_v3_inputs_complete_the_explicit_upgrade_to_five`. Current source3–7 coverage must additionally come from the new focused regression; a historical function name is not a current output-schema assertion. | + +The three `review_regressions.rs:454..` functions are `checked_save_returns_exact_bytes_and_accepts_unchanged_external_content`, `checked_save_rejects_external_changes_and_preserves_their_exact_bytes`, and `checked_save_rejects_external_deletion_without_recreating_the_file`. **Each loops over `project.arcadia` then `project.oa.json` in that order.** A successful function must now reach its second JSON branch. They check exact returned/disk bytes, whole decoded model, unchanged repeat, external edit preservation and deletion refusal. Previously failing first-source behavior could mask JSON behavior; do not count an early source failure as JSON evidence. + +Concrete static issue: `source7_contract.rs:1035` creates current formatter output, then attempts to replace literal `arcadia 7;` with a commented schema6 header. It also expects migration to literal ` 7;`. Current formatter output is schema8, so the initial replacement does not downgrade it and the later migration unwrap is unsupported. Repair the fixture explicitly to construct old6 from the actual current header and expect current-schema output, retaining exact comments/module bytes, whole-model equality, relation ownership and recompile checks. This is an evaluator correction, not permission to remove the test or weaken migration behavior. Report any further newly reached stale expectations individually. + +## Actual read-only CLI oracle + +Create a fresh isolated fixture directory outside source, with exactly three UTF-8 files without BOM. Each shown `\r\n` denotes actual CRLF; use byte writes so shell newline handling cannot change the oracle. UUID literals below are complete. + +```text +project.arcadia: +// 雨\r\narcadia 8;\r\nproject p "Project" id "00000000-0000-0000-0000-000000000001" {\r\ninclude "participants.arcadia"; include "children.arcadia";\r\n}\r\n + +participants.arcadia: +// @team remains documentation\r\noa_entity team "Team @team" id "00000000-0000-0000-0000-000000000002" {}\r\n + +children.arcadia: +oa_entity child "Child" id "00000000-0000-0000-0000-000000000003" { parent @team; }\r\n +``` + +Run the built executable (absolute path) twice, capturing exact argv, exit status, stdout and stderr: + +```text +arcadia.exe check --json +arcadia.exe rename-alias team rescue_team --json +``` + +These are actual `arguments()` forms in `crates/oa-cli/src/lib.rs`, dispatched by `main.rs`. Neither includes `--write`. Explicit IDs remove random UUID allocation from the expected report. + +Expected common report fields: `format_version=1`, supplied `entry` path, `exit_code=0`, `written=false`, `identities_to_stabilize=0`, `migration=null`, and no diagnostics for these named ordinary entities. Check reports `operation="check"`, `status="checked"`, `changes=[]`. Rename reports `operation="rename-alias"`, `status="preview"` and exactly two changes ordered by path: `children.arcadia`, `participants.arcadia`. Each `before` must equal its complete original literal. The complete expected `after` is the same literal with only `parent @team;` changed to `parent @rescue_team;` in children and only the declaration `oa_entity team ` changed to `oa_entity rescue_team ` in participants. The comment and display-name `@team` remain byte-identical. No entry-file change is permitted. Check the human diff reflects those same edits; complete `after` bytes, not diff presence, are the decisive oracle. Notes are explanatory implementation text and do not authorize a write. + +Before either invocation record sorted directory inventory and every file's full bytes/length/SHA256. Compare all three actual files and the complete directory inventory immediately after **each** invocation; report output is not proof of unchanged input. In particular `project.arcadia` remains identical both on disk and absent from reported changes. Keep captures outside the fixture directory so they cannot confuse this check. + +The CLI JSON schema does **not** expose the whole resolved Project. Do not invent such an assertion from report fields. Semantic expectation is unchanged project UUID/name, unchanged entity UUIDs/names/parent identity, with only ID2's alias becoming `rescue_team`. The existing whole-model integration assertions provide the supporting model evidence (`source_project` updates and identity tests). If a candidate-specific CLI-result whole-Project equality is required, add a small parent-owned test through existing public compile APIs that assembles the literal reported candidate and compares a fully authored Project; keep it distinct from the non-test CLI invocation and do not add a production export command. Existing `oa-cli/tests/source_cli.rs::alias_rename_across_modules_changes_only_live_tokens_and_retains_all_identity` demonstrates that model check, but also writes and uses a legacy schema7 setup; it is not the read-only current8 fixture itself. + +## Admission and limits + +Retain initial failures and exact source/test changes separately from repaired outcomes. List and execute on the same frozen candidate; retain receipt inputs, Git/disk equality, launchers/environment, executable hashes and raw outcomes. Investigate newly exposed JSON-save or transaction errors at their own layer. Full ordinary source8 compatibility does not imply support for analysis constructors, typed source syntax, complete typed formatting, depth128 qualification, or publication. Preserve `DEPTH_128_VALIDATED=false`, existing parser/storage/depth policies and the full-pipeline small-stack limitation. Linux remains user-deferred; cfg-excluded tests are not Windows passes. This plan adds no workspace-wide build and makes no acceptance claim. diff --git a/harness/experiments/ordinary-source8-20260925/checker-first-refusal.log b/harness/experiments/ordinary-source8-20260925/checker-first-refusal.log new file mode 100644 index 00000000..6d386f51 --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/checker-first-refusal.log @@ -0,0 +1,5 @@ +Traceback (most recent call last): + File "C:\Users\User\Documents\Git\ARCADIA-Studio\.local\ordinary-source8-review-20260925\inspect_runtime.py", line 354, in + assert (fixture / name).read_bytes() == text.encode() + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +AssertionError diff --git a/harness/experiments/ordinary-source8-20260925/evidence.zip b/harness/experiments/ordinary-source8-20260925/evidence.zip new file mode 100644 index 00000000..d7ef85c0 Binary files /dev/null and b/harness/experiments/ordinary-source8-20260925/evidence.zip differ diff --git a/harness/experiments/ordinary-source8-20260925/inspect_runtime.py b/harness/experiments/ordinary-source8-20260925/inspect_runtime.py new file mode 100644 index 00000000..0457d1f1 --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/inspect_runtime.py @@ -0,0 +1,510 @@ +"""Read-only ordinary source8 gate reconciliation. Run only after the final gates, integration suites and CLI captures. + +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 +assert expected_added == 6, 'Selected ordinary compatibility contract adds six tests' +base = Path(__file__).resolve().parents[2] +root = base / '.local/as3batch' +directory = base / '.local/ordinary-source8-gates-20260925' +prior = base / '.local/analysis-output-acceptance-gates-20260925' +destination = Path(__file__).with_name('ORDINARY-RUNTIME-READBACK.json') +assert not destination.exists(), 'Preserve prior readback; do not overwrite' +BASELINE = 'edf096cd33350865ecfc3c65ec266a6c0d3c4000' +ARCHIVE_SHA = '2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4' +COMPONENT = '0c07f53ab517626f536f79dbaa2885a587bf1db7' +FINAL_LAUNCHER = 'c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8' +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 identifier. + 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-output-acceptance-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'acceptance-{mode}-edf096c-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) == 292 and old['exit'] == 101 +assert sum(v == 'ok' for _, v in old_rows) == 276 +assert sum(v == 'FAILED' for _, v in old_rows) == 16 +old_out = dict(old_rows) +renames = { + 'language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public8': + 'language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public_typed8', + 'language::analysis_source::tests::public_source_headers_and_existing_numeric_token_controls_are_unchanged': + 'language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls', +} +assert set(renames) <= set(old_out) and not set(renames.values()) & set(old_out) +mapped_old = {renames.get(name, name): status for name, status in old_out.items()} +assert len(mapped_old) == len(old_out) +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) + +changed_paths = git('diff', '--name-only', COMPONENT, source).decode().splitlines() +assert sorted(changed_paths) == ['crates/oa-core/tests/r3_migration.rs', 'harness/ordinary-source8-compatibility-implementation-20260925.md'] +assert git('ls-tree', '-r', '--name-only', COMPONENT, *scope).decode().splitlines() == paths +component_inputs = [] +for item in expected_inputs: + if item['path'] == 'crates/oa-core/tests/r3_migration.rs': + content = git('show', COMPONENT + ':' + item['path']) + component_inputs.append({'path': item['path'], 'bytes': len(content), 'sha256': sha(content)}) + else: + component_inputs.append(item) +assert [a['path'] for a, b in zip(component_inputs, expected_inputs) if a != b] == ['crates/oa-core/tests/r3_migration.rs'] +assert len(expected_inputs) == 560 and len(component_inputs) == 560 + +prefix = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--lib'] +commands = { + 'focused': prefix + ['ordinary_source8', '--', '--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 +current_env = expected_env.copy() +verified, all_receipts, raw_logs = {}, {}, {} +artifact_identity = launcher_identity = None +for mode, command in commands.items(): + name = f'ordinary-{mode}-{COMPONENT[:7]}-1' + data, raw, receipt_raw = receipt(directory, name) + assert data['source'] == data['head_after'] == COMPONENT + assert data['mode'] == mode and data['command'] == command + assert data['invocation'] == 'cargo' and data['test_target'] is None + assert data['filter'] == ('ordinary_source8' 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': COMPONENT, 'inputs': component_inputs} + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] + assert COMPONENT.encode() in launcher + if launcher_identity is None: + launcher_identity = sha(launcher) + assert sha(launcher) == launcher_identity, 'Unexpected mixed launchers: review explicitly' + assert sha(launcher) == 'ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765', 'Review any final launcher successor before execution' + 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]) == (291 if mode == 'focused' else 0) + else: + assert not rows + assert data['exit'] == {'focused': 0, 'full': 0, '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': COMPONENT, '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) == 292 + expected_added +assert not set(renames) & set(new_out), 'Old names must be replaced only by the two exact authorized names' +assert all(new_out.get(k) == 'ok' for k in mapped_old), 'Every prior mapped name must pass, including all 16 former failures' +added = set(new_out) - set(mapped_old) +assert len(added) == expected_added +assert all(new_out[k] == 'ok' and 'ordinary_source8' in k for k in added) +focused_control = 'language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls' +assert focused_control in renames.values() and focused_control not in added +assert set(dict(all_receipts['focused']['outcomes'])) == added | {focused_control} +assert len(all_receipts['focused']['outcomes']) == 7 +assert all(status == 'ok' for _, status in all_receipts['focused']['outcomes']) +assert set(all_receipts['list']['listing_members']) == set(new_out) +old_blocks = failure_blocks(old_raw) +assert len(old_blocks) == 16 and set(old_blocks) == {k for k, v in old_out.items() if v == 'FAILED'} +assert not failure_blocks(raw_logs['full']) +assert all(value == 'ok' for value in new_out.values()) +assert raw_logs['fmt'] == baseline['fmt'][1] + + +def additional(name, mode, command, target=None, selected_filter='', *, checkpoint=COMPONENT, exit_code=0, artifact_count=1, current_artifact=True, allow_failures=False): + data, raw, raw_receipt = receipt(directory, name) + assert data['source'] == data['head_after'] == checkpoint + assert data['mode'] == mode and data['command'] == command + assert data['filter'] == selected_filter and data['test_target'] == target + assert data['invocation'] == 'cargo' and data['cwd'] == str(root) + assert data['environment'] == current_env and data['exit'] == exit_code + assert not data['changed_inputs'] + assert not data['verification_failures'] or allow_failures + manifest_raw = within(directory, data['inputs']).read_bytes() + assert sha(manifest_raw) == data['inputs_sha256'] + assert json.loads(manifest_raw) == {'source': checkpoint, 'inputs': expected_inputs if checkpoint == source else component_inputs} + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] == (FINAL_LAUNCHER if checkpoint == source else launcher_identity) + assert outcomes(raw) == [tuple(x) for x in data['outcomes']] + assert len(data['artifacts']) == artifact_count + artifact = data['artifacts'][0] if artifact_count else None + if artifact is not None and current_artifact: + path = Path(artifact['path']) + assert path.resolve().is_relative_to(Path(current_env['CARGO_TARGET_DIR']).resolve()) + actual = path.read_bytes() + assert len(actual) == artifact['bytes'] and sha(actual) == artifact['sha256'] + verified[name] = {'result_sha256': sha(raw_receipt), 'log_sha256': sha(raw), + 'inputs_sha256': sha(manifest_raw), 'artifact': artifact} + return data, raw + + +suites = { + 'source_project': '', 'source_identity_updates': '', 'source_nested_updates': '', + 'source_files': '', 'r3_migration': '', 'review_regressions': 'checked_save_', + 'source7_contract': 'source7_source_bundle_migration_is_token_only_and_new_link_stays_with_caller', +} +integration_counts = {} +for target, selected_filter in suites.items(): + selected = {} + for mode in ('integration-list', 'integration-suite'): + command = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--test', target] + if selected_filter: + command.append(selected_filter) + command += ['--', '--list' if mode == 'integration-list' else '--test-threads=1'] + if target == 'source7_contract': + command.append('--exact') + checkpoint = source if target == 'r3_migration' else COMPONENT + data, raw = additional(f'ordinary-{mode}-{target}-{checkpoint[:7]}-1', mode, command, target, selected_filter, checkpoint=checkpoint) + assert Path(data['artifacts'][0]['path']).name.startswith(target + '-') + running = re.findall(r'Running [^\r\n]+ \(([^\r\n]+\.exe)\)', raw.decode()) + assert len(running) == 1 + assert (root / running[0]).resolve() == Path(data['artifacts'][0]['path']).resolve() + listed = members(raw) if mode == 'integration-list' else [] + assert data['listing_members'] == listed and data['listing_count'] == len(listed) + if mode == 'integration-list': + assert listed and not outcomes(raw) + else: + rows = outcomes(raw) + assert rows and all(status == 'ok' for _, status in rows) + assert not failure_blocks(raw) + summary = re.findall(r'^test result: ok\. (\d+) passed; 0 failed; 0 ignored; 0 measured; \d+ filtered out;', raw.decode(), re.M) + assert summary == [str(len(rows))] + selected[mode] = data + listing, suite = selected['integration-list'], selected['integration-suite'] + assert listing['artifacts'] == suite['artifacts'] + assert set(listing['listing_members']) == {name for name, _ in suite['outcomes']} + if target == 'review_regressions': + assert set(listing['listing_members']) == { + 'checked_save_returns_exact_bytes_and_accepts_unchanged_external_content', + 'checked_save_rejects_external_changes_and_preserves_their_exact_bytes', + 'checked_save_rejects_external_deletion_without_recreating_the_file'} + if target == 'source7_contract': + assert listing['listing_members'] == [selected_filter] + integration_counts[target] = len(suite['outcomes']) + +old_r3 = {} +for mode in ('integration-list', 'integration-suite'): + command = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--test', 'r3_migration', + '--', '--list' if mode == 'integration-list' else '--test-threads=1'] + data, raw = additional(f'ordinary-{mode}-r3_migration-0c07f53-1', mode, command, 'r3_migration', + exit_code=0 if mode == 'integration-list' else 101, + current_artifact=False, allow_failures=mode == 'integration-suite') + if mode == 'integration-list': + assert len(members(raw)) == 5 and members(raw) == data['listing_members'] + assert data['listing_count'] == 5 and not outcomes(raw) + else: + assert data['verification_failures'] == ['Every selected integration outcome must actually pass', + 'Expected one complete all-passed selected integration summary'] + rows = outcomes(raw) + assert len(rows) == 5 and sum(status == 'ok' for _, status in rows) == 4 + assert {name for name, status in rows if status == 'FAILED'} == {'frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics'} + assert set(failure_blocks(raw)) == {'frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics'} + assert sha(raw) == 'ee55320de5e208beb921ce219afb38db7b27c86cd64d176837c952b803a48582' + assert re.findall(r'^test result: FAILED\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('4', '1', '0', '0')] + old_r3[mode] = data +assert old_r3['integration-list']['artifacts'] == old_r3['integration-suite']['artifacts'] +assert set(old_r3['integration-list']['listing_members']) == {name for name, _ in old_r3['integration-suite']['outcomes']} +new_r3_list, _ = receipt(directory, f'ordinary-integration-list-r3_migration-{stem}-1')[:2] +assert set(new_r3_list['listing_members']) == set(old_r3['integration-list']['listing_members']) +for mode in ('clippy', 'fmt'): + data, raw = additional(f'ordinary-{mode}-{stem}-1', mode, commands[mode], checkpoint=source, + exit_code=0 if mode == 'clippy' else 1, artifact_count=0) + assert not outcomes(raw) and not data['listing_members'] and data['listing_count'] == 0 + if mode == 'fmt': + assert raw == baseline['fmt'][1] == raw_logs['fmt'] + +build_command = ['cargo', 'build', '--locked', '--offline', '-p', 'oa-cli', '--bin', 'arcadia', '--message-format=json'] +build, build_raw = additional(f'ordinary-cli-build-{COMPONENT[:7]}-1', 'cli-build', build_command) +assert not build['outcomes'] and build['listing_members'] == [] and build['listing_count'] == 0 +emitted = [] +for line in build_raw.splitlines(): + try: + row = json.loads(line) + except (json.JSONDecodeError, UnicodeDecodeError): + continue + if row.get('reason') == 'compiler-artifact' and row.get('target', {}).get('name') == 'arcadia' and row.get('executable'): + assert row['target']['kind'] == ['bin'] and not row['profile']['test'] + emitted.append(row['executable']) +assert len(emitted) == 1 and Path(emitted[0]).resolve() == Path(build['artifacts'][0]['path']).resolve() + +original = { + 'project.arcadia': '// \u96e8\r\narcadia 8;\r\nproject p "Project" id "00000000-0000-0000-0000-000000000001" {\r\ninclude "participants.arcadia"; include "children.arcadia";\r\n}\r\n', + 'participants.arcadia': '// @team remains documentation\r\noa_entity team "Team @team" id "00000000-0000-0000-0000-000000000002" {}\r\n', + 'children.arcadia': 'oa_entity child "Child" id "00000000-0000-0000-0000-000000000003" { parent @team; }\r\n', +} +expected_after = { + 'participants.arcadia': '// @team remains documentation\r\noa_entity rescue_team "Team @team" id "00000000-0000-0000-0000-000000000002" {}\r\n', + 'children.arcadia': 'oa_entity child "Child" id "00000000-0000-0000-0000-000000000003" { parent @rescue_team; }\r\n', +} +inventory = {name: {'bytes': len(text.encode()), 'sha256': sha(text.encode())} for name, text in original.items()} +fixture = directory / f'cli-fixture-{COMPONENT[:7]}' +assert sorted(p.relative_to(fixture).as_posix() for p in fixture.rglob('*')) == sorted(original) +for name, text in original.items(): + assert (fixture / name).read_bytes() == text.encode() +cli_launcher_hash = None +for operation in ('check', 'rename-alias'): + name = f'ordinary-cli-{operation}-{COMPONENT[:7]}-1' + record_raw = (directory / (name + '.cli.json')).read_bytes() + data = json.loads(record_raw) + stdout = (directory / (name + '.stdout.json')).read_bytes() + stderr = (directory / (name + '.stderr.txt')).read_bytes() + assert data['stdout_sha256'] == sha(stdout) and data['stderr_sha256'] == sha(stderr) + assert data['source'] == COMPONENT and data['build_artifact'] == build['artifacts'][0] + assert data['environment'] == current_env and data['cwd'] == str(root) + assert data['inputs'] == build['inputs'] and data['inputs_sha256'] == build['inputs_sha256'] + assert not data['changed_inputs'] and not data['verification_failures'] + assert data['exit'] == 0 and stderr == b'' + assert data['expected_input_inventory'] == data['after_inventory'] == inventory + entry = str(fixture / 'project.arcadia') + command = [build['artifacts'][0]['path'], operation, entry] + if operation == 'rename-alias': + command += ['team', 'rescue_team'] + command.append('--json') + assert data['argv'] == command + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] + if cli_launcher_hash is None: + cli_launcher_hash = sha(launcher) + assert sha(launcher) == cli_launcher_hash + assert cli_launcher_hash == '308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d' + report = json.loads(stdout) + expected = {'format_version': 1, 'entry': entry, 'operation': operation, + 'status': 'checked' if operation == 'check' else 'preview', + 'exit_code': 0, 'written': False, 'diagnostics': [], + 'identities_to_stabilize': 0, 'migration': None} + for key, value in expected.items(): + assert key in report and report[key] == value + if operation == 'check': + assert report['changes'] == [] + else: + assert [r['path'] for r in report['changes']] == ['children.arcadia', 'participants.arcadia'] + for change in report['changes']: + path = change['path'] + assert change['before'] == original[path] and change['after'] == expected_after[path] + for marker, text in [('-', original[path]), ('+', expected_after[path])]: + assert marker + next(line for line in text.splitlines() if line.startswith('oa_entity')) in change['diff'] + verified[name] = {'receipt_sha256': sha(record_raw), 'stdout_sha256': sha(stdout), + 'stderr_sha256': sha(stderr), 'launcher_sha256': sha(launcher)} + +# Preserve and account for the actual first failed focused run, not an invented baseline. +initial, initial_raw, initial_receipt = receipt(directory, 'ordinary-focused-33b86a4-1') +assert initial['source'] == initial['head_after'] == '33b86a4d6b4bc1b156a93ae3596fe0ad7b4dbbe5' +assert initial['exit'] == 101 and not initial['changed_inputs'] +initial_rows = outcomes(initial_raw) +assert initial_rows == [tuple(row) for row in initial['outcomes']] +assert len(initial_rows) == 6 and sum(v == 'ok' for _, v in initial_rows) == 5 +assert [n for n, v in initial_rows if v == 'FAILED'] == ['language::ordinary_source8::current_formatter_roundtrips_complete_ordinary_examples_and_history'] +assert set(dict(initial_rows)) == added +assert initial['command'] == commands['focused'] and initial['environment'] == current_env +assert not initial['verification_failures'] +initial_launcher = within(directory, initial['launcher_copy']).read_bytes() +assert sha(initial_launcher) == initial['launcher_sha256'] == initial['launcher_sha256_after'] == '6e2fad2fff3066861a42f85ab6c3ada8b4c8954075fb402e555c5f686dae840b' +initial_manifest_raw = within(directory, initial['inputs']).read_bytes() +assert sha(initial_manifest_raw) == initial['inputs_sha256'] +initial_manifest = json.loads(initial_manifest_raw) +assert initial_manifest['source'] == initial['source'] +initial_paths = git('ls-tree', '-r', '--name-only', initial['source'], *scope).decode().splitlines() +assert initial_paths == [item['path'] for item in initial_manifest['inputs']] +initial_blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root, + input=''.join(f"{initial['source']}:{p}\n" for p in initial_paths).encode()) +offset = 0 +for item in initial_manifest['inputs']: + end = initial_blobs.index(b'\n', offset) + _, kind, size = initial_blobs[offset:end].split() + size = int(size) + raw = initial_blobs[end + 1:end + 1 + size] + assert kind == b'blob' and size == item['bytes'] and sha(raw) == item['sha256'] + offset = end + size + 2 +assert offset == len(initial_blobs) +assert b'assertion failed: !example.traces.is_empty()' in initial_raw +initial_failure = {'source': initial['source'], 'receipt_sha256': sha(initial_receipt), + 'log_sha256': sha(initial_raw), 'passed': 5, 'failed': 1} + +intermediate_source = '520e50ce62f067dff69f03760c8b12929df9b920' +intermediate_failures = { + *renames, + 'language::analysis_source::lower::tests::staged_oa_and_sa_lowering_match_complete_independent_17_uuid_oracles', + 'language::analysis_source::write::tests::typed_oa_sa_canonical_roundtrips_match_independent_projects', +} +intermediate = {} +intermediate_artifact = None +for mode in ('focused', 'full', 'list'): + name = f'ordinary-{mode}-520e50c-1' + data, raw, raw_receipt = receipt(directory, name) + assert data['source'] == data['head_after'] == intermediate_source + assert data['command'] == commands[mode] and data['mode'] == mode + assert data['environment'] == current_env and data['cwd'] == str(root) + assert not data['changed_inputs'] and not data['verification_failures'] + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] == '59104b1acd39b3981b7339e585af9bd7f9cb87865ee82ffb763f0e7ce527713c' + manifest_raw = within(directory, data['inputs']).read_bytes() + assert sha(manifest_raw) == data['inputs_sha256'] + manifest = json.loads(manifest_raw) + assert manifest['source'] == intermediate_source + historic_paths = git('ls-tree', '-r', '--name-only', intermediate_source, *scope).decode().splitlines() + assert historic_paths == [item['path'] for item in manifest['inputs']] + historic_blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root, + input=''.join(f'{intermediate_source}:{p}\n' for p in historic_paths).encode()) + offset = 0 + for item in manifest['inputs']: + end = historic_blobs.index(b'\n', offset) + _, kind, size = historic_blobs[offset:end].split() + size = int(size) + content = historic_blobs[end + 1:end + 1 + size] + assert kind == b'blob' and size == item['bytes'] and sha(content) == item['sha256'] + offset = end + size + 2 + assert offset == len(historic_blobs) + assert len(data['artifacts']) == 1 + if intermediate_artifact is None: + intermediate_artifact = data['artifacts'][0] + assert data['artifacts'] == [intermediate_artifact] + rows = outcomes(raw) + assert rows == [tuple(row) for row in data['outcomes']] + if mode == 'focused': + assert data['exit'] == 0 and dict(rows) == {name: 'ok' for name in added} + assert re.findall(r'^test result: ok\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('6', '0', '0', '292')] + elif mode == 'full': + assert data['exit'] == 101 and len(rows) == 298 + assert {name for name, status in rows if status == 'FAILED'} == intermediate_failures + assert sum(status == 'ok' for _, status in rows) == 294 + assert set(dict(rows)) == set(old_out) | added + assert all(dict(rows)[name] == 'ok' for name, status in old_out.items() if status == 'FAILED') + assert set(failure_blocks(raw)) == intermediate_failures + assert re.findall(r'^test result: FAILED\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('294', '4', '0', '0')] + else: + assert data['exit'] == 0 and not rows + assert members(raw) == data['listing_members'] and data['listing_count'] == 298 + assert set(members(raw)) == set(old_out) | added + intermediate[name] = {'receipt_sha256': sha(raw_receipt), 'log_sha256': sha(raw), + 'inputs_sha256': sha(manifest_raw), 'exit': data['exit']} + +result = {'source': source, 'baseline': BASELINE, 'baseline_archive_sha256': ARCHIVE_SHA, + 'checker_sha256': sha(Path(__file__).read_bytes()), 'inputs': len(expected_inputs), + 'focused_passed': 7, 'focused_existing_renamed_control': focused_control, + 'prior_passes_preserved': 276, 'prior_failures_now_passed': 16, 'added_passed': expected_added, 'added_names': sorted(added), + 'full_passed': sum(v == 'ok' for v in new_out.values()), 'full_failed': 0, + 'former_failure_names': sorted(old_blocks), + 'identical_fmt_sha256': sha(raw_logs['fmt']), 'artifact': artifact_identity, + 'environment': current_env, 'baseline_environment': expected_env, + 'receipts': verified, 'integration_pass_counts': integration_counts, + 'component_source': COMPONENT, 'reused_component_inputs': len(component_inputs), + 'successor_only_declared_delta': 'crates/oa-core/tests/r3_migration.rs', + 'old_r3_recorded_artifact': old_r3['integration-suite']['artifacts'][0], + 'cli_artifact': build['artifacts'][0], 'initial_failed_run': initial_failure, + 'exact_authorized_name_mapping': renames, 'intermediate_520_records': intermediate, + 'intermediate_recorded_artifact': intermediate_artifact, + '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/ordinary-source8-20260925/inspect_runtime_encoding_original.py b/harness/experiments/ordinary-source8-20260925/inspect_runtime_encoding_original.py new file mode 100644 index 00000000..3162ebfa --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/inspect_runtime_encoding_original.py @@ -0,0 +1,510 @@ +"""Read-only ordinary source8 gate reconciliation. Run only after the final gates, integration suites and CLI captures. + +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 +assert expected_added == 6, 'Selected ordinary compatibility contract adds six tests' +base = Path(__file__).resolve().parents[2] +root = base / '.local/as3batch' +directory = base / '.local/ordinary-source8-gates-20260925' +prior = base / '.local/analysis-output-acceptance-gates-20260925' +destination = Path(__file__).with_name('ORDINARY-RUNTIME-READBACK.json') +assert not destination.exists(), 'Preserve prior readback; do not overwrite' +BASELINE = 'edf096cd33350865ecfc3c65ec266a6c0d3c4000' +ARCHIVE_SHA = '2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4' +COMPONENT = '0c07f53ab517626f536f79dbaa2885a587bf1db7' +FINAL_LAUNCHER = 'c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8' +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 identifier. + 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-output-acceptance-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'acceptance-{mode}-edf096c-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) == 292 and old['exit'] == 101 +assert sum(v == 'ok' for _, v in old_rows) == 276 +assert sum(v == 'FAILED' for _, v in old_rows) == 16 +old_out = dict(old_rows) +renames = { + 'language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public8': + 'language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public_typed8', + 'language::analysis_source::tests::public_source_headers_and_existing_numeric_token_controls_are_unchanged': + 'language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls', +} +assert set(renames) <= set(old_out) and not set(renames.values()) & set(old_out) +mapped_old = {renames.get(name, name): status for name, status in old_out.items()} +assert len(mapped_old) == len(old_out) +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) + +changed_paths = git('diff', '--name-only', COMPONENT, source).decode().splitlines() +assert sorted(changed_paths) == ['crates/oa-core/tests/r3_migration.rs', 'harness/ordinary-source8-compatibility-implementation-20260925.md'] +assert git('ls-tree', '-r', '--name-only', COMPONENT, *scope).decode().splitlines() == paths +component_inputs = [] +for item in expected_inputs: + if item['path'] == 'crates/oa-core/tests/r3_migration.rs': + content = git('show', COMPONENT + ':' + item['path']) + component_inputs.append({'path': item['path'], 'bytes': len(content), 'sha256': sha(content)}) + else: + component_inputs.append(item) +assert [a['path'] for a, b in zip(component_inputs, expected_inputs) if a != b] == ['crates/oa-core/tests/r3_migration.rs'] +assert len(expected_inputs) == 560 and len(component_inputs) == 560 + +prefix = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--lib'] +commands = { + 'focused': prefix + ['ordinary_source8', '--', '--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 +current_env = expected_env.copy() +verified, all_receipts, raw_logs = {}, {}, {} +artifact_identity = launcher_identity = None +for mode, command in commands.items(): + name = f'ordinary-{mode}-{COMPONENT[:7]}-1' + data, raw, receipt_raw = receipt(directory, name) + assert data['source'] == data['head_after'] == COMPONENT + assert data['mode'] == mode and data['command'] == command + assert data['invocation'] == 'cargo' and data['test_target'] is None + assert data['filter'] == ('ordinary_source8' 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': COMPONENT, 'inputs': component_inputs} + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] + assert COMPONENT.encode() in launcher + if launcher_identity is None: + launcher_identity = sha(launcher) + assert sha(launcher) == launcher_identity, 'Unexpected mixed launchers: review explicitly' + assert sha(launcher) == 'ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765', 'Review any final launcher successor before execution' + 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]) == (291 if mode == 'focused' else 0) + else: + assert not rows + assert data['exit'] == {'focused': 0, 'full': 0, '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': COMPONENT, '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) == 292 + expected_added +assert not set(renames) & set(new_out), 'Old names must be replaced only by the two exact authorized names' +assert all(new_out.get(k) == 'ok' for k in mapped_old), 'Every prior mapped name must pass, including all 16 former failures' +added = set(new_out) - set(mapped_old) +assert len(added) == expected_added +assert all(new_out[k] == 'ok' and 'ordinary_source8' in k for k in added) +focused_control = 'language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls' +assert focused_control in renames.values() and focused_control not in added +assert set(dict(all_receipts['focused']['outcomes'])) == added | {focused_control} +assert len(all_receipts['focused']['outcomes']) == 7 +assert all(status == 'ok' for _, status in all_receipts['focused']['outcomes']) +assert set(all_receipts['list']['listing_members']) == set(new_out) +old_blocks = failure_blocks(old_raw) +assert len(old_blocks) == 16 and set(old_blocks) == {k for k, v in old_out.items() if v == 'FAILED'} +assert not failure_blocks(raw_logs['full']) +assert all(value == 'ok' for value in new_out.values()) +assert raw_logs['fmt'] == baseline['fmt'][1] + + +def additional(name, mode, command, target=None, selected_filter='', *, checkpoint=COMPONENT, exit_code=0, artifact_count=1, current_artifact=True, allow_failures=False): + data, raw, raw_receipt = receipt(directory, name) + assert data['source'] == data['head_after'] == checkpoint + assert data['mode'] == mode and data['command'] == command + assert data['filter'] == selected_filter and data['test_target'] == target + assert data['invocation'] == 'cargo' and data['cwd'] == str(root) + assert data['environment'] == current_env and data['exit'] == exit_code + assert not data['changed_inputs'] + assert not data['verification_failures'] or allow_failures + manifest_raw = within(directory, data['inputs']).read_bytes() + assert sha(manifest_raw) == data['inputs_sha256'] + assert json.loads(manifest_raw) == {'source': checkpoint, 'inputs': expected_inputs if checkpoint == source else component_inputs} + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] == (FINAL_LAUNCHER if checkpoint == source else launcher_identity) + assert outcomes(raw) == [tuple(x) for x in data['outcomes']] + assert len(data['artifacts']) == artifact_count + artifact = data['artifacts'][0] if artifact_count else None + if artifact is not None and current_artifact: + path = Path(artifact['path']) + assert path.resolve().is_relative_to(Path(current_env['CARGO_TARGET_DIR']).resolve()) + actual = path.read_bytes() + assert len(actual) == artifact['bytes'] and sha(actual) == artifact['sha256'] + verified[name] = {'result_sha256': sha(raw_receipt), 'log_sha256': sha(raw), + 'inputs_sha256': sha(manifest_raw), 'artifact': artifact} + return data, raw + + +suites = { + 'source_project': '', 'source_identity_updates': '', 'source_nested_updates': '', + 'source_files': '', 'r3_migration': '', 'review_regressions': 'checked_save_', + 'source7_contract': 'source7_source_bundle_migration_is_token_only_and_new_link_stays_with_caller', +} +integration_counts = {} +for target, selected_filter in suites.items(): + selected = {} + for mode in ('integration-list', 'integration-suite'): + command = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--test', target] + if selected_filter: + command.append(selected_filter) + command += ['--', '--list' if mode == 'integration-list' else '--test-threads=1'] + if target == 'source7_contract': + command.append('--exact') + checkpoint = source if target == 'r3_migration' else COMPONENT + data, raw = additional(f'ordinary-{mode}-{target}-{checkpoint[:7]}-1', mode, command, target, selected_filter, checkpoint=checkpoint) + assert Path(data['artifacts'][0]['path']).name.startswith(target + '-') + running = re.findall(r'Running [^\r\n]+ \(([^\r\n]+\.exe)\)', raw.decode()) + assert len(running) == 1 + assert (root / running[0]).resolve() == Path(data['artifacts'][0]['path']).resolve() + listed = members(raw) if mode == 'integration-list' else [] + assert data['listing_members'] == listed and data['listing_count'] == len(listed) + if mode == 'integration-list': + assert listed and not outcomes(raw) + else: + rows = outcomes(raw) + assert rows and all(status == 'ok' for _, status in rows) + assert not failure_blocks(raw) + summary = re.findall(r'^test result: ok\. (\d+) passed; 0 failed; 0 ignored; 0 measured; \d+ filtered out;', raw.decode(), re.M) + assert summary == [str(len(rows))] + selected[mode] = data + listing, suite = selected['integration-list'], selected['integration-suite'] + assert listing['artifacts'] == suite['artifacts'] + assert set(listing['listing_members']) == {name for name, _ in suite['outcomes']} + if target == 'review_regressions': + assert set(listing['listing_members']) == { + 'checked_save_returns_exact_bytes_and_accepts_unchanged_external_content', + 'checked_save_rejects_external_changes_and_preserves_their_exact_bytes', + 'checked_save_rejects_external_deletion_without_recreating_the_file'} + if target == 'source7_contract': + assert listing['listing_members'] == [selected_filter] + integration_counts[target] = len(suite['outcomes']) + +old_r3 = {} +for mode in ('integration-list', 'integration-suite'): + command = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--test', 'r3_migration', + '--', '--list' if mode == 'integration-list' else '--test-threads=1'] + data, raw = additional(f'ordinary-{mode}-r3_migration-0c07f53-1', mode, command, 'r3_migration', + exit_code=0 if mode == 'integration-list' else 101, + current_artifact=False, allow_failures=mode == 'integration-suite') + if mode == 'integration-list': + assert len(members(raw)) == 5 and members(raw) == data['listing_members'] + assert data['listing_count'] == 5 and not outcomes(raw) + else: + assert data['verification_failures'] == ['Every selected integration outcome must actually pass', + 'Expected one complete all-passed selected integration summary'] + rows = outcomes(raw) + assert len(rows) == 5 and sum(status == 'ok' for _, status in rows) == 4 + assert {name for name, status in rows if status == 'FAILED'} == {'frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics'} + assert set(failure_blocks(raw)) == {'frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics'} + assert sha(raw) == 'ee55320de5e208beb921ce219afb38db7b27c86cd64d176837c952b803a48582' + assert re.findall(r'^test result: FAILED\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('4', '1', '0', '0')] + old_r3[mode] = data +assert old_r3['integration-list']['artifacts'] == old_r3['integration-suite']['artifacts'] +assert set(old_r3['integration-list']['listing_members']) == {name for name, _ in old_r3['integration-suite']['outcomes']} +new_r3_list, _ = receipt(directory, f'ordinary-integration-list-r3_migration-{stem}-1')[:2] +assert set(new_r3_list['listing_members']) == set(old_r3['integration-list']['listing_members']) +for mode in ('clippy', 'fmt'): + data, raw = additional(f'ordinary-{mode}-{stem}-1', mode, commands[mode], checkpoint=source, + exit_code=0 if mode == 'clippy' else 1, artifact_count=0) + assert not outcomes(raw) and not data['listing_members'] and data['listing_count'] == 0 + if mode == 'fmt': + assert raw == baseline['fmt'][1] == raw_logs['fmt'] + +build_command = ['cargo', 'build', '--locked', '--offline', '-p', 'oa-cli', '--bin', 'arcadia', '--message-format=json'] +build, build_raw = additional(f'ordinary-cli-build-{COMPONENT[:7]}-1', 'cli-build', build_command) +assert not build['outcomes'] and build['listing_members'] == [] and build['listing_count'] == 0 +emitted = [] +for line in build_raw.splitlines(): + try: + row = json.loads(line) + except (json.JSONDecodeError, UnicodeDecodeError): + continue + if row.get('reason') == 'compiler-artifact' and row.get('target', {}).get('name') == 'arcadia' and row.get('executable'): + assert row['target']['kind'] == ['bin'] and not row['profile']['test'] + emitted.append(row['executable']) +assert len(emitted) == 1 and Path(emitted[0]).resolve() == Path(build['artifacts'][0]['path']).resolve() + +original = { + 'project.arcadia': '// 雨\r\narcadia 8;\r\nproject p "Project" id "00000000-0000-0000-0000-000000000001" {\r\ninclude "participants.arcadia"; include "children.arcadia";\r\n}\r\n', + 'participants.arcadia': '// @team remains documentation\r\noa_entity team "Team @team" id "00000000-0000-0000-0000-000000000002" {}\r\n', + 'children.arcadia': 'oa_entity child "Child" id "00000000-0000-0000-0000-000000000003" { parent @team; }\r\n', +} +expected_after = { + 'participants.arcadia': '// @team remains documentation\r\noa_entity rescue_team "Team @team" id "00000000-0000-0000-0000-000000000002" {}\r\n', + 'children.arcadia': 'oa_entity child "Child" id "00000000-0000-0000-0000-000000000003" { parent @rescue_team; }\r\n', +} +inventory = {name: {'bytes': len(text.encode()), 'sha256': sha(text.encode())} for name, text in original.items()} +fixture = directory / f'cli-fixture-{COMPONENT[:7]}' +assert sorted(p.relative_to(fixture).as_posix() for p in fixture.rglob('*')) == sorted(original) +for name, text in original.items(): + assert (fixture / name).read_bytes() == text.encode() +cli_launcher_hash = None +for operation in ('check', 'rename-alias'): + name = f'ordinary-cli-{operation}-{COMPONENT[:7]}-1' + record_raw = (directory / (name + '.cli.json')).read_bytes() + data = json.loads(record_raw) + stdout = (directory / (name + '.stdout.json')).read_bytes() + stderr = (directory / (name + '.stderr.txt')).read_bytes() + assert data['stdout_sha256'] == sha(stdout) and data['stderr_sha256'] == sha(stderr) + assert data['source'] == COMPONENT and data['build_artifact'] == build['artifacts'][0] + assert data['environment'] == current_env and data['cwd'] == str(root) + assert data['inputs'] == build['inputs'] and data['inputs_sha256'] == build['inputs_sha256'] + assert not data['changed_inputs'] and not data['verification_failures'] + assert data['exit'] == 0 and stderr == b'' + assert data['expected_input_inventory'] == data['after_inventory'] == inventory + entry = str(fixture / 'project.arcadia') + command = [build['artifacts'][0]['path'], operation, entry] + if operation == 'rename-alias': + command += ['team', 'rescue_team'] + command.append('--json') + assert data['argv'] == command + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] + if cli_launcher_hash is None: + cli_launcher_hash = sha(launcher) + assert sha(launcher) == cli_launcher_hash + assert cli_launcher_hash == '308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d' + report = json.loads(stdout) + expected = {'format_version': 1, 'entry': entry, 'operation': operation, + 'status': 'checked' if operation == 'check' else 'preview', + 'exit_code': 0, 'written': False, 'diagnostics': [], + 'identities_to_stabilize': 0, 'migration': None} + for key, value in expected.items(): + assert key in report and report[key] == value + if operation == 'check': + assert report['changes'] == [] + else: + assert [r['path'] for r in report['changes']] == ['children.arcadia', 'participants.arcadia'] + for change in report['changes']: + path = change['path'] + assert change['before'] == original[path] and change['after'] == expected_after[path] + for marker, text in [('-', original[path]), ('+', expected_after[path])]: + assert marker + next(line for line in text.splitlines() if line.startswith('oa_entity')) in change['diff'] + verified[name] = {'receipt_sha256': sha(record_raw), 'stdout_sha256': sha(stdout), + 'stderr_sha256': sha(stderr), 'launcher_sha256': sha(launcher)} + +# Preserve and account for the actual first failed focused run, not an invented baseline. +initial, initial_raw, initial_receipt = receipt(directory, 'ordinary-focused-33b86a4-1') +assert initial['source'] == initial['head_after'] == '33b86a4d6b4bc1b156a93ae3596fe0ad7b4dbbe5' +assert initial['exit'] == 101 and not initial['changed_inputs'] +initial_rows = outcomes(initial_raw) +assert initial_rows == [tuple(row) for row in initial['outcomes']] +assert len(initial_rows) == 6 and sum(v == 'ok' for _, v in initial_rows) == 5 +assert [n for n, v in initial_rows if v == 'FAILED'] == ['language::ordinary_source8::current_formatter_roundtrips_complete_ordinary_examples_and_history'] +assert set(dict(initial_rows)) == added +assert initial['command'] == commands['focused'] and initial['environment'] == current_env +assert not initial['verification_failures'] +initial_launcher = within(directory, initial['launcher_copy']).read_bytes() +assert sha(initial_launcher) == initial['launcher_sha256'] == initial['launcher_sha256_after'] == '6e2fad2fff3066861a42f85ab6c3ada8b4c8954075fb402e555c5f686dae840b' +initial_manifest_raw = within(directory, initial['inputs']).read_bytes() +assert sha(initial_manifest_raw) == initial['inputs_sha256'] +initial_manifest = json.loads(initial_manifest_raw) +assert initial_manifest['source'] == initial['source'] +initial_paths = git('ls-tree', '-r', '--name-only', initial['source'], *scope).decode().splitlines() +assert initial_paths == [item['path'] for item in initial_manifest['inputs']] +initial_blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root, + input=''.join(f"{initial['source']}:{p}\n" for p in initial_paths).encode()) +offset = 0 +for item in initial_manifest['inputs']: + end = initial_blobs.index(b'\n', offset) + _, kind, size = initial_blobs[offset:end].split() + size = int(size) + raw = initial_blobs[end + 1:end + 1 + size] + assert kind == b'blob' and size == item['bytes'] and sha(raw) == item['sha256'] + offset = end + size + 2 +assert offset == len(initial_blobs) +assert b'assertion failed: !example.traces.is_empty()' in initial_raw +initial_failure = {'source': initial['source'], 'receipt_sha256': sha(initial_receipt), + 'log_sha256': sha(initial_raw), 'passed': 5, 'failed': 1} + +intermediate_source = '520e50ce62f067dff69f03760c8b12929df9b920' +intermediate_failures = { + *renames, + 'language::analysis_source::lower::tests::staged_oa_and_sa_lowering_match_complete_independent_17_uuid_oracles', + 'language::analysis_source::write::tests::typed_oa_sa_canonical_roundtrips_match_independent_projects', +} +intermediate = {} +intermediate_artifact = None +for mode in ('focused', 'full', 'list'): + name = f'ordinary-{mode}-520e50c-1' + data, raw, raw_receipt = receipt(directory, name) + assert data['source'] == data['head_after'] == intermediate_source + assert data['command'] == commands[mode] and data['mode'] == mode + assert data['environment'] == current_env and data['cwd'] == str(root) + assert not data['changed_inputs'] and not data['verification_failures'] + launcher = within(directory, data['launcher_copy']).read_bytes() + assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] == '59104b1acd39b3981b7339e585af9bd7f9cb87865ee82ffb763f0e7ce527713c' + manifest_raw = within(directory, data['inputs']).read_bytes() + assert sha(manifest_raw) == data['inputs_sha256'] + manifest = json.loads(manifest_raw) + assert manifest['source'] == intermediate_source + historic_paths = git('ls-tree', '-r', '--name-only', intermediate_source, *scope).decode().splitlines() + assert historic_paths == [item['path'] for item in manifest['inputs']] + historic_blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root, + input=''.join(f'{intermediate_source}:{p}\n' for p in historic_paths).encode()) + offset = 0 + for item in manifest['inputs']: + end = historic_blobs.index(b'\n', offset) + _, kind, size = historic_blobs[offset:end].split() + size = int(size) + content = historic_blobs[end + 1:end + 1 + size] + assert kind == b'blob' and size == item['bytes'] and sha(content) == item['sha256'] + offset = end + size + 2 + assert offset == len(historic_blobs) + assert len(data['artifacts']) == 1 + if intermediate_artifact is None: + intermediate_artifact = data['artifacts'][0] + assert data['artifacts'] == [intermediate_artifact] + rows = outcomes(raw) + assert rows == [tuple(row) for row in data['outcomes']] + if mode == 'focused': + assert data['exit'] == 0 and dict(rows) == {name: 'ok' for name in added} + assert re.findall(r'^test result: ok\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('6', '0', '0', '292')] + elif mode == 'full': + assert data['exit'] == 101 and len(rows) == 298 + assert {name for name, status in rows if status == 'FAILED'} == intermediate_failures + assert sum(status == 'ok' for _, status in rows) == 294 + assert set(dict(rows)) == set(old_out) | added + assert all(dict(rows)[name] == 'ok' for name, status in old_out.items() if status == 'FAILED') + assert set(failure_blocks(raw)) == intermediate_failures + assert re.findall(r'^test result: FAILED\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('294', '4', '0', '0')] + else: + assert data['exit'] == 0 and not rows + assert members(raw) == data['listing_members'] and data['listing_count'] == 298 + assert set(members(raw)) == set(old_out) | added + intermediate[name] = {'receipt_sha256': sha(raw_receipt), 'log_sha256': sha(raw), + 'inputs_sha256': sha(manifest_raw), 'exit': data['exit']} + +result = {'source': source, 'baseline': BASELINE, 'baseline_archive_sha256': ARCHIVE_SHA, + 'checker_sha256': sha(Path(__file__).read_bytes()), 'inputs': len(expected_inputs), + 'focused_passed': 7, 'focused_existing_renamed_control': focused_control, + 'prior_passes_preserved': 276, 'prior_failures_now_passed': 16, 'added_passed': expected_added, 'added_names': sorted(added), + 'full_passed': sum(v == 'ok' for v in new_out.values()), 'full_failed': 0, + 'former_failure_names': sorted(old_blocks), + 'identical_fmt_sha256': sha(raw_logs['fmt']), 'artifact': artifact_identity, + 'environment': current_env, 'baseline_environment': expected_env, + 'receipts': verified, 'integration_pass_counts': integration_counts, + 'component_source': COMPONENT, 'reused_component_inputs': len(component_inputs), + 'successor_only_declared_delta': 'crates/oa-core/tests/r3_migration.rs', + 'old_r3_recorded_artifact': old_r3['integration-suite']['artifacts'][0], + 'cli_artifact': build['artifacts'][0], 'initial_failed_run': initial_failure, + 'exact_authorized_name_mapping': renames, 'intermediate_520_records': intermediate, + 'intermediate_recorded_artifact': intermediate_artifact, + '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/ordinary-source8-20260925/manifest.json b/harness/experiments/ordinary-source8-20260925/manifest.json new file mode 100644 index 00000000..f65b770f --- /dev/null +++ b/harness/experiments/ordinary-source8-20260925/manifest.json @@ -0,0 +1,653 @@ +{ + "source": "7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd", + "baseline": "edf096cd33350865ecfc3c65ec266a6c0d3c4000", + "component_source": "0c07f53ab517626f536f79dbaa2885a587bf1db7", + "scope": "Ordinary source8 compatibility only; private typed authoring remains excluded; no depth128 qualification or Linux evidence. Local-only until publication is confirmed.", + "archive": { + "file": "evidence.zip", + "bytes": 1220828, + "sha256": "879ec5a2198898a8a6d792d163710ca1d6ca83f8e7773ee093dcc93456c77378" + }, + "members": { + "baseline/acceptance-fmt-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-fmt-edf096c-1.inputs.json" + }, + "baseline/acceptance-fmt-edf096c-1.log": { + "bytes": 6446, + "sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-fmt-edf096c-1.log" + }, + "baseline/acceptance-fmt-edf096c-1.result.json": { + "bytes": 1892, + "sha256": "de9058d04aadc9734fb465061540600945c4c96b41c7b41a497715de3daac340", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-fmt-edf096c-1.result.json" + }, + "baseline/acceptance-full-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-full-edf096c-1.inputs.json" + }, + "baseline/acceptance-full-edf096c-1.log": { + "bytes": 47640, + "sha256": "5df6602c3d62c776720aa97916f0bf740de5488773d25601600aea8de27515e2", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-full-edf096c-1.log" + }, + "baseline/acceptance-full-edf096c-1.result.json": { + "bytes": 44019, + "sha256": "abf9e8ab5befe76f9be41d126a6015a9754bd9d13716ffedb3699b7f8a8b294b", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-full-edf096c-1.result.json" + }, + "baseline/acceptance-list-edf096c-1.inputs.json": { + "bytes": 104745, + "sha256": "6be8ae8911bb3d0aee346b137930d2b27a7d0ed4e77c4c9502b60d07982bd028", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-list-edf096c-1.inputs.json" + }, + "baseline/acceptance-list-edf096c-1.log": { + "bytes": 34079, + "sha256": "9ac3a152c7c2a98a161875b8088372d836162a7520f46d8a6a96f984d75207d7", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-list-edf096c-1.log" + }, + "baseline/acceptance-list-edf096c-1.result.json": { + "bytes": 36356, + "sha256": "717927d836c541f0855038ad3f4acd456fa00012784c006e2c012dc9a8524534", + "origin": ".local/analysis-output-acceptance-gates-20260925/acceptance-list-edf096c-1.result.json" + }, + "baseline/launchers/a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce.py": { + "bytes": 7681, + "sha256": "a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce", + "origin": ".local/analysis-output-acceptance-gates-20260925/launchers/a17935d88ccb953f441b8939ccf2dc6aabcd6ea406d9a3754e3e8306a5bd26ce.py" + }, + "cli/ordinary-cli-check-0c07f53-1.cli.json": { + "bytes": 2970, + "sha256": "796dd000f421569fc964bef8fe1e2afa95a20ca9c89c99b53041dfd9c3d6432c", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-check-0c07f53-1.cli.json" + }, + "cli/ordinary-cli-check-0c07f53-1.stderr.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-check-0c07f53-1.stderr.txt" + }, + "cli/ordinary-cli-check-0c07f53-1.stdout.json": { + "bytes": 743, + "sha256": "23e8366945c023bd5b589a644062956d897ee27278633c0ef1a373f5a31accba", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-check-0c07f53-1.stdout.json" + }, + "cli/ordinary-cli-rename-alias-0c07f53-1.cli.json": { + "bytes": 3008, + "sha256": "55ac982e3edb6abfc09ff15964b4a5b7e4b9513e0c751edb04f1ece4f48d1565", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-rename-alias-0c07f53-1.cli.json" + }, + "cli/ordinary-cli-rename-alias-0c07f53-1.stderr.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-rename-alias-0c07f53-1.stderr.txt" + }, + "cli/ordinary-cli-rename-alias-0c07f53-1.stdout.json": { + "bytes": 2160, + "sha256": "7977240a636b697bc5596c8d27c263a5971b2ee945844832807463d370e9d222", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-rename-alias-0c07f53-1.stdout.json" + }, + "cli/original-inputs/children.arcadia": { + "bytes": 85, + "sha256": "db0a26ff2aba33d7eec4fecae4d0a7ce2f380a2bb4f2bea3de44d29c99f75907", + "origin": ".local/ordinary-source8-gates-20260925/cli-fixture-0c07f53/children.arcadia" + }, + "cli/original-inputs/participants.arcadia": { + "bytes": 106, + "sha256": "462f7771f9c91fe28ff863aec2ffcb37e8d9a99753da6609fb0da4b45eb69c23", + "origin": ".local/ordinary-source8-gates-20260925/cli-fixture-0c07f53/participants.arcadia" + }, + "cli/original-inputs/project.arcadia": { + "bytes": 149, + "sha256": "b176dfe8ed8b2ef9905955846a2996f91093ec55e5ffdb91e6e31c2d0161a806", + "origin": ".local/ordinary-source8-gates-20260925/cli-fixture-0c07f53/project.arcadia" + }, + "contracts/ADOPTION-CRITIQUE.md": { + "bytes": 11705, + "sha256": "fbb6af1498998e793a062bf217c7567ca5e1841254cc0fd98af209abc71f2aec", + "origin": "harness/ordinary-source8-design-20260925/ADOPTION-CRITIQUE.md" + }, + "contracts/ADOPTION-MAP.md": { + "bytes": 14155, + "sha256": "09987da4c4f1cacd827f46d412d78f550fa27cf69c087e6ff1eb520cc5e18a67", + "origin": "harness/ordinary-source8-design-20260925/ADOPTION-MAP.md" + }, + "contracts/ordinary-source8-compatibility-contract-20260925.md": { + "bytes": 7236, + "sha256": "b2bded55570157628b2a358f3ff8054f7b796aa000ae8a5334a3d69827e4ade3", + "origin": "harness/ordinary-source8-compatibility-contract-20260925.md" + }, + "diffs/edf096c-to-0c07f53.patch": { + "bytes": 30457, + "sha256": "35cd9430661d5598a19210491edef90876d2efb3fcadea4064c0003dcc560b3b", + "origin": "git diff --no-ext-diff --no-textconv edf096cd33350865ecfc3c65ec266a6c0d3c4000 0c07f53ab517626f536f79dbaa2885a587bf1db7" + }, + "diffs/edf096c-to-33b86a4.patch": { + "bytes": 22063, + "sha256": "d246ab83ceffb91bc72fda68818362a4660c01145b0fe570b2867ae2ed6fdfd7", + "origin": "git diff --no-ext-diff --no-textconv edf096cd33350865ecfc3c65ec266a6c0d3c4000 33b86a4d6b4bc1b156a93ae3596fe0ad7b4dbbe5" + }, + "diffs/edf096c-to-520e50c.patch": { + "bytes": 23950, + "sha256": "5e6dd6c13fb5c1491b87ed58ca4f85ddf8434ab829bb3bc851d944fc65e4c078", + "origin": "git diff --no-ext-diff --no-textconv edf096cd33350865ecfc3c65ec266a6c0d3c4000 520e50ce62f067dff69f03760c8b12929df9b920" + }, + "diffs/edf096c-to-7b06b8e.patch": { + "bytes": 32593, + "sha256": "ea43d728010954d918c60cbd7edc122a50a6dfa1f141e61b3811faa927de0dc0", + "origin": "git diff --no-ext-diff --no-textconv edf096cd33350865ecfc3c65ec266a6c0d3c4000 7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd" + }, + "gates/launchers/308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d.py": { + "bytes": 8465, + "sha256": "308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d", + "origin": ".local/ordinary-source8-gates-20260925/launchers/308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d.py" + }, + "gates/launchers/59104b1acd39b3981b7339e585af9bd7f9cb87865ee82ffb763f0e7ce527713c.py": { + "bytes": 10896, + "sha256": "59104b1acd39b3981b7339e585af9bd7f9cb87865ee82ffb763f0e7ce527713c", + "origin": ".local/ordinary-source8-gates-20260925/launchers/59104b1acd39b3981b7339e585af9bd7f9cb87865ee82ffb763f0e7ce527713c.py" + }, + "gates/launchers/6e2fad2fff3066861a42f85ab6c3ada8b4c8954075fb402e555c5f686dae840b.py": { + "bytes": 10896, + "sha256": "6e2fad2fff3066861a42f85ab6c3ada8b4c8954075fb402e555c5f686dae840b", + "origin": ".local/ordinary-source8-gates-20260925/launchers/6e2fad2fff3066861a42f85ab6c3ada8b4c8954075fb402e555c5f686dae840b.py" + }, + "gates/launchers/ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765.py": { + "bytes": 10896, + "sha256": "ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765", + "origin": ".local/ordinary-source8-gates-20260925/launchers/ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765.py" + }, + "gates/launchers/c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8.py": { + "bytes": 10896, + "sha256": "c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8", + "origin": ".local/ordinary-source8-gates-20260925/launchers/c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8.py" + }, + "gates/ordinary-cli-build-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-build-0c07f53-1.inputs.json" + }, + "gates/ordinary-cli-build-0c07f53-1.log": { + "bytes": 58614, + "sha256": "fda7cc4a13707a8f861be4f1b1db590cec7f94e5e04e354390b3583800289b28", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-build-0c07f53-1.log" + }, + "gates/ordinary-cli-build-0c07f53-1.result.json": { + "bytes": 2236, + "sha256": "9001d42d915ce1bfe14c695a927befd16119e82ac91f11e625468c2b15ba56d6", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-cli-build-0c07f53-1.result.json" + }, + "gates/ordinary-clippy-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-clippy-0c07f53-1.inputs.json" + }, + "gates/ordinary-clippy-0c07f53-1.log": { + "bytes": 165, + "sha256": "3f18ecfb5fac754c6660d217d1f87752ee99a321fff525a6113ff7deb6ee2baa", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-clippy-0c07f53-1.log" + }, + "gates/ordinary-clippy-0c07f53-1.result.json": { + "bytes": 1976, + "sha256": "fcaef9f2ce8c1667cbdf47c7893ba6a4aebe6b7309a4a725153feb9257f0fc5c", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-clippy-0c07f53-1.result.json" + }, + "gates/ordinary-clippy-7b06b8e-1.inputs.json": { + "bytes": 104934, + "sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-clippy-7b06b8e-1.inputs.json" + }, + "gates/ordinary-clippy-7b06b8e-1.log": { + "bytes": 164, + "sha256": "84ff5001a15bb4c99a168286ee4816a48ca0cc6119386c198c8ca716ca54a824", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-clippy-7b06b8e-1.log" + }, + "gates/ordinary-clippy-7b06b8e-1.result.json": { + "bytes": 1977, + "sha256": "b8f59ee6cbebabfd31cb2aa2228481336245a403e086931e5f2cb80960718b91", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-clippy-7b06b8e-1.result.json" + }, + "gates/ordinary-fmt-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-fmt-0c07f53-1.inputs.json" + }, + "gates/ordinary-fmt-0c07f53-1.log": { + "bytes": 6446, + "sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-fmt-0c07f53-1.log" + }, + "gates/ordinary-fmt-0c07f53-1.result.json": { + "bytes": 1890, + "sha256": "38c5c4e68f0aaa29a1829aac8bd4eac131f04b4011d80fa747dca1d86a3650c2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-fmt-0c07f53-1.result.json" + }, + "gates/ordinary-fmt-7b06b8e-1.inputs.json": { + "bytes": 104934, + "sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-fmt-7b06b8e-1.inputs.json" + }, + "gates/ordinary-fmt-7b06b8e-1.log": { + "bytes": 6446, + "sha256": "c1c6b12861c8117ce6ffc6d6742ebf92618aafb10160ec6f99d370ca72ebab2d", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-fmt-7b06b8e-1.log" + }, + "gates/ordinary-fmt-7b06b8e-1.result.json": { + "bytes": 1890, + "sha256": "2ed4803758e5e1808566f250b7a6b0a36dbca9fe2970f92f33433c9cc549f740", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-fmt-7b06b8e-1.result.json" + }, + "gates/ordinary-focused-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-0c07f53-1.inputs.json" + }, + "gates/ordinary-focused-0c07f53-1.log": { + "bytes": 1194, + "sha256": "4bb20f728dc29c0f3119a7eedba6e1298bcaeec662b977e95877c44e1a457cbc", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-0c07f53-1.log" + }, + "gates/ordinary-focused-0c07f53-1.result.json": { + "bytes": 3182, + "sha256": "d68ef427bf5d85668cf3480f8b21a16cf6d4b23aa1521282ba004f7284b27b25", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-0c07f53-1.result.json" + }, + "gates/ordinary-focused-33b86a4-1.inputs.json": { + "bytes": 104934, + "sha256": "3e746fd4ecfccbaab4db44b5a2e38c890b5117a815e28598528b66890d042420", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-33b86a4-1.inputs.json" + }, + "gates/ordinary-focused-33b86a4-1.log": { + "bytes": 1685, + "sha256": "16787e1fe74e7c867352badf8dedc5516c50dc5295958d27d5c5f128d1c2f5c5", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-33b86a4-1.log" + }, + "gates/ordinary-focused-33b86a4-1.result.json": { + "bytes": 3052, + "sha256": "8d28d7d9c162f6fdd759ef9ffe1526393f56c0116691a353eae40f986889e195", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-33b86a4-1.result.json" + }, + "gates/ordinary-focused-520e50c-1.inputs.json": { + "bytes": 104934, + "sha256": "00f9b5454d499ed6bf47dfca1f765ee083dff1e3993d466faa1175846663bb70", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-520e50c-1.inputs.json" + }, + "gates/ordinary-focused-520e50c-1.log": { + "bytes": 1079, + "sha256": "c6dd4a5563e6b087072f76ca53e147f2df63b2c184077b3b736826c0085f71f2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-520e50c-1.log" + }, + "gates/ordinary-focused-520e50c-1.result.json": { + "bytes": 3046, + "sha256": "1aa7d7f7f38543a27db6be289126f484598a3aa89e45915f0219eccd3696822d", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-focused-520e50c-1.result.json" + }, + "gates/ordinary-full-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-full-0c07f53-1.inputs.json" + }, + "gates/ordinary-full-0c07f53-1.log": { + "bytes": 36561, + "sha256": "d9901deda399bcc3187f345b332fd5f2ba0c594113821f96f27681af4b6ed05d", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-full-0c07f53-1.log" + }, + "gates/ordinary-full-0c07f53-1.result.json": { + "bytes": 44717, + "sha256": "1e949b275a3f3fbae6717f697d211b42509cafe0d51d6ac1c4c1dfe4ca60ecdb", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-full-0c07f53-1.result.json" + }, + "gates/ordinary-full-520e50c-1.inputs.json": { + "bytes": 104934, + "sha256": "00f9b5454d499ed6bf47dfca1f765ee083dff1e3993d466faa1175846663bb70", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-full-520e50c-1.inputs.json" + }, + "gates/ordinary-full-520e50c-1.log": { + "bytes": 38871, + "sha256": "84b9e7a3a43e9f829a594a660e32faf574008718d7df46b87ac1d9661865fdd3", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-full-520e50c-1.log" + }, + "gates/ordinary-full-520e50c-1.result.json": { + "bytes": 44729, + "sha256": "69ec1a47ba13ebaee80b090369b89b51cf2033bf1a02292e3f3e7bc6b9438079", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-full-520e50c-1.result.json" + }, + "gates/ordinary-integration-list-r3_migration-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-r3_migration-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-list-r3_migration-0c07f53-1.log": { + "bytes": 724, + "sha256": "d655440440dbfd3df061c871da9ee96c8a7c8b7628fba1a8a930beb5193b6328", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-r3_migration-0c07f53-1.log" + }, + "gates/ordinary-integration-list-r3_migration-0c07f53-1.result.json": { + "bytes": 2675, + "sha256": "9d04bd9317852febb8f4ed16f64fb2697bcc76e52a31fcd263829949222ad1cc", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-r3_migration-0c07f53-1.result.json" + }, + "gates/ordinary-integration-list-r3_migration-7b06b8e-1.inputs.json": { + "bytes": 104934, + "sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-r3_migration-7b06b8e-1.inputs.json" + }, + "gates/ordinary-integration-list-r3_migration-7b06b8e-1.log": { + "bytes": 724, + "sha256": "3bf954f21c81ffc733d406175171beb6b3a2ac685f64b6c3b0a340017b443965", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-r3_migration-7b06b8e-1.log" + }, + "gates/ordinary-integration-list-r3_migration-7b06b8e-1.result.json": { + "bytes": 2674, + "sha256": "e8a28ac312d2193aa2a6a5846037f1729d5470d7a730d0a3d5a6edcf490ea1c3", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-r3_migration-7b06b8e-1.result.json" + }, + "gates/ordinary-integration-list-review_regressions-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-review_regressions-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-list-review_regressions-0c07f53-1.log": { + "bytes": 597, + "sha256": "cccc9047f0abd98b2919a7e8513c94dfe26a7889405ee6b7f881864105e6f5e1", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-review_regressions-0c07f53-1.log" + }, + "gates/ordinary-integration-list-review_regressions-0c07f53-1.result.json": { + "bytes": 2590, + "sha256": "2b3cb4d29cd681099a559c23309ca7568759ab144fcfd59331ec2d24c686ba9d", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-review_regressions-0c07f53-1.result.json" + }, + "gates/ordinary-integration-list-source7_contract-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source7_contract-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-list-source7_contract-0c07f53-1.log": { + "bytes": 448, + "sha256": "ba4e0c42ad375ef974ecebba3562d829156f938056824473d0d7671e49f2f8ba", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source7_contract-0c07f53-1.log" + }, + "gates/ordinary-integration-list-source7_contract-0c07f53-1.result.json": { + "bytes": 2578, + "sha256": "e89ca824de90c2585249ce496a031ce7f7210a99f0dbb5c08418d0ac7b3fbe6b", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source7_contract-0c07f53-1.result.json" + }, + "gates/ordinary-integration-list-source_files-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_files-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-list-source_files-0c07f53-1.log": { + "bytes": 923, + "sha256": "5703de5b7ea97bf4a03a2768910406ef506c8c9f2537ae87862b5493a7a0cce7", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_files-0c07f53-1.log" + }, + "gates/ordinary-integration-list-source_files-0c07f53-1.result.json": { + "bytes": 2876, + "sha256": "7d71114234578f043a53f582bd1ab450c42e5dff5635702fa7de8008ef6132d3", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_files-0c07f53-1.result.json" + }, + "gates/ordinary-integration-list-source_identity_updates-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_identity_updates-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-list-source_identity_updates-0c07f53-1.log": { + "bytes": 600, + "sha256": "1297c9929d8d17f900f129e3a3358cea4ed61a9527144b336788bbe1dfebec08", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_identity_updates-0c07f53-1.log" + }, + "gates/ordinary-integration-list-source_identity_updates-0c07f53-1.result.json": { + "bytes": 2570, + "sha256": "d3cc5dd44a8dc6017aacfbc383caa4105dd4eaa814efb7c1f6e4e5bc6335ff4a", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_identity_updates-0c07f53-1.result.json" + }, + "gates/ordinary-integration-list-source_nested_updates-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_nested_updates-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-list-source_nested_updates-0c07f53-1.log": { + "bytes": 1303, + "sha256": "4b34e9e9776a1bc5ffdcf1211d2937ed3c33c2ba45a7a9635d5e088489d8870c", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_nested_updates-0c07f53-1.log" + }, + "gates/ordinary-integration-list-source_nested_updates-0c07f53-1.result.json": { + "bytes": 3279, + "sha256": "a98808c798b1f3b56c7489c4afdcb51039b2483cefc21faef57f62809c213216", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_nested_updates-0c07f53-1.result.json" + }, + "gates/ordinary-integration-list-source_project-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_project-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-list-source_project-0c07f53-1.log": { + "bytes": 2975, + "sha256": "02bdebb9395c835d9069bdf8c97920c9b3e6fec8e037a44be8ec3e3496edaa7c", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_project-0c07f53-1.log" + }, + "gates/ordinary-integration-list-source_project-0c07f53-1.result.json": { + "bytes": 4943, + "sha256": "8a9a13020b38064a6f188c391f646a29cccdbdb35c220ff29e4b5ef22d13bc00", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-list-source_project-0c07f53-1.result.json" + }, + "gates/ordinary-integration-suite-r3_migration-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-r3_migration-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-suite-r3_migration-0c07f53-1.log": { + "bytes": 5133, + "sha256": "ee55320de5e208beb921ce219afb38db7b27c86cd64d176837c952b803a48582", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-r3_migration-0c07f53-1.log" + }, + "gates/ordinary-integration-suite-r3_migration-0c07f53-1.result.json": { + "bytes": 2955, + "sha256": "8a2ea478ed00f2f55ecee5da89376d169f8ab99fab40065fd56fcc8dd73792f8", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-r3_migration-0c07f53-1.result.json" + }, + "gates/ordinary-integration-suite-r3_migration-7b06b8e-1.inputs.json": { + "bytes": 104934, + "sha256": "6ac8f6eb5638448bdaf5969b2fb4d4d05f39276c15f48f8654bd7ae785d263ba", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-r3_migration-7b06b8e-1.inputs.json" + }, + "gates/ordinary-integration-suite-r3_migration-7b06b8e-1.log": { + "bytes": 740, + "sha256": "821552f251b3dcaf21a09aff01a1ca65eda2fcb0c64f124cd7ae14e816789997", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-r3_migration-7b06b8e-1.log" + }, + "gates/ordinary-integration-suite-r3_migration-7b06b8e-1.result.json": { + "bytes": 2817, + "sha256": "080e795d747e2c396bbb1a718fd26f7fb3be917e752aa2556bf807040979d463", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-r3_migration-7b06b8e-1.result.json" + }, + "gates/ordinary-integration-suite-review_regressions-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-review_regressions-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-suite-review_regressions-0c07f53-1.log": { + "bytes": 602, + "sha256": "c2a46ec6f199507c124c5f373fb52c8fe1bb226dcdd58e3b9c8990623814b5c3", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-review_regressions-0c07f53-1.log" + }, + "gates/ordinary-integration-suite-review_regressions-0c07f53-1.result.json": { + "bytes": 2682, + "sha256": "451ca27563d7b6aaf2d4a3ed4c52f21564ea3c0fb57e02d3db4b470e443580a4", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-review_regressions-0c07f53-1.result.json" + }, + "gates/ordinary-integration-suite-source7_contract-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source7_contract-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-suite-source7_contract-0c07f53-1.log": { + "bytes": 441, + "sha256": "629afa19abcee2630b9c8a1f645d9b863b81e0452f5da32c431495557096b91b", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source7_contract-0c07f53-1.log" + }, + "gates/ordinary-integration-suite-source7_contract-0c07f53-1.result.json": { + "bytes": 2617, + "sha256": "bec965b3342b6715d96151299df2a57c91e0fc92d1360d0aebe207662f590b4d", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source7_contract-0c07f53-1.result.json" + }, + "gates/ordinary-integration-suite-source_files-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_files-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-suite-source_files-0c07f53-1.log": { + "bytes": 957, + "sha256": "8ac702b98b8e518650baef1982da1cdc1efba0bdd77eaffaff9e3b562fd4bcce", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_files-0c07f53-1.log" + }, + "gates/ordinary-integration-suite-source_files-0c07f53-1.result.json": { + "bytes": 3097, + "sha256": "8be7fda52cd333f863da47ae2ecb23697cbd8465016d47f1f4d067fa79b41394", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_files-0c07f53-1.result.json" + }, + "gates/ordinary-integration-suite-source_identity_updates-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_identity_updates-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-suite-source_identity_updates-0c07f53-1.log": { + "bytes": 604, + "sha256": "9f09d1c72f70ed41509a821417fdf8e3e3f6df334a54e510b0f9ed9c876e5309", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_identity_updates-0c07f53-1.log" + }, + "gates/ordinary-integration-suite-source_identity_updates-0c07f53-1.result.json": { + "bytes": 2661, + "sha256": "e8369317900600cb985a106ea9950ea6fd6b98fa0915037f2b1f615b481b42c8", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_identity_updates-0c07f53-1.result.json" + }, + "gates/ordinary-integration-suite-source_nested_updates-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_nested_updates-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-suite-source_nested_updates-0c07f53-1.log": { + "bytes": 1362, + "sha256": "d0fcb9be9a0a75b4113e7c3abf7bcc3eea6533e9adde2c8f290106ef79be4a7c", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_nested_updates-0c07f53-1.log" + }, + "gates/ordinary-integration-suite-source_nested_updates-0c07f53-1.result.json": { + "bytes": 3602, + "sha256": "e1cf6cea7613ffd7343b07e125259431f96d7916ff398c9fb4d2236093f0fe8f", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_nested_updates-0c07f53-1.result.json" + }, + "gates/ordinary-integration-suite-source_project-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_project-0c07f53-1.inputs.json" + }, + "gates/ordinary-integration-suite-source_project-0c07f53-1.log": { + "bytes": 3159, + "sha256": "5f24b9b6ee1e7cabd72365698adccfe32037bca99e6978b93a629ad0d177d9ca", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_project-0c07f53-1.log" + }, + "gates/ordinary-integration-suite-source_project-0c07f53-1.result.json": { + "bytes": 5826, + "sha256": "da321481bcb17cba7603052aac4c874c59104bc51ef80491bd0bd4eadd404af3", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-integration-suite-source_project-0c07f53-1.result.json" + }, + "gates/ordinary-list-0c07f53-1.inputs.json": { + "bytes": 104934, + "sha256": "7c16b1ac507d60a132130675949ad508a554417f5330aa49eac1b10b6d5379d2", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-list-0c07f53-1.inputs.json" + }, + "gates/ordinary-list-0c07f53-1.log": { + "bytes": 34680, + "sha256": "22d4cfd1ef02f8c7adff8ce705efe56a7fe9a2e271951fed52aed687c626d06b", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-list-0c07f53-1.log" + }, + "gates/ordinary-list-0c07f53-1.result.json": { + "bytes": 36961, + "sha256": "e00ac1b86aadae7b2573d6b21551469263311a2a7b1f4eb7e5c69f495b347ddd", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-list-0c07f53-1.result.json" + }, + "gates/ordinary-list-520e50c-1.inputs.json": { + "bytes": 104934, + "sha256": "00f9b5454d499ed6bf47dfca1f765ee083dff1e3993d466faa1175846663bb70", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-list-520e50c-1.inputs.json" + }, + "gates/ordinary-list-520e50c-1.log": { + "bytes": 34677, + "sha256": "326452c7ccb98b85a06333cfdcedebdff83b75e68a6a0c9768ddf24d4a058420", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-list-520e50c-1.log" + }, + "gates/ordinary-list-520e50c-1.result.json": { + "bytes": 36958, + "sha256": "68a912f426aeb33bd9379aacaa219968ba61678f3057925d7e3de705769ca357", + "origin": ".local/ordinary-source8-gates-20260925/ordinary-list-520e50c-1.result.json" + }, + "launchers/package_evidence.py": { + "bytes": 8485, + "sha256": "9b5c3c1d5e72868c66820b4923efa83c313b9cc0f54bfd40d5d96bd960a81104", + "origin": ".local/package-ordinary-source8-20260925.py" + }, + "notes/ordinary-source8-compatibility-implementation-20260925.md": { + "bytes": 6811, + "sha256": "7d2b34649625cbefca46aa9ea837de6bc9784c1299aa293240782261a1dbddcf", + "origin": "7b06b8ea1b7ef902ee0b3d0ec2971a9a7a1f1acd:harness/ordinary-source8-compatibility-implementation-20260925.md" + }, + "notes/prior-toolchain.txt": { + "bytes": 536, + "sha256": "1f101518dd1f90bc2cba8d26570a762832aba6debebbbe6aa50f97a944590610", + "origin": ".local/analysis-mixed-index-gates-20260924/toolchain.txt" + }, + "reviews/CHECKER-NOTE.md": { + "bytes": 2583, + "sha256": "e3c2875629a2c76b7ce4bc55c6fa8471ed0d2ea713d97eab638b474275080878", + "origin": ".local/ordinary-source8-review-20260925/CHECKER-NOTE.md" + }, + "reviews/LAUNCHER-REVIEW.md": { + "bytes": 7633, + "sha256": "dd90dba910bc2ead67331609cbba0d7112de5397395497b837e5782a9052de8f", + "origin": ".local/ordinary-source8-review-20260925/LAUNCHER-REVIEW.md" + }, + "reviews/ORDINARY-RUNTIME-READBACK.json": { + "bytes": 22792, + "sha256": "3ee36b331431736062db7ea9fa94876795f61711d44820f5b5093e97cc515db5", + "origin": ".local/ordinary-source8-review-20260925/ORDINARY-RUNTIME-READBACK.json" + }, + "reviews/RUNTIME-REVIEW.md": { + "bytes": 6010, + "sha256": "47d511ce854bf90f3f35ddf909d3cd246f6c07b9e4bbdc9ebc256f6b41b5a6ce", + "origin": ".local/ordinary-source8-review-20260925/RUNTIME-REVIEW.md" + }, + "reviews/SOURCE-REVIEW.md": { + "bytes": 12998, + "sha256": "28c15a4ae255a76f0d8c528db3bf5e0b0ef63e6c0b15f0607f819ab3837cd99d", + "origin": ".local/ordinary-source8-review-20260925/SOURCE-REVIEW.md" + }, + "reviews/TEST-REVIEW.md": { + "bytes": 9791, + "sha256": "8b009ee5e8f8512758e6b4908e3f4abf934a64c7559ed9af37d98a08dfc7fcf8", + "origin": ".local/ordinary-source8-review-20260925/TEST-REVIEW.md" + }, + "reviews/VERIFICATION-PLAN.md": { + "bytes": 11567, + "sha256": "1637ce0674a4836493a1eb42bb3e7aaa567e62a24bc3ca6ba0a1f314481ac371", + "origin": ".local/ordinary-source8-review-20260925/VERIFICATION-PLAN.md" + }, + "reviews/checker-first-refusal.log": { + "bytes": 300, + "sha256": "778e0d07e63279164d444770adcf9f896ba17945e6ec152e9363ceff10e81686", + "origin": ".local/ordinary-source8-review-20260925/checker-first-refusal.log" + }, + "reviews/inspect_runtime.py": { + "bytes": 30854, + "sha256": "db853cc7677421e1abc13e59ca7d181fdcf7bcb45033164e51e09f13ca51c172", + "origin": ".local/ordinary-source8-review-20260925/inspect_runtime.py" + }, + "reviews/inspect_runtime_encoding_original.py": { + "bytes": 30855, + "sha256": "b544cdb20dc8f5cf1b5d29c5ab78791dd3ac6701a4c1f7f7229f0d73dac7b81e", + "origin": ".local/ordinary-source8-review-20260925/inspect_runtime_encoding_original.py" + } + } +}