SEMAPRAX v0.4.1

SEMAPRAX v0.4.1 is pre-alpha research software.

Changes

• Fix a temporary-path collision between two copies of the same owned-data
  native test helper. owned_vec_bytes_runtime/native.rs is
  #[path]-included by two modules of one test binary, so it is compiled
  twice and each copy owns a separate case counter starting at zero - while
  both named their scratch files from the process id and that counter alone.
  Two tests in the same process therefore shared a .c path and a binary
  path, which is exactly what the hosted shard reported twice: one run could
  not execute a binary a concurrent clang still held open (ETXTBSY), the
  next could not read a .c file the other copy's cleanup had already
  removed. The name now includes the module path, so the two copies cannot
  collide. The generated public generic consumer gate, which also compiles
  and then executes, retries a launch refused with ETXTBSY rather than
  adding another way for a foreign fork to redden an unrelated shard.

• Make the generated C and C++ public generic consumers build on Windows.
  The hosted leg found two things a Unix-only run could not: the UCRT marks
  the standard fopen deprecated in favour of its own fopen_s, which a
  -Werror build turns into an error, and a compiled consumer needs the
  host's executable name because Windows resolves a bare consumer by
  looking for consumer.exe. The generated sources now opt out of that
  deprecation, and the gate names the executable per host.
  The C++ consumer also drops std::span, which it used only to carry a
  pointer and a length together: a pointer and a size are the same
  information, so the generated artifact no longer needs a C++20 library
  header and builds under C++17. The compile check now fails on a warning
  or an error in the toolchain's output rather than on any output at all,
  because "compiles warning-free" is the claim; a linker note about
  something else is not evidence about the generated code.

• Make generated public generic consumers independent of the checkout that
  produced them. The fixed part of each consumer is an included template,
  and a Windows checkout delivers .txt with CRLF, so every placeholder
  whose match included its newline silently stopped substituting: the
  generated files kept their literal placeholders and lost both their type
  declarations and their embedded metadata. Templates are now normalized at
  generation time, .gitattributes pins .txt to LF like every other
  embedded text asset, and the generator itself asserts that no generated
  file carries a carriage return or a surviving placeholder — so this class
  fails where it happens rather than as a downstream expectation on one
  platform. A generator that only worked because of a checkout setting was
  not the deterministic generator the milestone claims.

• Guard the Windows checkout of the public generic ownership milestone job.
  Its first hosted run failed on windows-latest before any gate executed:
  the checkout itself cannot write this repository's retained evidence paths
  without core.longpaths, which every other Windows job already sets. The
  cross-platform leg was therefore reporting a checkout limit, not a
  milestone result.

• Add Public Generic Candidate Delta v1, milestone gate PG-4: a
  candidate-bound delta that describes the selected exports of an immutable
  Project candidate's base and final revisions over the public generic
  grammar, classifies the pair with the PG-3 rules, and binds the candidate
  digest, both Project and workspace revisions, both graph digests and a
  domain-separated facts digest. Inclusion is grammar-strict, so an entry in
  the delta is exactly a candidate public generic signature: no admitted
  export has one today, which makes the generic fixture all-excluded with
  the closed reason borrowed_byte_view - and the gate asserts its rendered
  bytes carry no template identity, instance term, record identity, or even
  the grammar's instance sigil. The substantive evidence rides on a Project
  v9 record-returning export, where a real add_record_field change is
  breaking with the finding on the record that changed and ordered
  arguments, substituted fields and owned leaves retained across mutation,
  recovery-capsule restoration and byte-exact independent replay
  (SPX-PG301-SPX-PG303).
  The grammar now also exposes Rejection::ALL and Rejection::of, so a
  consumer recovers a typed reason from the owning artifact instead of
  re-spelling its message, and the compatibility report exposes its digest.

• Add Public Generic Settlement Obligations v1: for one owned admitted
  instance parameter, which owned leaves a boundary is accountable for, in
  which order, how each is discharged, and what is released when a transfer
  fails part way - each fact bound to the compiler's own cleanup facts
  rather than derived beside them. The grammar's owned-leaf paths must equal
  the inventory's structural leaf order; each obligation is paired with its
  liveness flag in flag order and carries that flag's checked drop
  lifecycle, because an obligation whose flag does not match it has no
  stated way to be discharged; and the transfer unit is the cleanup plan's
  single whole live owned place, since reading leaves out of the plan would
  invent a per-leaf transfer the compiler never performs. Release order is
  the exact reverse of the canonical order, and every disagreement is a
  refusal (SPX-PG501, SPX-PG502) rather than a sort or a repair.
  This is the specification half of milestone gate PG-7, which stays open:
  nothing here allocates, transfers, releases or observes a runtime, and
  there is no public generic boundary to exercise on any engine.

• Wire the public generic ownership milestone corpus into CI as the
  public-generic-ownership-milestone job on ubuntu-latest,
  macos-latest and windows-latest, and declare it a release blocker so
  it cannot be satisfied vacuously. It runs the grammar, template-identity,
  compatibility and metadata-consumer projections, the separation gate, the
  frozen Project v9/v11 descriptor refusals of a selected generic result,
  and the four-language consumer gate, and it resolves and prints the
  consumer toolchains each host actually has - a language whose toolchain is
  absent is skipped, which is a narrower run rather than a pass.
  Milestone gate PG-8 stays open: the harness exists, the hosted evidence
  does not, and the gate moves only when the owning document records a run
  and job for an exact implementation commit.

