Validate latest PR40 assembly discovery batch

[cpunion]

Fork-only Draft staging for xgo-dev/plan9asm#40. The upstream-connected branch is unchanged. Promotion still requires current-head CI, an audited complete assembly ledger, and review of exclusions.

Discovery funnel

Stage	Count
Contiguous official Go Module Index records	18,758,534
Unique module paths recorded	965,347
Successfully inspected retained exact versions	952,900
Assembly-bearing exact versions queued	6,067
Original assembly files inventoried	78,961
Inspection failures retained for retry	16,390

The 215 validated ranges cover 2025-10-01T00:00:00Z through 2026-09-22T22:43:08Z. This is neither the complete historical index nor its current head. A reliable global unique-module denominator is unavailable; no global coverage percentage is claimed.

Keep the highest inspected version independently per (module path, Go-semver major) line. v0/v1 can coexist, while /v2 and /v3 are independent paths. Normalization never rewinds covered ranges. ledger/ is immutable inspection/cursor input, including negative results; assembly-ledger/ is derived compilation evidence, not a second scan copy.

Published repair batch

The repaired public head is 47ea649d. Development and external-module tests use actual Go 1.27.1 and LLVM 22.1.8; no alternate LLVM fallback is allowed.

• Strict private ARM64 SP-frame stores and bounded frame reads retain original and normalized proofs. Unknown writes, pointer escapes and unbalanced caller-LR effects still fail.
• Typed ARM CPSR flags, actual Go/LLVM/QEMU execution and negative status-register effects.
• Go-compatible included-tokenizer EOF behavior, bounded include/source diagnostics, and canonical positive diagnostic line/column fields. The bounded diagnostic sample does not truncate the retained raw tool output or hide later infrastructure errors.
• Go-selected *_test.s files remain ordinary assembly when their actual Go package role says so. Empty selected siblings retain their real source bytes and actual Go/CPP/LLVM proofs.
• Explicit typed ARM64 Go-funcval input carriers. This is a translator-side contract, not an invented hidden argument; the dependent llgo compiler must supply and verify the actual producer/layout.
• The full raw ARM64 SM3 Advanced SIMD family: PARTW1/W2, SS1, TT1A/B and TT2A/B. Raw masks, lanes, source-before-destination aliases, vectors and NZCV preservation have independent Go/LLVM/runtime oracles. The software lowering does not require host SM3 instructions.

Published 47ea649d local checks

Check	Result
Every non-root package in root ./...	Passed; corpus full suite 437.441 seconds
SM3/active-include focused root checks	Passed, 120.317 seconds
Nested cmd/plan9asm full suite	Passed, 2.095 seconds
Nested cmd/plan9asmll full suite	Passed, 248.011 seconds
Five-architecture official opcode/form gate	Passed without changing baselines
Priority scheduling tests and actionlint	Passed
Complete root suite	All 32 exhaustive partitions finished at frozen 47ea649d: 3,335 root passes, 35 existing skips and 7 failures; no missing roots. Five linker-environment failures passed a separate same-source LLVM/lld 22 rerun; two genuine ARM64 frame-contract failures remain. This is not a full-suite pass
Strict compile benchmark	Failed at original reflect.makeFuncStub on linux/386; dynamic caller-frame contract remains unfinished
Current-head remote CI and 64-shard corpus	Required, not yet passed

The official gate's supported/context split is explicit. Zero unsupported classifications does not mean every contextual runtime entry has compiled or executed.

Architecture	Observed forms	Supported	Requires function context	Unsupported	Parse errors
386	57	50	7	0	0
amd64	6,740	6,734	6	0	0
arm	499	455	44	0	0
arm64	2,048	1,977	71	0	0
wasm	120	0	120	0	0

All 98 required ARM64 opcodes available in this toolchain are encoder-defined, observed and lowerable. Opcode-table classifications, operand-form coverage, object compilation and runtime execution remain distinct measures.

Original-library repair witnesses

These frozen exact-source runs prove the respective fixes, not a substituted current-head aggregate. Ordinary Go/source exclusions remain visible.

Exact module	Frozen fix source	Full default target replay
github.com/Kany2t/gmsm-@v0.40.2	45f9e6d7	All 11 targets completed; 175 translated file/target scopes, no candidate/translation failures. Twelve separately recorded original-source ABI exclusions remain
github.com/dominikh/avo@v0.0.0-20260314015840-88ad9c81f33f	ff488337	396 file/target scopes: 131 translated scopes producing 134 object parts, plus 265 actual-Go source exclusions; no candidate failure
github.com/CWBudde/algo-fft@v0.8.0	4a49d765	Complete original default-11-target replay; 184 applicable files, 585 LLVM 22 objects across eight successful targets; source-inapplicable targets remain explicit
github.com/Parquet-Go/Parquet-Go@v0.32.0	4a49d765	Complete original default-11-target replay; 21 applicable files, 63 LLVM 22 objects across three successful targets; source-inapplicable targets remain explicit
github.com/pjgraczyk/gomacro@v0.0.0-20260616122001-83362707febb	b9dba52e	Original default-11-target replay passed with 11 LLVM objects; authenticated fixed include search and documentation-source roles retained
github.com/edisonwsk/golang-on-cygwin@v0.0.0-20091119214618-6fb6903d6871	b9dba52e	Original default-11-target replay passed with three actual bignum AMD64 objects; foreign documentation assembly has 11 typed Go NoGoError scope exclusions, zero objects, and is not an invalid-source pass
github.com/SnellerInc/sneller@v0.0.0-20251209211248-dc69d73211f5	97e54f30	Complete original default-target replay passed after the DATA/query fix: all 28 original ASM files retained, 75 actual LLVM objects across three eligible AMD64 configurations; nine original-Go scope exclusions remain explicit

SM3 checks include 1,638,400 decoder encodings, independent LLVM-MC encodings and 105 alias partitions. Actual Go WORD and independently calculated LLVM/C results passed 26,880 comparisons on both Darwin/ARM64 and Linux/ARM64 under pinned QEMU 10.2.3; all four NZCV flags are checked. Full corpus tests after strict diagnostic-column hardening passed at frozen 520860ff (614.921 seconds).

Ledger and completion gates

The committed published-head queue remains 6,067 pending, complete=false, verified=false. Matching reports from fork CI run 36942816488 have been imported by the automatic writer in a separate source-frozen worktree. The strict reader verified all six completed priority shard reports (5, 29, 36, 38, 39 and 42):

Current-source derived validation	Exact versions
Actual Go/CPP/LLVM object proofs passed	438
Source-inapplicable, concrete scoped Go diagnostics retained	91
Failed, retained for repair	81
Exact invalid source, separately evidenced skip	2
Exact superseded version, separately evidenced skip	1
Pending matching complete reports	5,454
Total assembly-bearing versions	6,067

