slovo/docs/compiler/ROADMAP.md

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:

.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.22, released on 2026-05-23 as run manifest and execution report 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.

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

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

Phase 2: Close Critical Semantic Gaps

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

Phase 3: Restore Slovo Tooling Promise

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

Phase 4: Implement Slovo v0 Core

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

Phase 5: Close v0 Compiler Surface

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

Phase 6: Start Slovo v1 Value Flow

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

Phase 7: Polish The Binary CLI

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

Phase 8: Start Slovo v1 Tooling Contracts

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

Phase 9: Slovo v1.1 Toolchain Productization

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

Phase 10: Slovo v1.2 Practical Runtime Values

• Implement immutable string let locals, parameters, returns, and calls returning strings.
• Implement string equality with =.
• Implement string byte length through temporary intrinsic string_len.
• Implement temporary intrinsic print_bool.
• Add deterministic runtime trap stderr messages for array bounds and option/result unwrap failures.
• Make runtime traps exit with code 1 for glagol test trapped tests and produced executables.
• Keep the v1.1 CLI/toolchain surface unchanged.
• Keep print_unit, mutable strings, string concatenation, strings in containers, project mode, imports, and modules deferred.
• 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

• Read slovo.toml project manifests with [project], required name, optional source_root = "src", and optional entry = "main".
• Select project mode for glagol check, glagol test, and glagol build only when input is a project root or the slovo.toml file itself.
• Keep single-file .slo behavior unchanged from v1.2.
• Discover only immediate .slo module files under the flat source root.
• Accept module export lists such as (module math (export add_one Point)).
• Accept explicit local imports such as (import math (add_one Point)).
• Enforce import/export visibility, module-private top-level names, duplicate-name rules, and reserved builtin/intrinsic names.
• Compile, test, diagnose, and write manifests in deterministic module order.
• Preserve source file identity and related spans for cross-file diagnostics.
• Extend slovo.artifact-manifest version 1 output for project roots, manifests, source roots, module lists, import edges, test counts, and build outputs.
• Add project fixture, manifest, command, diagnostic, deterministic-order, artifact-manifest, and single-file regression gates matching the Slovo v1.3 contract.
• 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

• Implement source-level match for exactly (option i32) and (result i32 i32).
• Require exhaustive two-arm forms: some/none for options and ok/err for results.
• Implement immutable payload bindings for some, ok, and err.
• Scope payload bindings and local bindings to one arm body only.
• Type each match expression as the common arm result type.
• 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.
• Add canonical multiline formatter support for promoted match.
• Add lowering-inspector, LLVM/runtime smoke, fixture-alignment, formatter, diagnostic, and regression gates matching the Slovo v1.4 contract.
• 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

• Implement compiler-known source-level standard-runtime names std.io.print_i32, std.io.print_string, std.io.print_bool, and std.string.len.
• Preserve legacy print_i32, print_string, print_bool, and string_len as compatibility aliases.
• Reject unknown or unpromoted std.* calls with a structured diagnostic, suggested code UnsupportedStandardLibraryCall.
• Reserve the exact promoted std.* names from user function/export shadowing.
• Keep promoted names out of user module, import, package, FFI, and stable C ABI semantics.
• 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.
• 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

• Centralize compiler-known unsafe operation head metadata for alloc, dealloc, load, store, ptr_add, unchecked_index, reinterpret, and ffi_call.
• Preserve lexical unsafe gating: outside (unsafe ...), these heads produce UnsafeRequired before user-function lookup; inside (unsafe ...), they produce UnsupportedUnsafeOperation.
• Reserve compiler-known unsafe heads from user functions, project imports/exports, parameters, locals, structs, and match payload bindings where the current reservation architecture applies.
• Add diagnostics-contract coverage for every unsafe head in both the unsafe-required and unsupported-inside-unsafe gates.
• 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