• Add Public Generic Metadata Consumers v1: a Rust, TypeScript/Wasm, C11
  and C++ consumer generated from a candidate public generic surface, plus
  the length-framed canonical metadata format they read. Before a foreign
  toolchain can call a public generic export, several of them have to agree
  on what its types are and refuse everything else - and that is
  falsifiable without a calling convention. All four consumers are compiled
  warning-free and run for real against nine hostile documents, and each
  must report the same closed refusal (malformed, term, mismatch) as
  the others and as the Rust reference reader; the gate fails when no
  toolchain was available rather than passing silently. Identifiers come
  from term bytes rather than display names, nested instances are declared
  before their holders so C and C++ never see an incomplete type, and
  regeneration is byte-identical.
  This closes the grammar half of milestone gates PG-5 and PG-6; both stay
  open for their descriptor half, because no public generic descriptor,
  carrier or calling convention exists. No generated consumer receives a
  SEMAPRAX value, allocates one, frees one, or links against anything, and
  every generated file says so in its own banner.

• Add Public Generic Compatibility v1, gate PG-3 of the public generic
  ownership milestone: candidate surfaces over the type grammar, and a
  closed thirteen-reason classification of one ordered pair of them. The
  rules are deliberately stricter than source compatibility, because a
  foreign consumer reads the whole substituted field tree and owned-leaf
  shape of what it receives: adding a Copy field to a nested reachable
  record is breaking even though no canonical term, parameter position or
  owned-leaf path moves, and it is reported once on the record that changed
  rather than on every position mentioning it. Presentation is never
  compatibility - renaming records, type parameters, fields, exports and
  parameters yields unchanged with an identical surface digest - and a
  parameter's value identity is excluded for the same reason the repository
  excludes it elsewhere: a revision-scoped fact must not move a verdict.
  A signature position that is not a data type gets its own closed
  view: vocabulary instead of widening the grammar. Both artifacts are
  canonical JSON with directional byte-exact replay
  (SPX-PG201-SPX-PG204), and both record that no semantic-version,
  support, publication or runtime conclusion follows from a verdict.
  A candidate surface is a description, not an admission: no public generic
  signature is admitted, and local evidence is the only evidence.

• Add Public Generic Type Grammar v1, gates PG-1 and PG-2 of the public
  generic ownership milestone: a versioned, target-neutral term for the
  types a public generic surface could name, plus the explicit template and
  ordered argument identities derived from it. Identities are
  length-prefixed in bytes, so an identity holding the grammar's own
  punctuation still round trips and two distinct types can never render
  alike; digests are computed over persistent identities, declared arity and
  ordered parameter positions, so a record, parameter or field display
  rename changes nothing while argument permutation, duplication or
  substitution changes the instance identity and omission is an
  arity_mismatch refusal. The vocabulary is closed to the eight Copy
  scalars, direct Bytes and fully concrete authored records; the other
  twelve reasons reject, bounds refuse instead of truncating, and replay is
  byte-exact against an independent recomputation. It is deliberately not
  the compiler's internal, unversioned identity_key spelling.
  Local evidence only: no hosted run, no descriptor, carrier, package or
  consumer selects the grammar, and public generic ownership remains
  unsupported and unpublished.

• Make public generic ownership a separate milestone instead of a side
  effect of the internal generic closure. The new
  Public Generic Ownership milestone
  owns nine prerequisite gates - a versioned target-neutral type grammar,
  explicit template and ordered argument identities, semantic compatibility
  rules, candidate ABI-delta evidence, generated Rust/TypeScript-Wasm/C/C++
  consumers, hostile metadata replay, owned allocation and failure
  settlement, cross-platform hosted evidence, and the explicit support and
  publication decision - plus separation invariants and an executable
  separation gate. The gate selects a generic template, a concrete
  generic-instance result and an owned generic parameter through the
  canonical ABI report, C header emission and the public scalar Wasm export
  edge, and pins each closed refusal, so an internal admission that starts
  producing a public generic surface reddens the build rather than becoming
  a silent public claim. Public generic ownership remains unsupported and
  unpublished; no grammar, descriptor, carrier or consumer is added here.

• Add effect-free listing cursors to std.fs, so the canonical
  immediate-name listing list already returns can be walked without a
  provider or any further authority: entry counting, per-entry span offsets,
  and an entry-name validity predicate rejecting an empty name, an embedded
  separator or NUL byte, and the two traversal names. No function gained an
  effect and the module's capability list is unchanged; recursive traversal,
  streaming and richer metadata remain Missing.

• Add the bundled std.env.policy package: a portable environment-variable
  name predicate, a value predicate, and a NAME=VALUE assignment cursor, all
  effect-free offset computations over borrowed bytes. It is a sibling package
  rather than more of std.env because the completion gate requires every
  std.env function to declare process.environment.read, and these functions
  read no environment - declaring that effect to satisfy a gate would claim a
  capability they never exercise.

• Add effect-free settlement and argument policy to std.process:
  classification of an existing settlement value as a normal exit or a signal
  termination - the only two kinds the termination encoding defines, per the
  low2-kind-0-exit-u32-or-1-signal graph fact - exit-code extraction defined
  only where the process exited normally, and argument-vector admissibility
  over borrowed bytes. A deadline expiry is deliberately not a settlement
  class: it is a call-level failure that prevents an output from existing, so
  classifying an unused bit pattern as one would invent a value no provider
  emits. Only std.process.run still carries process.execute; the new
  functions perform nothing and grant nothing, and broader physical-provider
  and general process support remain open.

