Ori 2026.04.26.1-alpha (Nightly)

Ori v2026.04.26.1-alpha

This release tightens iterator correctness end-to-end — from type checking through code generation — and improves the precision of several diagnostics that previously pointed at the wrong location or emitted the wrong error code.

Compiler

• flat_map closures now get a precise, well-located error. Previously, passing a non-iterator-returning closure to flat_map either silently miscompiled or produced a confusing "cannot infer type" (E2005) at the call site. The type checker now catches the shape mismatch early and emits E2001 (unsatisfied bound) pointing directly at the closure body. Divergent closures (panic, unreachable, infinite loops) are handled correctly and no longer leave unbound type variables that trigger spurious follow-on errors.

• E2005 ("cannot infer type") messages are now site-aware. Empty list literals ([]) suggest an explicit type annotation (let x: [int] = []). Lambda expressions with an unresolved parameter type narrow the error span to the specific parameter token rather than the entire lambda body. Other expression sites retain the existing wording. This makes ambiguous-type errors actionable without hunting for the right sub-expression.

• Free variable collection now covers all compound types. A silent gap in type generalization caused bindings whose initializers contained Struct, Enum, or Scheme types with free variables to be under-generalized — those type variables were quietly dropped rather than collected. This is now fixed, and the implementation delegates compound-tag traversal to a shared canonical walker so new compound types are covered automatically going forward.

• Codegen adds safety guards at JIT and AOT monomorphization entry points. Secondary assertion hooks now fire if any unresolved type variable survives into the pre-monomorphization IR, attributing the violation to the correct pipeline stage rather than surfacing it deep inside lowering.

Bug Fixes

• Fixed incorrect memory strides in flatten and flat_map for non-pointer-sized element types. The LLVM emitter was passing the size of the iterator handle (always 8 bytes) to the runtime instead of the size of the inner element. This was accidentally correct for int but silently produced wrong-stride memory operations for bool (1 B), char (4 B), and tuples. Both iter.flatten() and iter.flat_map(f) are now fixed; flat_map additionally had a second bug where it used the outer input element type instead of the closure's return type when computing the stride.

What's Next

• Method-level generics and where clauses — A proposal to allow @method<T> where T: Trait syntax directly on trait and impl methods has been reviewed and approved. Implementation work on the parser, AST, and monomorphization keys is the immediate next step.
• Empty container typing — Ongoing work to fully specify and validate how empty list literals, empty maps, and empty sets interact with the type system, including multi-error fault tolerance and JIT/AOT parity.
• AOT iterator test coverage — AOT execution paths for iterator operations currently lack executable test coverage; closing this gap is a tracked near-term priority.

Ori 2026.04.22.1-alpha (Nightly)

Ori v2026.04.22.1-alpha Release Notes

This release focuses on type inference correctness and ARC lowering reliability, resolving several soundness issues in polymorphic code and closure capture analysis. It also lays down compiler pipeline validation infrastructure that will underpin upcoming codegen hardening.

---

Compiler

• Fixed type variable substitution in polymorphic code — A bug in how the type checker resolved type variables during substitution caused incorrect unification results in certain polymorphic expressions. The checker now correctly follows union-find roots during substitution, producing accurate type errors and eliminating spurious unification failures.

• Fixed closure capture analysis for nested scopes — body_captures_outer was not correctly identifying variables captured from lexically-outer scopes in nested closures. This could silently produce unsound capture sets. The analysis is now lexical-scope-aware and sound.

• Added codegen seam validation for impl methods — The compiler now enforces pipeline-phase constraints when type-checking trait impl method bodies, catching violations earlier with a clearer error rather than surfacing them as a downstream codegen panic.

• Landed LLVM codegen seam hooks with Result cascade — The LLVM backend now has explicit seam points between compiler phases, with error propagation threaded as Result chains. This makes codegen errors recoverable rather than fatal, improving the overall compilation error experience for programs that hit backend issues.

• Renamed internal bound type variable representation — The compiler's internal type for universally-bound type variables was renamed from Generalized to BoundVar. This change improves the clarity of type-related diagnostic messages and internal error output.

Bug Fixes

• Fixed stack overflow in the test runner when ARC lowering fails — If ARC lowering produced errors on certain inputs, the test runner could recurse unboundedly and crash with a stack overflow instead of reporting the lowering error cleanly.

• Fixed newtype lowering under ARC — Newtype wrappers were not lowering correctly through the ARC pass in all cases, leading to incorrect retain/release placement. Newtype lowering and scheme-body handling are now consistent.