• Add glagol new <project-dir> [--name <name>] for minimal local project scaffolding with structured diagnostics for blocked targets and invalid arguments.
• Add glagol fmt --check and glagol fmt --write for files and project inputs while preserving plain glagol fmt <file> stdout formatting.
• Extend formatter coverage only for already-supported project module declarations, exports, imports, and imported calls.
• 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.
• Add scripts/release-gate.sh for the local release gate from either the repository root or compiler directory context.
• Keep Slovo language syntax and semantics unchanged.

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

• Treat the release as an experimental gate/readiness release based on v1.7, not as a new language expansion.
• Document the experimental-supported CLI, project workflow, language surface, and explicit deferrals in .llm/V2_0_0_BETA_1_RELEASE_GATE.md.
• Verify a scaffolded experimental project can run through new, fmt --check, test, doc, and hosted build when the toolchain is available.
• 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.
• Keep fixed-size immutable i32 arrays as the current collection subset.
• 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

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

Phase 18: exp-2 Collections Alpha Slice

• Implement the initial growable collection type: (vec i32).
• Extend the concrete vector family with (vec i64) in exp-94.
• Promote compiler-known std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, and std.vec.i32.index.
• Promote compiler-known std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, and std.vec.i64.index.
• Keep vector values immutable from source; append returns a new runtime-owned vector instead of mutating the input.
• Implement same-family (vec i32) and (vec i64) equality with =.
• Lower vector operations through private runtime helpers and reserve helper symbols from source/project names.
• Add runtime traps for vector allocation failure and vector index out-of-bounds.
• Add formatter, lowering-inspector, test-runner, LLVM/runtime, diagnostic snapshot, fixture-inventory, and hosted-runtime coverage for the slice.
• 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

• Implement the conservative exp-3 host IO standard-runtime calls.
• 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

• Implement payloadless user-defined enums, qualified constructors, equality, value flow, top-level tests, and exhaustive variant matches.
• 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

• Read workspace [workspace] members manifests and member package [package] manifests with name, version, source_root, and entry.
• Support local [dependencies] path records such as mathlib = { path = "../mathlib" }.
• Build a deterministic closed local package graph.
• Accept package-qualified imports such as (import mathlib.math (add_one)).
• Enforce package boundaries through existing module export lists.
• Extend artifact manifests with workspace and package graph information.
• Diagnose missing packages, duplicate package names, dependency cycles, path escapes, invalid package names, invalid package versions, private visibility, and dependency key mismatches.
• 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

• Accept top-level imported C declarations such as (import_c c_add ((lhs i32) (rhs i32)) -> i32).
• Restrict imported C signatures to i32 parameters and i32 or builtin unit returns.
• Require conservative C symbol names shared with the source import name.
• Require calls to imported C functions to appear inside lexical (unsafe ...).
• Preserve raw unsafe head diagnostics; ffi_call and the other v1.6 raw unsafe heads remain unsupported even inside unsafe blocks.
• Lower accepted imports to LLVM external declarations and direct calls.
• Support explicit local C source linking through glagol build --link-c <path>.
• Report UnsupportedTestExpression when the interpreter-style test runner reaches an imported C call.
• Extend artifact manifests with foreign_imports and c_link_inputs.
• 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

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

Phase 24: exp-8 Host Time And Sleep Alpha

• Promote compiler-known std.time.monotonic_ms: () -> i32 and std.time.sleep_ms: (i32) -> unit.
• Lower native calls through private runtime helpers and implement process-relative monotonic milliseconds plus nanosleep.
• Support deterministic sleep_ms 0 and non-negative monotonic execution in the test runner; trap negative sleeps with the exact runtime message.
• Keep threads, channels, async, timers, wall-clock time, time zones, scheduling guarantees, cancellation, high-resolution timing, and stable runtime ABI deferred.
• 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