• Add a checked lifecycle policy to std.agent: an admitted stage-transition
  predicate total over the lifecycle vocabulary, a terminality predicate
  consistent with it, and a deterministic bounded retry policy whose backoff is
  a pure function of the attempt count. These describe checked meaning only:
  no clock is read, no stage is executed, and the package gains no capability,
  effect or permit. Native and Wasm execution of these ordinary library
  functions still does not execute Agent stages.

• Add quoted-key validation and value cursors to std.data.toml, closing the
  key half of its recorded gap. basic_quoted_key_end admits the TOML
  basic-string escapes and rejects an unterminated string, a raw control byte
  and any other escape; literal_quoted_key_end admits '...' with no escapes;
  key_end dispatches the bare, basic-quoted and literal-quoted forms; and
  value_start, value_content_end and value_end bound a value quote-aware,
  so a # inside quotes does not open a comment and trailing spaces and tabs
  are excluded. Every scanner is an allocation-free offset computation and
  reports failure through the byte_len + 1 + offset sentinel the
  std.data.json family already uses for arbitrary-start scanners. Values stay
  uninterpreted bytes; tables, decoding, typed values and encoding remain
  Missing. Bare-key admission walks bytes directly instead of testing a growing
  byte_range sub-slice: that shape is admitted by the checker and executes on
  the interpreter and native C11, but emits a corrupt slice carrier on the Core
  Wasm lane, filed as issue #100 with a single-variable reproduction.

• Add decoded_token_eq to std.data.json.dec: two JSON string tokens in one
  input compared by their decoded bytes through the existing pull surface, with
  no buffer, so "a\u0062" and "ab" are equal keys and "\n" equals
  "\u000a". Tokens of different decoded length are unequal without decoding
  either fully. Duplicate-key detection over a whole document still needs the
  object walk in std.data.json.doc and remains Missing.

• Add the bundled std.encoding.base64 package,
  Base64 v1: pull-based padded standard Base64 encoding
  over a borrowed byte view. len gives the padded output length and byte
  gives its byte at one index, both computed from the input alone with no
  buffer, so a caller writes the digits into capacity it already owns. It is a
  sibling package because std.encoding sits on the default Project v1 route,
  which admits only Copy scalar boundaries and rejects a borrowed view.
  Decoding of padded input, streaming, and URL-safe or unpadded alphabets
  remain Missing.

• Add wrapping_mul to std.num.overflow, closing the wrapping-multiplication
  gap its own required scope recorded as Missing. The result is exact
  two's-complement wrapping for every operand pair, including i64::MIN * -1,
  i64::MIN * i64::MIN and i64::MAX * 2, and it never evaluates an
  overflowing intermediate under the language's checked arithmetic.

• Add a failure-mask discipline to std.test, so a nonzero test result names
  the failing check instead of merely being nonzero: bit_for is the bit an
  indexed case owns, bit_is_set reports membership, record_failure
  accumulates one case's verdict, and first_failure and failure_count
  report the lowest failing index and the number of failures. Indexes run 0 to
  62, record_failure refuses a bit another case already claimed, and the
  accumulated mask is monotonic, so two cases cannot silently share a bit and
  hide one another. The package's own conformance and examples modules now use
  the discipline they document.

• Add quote-aware field cursors to std.data.csv: field_end stops at the
  first comma outside quotes, field_start opens the next field,
  field_is_quoted reports the quoted form, and content_start and
  content_end bound a field's content excluding its surrounding quotes. A
  "" inside a quoted field is one escaped quote that never ends the field and
  stays in the content bytes, so decoding remains the caller's step. Empty
  records, empty quoted fields and consecutive commas yield exact offsets, and
  a walk terminates because the last field's field_start is the record
  length. The offsets compose with the std.io.lines record content and the
  std.bytes trimming offsets, and the package conformance adds a cursors
  bit to its failure mask on the interpreter, native C11 -O0/-O2 and Core
  Wasm. Typed fields, decoded content, dialects, streaming and writing remain
  Missing.

• Add explicit level filtering to std.log under the existing
  Log Writer v1 contract: level_enabled compares a
  level against a threshold on the existing 0-5 scale, event_admitted is the
  borrowed observer that is true only when the event both passes the threshold
  and fits the writer's live capacity, discard_event is the named drop path
  that consumes the event and returns the Writer untouched, and
  append_event_if writes a passing event exactly as append_event does.
  Capacity is required only for an event that is actually written, so a small
  buffer with a high threshold is a valid composition rather than a contract
  failure, and a filtered event releases its name and message bytes through
  ordinary lexical cleanup instead of being buffered. Three named cases join
  the logger corpus as individual bounded projects on the interpreter, native
  C11 -O0/-O2 and repeated Core Wasm. No sink, queue, timestamp source,
  redaction or concurrency is added.

• Add span cursors to std.bytes: is_space, trim_start, trim_end and
  is_blank for ASCII whitespace, and field_end, field_start and
  field_count for delimiter-separated fields. Field walking preserves empty
  fields, so a,,b is three fields and a trailing delimiter opens one final
  empty field, and every operation is a borrowed-view offset computation with
  no allocation and no copy. The offsets compose directly with the
  std.io.lines line content, so a bounded caller can walk a delimited record
  and trim each field without a buffer. Whitespace is exactly space, tab,
  carriage return and line feed; no Unicode whitespace class, quoting or
  escaping policy is implied.