Tooling

• Synchronized documentation to current compiler architecture — Multiple stale references across the compiler design docs, crate READMEs, testing guide, and formatter style guide have been updated to reflect the current CLI flags, module structure, and runtime ABI.

---

What's Next

• FFI boundary safety — An approved design for safe FFI boundary handling is now moving into implementation. This will give Ori programs principled, checked interop with native code at capability boundaries.
• Polymorphic lambda improvements — Ongoing work on how the type checker handles polymorphic lambdas, particularly around generalization and imported-generic leaks, is nearing completion and will land in an upcoming release.
• Expanded codegen validation — The seam validation infrastructure introduced this release will be extended across more compiler phases, moving the compiler toward catching phase-contract violations as structured errors rather than panics.

Ori 2026.04.17.1-alpha (Nightly)

Ori v2026.04.17.1-Alpha — Release Notes

This release focuses on type inference correctness, fixing two bugs that caused the type checker to fail or produce false errors on otherwise valid generic and iterator code.

Bug Fixes

• Fixed: fold/rfold accumulator type fails to infer when unused in the closure body. When calling fold or rfold with a closure that never performs operations on the accumulator directly — for example, counting elements into an integer accumulator without referencing its value — the type checker could not resolve the accumulator type and emitted an inference failure. The fix unifies the accumulator parameter type with the return type of fold/rfold so inference succeeds even when the closure body provides no additional constraints. Patterns like iter.fold(0, |acc, _| acc + 1) and cross-type accumulations (e.g., collecting strings into an integer count) now work correctly.

• Fixed: false E2005 "ambiguous type" error inside generic function bodies. The type checker incorrectly reported E2005 for type variables that are legitimate polymorphic parameters of a generic function. This happened because union-find can promote a fresh instantiation variable to the root of a scheme variable's equivalence class, making it look like an unresolved, unbound type — even though it is fully constrained by the function's declared type parameters. Generic functions that left some type parameters unconstrained in the body (but constrained at call sites) were falsely rejected. The fix builds an exempt root set from the function's declared scheme variable IDs before walking the type tree, so polymorphic parameters are never reported as ambiguous.

What's Next

• Iterator trait coverage — continued work on inference correctness across iterator combinators, building on the fold/rfold fix to harden the full iterator protocol.
• Type checker validation hardening — further auditing of the validate_body_types pass to eliminate remaining false positives in generic and polymorphic contexts.
• Bug tracker triage — newly filed issues in the type checker (including a body_type_map duplication) are queued for upcoming cycles.

Ori 2026.04.16.1-alpha (Nightly)

Ori v2026.04.16.1-Alpha

This release focuses on type checker correctness — specifically, closing gaps in how generic type variables flow through scheme bodies — along with internal compiler infrastructure work that sets the stage for more substantial type checking improvements landing in upcoming builds.

Compiler

• Fixed type variable propagation through generic schemes — The type checker now correctly propagates the HAS_VAR flag from a scheme's body type, as required by the type inference rules. Previously, certain generic definitions could reach validation with their variance flags incorrectly absent, producing misleading or missing errors in downstream checks.

• Fixed validator gate ordering in body type checks — The HAS_ERROR and HAS_VAR gates in the body type validator are now checked in the correct order. The previous ordering could suppress valid type errors in the presence of inference variables, causing some ill-typed programs to pass type checking silently.

• Introduced body type validation pass — A new structured validation pass (validate_body_types) is now wired into the type checking pipeline. This lays the foundation for catching a broader class of type errors in function and method bodies with precise, well-anchored diagnostics.

Tooling

• Fixed intel-query status path resolution — The intel-query tool now correctly resolves the language intelligence graph path when invoked from a Git worktree, fixing a breakage that affected contributors working in multi-worktree setups.

• Per-repo symbol counts in intel-query status — The status output now surfaces symbol counts broken down by repository (Ori + all 10 reference compilers), making it easier to spot indexing gaps or staleness at a glance.

What's Next

• Empty-container type inference — The team is completing the type checking pass for empty container literals ([], {}), ensuring they unify correctly with annotated types rather than defaulting to ambiguous error states.
• Bodies-pass integration — Broader integration of the new body type validation pass into the type checker is in progress, which will surface more precise errors for ill-typed function bodies.
• Documentation sync tooling — A redesigned /sync-docs workflow using batch third-party verification is being finalized to keep language documentation consistently accurate against the compiler's actual behavior.

