# Glagol Roadmap

Glagol is the first compiler for Slovo. Slovo language design lives in
`docs/language/` inside the same monorepo.

Compiler rule: make the tree visible. The pipeline should remain:

```text
.slo source -> tokens -> S-expression tree -> AST -> typed AST -> LLVM IR text -> hosted Clang/runtime executable step
```

Long-horizon compiler planning lives in `.llm/ROADMAP_TO_STABLE.md`. It
mirrors Slovo's release train beyond the first real general-purpose beta
toolchain.

Release maturity policy lives in `.llm/RELEASE_MATURITY_POLICY.md`. Historical
`exp-*` releases remain experimental maturity. `1.0.0-beta` is the first real
general-purpose beta release.

## Definition Of Done For A Compiler Feature

A Glagol feature is done only when it has parser/lowerer support, checker behavior, diagnostics for invalid forms, backend behavior or explicit unsupported diagnostics, and tests.

Current stage: `1.0.0-beta.24`, released on 2026-05-23 as package manifest
identity and local dependency diagnostic hardening. It keeps the
`1.0.0-beta` language/compiler support baseline and includes the
`1.0.0-beta.1` tooling hardening release, the `1.0.0-beta.2` runtime/resource
foundation release, the `1.0.0-beta.3` standard-library stabilization release,
the `1.0.0-beta.4` language-usability diagnostics release, the
`1.0.0-beta.5` package/workspace discipline release, the `1.0.0-beta.6`
compiler-known `std.net` loopback TCP runtime family with focused lowering,
interpreter, diagnostics, source-facade, promotion, and hosted smoke coverage,
the `1.0.0-beta.7` compiler-known `std.json.quote_string` runtime family with
matching source-facade, test-runner, hosted smoke, and benchmark-scaffold
coverage, the `1.0.0-beta.8` concrete type alias foundation update, and
focused diagnostics/formatter/project-mode gates for reserved generic
functions, parameterized aliases, generic type parameters, maps, sets, and
future generic stdlib calls. The beta.10 tooling/docs slice upgrades
generated `lib/std` API discovery so public documentation lists exact exported
helper signatures after alias normalization, and adds
`glagol symbols <file.slo|project|workspace>` for deterministic
editor-facing source metadata over modules, imports, exports, aliases,
structs, enums, functions, tests, spans/ranges, and workspace package labels.
The beta.11 documentation slice extends
`glagol doc <file|project|workspace> -o <dir>` with deterministic
exported/public API sections for local packages and modules, including exact
exported function signatures, exported struct fields, exported enum
variants/payload types, non-export filtering, and module-local alias
normalization. The beta.12 stdlib/helper parity slice adds source-authored
coverage for `std.vec_i64.count_of`, `std.vec_i64.starts_with`,
`std.vec_i64.without_prefix`, `std.vec_i64.ends_with`,
`std.vec_i64.without_suffix`, and `std.vec_f64.count_of` without changing
source-language runtime behavior. The beta.13 tooling/docs-only diagnostics
slice centralizes the `slovo.diagnostic` schema name/version constants and
adds structural gates for S-expression diagnostics, `--json-diagnostics`, and
artifact-manifest diagnostics metadata without changing emitted machine
diagnostic shape. The beta.14 tooling-only benchmark slice adds deterministic
suite-level local benchmark listing and release-gate coverage for
`python3 benchmarks/runner.py --suite-list --json`, including all current
benchmark directories, timing modes, cold/hot loop counts, checksum metadata,
required scaffold-file status, implementation slots, and a local-only timing
disclaimer without publishing timing results or claiming a stable JSON schema.
The beta.15 compiler/tooling slice centralizes reserved generic and collection
diagnostics across lowerer, formatter, and checker paths, rewords current
reserved diagnostics to stage-neutral current-beta text, and gates the
collection ledger for generic functions, parameterized aliases, generic type
parameters, generic vector spelling, map/set types, `std.vec.empty`, and
`std.result.map` across check, fmt, and project paths without promoting those
surfaces. The beta.16 compiler/runtime slice adds byte-oriented
`std.string.byte_at_result`, `std.string.slice_result`,
`std.string.starts_with`, and `std.string.ends_with` over current
null-terminated runtime strings, with invalid indexes/ranges returning
`err 1`, without Unicode/grapheme semantics, tokenizer/parser claims, or
stable ABI/layout commitments.
The beta.17 compiler/runtime slice adds promoted `std.json` primitive scalar
parse helpers for bool, i32, u32, i64, u64, and f64 JSON tokens, with strict
whole-token checks, matching test-runner and hosted-runtime behavior, source
facade alignment, diagnostics coverage, and release-gate coverage. It keeps
`parse_null_value_result` source-only and leaves JSON strings, objects,
arrays, recursive values, tokenizers, schema validation, streaming, Unicode
escape handling, and stable JSON APIs deferred.
The beta.18 compiler/runtime slice adds promoted
`std.json.parse_string_value_result` for exact ASCII JSON string tokens, with
simple escape decoding and matching test-runner/hosted-runtime behavior. It
also runs `glagol test` execution on a bounded larger worker stack so deep
source-authored stdlib fixture tests remain gateable through ordinary
diagnostics. It keeps object parsing, array parsing, recursive values,
tokenizers, Unicode escape decoding, Unicode normalization, streaming, schema
validation, embedded NUL support in the current null-terminated string ABI, and
stable JSON APIs deferred.
The beta.19 compiler/tooling slice adds
`glagol test --list <file|project|workspace>` and legacy
`glagol --run-tests --list <file>` support. The list action reuses the same
checked discovery path as normal test execution, preserves existing
single-file, project, and workspace ordering, honors `--filter <substring>`,
and avoids executing test bodies. It keeps normal test execution output
unchanged when `--list` is absent.

The beta.20 compiler/tooling slice bumps the package version and gates
source-authored `std.string` facades for `contains`, `index_of_option`,
`last_index_of_option`, `trim_ascii_start`, `trim_ascii_end`, and `trim_ascii`
through explicit `std.string` imports. It keeps those helpers composed over
beta16-or-earlier string primitives and existing option/result shapes, and
verifies that direct compiler-known runtime calls for the new helper names
remain unsupported.

The beta.21 compiler/tooling slice bumps the package version and gates
source-authored `std.json` document scalar facades for
`parse_string_document_result`, `parse_bool_document_result`,
`parse_i32_document_result`, `parse_u32_document_result`,
`parse_i64_document_result`, `parse_u64_document_result`,
`parse_f64_document_result`, and `parse_null_document_result` through explicit
`std.json` imports. It keeps those helpers source-authored over the existing
JSON token parser family and existing source-level composition, and verifies
that direct compiler-known runtime calls and private `__glagol_json_*document*`
symbols for the new helper names remain unsupported.

The beta.22 compiler/tooling slice bumps the package version and hardens
`glagol run --manifest` evidence with an additive run-report block in
run-mode artifact manifests. The block records executed-program exit status,
captured stdout, captured stderr, and forwarded program arguments. It is beta
CLI evidence metadata under the existing `slovo.artifact-manifest` version
`1` contract, not a stable schema freeze, and it adds no source-language,
runtime, package, or standard-library surface.

The beta.23 compiler/tooling slice bumps the package version and updates
generated `docs/language/STDLIB_API.md` output with per-module and per-helper
tier metadata. It adds a release-gate checker for the tier catalog, marks JSON,
loopback networking, random/time, and filesystem resource-handle helpers as
experimental, and keeps concrete vector modules beta-supported concrete lanes
without claiming generic collection stability. It adds no source-language,
runtime, package, or standard-library helper surface.

The beta.24 compiler/tooling slice bumps the package version and tightens
local package manifest diagnostics. Duplicate package manifest keys, invalid
dependency keys, and duplicate dependency keys are explicit diagnostics. It
keeps the existing closed local workspace model and adds no remote registry,
lockfile, semantic-version solving, package publishing, optional/dev/target
dependencies, stable package ABI/layout, source-language behavior, runtime
behavior, or standard-library behavior.

Generic vectors, generic collections, maps, sets, generic stdlib dispatch,
runtime collection changes, collection unification, stable human diagnostic
text, stable artifact-manifest or Markdown schema freezes, LSP/watch
protocols, SARIF/daemon protocols, re-exports/globs/hierarchical modules,
registry semantics, semver solving, mutable vectors, stable slice/view APIs,
tokenizers, broader JSON parsing, runtime helper names, source-language
syntax, parallel test execution, retries, tags/groups, coverage/event streams,
performance claims, ABI/layout stability, and a stable stdlib/API
compatibility freeze remain unimplemented until a later scoped contract
promotes them explicitly.

The final experimental precursor scope is `exp-125`. Its unsigned direct-value
flow, parse/format runtime lanes, and matching staged stdlib helper breadth
are now absorbed into `1.0.0-beta`.