• Add field padding to std.format under the existing
  Format Writer v1 contract: pad_len is the field
  width actually written (never narrower than the content), append_fill
  writes one repeated byte, append_str_left writes left-aligned text and
  append_usize_right right-aligned decimals. Each padded operation
  preflights the whole field rather than only its content, so a buffer that
  could hold the content but not its padding fails before any byte is written,
  and content longer than the field is written in full rather than truncated.
  Five named cases join the existing corpus as individual bounded projects on
  the interpreter, native C11 -O0/-O2 and repeated Core Wasm, and four
  further short or forged-output cases reject padded writes with the exact
  requires-false status. Alignment is byte alignment and the fill byte
  carries no character or locale policy; general format strings, arbitrary
  alignment modes, grouping separators and floating-point rendering remain
  Missing.

• Add the bundled std.path.normalize package,
  Path Normalization v1: lexical normalization
  of the typed Path values std.path.value owns. normalized_len and
  normalized_byte give the exact normalized length and each byte of a
  borrowed view with no buffer, and into(borrow Path, own Bytes) -> Path
  writes the normalized form into caller-supplied capacity after an exact
  preflight while preserving the borrowed input. A separator run collapses, .
  vanishes, .. cancels the nearest retained segment, an uncancelled .. is
  kept for a relative path and dropped at an absolute root, a trailing
  separator is removed, and an empty result is . or /, so a normalized
  Path is never zero bytes. Retention is decided without a stack, as the
  clamped maximum prefix sum of a forward walk that scores .. as +1 and an
  ordinary segment as -1. Ten named cases run as individual bounded projects
  on the interpreter, native C11 -O0/-O2 and repeated Core Wasm, with
  hostile cases rejecting a short buffer, a forged Path and out-of-range
  offsets, and a graph check replaying the projection and its per-shape
  cleanup-schema selection. No public export, descriptor, platform conversion
  or filesystem authority is added, and std.path.value stays byte-identical.

• Add the bundled std.io.lines package, IO Lines v1:
  bounded line processing over the unchanged std.io Reader and Writer
  cursors. line_end, line_terminated and
  line_content_len observe a borrowed byte view; reader_line_len and
  reader_line_complete observe a borrowed Reader; reader_line_into copies
  one line's content into caller-supplied Writer capacity after an exact
  preflight; reader_next_line is the consuming transition past the line and
  its terminator. One line feed terminates a line, whose content excludes that
  byte and one immediately preceding carriage return, so LF and CRLF inputs
  yield identical content and a bare carriage return stays content. Eight named
  cases run as individual bounded projects on the interpreter, native C11
  -O0/-O2 and repeated Core Wasm, and nine hostile cases reject short
  capacity, forged cursors and out-of-range view offsets with the exact
  requires-false status. A graph check pins the selected cleanup schema per
  shape: v5 for the copy and the record observers, v2 for the pure view
  helpers, with the caller's Writer as the copy's one owned parameter. No public export, descriptor, stream, standard
  stream or host authority is added, and existing cursor signatures, contracts
  and identities are unchanged.

• Add the private owned iterator payload profile for Iter<Bytes> and
  IterStep<Bytes>. Prelude v8, Graph v45, and CleanupPlan v13 bind the exact
  detached-prefix item/rest transfer and preserve prior scalar iterator,
  vector, and cache bytes. Focused library, interpreter/native C11 -O0/-O2,
  workspace, and Core Wasm checks pass, including graph/Prelude and cache
  replay, exact failure settlement, and malformed-provider output rejection.
  Hosted promotion, public generic iterator ABI, and broader iterator scope
  remain pending. Also close the omitted Graph v44 process-profile rejection
  in frozen evidence admission without changing serialized graph bytes.

• Extend std.test.bytes with reusable named snapshot fixtures and Copy
  comparison results containing equality, lengths, and the relative first
  difference. Borrowed fixtures and Reader cursors remain unchanged, with no
  new allocation or filesystem authority. Focused source-package and bundled
  consumer cases pass locally across the interpreter, C11 O0/O2, and repeated
  Core Wasm, including invalid-cursor cleanup.

• Add authenticated Project-linked State migration and workspace typed binding.
  A single declared or explicitly imported migration function extends the
  checked role closure; additive migration root v3 binds its exact source
  association while legacy root v1/v2 bytes remain unchanged. Durable recovery
  reconstructs the closure without evaluating migration again, preserves
  cumulative usage, and skips destination initialization. Focused local linked
  migration, selection refusal, recovery, and workspace currentness cases pass.

• Add the private std.agent source package and the linked Project lifecycle
  boundary. Task, Context, Observation, and Outcome records plus checked
  lifecycle and outcome helpers compose as ordinary source data; the linked
  path derives the Proposal schema from the retained Project closure and binds
  it to the additive typed iterative runtime while preserving the existing
  scalar/public package bytes and direct Runtime v2 binder. All six linked-role
  cases pass locally, and the four standard-library testing cases pass across
  interpreter, native C11 -O0/-O2, and Core Wasm, including epoch boundary
  cases and the byte-assertion regression. Linked migration, native/Wasm
  Agent-stage execution, live providers, hosted support, and full std.agent
  completion remain open.