• Add Glagol exp-9 documentation/audit state aligned with the Slovo hardening target.
• Record compatibility inventory for v2.0.0-beta.1 and exp-1 through exp-8.
• Record migration guidance that requires no source syntax, standard runtime, or manifest schema migration by default.
• Record source-reachable panic audit classifications for current source markers.
• Record benchmark smoke commands and known limits without public numeric thresholds.
• Add parser, formatter, diagnostic, project graph, runtime API, test-runner, backend-precondition, and artifact-manifest hardening tests.
• 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.
• Run the exp-9 release gate and benchmark smoke evidence.
• Write exp-9 release review evidence.
• 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

• Implement concrete (result string i32) value flow, observers, unwraps, and exact two-arm match without broadening arbitrary result payloads.
• Promote std.process.arg_result, std.env.get_result, std.fs.read_text_result, and std.fs.write_text_result.
• Return ordinary host failures as exactly err 1.
• Preserve exp-3 host call behavior unchanged for traps, missing environment variables, and write status values.
• Add formatter, lowering-inspector, diagnostics, deterministic test-runner, LLVM/runtime, and fixture-alignment gates for the target fixture host-io-result.slo.
• 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

• Promote exactly std.random.i32 : () -> i32.
• Return a non-negative implementation-owned i32 in runtime and deterministic-enough test-runner paths.
• Trap runtime unavailability with exactly slovo runtime error: random i32 unavailable.
• Add fixture alignment, formatter, lowering-inspector, diagnostic, test-runner, LLVM/runtime, and promotion-gate coverage for random.slo.
• 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

• Promote exactly std.io.read_stdin_result : () -> (result string i32).
• Return ok with remaining stdin text, including EOF as ok "", and ordinary host/input failure as err 1.
• Align Slovo supported and formatter fixtures with stdin-result.slo.
• Cover formatter and lowering-inspector visibility for (std.io.read_stdin_result).
• 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.
• 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

• Promote exactly std.string.parse_i32_result : (string) -> (result i32 i32).
• Parse an entire ASCII decimal signed i32, returning ok value on success and ordinary parse failure as err 1.
• Align Slovo supported and formatter fixtures with string-parse-i32-result.slo.
• Cover formatter and lowering-inspector visibility for (std.string.parse_i32_result text).
• 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.
• 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

• 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.
• Add lowering-inspector snapshots, promotion-gate inventory, formatter checks, compile-shape checks, and test-runner checks for the time/sleep fixture.
• Add a focused conformance gate script separate from scripts/release-gate.sh.
• 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.
• Release exp-14 only after focused conformance, full release gate, and Slovo/Glagol review pass together.
• 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

• Accept exactly std.result.is_ok, std.result.is_err, std.result.unwrap_ok, and std.result.unwrap_err.
• Map those names to existing result observer/unwrap behavior for exactly (result i32 i32) and (result string i32).
• Preserve source helper spelling in surface and checked lowering output.
• Keep legacy is_ok, is_err, unwrap_ok, and unwrap_err working.
• 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.
• 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

• Support user enum declarations with payloadless variants and unary i32 payload variants.
• Support qualified payload and payloadless constructors, immutable enum locals/params/returns/calls/tests/main flow, and same-enum equality.
• Require exhaustive enum matches with no binding on payloadless variants and one immutable arm-local i32 binding on payload variants.
• 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.
• 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.
• 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

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

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

• Treat top-level enum declarations as project/workspace local declarations that can be exported and imported alongside functions and structs.
• 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.
• Keep project/workspace symbol rewriting aligned for enum declarations, enum types, qualified constructors, enum match patterns, and imported enum symbols.
• Add project and workspace/package tests plus the examples/projects/enum-imports/ fixture.
• 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

• Allow direct known enum types as struct fields for current payloadless and unary i32 payload enums.
• Preserve UnsupportedEnumContainer for arrays, vectors, options, and results containing enum values in struct fields.
• Keep other unsupported struct field types on the existing UnsupportedStructFieldType path.
• 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.
• 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