Phases 9 through 84 and exp-1 through exp-124 remain historical experimental
release milestones. `exp-124` Fixed Array Enum And Struct Elements Alpha is
the last tagged experimental compiler slice before beta. exp-123 Owned Vector
Benchmark Suite Extension And Whitepaper Refresh Alpha is the previous tagged
experimental benchmark/publication slice. exp-122 Composite Data Benchmark
Suite Extension And Whitepaper Refresh Alpha is the earlier tagged
experimental benchmark/publication slice. exp-121 Non-Recursive Struct Enum
Payloads Alpha and exp-120 Fixed Array Struct Fields Alpha remain earlier
historical compiler broadening steps in the path to beta.
exp-115 Composite Struct Fields And
Nested Structs Alpha is the previous gated experimental compiler slice. It
broadens direct struct field declarations by allowing the current concrete vec
families, current concrete option/result families, and current non-recursive
struct types alongside the already promoted direct scalar, string, and enum
field families in the checker, formatter, diagnostics, promoted
composite-struct fixtures, and focused Glagol tests, while keeping arrays out
of struct fields and excluding recursive layouts, field mutation, and payload
mutation. exp-114 Mutable Composite Locals Alpha is the previous gated
experimental compiler slice. It broadened the current local-mutation lane by
allowing same-type mutable local reassignment through `var`/`set` for
`string`, the current concrete vec families, the current concrete
option/result families, known struct values, and current enum values in the
checker, formatter local rendering, LLVM emission, diagnostics coverage,
promoted composite-local fixtures, and focused Glagol tests, while keeping
arrays immutable-only and excluding field, element, and payload mutation.
exp-113 Mutable Scalar Locals Alpha is the previous gated
experimental compiler slice. It broadened the current local-mutation lane by
allowing mutable `bool`, `i64`, and `f64` locals through `var`/`set` in the
checker, formatter messaging, LLVM emission, diagnostics coverage, promoted
local-variable fixtures, and focused Glagol tests, while keeping mutable
strings, vectors, option/results, structs, and enums unsupported. exp-112
Immutable Bool Locals Alpha is the previous gated experimental compiler
slice. It broadened only the immutable local-value lane by allowing
`let`-bound `bool` locals in the checker, LLVM emission, diagnostics
coverage, and focused Glagol tests, while keeping mutable `bool` locals
unsupported. exp-111 Standard IO Stdin Source Helpers Alpha is the previous
gated experimental stdlib/source slice. It
broadens the existing Glagol-owned local and explicit-source `std.io`
helper fixtures with `read_stdin_result`, `read_stdin_option`,
`read_stdin_or`, `read_stdin_i32_result`, `read_stdin_i32_option`,
`read_stdin_i32_or_zero`, `read_stdin_i32_or`, `read_stdin_i64_result`,
`read_stdin_i64_option`, `read_stdin_i64_or_zero`, `read_stdin_i64_or`,
`read_stdin_f64_result`, `read_stdin_f64_option`,
`read_stdin_f64_or_zero`, `read_stdin_f64_or`,
`read_stdin_bool_result`, `read_stdin_bool_option`,
`read_stdin_bool_or_false`, and `read_stdin_bool_or`, while keeping the
slice source-authored over the already promoted `std.io.read_stdin_result`,
`std.string.parse_*_result`, and exp-109 `ok_or_none_*` bridge helpers only.
exp-110 Standard String, Env, Fs, Process, And Cli Option Helpers Alpha is
the previous gated experimental stdlib/source slice. It broadens the
existing Glagol-owned local and explicit-source `std.string`, `std.env`,
`std.fs`, `std.process`, and `std.cli` helper fixtures with
`parse_i32_option`, `parse_i64_option`, `parse_f64_option`,
`parse_bool_option`, `get_option`, `get_i32_option`, `get_i64_option`,
`get_f64_option`, `get_bool_option`, `read_text_option`,
`read_i32_option`, `read_i64_option`, `read_f64_option`,
`read_bool_option`, `arg_option`, `arg_i32_option`, `arg_i64_option`,
`arg_f64_option`, `arg_bool_option`, `arg_text_option`,
`arg_i32_option`, `arg_i64_option`, `arg_f64_option`, and
`arg_bool_option`, while keeping the slice source-authored over the already
promoted result families and the exp-109 `ok_or_none_*` bridge helpers only.
exp-109 Standard Option And Result Bridge Helpers Alpha is the previous
gated experimental stdlib/source slice. It broadens the Glagol-owned local,
explicit-source, and workspace-source `std.option` and `std.result` helper
fixtures with `some_or_err_i32`, `some_or_err_i64`, `some_or_err_f64`,
`some_or_err_bool`, `some_or_err_string`, `ok_or_none_i32`,
`ok_or_none_i64`, `ok_or_none_string`, `ok_or_none_f64`, and
`ok_or_none_bool`, while keeping the slice concrete and source-authored over
the already promoted option/result forms only. exp-108 Standard Vec String,
F64, And Bool Prefix And Suffix Helpers Alpha is the earlier gated
experimental stdlib/source slice. It broadens the Glagol-owned local and
explicit-source `std.vec_string`, `std.vec_f64`, and `std.vec_bool` helper
fixtures with `starts_with`, `without_prefix`, `ends_with`, and
`without_suffix`, while keeping all three lanes recursive, immutable, and
limited to the already promoted vec-string, vec-f64, and vec-bool runtime
names. exp-107 Standard Vec String, F64, And Bool Edit Helpers Alpha is the
earlier gated experimental stdlib/source slice. It broadens the same helper
fixtures with `insert_at`, `insert_range`, `replace_at`, `replace_range`,
`remove_at`, and `remove_range` while keeping all three lanes recursive,
immutable, and limited to the already promoted vec-string, vec-f64, and
vec-bool runtime names. exp-106 Standard Vec F64 And Bool Option Query
Helpers Alpha is the earlier gated experimental stdlib/source slice. It
broadens the `std.vec_f64` and `std.vec_bool` helper fixtures with
`index_option`, `first_option`, `last_option`, `index_of_option`, and
`last_index_of_option` while keeping both lanes recursive, immutable, and
limited to the already promoted vec-f64 and vec-bool runtime names plus the
already promoted concrete option families they return. exp-105 Standard Vec
F64 And Bool Transform Helpers Alpha is the earlier gated experimental
stdlib/source slice. It broadens the same helper fixtures with `concat`,
`take`, `drop`, `reverse`, and `subvec` while keeping both lanes recursive,
immutable, and limited to the already promoted vec-f64 and vec-bool runtime
names. exp-104 Standard Vec Bool Baseline Alpha is the previous gated
experimental compiler/runtime plus stdlib/source slice. It adds concrete
`(vec bool)` support for immutable params, returns, locals, direct
`std.vec.bool.empty/append/len/index` calls, same-family vector equality,
and the scalar bool-equality enablement needed by the source helper lane in
the checker, formatter, backend, runtime, std runtime inventory, and test
runner, plus the matching Glagol-owned local and explicit-source
`std.vec_bool` helper fixtures for `empty`, `append`, `len`, `at`,
`singleton`, `append2`, `append3`, `pair`, `triple`, `is_empty`, `index_or`,
`first_or`, `last_or`, `contains`, and `count_of`. exp-103 Standard Vec F64
Baseline Alpha is the earlier gated experimental compiler/runtime plus
stdlib/source slice. It adds concrete `(vec f64)` support for immutable
params, returns, locals, direct `std.vec.f64.empty/append/len/index` calls,
and same-family vector equality in the checker, formatter, backend, runtime,
std runtime inventory, and test runner, plus the matching Glagol-owned local
and explicit-source `std.vec_f64` helper fixtures for `empty`, `append`,
`len`, `at`, `singleton`, `append2`, `append3`, `pair`, `triple`,
`is_empty`, `index_or`, `first_or`, `last_or`, `contains`, and `sum`. exp-102 Standard
Option Bool And F64 Baseline Alpha is the earlier gated
experimental compiler/runtime plus stdlib/source slice. It adds concrete
`(option f64)` and `(option bool)` support for immutable params, returns,
locals, `some`/`none`, `is_some`/`is_none`, `unwrap_some`, and source-level
`match` payload binding in the checker, formatter, backend, and test runner,
plus the matching Glagol-owned local, explicit-source, and workspace-source
`std.option` helper fixtures for `some_f64`, `none_f64`, `is_some_f64`,
`is_none_f64`, `unwrap_some_f64`, `unwrap_or_f64`, `some_bool`,
`none_bool`, `is_some_bool`, `is_none_bool`, `unwrap_some_bool`, and
`unwrap_or_bool`. exp-101 Standard Vec String Option And Transform Helpers
Alpha is the earlier gated
experimental stdlib/source slice. It broadens the existing Glagol-owned local
and explicit-source `std.vec_string` helper fixtures with the option-query
helpers `index_option`, `first_option`, `last_option`, `index_of_option`,
and `last_index_of_option`, plus the transform helpers `concat`, `take`,
`drop`, `reverse`, and `subvec`, while staying concrete to `(vec string)`
plus raw current `(option string)` / `(option i32)` forms, recursive,
immutable, and limited to the existing `std.vec.string.*` runtime names.
exp-100 Standard Option String Baseline Alpha is the earlier gated
experimental compiler/runtime plus stdlib/source slice. It adds concrete
`(option string)` support for immutable params, returns, locals,
`some`/`none`, `is_some`/`is_none`, `unwrap_some`, and source-level `match`
payload binding in the checker, formatter, backend, and test runner, plus
the matching Glagol-owned local, explicit-source, and workspace-source
`std.option` helper fixtures for `some_string`, `none_string`,
`is_some_string`, `is_none_string`, `unwrap_some_string`, and
`unwrap_or_string`. exp-99 Standard Vec String Baseline Alpha is the earlier
compiler/runtime plus stdlib/source slice. It adds concrete `(vec string)`
support for immutable params, returns, locals, direct
`std.vec.string.empty/append/len/index` calls, and concrete vec-string
equality in the checker, formatter, backend, runtime, std runtime
inventory, and test runner, plus the matching Glagol-owned local and
explicit-source `std.vec_string` helper fixtures for `empty`, `append`,
`len`, `at`, `singleton`, `append2`, `append3`, `pair`, `triple`,
`is_empty`, `index_or`, `first_or`, `last_or`, `contains`, and `count_of`.
exp-98 Standard Vec I64 Edit Helpers Alpha is the previous
stdlib/source slice. It extends the staged `std.vec_i64` helper surface
through the Glagol-owned local fixture and explicit-source import fixture
with `insert_at`, `insert_range`, `replace_at`, `replace_range`,
`remove_at`, and `remove_range`, while keeping the local lane recursive and
immutable and reusing only the existing `(vec i64)` runtime names plus
existing option support. exp-97 Standard Vec I64 Transform Helpers Alpha is
the previous stdlib/source slice. It extends the same staged helper surface
with `concat`, `take`, `drop`, `reverse`, and `subvec` while keeping the
local lane recursive and immutable and reusing only the existing `(vec i64)`
runtime names plus existing option support. exp-96 Standard Vec I64 Option
Query Helpers Alpha is the earlier stdlib/source slice. It extends the same
staged helper surface with `index_option`, `first_option`, `last_option`,
`index_of_option`, and `last_index_of_option` while keeping the local lane
recursive and immutable and reusing only the existing `(vec i64)` runtime
names plus existing option support. exp-95 Standard Option I64 Baseline Alpha
is the previous compiler/runtime plus stdlib/source slice. It adds concrete
`(option i64)` support for immutable params, returns, locals, `some`,
`none`, `is_some`, `is_none`, `unwrap_some`, and source-level `match`, plus
the matching local and explicit-source `std.option` i64 helper coverage
through `std-layout-local-option/` and `std-import-option/`. exp-94 Standard
Vec I64 Baseline Alpha is the earlier compiler/runtime plus stdlib/source
slice.
exp-93 Standard Vec I32 Count-Of Helper Alpha is the earlier stdlib/source
gate. It extended the staged `std.vec_i32` concrete helper surface with the
source-authored `count_of(values,target)` helper while reusing the existing
`std.vec.i32` runtime names only and staying within the already staged
`len`, `at`, equality, and `while` surface.
exp-92 Standard Vec I32 Without-Prefix Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`without_prefix(values,prefix)`.
exp-91 Standard Vec I32 Without-Suffix Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`without_suffix(values,suffix)`.
exp-90 Standard Vec I32 Ends-With Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`ends_with(values,suffix)`.
exp-89 Standard Vec I32 Starts-With Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`starts_with(values,prefix)`.
exp-88 Standard Vec I32 Replace Range Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`replace_range(values,start,end_exclusive,replacement)`.
exp-87 Standard Vec I32 Insert Range Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`insert_range(values,position,inserted)`.
exp-86 Standard Vec I32 Remove Range Helper Alpha is an earlier stdlib/source
gate. It extended the same staged facade with source-authored
`remove_range(values,start,end_exclusive)`.
exp-85 Standard Vec I32 Subvec Helper Alpha is an earlier stdlib/source gate.
It extended the same staged facade with source-authored
`subvec(values,start,end_exclusive)`.
exp-84 Standard Vec I32 Insert Helper Alpha is an earlier stdlib/source gate.
It extended the same staged facade with source-authored
`insert_at(values,position,value)`.
exp-83 Standard Vec I32 Remove Helper Alpha is an earlier stdlib/source gate.
It extended the same staged facade with source-authored
`remove_at(values,position)`.
exp-82 Standard Vec I32 Replace Helper Alpha is an earlier stdlib/source
gate. It extended the same staged facade with source-authored
`replace_at(values,position,replacement)`.
exp-80 Standard Vec I32 Generated Constructor Helpers Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`repeat` and `range_from_zero` helpers.
exp-79 Standard Vec I32 Transform Helpers Alpha is an earlier stdlib/source
gate. It extended the same staged facade with source-authored `concat`,
`take`, `drop`, and `reverse` helpers.
exp-78 Standard CLI Local Source Facade Alpha is an earlier stdlib/source
gate. It keeps the staged `std.cli` helper surface unchanged while adding the
Glagol local `cli/process/string` fixture and alignment coverage for that same
source-authored facade shape.
exp-77 Standard Vec I32 Option Query Helpers Alpha is an earlier stdlib/source
gate. exp-76 Standard Vec I32 Source Helpers Alpha is an earlier stdlib/source
gate. exp-75 Standard Option Constructors Alpha is an earlier stdlib/source
gate. exp-74 Standard Result Constructor Helpers Alpha is an earlier
stdlib/source gate. exp-73 Standard Io Value Helpers Alpha is an earlier
stdlib/source gate.
exp-72 Standard Cli Custom Fallback Helpers Alpha is an earlier stdlib/source
gate. exp-71 Standard Process Custom Fallback Helpers Alpha is an earlier
stdlib/source gate. exp-70 Standard Fs Custom Fallback Helpers Alpha is an
earlier stdlib/source gate. exp-69 Standard Env Custom Fallback Helpers Alpha
is an earlier stdlib/source gate. exp-68 Standard String Custom Fallback
Helpers Alpha is an earlier stdlib/source gate. exp-67 Standard Process Typed
Helpers Alpha is an earlier stdlib/source gate. exp-66 Standard Fs Typed Read
Helpers Alpha is an earlier stdlib/source gate. exp-65 Standard Env Typed
Helpers Alpha is an earlier stdlib/source gate. exp-64 Standard Num Fallback
Helpers Alpha is an earlier stdlib/source gate.
exp-63 Standard Fs Fallback Helpers Alpha is an earlier stdlib/source gate.
exp-62 Standard Env Fallback Helpers Alpha is an earlier stdlib/source gate.
exp-61 Standard Process Fallback Helpers Alpha is an earlier stdlib/source
gate. exp-60 Standard String Fallback Helpers Alpha is an earlier
stdlib/source gate. exp-59 Hosted Build Optimization And Benchmark Publication
Alpha is the previous compiler/tooling gate. exp-58 Boolean Logic Alpha is the
previous compiler gate. exp-57 Integer Bitwise Alpha is the previous
compiler/stdlib gate. exp-56 Integer Remainder Alpha is an earlier
compiler/stdlib gate. exp-55 Result F64 Bool Source Flow Alpha is an earlier
compiler gate. exp-54 Standard CLI Typed Arguments Alpha is an earlier source
facade gate.
exp-53 Standard CLI Source Facade Alpha is an earlier source facade gate.
exp-52 Standard Process Facade Source Search Alpha is an earlier source facade
gate. exp-51 Standard Library Path List Alpha is the previous toolchain
discovery gate. exp-50 Installed Standard Library Discovery Alpha is an
earlier toolchain discovery gate. exp-43 Technical Whitepapers And Skills
Alpha is an earlier released documentation/tooling gate.
exp-42 Hot Loop Benchmark Mode Alpha is the latest released experimental
benchmark tooling gate.
exp-41 Lisp Benchmark Comparison Alpha is an earlier released experimental
benchmark comparison gate.
exp-40 Benchmark Suite And License Alpha is the latest released experimental
license/governance gate.
exp-39 Standard Math Extensions And Benchmark Scaffold Alpha is the latest
released experimental source-helper gate. exp-34 String Parse Bool Result
Alpha is the latest compiler semantic/runtime-operation support slice.