Ori 2026.04.15.1-alpha (Nightly)

Ori v2026.04.15.1-alpha Release Notes

This release tightens ARC memory soundness in the AIMS pipeline, corrects type generalization consistency in the type checker, and expands the formal verification suite. The primary theme is correctness: several latent unsoundness issues have been identified and addressed before they could affect user programs.

Compiler

• Type generalization is now fully consistent across all call sites. The rule determining when a let-bound value should be generalized was previously duplicated across three independent locations, making it possible for the same expression to be treated differently depending on how it was elaborated. All three sites now share a single authoritative implementation, eliminating the inconsistency.

• The Alive2 formal verification corpus has grown to 15 functions. Alive2 translation validation now covers a wider set of LLVM optimizations emitted by the Ori backend, including Z3 solver discovery fixes that previously caused some verification runs to silently skip.

Bug Fixes

• Fixed a soundness bug in ARC uniqueness analysis. The AIMS pipeline was applying cross-dimensional uniqueness proofs that could be unsound in certain aliasing configurations — concluding a value was uniquely owned when it was not. This has been removed. Affected programs may see slightly more conservative reference-count operations, but will no longer risk incorrectly elided RC ops.

• Fixed a borrow overlap false negative for unique COW sites. A check that validates borrow lifetimes at copy-on-write mutation sites was not running for values classified as uniquely owned. This could allow a borrow and a mutation to overlap without being caught. The check now applies uniformly regardless of ownership classification.

• Iterator pipeline lowering produces correct output. An investigation confirmed that the iterator pipeline canonicalization path produces semantically equivalent results across interpreter and LLVM backends. No code change was required, but the verification matrix is now in place to catch regressions.

Breaking Changes

• Collection element narrowing has been disabled. Type narrowing applied to elements extracted from collections (e.g., pattern-matched values from a List or Map) was unsound when those elements were subsequently passed through collect. Narrowed types could be used to bypass RC discipline in a way the backend could not validate. Narrowing is now suppressed at collection element sites. Programs that depended on narrowed types flowing through collect will need to add explicit type annotations. A tracked path toward re-enabling this safely (with a sound formulation) is being investigated.

What's Next

• Collection element narrowing re-enablement. The disable was necessary for soundness, but narrowing is a valuable precision tool. Work is underway to design a sound formulation that accounts for the collect aliasing case.
• Empty for-do body handling. A compiler crash when a for-do loop body is empty has been filed and will be addressed in an upcoming release.
• Sanitizer coverage in CI. Address sanitizer and undefined behavior sanitizer builds now have CI infrastructure in place; the next phase is extending coverage across the full spec test suite.

Ori 2026.04.14.1-alpha (Nightly)

Ori v2026.04.14.1-alpha Release Notes

This release focuses on compiler verification and correctness infrastructure: AddressSanitizer support lands for AOT-compiled programs, Alive2 formal translation validation is now integrated into the build pipeline, and a representation optimization bug that could produce incorrect code for narrowed list types is fixed.

Compiler

• AddressSanitizer and UBSan support for AOT programs — Ori-compiled binaries can now be instrumented with sanitizers via ORI_SANITIZE=address,undefined. Compilation is delegated to Clang, which handles sanitizer instrumentation; the Ori runtime (ori_rt) is now also built with an ASan-compatible variant. Use scripts/sanitizer-smoke.sh for a quick 17-program matrix or scripts/sanitizer-full.sh for a full spec sweep. This makes it dramatically easier to catch memory and undefined-behavior issues in programs compiled from Ori source.

• Alive2 translation validation integrated — The build pipeline now includes formal LLVM IR translation validation via Alive2. A curated corpus of 8 functions ships with the compiler (tests/alive2/), and diagnostics/alive2-verify.sh supports per-function verification, full codegen sweeps, and JSON output for CI integration. A false-positive suppression system (9 categories) prevents known-safe patterns from producing noise. Use scripts/build-alive2.sh to build the validator from the pinned LLVM 21 commit.

• Representation optimization narrowing confined correctly — A bug caused integer narrowing from representation optimization to propagate beyond the list storage boundary into adapter code, producing incorrect sign-extension in contexts where the narrowed representation should not be visible. This is now correctly confined to the storage layer. Existing programs with narrowed list types may see corrected runtime behavior.

Bug Fixes