• Add the sibling private std.test.bytes assertion package while preserving
  the existing scalar std.test facade and public descriptor. Exact slice and
  Reader-suffix comparisons, cursor validation, unchanged Reader positions, and
  failure-bit wrappers use the private useful-data.v2 profile with no exports
  and exact std.io plus std.test dependencies. Execution and invalid-cursor
  gates pass locally; richer fixtures, property tests, fuzzing, and snapshots
  remain open.

• Record the private std.process bounded process slice. Example, conformance,
  and bundled-consumer commands pass locally on the interpreter, native C11
  -O0/-O2, and Core Wasm. Five focused physical Darwin provider cases also
  pass, covering the registered local provider path. Linux physical-provider,
  hosted, public, and broader process support remain open; this does not promote
  the full process profile.

• Record the nested record-match entry/result phase ownership fix. The named
  nested_record_match_entry_and_result_phases_settle_across_engines gate now
  passes interpreter, native, and Core Wasm success and postcondition-failure
  cases while preserving canonical cleanup vectors.

• Add the private std.env environment snapshot package and Project
  environment-io.v1 composition. The bounded operation vocabulary, immutable
  UTF-8 snapshot constructor, capability checks, graph facts, package metadata,
  catalogs, and source links are in place. Four focused carrier cases cover
  empty, success, failure, and malformed Wasm paths; fourteen selected library
  checks cover the snapshot and environment admission surfaces, including the
  provider constructor on Node. The named gates
  environment_manifest_is_canonical_and_authority_is_closed and
  environment_package_executes_all_functions_with_injected_snapshot pass:
  the two Project commands pass on the
  interpreter, native C11, and repeated Core Wasm, including the bundled
  consumer; five focused useful-data environment checks also pass. The package
  is local/private evidence only, with no hosted CI or public ABI claim.

• Add the private std.log structured JSON-lines Writer. Its owned Event
  carries level, sequence, name, and message fields; append preflights level,
  UTF-8, and complete caller-owned Writer capacity before emitting one exact
  line. It composes bundled JSON UTF-8, JSON writing, and IO helpers without
  hidden allocation or ambient effects. The canonical package and fifteen
  expanded fixtures pass on interpreter, C11 -O0/-O2, and repeated Core
  Wasm with exact zero-to-three live Bytes bounds. Nine invalid-event/output
  cases pass twice with exact contract status. A direct ASCII validation path
  keeps the 300-byte message within unchanged interpreter fuel; the existing
  UTF-8 package conformance passes on all three backends. Catalog, metadata,
  formatting, links, and module-size checks pass. Broader Everyday logging
  remains Partial; no public ABI or hosted support is promoted.

• Add the private std.format Writer append slice: append_str,
  append_i64, append_usize, and append_bool preflight exact caller-owned
  std.io.Writer capacity and return the advanced writer. Checked digit,
  decimal-byte, and length helpers supply deterministic output without hidden
  allocation or effects under the private useful-data.v2 profile; the
  package has no public exports. Local verification now passes seven
  owned-function-import unit tests,
  including borrowed-str and ordinary owned-byte-record positives plus
  non-byte-record refusal; eight individually runnable named SPX tests pass on
  the interpreter, native C11 -O0/-O2, and repeated Core Wasm with a strict
  two-entry byte arena (the pure helper case uses zero allocation). Five
  short/forged-output preflight cases pass twice with exact requires-false
  status through the bundled std.format consumer and transitive std.io;
  metadata and catalog regeneration pass. Named tests run individually
  because the per-function static allocation limit is unchanged. General
  format strings and floating-point rendering remain outside this slice, with
  no hosted or production claim.

• Add allocation-free JSON cursor adapters: decode_into and quoted_into
  consume an owned Writer after exact capacity preflight while borrowing a
  Reader, and count_into renders a usize value into that writer. The
  additive Project v16 useful-data.v2 profile keeps private owned cursor
  composition separate from the frozen Useful Data v1 byte-export boundary.
  Legacy byte-only consumers retain their public boundary while unused newer
  dependency members stay outside the linked program.
  The standalone decoder/writer corpus passes on the interpreter, native C11
  -O0/-O2, and repeated Core Wasm, including a 300-byte decoded input; six
  malformed-input, insufficient-capacity, and forged-cursor contract-rejection
  cases pass. The named Project v16 gate
  profile_admission::project_v16_json_cursor_public_facade_replays_and_executes
  passes deterministic npm reconstruction, replay, and Node execution.
  The named cross-package gate
  private_json_cursor_roundtrip_executes_across_project_backends passes the
  local interpreter entry and repeated test, native C11 -O0/-O2, and
  repeated Core Wasm with a strict two-entry arena under the unchanged 16 MiB
  budget. These are local observations and do not claim hosted or public
  support.

• Refine workspace build-memory prebounds using bounded dependency identities
  and proven AST storage facts. Earlier successful budget receipts and fixed
  limits remain unchanged; a refused production build may retry once with the
  tighter bound after discarding its partial core and staged cache entries.
  Explicit smaller limits and nested budgets keep their original single-attempt
  behavior. JSON conformance scratch directories now remain distinct when
  decoder and writer checks run concurrently.

• Extend private std.fs with typed metadata, canonical immediate directory
  listing, directory creation/removal, and atomic file replacement through
  explicit providers. Project v15 and Graph v42 preserve the v1 profiles.
  Typed commands run on the interpreter, C11 O0/O2 and Core Wasm; malformed
  directory results fail before owned publication. Unix providers retain a
  directory descriptor and use same-parent rename for atomic replacement,
  without a durability claim. Private owned-input calls can return checked
  Copy-only records such as FileInfo; public ABI boundaries stay unchanged.