## Phase 1: Make Current Compiler Trustworthy

- [x] Add Rust integration tests for `examples/add.slo`.
- [x] Wire `tests/add.expected.ll` into a snapshot or shape-based test.
- [x] Add negative tests for unknown function, arity mismatch, type mismatch, unclosed list, and unknown top-level form.
- [x] Remove source-reachable backend panics.
- [x] Add `UnsupportedBackendFeature` diagnostics or implement lowering for all checked expression variants.
- [x] Add an explicit test for checked `if` not crashing the backend.
- [x] Remove unused imports and warnings in touched files.

## Phase 2: Close Critical Semantic Gaps

- [x] Implement LLVM lowering for value-producing `if` with then/else/merge blocks and `phi`.
- [x] Preserve spans on checked expressions.
- [x] Add integer range diagnostics for i32 literals.
- [x] Add severity to diagnostics.
- [x] Add line/column ranges while preserving byte spans.
- [x] Ensure complex placeholder types cannot emit ABI-sensitive LLVM accidentally.

## Phase 3: Restore Slovo Tooling Promise

- [x] Add parsed-tree printer.
- [x] Add canonical formatter for supported syntax.
- [x] Add formatter fixtures.
- [x] Add machine-diagnostic snapshots.
- [x] Add lowering inspector from surface AST to checked/core AST.

## Phase 4: Implement Slovo v0 Core

- [x] Implement top-level `(test "name" expr)` or explicitly reject it in supported examples.
- [x] Implement `let`, `var`, and `set`.
- [x] Promote value-producing `if`.
- [x] Implement `while`.
- [x] Implement string runtime support or structured unsupported diagnostics.
- [x] Implement first-pass structs and immediate field access.
- [x] Implement arrays and checked indexing.
- [x] Implement first-pass `option` and `result` constructors.
- [x] Implement lexical `unsafe` and unsafe-required diagnostics.

## Phase 5: Close v0 Compiler Surface

- [x] Treat `glagol` as the v0 binary CLI.
- [x] Document supported CLI modes, stdout/stderr behavior, and exit codes.
- [x] Test successful help, diagnostic failures, input failures, and usage errors.
- [x] Keep direct native executable output deferred behind the explicit
      LLVM-plus-Clang workflow.

## Phase 6: Start Slovo v1 Value Flow

- [x] Implement immutable struct locals, struct parameters, struct returns,
      calls returning structs, and field access through stored struct values.
- [x] Keep struct field/value mutation deferred for v1.
- [x] Implement option/result value flow and first-pass tag observation.
- [x] Implement option/result payload extraction after Slovo
      specifies the contract.
- [x] Keep broader option/result matching deferred until Slovo later specifies
      a narrow source-level `match` slice.
- [x] Implement array value flow and runtime-checked dynamic indexing for
      fixed-size `i32` arrays.
- [x] Implement the narrow string runtime slice: direct string literals stored
      as borrowed static `ptr` values and passed to temporary `print_string`.
- [x] Keep full string value flow and broad runtime printing deferred for v1.

## Phase 7: Polish The Binary CLI

- [x] Add explicit `--emit=llvm` while keeping default LLVM emission compatible.
- [x] Add `-o <path>` for successful primary output.
- [x] Add `--version` from Cargo package metadata.
- [x] Keep direct executable output deferred behind the LLVM-plus-Clang workflow.
- [x] Keep stdin source input deferred until source naming and span behavior are
      specified.

## Phase 8: Start Slovo v1 Tooling Contracts

- [x] Emit Slovo v1 machine diagnostics with `(schema slovo.diagnostic)`,
      `(version 1)`, and a root `(diagnostic ...)` form.
- [x] Add `--manifest <path>` for Slovo v1 textual artifact manifests on
      successful primary modes and source-diagnostic failures.
- [x] Reject user-visible `unit` parameter and return signatures with
      structured diagnostics while keeping `unit` available to internal
      compiler/runtime forms.
- [x] Preserve existing stdout, stderr, and `-o` behavior while adding
      manifest output as a side channel, not as native executable output.
- [x] Expand formatter stability coverage for comments, nested promoted forms,
      and long inline forms.
- [x] Expand and audit the v1 golden diagnostic matrix beyond the first schema
      migration.
- [x] Add lowering-inspector golden fixtures for every promoted v1 feature
      family.
- [x] Keep stable LLVM debug metadata, DWARF, source-map files, and stable
      ABI/layout promises deferred for v1.

## Phase 9: Slovo v1.1 Toolchain Productization

- [x] Add canonical `check`, `fmt`, `test`, and `build` subcommands.
- [x] Preserve v1 compatibility flags and default LLVM emission.
- [x] Add `--json-diagnostics` with newline-delimited
      `slovo.diagnostic` version `1` output.
- [x] Add `--no-color` across canonical commands and compatibility modes.
- [x] Implement hosted native `build` through emitted LLVM IR,
      `runtime/runtime.c`, and Clang with `GLAGOL_CLANG` override.
- [x] Implement v1.1 exit codes `0`, `1`, `2`, `3`, and `5`; reserve `4`
      for internal compiler errors.
- [x] Extend manifests for no-output `check`, canonical commands,
      diagnostics encoding, build artifacts, and parsed failure cases.
- [x] Add focused CLI, JSON diagnostic, manifest failure, missing-Clang, and
      ignored hosted-build smoke tests.

## Phase 10: Slovo v1.2 Practical Runtime Values

- [x] Implement immutable string `let` locals, parameters, returns, and calls
      returning strings.
- [x] Implement string equality with `=`.
- [x] Implement string byte length through temporary intrinsic `string_len`.
- [x] Implement temporary intrinsic `print_bool`.
- [x] Add deterministic runtime trap stderr messages for array bounds and
      option/result unwrap failures.
- [x] Make runtime traps exit with code `1` for `glagol test` trapped tests
      and produced executables.
- [x] Keep the v1.1 CLI/toolchain surface unchanged.
- [x] Keep `print_unit`, mutable strings, string concatenation, strings in
      containers, project mode, imports, and modules deferred.
- [x] Add fixture alignment, formatter idempotence, lowering-inspector,
      diagnostic, runtime smoke, and process-exit gates matching the Slovo
      v1.2 contract.

## Phase 11: Slovo v1.3 Project Mode And Modules

- [x] Read `slovo.toml` project manifests with `[project]`, required `name`,
      optional `source_root = "src"`, and optional `entry = "main"`.
- [x] Select project mode for `glagol check`, `glagol test`, and
      `glagol build` only when input is a project root or the `slovo.toml`
      file itself.
- [x] Keep single-file `.slo` behavior unchanged from v1.2.
- [x] Discover only immediate `.slo` module files under the flat source root.
- [x] Accept module export lists such as
      `(module math (export add_one Point))`.
- [x] Accept explicit local imports such as `(import math (add_one Point))`.
- [x] Enforce import/export visibility, module-private top-level names,
      duplicate-name rules, and reserved builtin/intrinsic names.
- [x] Compile, test, diagnose, and write manifests in deterministic module
      order.
- [x] Preserve source file identity and related spans for cross-file
      diagnostics.
- [x] Extend `slovo.artifact-manifest` version `1` output for project roots,
      manifests, source roots, module lists, import edges, test counts, and
      build outputs.
- [x] Add project fixture, manifest, command, diagnostic, deterministic-order,
      artifact-manifest, and single-file regression gates matching the Slovo
      v1.3 contract.
- [x] Keep packages/dependencies, workspaces, aliases/globs/qualified imports,
      re-exports, nested modules, project formatting, path escapes, watch/LSP,
      incremental builds, generated sources, object/library/header outputs, and
      ABI promises deferred.

## Phase 12: Slovo v1.4 Core Language Expansion

- [x] Implement source-level `match` for exactly `(option i32)` and
      `(result i32 i32)`.
- [x] Require exhaustive two-arm forms: `some`/`none` for options and
      `ok`/`err` for results.
- [x] Implement immutable payload bindings for `some`, `ok`, and `err`.
- [x] Scope payload bindings and local bindings to one arm body only.
- [x] Type each `match` expression as the common arm result type.
- [x] Add diagnostics for subject type mismatch, unsupported payload type,
      non-exhaustive matches, duplicate arms, malformed patterns, arm type
      mismatch, binding collisions, unsupported mutation, and unsupported
      containers.
- [x] Add canonical multiline formatter support for promoted `match`.
- [x] Add lowering-inspector, LLVM/runtime smoke, fixture-alignment, formatter,
      diagnostic, and regression gates matching the Slovo v1.4 contract.
- [x] Keep user-defined enums/ADTs, generics, non-`i32` payload matching,
      nested option/result payloads, option/result containers, mutation,
      vectors, `i64`, general block expressions, guards, wildcard/rest
      patterns, destructuring, standard-library error conventions, ownership,
      layout, and ABI guarantees deferred.

## Phase 13: Slovo v1.5 Standard Library Alpha

- [x] Implement compiler-known source-level standard-runtime names
      `std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and
      `std.string.len`.
- [x] Preserve legacy `print_i32`, `print_string`, `print_bool`, and
      `string_len` as compatibility aliases.
- [x] Reject unknown or unpromoted `std.*` calls with a structured diagnostic,
      suggested code `UnsupportedStandardLibraryCall`.
- [x] Reserve the exact promoted `std.*` names from user function/export
      shadowing.
- [x] Keep promoted names out of user module, import, package, FFI, and stable
      C ABI semantics.
- [x] Add fixture alignment for `examples/standard-runtime.slo`, formatter
      idempotence for `tests/standard-runtime.slo`, lowering-inspector,
      runtime-smoke, diagnostic, and regression gates matching the Slovo v1.5
      contract.
- [x] Keep `std.io.print_unit`, file IO, environment variables, process
      arguments, time, collections, allocation, overloading, generics, Unicode
      length semantics, ABI/layout promises, and FFI deferred.

## Phase 14: Slovo v1.6 Memory And Unsafe Design Slice

- [x] Centralize compiler-known unsafe operation head metadata for `alloc`,
      `dealloc`, `load`, `store`, `ptr_add`, `unchecked_index`, `reinterpret`,
      and `ffi_call`.
- [x] Preserve lexical unsafe gating: outside `(unsafe ...)`, these heads
      produce `UnsafeRequired` before user-function lookup; inside
      `(unsafe ...)`, they produce `UnsupportedUnsafeOperation`.
- [x] Reserve compiler-known unsafe heads from user functions, project
      imports/exports, parameters, locals, structs, and match payload bindings
      where the current reservation architecture applies.
- [x] Add diagnostics-contract coverage for every unsafe head in both the
      unsafe-required and unsupported-inside-unsafe gates.
- [x] Keep raw memory, pointers, allocation/free, unchecked indexing,
      reinterpretation, FFI execution, stable ABI/layout promises, and runtime
      C symbols deferred.

## Phase 15: Glagol v1.7 Developer Experience Hardening

- [x] Add `glagol new <project-dir> [--name <name>]` for minimal local project
      scaffolding with structured diagnostics for blocked targets and invalid
      arguments.
- [x] Add `glagol fmt --check` and `glagol fmt --write` for files and project
      inputs while preserving plain `glagol fmt <file>` stdout formatting.
- [x] Extend formatter coverage only for already-supported project module
      declarations, exports, imports, and imported calls.
- [x] Add `glagol doc <file-or-project> -o <dir>` for deterministic Markdown
      summaries of modules, imports, exports, structs, functions, and tests
      from current parser/lowerer/source forms.
- [x] Add `scripts/release-gate.sh` for the local release gate from either the
      repository root or compiler directory context.
- [x] Keep Slovo language syntax and semantics unchanged.

## Phase 16: Glagol v2.0.0-beta.1 Experimental Gate

- [x] Treat the release as an experimental gate/readiness release based on
      v1.7, not as a new language expansion.
- [x] Document the experimental-supported CLI, project workflow, language
      surface, and explicit deferrals in `.llm/V2_0_0_BETA_1_RELEASE_GATE.md`.
- [x] Verify a scaffolded experimental project can run through `new`,
      `fmt --check`, `test`, `doc`, and hosted `build` when the toolchain is
      available.
- [x] Keep the standard-runtime alpha scoped to basic IO/string names:
      `std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and
      `std.string.len`.
- [x] Keep fixed-size immutable `i32` arrays as the current collection subset.
- [x] Defer vectors, growable collections, package registries, stable
      ABI/layout, FFI, raw-memory execution, LSP, debug metadata, and
      source-map files until future beta work.

## Phase 17: exp-1 Owned String Concat Slice

- [x] Implement compiler-known `std.string.concat(left right)` without adding
      new syntax.
- [x] Keep concat strict to the standard-runtime name; no legacy
      `string_concat` alias is promoted.
- [x] Lower concat through an explicit private runtime helper without claiming
      stable ABI, layout, allocator, or lifetime semantics.
- [x] Keep string mutation, string containers, user deallocation, and `+`
      string concatenation deferred behind existing diagnostics.
- [x] Add checker, formatter, lowering-inspector, test-runner, LLVM-shape, and
      hosted-runtime coverage for the narrow slice.