These six reports contain 7,290 translated scopes. All six shards fail because their failing candidates are retained; 58 required reports are missing. The full fork run has now finished with failure: priority and strict aggregate gates failed, and downstream skipped jobs did not pass. This derived ledger has not yet been committed, and neither partial coverage nor source N/A is a pass. Reports from the PR merge ref retain their actual revision and tool hashes; their full source-content fingerprint exactly matches published 47ea649d. Previous source's successful reports remain historical evidence, never relabeled as new passes. Missing empty-sibling source bytes in an old proof were rejected rather than synthesized.

Fresh schema-10 reports must cover all 64 shards with identical source, scan ledger, Go/LLVM and tool-binary identities. Actual file/target/profile/custom-tag, package-role, source/CPP and LLVM-object proofs are retained by the v2 writer. Each candidate must end as an actual tested pass or a narrow, evidenced, reviewed skip; any pending or failed candidate blocks completion. Provisional native-layout/JIT exclusions remain separate and require review.

The policy and six previously failing shards (5, 29, 36, 38, 39, 42) run first. Downstream jobs require their success; a skipped job is not a pass. No matrix concurrency cap is imposed, and the strict aggregate still fails for missing/failed reports.

Actual third-party Go+assembly compilation, linking and execution belong to the dependent cpunion/llgo#259. Its next local batch resolves the actual public 47ea649d pseudo-version and includes an authenticated typed R26 closure-entry producer. A fresh checkout compiler passed actual Darwin/ARM64 CRC32, huff0 and websocket execution with normal assembly selection and build cache disabled; purego remains a genuine failure. Windows path repair passed native Go 1.27.0 and 1.27.1 regressions after both versions reproduced the original GOROOT/junction failure. These are bounded local/isolated CI results, not full compiler CI success or broad issue closure. The previous complete dependent CI run finished with failures and is preserved.

Unpublished local batch (2026-10-03)

The next batch remains separate from the public 47ea649d head. Fresh integrated validation is frozen at local ac5de03f; it has not been pushed and does not change the failed public CI conclusion. Later development is kept outside this running snapshot.

Frozen ac5de03f local gate	Actual result
Complete exhaustive root suite	All 32/32 partitions passed: 3,499 root passes, 20,248 subtest/seed passes, zero failures or incomplete roots; 37 existing host/cross-lane skips remain separate
Full cmd/plan9asmll race suite	Passed, 220.288 seconds
Full cmd/plan9asm race suite	Passed, 2.302 seconds
Caller/declaration focused race checks	Passed
Actual Go 1.20 root compatibility checks	Passed
Root and nested CLI vet/build	Passed
Unchanged official five-architecture classification gate	Passed; table above remains unchanged
Priority scheduling tests / actionlint	Passed, 14 tests / no errors
All non-root package race suites	Passed for all 11 packages; full corpus race suite 422.501 seconds
Strict compile benchmark	Failed: linux/386 compiled 19 applicable files before original reflect.makeFuncStub required an unfinished dynamic caller-frame contract; remaining targets did not run
Complete 64-shard external corpus	Running; neither partial reports nor historical passes satisfy this gate

These are local source-specific tests, not current public-head CI or runtime coverage of every external module. A preserved earlier root failure used 0x00000002 as an unknown-WORD negative even though it is valid UDF #2; the corrected tests retain a genuinely unsupported encoding and independently exercise reachable UDF traps versus trailing data.

The automatic writer strictly audited and committed the historical frozen ac5de03f partial snapshot; these are not new-development-head passes:

Audited ac5de03f assembly status	Exact versions
Actual Go/CPP/LLVM object proofs passed	3,246
Failed, retained for repair	720
Source/target-inapplicable, scoped evidence retained	690
Exact invalid-source skip	5
Exact superseded-version skip	2
Provisional native-layout skip; review still required	3
Pending	1,401
Total	6,067

Checkpoint 39 (ae8516d8, local evidence commit) contains 46,819 translated scopes in 48 completed failing shards and two partial shards (48, 49). The automatic writer and independent Go-1.27.1 readback validate 4,666/6,067 audited versions (76.91%), including 3,246 actual passes (53.50%) and 1,401 pending. Streaming verification checked all 256 module-hashed files, 6,067 unique exact-version/module keys, every status, positive object counts for every pass and the translation total. Every record matches its manifest SHA-256; all 50 immutable reports (793,099,108 bytes) matched their live-original hashes before/after copying. Only derived assembly-ledger files changed; the scan and semantic-source fingerprints remain unchanged. No entire shard has passed; all 64 are required, complete=false, verified=false. The three native-layout exclusions remain provisional and outside passes. These are historical frozen ac5de03f proofs, not newer-source or public-head passes. The live old-source run continues without rewriting this committed snapshot; later fixes are not retroactively attributed to it.

Subsequent reviewed repairs remain outside the running ac5de03f snapshot. Frozen cd5438b7 completed all non-root race suites, both nested CLI race suites, vet/build and the unchanged five-architecture gate. Its complete 32-partition root run recorded 3,516 passes, two real KMOV helper API failures and 37 existing skips; zero roots were incomplete and 20,621 subtests/seeds passed. This is preserved as a failed full-suite run. The mask-move dispatcher now binds its local opcode argument for old helper calls with empty instruction identity and rejects conflicting/unknown identities before emission. Complete B/W/D/Q, five operand directions, both x86 architectures, five target-object formats, negative forms, Go 1.27 race and Go 1.20 compatibility checks passed. Clean integrated b57d293b completed its fresh local regression with exit 0: all 32 root partitions passed (3,520 root passes, 20,747 subtest/seed passes, zero failures/incomplete roots and 37 existing skips), all 11 non-root package race suites passed (corpus 517.509 seconds), both nested CLI race suites passed (plan9asmll 260.772 seconds), vet/build passed, the unchanged five-architecture classification gate passed, and priority scheduling/actionlint passed. This is a complete bounded local regression, not remote CI success, full external-corpus completion, strict standard-library/benchmark success or native runtime proof of every external library.

The scalar SIMD/KMOV caller-region and complete Go floating-literal rewrite families now retain original-Go operand-form, initialized memory, register-alias, object and bounded semantic oracles. Packed moves and the complete named FMA3 caller family have since been implemented and tested as described below; mixed-CFG callers and full original Weaviate replays remain unfinished. Actual instrumentation early observation and same-mode pure-Go marker exports have complete source/buildmode/trace/archive/nm proofs. The separate original-source planner/export foundation retains full source bytes, import-C roles and mode/CGO/custom-tag decisions; four actual same-mode original exports and asmdecl proofs passed independent readback. Its later strict CLI and corpus consumers now independently consume dependency/header/CPP/LLVM object proofs, as detailed below; marker/query proofs alone still establish no candidate passes, C/SDK, sanitizer runtime or final linking. The test-only TEXT/DATA query mismatch is fixed with exact native object/listing/symbol equality, 18 LLVM object regressions across five architectures and the original Sneller replay above. Complete corpus/CLI race suites after that fix passed; their frozen proof does not substitute for the newer integrated-source rerun.

Latest reviewed local proof-family batch

