v0.23.0

Beagle v0.23.0

Beagle v0.23.0 brings the durable engine into the repository as Beagle
Store. The former branch-core tree, Fram command names, and FRAM_*
configuration surface are replaced by store, beagle-store-*, and
BEAGLE_STORE_*. The rename is the visible part of a deeper change: qualified
references now remain structural from source through the Racket compiler,
self-hosted compiler, Native Core, and Store, while exact source bytes and
receipts remain authoritative at their own boundaries.

Beagle Store

• Breaking: the in-repository engine is now Beagle Store. The engine lives
  under store/, its commands use the beagle-store-* prefix, its namespaces
  use store.*, and its configuration uses BEAGLE_STORE_*. The old
  branch-core/**, Fram command, namespace, package, and environment surfaces
  are removed rather than retained as aliases.
• Durable revision operations are part of the Store. Generations bind to
  revisions; branch references support durable compare-and-set and
  post-durable watching; long chains can reseal past the old segment ceiling;
  and unreachable segments can be collected from explicit durable roots.
  Native chain-parity and float-coercion checks protect these transitions.
• Store edits mint structural facts directly. Code ingestion and native
  fact reading retain qualified callee structure, Store resolution mints
  declarations and references from those values, and edit minting assigns
  ordered conflict-free keys. The temporary symbol-shaped qualified-reference
  scaffold and its accessor are gone, with a gate keeping the removed path at
  zero uses.

Language and compiler

• Qualified references are structural end-to-end. A qualified reference
  has explicit qualifier and local-name fields instead of being repeatedly
  split and reconstructed from text. The parser, AST, checker, type catalog,
  source facts, Native Core lowering, and Clojure, JavaScript, and Nix emitters
  consume the same representation, including under local shadowing.
• The self-hosted compiler carries the same contract. Its reader, parser,
  AST, checker, and hosted emitters preserve the structural reference, and the
  checked-in seed was reminted against the Racket oracle. Structural qualified
  references therefore survive the full self-host route rather than becoming
  target-specific strings.
• Exact source bytes remain exact. Selecting a hosted projection no longer
  changes the immutable source snapshot used for identity. Provider paths and
  source digests stay stable across target projection, invocation order, and
  checkout location.
• Beagle's boundary is stated plainly. The public documentation now
  presents Beagle as an independent typed Lisp with a Clojure-derived core,
  Native Core for execution, and Beagle Store for durable semantic identity.
  The allocation model and influence map distinguish shipped mechanisms from
  research claims and name the ideas Beagle adopts and refuses.

Test infrastructure and performance

• The gate serializes itself. Concurrent beagle test invocations share
  one file lock, so release evidence cannot be produced by overlapping suites
  that contend for the same caches and build outputs. Slow active tests are
  listed with their wall times at the end of every run.
• Consumer smoke is now a release-gate phase. A small multi-module program
  proves qualified Native references through source facts, and a Store-shaped
  program proves NativeLoweringCompleteV0 through the same native builder a
  real consumer uses. The fixtures and tool paths resolve from the checkout at
  runtime instead of depending on a repository name or fixed location.
• A formerly 90-second native test now takes about two seconds when warm.
  The native parallel proof still performs a real build, execution, and QBE and
  Wasm refusal checks, but uses a minimal fixture and the content-keyed gate
  cache. Its measured focused path was 37.0 seconds without the gate-result
  cache and 1.869 seconds warm; the original 90-second deadline remains a
  tripwire.
• Verified Native Core results are reusable. Whole-result and early-alias
  caches validate source, compiler, projection, and artifact identity before a
  hit can be reused, retire corrupt entries, and preserve failure diagnostics.
  The measured fully warm native build fell from roughly 180 seconds to 48.3
  seconds, a 3.73× improvement, with generated artifacts byte-identical to the
  cold build.
• CI and release publication have separate jobs. The active gate is
  distributed by scheduling unit, while release publication validates authored
  notes and the exact candidate commit before producing assets.

Consumer evidence

• Authoritative-history replay leaves both success and failure receipts. In
  the game consumer's history-and-shadow-engine proof (the Stage 4 proof), the
  same revision-bound journal window was replayed through the incumbent and
  candidate engines. A matching run and a deliberate semantic divergence were
  both retained as checked receipts, so agreement and refusal are independently
  auditable.
• A semantic live-cutover rehearsal produced a complete admission receipt.
  In the following live-engine proof (the Stage 5 proof), one source change
  invalidated and cold-compiled exactly one semantic unit while eight unaffected
  units retained identity. The receipt records the visible 16 → 17 behavior
  change, matching forward and reverse replay, refusal of a mismatched candidate,
  compare-and-set winners at the expected head, and continued state after
  admission. This is downstream evidence for the compiler and Store contracts,
  not a claim that a general live-upgrade language primitive was added.

Fixes and correctness

• Qualified Native globals retain their full spelling during free-reference
  discovery and lookup instead of losing the qualifier at the final lowering
  boundary.
• Unresolved structural references fail at the parser, checker, emitter, native
  reader, or Store resolver that owns the boundary; they no longer become
  phantom aliases or arbitrary typed values through string fallback.
• Canonical module-root comparisons use stable provider paths, and target
  projection preserves the original source bytes used by provenance and
  identity receipts.
• Native cache hits revalidate the exact input closure before publication and
  consume validated aliases directly, preventing projected facts from being
  rewritten under a different cache identity.
• Store sealing, status, ordering, graph control, edit verification, and commit
  gates now resolve through the renamed Beagle Store surface consistently.

Compatibility

This is a pre-1.0 minor release with a deliberate breaking rename. Repository
and script references to branch-core/** must move to store/**; Fram-prefixed
Store commands, namespaces, packages, and environment variables must move to
their beagle-store-*, store.*, and BEAGLE_STORE_* forms. No compatibility
aliases remain.

Code that inspected or constructed qualified references as symbol-shaped text
must use their qualifier and local-name fields. Store integrations must likewise
mint and consume structural reference facts. Whole-program compilation remains
the authoritative release path; the new caches reuse only previously verified
results and do not change the artifact contract.

Release artifacts

The GitHub release continues to attach the beagle-selfhost stage0 native
compiler and its beagle-selfhost.seed-nar-hash. Publication requires the exact
candidate commit to pass the non-publishing release gate, authored-note checks,
native artifact checks, and byte-for-byte native/Babashka/Racket parity over the
Beagle Store corpus.

Full Changelog: v0.22.0...v0.23.0