## Phase 18: exp-2 Collections Alpha Slice

- [x] Implement the initial growable collection type: `(vec i32)`.
- [x] Extend the concrete vector family with `(vec i64)` in exp-94.
- [x] Promote compiler-known `std.vec.i32.empty`, `std.vec.i32.append`,
      `std.vec.i32.len`, and `std.vec.i32.index`.
- [x] Promote compiler-known `std.vec.i64.empty`, `std.vec.i64.append`,
      `std.vec.i64.len`, and `std.vec.i64.index`.
- [x] Keep vector values immutable from source; `append` returns a new
      runtime-owned vector instead of mutating the input.
- [x] Implement same-family `(vec i32)` and `(vec i64)` equality with `=`.
- [x] Lower vector operations through private runtime helpers and reserve
      helper symbols from source/project names.
- [x] Add runtime traps for vector allocation failure and vector index
      out-of-bounds.
- [x] Add formatter, lowering-inspector, test-runner, LLVM/runtime, diagnostic
      snapshot, fixture-inventory, and hosted-runtime coverage for the slice.
- [x] Keep generic vectors, element families beyond `i32` and `i64`, vector
      mutation, push aliases, nested vectors, vectors inside other containers,
      stable layout, ABI, FFI, and deallocation deferred behind diagnostics.

## Phase 19: exp-3 Standard IO And Host Environment Slice

- [x] Implement the conservative exp-3 host IO standard-runtime calls.
- [x] Keep networking, async IO, binary IO, directory traversal, terminal
      control, stdin iteration, time, randomness, and stable host ABI deferred.

## Phase 20: exp-4 User ADTs Alpha Slice

- [x] Implement payloadless user-defined enums, qualified constructors,
      equality, value flow, top-level tests, and exhaustive variant matches.
- [x] Keep payload variants, generic ADTs, type aliases, traits, methods,
      unqualified variants, enum mutation, enum printing, enum ordering, enum
      containers, stable layout, and stable ABI deferred.

## Phase 21: exp-5 Local Packages And Workspaces Alpha

- [x] Read workspace `[workspace] members` manifests and member package
      `[package]` manifests with `name`, `version`, `source_root`, and `entry`.
- [x] Support local `[dependencies]` path records such as
      `mathlib = { path = "../mathlib" }`.
- [x] Build a deterministic closed local package graph.
- [x] Accept package-qualified imports such as
      `(import mathlib.math (add_one))`.
- [x] Enforce package boundaries through existing module export lists.
- [x] Extend artifact manifests with workspace and package graph information.
- [x] Diagnose missing packages, duplicate package names, dependency cycles,
      path escapes, invalid package names, invalid package versions, private
      visibility, and dependency key mismatches.
- [x] Diagnose duplicate package manifest keys, invalid dependency keys, and
      duplicate dependency keys explicitly.
- [x] Keep registries, lockfiles, semver solving, aliases/globs/re-exports,
      generated code, build scripts, publishing, optional/dev/target
      dependencies, stable package ABI, and remote dependencies deferred.

## Phase 22: exp-6 C FFI Scalar Imports Alpha

- [x] Accept top-level imported C declarations such as
      `(import_c c_add ((lhs i32) (rhs i32)) -> i32)`.
- [x] Restrict imported C signatures to `i32` parameters and `i32` or builtin
      `unit` returns.
- [x] Require conservative C symbol names shared with the source import name.
- [x] Require calls to imported C functions to appear inside lexical
      `(unsafe ...)`.
- [x] Preserve raw unsafe head diagnostics; `ffi_call` and the other v1.6 raw
      unsafe heads remain unsupported even inside unsafe blocks.
- [x] Lower accepted imports to LLVM external declarations and direct calls.
- [x] Support explicit local C source linking through
      `glagol build --link-c <path>`.
- [x] Report `UnsupportedTestExpression` when the interpreter-style test
      runner reaches an imported C call.
- [x] Extend artifact manifests with `foreign_imports` and `c_link_inputs`.
- [x] Keep pointers, raw allocation/deallocation, raw unsafe head execution,
      ownership/lifetime rules, C exports, callbacks, headers/libraries,
      broad linker configuration, and stable ABI/layout deferred.

## Phase 23: exp-7 Test Selection Alpha

- [x] Add `--filter <substring>` for `glagol test` and the legacy
      single-file `--run-tests` mode.
- [x] Count skipped tests before evaluation and record selected/skipped
      metadata in artifact manifests.
- [x] Keep tags, groups, retries, parallelism, benchmark behavior, and watch
      mode deferred.

## Phase 24: exp-8 Host Time And Sleep Alpha

- [x] Promote compiler-known `std.time.monotonic_ms: () -> i32` and
      `std.time.sleep_ms: (i32) -> unit`.
- [x] Lower native calls through private runtime helpers and implement
      process-relative monotonic milliseconds plus `nanosleep`.
- [x] Support deterministic `sleep_ms 0` and non-negative monotonic execution
      in the test runner; trap negative sleeps with the exact runtime message.
- [x] Keep threads, channels, async, timers, wall-clock time, time zones,
      scheduling guarantees, cancellation, high-resolution timing, and stable
      runtime ABI deferred.
- [x] Review artifact manifests: no current standard-runtime usage structure
      exists, so exp-8 defers time-specific metadata.

## Phase 25: exp-9 Reliability Performance And Ecosystem Hardening

- [x] Add Glagol exp-9 documentation/audit state aligned with the Slovo
      hardening target.
- [x] Record compatibility inventory for `v2.0.0-beta.1` and exp-1 through
      exp-8.
- [x] Record migration guidance that requires no source syntax, standard
      runtime, or manifest schema migration by default.
- [x] Record source-reachable panic audit classifications for current source
      markers.
- [x] Record benchmark smoke commands and known limits without public numeric
      thresholds.
- [x] Add parser, formatter, diagnostic, project graph, runtime API,
      test-runner, backend-precondition, and artifact-manifest hardening tests.
- [x] Add exp-9 corpus coverage and panic-audit classifications proving the
      current source-reachable panic markers are diagnostic/trap boundaries or
      non-source-reachable invariants.
- [x] Run the exp-9 release gate and benchmark smoke evidence.
- [x] Write exp-9 release review evidence.
- [x] Keep exp-9 hardening-only: no source syntax, no new standard-runtime
      names, no runtime capability expansion, no manifest schema bump, no ABI
      or performance stability claim, and no beta maturity claim.

## Phase 26: exp-10 Result-Based Host Errors Alpha

- [x] Implement concrete `(result string i32)` value flow, observers, unwraps,
      and exact two-arm `match` without broadening arbitrary result payloads.
- [x] Promote `std.process.arg_result`, `std.env.get_result`,
      `std.fs.read_text_result`, and `std.fs.write_text_result`.
- [x] Return ordinary host failures as exactly `err 1`.
- [x] Preserve exp-3 host call behavior unchanged for traps, missing
      environment variables, and write status values.
- [x] Add formatter, lowering-inspector, diagnostics, deterministic
      test-runner, LLVM/runtime, and fixture-alignment gates for the target
      fixture `host-io-result.slo`.
- [x] Keep exp-10 experimental only: no generic results, typed host error ADTs,
      error messages, errno domains, result equality/printing/mapping,
      manifest schema bump, stable ABI/layout, or beta maturity.

## Phase 27: exp-11 Basic Randomness Alpha

- [x] Promote exactly `std.random.i32 : () -> i32`.
- [x] Return a non-negative implementation-owned `i32` in runtime and
      deterministic-enough test-runner paths.
- [x] Trap runtime unavailability with exactly
      `slovo runtime error: random i32 unavailable`.
- [x] Add fixture alignment, formatter, lowering-inspector, diagnostic,
      test-runner, LLVM/runtime, and promotion-gate coverage for
      `random.slo`.
- [x] Keep exp-11 experimental only: no seed APIs, crypto suitability, range
      arguments, bytes, strings, UUIDs, stable sequences, manifest schema bump,
      stable helper ABI, runtime headers/libraries, or beta maturity.

## Phase 28: exp-12 Standard Input Result Alpha

- [x] Promote exactly `std.io.read_stdin_result : () -> (result string i32)`.
- [x] Return `ok` with remaining stdin text, including EOF as `ok ""`, and
      ordinary host/input failure as `err 1`.
- [x] Align Slovo supported and formatter fixtures with `stdin-result.slo`.
- [x] Cover formatter and lowering-inspector visibility for
      `(std.io.read_stdin_result)`.
- [x] Cover diagnostics for arity mismatch, bool-context/type misuse,
      source-name shadowing, helper-symbol shadowing, unsupported trap-based
      `std.io.read_stdin`, line/read-line APIs, prompt APIs, terminal mode,
      binary stdin, streaming, async stdin, and unknown deferred stdin
      boundaries named by Slovo.
- [x] Keep exp-12 experimental only: no trap-based stdin, line iteration,
      prompt APIs, terminal mode, binary stdin, streaming, async IO, encoding
      or Unicode promise, stable helper ABI/layout, manifest schema change,
      or beta maturity.

## Phase 29: exp-13 String Parse I32 Result Alpha

- [x] Promote exactly
      `std.string.parse_i32_result : (string) -> (result i32 i32)`.
- [x] Parse an entire ASCII decimal signed `i32`, returning `ok value` on
      success and ordinary parse failure as `err 1`.
- [x] Align Slovo supported and formatter fixtures with
      `string-parse-i32-result.slo`.
- [x] Cover formatter and lowering-inspector visibility for
      `(std.string.parse_i32_result text)`.
- [x] Cover diagnostics for arity mismatch, invalid argument type,
      result/bool-context misuse, source-name shadowing, helper-symbol
      shadowing, trap-based `std.string.parse_i32`, unsupported parse
      families, string indexing/slicing, tokenizer/scanner APIs, and named
      deferred parse boundaries.
- [x] Keep exp-13 experimental only: no trap-based parse,
      float/bool/string/bytes parsing, whitespace/locale/base-prefix/
      underscore/plus-sign parsing, generic parse API, richer parse errors,
      Unicode digit parsing, string indexing/slicing, tokenizer/scanner APIs,
      stdin line APIs, stable helper ABI/layout, runtime headers/libraries,
      manifest schema changes, or beta maturity.

## Phase 30: exp-14 Standard Runtime Conformance Alignment

- [x] Add Glagol `time-sleep.slo` supported and formatter fixtures over the
      released exp-8 `std.time.monotonic_ms` and `std.time.sleep_ms 0`
      surface.
- [x] Add lowering-inspector snapshots, promotion-gate inventory, formatter
      checks, compile-shape checks, and test-runner checks for the time/sleep
      fixture.
- [x] Add a focused conformance gate script separate from
      `scripts/release-gate.sh`.
- [x] Add focused integration coverage for projects/imports, tests, docs,
      `fmt --check`, `check`, `test`, hosted build/run when available, and
      the released standard-runtime surface through exp-13 plus exp-8
      time/sleep.
- [x] Release exp-14 only after focused conformance, full release gate, and
      Slovo/Glagol review pass together.
- [x] Keep exp-14 experimental only: no source syntax, type forms,
      standard-library operation names, runtime APIs, ABI/layout promises,
      manifest schema changes, or beta maturity.

## Phase 31: exp-15 Result Helper Standard Names Alpha

- [x] Accept exactly `std.result.is_ok`, `std.result.is_err`,
      `std.result.unwrap_ok`, and `std.result.unwrap_err`.
- [x] Map those names to existing result observer/unwrap behavior for exactly
      `(result i32 i32)` and `(result string i32)`.
- [x] Preserve source helper spelling in surface and checked lowering output.
- [x] Keep legacy `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err` working.
- [x] Add `result-helpers.slo` examples/tests, lowering snapshots,
      promotion-gate inventory, formatter coverage, compile-shape coverage,
      test-runner coverage, and focused negative tests for deferred/misused
      names.
- [x] Keep exp-15 experimental only: no `std.result.map`,
      `std.result.unwrap_or`, `std.result.and_then`, option standard names,
      generic results, new result payload families, runtime/runtime.c changes,
      LLVM runtime declarations, manifest schema changes, or beta maturity.

## Phase 32: exp-16 Unary I32 Enum Payloads Alpha

- [x] Support user enum declarations with payloadless variants and unary `i32`
      payload variants.
- [x] Support qualified payload and payloadless constructors, immutable enum
      locals/params/returns/calls/tests/main flow, and same-enum equality.
- [x] Require exhaustive enum matches with no binding on payloadless variants
      and one immutable arm-local `i32` binding on payload variants.
- [x] Lower payload enums as compiler-owned tag-plus-`i32` aggregates in LLVM
      and the test runner, without runtime/runtime.c changes or ABI/layout
      claims.
- [x] Add `enum-payload-i32.slo` examples/tests, surface and checked lowering
      snapshots, formatter coverage, focused Rust integration tests,
      promotion-gate inventory, and diagnostics for payload boundary cases.