• Add bounded filesystem reads and create-new writes through explicit providers,
  with source-authored std.fs composition of Path, Reader and Writer, bundled
  dependencies, Graph v41 replay, and the private Project v14 execution profile.
  Interpreter, C11 O0/O2 and Core Wasm cover typed operations, byte/operation
  limits, failure priority, repeated calls and owned-result cleanup. The Unix
  provider retains a directory descriptor and rejects symlink traversal; writes
  never overwrite and do not promise rollback of physical effects. Broader
  filesystem facilities and cross-platform promotion remain open.

• Add the source-authored std.path.value owned Path library with checked
  logical prefixes, lexical queries, consuming parent traversal and joins into
  caller-supplied buffers. Bundled dependency composition preserves the original
  std.path byte helpers and adds no filesystem authority or public nominal ABI.
  Shared-loan replay now authenticates completion of synchronous borrowed calls
  used directly as contract roots, preserving previously accepted plan bytes.

• Add source-authored std.io Reader/Writer cursors over caller-owned Bytes,
  checked bounds, consuming transitions and bundled dependency use. Internal
  Project calls now compose explicit owned-record signatures, and empty-export
  owned-data libraries run in both manifest layouts without a public descriptor.
  Independent cleanup replay and interpreter/native/Wasm lanes retain result
  transfers before arm cleanup. Focused tests cover binary roundtrips, contract
  failures, borrowed-owner escape, forged identities and missing transfers;
  generated catalogs now include the record declarations.

• Preserve both immutable workspace generations through typed Agent migration,
  durable recovery and chained migration using additive provenance receipts.
  Recovery rechecks compiler-owned bindings and exact receipts; current-run
  paths refuse stale destinations before host or store work. Focused local
  tests cover recovered A→B→C chains, forged receipts, stale destinations and
  preserved terminal failures after checkpoint acknowledgement loss.

• Bind acyclic, iterative, and typed Agent runtimes to exact immutable semantic
  service generations through additive workspace execution receipts. Replaying
  a receipt reselects compiler-owned state; current execution rejects drift
  before host calls while historical bindings retain their original generation.
  Join only actual producer evidence and preserve typed durable checkpoint
  replay. Twelve focused execution-root tests pass locally, including the new
  V1/V2/V3, forgery, refresh, and zero-host replay cases.

• Complete private native-builder cleanup test visitors for the additive
  iterator renewal transitions; the private test target compiles locally.

• Add private one/two-parameter generic iterator operations with ordered Copy
  substitutions, explicit argument permutation, and authored map/filter/fold.
  Conditional same-owner Vec updates inside consuming loops use additive
  CleanupPlan v12 reservation/renewal facts and Graph v40; ordinary loops keep
  v11/v39 semantics. Replay rejects missing renewal facts and schema downgrades.
  Native layout discovery now includes retained concrete function bodies.
  Focused local runtime and projection evidence is recorded in
  Generic Iterator Operations v1;
  public generic ABI and hosted promotion remain separate.

• Separate cross-platform Rust build validation from focused runtime evidence
  in CI, retaining both as release blockers. Run the complete MSRV check once
  across its four test shards and remove two identical generic-lane test
  repetitions. Cache the pinned mdBook tool and upload the book only for Pages
  deployment. Hosted timing and platform validation remain pending.

• Add private consuming for own traversal over scalar iterators, including
  generic callbacks and same-owner vector accumulation. The hidden Step
  protocol preserves exact loop ownership with additive CleanupPlan v11 and
  Graph v39. Fix native conditional owner materialization and Wasm borrowed
  remainder/aliased-move handling. Focused interpreter, C11 O0/O2, Core-Wasm,
  graph and ProgramRoot replay checks pass locally; hosted promotion is pending.

• Compose private generic iterator helpers with scalar callbacks and step
  reconstruction. Source and HIR retain scoped Iter<T>/IterStep<T> ownership;
  existing Prelude v7, CleanupPlan v10, and Graph v38 remain authoritative.
  The eight-scalar runtime corpus passes interpreter, C11 O0/O2, and Core Wasm,
  including callback contract failure and repeated settlement. Graph and
  ProgramRoot reject forged instance/scoped identities and changed source.
  Public iterator ABI and consuming loops remain separate work.

• Repair the prior head's CI failures by consolidating Closure test visitors,
  keeping production iterator/prelude helpers before test modules, and
  completing closure/iterator documentation metadata and catalog entries.

• Repair local-only iterator step construction across prelude selection, graph
  classification, cleanup case-state replay, backend runtime activation, and
  canonical owning matches. Add repeated cross-engine regressions for bound
  and direct Done constructors; preserve legacy graph and prelude selection.
  Retain complete iterator declaration and cleanup facts in both workspace
  linkers, restore Box's frozen prelude slice, and verify ProgramRoot replay.

• Add the private Owning Iterators v1 implementation tranche for scalar
  Iter<T>/IterStep<T> and consuming vec_into_iter/iter_next, with
  Prelude v7, CleanupPlan v10, Graph v38, and ProgramRoot binding. Local
  interpreter and C11 O0/O2 observations cover all eight scalar types, order,
  empty/exhaustion, early drop, Done/Yield reconstruction, contracts,
  private returns, and forged native cursors. The same corpus passes Core Wasm with exact scope settlement; hosted promotion and the
  broader iterator, owning-payload, lazy-adapter, and public-ABI work remain
  pending.