The latest completed integrated checkpoint is local e58f19ea, not the public head. Independently enumerated strict JSON readback verified 485 roots/6,888 subtests on actual Go 1.27.1 race (813.900 seconds) and Go 1.20.14 race (1,010.764 seconds). Full scanner race passes 42 roots/132 subtests on both; owned actual-Go command tests pass 3 roots/6 subtests on both. Current-Go full corpus passes 417 roots/1,069 subtests (986.435 seconds); nested plan9asmll passes 169/1,311 (824.261 seconds), nested plan9asm 23/14 (2.560 seconds). Every selected root/subtest terminated; zero failures, skips, unknown, duplicate or incomplete tests. Nine deliberately corrupted reports are independently rejected. Both root-module lanes pass vet/build and five-architecture classification baselines; both nested CLIs pass vet/build. All tracked source hashes match before/after each frozen lane; default module dependencies are unchanged. These concurrent regression timings are not an isolated benchmark.

This integrates the preceding arithmetic/conversion/move/shift/comparison/packed families, source-bound acyclic and small finite-loop proofs, complete legacy packed-float native-storage guards, sealed actual-Go AMD64 frame observation with owned-command/lifecycle protection, deterministic scanner examples and actual-source namespace checks for Go 1.20–1.27/all five architectures. Observation alone grants no native backing or pointer/GC permissions. Three unresolved native-EVEX execution roots remain outside this focused root selection; the preserved Rosetta illegal-instruction failures remain real. Original reflect dynamic frames, full Weaviate/external libraries, the strict benchmark, complete root/current-source 64-shard suite and public CI remain unfinished. No historical ledger pass is promoted.

The current Go 1.27 official classification has zero unsupported forms on all five architectures. Go 1.20 intentionally retains its one historical VADDPD.Z X30, X1, X0 unsupported input: actual Go 1.20 emits 6291f58858c6, actual Go 1.27 rejects the missing mask, and LLVM 22 rejects the corresponding explicit K0 write-mask assembly. It is not repaired by falsely accepting that source. No baseline was changed for the latest batch.

The actual floating-literal oracle no longer skips Go 1.20. It derives the invoked driver's exact progedit rewrite from actual source/tool routing and rechecks source and binaries after all formats. Across the same 336 source forms, Go 1.20 produced 84 physical objects and 252 concrete source rejections; Go 1.27 produced 248 objects and 88 concrete rejections. The additional frozen 026f06da actual Go 1.21–1.26 matrix passed 13 roots/652 subtests per compiler, zero failures/skips, independent exact-list JSON audits, unchanged tool/source SHA-256 and all five architecture classifications. Go 1.21–1.25 produced the historical 84/252 outcomes; actual Go 1.26 already uses the newer 248/88 rewrite. The translator's current grammar is separately checked; unknown or changed rewrite bodies fail rather than borrowing version-number expectations. This is official-format compatibility, not six extra toolchains for external modules or a whole-root/runtime-library pass.

The native-storage audit independently compared complete before/after official reports for Go 1.20–1.27: exactly four signed packed conversion forms changed from supported to Context, with unchanged source/form universe, encoder catalog and every unrelated form. All fingerprints were independently recomputed; this was not a blind baseline update. Real old-source REDs are retained. The whole-instruction native conversion cannot use unbound virtual SP/BP storage or manufacture alignment/backing from a zero mask. Complete-width/mask/address negative tests and all three LLVM APIs passed.

The reviewed acyclic caller proof (69185adc) deep-clones states and intersects byte/mask knowledge across every path. Checked readonly-input offset spans are not allocation bounds or no-fault promises; fresh result/length slots, SP/BP/g, saved cells and numerical flags remain strict. The subsequent finite-loop proof (5426f621, integrated 9ad654c9) admits only one source-bound, unit-stride natural loop whose authenticated local length is masked to at most three. All feasible paths/iterations are independently replayed before final per-access certificates; missing facts cannot become zero, pointer bits cannot become numeric inputs, and all guard/source/normalized mutations fail. Actual original Go and independent LLVM/C callers each passed 1,536 initialized numerical/buffer/canary checks. Unknown/dynamic/multiple/nested loops remain Context: the first Weaviate fragment passes but its unchanged complete assembly still fails. Fixed private frame backing and actual composite/external source capture are separate ongoing work, not new candidate passes.

The original DATA-only native-name producer now follows actual Go's objabi.PathToPrefix byte algorithm, retaining foreign/static identity and the unchanged LLVM logical namespace. Its test-only RED and fix are integrated locally (435d5911, 17df96cf); merged current-Go race coverage passed five roots/239 subtests. Independently frozen fabb4794 passed the original github.com/typesanitizer/happygo@v0.0.0-20260816184930-d8118a4a932a default eleven targets with 65 LLVM objects (11 DATA-only, 54 TEXT). ROOT independently reran the strict reader and reproduced aggregate SHA-256 8dd566504ecf141029fffdfc3420f5e99555c1e8a27a93b5d9254c288f3ae721. Seven genuine original-Go target-scoped exclusions remain; this is neither execution nor a later-head/library-wide exemption. That separate exact run reports one pass/6,066 pending, complete=false, verified=false; it is not mixed into the old ac5de03f ledger.

Ordinary source-hash replay now uses a per-call validated index instead of a source-by-directory nested scan (0e9aa379, 4198ad33), without removing path/header/file-membership/source/package-diagnostic checks. The separate frozen 9b467633 full corpus race gate passed 417 roots/1,069 subtests (zero failures/skips), and actual-Go-1.20 focused binding tests passed. At 2,048 directories, the isolated benchmark's median improved from 785.032 to 66.417 ms (11.82x), with roughly 12% greater allocation bytes; this is not an end-to-end corpus or strict standard-library budget pass.

The comparison-family development has complete shared Go-table grammar and declaration-backed caller effects. Independent tests exposed real lost MXCSR denormal/invalid effects in relation-only LLVM comparisons; the native whole-instruction repair preserves the actual predicate byte, native memory tuple, masks and SAE. The complete object/legacy-focused gate at clean 41382be3 passed 58 roots / 565 subtests on actual Go 1.27 race (69.651 seconds) and Go 1.20 (48.852 seconds), with zero failures/skips and vet/build passed. At separately frozen c1d712e4, authenticated Linux ARM64 plus pinned QEMU 10.2.3 AMD64 guest execution passed all 11 required roots and the buffer-lifetime root on both Go versions. Per toolchain, 384 translated VEX forms passed 1,492,992 full IEEE/MXCSR/CF/64-byte-alias/canary samples at each O0 and O2; original SSE (62,208), original VEX (373,248), exact raw legacy predicates (100,352), and six unaligned/fault observations also passed. The original Go 1.20 allocation/GC failure was repaired and genuinely rerun, not erased. Source, tool, driver and mod/sum hashes agree before/after. This is guest execution, not native AMD64 hardware, and does not prove unmasked trap priority or EVEX execution. The subsequent combined local 3d1bf462 regression failed (344.288 seconds): three full-EVEX/FP/dead-result roots hit illegal instructions on Rosetta; no full combined-suite pass is claimed. The VEX tests are integrated locally as 8d447cef, not published CI evidence. The complete original Weaviate replay on 490a05de still fails, including pointer-state changes at loop joins and unfinished SIMD caller effects; no whole-module success is claimed.