- [x] Keep exp-16 experimental only: no non-`i32` payload types, multiple
      payloads, record variants, generic enums/functions, wildcard/rest/nested
      enum patterns, guards, enum containers, enum mutation, enum printing,
      enum ordering/hash/reflection/discriminants, runtime ABI/layout claims,
      manifest schema changes, or beta maturity.

## Future Beta Next

- [x] Complete exp-9 hardening gates before adding source semantics.
- [x] Completed exp-10 gates; result-based host errors are released as
      experimental compiler support.
- [x] Completed exp-11 gates; basic randomness is released as experimental
      compiler support.
- [x] Completed exp-12 gates; standard input result is released as
      experimental compiler support.
- [x] Completed exp-13 gates; string parse i32 result is released as
      experimental compiler support.
- [x] Complete exp-14 Standard Runtime Conformance Alignment gates before
      treating the conformance fixture/gate set as released experimental
      support.
- [x] Completed exp-15 gates; result helper standard names are released as
      experimental compiler support.
- [x] Completed exp-16 gates; unary `i32` enum payloads are released as
      experimental compiler support.
- [x] Completed exp-17 gates; project/workspace enum imports are released as
      experimental compiler support.
- [x] Completed exp-18 gates; direct enum struct fields are released as
      experimental compiler support.

## Phase 33: exp-17 Project/Workspace Enum Imports Alpha

- [x] Treat top-level enum declarations as project/workspace local declarations
      that can be exported and imported alongside functions and structs.
- [x] Preserve payloadless and unary `i32` payload variant metadata for imported
      enum types in signatures, immutable locals, calls/returns, constructors,
      equality, exhaustive matches, `main`, and tests.
- [x] Keep project/workspace symbol rewriting aligned for enum declarations,
      enum types, qualified constructors, enum match patterns, and imported enum
      symbols.
- [x] Add project and workspace/package tests plus the
      `examples/projects/enum-imports/` fixture.
- [x] Keep exp-17 experimental only: no non-`i32` payloads, multi-payloads,
      record variants, enum containers, mutation, printing, ordering, generics,
      stable ABI/layout, manifest schema changes, registry/package-manager
      behavior, or beta maturity.
- [ ] If collections expand later, specify generic vectors/growable
      collections in Slovo first, then add Glagol parser/checker/formatter/
      diagnostic/backend/runtime gates.
- [ ] If editor tooling is promoted later, specify LSP/watch/debug/source-map
      behavior before claiming support.

## Phase 34: exp-18 Enum Struct Fields Alpha

- [x] Allow direct known enum types as struct fields for current payloadless
      and unary `i32` payload enums.
- [x] Preserve `UnsupportedEnumContainer` for arrays, vectors, options, and
      results containing enum values in struct fields.
- [x] Keep other unsupported struct field types on the existing
      `UnsupportedStructFieldType` path.
- [x] Add `enum-struct-fields.slo` examples/tests, surface and checked lowering
      snapshots, focused Rust integration tests, promotion-gate inventory, and
      diagnostics for enum container fields.
- [x] Keep exp-18 experimental only: no enum containers, nested structs,
      mutation, printing, ordering/hash/reflection, broader payloads, generics,
      stable ABI/layout, manifest schema changes, package registry behavior,
      import aliases/globs/re-exports, or beta maturity.

## Phase 35: exp-19 Primitive Struct Fields Alpha

- [x] Allow direct `bool` and immutable `string` field types in top-level
      structs, alongside existing direct `i32` fields and exp-18 direct enum
      fields.
- [x] Preserve unsupported diagnostics for arrays, vectors, options, and
      results containing these field types, nested structs, and unknown named
      field types.
- [x] Add `primitive-struct-fields.slo` examples/tests, surface and checked
      lowering snapshots, focused Rust integration tests, promotion-gate
      inventory, diagnostics, formatter coverage, test-runner coverage, LLVM
      shape coverage, and Slovo alignment hooks.
- [x] Keep exp-19 experimental only: no primitive containers as struct fields,
      nested structs, mutation, broader string ownership/cleanup promises,
      generics, methods/traits, stable ABI/layout, manifest schema changes,
      import/package widening, or beta maturity.

## Phase 36: exp-20 F64 Numeric Primitive Alpha

- [x] Add direct `f64` type/literal value flow for locals, parameters,
      returns, calls, top-level tests, and `main`-reachable helper calls.
- [x] Lower `f64` to LLVM `double`, including constants, function
      parameters/returns, arithmetic `+ - * /`, equality, and ordered
      comparisons.
- [x] Promote exactly `std.io.print_f64 : (f64) -> unit` with runtime
      `%.17g\n` formatting and test-runner coverage.
- [x] Add `f64-numeric-primitive.slo` examples/tests, surface and checked
      lowering snapshots, formatter coverage, focused Rust integration tests,
      LLVM shape coverage, runtime smoke, and mixed i32/f64 diagnostics.
- [x] Keep exp-20 experimental only: no f32, wider integer families,
      characters/bytes/decimal, casts, mixed i32/f64 arithmetic, f64
      arrays/vectors/options/results/enum payloads/struct fields, parse_f64,
      random floats, stable ABI/layout, or beta maturity.

## Phase 37: exp-21 I64 Numeric Primitive Alpha

- [x] Add direct `i64` type/literal value flow for immutable locals,
      parameters, returns, calls, top-level tests, and `main`-reachable helper
      calls.
- [x] Require explicit signed decimal `i64` suffix atoms and reject malformed
      or out-of-range `i64` literals with structured diagnostics.
- [x] Lower `i64` to LLVM `i64`, including constants, function
      parameters/returns, arithmetic `+ - * /`, equality, and ordered
      comparisons.
- [x] Promote exactly `std.io.print_i64 : (i64) -> unit` with runtime decimal
      output and test-runner coverage.
- [x] Add `i64-numeric-primitive.slo` examples/tests, surface and checked
      lowering snapshots, formatter coverage, focused Rust integration tests,
      LLVM shape coverage, runtime smoke, fixture alignment hooks, and
      diagnostics for mutable i64 locals and mixed numeric operands.
- [x] Keep exp-21 experimental only: no f32, unsigned integers, narrower
      signed integers, characters/bytes/decimal, casts, mixed
      i32/i64/f64 arithmetic, i64 arrays/vectors/options/results/enum
      payloads/struct fields, parse_i64, random i64, stable ABI/layout, or
      beta maturity.

## Phase 38: exp-22 Numeric Widening Conversions Alpha

- [x] Promote exactly `std.num.i32_to_i64 : (i32) -> i64`,
      `std.num.i32_to_f64 : (i32) -> f64`, and
      `std.num.i64_to_f64 : (i64) -> f64`.
- [x] Lower the promoted conversions directly to LLVM `sext`/`sitofp`
      conversion instructions without adding stable runtime helper ABI
      promises.
- [x] Execute the conversions in the deterministic test runner and preserve
      them in formatter and lowering-inspector fixtures.
- [x] Add diagnostics for wrong arity, wrong argument type, and explicitly
      unsupported narrowing or generic cast names.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
      fixtures for `numeric-widening-conversions.slo`.
- [x] Keep exp-22 experimental only: no implicit promotion, mixed numeric
      operators, narrowing or checked conversions, cast syntax, broader
      numeric families, stable ABI/layout, manifest schema changes, or beta
      maturity.

## Phase 39: exp-23 Checked I64-To-I32 Conversion Alpha

- [x] Promote exactly
      `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`.
- [x] Return `ok value` for signed `i64` inputs in signed `i32` range and
      `err 1` for out-of-range inputs, with no traps.
- [x] Lower directly to LLVM signed range checks, `trunc`, `select`, and the
      existing `(result i32 i32)` aggregate representation without adding a
      stable helper ABI promise.
- [x] Execute the conversion in the deterministic test runner and preserve it
      in formatter and lowering-inspector fixtures.
- [x] Add diagnostics for wrong arity, wrong argument type, and explicitly
      unsupported deferred checked/cast names.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
      fixture hooks for `checked-i64-to-i32-conversion.slo`.
- [x] Keep exp-23 experimental only: no implicit promotion, unchecked
      narrowing, cast syntax, additional narrowing conversions, f64
      conversions, stable ABI/layout, manifest schema changes, or beta
      maturity.

## Phase 40: exp-24 Integer To String Alpha

- [x] Promote exactly `std.num.i32_to_string : (i32) -> string` and
      `std.num.i64_to_string : (i64) -> string`.
- [x] Return signed decimal ASCII text with a leading `-` only for negative
      values and no leading `+`.
- [x] Lower to private runtime helpers with current implementation-owned
      string allocation behavior and no stable helper ABI/layout promise.
- [x] Execute both calls in the deterministic test runner and preserve them
      in formatter and lowering-inspector fixtures.
- [x] Add diagnostics for wrong arity, wrong argument type, and explicitly
      unsupported deferred formatting names.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
      fixture hooks for `integer-to-string.slo`.
- [x] Keep exp-24 experimental only: no f64 formatting, parse APIs,
      locale/base/radix/grouping/padding, generic display/format traits,
      implicit conversion, manifest schema changes, stable helper ABI/layout,
      or beta maturity.

## Phase 41: exp-25 String Parse I64 Result Alpha

- [x] Promote exactly
      `std.string.parse_i64_result : (string) -> (result i64 i32)`.
- [x] Accept only an entire non-empty signed decimal ASCII string with an
      optional leading `-` and signed `i64` bounds.
- [x] Return `ok value` for valid inputs and `err 1` for malformed or
      out-of-range inputs without ordinary traps.
- [x] Lower to a private runtime helper returning status plus an `i64`
      out-parameter, and keep the result aggregate implementation-owned.
- [x] Execute the call in the deterministic test runner and preserve it in
      formatter, lowering-inspector, hosted-runtime, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
      fixture hooks for `string-parse-i64-result.slo`.
- [x] Keep exp-25 experimental only: no leading `+`, whitespace, locale,
      base/radix prefixes, underscores, Unicode digits, suffix/trailing bytes,
      f64 parse, generic parse, rich parse errors, manifest schema changes,
      stable helper ABI/layout, or beta maturity.

## Phase 42: exp-26 F64 To String Alpha

- [x] Promote exactly `std.num.f64_to_string : (f64) -> string`.
- [x] Return finite decimal ASCII text for promoted finite `f64` fixture
      values.
- [x] Lower to a private runtime helper with implementation-owned string
      allocation behavior and no stable helper ABI/layout promise.
- [x] Execute the call in the deterministic test runner and preserve it in
      formatter, lowering-inspector, hosted-runtime, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
      fixture hooks for `f64-to-string.slo`.
- [x] Keep exp-26 experimental only: no `f32`, f64 parse, generic
      format/display/interpolation, locale/base/radix/grouping/padding/
      precision controls, stable NaN/infinity text, implicit conversion,
      manifest schema changes, stable helper ABI/layout, or beta maturity.

## Phase 43: exp-27 Checked F64 To I32 Result Alpha

- [x] Promote exactly
      `std.num.f64_to_i32_result : (f64) -> (result i32 i32)`.
- [x] Return `ok value` only for finite, exactly integral inputs inside the
      signed `i32` range and `err 1` for non-finite, fractional, or
      out-of-range input.
- [x] Lower directly to LLVM with ordered range checks before `fptosi`, so
      non-finite and out-of-range values do not reach undefined conversion.
- [x] Execute the call in the deterministic test runner and preserve it in
      formatter, lowering-inspector, LLVM smoke, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
      fixture hooks for `f64-to-i32-result.slo`.
- [x] Keep exp-27 experimental only: no unchecked `f64` to `i32`, casts or
      cast syntax, generic `cast_checked`, `f32`, unsigned/narrower integer
      families, f64 parse, mixed numeric arithmetic, numeric containers,
      manifest schema changes, stable ABI/layout, or beta maturity.

## Phase 45: exp-29 Numeric Struct Fields Alpha

- [x] Allow direct immutable struct fields whose types are exactly `i64` or
      finite `f64`, alongside existing direct `i32`, `bool`, immutable
      `string`, and current enum fields.
- [x] Preserve constructor, immutable local, parameter, return, call, and field
      access flow for `i64`/`f64` fields.
- [x] Allow accessed numeric fields to use existing same-type arithmetic,
      comparison, print, and format helper support without adding new APIs.
- [x] Preserve deferred containers, nested structs, mutation, mixed numeric
      arithmetic, implicit conversions, ABI/layout claims, manifest schema
      changes, and beta maturity.

## Phase 46: exp-30 Standard Library Source Layout Alpha

- [x] Recognize the repo `lib/std/` source layout as a contract artifact
      with `README.md`, `io.slo`, `string.slo`, `num.slo`, `result.slo`, and
      `math.slo`.
- [x] Add Glagol-local project coverage for an explicit local `math.slo`
      import through `examples/projects/std-layout-local-math/`.
- [x] Add an ignored sibling Slovo gate for `std/` file inventory and
      source-shape and formatter stability.
- [x] Keep exp-30 experimental only: no new source syntax, new
      compiler-known standard-runtime functions, automatic std import/search
      path, package registry behavior, manifest schema changes, self-hosted
      replacement for compiler-known `std.*` calls, or beta maturity.