• Invalid sign-extension removed from join trampoline — The join iterator trampoline was emitting a spurious sext instruction on list element types, which could produce incorrect values when element types were narrowed by representation optimization. Fixed, with regression tests covering adapter boundaries for narrowed lists.

Tooling

• Intelligence graph covers sentiment and issue signals — The /query-intel command now surfaces sentiment signals and issue trends from cross-language prior art (open issues, PR discussions). Use query-intel sentiment "<topic>" to get a read on how other language communities have received similar features before making design decisions.

• AIMS formal rule set codified — The rules governing ARC Intelligent Memory System placement decisions (RC elimination, reuse, FIP certification, demand propagation) are now captured in a formal ruleset document (codegen-rules.md). This has no immediate user-visible effect, but it is the foundation for verifying that the compiler's memory decisions are provably correct and will underpin future automated audit tooling.

What's Next

• Optional semicolons after block expressions — A proposal to make trailing semicolons after if/match/block expressions optional has been approved. Implementation will follow in an upcoming release, reducing visual noise in common expression patterns.
• Post-FFI sanitizer tooling — Once FFI lands, sanitizer propagation across the FFI boundary (so C/C++ code called from Ori is also instrumented) is planned as a follow-on.
• Alive2 CI sweep — The curated Alive2 corpus will expand to cover more codegen patterns, with a weekly full-sweep job running against all generated LLVM IR to catch translation-correctness regressions early.

Ori 2026.04.13.1-alpha (Nightly)

Ori v2026.04.13.1-Alpha Release Notes

This release focuses on correctness throughout the ARC analysis pipeline: a soundness fix to the AIMS lattice, a rewritten contract coherence oracle with richer diagnostics, and a string join memory leak fix. Alongside those, LLVM IR test coverage expands significantly and contributor tooling gains proposal-gate enforcement.

Compiler

• Fixed a soundness bug in the AIMS memory analysis lattice. An anti-monotone rule (Rule 4) could produce incorrect ARC analysis results in aliasing scenarios where the same value was accessed through multiple paths. Removing it and widening Rule 6 restores monotonicity across all reachable lattice states, meaning the compiler will no longer misclassify aliased values and emit incorrect reference-count operations.

• Rewrote the contract coherence oracle with aliasing-aware analysis. The oracle that checks whether FIP/AIMS contracts hold at call sites now tracks aliasing relationships through the full intraprocedural dataflow. When a mismatch is detected, the diagnostic now reports each individual contract violation with its specific cause rather than a single generic error, making it much easier to understand what the analysis found.

• Enriched contract coherence diagnostics. Violations now show per-mismatch detail — which field mismatched, what was expected, and what was inferred — alongside the existing summary. Previously the error offered no breakdown.

Standard Library

• Fixed a memory leak in string join. Heap-backed str temporaries created during the join trampoline path were not being freed. Programs that join collections of strings would leak memory proportional to the number of elements joined.

Tooling

• Added spec and grammar proposal-gate enforcement hooks. Pre-commit hooks now block direct modifications to grammar and spec files unless they are accompanied by an approved proposal. This prevents accidental drift between the spec and the implementation and formalizes the process for contributors proposing language changes.

• Wired cross-language intelligence queries into code review and bug-fix workflows. The /tpr-review and /fix-bug skills can now query a cross-language intelligence graph to surface relevant prior art, similar bugs in reference compilers, and applicable design patterns automatically during review.

Bug Fixes

• Fixed a dispatch order bug in protocol consumers. When iterating over a collection using a protocol receiver, method dispatch could select the wrong implementation if the receiver had mixed ownership. The correct implementation is now selected in all cases.

• Fixed iterator borrow promotion for mixed-ownership receivers. A collection iterator that held a mix of owned and borrowed elements could incorrectly promote a borrow to ownership under certain patterns. The promotion now correctly handles the mixed case.

What's Next

• Iterator element ownership. A tracked issue (filed this cycle) covers missing ownership analysis for certain iterator element types including compound keys. Fixing this will remove a remaining class of incorrect RC operations on collection elements.
• Entry-point diagnostics. A draft proposal landed this cycle for improving error messages at program entry points — covering missing @main, wrong arity, and incompatible return types. Implementation is queued.
• Set<int> support. A blocker was identified and filed this cycle: the LLVM codegen for Set<int> produces incorrect matrix fixtures. Resolving it unblocks a range of collection-type tests currently pinned as negative.

Ori 2026.04.12.1-alpha (Nightly)

Ori v2026.04.12.1-alpha Release Notes