The historical frozen 7b09d183 full regression is finished, not running: all 32 exhaustive root partitions and eleven non-root/nested CLI race suites completed. The root suite and related local gates passed, but strict standard-library and benchmark gates still failed on original reflect dynamic caller frames; the full driver remains failed. Earlier 79d6d84c failures, including genuine stock-Go malformed-input panics, remain retained. Such panics are explicitly labeled defect observations, never ordinary compilation or source-N/A certificates. Newer family-specific validation below does not promote that failed full driver.

Bounded repair / exact evidence source	Result
Complete named FMA3 typed grammar and caller effects	All 60 Go mnemonics and 1,836 AMD64 formats; independent initialized-input/mask/memory/alias negatives and five LLVM 22 target-object formats
FMA3 finite fixed-rounding semantics	Actual LLVM 22 reproduced a 1-ULP ambient-rounding error; exact integer helpers pass 640,000 independent float32/float64 edge/cancellation/DAZ/FTZ/fenv checks and all format numerical checks
FMA3 clean development gates 4646273c	Full focused race 293.387 seconds; actual Go 1.20 compatibility 54.503 seconds; vet/build passed
Independent integrated 926d5755 focused family / complete CLI race	Passed, 698.947 / 885.085 seconds; these source-specific results precede the later ARM64 integration
ARM64 large-frame implicit R20 34083a5e	Explicit original-and-normalized ABI0/frame/escape/initialized-input proof; 124 scalar/GP/FP-pair variants and 606 structure variants, three APIs and five objects; Darwin and native Linux original-Go plus independent LLVM/C numerical/canary checks passed
ARM64 producer/consumer activation 91590729	Complete original 32/32 failed ARM64 roots now pass; full focused race passed in 565.884 seconds with 103 root passes, preserving unknown-input, escape, incomplete-TEXT and frame-boundary negatives. Native Linux ARM64 replay passed (169.561 seconds), with 31 original roots passed and one old Darwin-only divide test separately skipped; the new required divide counterpart below fills that executed axis
ARM64 exact-head Go 1.20	Original namespace failure retained; explicit test-only runtime identity repair e00947f6 passed the complete family on actual Go 1.20 (163.001 seconds) and Go 1.27 (129.995 seconds). The later clean producer/consumer repair 91590729 also passed its complete family on actual Go 1.20 (170.630 seconds); vet/build passed
Foreign test-dependency original module boundaries	ZIP-bound nested roots, signed legacy proxy metadata as a separate origin, every observed metadata-copy canonical/hash guard before and after final objects; complete integrated shared race passed at 468c9430, complete CLI race passed at 926d5755
Instrumentation separate mode metadata / CPP / LLVM objects	Strict CLI invocation 453f2c53 retains full source/ABI0/mode/tool/file identities and separately bounded object counts. Four actual mode/CGO subprocess matrices, valid JSON formatting and paired-proof negatives passed (140.858 seconds); clean exact-head complete CLI race passed (1,380.082 seconds). Independent integrated shared race / actual four-mode CLI race passed (402.096 / 561.523 seconds)
Actual instrumentation corpus/report/progress/ledger consumers 4761aa27	Mandatory independently derived requirements, including canonical empty arrays; real original-Go exports, metadata/header queries, CPP and physical LLVM objects. Focused race passed (135.973 seconds), actual Go 1.20 reader checks passed (3.369 seconds), vet/build passed. Paired erasure/downgrade/layout mutations fail. Real early-target rejection and supported-target CGO prerequisite failure remain failures, not ordinary N/A. Full clean corpus race passed (1,246.298 seconds), shared race passed (87.837 seconds), and native Linux ARM64 mode-object consumer tests passed (62.136 seconds, zero skips). Independent integrated corpus race passed at aba5f1d0 as above; zero new external passes claimed
Filename-only discovery pruning 1d4a08fd	Stock Go filename matching removes impossible partners before header/SAT work without reducing final source checks. Five-architecture regression reduces one measured fixture from 61 header reads to one; clean full corpus race passed (638.745 seconds). Independent integrated focused race/Go 1.20 passed (1.718 / 0.584 seconds). This is not a whole-scan or benchmark performance claim
Go header/BOM selection c5e0f27d	Actual Go reproductions retained: legacy last-blank/block boundaries, duplicate modern constraints and first-byte BOM capture. Production capture-to-portable-reader test retains all six source cases across five architectures. Focused race/actual Go 1.20 passed (3.947 / 4.169 seconds), independently reviewed source bytes and hashes stay unchanged; complete clean corpus race passed (1,094.444 seconds), vet/build passed
Initialized divide/remainder Linux counterpart 44d6f86e	Actual Go and all three LLVM APIs cover 96 U/S W/X forms × 72 inputs, aliases/ZR, zero/min-overflow, NZCV and byte canaries. Native Linux ARM64 run passed (6.059 seconds): four required roots, zero skips. Independent integrated Darwin race/Go 1.20 passed (12.027 / 6.541 seconds)
Complete scalar REM quotient/R27 effects eaa6a467	All eight scalar opcodes follow original Go DIV-to-R27 then alias-sensitive MSUB, W zero-extension and zero/min-overflow behavior; code/LR/private-frame/range witnesses cannot survive a clobber. Original-Go bytes and 800 formats × 72 initialized inputs, flags/canaries, three APIs and five objects retain actual REDs. Focused race passed (442.948 seconds), Go 1.20 passed (178.453 seconds), native Linux ARM64 passed (155.681 seconds; one old Darwin-only test skipped, all new required axes executed). Independent integrated official five-architecture gate and eight-opcode extraction passed at 0e0dec25; integrated Go 1.20 family passed (43.636 seconds)
Complete generated-header byte bound 9085999e	Original Canvas GPU/GL header has 4,642 definitions; the true 4,096-cap failure is reproduced and fixed without truncation. Parsing, canonical output and independent readers use the same 64 MiB byte budget, retaining duplicate/invalid/oversized rejection. Actual >5,000-definition Go grammar and LLVM objects cover all five architectures, with late-definition mutation negatives. Clean shared/focused race, Go 1.20 and CLI vet/build passed; independent integrated shared/CLI race and actual Go 1.20 checks passed at a245d7f7. This does not claim Canvas whole-library or runtime success