• Repair Closure exhaustiveness in projection and semantic test traversals and
  native-builder mutable AST traversal, plus narrowly mechanical -D warnings
  hygiene exposed by the cancelled CI run. Hosted revalidation remains pending.

• Add scalar closure construction inside generic collection functions and bounded
  loops, with concrete instance identity remapping, independent scoped HIR
  validation, and source-only template body facts in Graph v37/ProgramRoot.
  Preserve per-iteration snapshots and collection settlement across interpreter,
  native C11, and Core Wasm; extend native Rust builder accounting while keeping
  its public callable boundary closed.

• Add private scalar snapshot Closures v1: exact AST/HIR cache carriers,
  Graph v37 and SemanticProgram v5/ProgramRoot replay, and local interpreter,
  C11 O0/O2, and Core-Wasm evidence for snapshot timing and captured generic
  Vec map/filter/fold composition. Owning captures, public callable ABI, and
  hosted promotion remain pending.

• Add private noncapturing Function Values v1 with checked declaration-identity
  references and indirect invocation, Graph v36 projection, and retained
  SemanticProgram v3 callable closures. Public ABI and hosted promotion remain
  outside this additive profile.

• Add the private generic-collection callback profile for Function Values v2;
  focused collection execution and ownership checks remain pending.

• Extend argument inference through nested omitted calls and generic callers, retaining scoped symbolic forwarding identities, independent bounded evidence, exact graph/root replay and ordinary evaluation-once ownership settlement.

• Extend private generic argument inference to complete ordered vectors and bounded expression type evidence, with independent source/HIR derivation and unchanged concrete instance, ownership and cleanup admission.

• Add durable Agent migration handoffs, trusted-store destination recovery and repeated revision chains with cumulative call, byte, stage and fuel accounting; preserve frozen operation checkpoint v2 bytes and bind additive migrated evidence to the handoff.

• Add private Vec<Bytes> push, replacement, reserve, clear and lexical cleanup across checked source/HIR, interpreter, C11 and Core Wasm. Mutations stage vector and payload owners together and fail before transfer; successful replacement drops the old payload once. Prelude v6 and explicit v2 host imports bind the new meaning, including graph and ProgramRoot replay. Scalar storage and prior prelude contracts remain frozen; focused local evidence is separate from hosted and public promotion.

• Add private owned Box<Bytes> allocation and consuming extraction across source/HIR, interpreter, native C11 and Core Wasm. Prelude v5 binds the additive contract; v2 Wasm imports prevent a legacy scalar host from silently leaking the payload. Allocation refusal keeps the staged Bytes owner live until ordinary cleanup, independently replayed before lowering. Focused local probes cover success, contract failure, allocation refusal, repeated settlement and frozen scalar compatibility; hosted and public promotion remain pending.

• Added exact argument-directed generic inference at monomorphic call sites,
  preserving explicit concrete HIR instances and ownership transfer boundaries.
  Seven language checks, private ProgramRoot replay and all-eight-scalar runtime
  success/failure settlement pass locally.

• Added consuming State migration from actual durable Suspend evidence into a
  differently rooted retained Agent, through a pure checked function replayed
  twice. Destination execution skips initialize, binds fresh authorizations and
  retains prior call, byte, stage and fuel charges, including failed migration
  fuel reservations. Focused unit and joined-runtime checks pass locally.

• Fixed YAML interpretation of unquoted Rust test-prefix selectors in CI run
  steps; GitHub had rejected the workflow before creating jobs. Added focused
  inference and migration selectors. Hosted execution remains unobserved.

• Added trusted-store checkpoints around each typed iterative effect, with
  persisted stage fuel reservations, intent/observation/transition generations,
  exact call and byte accounting, fresh-authorized recovery, and fail-closed
  uncertain delivery. Terminal failure survives a lost final store acknowledgement.
  Four execution and eight hostile decoder checks pass locally.

• Added private authored generic variants with one owned Bytes case and all
  eight Copy substitutions, including owning match/branch/call composition.
  Native selected-case destructuring now precedes arm construction, with
  outgoing ownership transferred only after the result exists. The 18-profile
  runtime corpus passes on interpreter, native O0/O2 and Core Wasm.
  Exact private variant/collection signatures now survive HIR linking; attempted
  public owning results reach the unchanged Scalar Export Profile and reject
  with its SPX-W115 diagnostic instead of the earlier private-linker SPX-H006.

• Added a deployed typed scalar operation registry with exact argument/result
  contracts, per-turn authorization, and call/byte ceilings. Direct Runtime v2
  compiles retained Agent source into this iterative product and joins its actual
  execution to deployment, instance and evidence roots. Five registry checks and
  the three-turn/two-operation Runtime integration pass locally.

• Added private generic Box/Vec functions over all eight Copy scalars, with
  exact source/HIR materialization, graph and ProgramRoot replay, and runtime
  success/failure settlement on interpreter, native O0/O2 and Core Wasm.
  Native intrinsic arguments now stage through the canonical transfer boundary;
  owned collection parameters reference their live cleanup slots. Interpreter
  report replay recognizes only the finite existing Box/Vec status tables.

• Added bounded iterative Agent Step execution with fresh per-turn authorization,
  cancellation and budget ceilings, exact source-Agent binding, and immutable
  invocation-bound evidence. Joined roots associate retained ProgramRoot v1-v3,
  deployment, invocation and actual one-pass or iterative execution. Iterative
  execution obeys both deployed turn and call ceilings. Copy-only Observation
  results use a narrow retained-call extension. Focused local checks pass;
  typed multi-effect checkpoints and migration remain follow-on work.

