41 changed files with 727 additions and 4182 deletions
--- a/.llm/BETA_21_JSON_DOCUMENT_SCALAR_PARSING_FOUNDATION.md
+++ b/.llm/BETA_21_JSON_DOCUMENT_SCALAR_PARSING_FOUNDATION.md
@ -1,72 +0,0 @@
 # 1.0.0-beta.21 JSON Document Scalar Parsing Foundation
 ## Scope
 `1.0.0-beta.21` is a standard-library and compiler-gate slice. It adds
 source-authored `std.json` helpers for scalar JSON documents while keeping
 source-language syntax, runtime C, compiler-known runtime names, and ABI/layout
 policy unchanged.
 The release adds:
 - `parse_string_document_result ((document string)) -> (result string i32)`
 - `parse_bool_document_result ((document string)) -> (result bool i32)`
 - `parse_i32_document_result ((document string)) -> (result i32 i32)`
 - `parse_u32_document_result ((document string)) -> (result u32 i32)`
 - `parse_i64_document_result ((document string)) -> (result i64 i32)`
 - `parse_u64_document_result ((document string)) -> (result u64 i32)`
 - `parse_f64_document_result ((document string)) -> (result f64 i32)`
 - `parse_null_document_result ((document string)) -> (result bool i32)`
 ## Contract
 Each helper trims ASCII whitespace around the whole input document with
 `std.string.trim_ascii`, then delegates to the already released exact
 value-token parser for that scalar family.
 Leading and trailing ASCII whitespace around one scalar document is accepted.
 Trailing non-whitespace remains an ordinary parse failure and returns `err 1`
 through the underlying exact parser.
 ## Non-Scope
 This scope does not add:
 - compiler-known `std.json.*_document_result` runtime names
 - private `__glagol_json_*document*` runtime symbols
 - runtime C helper implementations
 - source-language syntax
 - object or array parsing
 - recursive `JsonValue`
 - tokenizer/parser objects
 - maps, sets, executable generics, or generic collections
 - streaming parsers or encoders
 - Unicode escape decoding beyond the existing string-token helper
 - embedded NUL policy
 - stable JSON APIs
 - stable ABI/layout
 - stable standard-library compatibility
 - performance claims
 ## Acceptance Criteria
 - `lib/std/json.slo` exports all eight document scalar helpers.
 - Explicit `std.json` import examples exercise trimmed whitespace success,
  no-whitespace success, and trailing non-whitespace failure.
 - Local `std-layout-local-json` examples mirror the public helper surface with
  an explicit local `string` dependency for `trim_ascii`.
 - Focused compiler coverage verifies the helpers are source-authored and that
  direct compiler-known runtime calls for the new names remain unsupported.
 - `scripts/release-gate.sh` runs the focused beta21 test.
 - Generated standard-library API documentation includes the new signatures.
 ## Gates
 ```bash
 cargo fmt --check
 cargo test --test standard_json_document_scalar_parsing_beta21
 cargo test --test standard_json_source_facade_alpha
 cargo test --test promotion_gate
 cargo test
 ./scripts/release-gate.sh
 ```
--- a/.llm/BETA_22_RUN_MANIFEST_AND_EXECUTION_REPORT_HARDENING.md
+++ b/.llm/BETA_22_RUN_MANIFEST_AND_EXECUTION_REPORT_HARDENING.md
@ -1,71 +0,0 @@
 # 1.0.0-beta.22 Run Manifest And Execution Report Hardening
 ## Scope
 `1.0.0-beta.22` is a compiler/tooling evidence-hardening slice for
 `glagol run --manifest`. It keeps the Slovo source language, typed core,
 runtime capabilities, standard-library surface, compiler-known runtime names,
 ABI/layout policy, and package behavior unchanged.
 The release adds an additive run-report block to run-mode artifact manifests
 so manifest evidence can record:
 - process exit status for the invoked program
 - captured stdout from the run
 - captured stderr from the run
 - forwarded program arguments passed through `glagol run`
 ## Contract
 When `glagol run --manifest <path>` completes far enough to write an artifact
 manifest, the manifest should include run execution evidence in addition to the
 existing schema marker, command, mode, success, diagnostics metadata, primary
 output, and artifacts fields.
 The run-report data describes the native executable invocation performed by
 `glagol run`, not a new source-language or runtime feature. Captured stdout
 and stderr are evidence fields for tooling and release-gate review; they do
 not redefine ordinary terminal behavior. Forwarded args are recorded so
 fixtures can distinguish compiler arguments from user-program arguments.
 The block is additive beta tooling metadata. It is not a stable public schema
 freeze and does not bump `slovo.artifact-manifest` version `1`.
 ## Non-Scope
 This scope does not add:
 - source-language syntax
 - standard-library helpers
 - compiler-known `std.*` runtime names
 - runtime C capabilities
 - package, workspace, import, or registry behavior
 - stable artifact-manifest schema freeze
 - stable Markdown schema freeze
 - LSP, watch, SARIF, or daemon protocols
 - performance claims
 - stable ABI/layout
 - beta maturity beyond the existing `1.0.0-beta` line
 ## Acceptance Criteria
 - `glagol run --manifest <path>` writes an artifact manifest with an additive
  run-report block after executing a supported program.
 - The run report records exit status, captured stdout, captured stderr, and
  forwarded args.
 - Existing manifest fields and schema/version markers remain compatible with
  the beta artifact-manifest contract.
 - Non-run modes do not need run-report metadata.
 - Documentation describes beta22 as tooling/CLI evidence hardening only.
 - Release notes and roadmaps state that beta22 does not add language or
  stdlib features and does not freeze the manifest schema.
 ## Suggested Gates
 ```bash
 cargo fmt --check
 cargo test --test run_manifest_beta22
 cargo test --test cli_v1_1
 ./scripts/release-gate.sh
 git diff --check
 ```
--- a/.llm/BETA_23_STDLIB_STABILITY_TIER_LEDGER_AND_CATALOG_ALIGNMENT.md
+++ b/.llm/BETA_23_STDLIB_STABILITY_TIER_LEDGER_AND_CATALOG_ALIGNMENT.md
@ -1,73 +0,0 @@
 # 1.0.0-beta.23 Standard Library Stability Tier Ledger And Catalog Alignment
 ## Scope
 `1.0.0-beta.23` is a documentation/catalog clarity slice for the standard
 library. It adds a public stability-tier ledger and aligns the surrounding
 README, roadmap, release-note, and specification text with the generated API
 catalog boundary.
 This release does not change the source language, typed core, runtime
 capabilities, standard-library helper surface, compiler-known runtime names,
 ABI/layout policy, or package behavior. It does change generated catalog
 output and release-gate checks so tier metadata is visible and enforced.
 ## Contract
 The public standard-library docs use exactly these tier labels:
 - `beta-supported`
 - `experimental`
 - `internal`
 The generated `docs/language/STDLIB_API.md` catalog remains the exact exported
 signature inventory generated from `lib/std/*.slo`. The new
 `docs/language/STDLIB_TIERS.md` ledger records maturity and stability
 expectations for those helpers and surrounding standard-library domains.
 Experimental domains in the beta23 ledger include JSON, loopback networking,
 random/time, and filesystem resource-handle helpers. Concrete vector modules
 remain beta-supported concrete lanes; they are not a generic collections
 freeze and do not imply executable generics, maps, sets, iterators, mutable
 vectors, slice/view APIs, runtime collection changes, or stable ABI/layout.
 ## Non-Scope
 This scope does not add:
 - source-language syntax
 - standard-library helpers
 - compiler-known `std.*` runtime names
 - runtime C capabilities
 - package, workspace, import, or registry behavior
 - stable standard-library/API compatibility freeze
 - stable manifest schema freeze
 - stable Markdown schema freeze
 - stable ABI/layout
 - performance claims
 - beta maturity beyond the existing `1.0.0-beta` line
 ## Acceptance Criteria
 - `docs/language/STDLIB_TIERS.md` defines the public tier labels and their
  current meaning.
 - The tier ledger marks JSON, loopback networking, random/time, and filesystem
  resource-handle helpers as experimental domains.
 - The tier ledger records concrete vector modules as beta-supported concrete
  lanes without claiming generic collection stability.
 - README, `lib/std/README.md`, language release notes, language roadmap,
  post-beta roadmap, and the v1 spec link or describe the tier ledger.
 - Documentation states beta23 is docs/catalog tooling clarity only and does
  not add language, stdlib, runtime, stable schema, or stable API behavior.
 - The generated API catalog emits tier metadata, and the release gate checks
  that experimental tiers remain represented.
 ## Suggested Gates
 ```bash
 node --check scripts/render-stdlib-api-doc.js
 node --check scripts/check-stdlib-api-tiers.js
 ./scripts/render-stdlib-api-doc.sh
 ./scripts/check-stdlib-api-tiers.js
 git diff --check
 ```
--- a/.llm/BETA_24_PACKAGE_MANIFEST_IDENTITY_AND_DEPENDENCY_DISCIPLINE.md
+++ b/.llm/BETA_24_PACKAGE_MANIFEST_IDENTITY_AND_DEPENDENCY_DISCIPLINE.md
@ -1,79 +0,0 @@
 # 1.0.0-beta.24 Package Manifest Identity And Dependency Discipline
 ## Scope
 `1.0.0-beta.24` is a package/workspace discipline hardening slice for local
 manifest diagnostics. It tightens how package manifest identity and local
 dependency tables are reported when users write ambiguous or invalid manifest
 keys.
 This release changes diagnostics only. It does not change the Slovo source
 language, typed core, runtime behavior, standard-library helper surface,
 compiler-known runtime names, package graph semantics, ABI/layout policy, or
 artifact/Markdown schema stability guarantees.
 ## Contract
 The beta package model remains a closed local workspace model:
 - package manifests declare `[package]` identity metadata and optional
  `[dependencies]` local path records
 - dependency keys name local packages and must match the target package name
 - dependency paths remain local path records under the existing workspace and
  package boundary checks
 The beta24 diagnostic hardening makes these manifest errors explicit:
 - duplicate keys in package manifests report `PackageManifestInvalid`
 - invalid dependency keys report `InvalidPackageDependencyName`
 - duplicate dependency keys report `DuplicatePackageDependencyName`
 These diagnostics are part of the beta package/workspace discipline surface.
 They do not promote a package manager, resolver, lockfile, registry, publish
 flow, or stable package ABI/layout.
 ## Non-Scope
 This scope does not add:
 - remote registry behavior
 - lockfiles
 - semantic-version solving
 - package publishing
 - optional, dev, target, or feature-gated dependencies
 - build scripts or package archives
 - stable package ABI/layout
 - stable package manager behavior
 - source-language syntax or semantics
 - runtime behavior or runtime C capabilities
 - standard-library helpers or stdlib behavior
 - compiler-known `std.*` runtime names
 - stable artifact-manifest or Markdown schema guarantees
 - performance claims
 ## Acceptance Criteria
 - `docs/language/PACKAGES.md` documents duplicate package-manifest keys,
  invalid dependency keys, and duplicate dependency keys as explicit beta
  diagnostics.
 - Language and compiler release notes describe beta24 as package manifest
  identity/dependency diagnostic hardening only.
 - Language and compiler roadmaps record beta24 as a local package/workspace
  diagnostics slice with all registry, lockfile, semver, publishing,
  optional/dev/target dependency, ABI/layout, language, runtime, and stdlib
  work deferred.
 - README and the post-beta roadmap identify `1.0.0-beta.24` as the current
  package/workspace discipline hardening slice.
 - Glagol is versioned as `1.0.0-beta.24`.
 - `compiler/tests/package_workspace_discipline_beta24.rs` covers the focused
  package manifest/dependency diagnostics and a positive local dependency
  workspace.
 - `scripts/release-gate.sh` runs the focused beta24 test.
 ## Suggested Gates
 ```bash
 git diff --check
 cargo fmt --check
 cargo test --test package_workspace_discipline_beta24
 ```
--- a/.llm/BETA_25_USER_PROJECT_CONFORMANCE_MATRIX.md
+++ b/.llm/BETA_25_USER_PROJECT_CONFORMANCE_MATRIX.md
@ -1,95 +0,0 @@
 # 1.0.0-beta.25 User Project Conformance Matrix
 ## Scope
 `1.0.0-beta.25` is a tooling/conformance evidence slice for ordinary
 project and workspace usage. It adds a deterministic user-project conformance
 matrix over the existing checked examples under `examples/projects/` and
 `examples/workspaces/`.
 The matrix is stable-readiness evidence for the beta toolchain. It records
 which existing user-shaped example projects and workspaces are expected to
 pass `glagol check`, `glagol test --list`, and stable `glagol test` execution
 through ordinary Glagol entry points.
 At release time the matrix covers all 43 top-level fixture roots with
 `slovo.toml` under those inventories and 655 discovered tests. Environment
 fixtures run with deterministic in-test environment values so host shell state
 does not decide the result.
 This release changes tooling evidence only. It does not change the Slovo
 source language, typed core, runtime behavior, standard-library helper
 surface, compiler-known runtime names, package-manager behavior, package graph
 semantics, registry behavior, lockfile behavior, semver behavior, ABI/layout
 policy, stable schema policy, or performance policy.
 ## Contract
 The conformance matrix is deterministic and repository-local:
 - inputs are every top-level `slovo.toml` fixture under the existing
  `examples/projects/` and `examples/workspaces/` directories
 - entries are sorted by stable repository-relative path
 - each entry names the example kind, path, and ordinary project/workspace
  test count covered by the matrix
 - fixture inventory drift must fail the focused matrix test until the matrix
  and release evidence are updated deliberately
 - generated evidence must not depend on wall-clock time, host-specific
  absolute paths, random ordering, or network access
 - matrix output is beta readiness evidence, not a frozen public schema
 The matrix is intended to answer whether normal beta users can exercise the
 current example projects and workspaces through the documented toolchain. It
 does not promote new language forms, new standard-library helpers, new runtime
 capabilities, new package manager behavior, or new compatibility guarantees.
 ## Non-Scope
 This scope does not add:
 - source-language syntax or semantics
 - typed-core changes
 - standard-library helpers or stdlib behavior changes
 - compiler-known `std.*` runtime names
 - runtime behavior or runtime C capabilities
 - package manager behavior
 - remote registry behavior
 - lockfiles
 - semantic-version solving
 - package publishing
 - optional, dev, target, or feature-gated dependencies
 - stable package ABI/layout
 - stable artifact-manifest, Markdown, JSON, or conformance-matrix schema
  guarantees
 - performance thresholds, performance claims, or timing publication
 - LSP/watch, SARIF, daemon, coverage, retry, tag/group, or event-stream
  protocols
 ## Acceptance Criteria
 - README names `1.0.0-beta.25` as the current release and describes the
  user-project conformance matrix as tooling/readiness evidence only.
 - Language and compiler release notes describe beta25 as a
  tooling/conformance evidence slice over existing `examples/projects/` and
  `examples/workspaces/`.
 - Language and compiler roadmaps record beta25 as the current
  stable-readiness evidence slice while keeping language, stdlib, runtime,
  package-manager, stable-schema, and performance work deferred.
 - The post-beta roadmap records beta25 under tooling/release hardening.
 - Glagol is versioned as `1.0.0-beta.25`.
 - `compiler/tests/user_project_conformance_beta25.rs` covers all 43 top-level
  project/workspace fixture roots and 655 discovered tests.
 - Fixture inventory drift is checked against discovered top-level
  `slovo.toml` roots.
 - `scripts/release-gate.sh` runs the focused beta25 matrix test.
 - No compiler, runtime, standard-library, package-manager, registry, lockfile,
  semver, ABI/layout, stable-schema, or performance claim is introduced by
  the documentation.
 ## Suggested Gates
 ```bash
 git diff --check
 cargo fmt --check
 cargo test --test user_project_conformance_beta25
 ```
--- a/.llm/reviews/BETA_21_IMPLEMENTATION_NOTES.md
+++ b/.llm/reviews/BETA_21_IMPLEMENTATION_NOTES.md
@ -1,25 +0,0 @@
 # 1.0.0-beta.21 Glagol Implementation Notes
 Scope: JSON Document Scalar Parsing Foundation.
 This Glagol-side slice prepares compiler/test/release-gate coverage for the
 source-authored `std.json` document scalar helpers:
 - `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`
 - `parse_null_document_result`
 The focused beta21 test uses an explicit `std.json` import, checks/formats/tests
 the imported helpers, requires the helpers to exist in `lib/std/json.slo`, and
 asserts that no `std.json.parse_*_document_result` compiler-known calls or
 private `__glagol_json_*document*` runtime symbols are introduced.
 The JSON source-facade and promotion-gate inventories are updated to match the
 Slovo-side source/export/example work, which adds three JSON document scalar
 fixture tests and raises local and explicit `std.json` fixture output from 9 to
 12 tests.
--- a/.llm/reviews/BETA_21_RELEASE_REVIEW.md
+++ b/.llm/reviews/BETA_21_RELEASE_REVIEW.md
@ -1,52 +0,0 @@
 # 1.0.0-beta.21 Release Review
 Scope: JSON Document Scalar Parsing Foundation.
 ## Findings
 No blocking findings.
 The uncommitted beta21 candidate matches the release contract:
 - `lib/std/json.slo` exports all eight source-authored
  `parse_*_document_result` helpers.
 - Each document helper trims the whole input with `trim_ascii`, then delegates
  to the existing exact scalar value-token parser for the matching family.
 - Direct compiler-known `std.json.parse_*_document_result` calls are not
  introduced, and no private `__glagol_json_*document*` runtime symbol is
  introduced.
 - The explicit `std.json` example imports repo-root `std.json` and covers
  trimmed success, plain success, trailing non-whitespace failure, scalar
  token parsing, fields, arrays, objects, and 12 tests.
 - The local JSON example imports local `json`, the local `json` fixture imports
  local `string (trim_ascii)`, and it mirrors the same 12-test coverage.
 - Compiler coverage includes the focused beta21 test, JSON facade inventory,
  promotion-gate alignment, release-gate wiring, package version bump, and the
  generated standard-library API catalog signatures.
 - Release docs describe `1.0.0-beta.21` as released, and the source/docs scan
  did not find local/private publication text.
 ## Verification
 Commands run:
 ```bash
 git diff --check
 git diff --cached --check
 bash -n scripts/release-gate.sh
 cargo fmt --check --manifest-path compiler/Cargo.toml
 cargo test --test standard_json_document_scalar_parsing_beta21
 cargo test --test standard_json_source_facade_alpha
 cargo test --test promotion_gate -- promotion_gate_artifacts_are_aligned
 ```
 Results:
 - `standard_json_document_scalar_parsing_beta21`: 2 passed.
 - `standard_json_source_facade_alpha`: 2 passed.
 - `promotion_gate_artifacts_are_aligned`: 1 passed.
 - Formatting, shell syntax, and diff whitespace checks passed.
 - Targeted stale-release/private-text scans over source/docs paths passed.
 Not run by design for this review: full `cargo test`, ignored smoke tests, and
 the full release gate.
--- a/.llm/reviews/BETA_22_RELEASE_REVIEW.md
+++ b/.llm/reviews/BETA_22_RELEASE_REVIEW.md
@ -1,45 +0,0 @@
 # Beta22 Release Review
 Verdict: PASS with notes.
 ## Findings
 No blocking or non-blocking findings in the reviewed scope.
 ## Scope Reviewed
 - `compiler/src/main.rs` run manifest rendering and exit behavior.
 - `compiler/tests/run_manifest_beta22.rs` focused coverage.
 - `.llm/BETA_22_RUN_MANIFEST_AND_EXECUTION_REPORT_HARDENING.md` beta22 contract and suggested gates.
 - `README.md`, `docs/compiler/RELEASE_NOTES.md`, `docs/compiler/ROADMAP.md`, `docs/language/RELEASE_NOTES.md`, `docs/language/ROADMAP.md`, and `docs/language/SPEC-v1.md` release claims.
 - `scripts/release-gate.sh` inclusion.
 ## Acceptance Checklist
 - PASS: `glagol run --manifest <path>` writes additive run execution evidence after a supported program executes. The run path captures child stdout/stderr/status before manifest rendering and exits with the child status in `compiler/src/main.rs:892` through `compiler/src/main.rs:918`; rendering emits `(run-report ...)` in `compiler/src/main.rs:2162` through `compiler/src/main.rs:2188`.
 - PASS: Run-report records exit status, captured stdout, captured stderr, and forwarded args. Tests cover success stdout and args in `compiler/tests/run_manifest_beta22.rs:10` through `compiler/tests/run_manifest_beta22.rs:60`, and nonzero exit plus stderr preservation in `compiler/tests/run_manifest_beta22.rs:62` through `compiler/tests/run_manifest_beta22.rs:128`.
 - PASS: Existing manifest fields and schema/version markers remain compatible. The new path passes `Some(run_report)` only through the run-specific wrapper in `compiler/src/main.rs:2019` through `compiler/src/main.rs:2043`; the renderer still emits `slovo.artifact-manifest` version `1` in `compiler/src/main.rs:2067` through `compiler/src/main.rs:2069`.
 - PASS: Source failures do not receive fake run evidence. The focused test asserts no run-report for a type failure in `compiler/tests/run_manifest_beta22.rs:130` through `compiler/tests/run_manifest_beta22.rs:161`.
 - PASS: Non-run modes are outside the run-report requirement. Existing foreign-import/project manifest wrappers pass `None` for the run-report slot in `compiler/src/main.rs:1992` through `compiler/src/main.rs:2017`; beta22 docs state this explicitly in `.llm/BETA_22_RUN_MANIFEST_AND_EXECUTION_REPORT_HARDENING.md:58` and `docs/compiler/RELEASE_NOTES.md:35`.
 - PASS: Documentation does not overclaim language, stdlib, runtime, package, ABI, or stable manifest-schema changes. Representative deferrals are present in `README.md:172` through `README.md:178`, `docs/compiler/ROADMAP.md:118` through `docs/compiler/ROADMAP.md:124`, `docs/language/RELEASE_NOTES.md:52` through `docs/language/RELEASE_NOTES.md:62`, `docs/language/ROADMAP.md:99` through `docs/language/ROADMAP.md:106`, and `docs/language/SPEC-v1.md:260` through `docs/language/SPEC-v1.md:267`.
 - PASS: The beta22 contract suggested gate names match the implemented focused test and release gate. `.llm/BETA_22_RUN_MANIFEST_AND_EXECUTION_REPORT_HARDENING.md:63` through `.llm/BETA_22_RUN_MANIFEST_AND_EXECUTION_REPORT_HARDENING.md:71` lists `cargo test --test run_manifest_beta22`; `scripts/release-gate.sh:75` includes the same focused test.
 ## Verification
 Ran:
 ```bash
 cargo test --test run_manifest_beta22
 ```
 Result: passed, 3 tests passed.
 Recommended before release tag:
 ```bash
 cargo fmt --check
 ./scripts/release-gate.sh
 git diff --check
 ```
 Note: the focused hosted-run tests depend on Clang discovery, matching existing project patterns. In this local run they executed and passed rather than skipping.