The real ARM64 scratch-register RED is fixed in reviewed clean ed353f0c, integrated as 1bd807b4: all 30 arithmetic/logical/compare X/W mnemonics follow actual Go constant/register classes, including complete MBCON rows. Private decoded WORD origin prevents source-pseudo scratch effects and four raw-PC false resolves. Safe original-Go/three-API numerical oracles cover 1,364 class/alias formats × 8 inputs; 24 raw/source cases × 8 inputs, 16 expected SIGILL fault cases, and 8 precise old/new source-encoder Context witnesses are counted separately. Frozen Darwin full 14-root race passed (153.682 seconds; zero skips). Native Linux ARM64 exact Go 1.27.1/LLVM 22.1.8 family passed (191.438 seconds; 14 roots, zero skips); its broader 85-root native guard run passed in 218.160 seconds (zero skips), alongside the 86-root Darwin race guard run in 292.145 seconds. Actual Go 1.20 checks and full table-completeness checks passed; RSP operand/table coverage is not claimed as exhaustive numerical runtime. Independent integrated/full gates and original-library replays remain required. The private per-call instrumentation-planning index is integrated at 511c01b4; independent focused race (145.038 seconds), Go 1.20, vet/build passed. Clean 4c05ad9e full corpus race passed (982.710 seconds). Test-only follow-up a723535f runs the frozen baseline and index in the same benchmark invocation: busy-host samples are 9.07–10.02 ms/10.74 MB versus 1.90–2.15 ms/2.93 MB, with identical requirements and preserved errors. The follow-up's race/Go 1.20 checks passed (2.828/0.874 seconds); no whole compile-benchmark improvement is claimed. That complete frozen integration was 45baf2e8, not the published CI head; later development is tracked above and all complete gates remain source-specific.

Independent source-45baf2e8 original-library reruns now passed their full default 11-target production and strict report readback:

Exact module	Original applicable files	Translated/object scopes	Result
github.com/CWBudde/algo-fft@v0.8.0	184	585	Passed across eight successful targets; original source exclusions retained
github.com/Parquet-Go/Parquet-Go@v0.32.0	21	63	Passed across three successful targets; nine original asmdecl source rejections retained

These two reports have a matching source/tool/scan identity and are not copied into ac5de03f. Their 65,536-way diagnostic ledger was automatically read back but is not committed: its sparse pending-shard list would bloat the contribution. Reviewed producer-only exact-key replay b143e3bf preserves the normal 64-shard and all-candidate/full-target denominator, with unexecuted candidates pending and partial reports unable to pass completion. Its focused race, actual Go 1.20, vet/build gates passed, but its first complete corpus race genuinely exceeded the unchanged 45-minute limit and exited 1. The CLI regression's context-unbounded subprocess reproduced the lifecycle defect; follow-up f928e11c bounds that test subprocess and passes exhaustive corpus race verification in eight disjoint serial partitions: all 408 listed roots and 1,050 subtests/seeds passed, with zero skips, failures or missing roots. Inventory/plan/actual-run equality was independently checked. This full package result does not cover later integrated source or other packages. Both original libraries share normal shard 36 and must be genuinely rerun together after the final new source is frozen, not relabeled from these reports.

The wider source45 actual-Go1.20 71-root integration replay retained a genuine 70-pass/1-fail result: GP-data's generated module incorrectly demanded Go1.27. Nine dependency-free fixture minima were independently audited and integrated (5b3b5ded / 202873b1); their original source-only Linux runs still failed on the repeated helper and cold sink startup. Separate test-only 6162b2c7 / integrated 4221bfb5 replaces the executed repeated helper's temporary g/R18 writes with ordinary R22/R23 and adds a decoded-effect safety guard. Both actual Go1.20.14 and Go1.27.1 passed its four-root Linux/QEMU10.2.3 runtime/object checks with LLVM22.1.8 (24.951 / 27.422 seconds, zero skips), including 1,280 original-Go and independent LLVM/C numerical/canary comparisons. This does not claim runtime execution of the separate temporary-g source/object cases. The separate sink repair 8190f42b, integrated as b484c3ae, retains two genuine false-positive REDs: an expired startup budget and a prior SIGKILL with a descendant holding the pipe. Absolute monotonic startup checks and this invocation's acknowledged direct-child cancellation now pass 22 focused tests on actual Go1.27.1 race (16.571 seconds) and Go1.20.14 (13.199 seconds), with zero skips and both versions' vet/build passed. Its marker proves caller readiness, not an independently observed ASM PC. Earlier bounded Linux runs passed before this review. Fresh ea928e91 verification now passed the exact selected ten required ARM64 runtime roots and 22 owned-observer/lifecycle/unit roots on both actual Go1.27.1 and Go1.20.14, with LLVM22.1.8 and QEMU10.2.3. Current/old Go runtime suites took 115.182/105.168 seconds, including the unchanged 26,880 SM3 comparisons and acknowledged one-second self-BL observation. All selected roots have zero skips/failures; this is not the entire root suite or external-library runtime coverage. The first attempt retained a genuine prepared-module checksum failure; a separate v2 attempt settled and verified authenticated private dependencies before freezing and independently checked tracked source, tools, drivers, configuration, exits and before/after hashes. Both disposable containers and their owned tmpfs caches have exited and been released.

Runtime-command cancellation independently reproduced a live descendant retaining its output pipe. Clean owned-group/pipe-bound repair c00bb02f, integrated as 9231de50, passed all 125 affected root race tests (2,430.367 seconds, zero failures or skips), actual Go1.20 helper checks, vet and build. Unix descendant ownership is explicit; non-Unix retains bounded direct-child behavior without a descendant claim. Clean seven-scalar-GP-MOV memory family ef40a159, integrated as cb52ce42, fixes the retained stale-R27/caller-link, false raw-PC-width and private-frame consumer REDs. It shares Go's ordered expansion across lowering and every state proof, with 537 actual-Go positive formats, 161 common negative formats and seven separately observed pool-to-R27 version boundaries. Darwin current family/consumer race passed all 86 roots (151.280 seconds); actual Go1.20 family passed 22 roots (19.350 seconds). Native Linux ARM64 independently passed the 22-root family on Go1.27.1/Go1.20.14 (34.347 / 33.256 seconds), and all 62 current-Go consumers passed (84.509 seconds), with zero skips. The widened old-Go consumer run genuinely failed (53P/9F): eight old fixtures required Go1.27 and one retained a newer prologue expectation. Its whole container run exited 1; this does not erase the exact family successes or claim whole compatibility. Initialized original-Go and three-API LLVM/C numerical/NZCV/full-canary checks cover 296 variants plus 21 parameter/result/AUTO partial-write cases and five target-object formats. RSP remains class/object evidence only; differing source encoders, native FP/SB page identity and unproved classic CALL transport remain precise Context. No whole external library pass is inferred from these family gates. Missing reflect dynamic caller/result/closure/GC/native-entry contracts remain explicit, not instruction-grammar skips.

The integrated new scalar-memory Go audit was independently caught bypassing the owned lifecycle by a new AST RED; 88bc17eb fixes it and passes 27 roots on current Go race / actual Go1.20 (42.401 / 24.389 seconds), with vet/build passed. The old scalar writeback Go oracle had the same defect; dc278f7b adds its own real regression and passes current race / Go1.20 (6.748 / 5.724 seconds). Reusable LLVM compile, C link and executable-run stages are repaired separately in 261c5680 / integrated 28632446: each receives a new five-minute budget bounded by the test's existing overall deadline minus cleanup reserve, retains actual failures and uses the existing owned lifecycle. Focused race / Go1.20 checks (8.111 / 7.920 seconds), clean-source race readback, ownedprocess race, vet/build passed. These bounded repair checkpoints are not full-suite or current public CI passes.