• Allow direct bool and immutable string field types in top-level structs, alongside existing direct i32 fields and exp-18 direct enum fields.
• Preserve unsupported diagnostics for arrays, vectors, options, and results containing these field types, nested structs, and unknown named field types.
• 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.
• 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

• Add direct f64 type/literal value flow for locals, parameters, returns, calls, top-level tests, and main-reachable helper calls.
• Lower f64 to LLVM double, including constants, function parameters/returns, arithmetic + - * /, equality, and ordered comparisons.
• Promote exactly std.io.print_f64 : (f64) -> unit with runtime %.17g\n formatting and test-runner coverage.
• 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.
• 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

• Add direct i64 type/literal value flow for immutable locals, parameters, returns, calls, top-level tests, and main-reachable helper calls.
• Require explicit signed decimal i64 suffix atoms and reject malformed or out-of-range i64 literals with structured diagnostics.
• Lower i64 to LLVM i64, including constants, function parameters/returns, arithmetic + - * /, equality, and ordered comparisons.
• Promote exactly std.io.print_i64 : (i64) -> unit with runtime decimal output and test-runner coverage.
• 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.
• 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

• Promote exactly std.num.i32_to_i64 : (i32) -> i64, std.num.i32_to_f64 : (i32) -> f64, and std.num.i64_to_f64 : (i64) -> f64.
• Lower the promoted conversions directly to LLVM sext/sitofp conversion instructions without adding stable runtime helper ABI promises.
• Execute the conversions in the deterministic test runner and preserve them in formatter and lowering-inspector fixtures.
• Add diagnostics for wrong arity, wrong argument type, and explicitly unsupported narrowing or generic cast names.
• Keep Glagol examples/tests byte-aligned with Slovo supported/formatter fixtures for numeric-widening-conversions.slo.
• 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

• Promote exactly std.num.i64_to_i32_result : (i64) -> (result i32 i32).
• Return ok value for signed i64 inputs in signed i32 range and err 1 for out-of-range inputs, with no traps.
• Lower directly to LLVM signed range checks, trunc, select, and the existing (result i32 i32) aggregate representation without adding a stable helper ABI promise.
• Execute the conversion in the deterministic test runner and preserve it in formatter and lowering-inspector fixtures.
• Add diagnostics for wrong arity, wrong argument type, and explicitly unsupported deferred checked/cast names.
• Keep Glagol examples/tests byte-aligned with Slovo supported/formatter fixture hooks for checked-i64-to-i32-conversion.slo.
• 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

• Promote exactly std.num.i32_to_string : (i32) -> string and std.num.i64_to_string : (i64) -> string.
• Return signed decimal ASCII text with a leading - only for negative values and no leading +.
• Lower to private runtime helpers with current implementation-owned string allocation behavior and no stable helper ABI/layout promise.
• Execute both calls in the deterministic test runner and preserve them in formatter and lowering-inspector fixtures.
• Add diagnostics for wrong arity, wrong argument type, and explicitly unsupported deferred formatting names.
• Keep Glagol examples/tests byte-aligned with Slovo supported/formatter fixture hooks for integer-to-string.slo.
• 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

• Promote exactly std.string.parse_i64_result : (string) -> (result i64 i32).
• Accept only an entire non-empty signed decimal ASCII string with an optional leading - and signed i64 bounds.
• Return ok value for valid inputs and err 1 for malformed or out-of-range inputs without ordinary traps.
• Lower to a private runtime helper returning status plus an i64 out-parameter, and keep the result aggregate implementation-owned.
• Execute the call in the deterministic test runner and preserve it in formatter, lowering-inspector, hosted-runtime, and diagnostic fixtures.
• Keep Glagol examples/tests byte-aligned with Slovo supported/formatter fixture hooks for string-parse-i64-result.slo.
• 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