--- a/.llm/reviews/BETA_23_RELEASE_REVIEW.md
+++ b/.llm/reviews/BETA_23_RELEASE_REVIEW.md
@ -1,54 +0,0 @@
 # Beta23 Release Review
 Verdict: PASS with notes.
 ## Findings
 No blocking or non-blocking findings in the reviewed scope.
 ## Scope Reviewed
 - `scripts/render-stdlib-api-doc.js` tier rendering.
 - `scripts/check-stdlib-api-tiers.js` tier gate.
 - `scripts/release-gate.sh` integration.
 - Generated `docs/language/STDLIB_API.md`.
 - `docs/language/STDLIB_TIERS.md`, README, release notes, roadmaps, and spec updates.
 - Compiler package version bump and compiler release documentation.
 ## Acceptance Checklist
 - PASS: `docs/language/STDLIB_TIERS.md` defines the public tier labels and explains the current beta meaning. See `docs/language/STDLIB_TIERS.md:21` through `docs/language/STDLIB_TIERS.md:25`.
 - PASS: The tier ledger marks JSON, loopback networking, random/time, and filesystem resource-handle helpers as experimental domains. See `docs/language/STDLIB_TIERS.md:46` through `docs/language/STDLIB_TIERS.md:49`.
 - PASS: The tier ledger records concrete vector modules as beta-supported concrete lanes without claiming generic collection stability. See `docs/language/STDLIB_TIERS.md:44`.
 - PASS: The generated API catalog emits tier metadata and summary counts. See `docs/language/STDLIB_API.md:6` through `docs/language/STDLIB_API.md:24`.
 - PASS: Generated catalog classification matches the beta23 contract: filesystem handle helpers are experimental in `docs/language/STDLIB_API.md:115` through `docs/language/STDLIB_API.md:119`; `std.json`, `std.net`, `std.random`, and `std.time` are experimental in `docs/language/STDLIB_API.md:195` through `docs/language/STDLIB_API.md:240`, `docs/language/STDLIB_API.md:294` through `docs/language/STDLIB_API.md:308`, `docs/language/STDLIB_API.md:425` through `docs/language/STDLIB_API.md:432`, and `docs/language/STDLIB_API.md:540` through `docs/language/STDLIB_API.md:547`.
 - PASS: Concrete vector modules retain explicit no-generic-collection-freeze notes in generated output. Representative coverage is `docs/language/STDLIB_API.md:549` through `docs/language/STDLIB_API.md:554`, with the same note repeated for the other concrete `std.vec_*` modules.
 - PASS: The renderer implements the tier map and emits per-module/per-helper tiers. See `scripts/render-stdlib-api-doc.js:12` through `scripts/render-stdlib-api-doc.js:46`, `scripts/render-stdlib-api-doc.js:245` through `scripts/render-stdlib-api-doc.js:263`, and `scripts/render-stdlib-api-doc.js:297` through `scripts/render-stdlib-api-doc.js:330`.
 - PASS: The tier gate checks stale wording, summary tier definitions, experimental module/helper coverage, and vector boundary notes. See `scripts/check-stdlib-api-tiers.js:47` through `scripts/check-stdlib-api-tiers.js:80`.
 - PASS: `scripts/release-gate.sh` runs syntax checks for both tier scripts and executes the tier checker after catalog rendering. See `scripts/release-gate.sh:12` through `scripts/release-gate.sh:16`.
 - PASS: README, `lib/std/README.md`, language release notes, language roadmap, post-beta roadmap, and v1 spec link or describe the tier ledger and non-scope. Representative references: `README.md:69` through `README.md:79`, `lib/std/README.md:174` through `lib/std/README.md:184`, `docs/language/RELEASE_NOTES.md:53` through `docs/language/RELEASE_NOTES.md:69`, `docs/language/ROADMAP.md:109` through `docs/language/ROADMAP.md:119`, `docs/POST_BETA_ROADMAP.md:121` through `docs/POST_BETA_ROADMAP.md:132`, and `docs/language/SPEC-v1.md:268` through `docs/language/SPEC-v1.md:279`.
 - PASS: Documentation states beta23 is documentation/catalog tooling clarity only and does not add language, stdlib, runtime, stable schema, ABI/layout, or stable API behavior. See `docs/language/STDLIB_TIERS.md:10` through `docs/language/STDLIB_TIERS.md:15` and `docs/language/STDLIB_TIERS.md:52` through `docs/language/STDLIB_TIERS.md:68`.
 - PASS: Compiler package version and compiler release docs are aligned to `1.0.0-beta.23`. See `compiler/Cargo.toml:3`, `compiler/Cargo.lock:7`, `docs/compiler/RELEASE_NOTES.md:15` through `docs/compiler/RELEASE_NOTES.md:43`, and `docs/compiler/ROADMAP.md:126` through `docs/compiler/ROADMAP.md:132`.
 ## Verification
 Ran:
 ```bash
 node --check scripts/render-stdlib-api-doc.js
 node --check scripts/check-stdlib-api-tiers.js
 ./scripts/check-stdlib-api-tiers.js
 git diff --check
 rg -n '^- `experimental`' docs/language/STDLIB_API.md
 ```
 Result: all focused checks passed. The `rg` inspection confirmed 58 experimental helper signatures across the expected filesystem-handle, JSON, loopback networking, random, and time surfaces.
 Recommended before release tag:
 ```bash
 ./scripts/render-stdlib-api-doc.sh
 ./scripts/release-gate.sh
 ```
 Note: run the full release gate after the generated catalog changes are staged or committed; the gate intentionally fails if `docs/language/STDLIB_API.md` has unstaged generated-doc drift.
--- a/.llm/reviews/BETA_24_RELEASE_REVIEW.md
+++ b/.llm/reviews/BETA_24_RELEASE_REVIEW.md
@ -1,66 +0,0 @@
 # Beta24 Release Review
 Verdict: PASS.
 ## Findings
 No blocking or non-blocking findings in the reviewed scope.
 ## Scope Reviewed
 - `compiler/src/project.rs` package manifest diagnostics.
 - `compiler/tests/package_workspace_discipline_beta24.rs`.
 - `scripts/release-gate.sh` beta24 focused gate entry.
 - `compiler/Cargo.toml` and `compiler/Cargo.lock` version bump.
 - `.llm/BETA_24_PACKAGE_MANIFEST_IDENTITY_AND_DEPENDENCY_DISCIPLINE.md`.
 - README, language package/diagnostic/release/roadmap docs, compiler release/roadmap docs, and post-beta roadmap updates.
 ## Acceptance Checklist
 - PASS: Duplicate package manifest keys now use package-scoped diagnostics through `set_manifest_key(..., "PackageManifestInvalid", "package")` for package identity keys. See `compiler/src/project.rs:1505` through `compiler/src/project.rs:1545` and `compiler/src/project.rs:1752` through `compiler/src/project.rs:1771`.
 - PASS: Invalid dependency keys are rejected before graph validation with `InvalidPackageDependencyName`. See `compiler/src/project.rs:1556` through `compiler/src/project.rs:1572`.
 - PASS: Duplicate dependency keys are rejected before graph validation with `DuplicatePackageDependencyName`, and invalid/duplicate dependency records are not added to the dependency graph. See `compiler/src/project.rs:1573` through `compiler/src/project.rs:1593`.
 - PASS: Existing local-path-only dependency parsing and later dependency key/name matching remain in place. See `compiler/src/project.rs:1594` through `compiler/src/project.rs:1601`, `compiler/src/project.rs:1743` through `compiler/src/project.rs:1749`, and `compiler/src/project.rs:2970` through `compiler/src/project.rs:3005`.
 - PASS: Focused tests cover duplicate package keys, invalid dependency keys, duplicate dependency keys, and a clean local dependency workspace. See `compiler/tests/package_workspace_discipline_beta24.rs:11` through `compiler/tests/package_workspace_discipline_beta24.rs:109`.
 - PASS: `scripts/release-gate.sh` runs the beta24 focused test before full `cargo test`. See `scripts/release-gate.sh:68` through `scripts/release-gate.sh:82`.
 - PASS: The compiler package version is aligned to `1.0.0-beta.24` in both Cargo files. See `compiler/Cargo.toml:3` and `compiler/Cargo.lock:7`.
 - PASS: The beta24 contract defines diagnostics-only scope, explicit non-scope, acceptance criteria, and focused gates. See `.llm/BETA_24_PACKAGE_MANIFEST_IDENTITY_AND_DEPENDENCY_DISCIPLINE.md:5` through `.llm/BETA_24_PACKAGE_MANIFEST_IDENTITY_AND_DEPENDENCY_DISCIPLINE.md:79`.
 - PASS: README identifies `1.0.0-beta.24` as current and describes the package manifest/dependency diagnostic hardening scope without claiming package-manager, runtime, language, or stdlib changes. See `README.md:9` and `README.md:27` through `README.md:50`.
 - PASS: `docs/language/PACKAGES.md` documents duplicate package manifest keys, invalid dependency keys, and duplicate dependency keys as beta package/workspace diagnostics. See `docs/language/PACKAGES.md:59` through `docs/language/PACKAGES.md:73` and `docs/language/PACKAGES.md:111` through `docs/language/PACKAGES.md:130`.
 - PASS: `docs/language/DIAGNOSTICS.md` includes the new package/workspace diagnostic codes in the project/workspace catalog. See `docs/language/DIAGNOSTICS.md:240` through `docs/language/DIAGNOSTICS.md:279`.
 - PASS: Language and compiler release notes describe beta24 as package manifest identity/dependency diagnostic hardening only. See `docs/language/RELEASE_NOTES.md:44` through `docs/language/RELEASE_NOTES.md:68` and `docs/compiler/RELEASE_NOTES.md:15` through `docs/compiler/RELEASE_NOTES.md:42`.
 - PASS: Language/compiler roadmaps and post-beta roadmap mark beta24 as the current local package/workspace diagnostics slice with registry, lockfile, semver, publishing, optional/dev/target dependencies, ABI/layout, language, runtime, and stdlib work deferred. See `docs/language/ROADMAP.md:11` through `docs/language/ROADMAP.md:33`, `docs/compiler/ROADMAP.md:24` through `docs/compiler/ROADMAP.md:38`, `docs/compiler/ROADMAP.md:722` through `docs/compiler/ROADMAP.md:728`, and `docs/POST_BETA_ROADMAP.md:185` through `docs/POST_BETA_ROADMAP.md:191`.
 ## Verification Commands
 Ran:
 ```bash
 git diff --check
 cargo fmt --check
 cargo test --test package_workspace_discipline_beta24
 cargo test --test project_mode workspace_package_boundaries_are_diagnostics
 cargo test --test project_mode
 rg -n "beta\\.23|beta23|beta\\.24|beta24|1\\.0\\.0-beta\\.2[0-9]|current|Release state|Last updated" README.md docs/language/PACKAGES.md docs/language/DIAGNOSTICS.md docs/language/RELEASE_NOTES.md docs/language/ROADMAP.md docs/compiler/RELEASE_NOTES.md docs/compiler/ROADMAP.md docs/POST_BETA_ROADMAP.md .llm/BETA_24_PACKAGE_MANIFEST_IDENTITY_AND_DEPENDENCY_DISCIPLINE.md compiler/Cargo.toml compiler/Cargo.lock scripts/release-gate.sh
 ```
 Result: all executed checks passed. The focused beta24 test reported 4 passed tests. The full `project_mode` suite reported 36 passed tests.
 ## Final Gate Disposition
 After this review, the controller ran the full release gate:
 ```bash
 ./scripts/release-gate.sh
 ```
 Result: PASS. The gate completed docs/catalog checks, focused beta13-beta24
 tests, full `cargo test`, ignored promotion smoke, ignored binary smoke, and
 ignored LLVM smoke.
 ## Residual Risks
 - No release-blocking residual risks remain. The release gate regenerated and
  checked the standard-library API catalog; publication PDFs were not
  regenerated because this slice does not touch paper sources, and the gate
  verified that the required PDF artifacts are present.
--- a/.llm/reviews/BETA_25_RELEASE_REVIEW.md
+++ b/.llm/reviews/BETA_25_RELEASE_REVIEW.md
@ -1,64 +0,0 @@
 # Beta25 Release Review
 Verdict: PASS.
 ## Findings
 No blocking or non-blocking findings in the re-reviewed scope.
 The prior blocking finding is resolved. `compiler/tests/user_project_conformance_beta25.rs` now covers all 43 top-level fixture roots currently discovered under `examples/projects/` and `examples/workspaces/`: 41 project fixtures plus 2 workspace fixtures. The test also asserts the matrix length, total discovered-test count, sorted path order, and exact inventory completeness against discovered top-level `slovo.toml` fixture roots.
 ## Acceptance Checklist
 - PASS: The conformance matrix covers every current top-level `slovo.toml` fixture root under `examples/projects/` and `examples/workspaces/`.
 - PASS: `assert_matrix_inventory()` asserts the 43-root count, 655 discovered tests, sorted repository-relative path order, exact discovered fixture inventory, and the full expected path/test/run matrix.
 - PASS: The test runs `glagol check`, `glagol test --list`, and stable `glagol test` for every matrix entry.
 - PASS: Deterministic env fixture handling is wired through `configure_conformance_env()`: expected env variables are set to stable values and intentionally-missing env variables are removed before each Glagol command.
 - PASS: `scripts/release-gate.sh` still runs `cargo test --test user_project_conformance_beta25`.
 - PASS: `compiler/Cargo.toml` and `compiler/Cargo.lock` both version `glagol` as `1.0.0-beta.25`.
 - PASS: README, release notes, roadmaps, and the beta25 matrix doc continue to frame the release as tooling/conformance evidence without claiming language, runtime, stdlib, package-manager, stable-schema, ABI/layout, or performance changes.
 ## Verification Commands
 Ran:
 ```bash
 git status --short
 git diff --stat
 sed -n '1,620p' compiler/tests/user_project_conformance_beta25.rs
 find examples/projects -mindepth 2 -maxdepth 2 -name slovo.toml -printf '%h\n'
 find examples/workspaces -mindepth 2 -maxdepth 2 -name slovo.toml -printf '%h\n'
 find examples/projects -mindepth 2 -maxdepth 2 -name slovo.toml -printf '.' | wc -c
 find examples/workspaces -mindepth 2 -maxdepth 2 -name slovo.toml -printf '.' | wc -c
 rg -n "assert_eq!\(MATRIX\.len\(\), 43|discover_fixture_paths|configure_conformance_env|GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT|GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT" compiler/tests/user_project_conformance_beta25.rs
 git diff --check
 cargo fmt --check
 cargo test --test user_project_conformance_beta25
 ```
 Results:
 - `git diff --check`: PASS.
 - `cargo fmt --check`: PASS.
 - `cargo test --test user_project_conformance_beta25`: PASS, 1 test passed.
 - Fixture inventory counts: 41 top-level project roots and 2 top-level workspace roots.
 - Matrix inventory assertion: covers 43 roots and 655 discovered tests.
 ## Residual Risks
 No release-blocking residual risks remain for this slice.
 ## Final Gate Disposition
 The controller reran the full release gate after staging the generated
 `docs/language/STDLIB_API.md` beta25 catalog update:
 ```bash
 ./scripts/release-gate.sh
 ```
 Result: PASS. The gate reported:
 ```text
 release gate passed: docs, stdlib API catalog, fmt, tests, promotion, binary, and LLVM smoke checks completed
 ```
--- a/README.md
+++ b/README.md
@ -6,7 +6,7 @@ This repository is the canonical public monorepo for the language design,
 standard library source, compiler, runtime, examples, benchmarks, and technical
 documents.
-Current release: `1.0.0-beta.25`.
+Current release: `1.0.0-beta.20`.
 ## Repository Layout
@ -24,7 +24,7 @@ scripts/        local release and document tooling
 ## Beta Scope
-`1.0.0-beta.25` keeps the `1.0.0-beta` language baseline, includes the
+`1.0.0-beta.20` keeps the `1.0.0-beta` language baseline, includes the
 `1.0.0-beta.1` tooling/install hardening slice, the `1.0.0-beta.2`
 runtime/resource foundation bundle, the `1.0.0-beta.3` standard-library
 stabilization bundle, the `1.0.0-beta.4` language-usability diagnostics
@ -41,15 +41,8 @@ slice, the `1.0.0-beta.13` diagnostic catalog and schema policy slice, the
 ledger, the `1.0.0-beta.16` string scanning and token boundary foundation,
 the `1.0.0-beta.17` JSON primitive scalar parsing foundation, the
 `1.0.0-beta.18` JSON string token parsing foundation, the
-`1.0.0-beta.19` test discovery and user-project conformance foundation, the
+`1.0.0-beta.19` test discovery and user-project conformance foundation, and
-`1.0.0-beta.20` string search and ASCII trim foundation, and the
+the `1.0.0-beta.20` string search and ASCII trim foundation.
 `1.0.0-beta.21` JSON document scalar parsing foundation, plus the
 `1.0.0-beta.22` run manifest and execution report hardening slice, and the
 `1.0.0-beta.23` standard-library stability tier ledger and catalog alignment
 slice, and the `1.0.0-beta.24` package manifest identity and local dependency
 diagnostic hardening slice, plus the `1.0.0-beta.25` user-project
 conformance matrix evidence slice.
 The language baseline supports practical local command-line, file, and
 loopback-network programs with:
@ -64,8 +57,7 @@ loopback-network programs with:
  `SLOVO_STD_PATH`
 - beta-scoped loopback TCP handles through `std.net`
 - JSON string quoting, compact JSON text construction, primitive scalar token
-  parsing, ASCII JSON string-token parsing, and scalar JSON document parsing
+  parsing, and ASCII JSON string-token parsing through `std.json`
  through `std.json`
 - byte-oriented string search and ASCII edge trimming through `std.string`
 - hosted native builds through LLVM IR, Clang, and `runtime/runtime.c`
@ -73,13 +65,6 @@ The generated standard-library API catalog is a beta discovery aid: it lists
 exported helper signatures from `lib/std/*.slo`, normalizes module-local
 concrete aliases such as `VecI32` and `ResultU64` to their concrete public
 types, and omits non-exported helpers and `(type ...)` aliases.
 The companion
 [`docs/language/STDLIB_TIERS.md`](docs/language/STDLIB_TIERS.md) ledger
 defines the public tier labels `beta-supported`, `experimental`, and
 `internal`, marks JSON, loopback networking, random/time, and filesystem
 resource-handle helpers as experimental domains, and keeps concrete vector
 modules as beta-supported concrete lanes rather than a generic collections
 freeze.
 `glagol symbols <file.slo|project|workspace>` emits deterministic
 editor-facing S-expression metadata for modules, imports, exports, aliases,
 structs, enums, functions, tests, source spans, and workspace package names.
@ -87,11 +72,6 @@ structs, enums, functions, tests, source spans, and workspace package names.
 API sections for local package and module documentation: exact exported
 function signatures, exported struct fields, exported enum variants and payload
 types, non-export filtering, and module-local alias normalization.
 The `1.0.0-beta.22` tooling slice adds an additive run-report block to
 `glagol run --manifest` artifact manifests so local evidence can record the
 program exit status, captured stdout, captured stderr, and forwarded program
 arguments. This is beta CLI evidence hardening only: it does not add language
 or stdlib features and does not freeze the artifact-manifest schema.
 The `1.0.0-beta.12` vector parity slice adds source-authored helper coverage
 only: `std.vec_i64` gains `count_of`, `starts_with`, `without_prefix`,
 `ends_with`, and `without_suffix`, while `std.vec_f64` gains `count_of`.
@ -141,19 +121,18 @@ concrete numeric primitives, and exact `null` only. Numeric and boolean parse
 helpers consume one isolated JSON primitive token: no leading/trailing
 whitespace, no leading `+`, no leading-zero integer form except `0`, and no
 non-finite f64 values. This is not full JSON parsing: object/array parsing,
-tokenizers, recursive `JsonValue`, document parsing beyond the beta21 scalar
+tokenizers, recursive `JsonValue`, whitespace-tolerant document parsing,
-document helpers, schema validation, streaming, Unicode escape handling,
+schema validation, streaming, Unicode escape handling, stable ABI/layout, and
-stable ABI/layout, and a stable stdlib/API freeze remain deferred.
+a stable stdlib/API freeze remain deferred.
 The `1.0.0-beta.18` JSON string token parsing foundation adds
 `std.json.parse_string_value_result` as a thin source facade over the matching
 promoted runtime name. It consumes one already-isolated ASCII JSON string token
 with exact quotes and no leading/trailing whitespace, decodes the simple JSON
 escapes `\"`, `\\`, `\/`, `\b`, `\f`, `\n`, `\r`, and `\t`, and returns
-`err 1` for ordinary parse failure. Complete JSON document parsing beyond the
+`err 1` for ordinary parse failure. Full JSON document parsing, object/array
-beta21 scalar document helpers, object/array parsing, tokenizer APIs, Unicode
+parsing, tokenizer APIs, Unicode escape decoding/normalization, embedded NUL
-escape decoding/normalization, embedded NUL policy, stable ABI/layout, and a
+policy, stable ABI/layout, and a stable stdlib/API freeze remain deferred.
 stable stdlib/API freeze remain deferred.
 The `1.0.0-beta.19` test discovery and user-project conformance foundation
 adds `glagol test --list <file|project|workspace>` plus legacy