Independent exact replay at frozen f928e11c passed github.com/parquet-go/bitpack@v1.1.0: 21 original applicable assembly files, 63 actual LLVM22 object translations across six eligible target configurations, preserving all eleven default targets. Its normal shard is 13/64 with 90 candidates; only the requested exact candidate ran, so the report remains partial and 6,066 candidates remain pending. Three additional AMD64 SIMD profiles retain nine structured original-Go source rejections caused by incompatible slice/array API usage; those are not object passes or a whole-module skip. The original official-proxy network timeout is preserved as a separate failed attempt. Strict readback accepts the report, while the complete-coverage gate correctly exits 1. This object-translation result is not llgo compile/link/runtime coverage and is not relabeled for the later integrated head.

Original github.com/gostdlib/datastructures@v0.0.0-20260830230742-bc9fa7cfd548 was replayed at clean a245d7f7 using the full default target matrix. The new instrumentation denominator/consumers are actually reached, but the candidate remains failed with zero LLVM objects: original same-mode dependencies reject grpc@v1.73.0's use of missing http2.TrailerPrefix, while Linux CGO export from a Darwin host also lacks its real cross C/SDK environment. The exact failing mode observations are retained in the strict report; no missing SDK, original dependency failure or query is promoted to a translation pass. A separate authenticated ZIP/source audit confirms the old goroutine-pool version declares /gp-goroutine-pool but imports /go-goroutine-pool; that original dependency-identity failure remains failed, not a fabricated alias or assembly-invalid skip.

Independent final-source ea928e91 exact replays have now passed all six requested original modules with the default eleven targets, unchanged 6,067-candidate denominator and normal 64-shard ownership:

Exact original module	Applicable file identities	LLVM 22 objects	Result
github.com/CWBudde/algo-fft@v0.8.0	184	585	Pass
github.com/Parquet-Go/Parquet-Go@v0.32.0	21	63	Pass
github.com/parquet-go/bitpack@v1.1.0	21	63	Pass
github.com/segmentio/parquet@v0.0.0-20230712180008-5d42db8f0d47	24	72	Pass
github.com/mdisibio/parquet-go@v0.0.0-20251113212313-bb7dcf6d014e	21	63	Pass
github.com/MeKo-Christian/algoforge@v0.8.0	184	585	Pass

The producers and strict source/tool/scan reader exited 0: six actual candidate passes, 1,431 physical objects and 455 applicable file identities. Thirty-six concrete original-Go SIMD/asmdecl source exclusions remain scoped and are not passes. These are five partial shard reports, zero complete passing shards, and 6,061 pending candidates. The complete-coverage gate correctly exits 1. No results were relabeled into the old-source assembly ledger; after later source changes, the modules require another matching-head replay. Owned replay caches were removed only after their writers closed.

Reviewed post-ea928e91 repairs now include an owned TEXT fixture for isolated ARM64 AUTO probes, complete integer/floating operand rejection, precise writeback-overlap diagnostics and legal unknown-SP transfer fixtures. Current Go race, actual Go1.20 and vet/build passed at their respective clean fix sources; normal full-source/escape/decoder guards stay strict. The complete barrier family preserves unknown R27 without observing or materializing it, rejects Go-invalid floating immediates, and fixes SB's exact byte encoding. Original Go and independent LLVM-MC agree on d50330ff; all five LLVM target objects retain that encoding. Its final current-Go family has ten passing roots; four old-Go common roots pass separately because the original Go1.20 assembler does not define SB. An earlier overly broad HINT rejection failed on LLVM's unrelated return-address instrumentation and is preserved; the final source-IR and exact-byte assertions do not prohibit legitimate compiler-generated instructions. Counted-callee and self-BL escape repairs have been independently reviewed and integrated: only a complete original/normalized same-file RET-only callee can narrow scratch observation, and escape negatives use Go-legal transfers with actual Go raw-branch bytes. Combined source 77b3c540 passed 67 focused current-Go race roots and 66 actual-Go1.20 roots, plus the separately executed current-Go SB byte root, with zero failures/skips. Vet/build and the unchanged official five-architecture gate passed. No latest-head complete regression or remote CI pass is claimed.

The separately reviewed test-only FP-pair repair preserves the original C numbers and pair instructions. Actual Go establishes 544 stale-reference mismatches from the old eight-byte MOVD observation; both its whole-eight-byte independent reference and canaries pass. Corrected scalar observations use their actual one/two/four/eight-byte widths, with three typed APIs, initialized numerical/full-canary oracles and twenty objects across five ARM64 targets. At clean b0cf74a8, Darwin current-Go race and actual-Go1.20 gates each passed twenty roots (63.722/18.491 seconds). A frozen read-only Linux/amd64 driver with pinned QEMU10.2.3 passed all nineteen mandatory Linux roots on each actual Go version (89.632/70.279 seconds), zero failures/skips, LLVM22.1.8, exact authenticated private graphs and complete source/tool/config before/after checks. The first selection's actual host-inapplicable skip and exit1 remain preserved; the separately executed Darwin-only extra root is not falsely claimed as Linux execution. Both owned containers/caches have closed. This is bounded family runtime evidence, not all-library runtime or new-head ledger promotion.

The ARM64 decoder baseline change was independently audited, not blessed to make a gate green. The exact previous baseline source reproduces its old fingerprint with the same Go/x-arch input. Six changed ADD/SUB forms contain only Go-invalid extended-register shifts five through seven; two changed native register CALL/JMP forms genuinely need callee/frame/continuation context. The new stock-Go oracle checks eight W/X/flags aliases, all eight extensions and shifts zero through seven: 512 cases, 320 accepted objects and 192 genuine source rejections, on both actual Go1.27.1 and Go1.20.14. The strict selected-family decoder gate passes all 691 Go-accepted cases, with zero unsupported/parse errors and 38 contextual forms; the broader decoder includes reserved encodings and is not a Go-valid instruction list. The ordinary five-architecture baseline remains unchanged. Frozen 6f79dc26 has completed the full regression described above; its strict standard-library/benchmark failures still prevent whole-pipeline success.

The shared Go assembler repair retains fifteen genuine infrastructure false-positive REDs and fails missing tools, killed commands, footer-only errors and absent objects. Complete LEAW/L/Q effects and helper identity are integrated. Combined source d76f97a4 passed 107 focused current-Go race roots (103.730 seconds) and 51 actual Go 1.20 roots (26.761 seconds), with zero failures/skips; later commits need fresh gates.