• Promote exactly std.num.f64_to_string : (f64) -> string.
• Return finite decimal ASCII text for promoted finite f64 fixture values.
• Lower to a private runtime helper with implementation-owned string allocation behavior and no stable helper ABI/layout promise.
• Execute the call in the deterministic test runner and preserve it in formatter, lowering-inspector, hosted-runtime, and diagnostic fixtures.
• Keep Glagol examples/tests byte-aligned with Slovo supported/formatter fixture hooks for f64-to-string.slo.
• 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

• Promote exactly std.num.f64_to_i32_result : (f64) -> (result i32 i32).
• 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.
• Lower directly to LLVM with ordered range checks before fptosi, so non-finite and out-of-range values do not reach undefined conversion.
• Execute the call in the deterministic test runner and preserve it in formatter, lowering-inspector, LLVM smoke, and diagnostic fixtures.
• Keep Glagol examples/tests byte-aligned with Slovo supported/formatter fixture hooks for f64-to-i32-result.slo.
• 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

• Allow direct immutable struct fields whose types are exactly i64 or finite f64, alongside existing direct i32, bool, immutable string, and current enum fields.
• Preserve constructor, immutable local, parameter, return, call, and field access flow for i64/f64 fields.
• Allow accessed numeric fields to use existing same-type arithmetic, comparison, print, and format helper support without adding new APIs.
• 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

• 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.
• Add Glagol-local project coverage for an explicit local math.slo import through examples/projects/std-layout-local-math/.
• Add an ignored sibling Slovo gate for std/ file inventory and source-shape and formatter stability.
• 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

• Promote exactly std.num.f64_to_i64_result : (f64) -> (result i64 i32).
• 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.
• Lower directly to LLVM with ordered range checks before fptosi, so non-finite and out-of-range values do not reach undefined conversion.
• Execute the call in the deterministic test runner and preserve it in formatter, lowering-inspector, LLVM smoke, hosted-runtime, and diagnostic fixtures.
• 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

• Gate the narrow source-authored std/math.slo helper set without adding compiler-known runtime names or compiler-loaded std source.
• Extend examples/projects/std-layout-local-math/ so an ordinary project explicitly imports local math.slo helpers for i32, i64, and f64.
• 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.
• Add focused project-mode and promotion-gate coverage, including sibling Slovo lib/std/math.slo helper alignment in the ignored monorepo gate.
• 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

• Gate the narrow source-authored std/result.slo helper-name extension without adding compiler-known runtime names or compiler-loaded std source.
• Add examples/projects/std-layout-local-result/ so an ordinary project explicitly imports local result.slo helpers for existing concrete result families.
• 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.
• Add focused project-mode and promotion-gate coverage, including sibling Slovo lib/std/result.slo helper alignment in the ignored monorepo gate.
• 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

• Promote exactly std.string.parse_f64_result : (string) -> (result f64 i32).
• 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.
• 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.
• Lower hosted builds through private runtime helper __glagol_string_parse_f64_result and execute the call in the deterministic test runner.
• Preserve formatter, lowering-inspector, LLVM smoke, hosted-runtime, promotion-gate, and diagnostic fixtures.
• Keep Glagol examples/tests byte-aligned with Slovo supported/formatter fixture hooks for string-parse-f64-result.slo.
• 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

• Promote exactly std.string.parse_bool_result : (string) -> (result bool i32).
• 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.
• 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.
• Lower hosted builds through private runtime helper __glagol_string_parse_bool_result.
• Preserve diagnostics, promotion-gate, lowering-inspector, LLVM smoke, hosted-runtime, and sibling Slovo fixture/std-string source alignment.
• 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

• Gate the narrow source-authored std/result.slo bool helper-name extension without adding compiler-known runtime names or compiler-loaded std source.
• 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.
• Cover is_ok_bool, is_err_bool, unwrap_ok_bool, unwrap_err_bool, and unwrap_or_bool.
• Add focused project-mode and promotion-gate coverage, including sibling Slovo lib/std/result.slo bool helper alignment in the ignored monorepo gate.
• 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