## Phase 47: exp-31 Checked F64 To I64 Result Alpha

- [x] Promote exactly
      `std.num.f64_to_i64_result : (f64) -> (result i64 i32)`.
- [x] Return `ok value` only for finite, exactly integral inputs inside the
      signed `i64` range and `err 1` for non-finite, fractional, or
      out-of-range input.
- [x] Lower directly to LLVM with ordered range checks before `fptosi`, so
      non-finite and out-of-range values do not reach undefined conversion.
- [x] Execute the call in the deterministic test runner and preserve it in
      formatter, lowering-inspector, LLVM smoke, hosted-runtime, and
      diagnostic fixtures.
- [x] Keep exp-31 experimental only: no unchecked `f64` to `i64`, casts or
      cast syntax, generic `cast_checked`, `f32`, unsigned/narrower integer
      families, additional numeric conversion families, mixed numeric
      arithmetic, numeric containers, manifest schema changes, stable
      ABI/layout, or beta maturity.

## Phase 48: exp-32 Standard Math Source Helpers Alpha

- [x] Gate the narrow source-authored `std/math.slo` helper set without adding
      compiler-known runtime names or compiler-loaded std source.
- [x] Extend `examples/projects/std-layout-local-math/` so an ordinary project
      explicitly imports local `math.slo` helpers for `i32`, `i64`, and `f64`.
- [x] Cover `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`, `square_i32`,
      `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, `square_i64`, `abs_f64`,
      `min_f64`, `max_f64`, `clamp_f64`, and `square_f64`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
      Slovo `lib/std/math.slo` helper alignment in the ignored monorepo gate.
- [x] Keep exp-32 experimental only: no new compiler-known `std.*` runtime
      calls, runtime ABI changes, automatic std import/search, broad math
      library, trigonometry/sqrt/pow, `f32`, unsigned/narrower integers,
      generic math, overloads, traits, mixed numeric arithmetic, manifest
      schema changes, stable ABI/layout, or beta maturity.

## Phase 49: exp-33 Standard Result Source Helpers Alpha

- [x] Gate the narrow source-authored `std/result.slo` helper-name extension
      without adding compiler-known runtime names or compiler-loaded std
      source.
- [x] Add `examples/projects/std-layout-local-result/` so an ordinary project
      explicitly imports local `result.slo` helpers for existing concrete
      result families.
- [x] Cover `is_err_i64`, `unwrap_err_i64`, `is_err_string`,
      `unwrap_err_string`, `is_err_f64`, `unwrap_err_f64`, `unwrap_or_i32`,
      `unwrap_or_i64`, `unwrap_or_string`, and `unwrap_or_f64`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
      Slovo `lib/std/result.slo` helper alignment in the ignored monorepo gate.
- [x] Keep exp-33 experimental only: no generic result helpers, no
      compiler-known `std.result.unwrap_or`, no map/chaining helpers, no
      option helpers, no new result payload families, no new compiler-known
      `std.*` runtime calls, no runtime ABI changes, no automatic std
      import/search, no manifest schema changes, no stable ABI/layout, and no
      beta maturity.

## Phase 44: exp-28 String Parse F64 Result Alpha

- [x] Promote exactly
      `std.string.parse_f64_result : (string) -> (result f64 i32)`.
- [x] Accept complete finite ASCII decimal text in the narrow
      `-?digits.digits` shape and return `ok value`; return `err 1` for
      ordinary parse failure, non-finite text, unsupported leading/trailing
      characters, or out-of-domain input.
- [x] Add concrete `(result f64 i32)` compiler support for direct fixture
      flow, result helpers, lowering, and LLVM payload access without making
      results generic or opening source-authored `(result f64 i32)`
      constructors/matches.
- [x] Lower hosted builds through private runtime helper
      `__glagol_string_parse_f64_result` and execute the call in the
      deterministic test runner.
- [x] Preserve formatter, lowering-inspector, LLVM smoke, hosted-runtime,
      promotion-gate, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
      fixture hooks for `string-parse-f64-result.slo`.
- [x] Keep exp-28 experimental only: no generic parse, trap-based
      `std.string.parse_f64`, leading `+`, exponent notation, locale parsing,
      Unicode digits, rich parse errors, f64 containers, mixed numeric
      arithmetic, manifest schema changes, stable helper ABI/layout, or beta
      maturity.

## Phase 45: exp-34 String Parse Bool Result Alpha

- [x] Promote exactly
      `std.string.parse_bool_result : (string) -> (result bool i32)`.
- [x] Accept only complete lowercase ASCII `true` and `false`; return
      `ok true` or `ok false`, and return `err 1` for empty text, uppercase or
      mixed-case text, whitespace, numeric text, and all other text.
- [x] Add concrete `(result bool i32)` compiler support for direct fixture
      flow, result helpers, formatter/lowering snapshots, test-runner
      execution, and LLVM payload access without making results generic or
      opening source-authored `(result bool i32)` constructors/matches.
- [x] Lower hosted builds through private runtime helper
      `__glagol_string_parse_bool_result`.
- [x] Preserve diagnostics, promotion-gate, lowering-inspector, LLVM smoke,
      hosted-runtime, and sibling Slovo fixture/std-string source alignment.
- [x] Keep exp-34 experimental only: no generic parse, trap-based
      `std.string.parse_bool`, case-insensitive parsing, whitespace trimming,
      locale/Unicode parsing, numeric bool parsing, string/bytes parsing, rich
      parse errors, manifest schema changes, stable helper ABI/layout, or beta
      maturity.

## Phase 50: exp-35 Standard Result Bool Source Helpers Alpha

- [x] Gate the narrow source-authored `std/result.slo` bool helper-name
      extension without adding compiler-known runtime names or
      compiler-loaded std source.
- [x] Extend `examples/projects/std-layout-local-result/` so an ordinary
      project explicitly imports local `result.slo` helpers for values coming
      from `std.string.parse_bool_result`.
- [x] Cover `is_ok_bool`, `is_err_bool`, `unwrap_ok_bool`, `unwrap_err_bool`,
      and `unwrap_or_bool`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
      Slovo `lib/std/result.slo` bool helper alignment in the ignored monorepo
      gate.
- [x] Keep exp-35 experimental only: no source constructors for bool results,
      no generic bool result match, no compiler-known `std.result.unwrap_or`,
      no map/chaining helpers, no option helpers, no new compiler-known
      `std.*` runtime calls, no runtime ABI changes, no automatic std
      import/search, no manifest schema changes, no stable ABI/layout, and no
      beta maturity.

## Phase 51: exp-36 Standard Option Source Helpers Alpha

- [x] Gate the narrow source-authored `std/option.slo` helper-name facade
      without adding compiler-known runtime names or compiler-loaded std
      source.
- [x] Add `examples/projects/std-layout-local-option/` so an ordinary
      project explicitly imports local `option.slo` helpers for source-authored
      `(option i32)` values from `some` and `none`.
- [x] Cover `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, and
      `unwrap_or_i32`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
      Slovo `lib/std/option.slo` helper alignment in the ignored monorepo std
      source-layout gate.
- [x] Keep exp-36 experimental only: no new compiler-known `std.*` names, no
      generic option helpers, no option payload families beyond `i32`, no
      automatic std imports/search, no compiler-loaded std source, no
      manifest schema changes, no stable ABI/layout, and no beta maturity.

## Phase 75: exp-95 Standard Option I64 Baseline Alpha

- [x] Broaden the concrete option family from only `(option i32)` to
      `(option i64)` as well.
- [x] Extend checker, formatter, backend layout, and test-runner behavior for
      immutable `(option i64)` params, returns, locals, `some`, `none`,
      `is_some`, `is_none`, and `unwrap_some`.
- [x] Broaden source-level `match` payload binding and fixture coverage for
      `(option i64)` without widening to generic options.
- [x] Broaden the local `std-layout-local-option/` fixture and the explicit
      `std-import-option/` fixture to cover both the i32 and i64 helper
      families.
- [x] Broaden the staged `std.option` helper surface to `some_i64`,
      `none_i64`, `is_some_i64`, `is_none_i64`, `unwrap_some_i64`, and
      `unwrap_or_i64`.
- [x] Keep exp-95 experimental only: no compiler-known `std.option.*` runtime
      names, no generic option helpers, no broader payload families, no nested
      option containers, no stable ABI/layout guarantee, and no beta maturity.

## Phase 82: exp-102 Standard Option Bool And F64 Baseline Alpha

- [x] Broaden the concrete option family from only `(option i32)`,
      `(option i64)`, and `(option string)` to `(option f64)` and
      `(option bool)` as well.
- [x] Add checker, formatter, backend, and test-runner support for immutable
      `(option f64)` and `(option bool)` params, returns, locals, `some`,
      `none`, `is_some`, `is_none`, `unwrap_some`, and source `match`.
- [x] Broaden the local `std-layout-local-option/`, explicit
      `std-import-option/`, and workspace `std-import-option/` fixtures to
      cover the same concrete helper families through `some_f64`, `none_f64`,
      `is_some_f64`, `is_none_f64`, `unwrap_some_f64`, `unwrap_or_f64`,
      `some_bool`, `none_bool`, `is_some_bool`, `is_none_bool`,
      `unwrap_some_bool`, and `unwrap_or_bool`.
- [x] Extend focused option-result coverage, diagnostics snapshots, and
      promotion-gate inventory to the same concrete `(option f64)` and
      `(option bool)` baseline.
- [x] Keep exp-102 experimental only: no compiler-known `std.option.*`
      runtime names, no generic option helpers, no broader payload families,
      no nested option containers, no stable ABI/layout guarantee, and no
      beta maturity.

## Phase 81: exp-101 Standard Vec String Option And Transform Helpers Alpha

- [x] Broaden the staged local `std-layout-local-vec_string/` fixture from
      the exp-99 baseline with the option-query helpers `index_option`,
      `first_option`, `last_option`, `index_of_option`, and
      `last_index_of_option`.
- [x] Broaden the same concrete helper lane with the transform helpers
      `concat`, `take`, `drop`, `reverse`, and `subvec`.
- [x] Keep the local and explicit-source vec-string fixtures recursive and
      immutable with no `var` or `set`.
- [x] Keep the lane concrete to `(vec string)` plus raw current
      `(option string)` / `(option i32)` forms only, with no generic
      broadening or broader result families.
- [x] Extend focused vec-string source-helper/source-search coverage and
      promotion-gate inventory for the same helper package.
- [x] Keep exp-101 experimental only: no new compiler-known `std.*` runtime
      names, no edit helpers, no prefix/suffix helpers, no nested vecs, no
      mutating/capacity APIs, no stable ABI/layout guarantee, and no beta
      maturity.

## Phase 80: exp-100 Standard Option String Baseline Alpha

- [x] Broaden the concrete option family from only `(option i32)` and
      `(option i64)` to `(option string)` as well.
- [x] Add checker, formatter, backend, and test-runner support for immutable
      `(option string)` params, returns, locals, `some`, `none`, `is_some`,
      `is_none`, `unwrap_some`, and source `match`.
- [x] Broaden the local `std-layout-local-option/`, explicit
      `std-import-option/`, and workspace `std-import-option/` fixtures to
      cover the same concrete helper family through `some_string`,
      `none_string`, `is_some_string`, `is_none_string`,
      `unwrap_some_string`, and `unwrap_or_string`.
- [x] Extend focused option/result coverage and promotion-gate inventory to
      the same concrete `(option string)` baseline.
- [x] Keep exp-100 experimental only: no compiler-known `std.option.*`
      runtime names, no generic option helpers, no broader payload families,
      no nested option containers, no stable ABI/layout guarantee, and no
      beta maturity.

## Phase 79: exp-99 Standard Vec String Baseline Alpha

- [x] Add concrete `(vec string)` support for immutable params, returns, and
      locals in the checker, formatter, and backend.
- [x] Promote the concrete runtime names `std.vec.string.empty`,
      `std.vec.string.append`, `std.vec.string.len`, and
      `std.vec.string.index` without widening to generics or other vec
      families.
- [x] Add concrete vec-string equality and matching runtime/test-runner
      behavior.
- [x] Add the Glagol-owned local `std-layout-local-vec_string/` fixture with
      the frozen helper inventory `empty`, `append`, `len`, `at`,
      `singleton`, `append2`, `append3`, `pair`, `triple`, `is_empty`,
      `index_or`, `first_or`, `last_or`, `contains`, and `count_of`.
- [x] Add the explicit `std-import-vec_string/` fixture and focused Glagol
      coverage for the same helper surface, while tolerating mixed-repo
      states where sibling `lib/std/vec_string.slo` is not present yet.
- [x] Keep exp-99 experimental only: no generics, no other vec element
      families, no option-query helpers, no transform/range/edit helpers, no
      nested vecs or vecs inside other containers, no mutating or capacity
      APIs, no stable ABI/layout guarantee, and no beta maturity.

## Phase 78: exp-98 Standard Vec I64 Edit Helpers Alpha