Newly integrated coherent family	Bounded evidence, not whole-library completion
Fourteen scalar MOVSX/MOVZX forms and physical register aliases	Complete Go tables, three APIs, five object targets, defined-low-byte and pointer/CFG negatives; 8,704 original-Go and 26,112 LLVM/C numerical calls per toolchain. Case-compatible helper identity rejects conflicts before IR
Original g/R14 private PUSH/POP identity	Opaque token, no numeric entry value; every return restores original identity. Ten positive variants, twenty strict negatives, raw-leaf false-success regression, 4,356 original-Go/LLVM mathematical calls and 2,304 original-Go context checks per toolchain
Thirty-two packed logical mnemonics	Shared complete legacy/VEX/EVEX grammar, caller effects, masks/broadcast, fault-suppressed memory and coherent X/Y/Z bytes. Five x86 target objects, 7,552 independent LLVM/C numerical checks and 147 original-Go ANDNOT checks; related race 84 roots passed. Production code is 194 lines smaller than its separate lowerers
ARM64 final narrow-parameter alignment gap	Actual full declaration/Sizes plus original and normalized bounded bit-dependency proofs, exact per-read consumer; padding is not presumed initialized and source load width remains unchanged. Forty-six scalar/vector cases, four target objects, 13,984 randomized-padding original-Go calls and 3,496 LLVM/C checks. Clean a15735b1 complete nested CLI race passed in 680.534 seconds; the prior zero-size-signature failure is preserved

These four earlier batches and the following coherent fixes were integrated at clean 7b09d183. Its complete frozen run has finished with exit 1: all 32 root partitions passed (3,771 root passes, 25,001 subtest/seed passes, zero failures/incomplete roots, 38 existing skips counted separately); all eleven non-root race suites, both nested CLI race suites, vet/build, official five-architecture classification, selected-family decoder and scheduling checks passed. Strict standard-library and benchmark gates still fail on original linux/386 reflect dynamic caller frames; 19 of 33 applicable benchmark files compiled before that failure. Neither benchmark completeness nor its performance budget passed.

Latest clean integration is local 610f53df, not the public head. It includes all 24 legacy/VEX/EVEX insert/extract opcodes, both vector-zero opcodes and authenticated test-dependency embed closure. The combined regression independently enumerated and passed 123 roots / 3,263 subtests on both Go 1.27 race (348.325 seconds) and actual Go 1.20 (226.430 seconds), plus the separate inactive-memory-fault root on both toolchains: 124 unique affected roots in total, zero failures/skips. The complete merged CLI race suite passed (795.285 seconds; 1,362 root/subtest passes), as did full shared-profile/corpus race suites (109.943 / 955.740 seconds; 1,972 root/subtest passes). Vet/build and unchanged official five-architecture classification passed. FP fixtures now derive their result alignment from actual Go declarations instead of hand-made ret+4 layouts. Original-package replay and native Linux follow-up remain separate required gates. Packed logical shifts and signed scalar conversions are still independently finishing their complete native-width/FP-span/mode32/exception contracts and are not claimed as merged or whole-library passes. A fresh MUL/DIV regression retained actual caller failures and an LLVM 22 O2 defect: constant-folded MULSS lost MXCSR precision status and RU rounding. The separately frozen 37b9f0e1 required Linux driver passed its ten padding/raw-branch/unpack/horizontal roots on both Go toolchains; it was Linux AMD64 emulation on an ARM host with pinned QEMU, not native AMD64 or AVX512 execution.

Newly completed local family/mechanism	Evidence boundary
Eight HADD/HSUB mnemonics	Shared complete legacy/VEX grammar, caller effects, original-Go SSE3 and independent LLVM numerical/flags/MXCSR checks; native AVX execution not claimed
Twenty-four integer/floating unpack mnemonics	Complete shared grammar/lowering/caller effects, five target objects, full-byte aliases, independent FP fields, MMX native 4/8-byte reads and mandatory E4NF zero-mask faults; 14,208 LLVM numerical checks and original-Go SSE/MMX checks
Bounded ordinary invocation JSON	32-MiB shared strict producer/consumer limit with overflow/trailing/null/unknown-field negatives; full shared/corpus/CLI race checks passed at their frozen source
Insert/extract, packed shifts, qualified embedded assets	Separate TDD work remains active; no whole-library pass is inferred from a family or protocol test

Latest complete family / strict repair	Independently bounded evidence
Native raw opcode 63 widths	Correct 16/32 copy and REX.W sign extension, original byte identities, all 768 register ModRM combinations, three APIs / five targets and original-Go objects. Per toolchain 25,344 LLVM/C checks preserve three flags seeds. Vendor-dependent 16-bit memory remains Context. Darwin/Rosetta numerical checks are diagnostic; required Linux native-AMD64 runtime is still pending
Sixteen ordinary floating ADD/SUB mnemonics	Complete current-Go legacy/VEX/EVEX attributes and shared initialized caller effects. 916 function-format witnesses inside five object files, 93,696 LLVM/C checks, 384,000 fixed-rounding helper checks and 28 original-Go SSE NaN/invalid/tie/sticky cases. These do not establish native AVX512 or whole-library execution
ARM64 raw framed branch CFG	All 29 B/conditional/CBZ/TBZ forms through three APIs and five target objects. Actual Go encoding fields across Linux/Darwin/Windows retain source boundaries; original-Go and LLVM/C each execute 232 mathematical cases with canaries on Darwin. Required pinned Linux/QEMU counterpart is pending. No permission to clobber reserved R18/g
Strict Go backend diagnostics	Positionless/frame and PC-listing rejections require actual exit 1 and exact source-bound operand/frame/opcode identity. Footer-only, spoofed, panic, timeout, signal and cleanup failures stay rejected as evidence

Original Arrow's independent default-11 replay at 79d6d84c remains failed: the frame/PC-edge repair exposes an un-restored original R18 identity. Zero completed candidate translations are reported; a successful child or source-unit test is not a whole-library pass. Original canonical github.com/weaviate/weaviate@v1.39.6 remains failed under its normal shard 46/64 ownership, complete 6,067 denominator and default eleven targets. Original 3df64541 failed first at VHADDPS; after the complete HADD/HSUB repair, frozen 04cc1cc3 now reaches VZEROUPPER. That replay still records six successful children, ten failures and outer 0 passes / 1 failure / 6,066 pending; later ten targets did not execute. The insert/extract repair is undergoing mandatory legacy INSERTPS/EXTRACTPS review before integration. Vector-zero, packed shifts and remaining conversion/compare/multiply/narrowing/control contracts stay explicit work. No source push or new CI run is claimed.

Independent original-library replays expose remaining real failures without changing source or ledger status: github.com/Creativesoftwarefdn/weaviate@v1.39.6 currently produces six objects before ten applicable translation failures, first the complete LEAW/L/Q source/caller effect family; MOVSX/ZX and later vector/control families remain separate work. github.com/hummingbirddb/arrow-go/v18@v18.0.0-20260904202957-6542b630f84d reaches an original MOVD wider than its int16 parameter. Actual Go accepts the source, but its wrapper leaves the alignment padding unspecified. A private actual-declaration and whole-source bit-use proof is under development; padding is not assumed zero and source bytes are not rewritten. Original network failures and every unsuccessful production replay are retained. Neither library is counted as passed.