@ -170,59 +149,10 @@ helpers over the existing byte string primitives. Search is byte-oriented,
 empty needles match at the first index and at `(len value)` for last search,
 and ASCII trimming removes only bytes `9`, `10`, `11`, `12`, `13`, and `32`.
 The `1.0.0-beta.21` JSON document scalar parsing foundation adds
 source-authored `std.json.parse_*_document_result` helpers for string, bool,
 `i32`, `u32`, `i64`, `u64`, `f64`, and exact `null` scalar JSON documents.
 Each helper trims ASCII whitespace around the whole document with
 `std.string.trim_ascii`, then delegates to the already released exact JSON
 value-token parser for that scalar family. This scope does not add new
 compiler-known runtime names, object/array parsing, recursive `JsonValue`,
 tokenizer objects, maps/sets, streaming, Unicode escape decoding beyond the
 existing string-token behavior, embedded NUL policy, stable ABI/layout, or a
 stable stdlib/API freeze.
 The `1.0.0-beta.22` run manifest and execution report hardening slice extends
 `glagol run --manifest` artifact manifests with additive run-report evidence:
 the executed program's exit status, captured stdout, captured stderr, and
 forwarded user-program arguments. This release does not add source-language
 syntax, standard-library helpers, compiler-known runtime names, runtime
 capabilities, package behavior, stable artifact-manifest schema guarantees,
 stable ABI/layout, or a stable stdlib/API freeze.
 The `1.0.0-beta.23` standard-library stability tier ledger and catalog
 alignment slice adds the public
 [`STDLIB_TIERS.md`](docs/language/STDLIB_TIERS.md) maturity ledger beside the
 generated [`STDLIB_API.md`](docs/language/STDLIB_API.md) signature catalog.
 It is documentation/catalog tooling clarity only: no source-language syntax,
 stdlib helpers, compiler-known runtime names, runtime behavior, stable manifest
 schema, stable Markdown schema, stable ABI/layout, or stable stdlib/API freeze
 changes. The generated catalog and release gate now expose and check tier
 metadata.
 The `1.0.0-beta.24` package manifest identity and local dependency discipline
 slice tightens local manifest diagnostics only: duplicate package manifest
 keys, invalid dependency keys, and duplicate dependency keys are explicit beta
 package/workspace diagnostics. It does not add remote registries, lockfiles,
 semantic-version solving, package publishing, optional/dev/target
 dependencies, stable package ABI/layout, source-language changes, runtime
 changes, or standard-library changes.
 The `1.0.0-beta.25` user-project conformance matrix slice adds deterministic
 tooling/readiness evidence over the existing `examples/projects/` and
 `examples/workspaces/` inventories. It currently covers all 43 top-level
 fixture roots and 655 discovered tests through ordinary `check`,
 `test --list`, and stable `test` entry points. The matrix is for ordinary
 project and workspace usage evidence only: it does not add source-language
 syntax or semantics, standard-library helpers, runtime behavior, package
 manager or registry behavior, lockfile behavior, semantic-version solving,
 stable schema guarantees, or performance claims.
 Still deferred before stable: executable generics, generic aliases, maps/sets,
-broad package registry semantics, stable artifact-manifest schema, stable
+broad package registry semantics, stable Markdown schema, stable stdlib/API
 Markdown schema, stable conformance-matrix schema, stable stdlib/API
 compatibility freeze, DNS/TLS/async networking, LSP/watch guarantees, SARIF
-and daemon protocols, stable `1.0.0`
+and daemon protocols, stable `1.0.0` diagnostics freeze,
 diagnostics freeze,
 re-exports/globs/hierarchical modules, mutable vectors, slice/view APIs,
 iterators, additional compiler-known runtime names, stable ABI and layout,
 performance claims, stable benchmark JSON metadata schema, and runtime changes
@ -352,31 +282,6 @@ package/dependency summary, new workspace templates declare
 local-package rules. Remote registries, lockfiles, semantic-version solving,
 package publishing, and stable package ABI/layout remain deferred.
 ## 1.0.0-beta.24 Package Manifest Identity And Dependency Discipline
 The `1.0.0-beta.24` release keeps the local package model closed and local. It
 hardens diagnostics for manifest identity/dependency mistakes only: duplicate
 package manifest keys, invalid dependency keys, and duplicate dependency keys
 are reported explicitly.
 This scope does not add a remote registry, lockfile, semantic-version solver,
 package publishing flow, optional/dev/target dependencies, stable package
 ABI/layout, source-language behavior, runtime behavior, or standard-library
 behavior.
 ## 1.0.0-beta.25 User Project Conformance Matrix
 The `1.0.0-beta.25` release adds deterministic tooling evidence for the
 existing user-shaped examples under `examples/projects/` and
 `examples/workspaces/`. The conformance matrix is sorted by repository path and
 records ordinary `check`, `test --list`, and stable `test` behavior for all
 43 top-level fixture roots and 655 discovered tests.
 This scope is stable-readiness evidence only. It adds no source-language
 change, standard-library helper change, runtime behavior change, package
 manager or registry behavior, lockfile behavior, semantic-version solving,
 stable schema freeze, or performance claim.
 ## 1.0.0-beta.6 Networking Foundation
 The `1.0.0-beta.6` release adds a narrow blocking loopback TCP foundation:
@ -530,36 +435,6 @@ This scope adds no compiler-known runtime names. It does not claim Unicode
 scalar, grapheme, case-folding, locale, regex, tokenizer, mutable string,
 language slice/view, stable ABI/layout, or stable stdlib/API semantics.
 ## 1.0.0-beta.21 JSON Document Scalar Parsing Foundation
 The `1.0.0-beta.21` scope extends `std.json` with source-authored
 whole-document scalar helpers:
 `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`.
 The helpers accept leading and trailing ASCII whitespace around a single
 scalar document by composing with `std.string.trim_ascii`; trailing
 non-whitespace still fails through the existing exact value-token parsers.
 This scope does not add object/array parsing, recursive JSON values, parser
 objects, maps/sets, streaming, Unicode escape decoding beyond the existing
 string-token behavior, embedded NUL policy, new compiler-known runtime names,
 stable ABI/layout, or stable stdlib/API semantics.
 ## 1.0.0-beta.22 Run Manifest And Execution Report Hardening
 The `1.0.0-beta.22` scope hardens `glagol run --manifest` evidence by adding
 an additive run-report block to run-mode artifact manifests. The block records
 the executed program's exit status, captured stdout, captured stderr, and
 forwarded program arguments.
 This is tooling/CLI evidence work only. It does not add language syntax,
 stdlib helpers, compiler-known runtime names, runtime C capabilities, package
 or import behavior, stable artifact-manifest schema guarantees, stable
 ABI/layout, or stable stdlib/API semantics.
 ## 1.0.0-beta.15 Reserved Generic Collection Boundary Hardening And Collection Ledger
 The `1.0.0-beta.15` release documents the current concrete collection and
--- a/compiler/Cargo.lock
+++ b/compiler/Cargo.lock
@ -4,4 +4,4 @@ version = 3
 [[package]]
 name = "glagol"
-version = "1.0.0-beta.25"
+version = "1.0.0-beta.20"
--- a/compiler/Cargo.toml
+++ b/compiler/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "glagol"
-version = "1.0.0-beta.25"
+version = "1.0.0-beta.20"
 edition = "2021"
 description = "Glagol, the first compiler for the Slovo language"
 license = "MIT OR Apache-2.0"