- [x] Extend the staged `std.vec_i64` source-authored helper surface with
      `insert_at`, `insert_range`, `replace_at`, `replace_range`,
      `remove_at`, and `remove_range`.
- [x] Keep the local `std-layout-local-vec_i64/` lane recursive and immutable
      with no `var` or `set` in the expected source shape.
- [x] Update the explicit `std-import-vec_i64/` fixture to exercise the same
      helper inventory against repo-root `lib/std/vec_i64.slo`.
- [x] Extend focused integration coverage and promotion-gate inventory without
      widening parser, checker, formatter, runtime, backend, or test-runner
      semantics.
- [x] Keep exp-98 experimental only: no generics, no new compiler-known
      `std.*` runtime names, no mutating or capacity APIs, no iterators,
      sorting, mapping, filtering, and no beta maturity.

## Phase 77: exp-97 Standard Vec I64 Transform Helpers Alpha

- [x] Extend the staged `std.vec_i64` source-authored helper surface with
      `concat`, `take`, `drop`, `reverse`, and `subvec`.
- [x] Keep the local `std-layout-local-vec_i64/` lane recursive and immutable
      with no `var` or `set` in the expected source shape.
- [x] Update the explicit `std-import-vec_i64/` fixture to exercise the same
      helper inventory against repo-root `lib/std/vec_i64.slo`.
- [x] Extend focused integration coverage and promotion-gate inventory without
      widening parser, checker, formatter, runtime, backend, or test-runner
      semantics.
- [x] Keep exp-97 experimental only: no vec_i64 insert/replace/remove
      helpers, no generics, no new compiler-known `std.*` runtime names, no
      mutating or capacity APIs, no iterators, sorting, mapping, filtering,
      and no beta maturity.

## Phase 76: exp-96 Standard Vec I64 Option Query Helpers Alpha

- [x] Extend the staged `std.vec_i64` source-authored helper surface with
      `index_option`, `first_option`, `last_option`, `index_of_option`, and
      `last_index_of_option`.
- [x] Keep the local `std-layout-local-vec_i64/` lane recursive and immutable
      with no `var` or `set` in the expected source shape.
- [x] Update the explicit `std-import-vec_i64/` fixture to exercise the same
      helper inventory against repo-root `lib/std/vec_i64.slo`.
- [x] Extend focused integration coverage and promotion-gate inventory without
      widening parser, checker, formatter, runtime, backend, or test-runner
      semantics.
- [x] Keep exp-96 experimental only: no vec_i64 transform/range/edit helpers,
      no generics, no new compiler-known `std.*` runtime names, no mutating
      or capacity APIs, no iterators, sorting, mapping, filtering, and no
      beta maturity.

## Phase 52: exp-37 Standard Time Source Facade Alpha

- [x] Gate the narrow source-authored `std/time.slo` facade without adding
      compiler-known runtime names or compiler-loaded std source.
- [x] Add `examples/projects/std-layout-local-time/` so an ordinary project
      explicitly imports local `time.slo` facades for `monotonic_ms` and
      `sleep_ms_zero`.
- [x] Keep `sleep_ms_zero` source-shaped as an `i32` facade that calls
      `std.time.sleep_ms 0` and returns `0`, because source unit-return
      facade functions are not promoted.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
      Slovo `lib/std/time.slo` exact inventory and facade alignment in the ignored
      monorepo std source-layout gate.
- [x] Keep exp-37 experimental only: no new compiler-known `std.*` names, no
      automatic std imports/search, no compiler-loaded std source, no
      wall-clock/calendar/timezone/high-resolution timers, no async timers,
      no cancellation or scheduling guarantees, no runtime ABI changes, no
      stable ABI/layout, and no beta maturity.

## Phase 53: exp-38 Standard Host Source Facades Alpha

- [x] Gate narrow source-authored `std/random.slo`, `std/env.slo`, and
      `std/fs.slo` facades without adding compiler-known runtime names or
      compiler-loaded std source.
- [x] Add `examples/projects/std-layout-local-random/`,
      `examples/projects/std-layout-local-env/`, and
      `examples/projects/std-layout-local-fs/` so ordinary projects explicitly
      import local facades over already released host/runtime calls.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
      Slovo std-source exact inventory and facade alignment in the ignored
      monorepo std source-layout gate.
- [x] Keep exp-38 experimental only: no new compiler-known `std.*` names, no
      automatic std imports/search, no compiler-loaded std source, no
      seed/range/bytes/float/UUID/crypto random APIs, no environment
      mutation/enumeration, no binary/directory/streaming/async filesystem
      APIs, no rich host error ADTs, no runtime ABI changes, no stable
      ABI/layout, and no beta maturity.

## Phase 54: exp-39 Standard Math Extensions And Benchmark Scaffold Alpha

- [x] Extend the narrow source-authored `std/math.slo` helper set without
      adding compiler-known runtime names or compiler-loaded std source.
- [x] Add `neg`, `cube`, `is_zero`, `is_positive`, `is_negative`, and
      inclusive `in_range` helper coverage for `i32`, `i64`, and finite
      `f64` in `examples/projects/std-layout-local-math/`.
- [x] Add `benchmarks/math-loop/` with Slovo, C, Rust, and Python sources plus
      a runner that reports local-machine timing comparisons only.
- [x] Add focused benchmark scaffold and promotion-gate coverage, including
      repo `lib/std/math.slo` helper alignment in the ignored monorepo
      std source-layout gate.
- [x] Keep exp-39 experimental only: no new compiler-known `std.*` names, no
      automatic std imports/search, no compiler-loaded std source, no
      broad math APIs, no generic math, no mixed numeric arithmetic, no
      optimizer guarantees, no benchmark thresholds, no runtime ABI changes,
      no stable ABI/layout, and no beta maturity.

## Phase 55: exp-40 Benchmark Suite And License Alpha

- [x] Add a shared benchmark runner and broaden local benchmark scaffolds to
      `math-loop`, `branch-loop`, and `parse-loop`.
- [x] Include Slovo, C, Rust, Python, and Clojure source slots, with missing
      toolchains skipped and deterministic checksum validation kept mandatory
      for implementations that run.
- [x] Add benchmark scaffold and promotion-gate coverage for benchmark
      metadata, language-source inventory, format/check commands, and Python
      smoke runs.
- [x] Record project licensing as `MIT OR Apache-2.0` and document alpha/beta
      naming criteria.
- [x] Keep exp-40 experimental only: no new language semantics, no optimizer
      guarantees, no benchmark thresholds, no cross-machine performance
      claims, no runtime ABI changes, no stable ABI/layout, no package
      registry behavior, and no beta maturity.

## Phase 56: exp-41 Lisp Benchmark Comparison Alpha

- [x] Add Common Lisp/SBCL source slots beside Clojure for `math-loop`,
      `branch-loop`, and `parse-loop`.
- [x] Extend the shared benchmark runner to detect SBCL through `sbcl`,
      `SBCL`, or `--sbcl`.
- [x] Clarify cold-process benchmark timing: Clojure includes JVM/Clojure
      startup, and Common Lisp includes SBCL script startup.
- [x] Add benchmark scaffold and promotion-gate coverage for the second Lisp
      source slot.
- [x] Keep exp-41 experimental only: no new language semantics, no optimizer
      guarantees, no benchmark thresholds, no cross-machine performance
      claims, no runtime ABI changes, no stable ABI/layout, no package
      registry behavior, no hot-runtime benchmark daemon, and no beta
      maturity.

## Phase 57: exp-42 Hot Loop Benchmark Mode Alpha

- [x] Add explicit `--mode cold-process` and `--mode hot-loop` runner modes.
- [x] Record hot-loop counts and hot checksums in each benchmark scaffold.
- [x] Report hot-loop total time and normalized median time for the base
      `1000000` loop count.
- [x] Let Slovo benchmark fixtures receive the runner loop count through
      process arguments with stdin fallback, so Slovo participates in
      hot-loop mode.
- [x] Add benchmark scaffold and promotion-gate coverage for hot-loop
      metadata and execution.
- [x] Keep exp-42 experimental only: no new language semantics, no optimizer
      guarantees, no high-resolution Slovo timing APIs, no stable benchmark
      thresholds, no cross-machine performance claims, no runtime ABI
      changes, no stable ABI/layout, no package registry behavior, no
      hot-runtime benchmark daemon, and no beta maturity.

## Phase 58: exp-43 Technical Whitepapers And Skills Alpha

- [x] Add Glagol technical whitepaper Markdown and generated PDF.
- [x] Add concise compiler manifest Markdown and generated PDF.
- [x] Add repository-local beta compiler-design skill.
- [x] Keep exp-43 experimental only: no parser behavior, checker behavior,
      backend behavior, runtime API, compiler-known `std.*` names, optimizer
      guarantee, benchmark threshold, cross-machine claim, or beta maturity.

## Phase 59: exp-44 Standard Library Source Search Alpha

- [x] Add project-mode source search for explicit `std.<module>` imports,
      starting with `std.math`.
- [x] Load `std/math.slo` through `SLOVO_STD_PATH` or a `lib/std`
      checkout without copying it into the project.
- [x] Add `examples/projects/std-import-math/` plus focused integration and
      promotion-gate coverage.
- [x] Keep exp-44 experimental only: no automatic std imports,
      workspace/package std imports, package registry, broad standard library,
      stable ABI/layout, optimizer guarantee, or beta maturity.

## Phase 60: exp-45 Standard Result And Option Source Search Alpha

- [x] Add explicit project-mode `std.result` and `std.option` source-search
      fixtures without local copied modules.
- [x] Gate the fixtures with focused integration tests and promotion-gate
      coverage.
- [x] Keep exp-45 experimental only: no automatic std imports,
      workspace/package std imports, package registry, generic result/option
      helpers, broad standard library, stable ABI/layout, optimizer
      guarantee, or beta maturity.

## Phase 61: exp-46 Workspace Standard Source Search Alpha

- [x] Load explicit `std.<module>` imports inside workspace packages.
- [x] Resolve loaded standard modules before normal package-qualified
      dependency lookup.
- [x] Add `examples/workspaces/std-import-option/` plus focused integration
      and promotion-gate coverage.
- [x] Keep exp-46 experimental only: no automatic std imports, workspace
      dependency syntax for std, package registry, installed stdlib paths,
      broad standard library, stable ABI/layout, optimizer guarantee, or beta
      maturity.

## Phase 62: exp-47 Standard Host Facade Source Search Alpha

- [x] Gate explicit project-mode `std.time`, `std.random`, `std.env`, and
      `std.fs` source imports without local copied modules.
- [x] Add focused integration coverage for format, check, and test behavior
      across the host facade fixtures.
- [x] Add promotion-gate coverage for the new fixtures and sibling Slovo
      fixture alignment.
- [x] Keep exp-47 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, installed stdlib paths, broad host APIs,
      stable ABI/layout, optimizer guarantee, or beta maturity.

## Phase 63: exp-48 Standard Core Facade Source Search Alpha

- [x] Gate explicit project-mode `std.string` and `std.num` source imports
      without local copied modules.
- [x] Add focused integration coverage for format, check, and test behavior
      across the core facade fixtures.
- [x] Add promotion-gate coverage for the new fixtures and sibling Slovo
      fixture alignment.
- [x] Keep exp-48 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, installed stdlib paths, generic
      parse/format APIs, broad numeric casts, stable ABI/layout, optimizer
      guarantee, or beta maturity.

## Phase 64: exp-49 Standard IO Facade Source Search Alpha

- [x] Gate explicit project-mode `std.io` source imports without a local
      copied module.
- [x] Add focused integration coverage for format, check, and deterministic
      test behavior.
- [x] Add promotion-gate coverage for the new fixture and sibling Slovo
      fixture alignment.
- [x] Keep exp-49 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, installed stdlib paths, new
      compiler-known IO names, broad IO APIs, stable ABI/layout, optimizer
      guarantee, or beta maturity.

## Phase 65: exp-50 Installed Standard Library Discovery Alpha

- [x] Gate executable-relative installed stdlib discovery for explicit
      `std.<module>` source imports.
- [x] Add focused integration coverage that copies the compiler binary and
      resolves a probe module from `share/slovo/std`.
- [x] Add promotion-gate coverage for discovery candidates and diagnostics.
- [x] Keep exp-50 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, lockfiles, package std dependencies,
      stable install layout guarantee, broad stdlib APIs, stable ABI/layout,
      optimizer guarantee, or beta maturity.

## Phase 66: exp-51 Standard Library Path List Alpha

- [x] Treat `SLOVO_STD_PATH` as an ordered OS path list.
- [x] Add focused integration coverage for an empty first root and a second
      root containing the requested standard module.
- [x] Add promotion-gate coverage for path-list handling.
- [x] Keep exp-51 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, lockfiles, package std dependencies,
      semantic version solving, stable package manager behavior, broad stdlib
      APIs, stable ABI/layout, optimizer guarantee, or beta maturity.

## Phase 67: exp-52 Standard Process Facade Source Search Alpha

- [x] Add source-authored `std/process.slo` facade wrappers over the already
      promoted process argument runtime calls.