• Gate the narrow source-authored std/option.slo helper-name facade without adding compiler-known runtime names or compiler-loaded std source.
• 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.
• Cover is_some_i32, is_none_i32, unwrap_some_i32, and unwrap_or_i32.
• 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.
• 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

• Broaden the concrete option family from only (option i32) to (option i64) as well.
• 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.
• Broaden source-level match payload binding and fixture coverage for (option i64) without widening to generic options.
• Broaden the local std-layout-local-option/ fixture and the explicit std-import-option/ fixture to cover both the i32 and i64 helper families.
• 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.
• 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

• Broaden the concrete option family from only (option i32), (option i64), and (option string) to (option f64) and (option bool) as well.
• 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.
• 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.
• Extend focused option-result coverage, diagnostics snapshots, and promotion-gate inventory to the same concrete (option f64) and (option bool) baseline.
• 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

• 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.
• Broaden the same concrete helper lane with the transform helpers concat, take, drop, reverse, and subvec.
• Keep the local and explicit-source vec-string fixtures recursive and immutable with no var or set.
• Keep the lane concrete to (vec string) plus raw current (option string) / (option i32) forms only, with no generic broadening or broader result families.
• Extend focused vec-string source-helper/source-search coverage and promotion-gate inventory for the same helper package.
• 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

• Broaden the concrete option family from only (option i32) and (option i64) to (option string) as well.
• 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.
• 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.
• Extend focused option/result coverage and promotion-gate inventory to the same concrete (option string) baseline.
• 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

• Add concrete (vec string) support for immutable params, returns, and locals in the checker, formatter, and backend.
• 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.
• Add concrete vec-string equality and matching runtime/test-runner behavior.
• 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.
• 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.
• 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

• Extend the staged std.vec_i64 source-authored helper surface with insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range.
• Keep the local std-layout-local-vec_i64/ lane recursive and immutable with no var or set in the expected source shape.
• Update the explicit std-import-vec_i64/ fixture to exercise the same helper inventory against repo-root lib/std/vec_i64.slo.
• Extend focused integration coverage and promotion-gate inventory without widening parser, checker, formatter, runtime, backend, or test-runner semantics.
• 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

• Extend the staged std.vec_i64 source-authored helper surface with concat, take, drop, reverse, and subvec.
• Keep the local std-layout-local-vec_i64/ lane recursive and immutable with no var or set in the expected source shape.
• Update the explicit std-import-vec_i64/ fixture to exercise the same helper inventory against repo-root lib/std/vec_i64.slo.
• Extend focused integration coverage and promotion-gate inventory without widening parser, checker, formatter, runtime, backend, or test-runner semantics.
• 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

• 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.
• Keep the local std-layout-local-vec_i64/ lane recursive and immutable with no var or set in the expected source shape.
• Update the explicit std-import-vec_i64/ fixture to exercise the same helper inventory against repo-root lib/std/vec_i64.slo.
• Extend focused integration coverage and promotion-gate inventory without widening parser, checker, formatter, runtime, backend, or test-runner semantics.
• 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

• Gate the narrow source-authored std/time.slo facade without adding compiler-known runtime names or compiler-loaded std source.
• Add examples/projects/std-layout-local-time/ so an ordinary project explicitly imports local time.slo facades for monotonic_ms and sleep_ms_zero.
• 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.
• 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.
• 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

• 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.
• 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.
• 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.
• 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

• Extend the narrow source-authored std/math.slo helper set without adding compiler-known runtime names or compiler-loaded std source.
• 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/.
• Add benchmarks/math-loop/ with Slovo, C, Rust, and Python sources plus a runner that reports local-machine timing comparisons only.
• Add focused benchmark scaffold and promotion-gate coverage, including repo lib/std/math.slo helper alignment in the ignored monorepo std source-layout gate.
• 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