--- a/compiler/src/main.rs
+++ b/compiler/src/main.rs
@ -892,15 +892,14 @@ fn run_native_from_llvm(
    let _ = io::stdout().write_all(&run_output.stdout);
    let _ = io::stderr().write_all(&run_output.stderr);
    let stdout = String::from_utf8_lossy(&run_output.stdout).to_string();
-    let stderr = String::from_utf8_lossy(&run_output.stderr).to_string();
+    write_manifest_if_requested_with_foreign_imports(
    let exit_status = run_output.status.code();
    write_manifest_if_requested_with_run_report(
        &invocation,
        run_output.status.success(),
        PrimaryOutput::Stdout {
            kind: Mode::Run.output_kind(),
            text: &stdout,
        },
        None,
        Some(BuildInfo {
            clang: &native.clang,
            runtime: &native.runtime,
@ -908,14 +907,8 @@ fn run_native_from_llvm(
        }),
        &foreign_imports,
        project_artifact.as_ref(),
        RunReport {
            exit_status,
            stdout: &stdout,
            stderr: &stderr,
            args: &invocation.run_args,
        },
    );
-    process::exit(exit_status.unwrap_or(1));
+    process::exit(run_output.status.code().unwrap_or(1));
 }
 struct NativeBuild {
@ -1643,7 +1636,6 @@ fn exit_parse_error(err: ParseError, command_line: &str) -> ! {
                PrimaryOutput::Diagnostics { text: &stderr },
                None,
                None,
                None,
                &[],
                None,
                err.diagnostics,
@ -1897,13 +1889,6 @@ struct TestSummary {
    filter: Option<String>,
 }
 struct RunReport<'a> {
    exit_status: Option<i32>,
    stdout: &'a str,
    stderr: &'a str,
    args: &'a [String],
 }
 fn test_summary_from_report(report: test_runner::TestReport) -> TestSummary {
    TestSummary {
        total_discovered: report.total_discovered,
@ -2006,34 +1991,6 @@ fn write_manifest_if_requested_with_foreign_imports(
            success,
            primary_output,
            test_summary,
            None,
            build_info,
            foreign_imports,
            project_info,
            invocation.diagnostics,
        );
        write_manifest_or_exit(manifest_path, &manifest);
    }
 }
 fn write_manifest_if_requested_with_run_report(
    invocation: &Invocation,
    success: bool,
    primary_output: PrimaryOutput<'_>,
    build_info: Option<BuildInfo<'_>>,
    foreign_imports: &[project::ProjectArtifactCImport],
    project_info: Option<&project::ProjectArtifact>,
    run_report: RunReport<'_>,
 ) {
    if let Some(manifest_path) = invocation.manifest_path.as_deref() {
        let manifest = render_manifest(
            Some(&invocation.path),
            &invocation.command_line,
            Some(invocation.manifest_mode_name.as_str()),
            success,
            primary_output,
            None,
            Some(run_report),
            build_info,
            foreign_imports,
            project_info,
@ -2057,7 +2014,6 @@ fn render_manifest(
    success: bool,
    primary_output: PrimaryOutput<'_>,
    test_summary: Option<TestSummary>,
    run_report: Option<RunReport<'_>>,
    build_info: Option<BuildInfo<'_>>,
    foreign_imports: &[project::ProjectArtifactCImport],
    project_info: Option<&project::ProjectArtifact>,
@ -2159,34 +2115,6 @@ fn render_manifest(
        out.push_str("  )");
    }
    if let Some(report) = run_report {
        out.push('\n');
        out.push_str("  (run-report\n");
        match report.exit_status {
            Some(status) => out.push_str(&format!("    (exit-status {})\n", status)),
            None => out.push_str("    (exit-status null)\n"),
        }
        out.push_str(&format!(
            "    (stdout {})\n",
            diag::render_string(report.stdout)
        ));
        out.push_str(&format!(
            "    (stderr {})\n",
            diag::render_string(report.stderr)
        ));
        out.push_str("    (args");
        if report.args.is_empty() {
            out.push_str(")\n");
        } else {
            out.push('\n');
            for arg in report.args {
                out.push_str(&format!("      (arg {})\n", diag::render_string(arg)));
            }
            out.push_str("    )\n");
        }
        out.push_str("  )");
    }
    if let Some(build) = build_info {
        out.push('\n');
        out.push_str("  (hosted-build\n");
--- a/compiler/src/project.rs
+++ b/compiler/src/project.rs
@ -1124,16 +1124,7 @@ fn parse_manifest(path: PathBuf, source: String) -> Result<Manifest, Vec<Diagnos
        };
        match key {
-            "name" => set_manifest_key(
+            "name" => set_manifest_key(&file, &mut errors, &mut name, parsed, line.span, "name"),
                &file,
                &mut errors,
                &mut name,
                parsed,
                line.span,
                "name",
                "ProjectManifestInvalid",
                "project",
            ),
            "source_root" => set_manifest_key(
                &file,
                &mut errors,
@ -1141,19 +1132,8 @@ fn parse_manifest(path: PathBuf, source: String) -> Result<Manifest, Vec<Diagnos
                parsed,
                line.span,
                "source_root",
                "ProjectManifestInvalid",
                "project",
            ),
            "entry" => set_manifest_key(
                &file,
                &mut errors,
                &mut entry,
                parsed,
                line.span,
                "entry",
                "ProjectManifestInvalid",
                "project",
            ),
            "entry" => set_manifest_key(&file, &mut errors, &mut entry, parsed, line.span, "entry"),
            _ => errors.push(
                Diagnostic::new(
                    &file,
@ -1432,7 +1412,6 @@ fn parse_package_manifest(
    let mut source_root = None::<String>;
    let mut entry = None::<String>;
    let mut dependencies = Vec::new();
    let mut dependency_keys = BTreeSet::<String>::new();
    for line in manifest_lines(&source) {
        let trimmed = line.text.trim();
@ -1510,8 +1489,6 @@ fn parse_package_manifest(
                        parsed,
                        line.span,
                        "name",
                        "PackageManifestInvalid",
                        "package",
                    ),
                    "version" => set_manifest_key(
                        &file,
@ -1520,8 +1497,6 @@ fn parse_package_manifest(
                        parsed,
                        line.span,
                        "version",
                        "PackageManifestInvalid",
                        "package",
                    ),
                    "source_root" => set_manifest_key(
                        &file,
@ -1530,8 +1505,6 @@ fn parse_package_manifest(
                        parsed,
                        line.span,
                        "source_root",
                        "PackageManifestInvalid",
                        "package",
                    ),
                    "entry" => set_manifest_key(
                        &file,
@ -1540,8 +1513,6 @@ fn parse_package_manifest(
                        parsed,
                        line.span,
                        "entry",
                        "PackageManifestInvalid",
                        "package",
                    ),
                    other => errors.push(
                        Diagnostic::new(
@ -1553,44 +1524,12 @@ fn parse_package_manifest(
                    ),
                }
            }
-            "dependencies" => {
+            "dependencies" => match parse_dependency_path(value) {
-                let valid_key = if is_project_name(key) {
+                Some(path) => dependencies.push(PackageDependency {
                    true
                } else {
                    errors.push(
                        Diagnostic::new(
                            &file,
                            "InvalidPackageDependencyName",
                            format!(
                                "package dependency name `{}` must start with `a-z` and contain only `a-z`, `0-9`, and `-`",
                                key
                            ),
                        )
                        .with_span(line.span),
                    );
                    false
                };
                let unique_key = if dependency_keys.insert(key.to_string()) {
                    true
                } else {
                    errors.push(
                        Diagnostic::new(
                            &file,
                            "DuplicatePackageDependencyName",
                            format!("duplicate package dependency name `{}`", key),
                        )
                        .with_span(line.span),
                    );
                    false
                };
                match parse_dependency_path(value) {
                    Some(path) if valid_key && unique_key => dependencies.push(PackageDependency {
                    key: key.to_string(),
                    path,
                    span: line.span,
                }),
                    Some(_) => {}
                None => errors.push(
                    Diagnostic::new(
                        &file,
@ -1599,8 +1538,7 @@ fn parse_package_manifest(
                    )
                    .with_span(line.span),
                ),
-                }
+            },
            }
            "" | "project" => errors.push(
                Diagnostic::new(
                    &file,
@ -1756,15 +1694,13 @@ fn set_manifest_key(
    value: String,
    span: Span,
    key: &str,
    code: &'static str,
    manifest_kind: &str,
 ) {
    if slot.replace(value).is_some() {
        errors.push(
            Diagnostic::new(
                file,
-                code,
+                "ProjectManifestInvalid",
-                format!("duplicate {} manifest key `{}`", manifest_kind, key),
+                format!("duplicate project manifest key `{}`", key),
            )
            .with_span(span),
        );
--- a/compiler/tests/package_workspace_discipline_beta24.rs
+++ b/compiler/tests/package_workspace_discipline_beta24.rs
@ -1,229 +0,0 @@
 use std::{
    fs,
    path::PathBuf,
    process::{Command, Output},
    sync::atomic::{AtomicUsize, Ordering},
    time::{SystemTime, UNIX_EPOCH},
 };
 static NEXT_WORKSPACE_ID: AtomicUsize = AtomicUsize::new(0);
 #[test]
 fn duplicate_package_keys_report_package_manifest_invalid() {
    let workspace = write_workspace(
        "duplicate-package-key",
        "[workspace]\nmembers = [\"packages/app\"]\n",
        &[WorkspacePackageSpec {
            member: "packages/app",
            manifest: "[package]\nname = \"app\"\nname = \"other\"\nversion = \"0.1.0\"\n",
            modules: &[("main", "(module main)\n\n(fn main () -> i32\n  0)\n")],
        }],
    );
    let output = run_glagol([
        "--json-diagnostics".as_ref(),
        "check".as_ref(),
        workspace.as_os_str(),
    ]);
    assert_exit_code("duplicate package key", &output, 1);
    assert_json_diagnostic_code("duplicate package key", &output, "PackageManifestInvalid");
    assert_json_diagnostic_code_absent("duplicate package key", &output, "ProjectManifestInvalid");
 }
 #[test]
 fn invalid_dependency_key_reports_invalid_package_dependency_name() {
    let workspace = write_workspace(
        "invalid-dependency-key",
        "[workspace]\nmembers = [\"packages/app\"]\n",
        &[WorkspacePackageSpec {
            member: "packages/app",
            manifest: "[package]\nname = \"app\"\nversion = \"0.1.0\"\n\n[dependencies]\nBad_Name = { path = \"../util\" }\n",
            modules: &[("main", "(module main)\n\n(fn main () -> i32\n  0)\n")],
        }],
    );
    let output = run_glagol([
        "--json-diagnostics".as_ref(),
        "check".as_ref(),
        workspace.as_os_str(),
    ]);
    assert_exit_code("invalid dependency key", &output, 1);
    assert_json_diagnostic_code(
        "invalid dependency key",
        &output,
        "InvalidPackageDependencyName",
    );
 }
 #[test]
 fn duplicate_dependency_keys_report_duplicate_package_dependency_name() {
    let workspace = write_workspace(
        "duplicate-dependency-key",
        "[workspace]\nmembers = [\"packages/app\"]\n",
        &[WorkspacePackageSpec {
            member: "packages/app",
            manifest: "[package]\nname = \"app\"\nversion = \"0.1.0\"\n\n[dependencies]\nutil = { path = \"../util\" }\nutil = { path = \"../util-again\" }\n",
            modules: &[("main", "(module main)\n\n(fn main () -> i32\n  0)\n")],
        }],
    );
    let output = run_glagol([
        "--json-diagnostics".as_ref(),
        "check".as_ref(),
        workspace.as_os_str(),
    ]);
    assert_exit_code("duplicate dependency key", &output, 1);
    assert_json_diagnostic_code(
        "duplicate dependency key",
        &output,
        "DuplicatePackageDependencyName",
    );
 }
 #[test]
 fn valid_dependency_identity_checks_cleanly() {
    let workspace = write_workspace(
        "valid-dependency-identity",
        "[workspace]\nmembers = [\"packages/app\", \"packages/util\"]\n",
        &[
            WorkspacePackageSpec {
                member: "packages/util",
                manifest: "[package]\nname = \"util\"\nversion = \"0.1.0\"\n",
                modules: &[(
                    "util",
                    "(module util (export answer))\n\n(fn answer () -> i32\n  42)\n",
                )],
            },
            WorkspacePackageSpec {
                member: "packages/app",
                manifest: "[package]\nname = \"app\"\nversion = \"0.1.0\"\n\n[dependencies]\nutil = { path = \"../util\" }\n",
                modules: &[(
                    "main",
                    "(module main)\n\n(import util.util (answer))\n\n(fn main () -> i32\n  (answer))\n",
                )],
            },
        ],
    );
    let output = run_glagol(["check".as_ref(), workspace.as_os_str()]);
    assert_success_stdout("valid dependency identity", output, "");
 }
 struct WorkspacePackageSpec<'a> {
    member: &'a str,
    manifest: &'a str,
    modules: &'a [(&'a str, &'a str)],
 }
 fn write_workspace(
    name: &str,
    workspace_manifest: &str,
    packages: &[WorkspacePackageSpec<'_>],
 ) -> PathBuf {
    let root = unique_path(name);
    fs::create_dir_all(&root).expect("create workspace root");
    fs::write(root.join("slovo.toml"), workspace_manifest).expect("write workspace manifest");
    for package in packages {
        let package_root = root.join(package.member);
        let src = package_root.join("src");
        fs::create_dir_all(&src).expect("create workspace package src");
        fs::write(package_root.join("slovo.toml"), package.manifest)
            .expect("write workspace package manifest");
        for (module, source) in package.modules {
            fs::write(src.join(format!("{}.slo", module)), source)
                .expect("write workspace package module");
        }
    }
    root
 }
 fn unique_path(name: &str) -> PathBuf {
    let id = NEXT_WORKSPACE_ID.fetch_add(1, Ordering::SeqCst);
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|duration| duration.as_nanos())
        .unwrap_or(0);
    std::env::temp_dir().join(format!(
        "glagol-package-workspace-discipline-beta24-{}-{}-{}-{}",
        std::process::id(),
        nanos,
        id,
        name
    ))
 }
 fn run_glagol<I, S>(args: I) -> Output
 where
    I: IntoIterator<Item = S>,
    S: AsRef<std::ffi::OsStr>,
 {
    Command::new(env!("CARGO_BIN_EXE_glagol"))
        .args(args)
        .output()
        .expect("run glagol")
 }
 fn assert_success_stdout(context: &str, output: Output, expected: &str) {
    assert!(
        output.status.success(),
        "{} failed\nstdout:\n{}\nstderr:\n{}",
        context,
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(
        String::from_utf8_lossy(&output.stdout),
        expected,
        "{} stdout mismatch",
        context
    );
    assert!(
        output.stderr.is_empty(),
        "{} wrote stderr:\n{}",
        context,
        String::from_utf8_lossy(&output.stderr)
    );
 }
 fn assert_exit_code(context: &str, output: &Output, expected: i32) {
    assert_eq!(
        output.status.code(),
        Some(expected),
        "{} exit code mismatch\nstdout:\n{}\nstderr:\n{}",
        context,
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
 }
 fn assert_json_diagnostic_code(context: &str, output: &Output, expected: &str) {
    let diagnostics = diagnostic_text(output);
    assert!(
        diagnostics.contains(&format!(r#""code":"{}""#, expected)),
        "{} did not report `{}`:\n{}",
        context,
        expected,
        diagnostics
    );
 }
 fn assert_json_diagnostic_code_absent(context: &str, output: &Output, unexpected: &str) {
    let diagnostics = diagnostic_text(output);
    assert!(
        !diagnostics.contains(&format!(r#""code":"{}""#, unexpected)),
        "{} unexpectedly reported `{}`:\n{}",
        context,
        unexpected,
        diagnostics
    );
 }
 fn diagnostic_text(output: &Output) -> String {
    format!(
        "{}{}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    )
 }
--- a/compiler/tests/promotion_gate.rs
+++ b/compiler/tests/promotion_gate.rs
@ -1229,14 +1229,6 @@ const STANDARD_JSON_SOURCE_FACADE_ALPHA: &[&str] = &[
    "parse_u64_value_result",
    "parse_f64_value_result",
    "parse_null_value_result",
    "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",
    "parse_null_document_result",
    "field_string",
    "field_bool",
    "field_i32",
@ -1273,7 +1265,6 @@ const STANDARD_JSON_RUNTIME_NAMES: &[&str] = &[
 ];
 const STANDARD_JSON_ALLOWED_STD_NAMES: &[&str] = &[
    "(import std.string (trim_ascii))",
    "std.json.quote_string",
    "std.string.concat",
    "std.num.i32_to_string",
@ -1290,17 +1281,6 @@ const STANDARD_JSON_ALLOWED_STD_NAMES: &[&str] = &[
    "std.json.parse_f64_value_result",
 ];
 const STANDARD_JSON_DOCUMENT_SCALAR_BETA21: &[&str] = &[
    "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",
    "parse_null_document_result",
 ];
 const STANDARD_PROCESS_SOURCE_FACADE_ALPHA: &[&str] = &[
    "argc",
    "arg",
@ -4478,7 +4458,6 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) {
    );
    for source in [&slovo_json, &glagol_json] {
        assert_deferred_json_surface_absent(source, "standard json facade");
        assert_json_document_scalar_helpers_are_source_authored(source, "standard json facade");
    }
    for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA {
        assert!(
@ -7337,13 +7316,10 @@ fn assert_project_std_import_json_tooling_matches_fixture(project: &Path) {
            "test \"explicit std json primitive scalar parse failure facade\" ... ok\n",
            "test \"explicit std json string token parse success facade\" ... ok\n",
            "test \"explicit std json string token parse failure facade\" ... ok\n",
            "test \"explicit std json document parse trimmed success facade\" ... ok\n",
            "test \"explicit std json document parse plain success facade\" ... ok\n",
            "test \"explicit std json document parse trailing failure facade\" ... ok\n",
            "test \"explicit std json fields facade\" ... ok\n",
            "test \"explicit std json arrays objects facade\" ... ok\n",
            "test \"explicit std json facade all\" ... ok\n",
-            "12 test(s) passed\n",
+            "9 test(s) passed\n",
        ),
    );
 }
@ -9551,13 +9527,10 @@ fn assert_project_std_layout_local_json_tooling_matches_fixture(project: &Path)
            "test \"explicit local json primitive scalar parse failure facade\" ... ok\n",
            "test \"explicit local json string token parse success facade\" ... ok\n",
            "test \"explicit local json string token parse failure facade\" ... ok\n",
            "test \"explicit local json document parse trimmed success facade\" ... ok\n",
            "test \"explicit local json document parse plain success facade\" ... ok\n",
            "test \"explicit local json document parse trailing failure facade\" ... ok\n",
            "test \"explicit local json fields facade\" ... ok\n",
            "test \"explicit local json arrays objects facade\" ... ok\n",
            "test \"explicit local json facade all\" ... ok\n",
-            "12 test(s) passed\n",
+            "9 test(s) passed\n",
        ),
        "std layout local json project test",
    );
@ -10751,34 +10724,6 @@ fn assert_deferred_json_surface_absent(source: &str, context: &str) {
    }
 }
 fn assert_json_document_scalar_helpers_are_source_authored(source: &str, context: &str) {
    for helper in STANDARD_JSON_DOCUMENT_SCALAR_BETA21 {
        assert!(
            !source.contains(&format!("std.json.{}", helper)),
            "{} must keep `{}` source-authored, not compiler-known",
            context,
            helper
        );
    }
    for private_prefix in [
        "__glagol_json_parse_string_document",
        "__glagol_json_parse_bool_document",
        "__glagol_json_parse_i32_document",
        "__glagol_json_parse_u32_document",
        "__glagol_json_parse_i64_document",
        "__glagol_json_parse_u64_document",
        "__glagol_json_parse_f64_document",
        "__glagol_json_parse_null_document",
    ] {
        assert!(
            !source.contains(private_prefix),
            "{} must not introduce private JSON document runtime symbol `{}`",
            context,
            private_prefix
        );
    }
 }
 fn repo_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .parent()
--- a/compiler/tests/run_manifest_beta22.rs
+++ b/compiler/tests/run_manifest_beta22.rs
@ -1,267 +0,0 @@
 use std::{
    env, fs,
    path::{Path, PathBuf},
    process::{Command, Output},
    sync::atomic::{AtomicUsize, Ordering},
 };
 static NEXT_FIXTURE_ID: AtomicUsize = AtomicUsize::new(0);
 #[test]
 fn run_manifest_records_success_report_stdout_and_program_args() {
    let Some(clang) = find_clang() else {
        eprintln!("skipping run manifest success report: set GLAGOL_CLANG or install clang");
        return;
    };
    let source = write_fixture(
        "success",
        r#"
 (module main)
 (fn main () -> i32
  (print_string "beta22-out")
  0)
 "#,
        "slo",
    );
    let manifest_path = temp_path("success-manifest", "manifest.slo");
    let mut command = Command::new(compiler_path());
    command
        .arg("run")
        .arg(&source)
        .arg("--manifest")
        .arg(&manifest_path)
        .arg("--")
        .arg("alpha")
        .arg("two words")
        .arg("--literal")
        .env("GLAGOL_CLANG", &clang);
    configure_clang_runtime_env(&mut command, &clang);
    let output = command.output().expect("run glagol success manifest");
    assert_success_stdout("run manifest success", &output, "beta22-out\n");
    let manifest = read_manifest(&manifest_path);
    assert!(
        manifest.contains("  (mode run)\n")
            && manifest.contains("  (success true)\n")
            && manifest.contains("  (run-report\n")
            && manifest.contains("    (exit-status 0)\n")
            && manifest.contains("    (stdout \"beta22-out\\n\")\n")
            && manifest.contains("    (stderr \"\")\n")
            && manifest.contains("      (arg \"alpha\")\n")
            && manifest.contains("      (arg \"two words\")\n")
            && manifest.contains("      (arg \"--literal\")\n"),
        "successful run manifest mismatch:\n{}",
        manifest
    );
 }
 #[test]
 fn run_manifest_records_nonzero_report_and_preserves_program_stderr() {
    let Some(clang) = find_clang() else {
        eprintln!("skipping run manifest nonzero report: set GLAGOL_CLANG or install clang");
        return;
    };
    let source = write_fixture(
        "nonzero",
        r#"
 (module main)
 (import_c beta22_stderr () -> i32)
 (fn emit_stderr () -> i32
  (unsafe
    (beta22_stderr)))
 (fn main () -> i32
  (emit_stderr)
  7)
 "#,
        "slo",
    );
    let c_source = write_fixture(
        "nonzero-stderr",
        r#"
 #include <stdio.h>
 int beta22_stderr(void) {
    fputs("beta22-err\n", stderr);
    return 0;
 }
 "#,
        "c",
    );
    let manifest_path = temp_path("nonzero-manifest", "manifest.slo");
    let mut command = Command::new(compiler_path());
    command
        .arg("run")
        .arg(&source)
        .arg("--link-c")
        .arg(&c_source)
        .arg("--manifest")
        .arg(&manifest_path)
        .env("GLAGOL_CLANG", &clang);
    configure_clang_runtime_env(&mut command, &clang);
    let output = command.output().expect("run glagol nonzero manifest");
    assert_exit_code("run manifest nonzero", &output, 7);
    assert_eq!(output.stdout, b"", "nonzero run stdout drifted");
    assert_eq!(output.stderr, b"beta22-err\n", "nonzero run stderr drifted");
    let manifest = read_manifest(&manifest_path);
    assert!(
        manifest.contains("  (mode run)\n")
            && manifest.contains("  (success false)\n")
            && manifest.contains("  (run-report\n")
            && manifest.contains("    (exit-status 7)\n")
            && manifest.contains("    (stdout \"\")\n")
            && manifest.contains("    (stderr \"beta22-err\\n\")\n")
            && manifest.contains("    (args)\n"),
        "nonzero run manifest mismatch:\n{}",
        manifest
    );
 }
 #[test]
 fn run_manifest_source_failure_does_not_record_fake_run_report() {
    let source = write_fixture(
        "source-failure",
        r#"
 (module main)
 (fn main () -> i32
  true)
 "#,
        "slo",
    );
    let manifest_path = temp_path("source-failure-manifest", "manifest.slo");
    let output = run_glagol([
        "run".as_ref(),
        source.as_os_str(),
        "--manifest".as_ref(),
        manifest_path.as_os_str(),
    ]);
    assert_exit_code("run manifest source failure", &output, 1);
    let manifest = read_manifest(&manifest_path);
    assert!(
        manifest.contains("  (mode run)\n")
            && manifest.contains("  (success false)\n")
            && manifest.contains("    (kind diagnostics)\n")
            && manifest.contains("TypeMismatch")
            && !manifest.contains("  (run-report\n"),
        "source failure manifest included fake run report:\n{}",
        manifest
    );
 }
 fn run_glagol<const N: usize>(args: [&std::ffi::OsStr; N]) -> Output {
    Command::new(compiler_path())
        .args(args)
        .output()
        .expect("run glagol")
 }
 fn compiler_path() -> &'static str {
    env!("CARGO_BIN_EXE_glagol")
 }
 fn write_fixture(name: &str, source: &str, extension: &str) -> PathBuf {
    let path = temp_path(name, extension);
    fs::write(&path, source).unwrap_or_else(|err| panic!("write `{}`: {}", path.display(), err));
    path
 }
 fn temp_path(name: &str, extension: &str) -> PathBuf {
    let id = NEXT_FIXTURE_ID.fetch_add(1, Ordering::Relaxed);
    let mut path = env::temp_dir();
    path.push(format!(
        "glagol-run-manifest-beta22-{}-{}-{}.{}",
        std::process::id(),
        id,
        name,
        extension
    ));
    path
 }
 fn read_manifest(path: &Path) -> String {
    fs::read_to_string(path).unwrap_or_else(|err| panic!("read `{}`: {}", path.display(), err))
 }
 fn assert_success_stdout(context: &str, output: &Output, expected: &str) {
    assert!(
        output.status.success(),
        "{} failed\nstdout:\n{}\nstderr:\n{}",
        context,
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(
        String::from_utf8_lossy(&output.stdout),
        expected,
        "{} stdout mismatch",
        context
    );
    assert!(
        output.stderr.is_empty(),
        "{} wrote stderr:\n{}",
        context,
        String::from_utf8_lossy(&output.stderr)
    );
 }
 fn assert_exit_code(context: &str, output: &Output, expected: i32) {
    assert_eq!(
        output.status.code(),
        Some(expected),
        "{} exit code mismatch\nstdout:\n{}\nstderr:\n{}",
        context,
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
 }
 fn find_clang() -> Option<PathBuf> {
    if let Some(path) = env::var_os("GLAGOL_CLANG").filter(|value| !value.is_empty()) {
        let path = PathBuf::from(path);
        if path.is_file() {
            return Some(path);
        }
    }
    let hermetic_clang = PathBuf::from("/tmp/glagol-clang-root/usr/bin/clang");
    if hermetic_clang.is_file() {
        return Some(hermetic_clang);
    }
    find_on_path("clang")
 }
 fn find_on_path(name: &str) -> Option<PathBuf> {
    let path = env::var_os("PATH")?;
    env::split_paths(&path)
        .map(|dir| dir.join(name))
        .find(|candidate| candidate.is_file())
 }
 fn configure_clang_runtime_env(command: &mut Command, clang: &Path) {
    if !clang.starts_with("/tmp/glagol-clang-root") {
        return;
    }
    let root = Path::new("/tmp/glagol-clang-root");
    let lib64 = root.join("usr/lib64");
    let lib = root.join("usr/lib");
    let existing = env::var_os("LD_LIBRARY_PATH").unwrap_or_default();
    let mut paths = vec![lib64, lib];
    paths.extend(env::split_paths(&existing));
    let joined = env::join_paths(paths).expect("join LD_LIBRARY_PATH");
    command.env("LD_LIBRARY_PATH", joined);
 }
--- a/compiler/tests/standard_json_document_scalar_parsing_beta21.rs
+++ b/compiler/tests/standard_json_document_scalar_parsing_beta21.rs
@ -1,313 +0,0 @@
 use std::{
    env,
    ffi::OsStr,
    fs,
    path::{Path, PathBuf},
    process::{Command, Output},
    sync::atomic::{AtomicUsize, Ordering},
 };
 static NEXT_TEMP_ID: AtomicUsize = AtomicUsize::new(0);
 const EXPECTED_TEST_OUTPUT: &str = concat!(
    "test \"explicit std json document scalar string\" ... ok\n",
    "test \"explicit std json document scalar bool\" ... ok\n",
    "test \"explicit std json document scalar integer\" ... ok\n",
    "test \"explicit std json document scalar float null\" ... ok\n",
    "test \"explicit std json document scalar failures\" ... ok\n",
    "test \"explicit std json document scalar all\" ... ok\n",
    "6 test(s) passed\n",
 );
 const STANDARD_JSON_DOCUMENT_SCALAR_BETA21: &[&str] = &[
    "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",
    "parse_null_document_result",
 ];
 #[test]
 fn explicit_std_json_document_scalar_helpers_check_and_test() {
    let project = write_project(
        "std-json-document-scalar-beta21",
        r#"
 (module main)
 (import std.json (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 parse_null_document_result))
 (fn imported_json_document_string_ok () -> bool
  (if (= (std.result.unwrap_ok (parse_string_document_result "  \"slovo\"  ")) "slovo")
    (= (std.result.unwrap_ok (parse_string_document_result "\n\t\"slo\\\"vo\"\t")) "slo\"vo")
    false))
 (fn imported_json_document_bool_ok () -> bool
  (if (std.result.unwrap_ok (parse_bool_document_result " true "))
    (= (std.result.unwrap_ok (parse_bool_document_result "\nfalse\t")) false)
    false))
 (fn imported_json_document_integer_ok () -> bool
  (if (= (std.result.unwrap_ok (parse_i32_document_result " -7 ")) -7)
    (if (= (std.result.unwrap_ok (parse_u32_document_result "\n7\t")) 7u32)
      (if (= (std.result.unwrap_ok (parse_i64_document_result " -8 ")) -8i64)
        (= (std.result.unwrap_ok (parse_u64_document_result "9 ")) 9u64)
        false)
      false)
    false))
 (fn imported_json_document_float_null_ok () -> bool
  (if (= (std.result.unwrap_ok (parse_f64_document_result " 1e2 ")) 100.0)
    (std.result.unwrap_ok (parse_null_document_result "\nnull\t"))
    false))
 (fn imported_json_document_failures_ok () -> bool
  (if (= (std.result.unwrap_err (parse_string_document_result "\"slovo\" x")) 1)
    (if (= (std.result.unwrap_err (parse_bool_document_result " TRUE ")) 1)
      (if (= (std.result.unwrap_err (parse_i32_document_result " 01 ")) 1)
        (if (= (std.result.unwrap_err (parse_u32_document_result " -1 ")) 1)
          (if (= (std.result.unwrap_err (parse_i64_document_result " 8i64 ")) 1)
            (if (= (std.result.unwrap_err (parse_u64_document_result " ")) 1)
              (if (= (std.result.unwrap_err (parse_f64_document_result " 01.0 ")) 1)
                (= (std.result.unwrap_err (parse_null_document_result " NULL ")) 1)
                false)
              false)
            false)
          false)
        false)
      false)
    false))
 (fn imported_json_document_scalar_all_ok () -> bool
  (if (imported_json_document_string_ok)
    (if (imported_json_document_bool_ok)
      (if (imported_json_document_integer_ok)
        (if (imported_json_document_float_null_ok)
          (imported_json_document_failures_ok)
          false)
        false)
      false)
    false))
 (fn main () -> i32
  (if (imported_json_document_scalar_all_ok)
    42
    1))
 (test "explicit std json document scalar string"
  (imported_json_document_string_ok))
 (test "explicit std json document scalar bool"
  (imported_json_document_bool_ok))
 (test "explicit std json document scalar integer"
  (imported_json_document_integer_ok))
 (test "explicit std json document scalar float null"
  (imported_json_document_float_null_ok))
 (test "explicit std json document scalar failures"
  (imported_json_document_failures_ok))
 (test "explicit std json document scalar all"
  (= (main) 42))
 "#,
    );
    let source = read(&project.join("src/main.slo"));
    let std_json = read(&std_json_path());
    assert!(
        !project.join("src/json.slo").exists(),
        "beta21 fixture must exercise repo-root std.json, not a local module copy"
    );
    assert!(
        source.starts_with("(module main)\n\n(import std.json ("),
        "beta21 fixture must use an explicit std.json import"
    );
    assert_json_document_scalar_helpers_are_source_authored(&std_json);
    let fmt = run_glagol([
        OsStr::new("fmt"),
        OsStr::new("--check"),
        project.as_os_str(),
    ]);
    assert_success("std json document scalar fmt --check", &fmt);
    let check = run_glagol([OsStr::new("check"), project.as_os_str()]);
    assert_success_stdout(check, "", "std json document scalar check");
    let test = run_glagol([OsStr::new("test"), project.as_os_str()]);
    assert_success_stdout(test, EXPECTED_TEST_OUTPUT, "std json document scalar test");
 }
 #[test]
 fn json_document_scalar_helpers_are_not_compiler_known_runtime_calls() {
    let std_json = read(&std_json_path());
    assert_json_document_scalar_helpers_are_source_authored(&std_json);
    for helper in STANDARD_JSON_DOCUMENT_SCALAR_BETA21 {
        let fixture = write_fixture(
            helper,
            &format!(
                "(module main)\n\n(fn main () -> i32\n  (std.result.unwrap_err (std.json.{} \"invalid\")))\n",
                helper
            ),
        );
        let output = run_glagol([fixture.as_os_str()]);
        assert_failure_stderr_contains(
            &format!("direct std.json.{} runtime call", helper),
            &output,
            &format!(
                "standard library call `std.json.{}` is not supported",
                helper
            ),
        );
    }
 }
 fn assert_json_document_scalar_helpers_are_source_authored(std_json: &str) {
    assert!(
        std_json.starts_with("(module json (export "),
        "lib/std/json.slo must stay a source-authored module export"
    );
    for helper in STANDARD_JSON_DOCUMENT_SCALAR_BETA21 {
        assert!(
            std_json.contains(&format!("(fn {} ", helper)),
            "lib/std/json.slo is missing source facade `{}`",
            helper
        );
        assert!(
            !std_json.contains(&format!("std.json.{}", helper)),
            "std.json.{} must remain source-authored, not a compiler-known runtime call",
            helper
        );
    }
    for private_prefix in [
        "__glagol_json_parse_string_document",
        "__glagol_json_parse_bool_document",
        "__glagol_json_parse_i32_document",
        "__glagol_json_parse_u32_document",
        "__glagol_json_parse_i64_document",
        "__glagol_json_parse_u64_document",
        "__glagol_json_parse_f64_document",
        "__glagol_json_parse_null_document",
    ] {
        assert!(
            !std_json.contains(private_prefix),
            "lib/std/json.slo must not introduce private JSON document runtime symbol `{}`",
            private_prefix
        );
    }
 }
 fn run_glagol<I, S>(args: I) -> Output
 where
    I: IntoIterator<Item = S>,
    S: AsRef<OsStr>,
 {
    Command::new(env!("CARGO_BIN_EXE_glagol"))
        .args(args)
        .current_dir(Path::new(env!("CARGO_MANIFEST_DIR")))
        .output()
        .expect("run glagol")
 }
 fn write_project(name: &str, source: &str) -> PathBuf {
    let root = temp_root(name);
    let src = root.join("src");
    fs::create_dir_all(&src).unwrap_or_else(|err| panic!("create `{}`: {}", src.display(), err));
    fs::write(
        root.join("slovo.toml"),
        format!(
            "[project]\nname = \"{}\"\nsource_root = \"src\"\nentry = \"main\"\n",
            name
        ),
    )
    .unwrap_or_else(|err| panic!("write project manifest: {}", err));
    fs::write(src.join("main.slo"), source.trim_start())
        .unwrap_or_else(|err| panic!("write project main.slo: {}", err));
    root
 }
 fn write_fixture(name: &str, source: &str) -> PathBuf {
    let mut path = env::temp_dir();
    path.push(format!(
        "glagol-standard-json-document-scalar-beta21-{}-{}-{}.slo",
        name,
        std::process::id(),
        NEXT_TEMP_ID.fetch_add(1, Ordering::Relaxed)
    ));
    fs::write(&path, source.trim_start())
        .unwrap_or_else(|err| panic!("write `{}`: {}", path.display(), err));
    path
 }
 fn temp_root(name: &str) -> PathBuf {
    let root = env::temp_dir().join(format!(
        "glagol-standard-json-document-scalar-beta21-{}-{}-{}",
        name,
        std::process::id(),
        NEXT_TEMP_ID.fetch_add(1, Ordering::Relaxed)
    ));
    let _ = fs::remove_dir_all(&root);
    fs::create_dir_all(&root).unwrap_or_else(|err| panic!("create `{}`: {}", root.display(), err));
    root
 }
 fn std_json_path() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("../lib/std/json.slo")
 }
 fn read(path: &Path) -> String {
    fs::read_to_string(path).unwrap_or_else(|err| panic!("read `{}`: {}", path.display(), err))
 }
 fn assert_success(context: &str, output: &Output) {
    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        output.status.success(),
        "{} failed\nstatus: {:?}\nstdout:\n{}\nstderr:\n{}",
        context,
        output.status.code(),
        stdout,
        stderr
    );
    assert!(stderr.is_empty(), "{} wrote stderr:\n{}", context, stderr);
 }
 fn assert_success_stdout(output: Output, expected: &str, context: &str) {
    assert_success(context, &output);
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert_eq!(stdout, expected, "{}", context);
 }
 fn assert_failure_stderr_contains(context: &str, output: &Output, needle: &str) {
    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        !output.status.success(),
        "{} unexpectedly passed\nstdout:\n{}\nstderr:\n{}",
        context,
        stdout,
        stderr
    );
    assert!(
        stdout.is_empty(),
        "{} rejected compile wrote stdout:\n{}",
        context,
        stdout
    );
    assert!(
        stderr.contains(needle),
        "{} stderr did not contain `{}`:\n{}",
        context,
        needle,
        stderr
    );
 }
--- a/compiler/tests/standard_json_source_facade_alpha.rs
+++ b/compiler/tests/standard_json_source_facade_alpha.rs
@ -12,13 +12,10 @@ const EXPECTED_LOCAL_TEST_OUTPUT: &str = concat!(
    "test \"explicit local json primitive scalar parse failure facade\" ... ok\n",
    "test \"explicit local json string token parse success facade\" ... ok\n",
    "test \"explicit local json string token parse failure facade\" ... ok\n",
    "test \"explicit local json document parse trimmed success facade\" ... ok\n",
    "test \"explicit local json document parse plain success facade\" ... ok\n",
    "test \"explicit local json document parse trailing failure facade\" ... ok\n",
    "test \"explicit local json fields facade\" ... ok\n",
    "test \"explicit local json arrays objects facade\" ... ok\n",
    "test \"explicit local json facade all\" ... ok\n",
-    "12 test(s) passed\n",
+    "9 test(s) passed\n",
 );
 const EXPECTED_STD_IMPORT_TEST_OUTPUT: &str = concat!(
@ -28,13 +25,10 @@ const EXPECTED_STD_IMPORT_TEST_OUTPUT: &str = concat!(
    "test \"explicit std json primitive scalar parse failure facade\" ... ok\n",
    "test \"explicit std json string token parse success facade\" ... ok\n",
    "test \"explicit std json string token parse failure facade\" ... ok\n",
    "test \"explicit std json document parse trimmed success facade\" ... ok\n",
    "test \"explicit std json document parse plain success facade\" ... ok\n",
    "test \"explicit std json document parse trailing failure facade\" ... ok\n",
    "test \"explicit std json fields facade\" ... ok\n",
    "test \"explicit std json arrays objects facade\" ... ok\n",
    "test \"explicit std json facade all\" ... ok\n",
-    "12 test(s) passed\n",
+    "9 test(s) passed\n",
 );
 const STANDARD_JSON_SOURCE_FACADE_ALPHA: &[&str] = &[
@ -54,14 +48,6 @@ const STANDARD_JSON_SOURCE_FACADE_ALPHA: &[&str] = &[
    "parse_u64_value_result",
    "parse_f64_value_result",
    "parse_null_value_result",
    "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",
    "parse_null_document_result",
    "field_string",
    "field_bool",
    "field_i32",
@ -98,7 +84,6 @@ const STANDARD_JSON_RUNTIME_NAMES: &[&str] = &[
 ];
 const STANDARD_JSON_ALLOWED_STD_NAMES: &[&str] = &[
    "(import std.string (trim_ascii))",
    "std.json.quote_string",
    "std.string.concat",
    "std.num.i32_to_string",
@ -115,17 +100,6 @@ const STANDARD_JSON_ALLOWED_STD_NAMES: &[&str] = &[
    "std.json.parse_f64_value_result",
 ];
 const STANDARD_JSON_DOCUMENT_SCALAR_BETA21: &[&str] = &[
    "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",
    "parse_null_document_result",
 ];
 #[test]
 fn standard_json_source_facade_project_checks_formats_and_tests() {
    let project =
@ -225,7 +199,6 @@ fn assert_json_source_shape(json: &str, main: &str, context: &str) {
    }
    assert_std_only_contains(json, STANDARD_JSON_ALLOWED_STD_NAMES, context);
    assert_deferred_json_surface_absent(json, main, context);
    assert_json_document_scalar_helpers_are_source_authored(json, context);
    for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA {
        assert!(
@ -243,34 +216,6 @@ fn assert_json_source_shape(json: &str, main: &str, context: &str) {
    }
 }
 fn assert_json_document_scalar_helpers_are_source_authored(json: &str, context: &str) {
    for helper in STANDARD_JSON_DOCUMENT_SCALAR_BETA21 {
        assert!(
            !json.contains(&format!("std.json.{}", helper)),
            "{} must keep `{}` source-authored, not compiler-known",
            context,
            helper
        );
    }
    for private_prefix in [
        "__glagol_json_parse_string_document",
        "__glagol_json_parse_bool_document",
        "__glagol_json_parse_i32_document",
        "__glagol_json_parse_u32_document",
        "__glagol_json_parse_i64_document",
        "__glagol_json_parse_u64_document",
        "__glagol_json_parse_f64_document",
        "__glagol_json_parse_null_document",
    ] {
        assert!(
            !json.contains(private_prefix),
            "{} must not introduce private JSON document runtime symbol `{}`",
            context,
            private_prefix
        );
    }
 }
 fn assert_deferred_json_surface_absent(json: &str, main: &str, context: &str) {
    for deferred in [
        "parse_object",
--- a/compiler/tests/user_project_conformance_beta25.rs
+++ b/compiler/tests/user_project_conformance_beta25.rs
@ -1,539 +0,0 @@
 use std::{
    ffi::OsStr,
    fs,
    path::{Path, PathBuf},
    process::{Command, Output},
    sync::atomic::{AtomicUsize, Ordering},
    time::{SystemTime, UNIX_EPOCH},
 };
 static NEXT_TEMP_ID: AtomicUsize = AtomicUsize::new(0);
 struct MatrixEntry {
    path: &'static str,
    expected_tests: usize,
    run_tests: bool,
 }
 const MATRIX: &[MatrixEntry] = &[
    MatrixEntry {
        path: "examples/projects/basic",
        expected_tests: 2,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/enum-imports",
        expected_tests: 9,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-cli",
        expected_tests: 17,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-env",
        expected_tests: 23,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-fs",
        expected_tests: 35,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-io",
        expected_tests: 12,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-json",
        expected_tests: 12,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-math",
        expected_tests: 4,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-net",
        expected_tests: 9,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-num",
        expected_tests: 5,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-option",
        expected_tests: 36,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-process",
        expected_tests: 21,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-random",
        expected_tests: 2,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-result",
        expected_tests: 26,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-string",
        expected_tests: 12,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-time",
        expected_tests: 3,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-vec_bool",
        expected_tests: 19,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-vec_f64",
        expected_tests: 20,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-vec_i32",
        expected_tests: 22,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-vec_i64",
        expected_tests: 20,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-import-vec_string",
        expected_tests: 19,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-cli",
        expected_tests: 17,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-env",
        expected_tests: 23,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-fs",
        expected_tests: 35,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-io",
        expected_tests: 12,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-json",
        expected_tests: 12,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-math",
        expected_tests: 7,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-net",
        expected_tests: 9,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-num",
        expected_tests: 5,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-option",
        expected_tests: 36,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-process",
        expected_tests: 21,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-random",
        expected_tests: 3,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-result",
        expected_tests: 26,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-string",
        expected_tests: 12,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-time",
        expected_tests: 3,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-vec_bool",
        expected_tests: 19,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-vec_f64",
        expected_tests: 20,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-vec_i32",
        expected_tests: 22,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-vec_i64",
        expected_tests: 20,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/std-layout-local-vec_string",
        expected_tests: 19,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/projects/stdlib-composition",
        expected_tests: 3,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/workspaces/exp-5-local",
        expected_tests: 2,
        run_tests: true,
    },
    MatrixEntry {
        path: "examples/workspaces/std-import-option",
        expected_tests: 1,
        run_tests: true,
    },
 ];
 #[test]
 fn user_project_conformance_matrix_checks_lists_and_runs_stable_tests() {
    assert_matrix_inventory();
    let repo_root = repo_root();
    for entry in MATRIX {
        let fixture = repo_root.join(entry.path);
        assert!(
            fixture.join("slovo.toml").is_file(),
            "{} must remain an existing project or workspace fixture",
            entry.path
        );
        let check = run_glagol(
            [OsStr::new("check"), fixture.as_os_str()],
            &temp_root(entry.path, "check"),
        );
        assert_success_no_stderr(entry.path, "check", &check);
        assert_stdout_eq(entry.path, "check", &check, "");
        let list = run_glagol(
            [
                OsStr::new("test"),
                OsStr::new("--list"),
                fixture.as_os_str(),
            ],
            &temp_root(entry.path, "list"),
        );
        assert_success_no_stderr(entry.path, "test --list", &list);
        assert_stdout_contains(
            entry.path,
            "test --list",
            &list,
            &format!(
                "{} test(s) selected (total_discovered {}, selected {}, passed 0, failed 0, skipped 0, filter none)",
                entry.expected_tests, entry.expected_tests, entry.expected_tests
            ),
        );
        if entry.run_tests {
            let test = run_glagol(
                [OsStr::new("test"), fixture.as_os_str()],
                &temp_root(entry.path, "test"),
            );
            assert_success_no_stderr(entry.path, "test", &test);
            assert_stdout_contains(
                entry.path,
                "test",
                &test,
                &format!("{} test(s) passed", entry.expected_tests),
            );
        }
    }
 }
 fn assert_matrix_inventory() {
    assert_eq!(MATRIX.len(), 43, "beta25 fixture-root count changed");
    assert_eq!(
        MATRIX
            .iter()
            .map(|entry| entry.expected_tests)
            .sum::<usize>(),
        655,
        "beta25 discovered-test count changed"
    );
    let matrix_paths = MATRIX
        .iter()
        .map(|entry| entry.path.to_owned())
        .collect::<Vec<_>>();
    let mut sorted_matrix_paths = matrix_paths.clone();
    sorted_matrix_paths.sort();
    assert_eq!(
        matrix_paths, sorted_matrix_paths,
        "beta25 user-project conformance matrix must remain sorted by repository-relative path"
    );
    let discovered_paths = discover_fixture_paths(&repo_root());
    assert_eq!(
        discovered_paths, matrix_paths,
        "beta25 user-project conformance matrix must cover every top-level example project and workspace fixture"
    );
    let inventory = MATRIX
        .iter()
        .map(|entry| {
            format!(
                "{}|tests={}|run_tests={}",
                entry.path, entry.expected_tests, entry.run_tests
            )
        })
        .collect::<Vec<_>>()
        .join("\n");
    assert_eq!(
        inventory,
        concat!(
            "examples/projects/basic|tests=2|run_tests=true\n",
            "examples/projects/enum-imports|tests=9|run_tests=true\n",
            "examples/projects/std-import-cli|tests=17|run_tests=true\n",
            "examples/projects/std-import-env|tests=23|run_tests=true\n",
            "examples/projects/std-import-fs|tests=35|run_tests=true\n",
            "examples/projects/std-import-io|tests=12|run_tests=true\n",
            "examples/projects/std-import-json|tests=12|run_tests=true\n",
            "examples/projects/std-import-math|tests=4|run_tests=true\n",
            "examples/projects/std-import-net|tests=9|run_tests=true\n",
            "examples/projects/std-import-num|tests=5|run_tests=true\n",
            "examples/projects/std-import-option|tests=36|run_tests=true\n",
            "examples/projects/std-import-process|tests=21|run_tests=true\n",
            "examples/projects/std-import-random|tests=2|run_tests=true\n",
            "examples/projects/std-import-result|tests=26|run_tests=true\n",
            "examples/projects/std-import-string|tests=12|run_tests=true\n",
            "examples/projects/std-import-time|tests=3|run_tests=true\n",
            "examples/projects/std-import-vec_bool|tests=19|run_tests=true\n",
            "examples/projects/std-import-vec_f64|tests=20|run_tests=true\n",
            "examples/projects/std-import-vec_i32|tests=22|run_tests=true\n",
            "examples/projects/std-import-vec_i64|tests=20|run_tests=true\n",
            "examples/projects/std-import-vec_string|tests=19|run_tests=true\n",
            "examples/projects/std-layout-local-cli|tests=17|run_tests=true\n",
            "examples/projects/std-layout-local-env|tests=23|run_tests=true\n",
            "examples/projects/std-layout-local-fs|tests=35|run_tests=true\n",
            "examples/projects/std-layout-local-io|tests=12|run_tests=true\n",
            "examples/projects/std-layout-local-json|tests=12|run_tests=true\n",
            "examples/projects/std-layout-local-math|tests=7|run_tests=true\n",
            "examples/projects/std-layout-local-net|tests=9|run_tests=true\n",
            "examples/projects/std-layout-local-num|tests=5|run_tests=true\n",
            "examples/projects/std-layout-local-option|tests=36|run_tests=true\n",
            "examples/projects/std-layout-local-process|tests=21|run_tests=true\n",
            "examples/projects/std-layout-local-random|tests=3|run_tests=true\n",
            "examples/projects/std-layout-local-result|tests=26|run_tests=true\n",
            "examples/projects/std-layout-local-string|tests=12|run_tests=true\n",
            "examples/projects/std-layout-local-time|tests=3|run_tests=true\n",
            "examples/projects/std-layout-local-vec_bool|tests=19|run_tests=true\n",
            "examples/projects/std-layout-local-vec_f64|tests=20|run_tests=true\n",
            "examples/projects/std-layout-local-vec_i32|tests=22|run_tests=true\n",
            "examples/projects/std-layout-local-vec_i64|tests=20|run_tests=true\n",
            "examples/projects/std-layout-local-vec_string|tests=19|run_tests=true\n",
            "examples/projects/stdlib-composition|tests=3|run_tests=true\n",
            "examples/workspaces/exp-5-local|tests=2|run_tests=true\n",
            "examples/workspaces/std-import-option|tests=1|run_tests=true",
        ),
        "beta25 user-project conformance matrix changed without updating the inventory assertion"
    );
 }
 fn discover_fixture_paths(repo_root: &Path) -> Vec<String> {
    let mut paths = Vec::new();
    for parent in ["examples/projects", "examples/workspaces"] {
        let parent_path = repo_root.join(parent);
        for entry in fs::read_dir(&parent_path).unwrap_or_else(|err| {
            panic!(
                "read fixture inventory `{}`: {}",
                parent_path.display(),
                err
            );
        }) {
            let entry = entry.unwrap_or_else(|err| {
                panic!(
                    "read fixture entry under `{}`: {}",
                    parent_path.display(),
                    err
                );
            });
            let path = entry.path();
            if path.join("slovo.toml").is_file() {
                paths.push(
                    path.strip_prefix(repo_root)
                        .expect("fixture path under repository root")
                        .to_string_lossy()
                        .replace('\\', "/"),
                );
            }
        }
    }
    paths.sort();
    paths
 }
 fn repo_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .parent()
        .expect("compiler crate has repository parent")
        .to_path_buf()
 }
 fn run_glagol<I, S>(args: I, cwd: &Path) -> Output
 where
    I: IntoIterator<Item = S>,
    S: AsRef<OsStr>,
 {
    fs::create_dir_all(cwd).unwrap_or_else(|err| {
        panic!("create command cwd `{}`: {}", cwd.display(), err);
    });
    let mut command = Command::new(env!("CARGO_BIN_EXE_glagol"));
    configure_conformance_env(&mut command);
    command
        .args(args)
        .current_dir(cwd)
        .output()
        .expect("run glagol")
 }
 fn configure_conformance_env(command: &mut Command) {
    for key in [
        "GLAGOL_STD_IMPORT_ENV_ALPHA_UNLIKELY_MISSING",
        "GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_UNLIKELY_MISSING",
    ] {
        command.env_remove(key);
    }
    for (key, value) in [
        (
            "GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT",
            "glagol-std-import-env-alpha-value",
        ),
        ("GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT_I32", "42"),
        ("GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT_I64", "42000000000"),
        ("GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT_U32", "42"),
        ("GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT_U64", "4294967296"),
        ("GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT_F64", "42.5"),
        ("GLAGOL_STD_IMPORT_ENV_ALPHA_PRESENT_BOOL", "true"),
        ("GLAGOL_STD_IMPORT_ENV_ALPHA_INVALID", "not-a-number"),
        (
            "GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT",
            "glagol-std-layout-local-env-alpha-value",
        ),
        ("GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT_I32", "42"),
        (
            "GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT_I64",
            "42000000000",
        ),
        ("GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT_U32", "42"),
        (
            "GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT_U64",
            "4294967296",
        ),
        ("GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT_F64", "42.5"),
        ("GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_PRESENT_BOOL", "true"),
        ("GLAGOL_STD_LAYOUT_LOCAL_ENV_ALPHA_INVALID", "not-a-number"),
    ] {
        command.env(key, value);
    }
 }
 fn temp_root(path: &str, command: &str) -> PathBuf {
    let id = NEXT_TEMP_ID.fetch_add(1, Ordering::Relaxed);
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system clock before UNIX_EPOCH")
        .as_nanos();
    let fixture = path
        .chars()
        .map(|ch| if ch == '/' || ch == '-' { '_' } else { ch })
        .collect::<String>();
    std::env::temp_dir().join(format!(
        "glagol-user-project-conformance-beta25-{}-{}-{}-{}-{}",
        std::process::id(),
        nanos,
        id,
        fixture,
        command
    ))
 }
 fn assert_success_no_stderr(fixture: &str, command: &str, output: &Output) {
    assert!(
        output.status.success(),
        "{} `{}` failed\nstatus: {:?}\nstdout:\n{}\nstderr:\n{}",
        fixture,
        command,
        output.status.code(),
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(
        output.stderr.is_empty(),
        "{} `{}` wrote stderr:\n{}",
        fixture,
        command,
        String::from_utf8_lossy(&output.stderr)
    );
 }
 fn assert_stdout_eq(fixture: &str, command: &str, output: &Output, expected: &str) {
    assert_eq!(
        String::from_utf8_lossy(&output.stdout),
        expected,
        "{} `{}` stdout mismatch",
        fixture,
        command
    );
 }
 fn assert_stdout_contains(fixture: &str, command: &str, output: &Output, needle: &str) {
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains(needle),
        "{} `{}` stdout did not contain `{}`:\n{}",
        fixture,
        command,
        needle,
        stdout
    );
 }
--- a/docs/POST_BETA_ROADMAP.md
+++ b/docs/POST_BETA_ROADMAP.md
@ -56,15 +56,6 @@ LSP/watch behavior, SARIF/daemon protocols, JSON expansion, runtime helper
 names, source-language syntax, package registries, semver solving, or
 performance claims.
 Released in `1.0.0-beta.25`: user-project conformance matrix evidence. The
 scope adds a deterministic matrix over the existing `examples/projects/` and
 `examples/workspaces/` inventories so ordinary project and workspace usage has
 stable-readiness evidence across all 43 top-level fixture roots and 655
 discovered tests. It is tooling/conformance evidence only: no
 source-language change, standard-library helper change, runtime behavior
 change, package manager or registry behavior, lockfile behavior,
 semantic-version solving, stable schema freeze, or performance claim.
 Why first: it reduces friction for every later feature and gives users a better
 way to exercise the beta.
@ -127,19 +118,6 @@ bytes `9`, `10`, `11`, `12`, `13`, and `32`. Unicode/grapheme semantics,
 case folding, regexes, tokenizers, mutable strings, slice/view syntax, new
 runtime names, and stable stdlib/API promises remain deferred.
 Released in `1.0.0-beta.23`: the public
 [`docs/language/STDLIB_TIERS.md`](language/STDLIB_TIERS.md) ledger defines the
 current standard-library tier labels `beta-supported`, `experimental`, and
 `internal`, and aligns the docs around the generated
 [`docs/language/STDLIB_API.md`](language/STDLIB_API.md) signature catalog.
 JSON, loopback networking, random/time, and filesystem resource-handle helpers
 are documented as experimental domains. Concrete vector modules remain
 beta-supported concrete lanes, not a generic collections freeze. The slice is
 documentation/catalog tooling clarity only: no syntax, helper, runtime,
 manifest-schema, Markdown-schema, ABI/layout, or stable stdlib/API behavior
 changes. It updates generated catalog output and the release gate so tier
 metadata is visible and checked.
 Why third: stdlib growth is already broad enough that naming and stability tiers
 matter more than adding another isolated helper group.
@ -191,14 +169,6 @@ local-package rules. Lockfiles, remote registries, semver solving, publishing,
 optional/dev/target dependencies, and stable package ABI/layout remain out of
 scope.
 Released in `1.0.0-beta.24`: package manifest identity and dependency
 diagnostics are tightened without changing the package model. Duplicate
 package manifest keys, invalid dependency keys, and duplicate dependency keys
 are explicit diagnostics. The slice adds no remote registry, lockfile,
 semantic-version solving, package publishing, optional/dev/target
 dependencies, stable package ABI/layout, source-language change, runtime
 change, or standard-library change.
 Why fifth: stable package rules are a prerequisite for a usable public language,
 but remote publishing can wait.
@ -261,15 +231,6 @@ object/array parsing, tokenizer objects, Unicode escape decoding or
 normalization, embedded NUL policy, streaming, schema validation, and stable
 ABI/API guarantees remain deferred.
 Released in `1.0.0-beta.21`: `lib/std/json.slo` adds source-authored scalar
 document parse facades for string, bool, `i32`, `u32`, `i64`, `u64`, `f64`,
 and exact `null`. Each helper trims ASCII whitespace around the whole document
 with `std.string.trim_ascii`, then delegates to the already released exact
 value-token parser. This intentionally remains scalar document parsing only:
 object/array parsing, recursive JSON values, parser/tokenizer objects,
 maps/sets, streaming, new compiler-known runtime names, broader Unicode escape
 policy, embedded NUL policy, and stable ABI/API guarantees remain deferred.
 Why seventh: networking and CLI tools need data interchange, but a complete JSON
 library depends on collection work.
@ -571,13 +532,9 @@ foundation before richer string or data-interchange APIs are credible.
 Slovo should not become stable until all of these are true:
 - migration and deprecation policy is documented
- `lib/std` has explicit beta-supported, experimental, and internal tiers plus
+- `lib/std` has explicit stable and experimental tiers
  a later stable-tier/deprecation policy before `1.0.0`
 - package/workspace behavior is deterministic
- package manifest identity and dependency-key failures have explicit
+- conformance tests cover user-shaped projects
  diagnostics
 - conformance tests and matrix evidence cover user-shaped projects and
  workspaces
 - release gates are reproducible on a clean checkout
 - diagnostics and formatter output are stable for promoted features
 - performance publications are repeatable and labeled as local-machine evidence
--- a/docs/compiler/RELEASE_NOTES.md
+++ b/docs/compiler/RELEASE_NOTES.md
@ -12,165 +12,6 @@ integration/readiness release, not the first real beta.
 No active unreleased compiler scope is documented here yet.
 ## 1.0.0-beta.25
 Release label: `1.0.0-beta.25`
 Release date: 2026-05-23
 Release state: user-project conformance matrix evidence
 ### Summary
 The beta.25 compiler/tooling slice adds deterministic stable-readiness
 evidence for ordinary project and workspace usage without changing the
 language, runtime, stdlib, or package manager model:
 - Add a user-project conformance matrix over all 43 top-level fixture roots
  under existing `examples/projects/` and `examples/workspaces/`, covering
  655 discovered tests.
 - Keep matrix inputs repository-local and deterministically sorted by
  repository-relative path.
 - Record ordinary `check`, `test --list`, and stable `test` behavior for each
  existing example in the matrix.
 - Treat matrix output as beta tooling evidence rather than a stable public
  schema.
 ### Explicit Deferrals
 This release does not implement source-language change, standard-library
 helper change, runtime behavior change, compiler-known `std.*` runtime names,
 package manager behavior, remote registries, lockfiles, semantic-version
 solving, package publishing, optional/dev/target dependencies, stable
 artifact-manifest schema guarantees, stable Markdown schemas, stable
 conformance-matrix schema guarantees, LSP/watch/SARIF/daemon protocols, stable
 ABI/layout, or performance claims.
 ## 1.0.0-beta.24
 Release label: `1.0.0-beta.24`
 Release date: 2026-05-23
 Release state: package manifest identity and local dependency diagnostic
 hardening
 ### Summary
 The beta.24 compiler/tooling slice tightens local package manifest diagnostics
 without changing the language, runtime, stdlib, or package graph model:
 - Bump the `glagol` compiler package version to `1.0.0-beta.24`.
 - Diagnose duplicate package manifest keys explicitly.
 - Diagnose invalid dependency keys explicitly.
 - Diagnose duplicate dependency keys explicitly.
 - Keep dependency records local-path-only and require dependency keys to match
  target package names.
 ### Explicit Deferrals
 This release does not implement remote registries, lockfiles,
 semantic-version solving, package publishing, optional/dev/target
 dependencies, feature flags, build scripts, package archives, stable package
 ABI/layout, source-language syntax, runtime C capabilities, standard-library
 helpers, compiler-known `std.*` runtime names, stable artifact-manifest schema
 guarantees, stable Markdown schemas, LSP/watch/SARIF/daemon protocols, or
 performance claims.
 ## 1.0.0-beta.23
 Release label: `1.0.0-beta.23`
 Release date: 2026-05-23
 Release state: standard-library stability tier ledger and catalog alignment
 ### Summary
 The beta.23 compiler/tooling slice aligns generated standard-library API
 catalog output with the public tier ledger:
 - Bump the `glagol` compiler package version to `1.0.0-beta.23`.
 - Render per-module and per-helper `beta-supported` or `experimental` tier
  metadata in `docs/language/STDLIB_API.md`.
 - Add `scripts/check-stdlib-api-tiers.js` and wire it into the release gate.
 - Mark JSON, loopback networking, random/time, and filesystem resource-handle
  helpers as experimental in generated catalog output.
 - Keep concrete vector modules beta-supported concrete lanes with an explicit
  no-generic-collection-freeze note.
 ### Explicit Deferrals
 This release does not implement source-language syntax, standard-library
 helpers, compiler-known `std.*` runtime names, runtime C capabilities, package
 or workspace behavior, stable artifact-manifest schema guarantees, stable
 Markdown schemas, LSP/watch/SARIF/daemon protocols, performance claims,
 stable ABI/layout, or a stable standard-library compatibility contract.
 ## 1.0.0-beta.22
 Release label: `1.0.0-beta.22`
 Release date: 2026-05-23
 Release state: run manifest and execution report hardening
 ### Summary
 The beta.22 compiler/tooling slice hardens `glagol run --manifest` evidence
 without changing the Slovo language or standard-library surface:
 - Bump the `glagol` compiler package version to `1.0.0-beta.22`.
 - Add an additive run-report block to run-mode artifact manifests.
 - Record executed-program exit status, captured stdout, captured stderr, and
  forwarded program arguments.
 - Keep the run report as beta tooling metadata under the existing
  `slovo.artifact-manifest` version `1` contract rather than a stable schema
  freeze.
 - Keep non-run modes outside this run-report requirement.
 ### Explicit Deferrals
 This release does not implement source-language syntax, standard-library
 helpers, compiler-known `std.*` runtime names, runtime C capabilities, package
 or workspace behavior, stable artifact-manifest schema guarantees, stable
 Markdown schemas, LSP/watch/SARIF/daemon protocols, performance claims,
 stable ABI/layout, or a stable standard-library compatibility contract.
 ## 1.0.0-beta.21
 Release label: `1.0.0-beta.21`
 Release date: 2026-05-23
 Release state: JSON document scalar parsing foundation
 ### Summary
 The beta.21 compiler/tooling slice adds focused coverage for source-authored
 `std.json` document-scalar helpers without adding compiler-known runtime names:
 - Bump the `glagol` compiler package version to `1.0.0-beta.21`.
 - Add focused `standard_json_document_scalar_parsing_beta21` coverage for
  explicit `std.json` imports of `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`.
 - Gate the helpers as source-authored public facades over existing JSON token
  parsers and source-level document trimming/composition.
 - Require direct `std.json.parse_*_document_result` runtime calls and private
  `__glagol_json_*document*` runtime symbols to remain unsupported.
 - Add the focused beta21 test to `scripts/release-gate.sh`.
 ### Explicit Deferrals
 This release does not implement object parsing, array parsing, recursive JSON
 values, tokenizers, Unicode escape decoding, streaming, schema validation,
 stable parser APIs, new compiler-known `std.*` runtime names, runtime C
 changes, source-language syntax, stable ABI/layout, or a stable
 standard-library compatibility contract.
 ## 1.0.0-beta.20
 Release label: `1.0.0-beta.20`
--- a/docs/compiler/ROADMAP.md
+++ b/docs/compiler/ROADMAP.md
@ -9,9 +9,10 @@ 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
+Long-horizon compiler planning lives in
-mirrors Slovo's release train beyond the first real general-purpose beta
+`.llm/GENERAL_PURPOSE_LANGUAGE_ROADMAP.md`. It mirrors Slovo's experimental
-toolchain.
+release train from the historical `v2.0.0-beta.1` tag toward and 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
@ -21,8 +22,8 @@ general-purpose beta release.
 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.25`, released on 2026-05-23 as user-project
+Current stage: `1.0.0-beta.20`, released on 2026-05-23 as a string search
-conformance matrix evidence. It keeps the
+and ASCII trim foundation. 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,
@ -104,56 +105,10 @@ beta16-or-earlier string primitives and existing option/result shapes, and
 verifies that direct compiler-known runtime calls for the new helper names
 remain unsupported.
 The beta.21 compiler/tooling slice bumps the package version and gates
 source-authored `std.json` document scalar facades for
 `parse_string_document_result`, `parse_bool_document_result`,
 `parse_i32_document_result`, `parse_u32_document_result`,
 `parse_i64_document_result`, `parse_u64_document_result`,
 `parse_f64_document_result`, and `parse_null_document_result` through explicit
 `std.json` imports. It keeps those helpers source-authored over the existing
 JSON token parser family and existing source-level composition, and verifies
 that direct compiler-known runtime calls and private `__glagol_json_*document*`
 symbols for the new helper names remain unsupported.
 The beta.22 compiler/tooling slice bumps the package version and hardens
 `glagol run --manifest` evidence with an additive run-report block in
 run-mode artifact manifests. The block records executed-program exit status,
 captured stdout, captured stderr, and forwarded program arguments. It is beta
 CLI evidence metadata under the existing `slovo.artifact-manifest` version
 `1` contract, not a stable schema freeze, and it adds no source-language,
 runtime, package, or standard-library surface.
 The beta.23 compiler/tooling slice bumps the package version and updates
 generated `docs/language/STDLIB_API.md` output with per-module and per-helper
 tier metadata. It adds a release-gate checker for the tier catalog, marks JSON,
 loopback networking, random/time, and filesystem resource-handle helpers as
 experimental, and keeps concrete vector modules beta-supported concrete lanes
 without claiming generic collection stability. It adds no source-language,
 runtime, package, or standard-library helper surface.
 The beta.24 compiler/tooling slice bumps the package version and tightens
 local package manifest diagnostics. Duplicate package manifest keys, invalid
 dependency keys, and duplicate dependency keys are explicit diagnostics. It
 keeps the existing closed local workspace model and adds no remote registry,
 lockfile, semantic-version solving, package publishing, optional/dev/target
 dependencies, stable package ABI/layout, source-language behavior, runtime
 behavior, or standard-library behavior.
 The beta.25 compiler/tooling slice adds deterministic stable-readiness
 evidence for ordinary project and workspace usage over the existing
 `examples/projects/` and `examples/workspaces/` inventories. The conformance
 matrix is repository-local, sorted by stable path, and records ordinary
 `check`, `test --list`, and stable `test` behavior for all 43 top-level
 fixture roots and 655 discovered tests. It adds no source-language behavior,
 runtime behavior, standard-library helper behavior, package manager or
 registry behavior, lockfile behavior, semantic-version solving, stable schema
 freeze, or performance claim.
 Generic vectors, generic collections, maps, sets, generic stdlib dispatch,
 runtime collection changes, collection unification, stable human diagnostic
-text, stable artifact-manifest, Markdown, or conformance-matrix schema
+text, stable artifact-manifest or Markdown schema freezes, LSP/watch
-freezes, LSP/watch protocols, SARIF/daemon protocols,
+protocols, SARIF/daemon protocols, re-exports/globs/hierarchical modules,
 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,
@ -733,8 +688,6 @@ Alpha is the latest compiler semantic/runtime-operation support slice.
 - [x] Diagnose missing packages, duplicate package names, dependency cycles,
      path escapes, invalid package names, invalid package versions, private
      visibility, and dependency key mismatches.
 - [x] Diagnose duplicate package manifest keys, invalid dependency keys, and
      duplicate dependency keys explicitly.
 - [x] Keep registries, lockfiles, semver solving, aliases/globs/re-exports,
      generated code, build scripts, publishing, optional/dev/target
      dependencies, stable package ABI, and remote dependencies deferred.
--- a/docs/language/DIAGNOSTICS.md
+++ b/docs/language/DIAGNOSTICS.md
@ -237,47 +237,6 @@ Future releases may add codes or split broad codes when the release scope
 requires more precise tooling behavior. Such changes must be documented using
 the compatibility classes above.
 ## Project And Workspace Codes
 Project, package, and workspace diagnostics are covered by integration tests
 because they often require multiple files, manifests, or generated temporary
 directories rather than a single `.slo` golden fixture. These codes still use
 the same `slovo.diagnostic` version `1` schema and PascalCase code policy.
 Current package/workspace loader and graph diagnostics include:
 - `DependencyNameMismatch`
 - `DependencyPathEscape`
 - `DuplicatePackageDependencyName`
 - `DuplicatePackageName`
 - `DuplicateWorkspaceMember`
 - `InvalidPackageDependencyName`
 - `InvalidPackageName`
 - `InvalidPackageVersion`
 - `MissingPackageDependency`
 - `MissingPackageModule`
 - `PackageDependencyCycle`
 - `PackageImportNotDependency`
 - `PackageManifestInvalid`
 - `PackageSourceReadFailed`
 - `PackageSourceRootEscape`
 - `PackageSourceRootMissing`
 - `ProjectEntryMainInvalidSignature`
 - `ProjectEntryMainMissing`
 - `ProjectManifestInvalid`
 - `ProjectManifestReadFailed`
 - `ProjectSourceReadFailed`
 - `ProjectSourceRootMissing`
 - `UnsupportedDependency`
 - `WorkspaceBuildAmbiguousEntryPackage`
 - `WorkspaceDefaultPackageEntryMissing`
 - `WorkspaceDefaultPackageMissing`
 - `WorkspaceEntryMainInvalidSignature`
 - `WorkspaceEntryMainMissing`
 - `WorkspaceManifestInvalid`
 - `WorkspaceMemberManifestMissing`
 - `WorkspaceMemberPathEscape`
 ## Explicit Deferrals
 `1.0.0-beta.13` does not define:
--- a/docs/language/PACKAGES.md
+++ b/docs/language/PACKAGES.md
@ -56,10 +56,6 @@ used for solving dependency constraints.
 dependency paths must stay inside the workspace/package boundary after
 normalization and canonical path checks.
 Duplicate keys in package manifests are `PackageManifestInvalid` diagnostics.
 The manifest loader does not silently choose one spelling for repeated package
 identity or dependency entries.
 Dependencies are local path records only. The dependency key must match the
 target package name:
@ -67,11 +63,6 @@ target package name:
 mathlib = { path = "../mathlib" }
 ```
 Dependency keys use the same package-name shape as package identities. Invalid
 dependency keys are `InvalidPackageDependencyName` diagnostics, and duplicate
 dependency keys are `DuplicatePackageDependencyName` diagnostics before the
 local dependency graph is accepted.
 ## Imports
 Within a workspace, a package imports a dependency module through the package
@ -115,12 +106,9 @@ The package/workspace gate covers these user-facing error families:
 - missing member manifests
 - duplicate normalized workspace members
 - invalid member or dependency paths
 - duplicate package manifest keys
 - invalid package names and versions
 - duplicate package names
 - missing local path dependencies
 - invalid dependency keys
 - duplicate dependency keys
 - dependency key/name mismatches
 - package dependency cycles
 - private cross-package imports
--- a/docs/language/RELEASE_NOTES.md
+++ b/docs/language/RELEASE_NOTES.md
@ -8,7 +8,7 @@ Historical `exp-*` releases listed here are experimental maturity milestones.
 The pushed tag `v2.0.0-beta.1` is historical. It is now documented as an
 experimental integration/readiness release, not as a beta maturity claim.
-The current release is `1.0.0-beta.25`, published on 2026-05-23. It keeps the
+The current release is `1.0.0-beta.20`, published on 2026-05-23. It keeps the
 `1.0.0-beta` language surface, includes the first post-beta tooling/install
 hardening bundle from `1.0.0-beta.1`, and adds the first runtime/resource
 foundation bundle from `1.0.0-beta.2` plus the first standard-library
@ -30,152 +30,12 @@ boundary foundation from `1.0.0-beta.16`, and the JSON primitive scalar
 parsing foundation from `1.0.0-beta.17`, plus the JSON string token parsing
 foundation from `1.0.0-beta.18`, the test discovery and user-project
 conformance foundation from `1.0.0-beta.19`, and the string search and ASCII
-trim foundation from `1.0.0-beta.20`, plus the JSON document scalar parsing
+trim foundation from `1.0.0-beta.20`.
 foundation from `1.0.0-beta.21`, and the run manifest execution-report
 hardening slice from `1.0.0-beta.22`, plus the standard-library stability tier
 ledger and catalog alignment slice from `1.0.0-beta.23`, the package manifest
 identity and local dependency diagnostic hardening slice from
 `1.0.0-beta.24`, and the user-project conformance matrix evidence slice from
 `1.0.0-beta.25`.
 ## Unreleased
 No active unreleased language scope is documented here yet.
 ## 1.0.0-beta.25
 Release label: `1.0.0-beta.25`
 Release name: User Project Conformance Matrix
 Release date: 2026-05-23
 Status: released beta tooling/conformance evidence on the `1.0.0-beta`
 language baseline.
 This release adds deterministic stable-readiness evidence for ordinary
 project and workspace usage over the existing `examples/projects/` and
 `examples/workspaces/` inventories. The conformance matrix records
 repository-local example coverage for all 43 top-level fixture roots and 655
 discovered tests through ordinary Glagol project/workspace entry points.
 This release adds no source-language change, standard-library helper change,
 runtime behavior change, compiler-known runtime names, package manager or
 registry behavior, lockfile behavior, semantic-version solving, stable
 artifact-manifest schema, stable Markdown schema, stable conformance-matrix
 schema, stable ABI/layout, or performance claim.
 ## 1.0.0-beta.24
 Release label: `1.0.0-beta.24`
 Release name: Package Manifest Identity And Dependency Discipline
 Release date: 2026-05-23
 Status: released beta package/workspace diagnostic hardening on the
 `1.0.0-beta` language baseline.
 This release tightens diagnostics for local package manifests only. Duplicate
 package manifest keys, invalid dependency keys, and duplicate dependency keys
 are explicit beta package/workspace diagnostics.
 The package model remains the existing closed local workspace model:
 dependencies are local path records, dependency keys must match target package
 names, and package-qualified imports still resolve through the local workspace
 graph.
 This release adds no remote registry, lockfile, semantic-version solving,
 package publishing, optional/dev/target dependencies, stable package
 ABI/layout, source-language syntax or semantics, runtime behavior,
 standard-library helpers, compiler-known runtime names, stable manifest schema,
 stable Markdown schema, or performance claim.
 ## 1.0.0-beta.23
 Release label: `1.0.0-beta.23`
 Release name: Standard Library Stability Tier Ledger And Catalog Alignment
 Release date: 2026-05-23
 Status: released beta documentation/catalog clarity on the `1.0.0-beta`
 language baseline.
 This release adds [`STDLIB_TIERS.md`](STDLIB_TIERS.md) as the public maturity
 ledger for the generated [`STDLIB_API.md`](STDLIB_API.md) standard-library API
 catalog. The ledger defines the tier labels `beta-supported`, `experimental`,
 and `internal`.
 The beta23 ledger classifies JSON, loopback networking, random/time, and
 filesystem resource-handle helpers as experimental domains. Concrete vector
 modules remain beta-supported concrete lanes; this is not a generic
 collections freeze and does not imply executable generics, maps, sets,
 iterators, mutable vectors, slice/view APIs, runtime collection changes, or
 stable ABI/layout.
 This release adds no source-language syntax, standard-library helpers,
 compiler-known runtime names, runtime behavior, package behavior, stable
 artifact-manifest schema, stable Markdown schema, stable ABI/layout, or stable
 stdlib/API compatibility freeze. It does update generated catalog output and
 the release gate so tier metadata is visible and checked.
 ## 1.0.0-beta.22
 Release label: `1.0.0-beta.22`
 Release name: Run Manifest And Execution Report Hardening
 Release date: 2026-05-23
 Status: released beta tooling/CLI evidence hardening on the `1.0.0-beta`
 language baseline.
 This release does not change the Slovo language or standard-library surface.
 It documents the matching Glagol tooling update: `glagol run --manifest`
 artifact manifests now include an additive run-report block for the executed
 program's exit status, captured stdout, captured stderr, and forwarded program
 arguments.
 The run-report block is beta tooling metadata under the existing
 `slovo.artifact-manifest` version `1` contract. It is not a stable manifest
 schema freeze and does not add source-language syntax, stdlib helpers,
 compiler-known runtime names, runtime C capabilities, package/import behavior,
 stable ABI/layout guarantees, or stable stdlib/API compatibility.
 ## 1.0.0-beta.21
 Release label: `1.0.0-beta.21`
 Release name: JSON Document Scalar Parsing Foundation
 Release date: 2026-05-23
 Status: released beta standard-library JSON document scalar parsing foundation
 on the `1.0.0-beta` language baseline.
 The source facade adds these source-authored `std.json` helpers:
 - `parse_string_document_result ((document string)) -> (result string i32)`
 - `parse_bool_document_result ((document string)) -> (result bool i32)`
 - `parse_i32_document_result ((document string)) -> (result i32 i32)`
 - `parse_u32_document_result ((document string)) -> (result u32 i32)`
 - `parse_i64_document_result ((document string)) -> (result i64 i32)`
 - `parse_u64_document_result ((document string)) -> (result u64 i32)`
 - `parse_f64_document_result ((document string)) -> (result f64 i32)`
 - `parse_null_document_result ((document string)) -> (result bool i32)`
 Each helper trims ASCII whitespace around the whole document with
 `std.string.trim_ascii`, then delegates to the already released exact
 value-token parser for that scalar family. Leading and trailing ASCII
 whitespace around one scalar document is accepted; trailing non-whitespace
 still returns `err 1` through the underlying exact parser.
 This release adds no compiler-known runtime names, parser objects, object/array
 parsing, recursive `JsonValue`, maps/sets, streaming, Unicode escape decoding
 beyond the existing string-token behavior, embedded NUL policy, stable
 ABI/layout guarantees, or stable stdlib/API freeze.
 ## 1.0.0-beta.20
 Release label: `1.0.0-beta.20`
--- a/docs/language/ROADMAP.md
+++ b/docs/language/ROADMAP.md
@ -5,13 +5,15 @@ compiler implementation inside the same monorepo.
 Guiding rule: the manifest wins. A feature is not accepted until it has surface syntax, typed-core meaning, lowering behavior, formatter behavior, diagnostics, and tests.
-Long-horizon planning lives in `.llm/ROADMAP_TO_STABLE.md`. It defines the
+Long-horizon planning lives in
-release train beyond the first real general-purpose beta Slovo contract.
+`.llm/GENERAL_PURPOSE_LANGUAGE_ROADMAP.md`. It defines the experimental
 release train from the historical `v2.0.0-beta.1` tag toward and beyond the
 first real general-purpose beta Slovo contract.
-Current stage: `1.0.0-beta.25`, released on 2026-05-23 as post-beta
+Current stage: `1.0.0-beta.20`, released on 2026-05-23 as a post-beta string
-user-project conformance matrix evidence. It keeps the `1.0.0-beta` language
+search and ASCII trim foundation. It keeps the
-contract and includes the `1.0.0-beta.1` tooling
+`1.0.0-beta` language
-hardening release, the
+contract 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
@ -26,12 +28,7 @@ collection boundary hardening and collection ledger, and `1.0.0-beta.16`
 string scanning and token boundary helpers, `1.0.0-beta.17` JSON primitive
 scalar token parsing, `1.0.0-beta.18` JSON string token parsing,
 `1.0.0-beta.19` test discovery and user-project conformance tooling, and
-`1.0.0-beta.20` string search and ASCII trim helpers, plus
+`1.0.0-beta.20` string search and ASCII trim helpers.
 `1.0.0-beta.21` JSON document scalar parsing helpers, and
 `1.0.0-beta.22` run manifest execution-report hardening, plus
 `1.0.0-beta.23` standard-library stability tier documentation,
 `1.0.0-beta.24` package manifest/dependency diagnostic hardening, and
 `1.0.0-beta.25` user-project conformance matrix evidence.
 `1.0.0-beta.16` adds `std.string` source facades and examples for
 `byte_at_result`, `slice_result`, `starts_with`, and `ends_with`. These helpers
@ -43,12 +40,11 @@ semantics; full JSON parsing; object/array parsing; tokenizer objects;
 language slice/view syntax; mutable strings; stable ABI/layout; performance
 claims; or a stable stdlib/API freeze.
-The current released JSON stage adds primitive scalar JSON token parse facades
+The current released stage adds primitive scalar JSON token parse facades for
-for booleans, concrete numeric primitives, exact `null`, one narrow ASCII JSON
+booleans, concrete numeric primitives, exact `null`, and one narrow ASCII JSON
-string-token helper, and scalar JSON document helpers that accept leading and
+string-token helper. Full JSON document parsing, object/array parsing,
-trailing ASCII whitespace. Object/array parsing, recursive JSON values,
+recursive JSON values, tokenizers, whitespace-tolerant document parsing, schema
-tokenizers, schema validation, streaming, Unicode escape
+validation, streaming, Unicode escape decoding/normalization, embedded NUL
 decoding/normalization beyond the existing string-token helper, embedded NUL
 policy, stable ABI/layout, and stable stdlib/API freeze remain deferred.
 Full JSON parsing, object/array parsing, recursive JSON values,
@ -89,55 +85,6 @@ Unicode/grapheme semantics, case folding, regexes, tokenizer APIs, language
 slice/view syntax, mutable strings, stable ABI/layout guarantees, or stable
 stdlib/API freeze.
 `1.0.0-beta.21` adds source-authored
 `std.json.parse_*_document_result` helpers for string, bool, `i32`, `u32`,
 `i64`, `u64`, `f64`, and exact `null` documents by trimming ASCII whitespace
 around the whole document with `std.string.trim_ascii`, then delegating to the
 existing exact value-token parser for each scalar family. The scope keeps
 object/array parsing, recursive JSON values, tokenizer objects, maps/sets,
 streaming, new compiler-known runtime names, Unicode escape decoding beyond
 the existing string-token helper, embedded NUL policy, stable ABI/layout, and
 stable stdlib/API freeze deferred.
 `1.0.0-beta.22` is tooling/CLI evidence hardening, not a language feature. It
 documents the matching Glagol `run --manifest` update: run-mode artifact
 manifests gain an additive run-report block for executed-program exit status,
 captured stdout, captured stderr, and forwarded program arguments. The block is
 beta tooling metadata under the existing `slovo.artifact-manifest` version `1`
 contract. It is not a stable schema freeze and adds no language syntax,
 standard-library helpers, runtime capabilities, package/import behavior,
 stable ABI/layout, or stable stdlib/API guarantees.
 `1.0.0-beta.23` is documentation/catalog clarity, not a language or stdlib
 behavior feature. It adds [`STDLIB_TIERS.md`](STDLIB_TIERS.md) as the public
 stability-tier ledger beside the generated [`STDLIB_API.md`](STDLIB_API.md)
 signature catalog. The ledger defines `beta-supported`, `experimental`, and
 `internal`; marks JSON, loopback networking, random/time, and filesystem
 resource-handle helpers as experimental domains; and keeps concrete vector
 modules as beta-supported concrete lanes rather than a generic collections
 freeze. It adds no source-language syntax, helpers, runtime names, runtime
 behavior, stable manifest schema, stable Markdown schema, stable ABI/layout,
 or stable stdlib/API freeze. It does update generated catalog output and the
 release gate so tier metadata is visible and checked.
 `1.0.0-beta.24` is package/workspace diagnostic hardening, not a language,
 runtime, package-manager, or stdlib behavior feature. It makes duplicate
 package manifest keys, invalid dependency keys, and duplicate dependency keys
 explicit diagnostics while keeping the existing closed local workspace model.
 It adds no remote registry, lockfile, semantic-version solving, package
 publishing, optional/dev/target dependencies, stable package ABI/layout,
 source-language change, runtime change, or stdlib change.
 `1.0.0-beta.25` is tooling/conformance evidence, not a language, stdlib,
 runtime, package-manager, schema-freeze, or performance feature. It adds a
 deterministic user-project conformance matrix over the existing
 `examples/projects/` and `examples/workspaces/` inventories so ordinary
 project and workspace usage has stable-readiness evidence. The release covers
 all 43 top-level fixture roots and 655 discovered tests. It adds no
 source-language change, standard-library helper change, runtime behavior
 change, package manager or registry behavior, lockfile behavior,
 semantic-version solving, stable schema freeze, or performance claim.
 The final experimental precursor scope is `exp-125`, defined in
 `.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`. Its
 unsigned direct-value flow, parse/format runtime lanes, and matching staged
--- a/docs/language/SPEC-v1.md
+++ b/docs/language/SPEC-v1.md
@ -11,12 +11,10 @@ boundary hardening and collection ledger, `1.0.0-beta.16` string scanning
 and token boundary foundation, `1.0.0-beta.17` JSON primitive scalar parsing
 foundation, `1.0.0-beta.18` JSON string token parsing foundation,
 `1.0.0-beta.19` test discovery and user-project conformance tooling, and
-`1.0.0-beta.20` string search and ASCII trim foundation, and
+`1.0.0-beta.20` string search and ASCII trim foundation. The
-`1.0.0-beta.21` JSON document scalar parsing foundation, and
+language contract
-`1.0.0-beta.22` run manifest and execution-report hardening, and
+integrates
-`1.0.0-beta.23` standard-library stability tier ledger and catalog alignment.
+promoted language slices through `exp-125` and the historical publication
 The language contract integrates promoted language slices through `exp-125`
 and the historical publication
 baseline through `exp-123`. `1.0.0-beta` is the first real general-purpose
 beta release. `exp-125` completed the unsigned numeric and stdlib breadth
 precursor scope, `exp-124` is the last tagged experimental alpha language
@ -207,20 +205,20 @@ Current v1 release surface and explicit experimental targets:
  `std.json.parse_i64_value_result`, `std.json.parse_u64_value_result`,
  `std.json.parse_f64_value_result`, and `std.json.parse_null_value_result`
  consume one already-isolated primitive scalar token and return concrete
-  `(result ... i32)` values; JSON document parsing beyond the beta21 scalar
+  `(result ... i32)` values; full JSON document parsing, string/object/array
-  helpers, string/object/array parsing, tokenizers, recursive `JsonValue`,
+  parsing, tokenizers, recursive `JsonValue`, Unicode escape handling, stable
-  Unicode escape handling, stable ABI/layout, performance claims, and stable
+  ABI/layout, performance claims, and stable stdlib/API freeze remain out of
-  stdlib/API freeze remain out of scope
+  scope
 - `1.0.0-beta.18` JSON string token parsing target:
  `std.json.parse_string_value_result : (string) -> (result string i32)`
  consumes one already-isolated ASCII JSON string token with exact quotes and
  no leading/trailing whitespace, decodes simple JSON escapes, returns
  `err 1` for ordinary parse failure, and rejects raw control bytes, bad
  escapes, unterminated/trailing bytes, raw non-ASCII, and all `\uXXXX` escapes
-  for this slice; JSON document parsing beyond the beta21 scalar helpers,
+  for this slice; full JSON document parsing, object/array parsing, tokenizer
-  object/array parsing, tokenizer APIs, recursive `JsonValue`, Unicode escape
+  APIs, recursive `JsonValue`, Unicode escape decoding/normalization, embedded
-  decoding/normalization, embedded NUL policy, stable ABI/layout, performance
+  NUL policy, stable ABI/layout, performance claims, and stable stdlib/API
-  claims, and stable stdlib/API freeze remain out of scope
+  freeze remain out of scope
 - `1.0.0-beta.19` test discovery and user-project conformance target:
  `glagol test --list <file|project|workspace>` and legacy
  `glagol --run-tests --list <file>` list checked/discovered tests without
@ -242,41 +240,6 @@ Current v1 release surface and explicit experimental targets:
  runtime names, Unicode/grapheme semantics, case folding, locale-sensitive
  matching, regex, tokenizer APIs, language slice/view syntax, mutable
  strings, stable ABI/layout, performance claims, or stable stdlib/API freeze
 - `1.0.0-beta.21` JSON document scalar parsing:
  source-authored `std.json.parse_string_document_result`,
  `std.json.parse_bool_document_result`,
  `std.json.parse_i32_document_result`,
  `std.json.parse_u32_document_result`,
  `std.json.parse_i64_document_result`,
  `std.json.parse_u64_document_result`,
  `std.json.parse_f64_document_result`, and
  `std.json.parse_null_document_result` trim ASCII whitespace around the whole
  document with `std.string.trim_ascii`, then delegate to the existing exact
  value-token parsers for one scalar JSON document. This target does not add
  compiler-known runtime names, object/array parsing, recursive `JsonValue`,
  parser/tokenizer objects, maps/sets, streaming, Unicode escape decoding
  beyond the existing string-token behavior, embedded NUL policy,
  ABI/layout guarantees, performance claims, or stable stdlib/API freeze
 - `1.0.0-beta.22` run manifest and execution-report hardening:
  `glagol run --manifest` artifact manifests include an additive run-report
  block after a supported program executes. The block records the executed
  program exit status, captured stdout, captured stderr, and forwarded
  program arguments. This target is beta tooling evidence only; it does not
  add source-language syntax, stdlib helpers, compiler-known runtime names,
  runtime C capabilities, package/import behavior, stable artifact-manifest
  schema guarantees, stable ABI/layout, or stable stdlib/API freeze
 - `1.0.0-beta.23` standard-library stability tier ledger and catalog
  alignment:
  [`STDLIB_TIERS.md`](STDLIB_TIERS.md) defines the public tier labels
  `beta-supported`, `experimental`, and `internal` beside the generated
  [`STDLIB_API.md`](STDLIB_API.md) signature catalog. JSON, loopback
  networking, random/time, and filesystem resource-handle helpers are
  experimental domains. Concrete vector modules remain beta-supported concrete
  lanes, not a generic collections freeze. This target does not add
  source-language syntax, stdlib helpers, compiler-known runtime names,
  runtime behavior, stable artifact-manifest schema, stable Markdown schema,
  stable ABI/layout, or stable stdlib/API freeze. It does update generated
  catalog output and the release gate so tier metadata is visible and checked
 - `exp-1` owned runtime strings: compiler-known `std.string.concat` accepts two
  `string` values and returns an immutable runtime-owned `string`; existing
  string equality, length, printing, locals, parameters, returns, and calls work
@ -1303,10 +1266,6 @@ std.json.parse_string_value_result: (string) -> (result string i32)
 std.json.parse_bool_value_result: (string) -> (result bool i32)
 std.json.parse_i32_value_result/parse_u32_value_result/parse_i64_value_result/parse_u64_value_result/parse_f64_value_result
 std.json.parse_null_value_result: (string) -> (result bool i32)
 std.json.parse_string_document_result: (string) -> (result string i32)
 std.json.parse_bool_document_result: (string) -> (result bool i32)
 std.json.parse_i32_document_result/parse_u32_document_result/parse_i64_document_result/parse_u64_document_result/parse_f64_document_result
 std.json.parse_null_document_result: (string) -> (result bool i32)
 std.json.field_string/field_bool/field_i32/field_u32/field_i64/field_u64/field_f64/field_null
 std.json.array0/array1/array2/array3
 std.json.object0/object1/object2/object3
@ -1334,20 +1293,13 @@ whitespace. It decodes the simple JSON escapes `\"`, `\\`, `\/`, `\b`, `\f`,
 unterminated or trailing bytes, raw non-ASCII, and all `\uXXXX` escapes for
 this slice.
 The `1.0.0-beta.21` JSON foundation adds source-authored
 `parse_*_document_result` helpers for string, bool, concrete numeric
 primitives, and exact `null`. Each helper accepts leading and trailing ASCII
 whitespace around one scalar JSON document by composing with
 `std.string.trim_ascii`, then delegates to the matching exact value-token
 parser. Trailing non-whitespace still fails through the exact parser.
 This is not a complete JSON or serialization contract. JSON parsing beyond the
-scalar document helpers, object/array parsing, recursive JSON values, maps/sets,
+single ASCII string-token helper, object/array parsing, recursive JSON values,
-generic collections, tokenizer objects, streaming decoders or encoders, schema
+maps/sets, generic collections, tokenizer objects, streaming decoders or
-validation, Unicode escape decoding or normalization beyond the existing
+encoders, schema validation, Unicode escape decoding or
-string-token behavior, embedded NUL policy, stable text encoding policy beyond
+normalization, embedded NUL policy, stable text encoding policy beyond the
-the current null-terminated runtime string ABI, stable runtime helper symbols,
+current null-terminated runtime string ABI, stable runtime helper symbols, and
-and stable standard-library API guarantees remain deferred.
+stable standard-library API guarantees remain deferred.
 ### 4.4.6 Post-Beta Concrete Type Alias Foundation
--- a/docs/language/STDLIB_API.md
+++ b/docs/language/STDLIB_API.md
--- a/docs/language/STDLIB_TIERS.md
+++ b/docs/language/STDLIB_TIERS.md
@ -1,68 +0,0 @@
 # Slovo Standard Library Stability Tiers
 Status: beta public ledger for `1.0.0-beta.23`.
 This document records the current maturity labels for the source-authored
 standard-library facade surface. Exact exported helper signatures remain in
 [`STDLIB_API.md`](STDLIB_API.md), which is generated from `lib/std/*.slo`.
 This ledger explains how to read that catalog during the beta line.
 `1.0.0-beta.23` is documentation and catalog-tooling alignment only. It adds no
 source syntax, standard-library helpers, compiler-known runtime names, runtime
 behavior, package behavior, manifest schema guarantee, Markdown schema
 guarantee, ABI/layout guarantee, or stable standard-library/API compatibility
 freeze. It does make the generated API catalog emit tier metadata and makes the
 release gate check that experimental tier metadata is present.
 ## Tier Labels
 Slovo uses these public standard-library tier labels:
 | Tier | Meaning |
 | --- | --- |
 | `beta-supported` | Exported from `lib/std`, covered by current beta source-search, promotion, facade, or composition gates, and suitable for beta programs. Names and behavior are still beta contracts, not a stable `1.0.0` freeze. |
 | `experimental` | Exported or documented in the beta line, but intentionally fluid because the domain still depends on deferred language, runtime, resource, platform, or schema policy. Use for feedback and narrow programs, not compatibility promises. |
 | `internal` | Not public standard-library API. This includes non-exported helper names, module-local concrete aliases, implementation details, generated-document internals, and private runtime symbols. Internal names may be omitted from public catalogs or changed without migration promises. |
 ## Catalog Boundary
 [`STDLIB_API.md`](STDLIB_API.md) is the generated signature inventory: it lists
 exported `(fn ...)` helpers from `lib/std/*.slo`, normalizes module-local
 concrete aliases to public concrete types, and omits non-exported helpers and
 `(type ...)` aliases.
 This ledger is the public maturity companion to that generated catalog. If the
 catalog lists a signature, read the tier marker beside that signature as the
 generated summary of this ledger. The generated catalog is a beta discovery
 aid, not a stable Markdown schema or stable API freeze.
 ## Current Tier Ledger
 | Surface | Current tier | Notes |
 | --- | --- | --- |
 | `std.cli`, `std.env`, `std.io`, `std.math`, `std.num`, `std.option`, `std.process`, `std.result`, and byte-oriented `std.string` helpers | `beta-supported` | Current source facade helpers over promoted concrete runtime/value families. The beta label still allows additive changes and scoped migrations before `1.0.0`. |
 | Concrete vector modules: `std.vec_i32`, `std.vec_i64`, `std.vec_f64`, `std.vec_bool`, and `std.vec_string` | `beta-supported` | These are concrete immutable vector lanes over existing concrete runtime families. This is not a generic collections freeze and does not imply executable generics, generic aliases, maps, sets, iterators, mutable vectors, slice/view APIs, runtime collection changes, or stable ABI/layout. |
 | Basic filesystem text/status helpers such as `read_text`, `write_text_result`, `exists`, `is_file`, `is_dir`, `remove_file_result`, and `create_dir_result` | `beta-supported` | Current concrete file helpers remain beta contracts over host filesystem behavior. Platform-specific errors and richer host-error ADTs remain deferred. |
 | Filesystem resource-handle helpers such as `open_text_read_result`, `read_open_text_result`, `close_result`, `read_text_via_handle_result`, and `close_ok` | `experimental` | Handles are beta-scoped opaque `i32` values. Writable handles, directory handles/enumeration, stable handle ABI/layout, and richer platform error policy remain deferred. |
 | `std.json` | `experimental` | Includes compact JSON text construction, exact primitive scalar token parsing, ASCII string-token parsing, and scalar document parsing. Object/array parsing, recursive `JsonValue`, parser/tokenizer objects, maps/sets, streaming, broad Unicode escape policy, embedded NUL policy, stable text encoding policy, and stable JSON API compatibility remain deferred. |
 | `std.net` | `experimental` | Current blocking loopback TCP facade only. DNS, TLS, UDP, async IO, non-loopback binding, HTTP frameworks, stable socket ABI/layout, and rich host-error ADTs remain deferred. |
 | `std.random` and `std.time` | `experimental` | Available as narrow beta host facades, but deterministic testing policy, seeding/time-source contracts, monotonic/wall-clock distinctions, reproducibility guarantees, and stable platform behavior remain deferred. |
 | Non-exported helper names, module-local aliases, private runtime symbols, generated catalog internals, and release-tool implementation details | `internal` | Not part of the public standard-library compatibility surface. |
 ## Explicit Non-Changes
 This ledger does not promote:
 - source-language syntax
 - standard-library helper additions, removals, or renames
 - compiler-known runtime names
 - runtime behavior changes
 - executable generics or generic aliases
 - generic stdlib dispatch
 - maps, sets, iterators, mutable vectors, or slice/view APIs
 - object/array JSON parsing or stable JSON schemas
 - DNS, TLS, UDP, async networking, or non-loopback binding
 - stable resource-handle ABI/layout
 - stable artifact-manifest schema
 - stable generated Markdown schema
 - stable `1.0.0` standard-library/API compatibility freeze
--- a/examples/projects/std-import-json/src/main.slo
+++ b/examples/projects/std-import-json/src/main.slo
@ -1,6 +1,6 @@
 (module main)
-(import std.json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result 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 parse_null_document_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+(import std.json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
 (type JsonText string)
@ -92,57 +92,6 @@
      false)
    false))
 (fn imported_json_parse_document_trimmed_success () -> bool
  (if (= (unwrap_ok (parse_string_document_result " \t\n\"slovo\" \n\t")) "slovo")
    (if (unwrap_ok (parse_bool_document_result "\n true \t"))
      (if (= (unwrap_ok (parse_i32_document_result " -7 ")) -7)
        (if (= (unwrap_ok (parse_u32_document_result " 7 ")) 7u32)
          (if (= (unwrap_ok (parse_i64_document_result " 8 ")) 8i64)
            (if (= (unwrap_ok (parse_u64_document_result " 9 ")) 9u64)
              (if (= (unwrap_ok (parse_f64_document_result " 1e2 ")) 100.0)
                (unwrap_ok (parse_null_document_result " null "))
                false)
              false)
            false)
          false)
        false)
      false)
    false))
 (fn imported_json_parse_document_plain_success () -> bool
  (if (= (unwrap_ok (parse_string_document_result "\"plain\"")) "plain")
    (if (= (unwrap_ok (parse_bool_document_result "false")) false)
      (if (= (unwrap_ok (parse_i32_document_result "-8")) -8)
        (if (= (unwrap_ok (parse_u32_document_result "8")) 8u32)
          (if (= (unwrap_ok (parse_i64_document_result "9")) 9i64)
            (if (= (unwrap_ok (parse_u64_document_result "10")) 10u64)
              (if (= (unwrap_ok (parse_f64_document_result "1.5")) 1.5)
                (unwrap_ok (parse_null_document_result "null"))
                false)
              false)
            false)
          false)
        false)
      false)
    false))
 (fn imported_json_parse_document_trailing_failure () -> bool
  (if (= (unwrap_err (parse_string_document_result " \t\"slovo\"x \n")) 1)
    (if (= (unwrap_err (parse_bool_document_result " truex ")) 1)
      (if (= (unwrap_err (parse_i32_document_result " -7x ")) 1)
        (if (= (unwrap_err (parse_u32_document_result " 7x ")) 1)
          (if (= (unwrap_err (parse_i64_document_result " 8x ")) 1)
            (if (= (unwrap_err (parse_u64_document_result " 9x ")) 1)
              (if (= (unwrap_err (parse_f64_document_result " 1.5x ")) 1)
                (= (unwrap_err (parse_null_document_result " nullx ")) 1)
                false)
              false)
            false)
          false)
        false)
      false)
    false))
 (fn imported_json_fields () -> bool
  (if (= (field_string "name" "slo\"vo") "\"name\":\"slo\\\"vo\"")
    (if (= (field_bool "ok" true) "\"ok\":true")
@ -190,9 +139,6 @@
        (if (imported_json_parse_scalar_failure)
          (if (imported_json_parse_string_success)
            (if (imported_json_parse_string_failure)
              (if (imported_json_parse_document_trimmed_success)
                (if (imported_json_parse_document_plain_success)
                  (if (imported_json_parse_document_trailing_failure)
              (if (imported_json_fields)
                (imported_json_arrays_objects)
                false)
@ -201,9 +147,6 @@
          false)
        false)
      false)
          false)
        false)
      false)
    false))
 (fn main () -> i32
@ -229,15 +172,6 @@
 (test "explicit std json string token parse failure facade"
  (imported_json_parse_string_failure))
 (test "explicit std json document parse trimmed success facade"
  (imported_json_parse_document_trimmed_success))
 (test "explicit std json document parse plain success facade"
  (imported_json_parse_document_plain_success))
 (test "explicit std json document parse trailing failure facade"
  (imported_json_parse_document_trailing_failure))
 (test "explicit std json fields facade"
  (imported_json_fields))
--- a/examples/projects/std-layout-local-json/src/json.slo
+++ b/examples/projects/std-layout-local-json/src/json.slo
@ -1,6 +1,4 @@
-(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result 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 parse_null_document_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
 (import string (trim_ascii))
 (type JsonText string)
@ -58,30 +56,6 @@
    (ok bool i32 true)
    (err bool i32 1)))
 (fn parse_string_document_result ((document string)) -> (result string i32)
  (parse_string_value_result (trim_ascii document)))
 (fn parse_bool_document_result ((document string)) -> (result bool i32)
  (parse_bool_value_result (trim_ascii document)))
 (fn parse_i32_document_result ((document string)) -> (result i32 i32)
  (parse_i32_value_result (trim_ascii document)))
 (fn parse_u32_document_result ((document string)) -> (result u32 i32)
  (parse_u32_value_result (trim_ascii document)))
 (fn parse_i64_document_result ((document string)) -> (result i64 i32)
  (parse_i64_value_result (trim_ascii document)))
 (fn parse_u64_document_result ((document string)) -> (result u64 i32)
  (parse_u64_value_result (trim_ascii document)))
 (fn parse_f64_document_result ((document string)) -> (result f64 i32)
  (parse_f64_value_result (trim_ascii document)))
 (fn parse_null_document_result ((document string)) -> (result bool i32)
  (parse_null_value_result (trim_ascii document)))
 (fn field_fragment ((name string) (encoded_value JsonText)) -> JsonField
  (std.string.concat (std.string.concat (quote_string name) ":") encoded_value))
--- a/examples/projects/std-layout-local-json/src/main.slo
+++ b/examples/projects/std-layout-local-json/src/main.slo
@ -1,6 +1,6 @@
 (module main)
-(import json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result 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 parse_null_document_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+(import json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
 (type JsonText string)
@ -92,57 +92,6 @@
      false)
    false))
 (fn imported_json_parse_document_trimmed_success () -> bool
  (if (= (unwrap_ok (parse_string_document_result " \t\n\"slovo\" \n\t")) "slovo")
    (if (unwrap_ok (parse_bool_document_result "\n true \t"))
      (if (= (unwrap_ok (parse_i32_document_result " -7 ")) -7)
        (if (= (unwrap_ok (parse_u32_document_result " 7 ")) 7u32)
          (if (= (unwrap_ok (parse_i64_document_result " 8 ")) 8i64)
            (if (= (unwrap_ok (parse_u64_document_result " 9 ")) 9u64)
              (if (= (unwrap_ok (parse_f64_document_result " 1e2 ")) 100.0)
                (unwrap_ok (parse_null_document_result " null "))
                false)
              false)
            false)
          false)
        false)
      false)
    false))
 (fn imported_json_parse_document_plain_success () -> bool
  (if (= (unwrap_ok (parse_string_document_result "\"plain\"")) "plain")
    (if (= (unwrap_ok (parse_bool_document_result "false")) false)
      (if (= (unwrap_ok (parse_i32_document_result "-8")) -8)
        (if (= (unwrap_ok (parse_u32_document_result "8")) 8u32)
          (if (= (unwrap_ok (parse_i64_document_result "9")) 9i64)
            (if (= (unwrap_ok (parse_u64_document_result "10")) 10u64)
              (if (= (unwrap_ok (parse_f64_document_result "1.5")) 1.5)
                (unwrap_ok (parse_null_document_result "null"))
                false)
              false)
            false)
          false)
        false)
      false)
    false))
 (fn imported_json_parse_document_trailing_failure () -> bool
  (if (= (unwrap_err (parse_string_document_result " \t\"slovo\"x \n")) 1)
    (if (= (unwrap_err (parse_bool_document_result " truex ")) 1)
      (if (= (unwrap_err (parse_i32_document_result " -7x ")) 1)
        (if (= (unwrap_err (parse_u32_document_result " 7x ")) 1)
          (if (= (unwrap_err (parse_i64_document_result " 8x ")) 1)
            (if (= (unwrap_err (parse_u64_document_result " 9x ")) 1)
              (if (= (unwrap_err (parse_f64_document_result " 1.5x ")) 1)
                (= (unwrap_err (parse_null_document_result " nullx ")) 1)
                false)
              false)
            false)
          false)
        false)
      false)
    false))
 (fn imported_json_fields () -> bool
  (if (= (field_string "name" "slo\"vo") "\"name\":\"slo\\\"vo\"")
    (if (= (field_bool "ok" true) "\"ok\":true")
@ -190,9 +139,6 @@
        (if (imported_json_parse_scalar_failure)
          (if (imported_json_parse_string_success)
            (if (imported_json_parse_string_failure)
              (if (imported_json_parse_document_trimmed_success)
                (if (imported_json_parse_document_plain_success)
                  (if (imported_json_parse_document_trailing_failure)
              (if (imported_json_fields)
                (imported_json_arrays_objects)
                false)
@ -201,9 +147,6 @@
          false)
        false)
      false)
          false)
        false)
      false)
    false))
 (fn main () -> i32
@ -229,15 +172,6 @@
 (test "explicit local json string token parse failure facade"
  (imported_json_parse_string_failure))
 (test "explicit local json document parse trimmed success facade"
  (imported_json_parse_document_trimmed_success))
 (test "explicit local json document parse plain success facade"
  (imported_json_parse_document_plain_success))
 (test "explicit local json document parse trailing failure facade"
  (imported_json_parse_document_trailing_failure))
 (test "explicit local json fields facade"
  (imported_json_fields))
--- a/examples/projects/std-layout-local-json/src/string.slo
+++ b/examples/projects/std-layout-local-json/src/string.slo
@ -1,55 +0,0 @@
 (module string (export trim_ascii))
 (fn len ((value string)) -> i32
  (std.string.len value))
 (fn byte_at_result ((value string) (index i32)) -> (result i32 i32)
  (std.string.byte_at_result value index))
 (fn slice_result ((value string) (start i32) (count i32)) -> (result string i32)
  (std.string.slice_result value start count))
 (fn is_ascii_trim_byte ((value i32)) -> bool
  (if (= value 9)
    true
    (if (= value 10)
      true
      (if (= value 11)
        true
        (if (= value 12)
          true
          (if (= value 13)
            true
            (= value 32)))))))
 (fn byte_is_ascii_trim ((value string) (position i32)) -> bool
  (match (byte_at_result value position)
    ((ok byte)
      (is_ascii_trim_byte byte))
    ((err code)
      false)))
 (fn trim_ascii_start ((value string)) -> string
  (let value_len i32 (len value))
  (var start i32 0)
  (while (and (< start value_len) (byte_is_ascii_trim value start))
    (set start (+ start 1)))
  (match (slice_result value start (- value_len start))
    ((ok text)
      text)
    ((err code)
      value)))
 (fn trim_ascii_end ((value string)) -> string
  (let value_len i32 (len value))
  (var end i32 value_len)
  (while (and (> end 0) (byte_is_ascii_trim value (- end 1)))
    (set end (- end 1)))
  (match (slice_result value 0 end)
    ((ok text)
      text)
    ((err code)
      value)))
 (fn trim_ascii ((value string)) -> string
  (trim_ascii_end (trim_ascii_start value)))
--- a/lib/std/README.md
+++ b/lib/std/README.md
@ -42,13 +42,10 @@ compiler-known runtime calls; `1.0.0-beta.7` serialization work releases
 `1.0.0-beta.17` JSON foundation adds primitive scalar token parse facades for
 booleans, concrete numeric primitives, and exact `null`; the Slovo-facing
 `1.0.0-beta.18` JSON foundation adds one ASCII string-token parse
-facade; the `1.0.0-beta.21` JSON foundation adds source-authored
+facade; the
 whole-document scalar parse facades over `std.string.trim_ascii` and the
 existing exact value-token parsers; the
 `1.0.0-beta.8` concrete type alias target keeps that same helper surface while
 using local `JsonText` and `JsonField` aliases as transparent names for
-`string` JSON fragments; `1.0.0-beta.23` adds the public
+`string` JSON fragments.
 standard-library stability tier ledger without changing this helper surface.
 This directory is the source home for staged standard library modules and
 examples. exp-44 lets project-mode source explicitly import `std/math.slo` as
@ -114,15 +111,10 @@ and the current `std.num.*_to_string` helpers. The Slovo-facing
 facades over promoted `std.json` bool/numeric runtime helpers and an exact
 source-only `null` token helper. The `1.0.0-beta.18` JSON foundation
 adds `parse_string_value_result` for one already-isolated ASCII JSON string
-token over the matching promoted runtime helper. The
+token over the matching promoted runtime helper. Full JSON document parsing,
-`1.0.0-beta.21` JSON foundation adds source-authored
+object/array parsing, recursive JSON values, maps/sets, streaming decoders or
-`parse_*_document_result` helpers for string, bool, concrete numeric
+encoders, schema validation, Unicode escape decoding/normalization, embedded
-primitives, and exact `null` by trimming ASCII whitespace around the whole
+NUL policy, and stable text encoding policy remain deferred;
 document and delegating to those exact value-token parsers. Object/array
 parsing, recursive JSON values, maps/sets, streaming decoders or encoders,
 schema validation, Unicode escape decoding/normalization beyond the existing
 string-token behavior, embedded NUL policy, and stable text encoding policy
 remain deferred;
 `1.0.0-beta.8` targets top-level concrete type aliases in source facades and
 uses `JsonText` / `JsonField` only as local transparent aliases inside
 `std/json.slo` and matching local JSON fixtures. These aliases are not exported
@ -171,18 +163,6 @@ make the standard library fully self-hosted, does not add automatic
 standard-library imports, and does not replace the compiler-known `std.*`
 standard-runtime calls cataloged in `../STANDARD_RUNTIME.md`.
 `docs/language/STDLIB_API.md` remains the generated exact signature catalog
 for exported helpers in this directory. `docs/language/STDLIB_TIERS.md` is the
 beta23 public maturity ledger for that catalog. It defines the tier labels
 `beta-supported`, `experimental`, and `internal`; classifies JSON, loopback
 networking, random/time, and filesystem resource-handle helpers as
 experimental domains; and records the concrete vector modules as
 beta-supported concrete lanes, not a generic collections freeze. The tier
 ledger is documentation/catalog tooling clarity only and does not add helpers,
 syntax, runtime behavior, stable Markdown schema, or a stable stdlib/API
 freeze. The generated catalog and release gate now expose and check tier
 metadata.
 The current `.slo` files use flat module declarations such as `(module math)`.
 For exp-44, exp-45, exp-47, exp-48, exp-49, exp-52, exp-53, exp-76, exp-94,
 exp-96, exp-97, exp-98, exp-99, exp-103, exp-104, exp-105, exp-107, exp-108,
@ -350,18 +330,11 @@ array, and small object text from existing string and number helpers.
 `1.0.0-beta.17` adds primitive scalar token parse facades for `bool`, `i32`,
 `u32`, `i64`, `u64`, `f64`, and exact `null` only. The
 `1.0.0-beta.18` source facade adds `parse_string_value_result` for one exact
-ASCII JSON string token with simple escape decoding. The
+ASCII JSON string token with simple escape decoding. It is not a full JSON
-`1.0.0-beta.21` source facade adds `parse_string_document_result`,
+parser and does not define object/array parsing, recursive JSON values,
-`parse_bool_document_result`, `parse_i32_document_result`,
+maps/sets, streaming decoders or encoders, schema validation, Unicode escape
-`parse_u32_document_result`, `parse_i64_document_result`,
+decoding/normalization, embedded NUL policy, or stable text encoding policy
-`parse_u64_document_result`, `parse_f64_document_result`, and
+beyond the current runtime string ABI.
 `parse_null_document_result`; each trims ASCII whitespace around the whole
 document with `std.string.trim_ascii`, then delegates to the matching exact
 value-token parser. It is not a full JSON parser and does not define
 object/array parsing, recursive JSON values, maps/sets, streaming decoders or
 encoders, schema validation, Unicode escape decoding/normalization beyond the
 existing string-token behavior, embedded NUL policy, or stable text encoding
 policy beyond the current runtime string ABI.
 `std/process.slo` includes the exp-52 narrow source wrappers over already
 released process argument runtime calls and a source-authored `has_arg`
 predicate. exp-61 adds `arg_or` and `arg_or_empty` as ordinary source
--- a/lib/std/json.slo
+++ b/lib/std/json.slo
@ -1,6 +1,4 @@
-(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result 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 parse_null_document_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value parse_string_value_result parse_bool_value_result parse_i32_value_result parse_u32_value_result parse_i64_value_result parse_u64_value_result parse_f64_value_result parse_null_value_result field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
 (import std.string (trim_ascii))
 (type JsonText string)
@ -58,30 +56,6 @@
    (ok bool i32 true)
    (err bool i32 1)))
 (fn parse_string_document_result ((document string)) -> (result string i32)
  (parse_string_value_result (trim_ascii document)))
 (fn parse_bool_document_result ((document string)) -> (result bool i32)
  (parse_bool_value_result (trim_ascii document)))
 (fn parse_i32_document_result ((document string)) -> (result i32 i32)
  (parse_i32_value_result (trim_ascii document)))
 (fn parse_u32_document_result ((document string)) -> (result u32 i32)
  (parse_u32_value_result (trim_ascii document)))
 (fn parse_i64_document_result ((document string)) -> (result i64 i32)
  (parse_i64_value_result (trim_ascii document)))
 (fn parse_u64_document_result ((document string)) -> (result u64 i32)
  (parse_u64_value_result (trim_ascii document)))
 (fn parse_f64_document_result ((document string)) -> (result f64 i32)
  (parse_f64_value_result (trim_ascii document)))
 (fn parse_null_document_result ((document string)) -> (result bool i32)
  (parse_null_value_result (trim_ascii document)))
 (fn field_fragment ((name string) (encoded_value JsonText)) -> JsonField
  (std.string.concat (std.string.concat (quote_string name) ":") encoded_value))
--- a/scripts/check-stdlib-api-tiers.js
+++ b/scripts/check-stdlib-api-tiers.js
@ -1,80 +0,0 @@
 #!/usr/bin/env node
 "use strict";
 const fs = require("fs");
 const path = require("path");
 const repoRoot = path.resolve(__dirname, "..");
 const catalogPath = path.join(repoRoot, "docs", "language", "STDLIB_API.md");
 const catalog = fs.readFileSync(catalogPath, "utf8");
 function fail(message) {
  console.error(`stdlib API tier check failed: ${message}`);
  process.exit(1);
 }
 function requireText(text, message) {
  if (!catalog.includes(text)) {
    fail(message);
  }
 }
 function moduleSection(moduleName) {
  const marker = `### std.${moduleName}\n`;
  const start = catalog.indexOf(marker);
  if (start < 0) {
    fail(`missing std.${moduleName} module section`);
  }
  const next = catalog.indexOf("\n### std.", start + marker.length);
  return next < 0 ? catalog.slice(start) : catalog.slice(start, next);
 }
 function requireModuleTier(moduleName, expectedTier) {
  const section = moduleSection(moduleName);
  if (!section.includes(`- Tiers: \`${expectedTier}\``)) {
    fail(`std.${moduleName} is not marked as ${expectedTier}`);
  }
 }
 function requireHelperTier(moduleName, helperName, expectedTier) {
  const section = moduleSection(moduleName);
  const helperPattern = new RegExp(`^- \`${expectedTier}\` \`${helperName} `, "m");
  if (!helperPattern.test(section)) {
    fail(`std.${moduleName}.${helperName} is not marked as ${expectedTier}`);
  }
 }
 if (/experimental`: not used|experimental not used/i.test(catalog)) {
  fail("catalog still contains stale wording that says experimental is unused");
 }
 requireText("- `beta-supported`:", "missing beta-supported tier definition");
 requireText("- `experimental`:", "missing experimental tier definition");
 requireText("- `internal`:", "missing internal tier definition");
 requireText("- `experimental` helper signatures:", "missing experimental summary count");
 requireText("Concrete `std.vec_*` modules are beta-supported as concrete helper families only; this does not freeze a generic collection API.", "missing concrete vector boundary");
 if (!/^- `experimental` `[^`]+`/m.test(catalog)) {
  fail("catalog does not list any experimental helper signatures");
 }
 for (const moduleName of ["json", "net", "random", "time"]) {
  requireModuleTier(moduleName, "experimental");
 }
 for (const helperName of [
  "open_text_read_result",
  "read_open_text_result",
  "close_result",
  "read_text_via_handle_result",
  "close_ok",
 ]) {
  requireHelperTier("fs", helperName, "experimental");
 }
 for (const moduleName of ["vec_bool", "vec_f64", "vec_i32", "vec_i64", "vec_string"]) {
  const section = moduleSection(moduleName);
  if (!section.includes("- Note: concrete-only vector helper family; no generic collection freeze.")) {
    fail(`std.${moduleName} is missing the concrete vector boundary note`);
  }
 }
--- a/scripts/release-gate.sh
+++ b/scripts/release-gate.sh
@ -9,11 +9,8 @@ cd "${repo_root}"
 git diff --check
 bash -n scripts/install.sh
 bash -n scripts/render-stdlib-api-doc.sh
 node --check scripts/render-stdlib-api-doc.js
 node --check scripts/check-stdlib-api-tiers.js
 "${repo_root}/scripts/render-stdlib-api-doc.sh"
 "${repo_root}/scripts/check-stdlib-api-tiers.js"
 git diff --check
 if ! git diff --quiet -- docs/language/STDLIB_API.md; then
  echo "standard library API catalog changed; review and commit generated docs before release" >&2
@ -74,10 +71,6 @@ cargo test --test standard_json_scalar_parsing_beta17
 cargo test --test standard_json_string_parsing_beta18
 cargo test --test test_discovery_beta19
 cargo test --test standard_string_search_trim_beta20
 cargo test --test standard_json_document_scalar_parsing_beta21
 cargo test --test run_manifest_beta22
 cargo test --test package_workspace_discipline_beta24
 cargo test --test user_project_conformance_beta25
 # Full cargo test includes unignored integration gates such as dx_v1_7,
 # beta_v2_0_0_beta_1, and beta_1_0_0.
 cargo test
--- a/scripts/render-stdlib-api-doc.js
+++ b/scripts/render-stdlib-api-doc.js
@ -9,46 +9,6 @@ const stdDir = path.join(repoRoot, "lib", "std");
 const outputPath = path.join(repoRoot, "docs", "language", "STDLIB_API.md");
 const readmePath = path.join(repoRoot, "README.md");
 const TIERS = Object.freeze({
  BETA_SUPPORTED: "beta-supported",
  EXPERIMENTAL: "experimental",
  INTERNAL: "internal",
 });
 const EXPERIMENTAL_MODULES = new Set(["json", "net", "random", "time"]);
 const EXPERIMENTAL_HELPERS = new Map([
  [
    "fs",
    new Set([
      "open_text_read_result",
      "read_open_text_result",
      "close_result",
      "read_text_via_handle_result",
      "close_ok",
    ]),
  ],
 ]);
 const CONCRETE_VEC_MODULES = new Set(["vec_bool", "vec_f64", "vec_i32", "vec_i64", "vec_string"]);
 function helperTier(moduleName, exportName) {
  if (EXPERIMENTAL_MODULES.has(moduleName)) {
    return TIERS.EXPERIMENTAL;
  }
  const experimentalHelpers = EXPERIMENTAL_HELPERS.get(moduleName);
  if (experimentalHelpers && experimentalHelpers.has(exportName)) {
    return TIERS.EXPERIMENTAL;
  }
  return TIERS.BETA_SUPPORTED;
 }
 function uniqueSorted(values) {
  return Array.from(new Set(values)).sort();
 }
 function tokenize(source) {
  const tokens = [];
  let index = 0;
@ -244,11 +204,7 @@ function stdModules() {
      for (const exported of module.exports) {
        if (functions.has(exported)) {
-          signatures.push({
+          signatures.push(functionSignature(functions.get(exported), aliases, relativePath));
            name: exported,
            signature: functionSignature(functions.get(exported), aliases, relativePath),
            tier: helperTier(module.name, exported),
          });
        } else if (aliases.has(exported)) {
          omittedAliasExports.push(exported);
        } else {
@ -260,7 +216,6 @@ function stdModules() {
        fileName,
        relativePath,
        name: module.name,
        tiers: uniqueSorted(signatures.map((signature) => signature.tier)),
        signatures,
        omittedAliasExports,
      };
@ -279,15 +234,6 @@ function releaseVersion() {
 function render(modules, version) {
  const totalExports = modules.reduce((count, module) => count + module.signatures.length, 0);
  const totalOmittedAliases = modules.reduce((count, module) => count + module.omittedAliasExports.length, 0);
  const tierCounts = new Map([
    [TIERS.BETA_SUPPORTED, 0],
    [TIERS.EXPERIMENTAL, 0],
  ]);
  for (const module of modules) {
    for (const signature of module.signatures) {
      tierCounts.set(signature.tier, (tierCounts.get(signature.tier) || 0) + 1);
    }
  }
  const out = [];
  out.push("# Slovo Standard Library API Catalog");
  out.push("");
@ -297,13 +243,12 @@ function render(modules, version) {
  out.push("## Stability Tiers");
  out.push("");
  out.push("- `beta-supported`: exported from `lib/std` and covered by source-search, promotion, or facade gates in the current beta line.");
-  out.push(`- \`experimental\`: exported from \`lib/std\` in \`${version}\`, but still has beta caveats around host behavior, resource handles, or API shape.`);
+  out.push(`- \`experimental\`: not used for exported \`lib/std\` helpers in \`${version}\`; future releases may mark new helpers this way before they graduate.`);
  out.push("- `internal`: helper names that are not exported from their module; they are intentionally omitted from this catalog.");
  out.push("");
  out.push("The catalog is a beta API discovery aid, not a stable `1.0.0` standard-library freeze.");
  out.push("Module-local concrete aliases are normalized in signatures so names such as `VecI32` and `ResultU64` do not leak into the public catalog.");
  out.push("Only exported `(fn ...)` helpers are listed; `(type ...)` aliases and non-exported helpers are omitted.");
  out.push("Concrete `std.vec_*` modules are beta-supported as concrete helper families only; this does not freeze a generic collection API.");
  out.push("");
  out.push("## Summary");
  out.push("");
@ -311,8 +256,6 @@ function render(modules, version) {
  out.push(`- Exported helper signatures: ${totalExports}`);
  out.push(`- Exported type aliases omitted: ${totalOmittedAliases}`);
  out.push("- Default tier: `beta-supported`");
  out.push(`- \`${TIERS.BETA_SUPPORTED}\` helper signatures: ${tierCounts.get(TIERS.BETA_SUPPORTED) || 0}`);
  out.push(`- \`${TIERS.EXPERIMENTAL}\` helper signatures: ${tierCounts.get(TIERS.EXPERIMENTAL) || 0}`);
  out.push("");
  out.push("## Modules");
  out.push("");
@ -320,14 +263,11 @@ function render(modules, version) {
    out.push(`### std.${module.name}`);
    out.push("");
    out.push(`- Path: \`${module.relativePath}\``);
-    out.push(`- Tiers: ${module.tiers.map((tier) => `\`${tier}\``).join(", ")}`);
+    out.push("- Tier: `beta-supported`");
    out.push(`- Exported helper signatures: ${module.signatures.length}`);
    if (CONCRETE_VEC_MODULES.has(module.name)) {
      out.push("- Note: concrete-only vector helper family; no generic collection freeze.");
    }
    out.push("");
-    for (const { signature, tier } of module.signatures) {
+    for (const signature of module.signatures) {
-      out.push(`- \`${tier}\` \`${signature}\``);
+      out.push(`- \`${signature}\``);
    }
    out.push("");
  }