- [x] Gate explicit project-mode `std.process` source imports without a local
      copied module.
- [x] Add focused integration coverage and promotion-gate coverage.
- [x] Keep exp-52 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, lockfiles, package std dependencies,
      process spawning, exit/status control, current-directory APIs, signal
      handling, stable ABI/layout, optimizer guarantee, or beta maturity.

## Phase 68: exp-53 Standard CLI Source Facade Alpha

- [x] Add source-authored `std/cli.slo` facade helpers that compose
      `std.process` and `std.string`.
- [x] Gate explicit project-mode `std.cli` source imports without a local
      copied module.
- [x] Add focused integration coverage and promotion-gate coverage for
      transitive standard-source imports.
- [x] Keep exp-53 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, lockfiles, package std dependencies,
      shell parsing, option/flag parsing, subcommands, environment-backed
      configuration, stable CLI framework APIs, stable ABI/layout, optimizer
      guarantee, or beta maturity.

## Phase 69: exp-54 Standard CLI Typed Arguments Alpha

- [x] Extend `std/cli.slo` with `arg_i64_result` and `arg_i64_or_zero`.
- [x] Add direct `arg_f64_result` and `arg_bool_result` parse-result wrappers
      over `std.process.arg`.
- [x] Update focused integration coverage and promotion-gate coverage for the
      expanded helper inventory.
- [x] Keep exp-54 experimental only: no automatic std imports, `std.slo`
      aggregator, package registry, lockfiles, package std dependencies, new
      compiler-known runtime names, shell parsing, option/flag parsing,
      subcommands, environment-backed configuration, stable CLI framework
      APIs, stable ABI/layout, optimizer guarantee, or beta maturity.

## Phase 70: exp-55 Result F64 Bool Source Flow Alpha

- [x] Promote source constructors for `(result f64 i32)` and
      `(result bool i32)`.
- [x] Promote source `match` payload bindings for `(result f64 i32)` and
      `(result bool i32)`.
- [x] Add focused coverage for formatter, checker, test runner, and LLVM
      aggregate shape.
- [x] Update `std.cli` coverage so `f64` and `bool` missing argument indexes
      are result-based.
- [x] Keep exp-55 experimental only: no generic result types, no result
      payload families beyond the already promoted concrete families, no
      generic result combinators, stable ABI/layout, optimizer guarantee, or
      beta maturity.

## Phase 71: exp-56 Integer Remainder Alpha

- [x] Add `%` surface/lowering support for same-width `i32` and `i64`
      operands.
- [x] Gate checker, formatter, test-runner, and LLVM `srem` behavior.
- [x] Reject `f64` remainder explicitly while keeping mixed numeric operand
      diagnostics.
- [x] Add `examples/integer-remainder.slo` and sibling Slovo fixture
      alignment.
- [x] Extend `std.math` with `rem_i32`, `is_even_i32`, `is_odd_i32`,
      `rem_i64`, `is_even_i64`, and `is_odd_i64`.
- [x] Keep exp-56 experimental only: no floating-point remainder, Euclidean
      modulo, unsigned arithmetic, bit operations, generic math, stable
      ABI/layout, optimizer guarantee, or beta maturity.

## Phase 72: exp-57 Integer Bitwise Alpha

- [x] Add `bit_and`, `bit_or`, and `bit_xor` surface/lowering support for
      same-width `i32` and `i64` operands.
- [x] Gate checker, formatter, test-runner, and LLVM `and`/`or`/`xor`
      behavior.
- [x] Reject `f64` bitwise operations explicitly while keeping mixed numeric
      operand diagnostics.
- [x] Add `examples/integer-bitwise.slo` and sibling Slovo fixture alignment.
- [x] Extend `std.math` with `bit_and_i32`, `bit_or_i32`, `bit_xor_i32`,
      `bit_and_i64`, `bit_or_i64`, and `bit_xor_i64`.
- [x] Keep exp-57 experimental only: no shifts, bit-not, unsigned arithmetic,
      bit-width-specific integer families, generic math, stable ABI/layout,
      optimizer guarantee, or beta maturity.

## Phase 73: exp-58 Boolean Logic Alpha

- [x] Add `and`, `or`, and `not` formatter/lowering support.
- [x] Lower `and` and `or` through existing `if` semantics so they
      short-circuit.
- [x] Add `examples/boolean-logic.slo` and sibling Slovo fixture alignment.
- [x] Gate checker, test-runner, formatter, and LLVM branch shape.
- [x] Keep exp-58 experimental only: no truthiness, variadic boolean
      operators, pattern guards, macro expansion, stable ABI/layout,
      optimizer guarantee, or beta maturity.

## Phase 74: exp-59 Hosted Build Optimization And Benchmark Publication Alpha

- [x] Build hosted executables through `clang -O2`.
- [x] Lower current immutable numeric locals as SSA values where no stack
      storage is required.
- [x] Refresh benchmark methodology and evidence in the publication
      documents.
- [x] Add repo-local PDF rendering scripts and wire them into the release
      gate.
- [x] Keep exp-59 experimental only: no benchmark thresholds, no
      cross-machine performance claims, no broad optimizer guarantees, no
      general SSA lowering for every value family, and no beta maturity.

## Phase 75: exp-119 Benchmark Suite Extension And Whitepaper Refresh Alpha

- [x] Add `benchmarks/array-index-loop/` with Slovo, C, Rust, Python,
      Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Add `benchmarks/string-eq-loop/` with Slovo, C, Rust, Python, Clojure,
      and Common Lisp/SBCL scaffold implementations.
- [x] Keep the shared benchmark runner model unchanged while extending focused
      benchmark scaffold and promotion-gate coverage from three kernels to
      five.
- [x] Refresh the Glagol whitepaper and publication docs around the expanded
      benchmark suite and the current experimental compiler surface.
- [x] Keep exp-119 experimental only: no language-surface change, no runtime
      ABI claim, no benchmark thresholds, no cross-machine performance claims,
      no broad optimizer guarantee, and no beta maturity.

## Phase 76: exp-120 Fixed Array Struct Fields Alpha

- [x] Allow direct struct field declarations over `(array i32 N)`,
      `(array i64 N)`, `(array f64 N)`, `(array bool N)`, and
      `(array string N)`.
- [x] Keep fixed arrays positive-length only, immutable only, and limited to
      the already promoted direct scalar and string element families.
- [x] Add promoted `array-struct-fields` fixture coverage, formatter/lowering
      snapshots, focused Glagol tests, and diagnostic snapshot updates.
- [x] Keep exp-120 experimental only: no zero-length arrays, no array or field
      mutation, no nested arrays, no arrays of unsupported element kinds, no
      array equality/printing, no stable ABI/layout claim, and no beta
      maturity.

## Phase 77: exp-121 Non-Recursive Struct Enum Payloads Alpha

- [x] Allow unary enum payload variants whose payload type is a current known
      non-recursive struct type.
- [x] Keep one payload per payload variant and the existing same-payload-type
      rule when payload variants are present.
- [x] Add promoted `enum-payload-structs` fixture coverage, formatter/lowering
      snapshots, focused Glagol tests, and diagnostic snapshot updates.
- [x] Keep exp-121 experimental only: no direct array/vec/option/result
      payloads, no equality requirement for struct-payload enums, no mutation,
      no recursion, no stable ABI/layout claim, and no beta maturity.

## Phase 78: exp-122 Composite Data Benchmark Suite Extension And Whitepaper Refresh Alpha

- [x] Add `benchmarks/array-struct-field-loop/` with Slovo, C, Rust, Python,
      Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Add `benchmarks/enum-struct-payload-loop/` with Slovo, C, Rust, Python,
      Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Keep the shared benchmark runner model unchanged while extending focused
      benchmark scaffold and promotion-gate coverage from five kernels to
      seven.
- [x] Refresh the Glagol whitepaper and publication docs around the expanded
      suite and the current experimental compiler surface through `exp-121`.
- [x] Keep exp-122 experimental only: no language-surface change, no runtime
      ABI claim, no benchmark thresholds, no cross-machine performance claims,
      no broad optimizer guarantee, and no beta maturity.

## Phase 79: exp-123 Owned Vector Benchmark Suite Extension And Whitepaper Refresh Alpha

- [x] Add `benchmarks/vec-i32-index-loop/` with Slovo, C, Rust, Python,
      Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Add `benchmarks/vec-string-eq-loop/` with Slovo, C, Rust, Python,
      Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Keep the shared benchmark runner model unchanged while extending focused
      benchmark scaffold and promotion-gate coverage from seven kernels to
      nine.
- [x] Refresh the Glagol whitepaper and publication docs around the expanded
      suite and the current experimental compiler surface through `exp-121`.
- [x] Keep exp-123 experimental only: no language-surface change, no runtime
      ABI claim, no benchmark thresholds, no cross-machine performance claims,
      no broad optimizer guarantee, and no beta maturity.

## Deferred

- [ ] Macros.
- [ ] Generics.
- [ ] Concurrency.
- [ ] Advanced ownership.
- [ ] Package manager.
- [ ] Direct machine-code backend.
- [ ] Direct machine-code backend; hosted native builds use emitted LLVM IR
      plus Clang and `runtime/runtime.c`.
- [ ] Stdin source input until source naming and source spans are specified.
- [ ] JSON output for lowering inspection.
- [ ] User-visible `unit` values and function signatures until Slovo specifies
      their source semantics.
- [ ] Pointer types, raw memory operations, unchecked indexing,
      reinterpretation, raw `ffi_call`, broad FFI, and other raw unsafe
      operations. Preserve lexical unsafe diagnostics meanwhile; exp-6 only
      promotes explicit `i32` C scalar imports.
- [ ] Mutable arrays, array mutation, arrays of other unsupported element
      types, zero-length arrays, slices, equality,
      printing, nested arrays, unchecked indexing, and stable ABI/layout
      promises.
- [ ] Numeric expansion beyond exp-29 direct `f64`, direct `i64`, explicit
      widening conversions, the checked `i64 -> i32` result conversion, and
      `i32`/`i64` decimal-to-string calls, the single strict string-to-`i64`
      result parse, finite `f64` to string, checked `f64 -> i32` result, and
      strict string-to-`f64` result parse, plus direct `i64`/`f64` struct
      fields,
      including f32,
      unsigned/narrower integer
      families, char/bytes/decimal, additional narrowing or checked
      conversions, cast syntax, mixed numeric arithmetic, numeric containers,
      broader parse/format APIs, random numeric APIs, stable ABI/layout, and
      beta maturity.
- [ ] Generic vectors, non-`i32` vectors, vector mutation, nested vectors,
      vectors inside other containers, and broader growable collections until a
      later Slovo contract promotes their syntax, semantics, diagnostics, and
      runtime behavior.
- [ ] Option/result matching outside the exact v1.4 `(option i32)`,
      `(result i32 i32)`, and exp-25 `(result i64 i32)` two-arm forms, other
      non-`i32` payloads, nested
      option/result values, option/result printing, and stable ABI/layout
      promises.
- [ ] Result helper expansion beyond exp-33 concrete source helpers, including
      compiler-known `std.result.unwrap_or`, `std.result.map`,
      `std.result.and_then`, generic result helpers, option standard helper
      names, and new result payload families beyond the current concrete
      families.
- [ ] Mutable strings, string concatenation, string indexing/slicing, strings
      in containers, broad runtime printing beyond promoted legacy aliases and
      v1.5 `std.io.print_*` names, ownership, allocation/free, Unicode length
      semantics, and stable ABI promises.
- [ ] Parsing beyond the released exp-13
      `std.string.parse_i32_result : (string) -> (result i32 i32)`, exp-25
      `std.string.parse_i64_result : (string) -> (result i64 i32)`, and
      exp-28 `std.string.parse_f64_result : (string) -> (result f64 i32)`,
      and exp-34
      `std.string.parse_bool_result : (string) -> (result bool i32)` slices,
      including trap-based parse, string/bytes parse families,
      whitespace/locale/base-prefix/underscore/plus-sign parsing, generic
      parse APIs, rich parse errors, Unicode digit parsing, string
      indexing/slicing, tokenizer/scanner APIs, stdin line APIs, stable helper
      ABI/layout, runtime headers/libraries, manifest schema changes, and beta
      maturity.
- [ ] `std.io.print_unit`, host IO beyond the exp-3 slice, networking, async
      IO, binary file APIs, directory traversal, terminal control,
      result-based host errors beyond the exp-10 slice, stdin iteration,
      wall-clock time, timers, time zones, generic vectors/maps/sets or other
      collections, user-defined standard modules, imports/packages for
      standard-runtime names,
      overloading, generic standard-library APIs, and FFI contracts.
- [ ] Package registries, lockfiles, semver solving, remote dependencies,
      publishing, optional/dev/target dependencies, stable package ABI,
      hierarchical modules, import aliases/globs/qualified access, re-exports,
      generated sources, project formatting, watch/LSP, incremental builds,
      cross-compilation, and public ABI promises beyond the exp-5 local
      workspace/package contract.
- [ ] Stable LLVM debug metadata, DWARF emission, and source-map files.