• Add a shared benchmark runner and broaden local benchmark scaffolds to math-loop, branch-loop, and parse-loop.
• Include Slovo, C, Rust, Python, and Clojure source slots, with missing toolchains skipped and deterministic checksum validation kept mandatory for implementations that run.
• Add benchmark scaffold and promotion-gate coverage for benchmark metadata, language-source inventory, format/check commands, and Python smoke runs.
• Record project licensing as MIT OR Apache-2.0 and document alpha/beta naming criteria.
• 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

• Add Common Lisp/SBCL source slots beside Clojure for math-loop, branch-loop, and parse-loop.
• Extend the shared benchmark runner to detect SBCL through sbcl, SBCL, or --sbcl.
• Clarify cold-process benchmark timing: Clojure includes JVM/Clojure startup, and Common Lisp includes SBCL script startup.
• Add benchmark scaffold and promotion-gate coverage for the second Lisp source slot.
• 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

• Add explicit --mode cold-process and --mode hot-loop runner modes.
• Record hot-loop counts and hot checksums in each benchmark scaffold.
• Report hot-loop total time and normalized median time for the base 1000000 loop count.
• Let Slovo benchmark fixtures receive the runner loop count through process arguments with stdin fallback, so Slovo participates in hot-loop mode.
• Add benchmark scaffold and promotion-gate coverage for hot-loop metadata and execution.
• 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

• Add Glagol technical whitepaper Markdown and generated PDF.
• Add concise compiler manifest Markdown and generated PDF.
• Add repository-local beta compiler-design skill.
• 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

• Add project-mode source search for explicit std.<module> imports, starting with std.math.
• Load std/math.slo through SLOVO_STD_PATH or a lib/std checkout without copying it into the project.
• Add examples/projects/std-import-math/ plus focused integration and promotion-gate coverage.
• 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

• Add explicit project-mode std.result and std.option source-search fixtures without local copied modules.
• Gate the fixtures with focused integration tests and promotion-gate coverage.
• 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

• Load explicit std.<module> imports inside workspace packages.
• Resolve loaded standard modules before normal package-qualified dependency lookup.
• Add examples/workspaces/std-import-option/ plus focused integration and promotion-gate coverage.
• 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

• Gate explicit project-mode std.time, std.random, std.env, and std.fs source imports without local copied modules.
• Add focused integration coverage for format, check, and test behavior across the host facade fixtures.
• Add promotion-gate coverage for the new fixtures and sibling Slovo fixture alignment.
• 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

• Gate explicit project-mode std.string and std.num source imports without local copied modules.
• Add focused integration coverage for format, check, and test behavior across the core facade fixtures.
• Add promotion-gate coverage for the new fixtures and sibling Slovo fixture alignment.
• 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

• Gate explicit project-mode std.io source imports without a local copied module.
• Add focused integration coverage for format, check, and deterministic test behavior.
• Add promotion-gate coverage for the new fixture and sibling Slovo fixture alignment.
• 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

• Gate executable-relative installed stdlib discovery for explicit std.<module> source imports.
• Add focused integration coverage that copies the compiler binary and resolves a probe module from share/slovo/std.
• Add promotion-gate coverage for discovery candidates and diagnostics.
• 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

• Treat SLOVO_STD_PATH as an ordered OS path list.
• Add focused integration coverage for an empty first root and a second root containing the requested standard module.
• Add promotion-gate coverage for path-list handling.
• 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

• Add source-authored std/process.slo facade wrappers over the already promoted process argument runtime calls.
• Gate explicit project-mode std.process source imports without a local copied module.
• Add focused integration coverage and promotion-gate coverage.
• 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

• Add source-authored std/cli.slo facade helpers that compose std.process and std.string.
• Gate explicit project-mode std.cli source imports without a local copied module.
• Add focused integration coverage and promotion-gate coverage for transitive standard-source imports.
• 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