This release focuses on compiler correctness and verification infrastructure. ARC memory analysis is more accurate, LLVM code generation failures now surface as hard errors, and the AIMS subsystem gains a contract coherence oracle for catching memory contract inconsistencies at compile time.

Compiler

• LLVM verification failures now block compilation. Previously, LLVM IR verification errors were recorded but did not prevent a binary from being emitted. Verification failures now propagate as hard compilation errors, ensuring that invalid IR never silently produces a broken executable.

• AIMS contract coherence oracle. The ARC Intelligent Memory System now includes an oracle that detects contradictions between memory contracts across the pipeline. When a function's realized memory behavior disagrees with its declared contract, the compiler surfaces the inconsistency rather than silently generating incorrect retain/release sequences.

• ARC live-block analysis corrected. The backward liveness pass now seeds correctly from function entry and Resume exit points, rather than using an approximation that included unreachable blocks. A related fix narrows parameter-usage diagnostics to live code paths only, eliminating false positives on dead branches.

Tooling

• FileCheck-style IR verification for LLVM codegen. A new FileCheck-compatible matching engine lets contributors write pattern-based assertions directly against emitted LLVM IR. Twelve IR tests now cover retain/release sequencing, copy-on-write, iterator lowering, and ABI calling conventions — providing a fast regression layer between end-to-end tests and manual IR inspection.

• AIMS pipeline snapshot testing. The compiler now exposes checkpoint hooks throughout the AIMS optimization pipeline, enabling snapshot-based tests that pin the ARC IR state after each pass. An initial corpus covers five priority passes, making regressions in memory optimization immediately visible.

• Shared test harness crate (ori_test_harness). Common test infrastructure previously duplicated across crates is now centralized. Snapshot comparisons normalize CRLF line endings, fixing spurious test failures in Windows CI environments.

Bug Fixes

• Proptest-based lattice verification discovered a soundness gap (BUG-04-057). Property-based testing of the AIMS unification lattice found an associativity violation under specific contract combinations. The bug is tracked and will be fixed in an upcoming release.

What's Next

• LLVM verification tooling expansion. Work on sections covering ABI verification and pass-level snapshot diffing continues; the goal is full end-to-end IR correctness coverage across all codegen paths.
• BUG-04-057 lattice soundness fix. The AIMS associativity gap discovered by property testing will be addressed, with a full TDD matrix covering the affected contract combinations.
• Protocol and builtin verification hardening. Argument-count pinning for protocol builtins is in place; further work will extend contract verification to the broader set of compiler-known builtins.

Ori 2026.04.11.1-alpha (Nightly)

Ori v2026.04.11.1-alpha Release Notes

This release focuses on compiler correctness verification and diagnostic observability. The LLVM codegen pipeline now validates generated IR at every emission site, and the ARC memory system gains new tooling to pinpoint exactly which optimization pass introduces an issue.

Compiler

• LLVM IR is now verified at every emission site — Every function emitted by the compiler, including derived code paths (copy thunks, drop thunks, and similar auto-generated functions), is now verified before it is passed to the optimization pipeline. Previously, malformed IR in derived functions could silently produce incorrect binaries or cryptic LLVM crashes. Errors are now caught and reported at the source.

• Per-pass LLVM verification available — Setting ORI_VERIFY_EACH=1 enables LLVM IR verification after every optimization pass. When IR becomes invalid mid-pipeline, this pinpoints exactly which pass broke it rather than surfacing a confusing error at the end of compilation.

• ARC verification is now enforced under ORI_VERIFY_ARC=1 — ARC and AIMS invariant checks are now blocking rather than advisory when the flag is set, and CI runs with it enabled. This means RC-balance errors and drop-placement violations are caught on every build rather than silently continuing.

• LLVM lint pass integrated into the codegen audit — The LLVM lint pass (detectable undefined behavior patterns: division by zero, suspicious alignment, unreachable code) is now part of the ORI_AUDIT_CODEGEN=1 pipeline.

Tooling

• rc-stats.sh now outputs structured JSON — The RC statistics diagnostic script has been migrated to compiler-backed JSON output with --block-level and --optimized flags, making it scriptable and suitable for automated regression tracking.

• AIMS pipeline bisector (bisect-passes.sh) — A new diagnostic script isolates which AIMS optimization pass first introduces an RC imbalance or structural anomaly. Each pass now emits a trace checkpoint, so bisect-passes.sh can binary-search across the pipeline and report the exact pass responsible. Useful for debugging complex ARC/COW interactions.