Native AVX512 execution, raw FP16 fixed-rounding semantics, original Weaviate/Arrow whole-library success and broad external-module execution are not inferred from these bounded family gates.

The complete zero-byte source-only sibling repair 2767ac60 preserves original ZIP members, complete actual Go SFiles and pre/post object source guards without fake objects; independent integrated shared race (159.345 seconds), real producer/LLVM/reader race (189.925 seconds), vet and actual Go 1.20 checks passed at 90f2d313. Fresh original Sonic v1.15.4 replay has crossed that loader boundary and now fails on 23 ARM64 NEON wrappers' JMP (R11) native frame/LR/register-result contract; it produced zero LLVM objects and the remaining nine target configurations did not complete. Reader consistency only establishes that this failed report is authentic. A separate original-ZIP audit compiled all 23 original wrappers with stock Go for both Darwin and Linux ARM64 (46 Go objects, not LLVM objects, no target execution). Their real code addresses, continuations, mutable native-entry pointers and Go runtime stack protocol still require a separate compiler/runtime bridge; no source-name whitelist or weakened indirect jump is accepted.

The AMD64 numeric fixture's invalid .Z stores were independently reproduced as SIGILL, then replaced by legal merge stores in clean ea28ca32; original-Go, normal LLVM numerical results and the complete 10-opcode/X-Y-Z expected-fault Go/LLVM oracle passed a 64.584-second focused race run and an actual Go 1.20 run (138.157 seconds). A numerical-fixture guard now rejects a reachable invalid-opcode trap instead of silently accepting it. Production trap semantics remain unchanged. Public current-head CI, all 64 corpus shards, strict stdlib/benchmark and review remain required.

Independent inventory checkpoint (not imported into this running snapshot)

Source-inspection funnel	Count
Contiguous Index records	20,042,489
Unique module paths	1,015,166
Successfully inspected retained exact versions	1,021,034
Assembly-bearing exact versions	6,371
Original assembly files	81,518
Inspection failures retained for retry	16,600
Direct-cgo module paths, outside this repository	22,072

The scanner has completed its requested cutoff interval, 2025-10-01T00:00:00Z through 2026-09-30T02:32:07Z, in 304 validated contiguous ranges and is not currently running. The general history_complete=false flag refers to older global history outside that cutoff. These source-only results are a separate pending compilation queue, not current plan9asm passes. Import waits for the frozen corpus writers to exit; the 6,067-version running denominator remains unchanged.

The automatic writer has committed and read back the matching incomplete e81e966a assembly snapshot (b42a7f51) in a separate evidence worktree:

Audited local-source assembly status	Exact versions
Passed with actual Go/CPP/LLVM object evidence	460
Failed, retained for repair	54
Source/target-inapplicable, scoped evidence retained	96
Exact invalid-source skip	2
Exact superseded-version skip	1
Pending	5,454
Total	6,067

This historical snapshot contains 9,589 translated scopes and all six completed failing priority shards, with no partial report remaining. The other 58 required reports are missing, so it remains complete=false, verified=false. Source changes invalidate reuse; these results must not be relabeled as evidence for ac5de03f or the new declaration protocols.

The batch includes typed ARM64 wide-FP fallback, exact raw self-BL sink semantics, rejection of floating operands in integer GP forms, bounded scheduler/SVC control guards, x86 raw far returns, actual-Go legacy build-constraint handling, original pre-CPP rejection proofs and explicit dynamic-FP diagnostics without invented caller padding.

The complete ARM64 raw UDF imm16 family is now decoded, preserving every immediate in the 65,536-encoding field. Tests check exact function-bound object bytes on Darwin, Linux GNU/musl and Windows. Independent original Go and LLVM/C calls verify SIGILL on native Darwin/ARM64 and native Linux/ARM64 with actual Go 1.27.1 and LLVM 22.1.8. The required cross-runtime test prefix is wired into the existing CI lane. Floating WORD/exception-immediate source classes first reproduced failures, then passed strict Go-compatible rejection checks. Focused race, Go 1.20 root compatibility, the unchanged five-architecture official baseline, vet and build all passed at the respective frozen fix source.

A related performance regression retained a real 15-minute race timeout in the original large SVE pool group. Per-analysis, complete-machine-word effect reuse now removes the repeated decoder's 84 allocations and roughly 15 KB per warmed query: the microbenchmark changed from 13–17 microseconds to about 2.7–2.9 nanoseconds, zero allocations. The unchanged large SVE fixture compiled all three target objects under the race detector in 216 seconds; related pool tests, Go 1.20 compatibility and the official baseline passed. This is a bounded hotspot improvement, not a passing complete compile benchmark.

Separate original-library default-11-target replays passed for github.com/Consensys/gurvy@v0.21.0 (62 applicable scopes, 186 LLVM objects), github.com/KlausPost/reedsolomon@v1.14.2 (six original files, 27 translated scopes) and the audited LetsGo-OS source (nine applicable files, 16 objects). Each retains its exact frozen source, original-source exclusions and sparse-ledger pending accounting; none proves all 6,067 versions.

Original github.com/ajaxorg/ace@v1.44.0 completed its default 11-target replay at the separate clean Fortran-proof fix. All 22 original file/target scopes have independently verified stock-Go pre-CPP or CGO-disabled Fortran-loader refusals. The strict reader records one source-inapplicable candidate, zero passes, zero failures and zero LLVM objects: this repairs attribution without manufacturing translation or runtime coverage.

The actual-Go test-only declaration/callee mechanism initially retained a real gensimd failure caused by an unbound same-module pure-Go test dependency. The source-only dependency-closure companion at clean 56e76b8d passes the original exact gensimd version's full default-11-target replay: one passing candidate, 12 applicable original files and 36 LLVM 22 objects across Darwin/Linux/Windows AMD64. Its complete CLI (117.084 seconds), corpus (248.721 seconds), strict reader, vet/build and Go 1.20 compile checks passed. The mechanism is integrated and the new ac5de03f production shard independently reproduces its passing result; original failed evidence and other target/ABI exclusions remain preserved. This is not a complete queue or runtime pass.

The x86 private caller-region source producer, scalar source-stack/CFG consumer and actual CLI-loader binding are separately reviewed and integrated in ac5de03f, with subsequent family completion described above. They require complete original typed Go callers, exact pointer/void declarations, unchanged actual package-load selection, per-access bounds and identity, initialized numerical output tracking, and balanced stack restoration; unknown effects, overlays and unbound generated sources still fail. Family fixtures do not establish original Weaviate or native AMD64 runtime success. Reviewed CPP fixed-search and included-header EOF repairs retain genuine original-library failures and bounded passing counterparts. The strict reflect.makeFuncStub dynamic-frame contract, current-head complete corpus, full CI, exclusions review and final ledger verification remain unfinished.