• Extend std/cli.slo with arg_i64_result and arg_i64_or_zero.
• Add direct arg_f64_result and arg_bool_result parse-result wrappers over std.process.arg.
• Update focused integration coverage and promotion-gate coverage for the expanded helper inventory.
• 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

• Promote source constructors for (result f64 i32) and (result bool i32).
• Promote source match payload bindings for (result f64 i32) and (result bool i32).
• Add focused coverage for formatter, checker, test runner, and LLVM aggregate shape.
• Update std.cli coverage so f64 and bool missing argument indexes are result-based.
• 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

• Add % surface/lowering support for same-width i32 and i64 operands.
• Gate checker, formatter, test-runner, and LLVM srem behavior.
• Reject f64 remainder explicitly while keeping mixed numeric operand diagnostics.
• Add examples/integer-remainder.slo and sibling Slovo fixture alignment.
• Extend std.math with rem_i32, is_even_i32, is_odd_i32, rem_i64, is_even_i64, and is_odd_i64.
• 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

• Add bit_and, bit_or, and bit_xor surface/lowering support for same-width i32 and i64 operands.
• Gate checker, formatter, test-runner, and LLVM and/or/xor behavior.
• Reject f64 bitwise operations explicitly while keeping mixed numeric operand diagnostics.
• Add examples/integer-bitwise.slo and sibling Slovo fixture alignment.
• Extend std.math with bit_and_i32, bit_or_i32, bit_xor_i32, bit_and_i64, bit_or_i64, and bit_xor_i64.
• 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

• Add and, or, and not formatter/lowering support.
• Lower and and or through existing if semantics so they short-circuit.
• Add examples/boolean-logic.slo and sibling Slovo fixture alignment.
• Gate checker, test-runner, formatter, and LLVM branch shape.
• 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

• Build hosted executables through clang -O2.
• Lower current immutable numeric locals as SSA values where no stack storage is required.
• Refresh benchmark methodology and evidence in the publication documents.
• Add repo-local PDF rendering scripts and wire them into the release gate.
• 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

• Add benchmarks/array-index-loop/ with Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL scaffold implementations.
• Add benchmarks/string-eq-loop/ with Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL scaffold implementations.
• Keep the shared benchmark runner model unchanged while extending focused benchmark scaffold and promotion-gate coverage from three kernels to five.
• Refresh the Glagol whitepaper and publication docs around the expanded benchmark suite and the current experimental compiler surface.
• 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

• Allow direct struct field declarations over (array i32 N), (array i64 N), (array f64 N), (array bool N), and (array string N).
• Keep fixed arrays positive-length only, immutable only, and limited to the already promoted direct scalar and string element families.
• Add promoted array-struct-fields fixture coverage, formatter/lowering snapshots, focused Glagol tests, and diagnostic snapshot updates.
• 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

• Allow unary enum payload variants whose payload type is a current known non-recursive struct type.
• Keep one payload per payload variant and the existing same-payload-type rule when payload variants are present.
• Add promoted enum-payload-structs fixture coverage, formatter/lowering snapshots, focused Glagol tests, and diagnostic snapshot updates.
• 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

• Add benchmarks/array-struct-field-loop/ with Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL scaffold implementations.
• Add benchmarks/enum-struct-payload-loop/ with Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL scaffold implementations.
• Keep the shared benchmark runner model unchanged while extending focused benchmark scaffold and promotion-gate coverage from five kernels to seven.
• Refresh the Glagol whitepaper and publication docs around the expanded suite and the current experimental compiler surface through exp-121.
• 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

• Add benchmarks/vec-i32-index-loop/ with Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL scaffold implementations.
• Add benchmarks/vec-string-eq-loop/ with Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL scaffold implementations.
• Keep the shared benchmark runner model unchanged while extending focused benchmark scaffold and promotion-gate coverage from seven kernels to nine.
• Refresh the Glagol whitepaper and publication docs around the expanded suite and the current experimental compiler surface through exp-121.
• 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.