• Diagnostic self-test suite expanded — 13 new test fixtures covering core patterns, AIMS-heavy programs, and expected-failure cases were added to the diagnostic script self-test suite, improving confidence that diagnostic tooling stays accurate as the compiler evolves.

Bug Fixes

• Map iteration and display no longer leak internal key prefixes — Maps with certain key types would expose internal encoding prefixes when iterating, printing, or debugging values. Keys now display as their source-level representation in all output paths.

What's Next

• Continued LLVM verification hardening — The verification gates now in place will surface latent codegen correctness issues; upcoming work will address what those gates find.
• AIMS diagnostic coverage — The bisection and trace tooling added this cycle will be used to audit and fix RC imbalance issues identified in complex optimization scenarios.
• Diagnostic tooling expansion — Remaining diagnostic script sections are in progress, extending coverage to additional compiler phases and output formats.

Ori 2026.04.10.1-alpha (Nightly)

Ori v2026.04.10.1-alpha — Release Notes

This release focuses on ARC correctness, LLVM codegen reliability, and a significantly expanded diagnostic toolchain. Several bugs affecting reference counting and enum codegen are resolved, and compiler debug tooling now works in release builds.

Compiler

• Phase dumps now available in release builds — ORI_DUMP_AFTER_PARSE, ORI_DUMP_AFTER_TYPECK, ORI_DUMP_AFTER_ARC, and ORI_DUMP_AFTER_LLVM were previously gated to debug builds. They now work in any build, making it easier to inspect compiler output without a debug binary.

• ORI_LOG parse errors are now surfaced — If ORI_LOG was set to an invalid filter expression, the error was silently swallowed. The compiler now reports parse failures so misconfigured tracing is immediately visible.

• ORI_NO_REPR_OPT and ORI_VERIFY_ARC are properly registered — These environment variables were accepted at runtime but not registered in the compiler's flag registry, causing them to be ignored in some contexts. Both are now correctly wired up.

• Windows WASI sysroot detection fixed — check_wasi_sdk now correctly wires the sysroot on Windows, unblocking WASI target compilation on that platform.

Bug Fixes

• Fixed duplicate RC increments on aggregate values — When an aggregate value (struct, tuple) was used more than once in a terminator position, the ARC lowering pass could emit redundant RcInc operations, leading to over-retention and potential memory leaks. The deduplication logic now correctly handles these cases.

• Fixed ARC lineage deduplication for aliased let bindings — A bug in how the ARC pass tracked variable lineage could produce incorrect deduplication when a value was accessed through a let alias. The pass now resolves aliases to their canonical representative before deduplication, giving correct RC decisions.

• Fixed LLVM codegen for pointer payloads in explicit-tag enums — Enum variants carrying pointer-typed payloads in explicit-tag layout could produce incorrect LLVM IR due to a missing ptrtoint cast. This caused miscompilation on affected enum patterns. The cast is now emitted correctly.

• Fixed ARC owned-position check for forward-walked values — The forward walk used to determine ownership positions now routes through the canonical variable query, preventing incorrect ownership decisions for values that flow through aliases or let-bindings.

Tooling

• New debug-release-compare.sh diagnostic script — Runs a program under both debug and release builds and compares exit codes and stdout. On mismatch, diffs the LLVM IR between the two builds, making it straightforward to isolate release-only miscompilation.

• dual-exec-debug.sh enhanced — The interpreter-vs-AOT comparison tool now auto-dumps phase IR and ARC state on mismatch, reducing the manual steps needed to diagnose divergence between the two execution paths.

• diagnose-aot.sh expanded — Now includes codegen audit output, ARC IR inspection, and optional release build analysis alongside the existing debug workflow. Surfaces more signal in a single command run.

• Hygiene lint suite added — A new static analysis tool suite backs the implementation hygiene review process, including detectors for memory leaks, coverage gaps, and enum layout drift. Five previously noisy checks were tightened and five new gap/leak detectors were added.

What's Next

• Enum layout SSOT — Work is underway to establish a single source of truth for enum layout decisions across the compiler, eliminating drift between the type system, ARC pass, and LLVM codegen layers.
• Representation optimization hardening — The repr-opt subsystem has open findings under review; the next cycle will address remaining edge cases in integer narrowing and enum packing.
• Continued diagnostic depth — The diagnostic toolchain expansion continues, with planned improvements to RC statistics reporting and Valgrind integration coverage.