• Made the generated Proposal-client execution gate portable across Linux,
  macOS and Windows with exact UTF-8/LF output and provisioned TypeScript JS
  execution through Node. All three clients compile and execute locally on
  macOS; the added blocking CI matrix awaits exact-head hosted evidence.

• Added structural nested generic record composition and multiple owning
  parameters, with explicit reconstruction into different nominal result types.
  Source and HIR validate substituted fields, recursive patterns and complete
  ownership; nested update construction and replay select cleanup v9 after
  concrete substitution. Native owning branches now emit their canonical join
  and staged-call transfers. Focused all-eight-scalar runtime corpora pass on
  interpreter, C11 O0/O2 and Core Wasm, including both branches, nested owner
  replacement, contract and second-argument failure, repeated execution,
  allocation settlement and no additional aggregate memory.copy.

• Added explicit generic argument permutations, repetition and concrete
  substitutions with independent source/HIR proof, cycle rejection and the
  existing 256-instance closure bound. Additive Graph v35 binds symbolic
  caller-parameter/concrete mappings by authenticated expression paths;
  identity-only programs retain v34 bytes. ProgramRoot and bounded context
  expose the same mappings. Focused source, hostile graph, workspace replay
  and interpreter/native O0/O2/Core-Wasm checks pass.

• Extended generic Result propagation to Result<T, Bytes> for all eight Copy
  success types. Cleanup consumes the conditional owner without inventing a
  success cleanup slot; interpreter, native and Wasm preserve scalar Ok values
  and owned Err settlement. Forty focused cross-engine success/failure profiles
  pass, with forged empty-case flags and missing residual transitions rejected.

• Added generic Result<Bytes, E> relay, explicit forwarding and postfix ?
  for every Copy error scalar plus Bytes. Independent HIR proofs validate
  unused substitutions without requiring a discovered call instance. Existing
  conditional cleanup handles empty scalar-error ownership paths; native
  residual return now preserves those scalar values before publishing the tag.
  Graph v34 and ProgramRoot bind concrete variant and residual facts across
  private function boundaries. Focused local runtime evidence covers 45
  success/failure profiles on interpreter, C O0/O2 and Core-Wasm; public generic
  descriptors remain closed. This begins GEN-06, not the end of the full goal.

• Completed Graph-v34 type facts for concrete generic instance signatures and
  bodies, including template-only context selection. Frozen legacy graph
  collection remains unchanged. Added focused hosted compatibility selectors
  for existing Component byte known answers and closed public mappings.

• Added Graph v34 concrete generic-instance ownership, revision-bound semantic
  identities, forwarding facts and exact source replay, with independently
  selected cleanup schemas preserving existing CleanupPlan bytes. An additive
  SemanticProgram v2 node binds linked generic closures into ProgramRoot;
  frozen graph consumers and public ABI descriptors retain their prior
  contracts. The independent GEN-05B generic instance semantic closure Linux
  job combines the eight-scalar flat and
  nested corpus, graph/schema hostility, expression composition and scalar
  cross-package execution. Focused graph and workspace replay checks pass;
  the bounded GEN-05B/GEN-05C Linux tranche passed for implementation commit
  c27d06f0cf74749804237a43cc71c248b319cfe0 in
  CI run 34058787739, job 101555489228.
  This documentation-only successor records that implementation result and
  does not claim a new test run, full-CI passage, or a public generic ABI.
  Semantic instance identities survive
  comment-only edits while ProgramRoot still binds exact source. Preserved
  existing workspace known answers and ownership/range diagnostics.

• Added a source-native Agent-to-Lifecycle v1 bridge and executable generated
  Proposal-client evidence. One checked .spx Agent is selected by stable
  identity, lowered through the frozen AgentDefinition-v1 compiler, and bound
  to the existing one-pass lifecycle; replay now requires both exact lifecycle
  bytes and the semantic source revision, so role-body drift fails closed.
  Focused regressions cover completion, refusal, injected-effect failure,
  missing-Agent/incompatible-role cases, stale source, and fail-first oversized or
  malformed replay selectors. A named Linux step also materializes generated
  record and variant clients in isolated temporary projects, strict-compiles
  TypeScript 5.8.3, byte-compiles Python, builds Rust offline with a private
  target, executes all three, and submits their exact integer/UTF-8/case output
  through the canonical decoder. This changes no frozen Agent or Runtime wire
  and adds no provider, tool, filesystem, publication, or ambient authority.

• Extended Exact Program Context v2 with candidate-safe ProgramRoot-v3 refresh.
  A host-authenticated successor context is independently replayed against a
  separately compiler-admitted candidate Project; successor external facts are
  freshly supplied and replayed rather than implicitly copied from the current
  generation. The persistent service selects the active
  workspace/v3 root first, stages the complete candidate generation, cache,
  indexes, unchanged refresh-v1 receipt, and history entry, then adopts them
  together. Stale selectors, cross-paired facts, invalid source, or replay
  failure preserve the active generation and history; old snapshots remain
  exact. This adds no wire, filesystem acquisition, execution, commit, or
  publication authority.

These unsigned archives are not notarized and make no cross-host reproducible-build claim.
SHA-256 checksums are integrity facts, not signatures.