[FEATURE] Track Phase 6 POSIX compatibility and full EriX self-hosting #65

Open
opened 2026-09-19 11:36:51 +02:00 by erikinkinen · 298 comments
Owner

Problem and motivation

Checked implementation items do not establish that pending tests, current CI or native execution have passed. The complete guest builds and in-guest Rust/LLVM rebuild remain undemonstrated.

EriX needs POSIX compatibility and a complete development environment capable of building EriX within EriX. This issue tracks the full scope and supplementary requirements; detailed designs and evidence remain in the owning records.

Proposed behavior and scope

Implement the POSIX ABI/service, files and namespaces, memory and threads, processes/signals, libc/startup/sysroot, compatibility ELF/TLS/linking, shell and utilities, imported development tools, profiling and image assembly. Preserve required input, including physical command delivery, signing, consoles, TUI and boot-logo work.

Build the entire EriX graph and bootable images inside EriX, boot a resulting image, and repeat the complete build there. Cross-bootstrap the selected external Rust/LLVM toolchain and C/C++ runtime against EriX's libc/sysroot; rebuild that toolchain inside EriX using explicit offline inputs, validate it, and use it for a complete EriX build. Both guest generations and the external toolchain rebuild are mandatory.

Partition-payload assembly extends the image initializer with exact retained file reads and removes the product partition overlays.

Native FAT32 image creation adds deterministic filesystem metadata and selected file contents through that assembly path, with adoption in the three ESP recipe routes.

Generated Cargo lock inputs extend the offline source inventory with exact final locks and their workspace/source bindings.

Portable Cargo dependency graphs add the completed package, target, feature and resolve graph to that inventory with original source-role coordinates.

Original Git object transport supplies explicit offline object inputs and a fresh source/Cargo preparation path, preserving original commits, locks and graph semantics.

Journaled ext4 image initialization adds an explicit native filesystem format path. Complete typed population and product recipe replacement remain separate work.

Offline bundle preparation adds a maintained command for explicit tools, complete role selections, fresh Git and locked Cargo results, and original operation cleanup.

Typed ext4 product population adds the complete declared product tree, explicit inode metadata and one original file input across mapped extents, with product recipe adoption.

Authority, security and reliability

Apply security, reliability, then performance. Eliminate ambient, residual and unwanted explicit authority. Audit original capability identity, recipients, minimal rights, delegation, lifetimes, partial effects, cancellation, restart and positive retirement before reuse. Names, IDs, paths and observations never confer authority. Preserve denied/uncertain states and independent cleanup obligations.

Continuously remove deprecated APIs, redundant code and incidental restrictions; identify and eliminate measured bottlenecks with Integration's profiler. Keep authored code files below 1,000 physical lines through thematic refactoring. Document public and private invariants with rustdoc and enforce missing_docs in every crate. Keep trusted EriX code clean-room and separate from permitted imported payloads.

Before publishing a shared supplier, run the authored-Rust documentation gate against actual Cargo target metadata, including integration-test crate roots, and the authored-code size gate. Preserve explicit source and helper revisions.

Use self-contained per-feature branches and a separate PR for each branch (WIP while incomplete), squash dependency-pin-only churn into the owning feature, regular signed nonforce commits in canonical CONTRIBUTING format, main for Cargo.toml Git dependencies with CI branch overrides, and explicit immutable resolved revisions for catalogs, helpers, packaged component receipts and build evidence, and coherent dependency publication. Maintain canonical governance/templates, README/ARCHITECTURE/ROADMAP formats, technical-manual TeX and API references. New repositories use meta as their remote template. Keep review PRs WIP until their full scope is accepted; merges and releases require separate approval. Keep secrets and suspected vulnerabilities private.

Acceptance criteria

Complete each parent's full implementation scope; expose partial work through its existing children. Preserve meaningful positive, malformed-input, authority-negative, interruption and cleanup controls. Historical source acceptance under earlier testing waivers is not retrospective test proof.

Run cargo fmt, strict Clippy, supported unit/feature/target/doctests, warning-denied builds and rustdoc/manual checks. Add and run necessary bounded VM tests; monitor all repository CI and older regressions. Parallel testing and CI must not block independent implementation. Resolve failures and warnings at source; skipped, pending and unrun checks are never passes. All repositories must pass CI before final completion. Preserve every same-repository pull-request duplicate-run guard without disabling fork, push or manual runs.

Phase 5 handoff and remaining gates

Weight: 2%. Owning issue · integration PR 12.

Checklist
  • Preserve the archived tracker and an evidence index for the exact source graphs, CI logs, main-image hashes, rejected experiments and all failed timing observations; distinguish historical results from current-head gates.

    • Preserve the original Phase 5 tracker, signed source selections and
      failed timing observations.
    • Retain source-bound CI logs and image/artifact identities for
      subsequent checkpoints.
    • Consolidate the complete handoff index and verify every
      historical/current link.
  • Observe CI 1549 to terminal status, audit every job/log and full scenario/post-image count, and classify remaining failures without weakening markers, source identity, worker ownership or deadlines.

  • Review the held 10d57e98 checkpoint and record its disposition: preserve its signed ancestry when creating feature/posix-compat; publish a coherent new-branch graph only after the predecessor evidence is retained. Do not drop the locally committed pin or silently substitute an older graph.

  • Run the carried checkpoint's own exact-head full CI and a fresh repository-wide CI inventory; resolve any failures/warnings at their owners.

    • Create the repository-wide branch, source and CI inventory.
    • Refresh current component CI states against the selected feature
      heads.
    • Complete the carried checkpoint and dependent full Integration gates.
    • Resolve all remaining owner failures and warnings without weakening
      acceptance.
  • Revalidate the prepared direct-chunk private-image recipe against the chosen Phase 6 base before reuse; bind all source revisions, environments, cache keys, executable PT_LOAD bytes and rootd path/capacity differences.

  • Build/audit matching private dev/release images once admitted; retain original helper failures and the narrow proven locale-receipt handling. Do not reuse a predecessor's symbol addresses or compiled-object attribution.

  • Collect one adjacent audited control and two complete candidate startup observations, with no concurrent local VM/compiler, using unchanged 120 s total / 15 s silence / 10 s command collection limits.

  • Close the carried startup acceptance only after both candidate observations satisfy root-to-final-READY ≤5 s, largest service-ready gap ≤1 s, final-READY-to-full-editor-caret ≤1 s, and the exact four-command interval ≤2 s. Preserve the maintained oracle and command; never retry unchanged input to green.

  • Record remaining bottlenecks as Integration profiler and measured optimization findings if Phase 5 handoff and remaining gates fails; validate each eventual fix with strict component checks and matching VMs.

    • Retain failing startup observations and identify mapping/switching
      candidates using actual captured code.
    • Finish the causal correction and required matching component/VM
      validation.
    • Meet the original uninstrumented startup bounds and reconcile the
      carried finding.
  • Update the carried acceptance report and component/manual status with actual results; retain all six old unchecked rows as covered by these items rather than counting duplicate validation prose as six independent gates.

Scope, repository and build inventory

Weight: 3%. Owning issue · integration PR 12.

Checklist
  • Inventory all existing repositories, nested Cargo workspaces and crates, targets, profiles, feature combinations, scripts and maintained tests. Record repository paths, remotes, exact heads, dirty state and build ownership.

    • Inventory repository paths, remotes, exact heads, branches and dirty
      state.
    • Inventory nested Cargo packages, targets, declared features/profiles,
      scripts and tests.
    • Review all supported feature combinations and complete target/test
      build ownership.
  • Record/create feature/posix-compat before each repository's first edit; verify exact dependency pins and signed ancestry from the accepted base.

  • Verify whether lib-posixabi, lib-cstd and posixd already exist remotely; create each missing required repository in Forgejo from meta before cloning.

  • Scaffold those three components with explicit responsibility and authority boundaries, rustdoc, strict CI, tests and specialized canonical docs. Keep import recipes/profiler in Integration; do not invent extra daemons/repos without a concrete ownership need and recorded design review.

    • Provide the documented, strictly tested lib-posixabi crate and
      component CI.
    • Provide the documented, strictly tested lib-cstd crate and component
      CI.
    • Provide Posixd responsibility, ownership and bootstrap design
      documents with CI.
    • Add the Posixd runtime crate, strict Rust CI, tests and executable
      responsibility boundaries.
  • Add new components to Integration's commit-pinned catalogs and immutable dependency policy; validate the exact transitive source graph.

    • Adopt the original lib-cstd memory implementation in the native
      component catalog and validate its selected graph.
    • Adopt the required lib-posixabi and runnable Posixd components with
      exact transitive selections.
    • Reconcile all three complete component versions across catalogs and
      immutable dependency checks.
  • Freeze a machine-readable full-build output inventory: every maintained EriX crate/library/binary, kernel, EFI bootloader, native build tools, boot image, dynamic/launch metadata, four image profiles and release manifests.

    • Record the initial machine-readable repository/target and output-class
      inventory.
    • Implement and test explicit-source build-scope and output-receipt
      validation.
    • Complete and review ownership/recipes for every maintained output and
      all four image profiles.
    • Freeze a complete accepted inventory with no missing or unclassified
      output.
  • Inventory all canonical generators, documentation/manual outputs, checksums/compression/signing steps and their host executables. Include these in the in-EriX build closure; distinguish external test execution from building.

    • Identify current generators, image/signing/compression tools and
      documentation host dependencies.
    • Resolve the exact complete executable/version and generated-output
      closure.
    • Bind every required generator to its guest build recipe and
      distinguish execution-only external tests.
  • Record the build-host versus emitted-target matrix: EriX-hosted tools and compatibility libraries for x86_64-unknown-erix, plus the existing bare-metal and UEFI targets needed to rebuild the OS. Do not rewrite native target ABIs merely to make imported tools run.

  • Produce an API/workload matrix from the exact intended Rust/LLVM, Cargo, Python, Git, shell, image and documentation recipes; map every required call/ELF feature to an owner, implementation item and independent test.

  • Define the POSIX specification edition/profile, C ABI/data model, locale baseline and optional extensions. Mark unsupported optional surfaces explicitly; never claim full POSIX certification from a selected build workload.

  • Resolve/document the existing Phase 6 close-on-exec-by-default policy versus standard descriptor inheritance expectations. Preserve native authority ceilings; specify any compatibility deviation before implementation.

  • Approve the architecture/threat model for posixd isolation, process mediation, TLS, fork snapshotting, signal delivery and build realms. Enumerate trusted components and keep POSIX policy out of the kernel/rootd.

    • Specify native realm ownership, authenticated client ingress and
      mediator isolation.
    • Specify retained installation/revocation custody and guarded staged
      bootstrap.
    • Complete TLS, fork snapshot, signal and build-realm threat models.
    • Review the complete trusted-component and policy-placement contract
      together.
  • Fix per-scenario resource budgets and progress/deadline contracts from measured workloads; distinguish ABI/hardware bounds, authorized quotas and accidental hard-coded limitations.

  • Define exact self-host success/failure criteria and evidence schema before implementation: source-only inputs, no host build delegation, two clean in-EriX builds, deterministic artifacts, boot result and authority-negative tests.

    • Define source-only inputs, two complete guest builds and the required
      guest toolchain rebuild.
    • Define source/output identity and receipt schemas without claiming
      guest execution from hashes.
    • Complete the end-to-end guest execution, reproducibility, boot and
      authority-negative evidence schema.
  • Extend inventories with rootfs authority-bearing files/signatures, firmware trust enrollment, native build-tool targets, man/help coverage and console/input interfaces; assign each an owning public issue and acceptance test.

    • Assign public ownership and explicit acceptance requirements for
      signing, native tools, manuals and console/input extensions.
    • Complete their concrete file/interface/trust inventory and test
      mapping.
  • Record v1.0.0-alpha.1 as the intended manually reviewed release baseline, coordinating platform/component version policy without premature version bumps, tags, PR readiness or release publication.

Whole-codebase authority and quality audit

Weight: 8%. Owning issue · integration PR 12.

Checklist
  • Create an audit register keyed by stable finding ID, repository, file/symbol, category, severity, exact revision, invariant, reproduction, remediation owner, regression test, status and closure evidence.

    • Retain per-finding source, reproduction, remediation and validation
      records plus canonical public bug reports.
    • Unify all findings into the complete keyed audit register with
      severity, owner, invariant and closure fields.
    • Reconcile every register entry with current source and independent
      closure evidence.
  • Inventory every startup/runtime capability: origin, receiving principal, object, operations, delegation ceiling, lifetime and all aliases. Include boot handoff, service registration, compatibility realms and tools.

    • Map native VSpace/backing/table and staged-process
      installation/revocation owners.
    • Complete service, device, filesystem, terminal and compatibility
      runtime capability inventories.
    • Reconcile every origin, receiver, operation, alias, delegation ceiling
      and lifetime.
  • Find ambient authority from global selectors, default service discovery, cwd/PATH/env, numeric slots/PIDs, implicit devices, inherited routes, host filesystem fallbacks and cache metadata; replace it with explicit grants.

    • Correct the validated native mapping/current-caller and explicit
      host-tool selection boundaries.
    • Complete startup/service-discovery, device and inherited-route
      authority removal.
    • Complete cwd/PATH/environment, filesystem and cache authority removal
      across build/runtime paths.
    • Independently validate whole-codebase absence of remaining ambient
      authority.
  • Find residual authority after success, error, cancellation, interruption, timeout, restart, failed reply/transfer, fork, exec and teardown. Prove every alias is retired or its necessary retention is documented.

    • Implement and test retained native invocation, process and mapping
      cleanup ownership.
    • Retain table allocations through publication/rollback and preserve
      backing through withdrawal.
    • Complete live private-root/CPU residency retirement and remaining
      consumer-loss paths.
    • Complete realm/fork/exec/interrupt/restart/transfer teardown and final
      alias audit.
  • Find unwanted explicit authority: oversized startup inventories, broad provider/admin endpoints, duplicate aliases, unnecessary read/write/exec rights and debug routes. Attenuate/remove it even when technically explicit.

    • Implement root-capability-free staged construction and explicit
      install-grant attenuation.
    • Complete minimum runnable mediator/client bootstrap inventories and
      retire setup aliases.
    • Audit and minimize all remaining service, provider/admin, device and
      debug grants.
  • Audit generation reuse, replay, stale pending replies, confused deputy paths, endpoint impersonation and TOCTOU around path/object resolution. Test forged descriptive identity without the corresponding capability.

    • Bind native owned invocation and terminal observation to actual
      caller/process generations.
    • Validate native stale-generation, forwarded-sender, object-reuse and
      exact-grant controls.
    • Complete path/provider/realm replay and TOCTOU coverage across the
      remaining codebase.
  • Audit cleanup failure behavior: attempt independent retirements, preserve existing caller-specific error precedence, including cleanup uncertainty overriding the triggering error, and quarantine/terminate when required; never continue serving with an unaccounted grant.

    • Implement acknowledged native terminal/retirement progress and
      retained cleanup failure ownership.
    • Complete ordinary consumer loss, running mediator retirement and
      independent provider cleanup.
    • Audit all callers for error precedence, quarantine and absence of
      unaccounted grants.
  • Audit unsafe code, FFI, wire parsing, range arithmetic, initialization, lifetimes, locks, interruption and publication order; give each unsafe block an exact safety argument and adversarial test where practical.

    • Correct and validate owned hardware-table storage, geometry, rollback
      and publication boundaries.
    • Validate the implemented C byte/string FFI and compatibility
      scalar/wire boundaries.
    • Complete the remaining unsafe, parsing, arithmetic, lifetime and
      concurrency audit.
    • Independently review every safety argument and applicable adversarial
      control.
  • Inventory redundant implementations, dead/fallback code, duplicated validators, obsolete wrappers and deprecated public/wire APIs with all callers.

    • Identify duplicate memory-runtime ownership, retired invocation
      selectors and superseded frame-checker paths.
    • Finish the whole-codebase redundant/dead/fallback/API inventory with
      every caller.
  • Migrate callers and remove deprecated APIs/compatibility shims in coordinated signed graphs; test rejection of retired versions without silent permissive fallback. Do not retain an obsolete API solely to avoid caller edits.

    • Migrate the native generation-bound invocation/terminal selectors and
      reject retired wire forms.
    • Remove duplicate Integration memory implementations and superseded
      shell checker APIs.
    • Finish migration and removal of all remaining deprecated APIs and
      compatibility shims.
    • Validate the complete final consumer graph and retired-version
      refusal.
  • Classify every hard-coded size/count/depth/time restriction as ABI, hardware, explicit resource policy or accidental implementation limit. Replace accidental limits with checked caller-sized storage or authorized allocation.

    • Remove the identified fixed owned-table storage ceiling with checked
      geometric ownership growth.
    • Classify all other size/count/depth/time bounds as ABI, hardware,
      explicit policy or incidental.
    • Replace remaining incidental limits with owned storage and preserved
      exhaustion behavior.
  • Test above every removed old boundary and at exact allocation/ABI boundaries; preserve resource exhaustion errors, denial-of-service protection and mandatory bounded waits instead of interpreting “no arbitrary limits” as “unlimited resources”.

    • Validate expanded native table/mapping boundaries and
      allocation/rollback exhaustion controls.
    • Cover every remaining removed boundary, exact ABI/allocation endpoint
      and bounded-wait policy.
  • Inventory all authored code files at/over 1,000 physical lines, including tests, scripts and generated-source templates. Refactor them into cohesive modules below 1,000 lines, preserving meaningful APIs and tests.

  • Add a deterministic tracked-source size gate; exclude only genuine non-code data/external payload archives, not large authored tests or fixtures containing executable logic. Split generators and their generated code too.

    • Run deterministic tracked-source file-size censuses including tests
      and authored scripts.
    • Promote the reviewed classification into a maintained source-size
      gate.
    • Add negative fixtures and CI coverage for authored/generated code
      without broad exclusions.
  • Audit production versus integration/dev-only feature gating and linked symbols. Move/delete remaining test orchestration/diagnostics from production rootd; carry every retained move/delete classification to closure.

  • Re-measure rootd semantic surface using the maintained baseline tooling; compare same-toolchain code size, imports, unsafe blocks, accepted messages and authority inventory, not incomparable historical LoC estimates.

    • Retain same-toolchain Rootd code/symbol/authority baseline
      observations and corrected production audit artifacts.
    • Complete the current semantic-surface comparison and every retained
      move/delete classification.
  • Audit bootstrap service ownership and release/development authority parity; prevent new compatibility work from adding policy or routine test orchestration back into rootd. initd/bootd-style work stays Phase 7.3.

  • Audit all performance findings through Integration profiler and measured optimization evidence before changing algorithms; deduplicate measured hot paths without caching successful access checks, broadening grants or leaving invalidatable state unowned.

    • Measure and validate native invocation lookup/settlement improvements
      without cached authorization.
    • Measure and remove repeated host frame-checker parsing/analysis work.
    • Finish causal mapping/startup optimization with unchanged end-to-end
      timing acceptance.
    • Complete measured build-workload optimization and whole-codebase
      performance review.
  • Audit build/CI scripts for secret exposure, mutable shared outputs, symlink escapes, unsafe deletion, unbounded subprocesses, silent warning suppression and accidental host dependencies.

    • Correct demonstrated host-tool selection, source identity, subprocess
      and output-ownership defects.
    • Complete all build/CI script secret, symlink, deletion, shared-output
      and dependency audits.
    • Validate final script custody and warning behavior across the complete
      build closure.
  • Repeat the entire audit on final heads, independently review all security closures, and require zero unresolved in-scope authority, deprecated API, undocumented-code and over-1k-code findings before Phase 6 acceptance.

  • Inventory obsolete planning/migration documents, manifests, scripts, CI jobs, feature flags and migration-only tests, including dynlink migration checks and the superseded local planning archive. Preserve necessary evidence in historical artifacts/issues, then delete obsolete active files and references; retain current specifications and security assertions, not obsolete scaffolding.

  • Remove superseded static executable intake from every public launch, loader, policy, configuration and test path now replaced by dynlink intake. Map each former useful assertion to maintained coverage, reject retired input, and preserve genuinely required mount/bootstrap mechanisms with explicit scope. Inspect real consumers: a shared segment type used by dynamic materialization or the EFI loader's pre-runtime boot contract is not removed by name alone.

  • Audit symbols, filenames, flags, wire names and diagnostic tokens for milestone terminology; replace planning-based naming with semantic responsibility names and update all consumers/tests atomically. Allow useful historical comments/docs and real algorithmic concepts, not executable planning APIs hidden behind an exception.

  • Review code navigation, naming, control flow, error paths, module cohesion and inline explanations with a contributor/auditor walkthrough; merge semantically similar files where useful while staying below 1,000 lines.

    • Split and document the changed Kernel, Integration and shell checker
      modules by responsibility.
    • Complete contributor/auditor walkthroughs of naming, control flow and
      errors in remaining components.
    • Finish justified consolidation and verify whole-code navigation and
      cohesion.
  • Identify repeated behavior across repositories suitable for an authority-free shared library; document genuine common semantics, variation, dependencies and boundaries before extracting it. Do not abstract merely similar syntax or combine unrelated trust domains.

  • For each justified extraction, create a new Forgejo repository from meta first, clone/branch it, implement documented/tested shared APIs, migrate callers, remove duplicates, and add catalog/CI/manual/man-page/audit/PR entries. Add explicit checklist rows for every resulting repository and use exact dependency commit pins without circular service/library dependencies.

  • Complete the authority, lifecycle, quality and documentation audit for blockd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for boot-tool, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for bootloader, including required tests and original CI; justify non-applicability per dimension. Repository audit. profile deadline.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for coreutils, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for crashd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for deviced, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for docs, including required tests and original CI; justify non-applicability per dimension. Repository audit. API conversion design · artifact publication design · generated Coreutils note · publisher startup · manual builder · TLS fixture parser · publisher clock.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for drv-acpi, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for drv-i8042, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for drv-ps2-keyboard, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for drv-ps2-mouse, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for drv-rtc-cmos, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for drv-serial, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for drv-virtio-block, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for dynlinkd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for e2fsd, including required tests and original CI; justify non-applicability per dimension. Repository audit. Checker fixture collision.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for exsh, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    Signature certification diagnostics must be resolved under the existing independent key/fingerprint contract.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for extop, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for fatd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for fbcond, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for hotplugd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for inputd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for integration, including required tests and original CI; justify non-applicability per dimension. Repository audit. reserved signal admission · parser fixture inputs. Native compiler prerequisite. Cargo catalog alignment.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for irqd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for kernel, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for keyd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for launchd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-aes, including required tests and original CI; justify non-applicability per dimension. Repository audit. fixed-work arithmetic.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-block, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-bootimg, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-bootstrap, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-capabi, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-cli, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-console, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-constant-time, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-crc, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-deflate, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-device, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-driver, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-dynlink, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-ed25519, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-elf, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-fs-crypto, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-fs-name, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-handoff, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-input, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-interrupt, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-ipc, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    Counted filesystem, bootstrap and launch path migration coordinates removal of the remaining fixed-width APIs and their callers.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-log, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-partition, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-service, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-sha2, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-stdio, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-time, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-tty, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-vfs, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for loaderd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for logd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for memd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for meta, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for named, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for pagerd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for powerboxd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for probed, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for procd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for ramfsd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for rootd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for seriald, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for sha2-tool, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for timed, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for ttyd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for vfsd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for vspaced, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-posixabi, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-cstd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for posixd, including required tests and original CI; justify non-applicability per dimension. Repository audit.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit, feature-boundary
      and performance review.
    • Verify current authored code files remain below 1,000 physical lines.
    • Inventory direct crate-root missing_docs declarations, or establish
      that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and all
      applicable lint-coverage review.
    • Complete applicable component format/lint/test/build/documentation
      checks recorded locally or by original CI.
    • Observe successful original component CI for this exact current
      feature head.
    • Reconcile complete warning-free logs, applicable consumer/VM gates and
      independent repository closure.
  • Complete the authority, lifecycle, quality and documentation audit for lib-owned-region, including required tests and original CI; justify non-applicability per dimension. Shared library.

    • Complete capability, alias, replay, cleanup, unsafe/FFI and
      error-ordering audit.
    • Complete redundancy/deprecated-API, incidental-limit,
      feature-boundary and performance review.
    • Verify current authored code files remain below 1,000
      physical lines.
    • Inventory direct crate-root missing_docs declarations, or
      establish that this repository has no Rust target.
    • Complete meaningful public/private inline documentation and
      all applicable lint-coverage review.
    • Complete applicable component
      format/lint/test/build/documentation checks recorded locally or by
      original CI.
    • Observe successful original component CI for this exact
      current feature head.
    • Reconcile complete warning-free logs, applicable
      consumer/VM gates and independent repository closure.

Rustdoc, missing_docs and documentation

Weight: 5%. Owning issue · docs PR 4.

Checklist
  • Inventory every crate root and target, including binary-only, build-script, test/example and nested crates; identify existing missing_docs enforcement and every local allow/expect/doc-hidden escape.

  • Document crate/module purpose, trust boundary, owned/borrowed state, lifecycle, authority and error contracts using //!//// rustdoc comments.

    • Document the changed native ownership, invocation and hardware-table
      module contracts.
    • Document implemented compatibility scalar/wire and C byte/string
      module boundaries.
    • Finish remaining service, driver, filesystem and terminal module
      lifecycle/authority contracts.
    • Complete crate/module documentation for added runtime/toolchain/build
      implementations.
  • Document every public item, field, variant, constant, associated item, macro and FFI export with semantics, units, ranges and failure behavior.

    • Document and regenerate the implemented shared ABI, native invocation
      and C runtime API slices.
    • Review semantics, units, ranges and errors for every remaining
      existing public item.
    • Complete public item documentation for remaining Phase 6
      implementations.
  • Document private functions, structures, fields and non-obvious algorithms as well; explain concurrency, mutation order, cleanup, complexity and invariants. missing_docs alone is not a private-code completeness audit.

    • Document changed native table/cleanup algorithms and
      profiler/frame-checker internals.
    • Review remaining private functions, structures, fields and algorithms
      across all repositories.
    • Complete private concurrency, mutation, cleanup and complexity
      documentation for later implementations.
  • Give unsafe APIs # Safety, and fallible/panicking APIs accurate # Errors/# Panics sections where applicable. Document each unsafe block's concrete invariant and why safe alternatives do not cover the operation.

    • Document implemented C FFI pointer/link contracts and changed native
      unsafe ownership boundaries.
    • Complete every remaining Safety/Errors/Panics contract and
      unsafe-block argument.
    • Independently review arguments against actual error, panic and
      safe-alternative behavior.
  • Enforce #![deny(missing_docs)] or an equally non-bypassable shared lint policy in every EriX-authored crate/target; reject weakening attributes. Do not use blanket allowances, dummy comments or doc-hidden to pass the gate.

    • Verify direct missing_docs denial declarations in all current authored
      crate roots.
    • Scan current tracked Rust for lint weakening and hidden-documentation
      escapes.
    • Enforce rejection of weakening attributes in the maintained
      whole-source policy.
    • Finish meaningful-documentation review and enforcement for all
      remaining targets.
  • Add private-item documentation review/check coverage and run Rustdoc with --document-private-items; validate broken links and examples with RUSTDOCFLAGS="-D warnings" across supported target/feature profiles.

    • Run warning-denied private rustdoc in the changed component validation
      matrices.
    • Complete private-documentation review/check coverage across all
      repositories.
    • Verify links/examples and every supported target/feature profile in
      the final graph.
  • Ensure CI actually checks missing_docs in default and alternate feature builds, not only one public-library configuration; add a negative fixture proving undocumented public API fails the shared policy check.

    • Run existing default/alternate-feature strict CI for the implemented
      component checkpoints.
    • Add a shared negative fixture proving undocumented public API fails
      policy.
    • Complete all crate/target/feature enforcement coverage and reject
      bypasses.
  • Document non-Rust authored code inline in its language's supported comment format, including shell/Python tools and assembly boundary contracts. Do not pretend rustdoc parses unrelated languages.

    • Document the changed Python/Shell owners, profilers/checkers and C
      runtime assembly boundaries.
    • Complete meaningful inline documentation in remaining non-Rust
      authored code.
    • Review documentation for new generators, packaging and runtime
      boundary code.
  • Update meta standards/templates and propagate necessary policy changes deliberately. Repair stale canonical GenAI policy links to docs/policies/generative-ai-contributions.md; keep attribution optional.

  • Update README/ARCHITECTURE/ROADMAP and relevant manual chapters for each implemented ABI, realm, POSIX service, toolchain, profiler and build step; keep historical measurements separate from current guarantees.

    • Update canonical component and manual contracts for implemented
      ABI/libc, native custody and profiler work.
    • Complete documentation for remaining realm/POSIX/toolchain/build
      functionality.
    • Reconcile all final component documents and manual guarantees with
      current behavior.
  • Regenerate API references with the native Rustdoc JSON producer, test examples, build the whole manual, check final warnings/overflow/links and visually inspect changed rendered pages. Record toolchain/source provenance for the generated documentation.

    • Generate source-bound API references for the implemented interface
      checkpoints.
    • Build and test the current full manual with final warning/layout and
      changed-page visual checks.
    • Regenerate and validate every remaining Phase 6 interface/example and
      the final complete manual.
  • Update canonical templates and every repository README to remove current-status/progress/checkpoint sections; put concise current state in ROADMAP/ARCHITECTURE and detailed historical evidence in linked issue/reports.

  • Refactor long README/ARCHITECTURE/ROADMAP paragraphs and exhaustive lists into short summaries plus focused design/API/operator documents. Preserve canonical headings, discoverability and normative invariants; do not hide important authority limitations or move status into another README section.

    • Extract focused ownership, bootstrap, profiler and build-scope
      design/operator documents.
    • Remove remaining exhaustive progress prose from canonical component
      documents.
    • Review all canonical headings, concise summaries and links without
      hiding limitations.
  • Keep help text, man pages, rustdoc, C headers, IPC specifications and technical manual consistent through shared semantic metadata where useful; validate coverage and examples, not merely that generated files exist.

Integration profiler and measured optimization

Weight: 5%. Owning issue · integration PR 12.

Checklist
  • Inventory existing READY/command timers and private QMP/PC evidence; define which collectors are reusable, incomplete, obsolete or unsafe to retain.

    • Inventory maintained READY/command timers and the named historical
      QMP/PC captures.
    • Complete the reusable/incomplete/obsolete/unsafe classification and
      all retained diagnostic dispositions.
  • Specify a versioned profile format with source/image/config hashes, toolchain, hardware/QEMU/acceleration/CPU/memory/worker settings, time domain, capture interval, exact process generation and module identity.

    • Version host startup metadata, source/image/configuration hashes and
      timing/resource fields.
    • Record native host workload and exact executed-code capture identities
      with explicit attribution limits.
    • Complete authenticated guest process-generation/module identity and
      full build profile contracts.
  • Define explicit capture authority, lifecycle and permitted fields; exclude key material, capability contents, consent input and arbitrary process memory. Diagnostics must not confer process control or namespace access.

    • Define explicit bounded host capture inputs, permitted scalar/code
      fields and owned teardown.
    • Exclude implicit guest control/memory mutation, secrets and consent
      data from maintained host interfaces.
    • Define and validate any required guest capture authority, cross-realm
      policy and retirement.
  • Add a bounded host collector with hard/silence limits, owned PID cleanup, interruption handling, raw-log preservation and true failure status.

  • Implement exact image/ELF/PT_LOAD/source binding and symbolization; reject stale maps and ambiguous userspace addresses without process/module identity. Do not infer process ownership from an overlapping virtual address.

    • Bind startup admission to original source/features and exact packaged
      image/artifact bytes.
    • Match TCG captured code to exact executable load bytes and symbols
      while retaining ambiguity.
    • Bind userspace attribution to actual process generation/module
      ownership and reject stale identities.
  • Add authenticated, opt-in guest timing/counter hooks where host samples cannot attribute a cost; compile/runtime gate them appropriately and prove their absence from clean release images when disabled.

  • Record boot service stages: image resolution/read, relocation, mapping/materialization, process start, startup delivery, initialization, publication, cleanup, final READY and full shell-caret display.

    • Capture ordered service READY barriers, final readiness and the full
      shell caret.
    • Attribute image resolution/read, relocation, materialization and
      process start.
    • Attribute startup delivery, initialization, publication and cleanup
      within each service.
  • Record command stages: Enter acceptance, parse/expand/resolve, authority request/decision, file reads, link/load, spawn/scheduling, first execution/output, output drain, exit/wait and fresh caret.

    • Retain the actual native command transcript, command interval and
      fresh-caret observations.
    • Attribute input, parse/expand/resolve, authority and file/link/load
      stages.
    • Attribute spawn/scheduling, execution/output, drain, exit and wait
      stages.
  • Measure IPC count/bytes/waits, runnable versus blocked time, context switches, mapping scans/batches, page allocation/faults, VFS/provider fanout, block request size/LBA, cache hits/misses and TTY/framebuffer work.

    • Measure actual native invocation workloads and preserve
      setup/operation/cleanup counts and times.
    • Record real task CPU counters separately from wall time and TCG
      instruction upper bounds.
    • Complete runnable/blocked, context-switch, allocation/fault and
      mapping counter attribution.
    • Complete VFS/block/cache and terminal/framebuffer measurement
      coverage.
  • Bound buffers through explicit resource policy, report dropped records, clock discontinuities and partial captures; never label incomplete data a complete profile or fabricate a percentage of total CPU time.

  • Implement reproducible reports: service timeline, command critical path, per-component counts, latency distributions and symbol/sample summaries. Separate wall time, CPU time, blocking time and sampling observations.

    • Produce bounded reproducible startup timelines and conservative
      command timing reports.
    • Produce native workload distributions and exact-code/symbol candidate
      summaries.
    • Complete per-component guest critical paths and separate
      CPU/blocking/wall-time reports.
  • Add deterministic parser/attribution/error fixtures, malformed/stale identity tests, dropped-record tests and collector cancellation/timeout tests.

    • Test host parser framing, stale/malformed inputs, budgets,
      discontinuities and partial captures.
    • Test collector cancellation, timeout, process cleanup and real
      executed-code fixture admission.
    • Complete authenticated guest-generation/module attribution and
      cross-realm error fixtures.
  • Add VM profiler tests that identify known synthetic CPU, wait and I/O workloads, reject cross-realm capture and verify all capture authority is retired. Compare profiled versus unprofiled overhead without subtracting it from acceptance measurements.

    • Run the real QEMU plugin fixture for known executed code, counters and
      bounded output refusal.
    • Identify guest CPU, wait and I/O workloads with actual authenticated
      ownership.
    • Prove cross-realm capture denial and complete authority retirement.
    • Complete profiled/unprofiled overhead comparison under unchanged
      acceptance bounds.
  • Establish controlled cold/warm startup and build baselines with isolated repeats, explicit resource limits and confidence/variance reporting. Preserve the stricter carried Phase 5 handoff and remaining gates startup thresholds without moving endpoints.

    • Retain controlled native host workload comparisons and original failed
      startup/control observations.
    • Establish complete cold/warm startup baselines with the required
      isolated repeats and variance.
    • Establish full compiler/build baselines under explicit resource and
      deadline policies.
  • Rank evidenced bottlenecks by measured end-to-end impact; create individual Whole-codebase authority and quality audit findings with one causal hypothesis, owner and acceptance test.

    • Rank native invocation/checker costs and exact-code mapping/switching
      candidates with documented limits.
    • Establish end-to-end impact and causal findings for complete startup
      and build workloads.
  • Optimize the highest-impact proven path, then reprofile and repeat: inspect loader/provider fanout, mapping/process startup, event waits, build dependency scheduling and terminal delivery according to evidence, not guesses.

    • Implement and reprofile validated native invocation lookup/settlement
      improvements.

    • Implement and reprofile measured host checker parsing/analysis
      improvements.

    • Complete measured startup-path improvement under the original guest
      timing oracle.

    • Profile and optimize remaining full build, I/O, scheduling and
      terminal bottlenecks.

    • Eliminate repeated parser and runtime test fixture compilation through
      borrowed callbacks; retain original semantics and match both compiler profiles.
      All fourteen ordinary dev/release selections and strict host/native controls
      pass under unchanged limits; current CI unit/checker controls pass while the
      separate native frame proof remains open.
      Implementation, compiler issue,
      pull request.

  • For each optimization, prove unchanged authorization, revocation, permissions, object identity, failure ordering, output semantics and fairness; retain strict tests and isolated same-configuration before/after measurements.

    • Retain authorization/revocation/error-ordering controls and
      same-configuration measurements for accepted lookup/checker changes.
    • Complete equivalent semantic and isolated before/after proof for
      remaining startup/build optimizations.
    • Reconcile all optimization findings against the final original-source
      graph.
  • Add reviewed startup/build throughput and resource regression budgets to CI, using dedicated uncontended performance jobs and calibrated full-build deadlines. Ordinary functional jobs still have forced stall limits.

    • Preserve and exercise the existing strict startup oracle and
      functional stall limits.
    • Add calibrated build-throughput/resource budgets and dedicated
      uncontended CI performance jobs.
  • Remove superseded diagnostic hooks/helpers and document how to capture, interpret and reproduce profiles. Keep only evidence-backed tooling.

    • Document maintained startup, native workload and executed-code
      capture/report procedures.
    • Retire every superseded diagnostic implementation and finish
      reproducibility coverage.

POSIX ABI

Weight: 3%. Owning issue · lib-posixabi PR 3.

Checklist
  • Define x86_64 C ABI sizes, signedness, alignment, byte order, calling conventions, structure layouts and ABI version negotiation.

    • Define and independently probe implemented x86_64 LP64 scalar sizes,
      alignment and C call declarations.
    • Complete all required structure layouts, calling contracts and ABI
      version negotiation.
  • Define errno values and a complete native-error mapping table, including missing authority, absence, unsupported operation, interruption, would-block, exhaustion, stale identity and partial I/O.

    • Define checked errno scalar values and explicit contextual
      native-completion classification.
    • Complete operation-specific native error mappings for all POSIX
      workloads.
    • Validate interruption, partial I/O and cleanup/error precedence
      through real adapters.
  • Define fd/open-description, PID/process-generation, process-group, session, thread and realm identifiers as non-authoritative compatibility data.

  • Define file/status/mode/credential/ACL, seek/offset, directory, time, signal/action/set, wait and resource-limit types/constants.

    • Define checked file modes/base status, file offsets and canonical time
      scalars.
    • Complete credential/ACL, directory, signal/action/set, wait and
      resource-limit surfaces.
      Live sets/actions, client-local labels and mask/entry calculations are
      implemented, with compatibility1.10 action/mask/self-generation/handoff
      codecs. Remaining surfaces and full runtime obligations keep this substep open.
    • Bind those definitions to trusted metadata and required runtime
      operations.
  • Define IPC shapes with exact validation, request correlation, version/reserved-field rules and normalized capability transfer expectations; keep pure ABI parsing free of syscalls or service lookup.

    • Implement the version-query wire codec with checked framing and
      authority-free parsing.
    • Implement compatibility 1.1 Read/Write/Close wire codecs
      with exact framing, full correlation, counted payloads and atomic encoding.
    • Complete remaining POSIX operation request/reply shapes and
      correlation/version/flag rules.
    • Validate capability-transfer expectations through the native consumer
      adapters.
  • Define checked 64-bit file/time arithmetic, C pointer/length handling, integer conversion and deterministic overflow/error behavior.

    • Implement checked full-width file/time arithmetic and canonical
      timespec normalization.
    • Implement numeric byte-extent overflow checks without manufacturing
      pointer authority.
    • Complete operation sentinels, C pointer intake and native adapter
      semantics.
  • Provide reviewed C header declarations corresponding to Rust ABI definitions; test layout/constant agreement with independent C and Rust probes.

    • Publish C declarations and independent C/Rust probes for implemented
      scalar/status interfaces.
    • Complete headers and layout/constant agreement for the remaining POSIX
      ABI.
  • Test malformed/old versions, unknown flags, invalid identifiers, overflow, nonzero reserved fields, extra capabilities and noncanonical errors.

    • Test malformed versions/flags/reserved fields, invalid scalars and
      arithmetic boundaries in implemented codecs.
    • Complete all operation-specific malformed input, extra-capability and
      error-canonicalization controls.
  • Publish documented ABI compatibility rules and pass strict crate, header, cross-target and exact-head CI gates before consumers depend on it.

    • Publish implemented compatibility contracts and pass strict
      host/header/freestanding component CI.
    • Complete ABI-wide compatibility rules, consumer coverage and final
      strict validation.

POSIX service and realm lifecycle

Weight: 6%. Owning issue · posixd PR 5.

Checklist
  • Specify per-realm/per-process ownership and isolation inside posixd; separate private native service routes from each client's narrow authenticated ingress and reject numeric-realm impersonation.

  • Implement create/configure/seal/start/abort/retire realm states with generation-bound identities, validated resource ceilings and exact rollback.

    • Implement root-capability-free native staged process construction with
      exact identities and rollback.

    • Implement authenticated Procd/Launchd install-grant return and guarded
      unstarted preparation.

    • Implement native ancestor/nested revocation custody and acknowledged
      terminal primitives.

    • Install counted minimum startup/configuration receivers and
      acknowledge setup-authority disposal.

    • Execute the actual Posixd mediator and authenticate receiver
      readiness.

    • Implement pure counted configuration, ordinal pull, client
      startup and seal/terminal codecs with complete scalar correlation.

    • Implement the native Posixd counted configuration, receiver
      admission, seal and byte-I/O consumer with host fault controls, strict
      component CI and verified debug/release executable layout.

    • Complete Launchd runtime orchestration and coordinated
      producer/consumer adoption, then configure/seal/publish the realm and perform
      mediated client I/O in the native witness.

    • Complete remaining abort/retire,
      supervisor-loss and resource-ceiling validation.

    • Implement and validate the native RCS1 byte-client executable,
      including complete startup/capability census and retained byte-call custody.
      Component evidence: Posixd 1aa9b76,58 tests in four profiles, CI31/32.

    • Implement and validate counted Launchd client rows, canonical
      plan storage, two-column capability reservation and LCH1 V4/88 admission.
      Component evidence: Launchd f403dde,403 tests in six selections, CI157/158.

    • Implement and validate Loaderd root-derived layout binding,
      distinct client preparation and original process/linker/staged cleanup owners.
      Component evidence: Loaderd e0562cd,142 tests in four profiles, CI105/106.

    • Implement and validate Procd counted client provisioning,
      seal, terminal/disposal notification and nonconsuming final CPU READ/ACK.
      Component evidence: Procd 3b84f4b,380/386 total tests per profile, CI312/313.

    • Implement and validate Posixd's distinct never-started client
      disposal, retained through configuration with exact binding/delivery/receiver
      retirement and fixed control-reply custody after failed COMPLETE.
      Component evidence: Posixd 3541ce5,64 tests in four profiles, CI33/34.

    • Implement and component-validate Launchd guarded client
      preparation, separate grant/provider custody and unstarted private
      Retire/Read/Ack cleanup with original native RELEASE and unknown-creation
      quarantine while independent peers retire.
      Current-source evidence: Launchd 21635dba,451 tests in six selections, CI167/168.

    • Implement and component-validate public canonical plan append
      and freeze with original caller/member admission, immutable record order,
      complete uniqueness/coverage/ring checks and accepted-effect loss cleanup.
      Remove the profiled quadratic validation bottleneck with exact byte restoration.
      Current-source evidence: Launchd 21635dba,451 tests in six selections, CI167/168.

    • Implement and component-validate counted stopped-client
      provisioning through public Start: exact grant/receive custody, complete
      startup hashing, ordered descriptor streaming, native RELEASE between stages
      and all client Commits before mediator Start. Preserve cancellation, unknown
      invocation and independent original cleanup; no client execution is claimed.
      Current-source evidence: Launchd 21635dba,451 tests in six selections, CI167/168.

    • Implement and component-validate authenticated configuration
      pulls after counted PrivateReady, with exact original context/order, immutable
      records, original RECV-only COPY and retained source/serving custody. Preserve
      malformed/lost-call cleanup and bounded idle progress without client execution.
      Current-source evidence: Launchd 8a3b6a0b,461 tests in six selections, CI169/170.

    • Implement and component-validate public two-sided seal with
      original supervisor/cohort admission, continued configuration pull progress,
      exact Prepared and native RELEASE before original RECV/setup source disposal,
      and complete absence before CommitSeal. Retain failures and unknown custody;
      acknowledge Sealed only after exact result and original caller retirement.
      Current-source evidence: Launchd 2fd8dff1,472 tests in six selections, CI171/172;
      Docs c63da0d8,45 tests, full manual/visual checks and CI1079/1080.

    • Implement and component-validate original sealed-client Start,
      role-preserving private WAIT and full terminal outcomes through retirement.
      Retain separate original supervisor/controller identities; commit checked
      client CPU once before exact ACK and original caller RELEASE. Preserve unknown
      custody, public/parent loss, independent event/accounting arrival, overflow and
      ACK loss; idle WAIT and completed mediator cleanup must yield without spinning.
      Current-source evidence: Launchd d226af9c,487 tests in six selections, CI175/176;
      Launchd issue 9 corrected with producer-consistent red/green and substitution controls.

    • Implement and component-validate mediator final Read/local
      once-only CPU recording/exact Ack with original native caller RELEASE before
      full retirement. Preserve the original supervisor, actual spontaneous event,
      distinct positive nonexecution, unknown/lost callers and checked overflow.
      Share checked aggregation between separate client and mediator lifetime sinks;
      native managed-row reuse is recorded below; final CPU/profiler values remain open.
      Current-source evidence: Launchd 0b0788b5,496 tests in six selections, CI177/178.

    • Execute the native configured-client witness with an exact
      resident process budget, replace a retired realm while its peer stays live,
      reject stale selectors and verify the actual packaged process/paging counts.
      Integration 3bfa40a6
      passes with Procd38/Pagerd102,109 artifacts and57045 serial bytes. Final
      numeric CPU/profiler values and remaining loss/exhaustion gates stay open.

    • Observe all eleven native final Measured snapshot additions and the
      surviving Launchd lifetime sums after retirement. Verify original code,
      actual returns, captured physical storage and inactive user-access denial.
      All original VM markers, native exit and 120/45-second gates pass without
      adding guest authority. Accounting evidence.

    • Execute native full-table realm reservation refusal, preserving both
      sealed peers and all byte-I/O, actual exit, retirement and reuse checks.
      Verify the retained BootConfig and exact packaged record budgets with the
      original VM gates; older preparation/startup scenarios also pass.
      Native image evidence.

    • Execute separate native client-record and plan-storage exhaustion
      with valid counts, exact refusals and preserved Guarded/Sealed peers.
      Require normal configuration before and after reclamation and every original
      execution, retirement and reuse gate; older preparation/startup VMs pass.
      Native image evidence.

    • Dispose of two fully provisioned native clients before public START,
      then reuse their exact records while the original peer stays sealed.
      Preserve absent stale pairs, six actual successful client exits, all capacity
      refusals and original gates; client, preparation/startup and full CI1824 pass.
      Positive numerical NeverExecuted accounting remains a separate open requirement.
      Native source, CI1824,
      pull request.

  • Bind read-only source/toolchain roots, output/tmp roots, executable directories, cwd/root selectors and inherited streams from actual receipts.

    • Implement Vfsd-enforced directory attenuation: pin a new navigation
      ceiling, optionally remove writes, preserve restrictions through cwd,
      child resolution, redirection and redelegation, and retire independent
      provider anchors. Tests authored; execution waived by the user.
      Vfsd review, wire contract.
    • Extend canonical counted configuration and deployment storage for typed
      filesystem and inherited-stream bindings, preserving original generations,
      explicit counts and immutable plan identity without an incidental fixed cap.
      Shared framing, Launchd/Posixd custody and Procd target-layout adoption are
      implemented. RCS1 minor one now includes internal and external stream
      descriptors with exact frozen-plan counts and original D+A storage bounds.
      Rootd/Integration/Loaderd/Exsh adoption and the coherent immutable dependency
      graph are implemented and signed/pushed. The bounded native binding
      scenario is authored; tests and CI are waived without pass claims.
    • Derive filesystem endpoints through Launchd's authenticated Vfsd route
      and streams from original caller I/O owners, retaining receipts and native
      ownership through publication, release, cancellation and uncertain cleanup.
      Authenticated directory and stream public preparation, canonical append,
      native delivery and seal handoff are implemented. Actual owned provider
      registration/serving and reply framing remain unfinished in
      the transport defect; legacy receivers
      cannot satisfy the mediator's owned invocation contract. This reopens the
      parent for code work despite waived testing. Stream request-loss lifetime
      is separately corrected in Launchd.
      Testing is waived for completion; authored controls remain unrun.
      Retain the original root cleanup identity after operation-source disposal;
      only a correlated private-route provider result discharges that obligation.
      Dedicated recipient stream views must dispose their own provider custody
      before BOTH/CANCELLED acknowledgment, independently of offsets/access,
      while preserving the lender. Ordinary existing proxies are insufficient.
    • Bind actual Posixd SEND receipts to the frozen plan after exact native
      receipt/QUERY agreement; reserve custody before effects and require source
      retirement before seal plus actual DROP/absence before reuse.
      Consumer intake, lookup, provider/caller/local retirement, complete source
      handoff and dedicated stream-view production are implemented. Coordinated
      image adoption remains covered by the separate deployment and publication
      substeps. Authored controls are unrun; testing is waived for completion.
    • Author complete positive, replay, read-only, escape, two-realm and
      cleanup tests plus a bounded native binding scenario; update documentation,
      coordinated signed revisions and public tracking with testing deferred.
      Implemented with eleven new test functions and six inherited packaging
      controls, all unrun. Scenario and scope,
      client review, shell review.

    Evidence and remaining scope: realm binding design,
    Launchd review, manual review.

  • Implement launch integration that creates a fresh compatibility process context, supplies only its selected routes, and never grants global named, provider, device, raw-block or kernel process-control endpoints.

    • Add exact-executable guarded mediator staging with no ordinary-start
      fallback.
    • Create and start the actual compatibility process context with only
      its selected private routes.
    • Verify final client/mediator inventories and absence of
      global/provider/device/control grants.

    Implemented and audited with original rootless process/grant custody, ingress-only
    client census and complete final mediator inventory before Prepared. Eight
    controls are authored but unrun; testing is waived without pass claims.
    Current ownership contract,
    Procd review, Posixd review,
    external-count fix, empty-table fix.

  • Implement deny-only uid/gid/group/mode/ACL checks after native capability admission; test uid 0, chmod/chown-like metadata and executable permission changes cannot manufacture access or bypass a capability ceiling.

    • Define checked credential/group and access-ACL views with
      complete deny-only mode/ACL decisions, no UID-zero bypass, explicit borrowed
      storage and independent positive/malformed/large-input controls.
    • Admit trusted per-client credentials bound to the original
      realm/process generations; request text, inherited environment and UID-zero
      labels cannot choose another identity or silently change group membership.
    • Complete sealed-client filesystem mediation for remaining native
      operations using trusted metadata and complete ACL evidence on the exact
      grant; preserve native ceilings under metadata updates, revocation and
      executable-permission changes. Counted bound-file resizing and directory
      access are accepted separately below; broader descriptor/pathname and
      operation-specific effects remain implementation work.
    • Author bounded native positive/negative/replay/cleanup coverage,
      update component/manual contracts and publish coordinated immutable pins,
      issues/PRs and the master checklist. Testing/CI are waived, not unfinished implementation.
    • Define explicit retained-provider permission snapshot and
      conditional-effect wire contracts, distinguishing unknown ownership/ACL
      evidence from proven absence, with exact framing and atomic refusal controls.
    • Implement Ramfsd retained-node permission snapshots and
      conditional truncation, shared per-node revision updates in both metadata
      setters, stale/restore/exhaustion controls, documentation and signed adoption.
    • Complete remaining operation-specific provider conditional
      effects required by native consumers, retaining full ownership/ACL evidence
      and the implemented persistent metadata/reference lifetimes.
    • Implement E2fsd retained snapshots and conditional truncation
      from original checked inode metadata and complete local access ACLs; retain
      unique revisions/full fingerprints, invalidate metadata attempts, share
      resize behavior, author controls and publish documentation/catalog adoption.
    • Transport complete canonical ACL entries in bounded pages on
      original retained revisions; implement actual ext dispatch, explicit Ramfsd
      refusal and caller-storage complete assembly with poison/cleanup semantics.
      Author controls and publish contracts, manual, coherent pins and tracking.
    • Implement consumer-side inherited stream invocation custody:
      original CLAIM client and frozen binding selection, shared offsets, bounded
      staging, partial I/O/EOF, cancellation, fixed results and dedicated-view Close.
      Author host/native controls, document and publish the consumer; actual native
      provider intake is implemented in provider intake.
    • Forward trusted permission snapshots and bounded ACL pages on
      original job-lifetime directory metadata endpoints; preserve exact operation
      ceilings, private provider correlation, object-ID rewriting, staging cleanup
      and owned result custody. Author controls, document and publish coherent pins.
    • Implement original bound-directory access under sealed effective
      credentials, actual native write ceilings and complete streamed ACL evidence;
      retain both invocation owners through cancellation and one-shot completion.
      Author host/native controls, document and publish coherent signed revisions.
    • Implement complete ext value-inode ACL acquisition, shared
      reference retirement and persistent mode/owner coherence; preserve named/default
      entries, per-reference quota charges, checksums, transaction/fail-stop and original
      provider epochs. Author media/provider controls and publish signed source,
      maintained documentation/manual and coherent catalog revisions. Native ACL
      metadata scenario and independent host-oracle controls are also authored,
      with separate helper/consumer/catalog identities and execution waived.
    • Implement the explicit native RESIZE_FILE grant and conditional
      provider bridge: original file/write ceilings, snapshot/complete ACL pages,
      fixed result capacity before effects, trusted clock and private correlation,
      stale/uncertain separation, owned result retention and explicit disposal.
      Centralize operation recognition across IPC, launch, broker and session
      without expanding bootstrap defaults. Author 23 controls, update contracts
      and manual, publish signed immutable dependencies and synchronize tracking.
    • Implement the complete counted bound-file resize path:
      authenticated fixed-purpose preparation, original scope/provider/alias
      custody, frozen per-client bindings, sealed mode/complete ACL policy and
      exactly-once conditional effect with fixed results and independent cleanup.
      Share filesystem ownership and permission machinery; remove obsolete APIs.
      Author 19 new host controls and extend the actual native workload with
      owner/nonowner/absent-selector cases and independent post-retirement reads.
      Update contracts/manual, fixture budgets and signed dependencies, fix the
      nested test module regression, and synchronize issues/PRs/phase tracking.

    E2fsd retained snapshots and conditional truncation are implemented for
    complete local access ACLs; the ext scope
    is closed with seventeen authored, unrun controls and signed catalog adoption.
    Complete local ACL transport and caller-storage acquisition are implemented in
    the entry design, with nineteen
    additional authored/unrun controls. Complete value acquisition, shared cleanup
    and persistent ACL metadata are implemented; operation-specific conditional
    native effects and scenario coverage remain open.

    Metadata policy and trusted credential intake are implemented. The shared
    provider wire contract and Ramfsd snapshot/conditional-truncation path are
    implemented, documented and signed, with ten additional controls authored but
    unrun. Native consumer enforcement and other providers' ACL evidence remain
    unfinished; the parent stays open. Design,
    library review,
    mediator review,
    catalog review,
    manual review.

  • Implement explicit root/cwd/PATH resolution confined to delegated namespace/executable roots; environment text, absolute paths and .. cannot escape the realm or select an undelegated service.

  • Implement resource accounting for process/thread/fd/memory/temp and in-flight work, with deterministic exhaustion and no fixed accidental table cap.

  • Implement noninteractive build policy: out-of-envelope operations fail promptly with documented errors, without hanging for a hidden prompt.

  • Implement realm teardown on normal exit, crash, denied transfer, launch abort, timeout and supervisor failure; retire all descendants/aliases and prove process/realm generation reuse cannot recover prior authority.

    • Implement exact staged abort and native process/route lifetime
      prerequisites.
    • Complete running realm teardown for exit, crash, denied transfer and
      timeout.
    • Complete supervisor-loss/descendant cleanup and actual
      realm-generation reuse refusal.
  • Add two-realm isolation VMs for filesystem, process, credentials, descriptors, service routes and teardown; include malicious message replay.

  • Package/start posixd from ext4 after the required native services; keep compatibility orchestration out of rootd and preserve READY/shell ordering.

  • Implement runtime exceptional-authority requests from running compatibility processes through their authenticated launch/realm route; resolve only within the caller's existing delegated selector ceiling.

  • Bind every grant to exact process/job/realm generations, resolved object identity, permitted operation and explicit one-shot/invocation/transaction lifetime. Never turn approval into a broad directory or reusable admin grant.

  • Extend trusted prompt descriptions for compatibility programs to show executable provenance, operation, object and lifetime; escape untrusted labels and keep labels/argv/paths non-authoritative.

  • Preserve automatic same-session secure attention, trusted y/n plus Enter decisions, renderer acknowledgement and fresh-input fences on serial and framebuffer TTYs. Untrusted PTY output cannot approve or spoof a prompt.

  • Deliver approved grants to the exact still-running process using explicit caller-local slots and tracked revocable aliases; reject stale, replaced, cancelled or already-exited recipients and clean partial delivery.

  • Implement operation-completion/denial/timeout/cancellation/revoke cleanup, including process death during approval and errors after one-shot consumption. No grant remains reusable by a later process or shell command.

  • Support exact-entry unlink/rename/truncate and reviewed recursive transaction envelopes; require a fresh explicit policy for any traversal scope, and prove rollback/partial-progress rules without ambient parent-directory write.

  • Add interactive VMs for approve, deny, revoke, malformed grant, object replacement, process exit, wrong TTY, replay and two-realm isolation; add a noninteractive build VM proving no prompt or silent escalation occurs.

Files, descriptors and namespace semantics

Weight: 6%. Owning issue · posixd PR 5.

Checklist
  • Implement per-process fd tables distinct from shared open-file descriptions; record rights, offset, status flags, inheritance and alias count.

  • Implement open/openat/close and dup/dup2/fcntl duplication with atomic replacement, lowest-free allocation and complete transfer cleanup.

    • Implement authenticated lowest-free and exact fd duplication,
      same-fd behavior and independent inheritance flags over shared original
      access/status/cursor ownership. Connect literal framing, counted producer
      storage, actual serving, host/native controls, documentation and publication.
    • Implement nonfinal/final Close and atomic target replacement
      with retained original source holds, provider/caller/local cleanup, stable
      generations, cancellation, refused-completion results and terminal disposal.
      Author failure and alias-lifetime controls and native workloads; publish the
      coherent signed graph and keep cleanup uncertainty fail-stopped.
    • Implement dynamic open/openat acquisition under explicit
      directory authority and native permission evidence, with required creation,
      access/status flags, complete acquisition/transfer failure cleanup and
      descriptor installation. Connect producer/consumer/native workloads,
      contracts/manual, signed dependencies and issue/PR tracking in one pass.
  • Implement read/write/pread/pwrite/readv/writev and lseek as required, covering zero/short I/O, shared offsets, append atomicity, EINTR and nonblocking.

    • Implement scalar/vector file I/O with complete direction checks,
      zero/short progress, shared cursors, one gathered provider-atomic append,
      explicit signed limits and canonical transient versus uncertain admission.
      Publish the coordinated codecs/providers/consumer and authored controls.
    • Implement positioned cursor preservation and SET/CUR/END/DATA/HOLE
      seeking through fresh original-object size, including write-only admission,
      signed boundary errors and unchanged state on refusal. Publish contracts,
      unit controls and the extended native realm workload.
    • Implement scalar/vector nonblocking streams/channels and retained
      blocking channels with shared status replacement, zero/short progress,
      EOF/EPIPE readiness, exact caller cancellation, draining/terminal cleanup
      and no replay after completion refusal. Publish controls and native peers.
    • Connect authenticated caught-signal delivery to actual retained
      I/O, returning EINTR only before progress and preserving positive progress,
      original native custody and cleanup across interruption and completion races.
      Implemented: original-supervisor/controller generation with full native
      identity, generation and digest proof; distinct signal custody without creation
      rollback; real pending caught state interrupts retained channel/file/stream
      calls before new effects. Positive progress, fixed results and original
      provider outcomes/cleanup survive races. Native USR2/callback/mask restoration
      and meaningful boundary/race controls are authored.
    • Connect required blocking native-stream readiness through the
      original provider/description and caller lifetime; remove the current
      unsupported-mode refusal only when actual readiness and cancellation work.
  • Implement pipe endpoints, EOF/hangup/broken-pipe semantics and
    bounded buffering; descriptor closure must wake exactly the affected waiters.

    • Admit explicit counted pipe-pool rings and exact versioned wire
      framing, including pool-only plans and atomic resource refusal.
    • Reserve the two lowest-free descriptors and independent
      descriptions atomically; publish after accepted COMPLETE or cancel both.
    • Implement FIFO scalar/vector small-write atomicity and
      bounded blocking/nonblocking behavior without a maximum-write ceiling.
    • Preserve original-description wait readiness, final-alias
      EOF/EPIPE, complete ring scrubbing, stale-generation refusal and safe reuse.
    • Implement ignored/caught/blocked SIGPIPE and default native
      termination through the retained original controller, without new grants.
    • Author unit/native/packaging controls, migrate producers and
      maintained contracts/manual, and apply rustfmt.
    • Publish signed immutable revisions and reconcile exact issue,
      PR and master tracking. Signed source and all exact public readbacks are
      reconciled. No test execution, runtime or profiler pass is claimed.
  • Implement stat/fstat/lstat/fstatat, readdir and seekable directory
    iteration with stable identity, correct dot entries, mode/size/link counts and
    source-qualified ctime/mtime/atime behavior.

    • Define exact source-qualified status and directory wire
      contracts with independent hostile-input and atomic-encoding controls.
    • Supply original provider identities, complete required
      metadata and honest signed time/source/precision, including volatile roots
      and mutations; fix E2fsd#14 without converting unknown time to Epoch.
    • Route held-object metadata and mounted directory enumeration
      through Vfsd with exact original scope, no authority widening and full-width
      provider cursors.
    • Implement compatibility path/fd stat families with correct
      follow/search/error behavior and original native cleanup.
    • Implement shared-description readdir/tell/seek/rewind, dot
      entries, aliases, result-capacity admission and cancellation.
    • Author meaningful unit/provider/native integration controls;
      audit/refactor touched code and update inline/component/manual documentation.
    • Publish signed immutable revisions and reconcile owning
      issues, affected PRs and public master issue65 with exact metadata/readbacks.
  • Implement mkdir/rmdir/unlink/link/symlink/readlink/rename variants required by the workload, with exact-entry authority and atomic visibility; cross-filesystem operations fail deterministically without partial mutation.
    Owning namespace mutation and lifetime design.

    • Define exact compatibility/native operation, outcome, counted payload and conditional original-entry contracts; migrate producers/consumers coherently.
    • Complete FAT namespace primitives with original-parent/target admission, creation policy, links, times and atomic publication.
    • Integrate original-client path/dirfd resolution, complete parent/target permission checks and one-use freshness into actual compatibility serving.
    • Complete two-path rename/link behavior, final links, trailing separators, same-object rename and no-effect cross-filesystem refusal.
    • Resolve held-object/directory detachment and alias lifetime dependencies; retain custody through cancellation, uncertainty, final retirement and reuse.
    • Author unit/provider/native workloads, audit/refactor authority and code, and update inline/component/manual documentation.
    • Publish the coherent signed immutable graph and reconcile linked reviews, owning issues and phase master.
    • Implement raw readlink/readlinkat through original-client root/cwd/dirfd resolution, complete prefix policy, bounded raw pages and original cleanup; include authored service/native controls, documentation and signed publication.
    • Implement RAM conditional namespace primitives with fixed-role original entries, permission freshness, creation policy, two-parent link/rename, raw symlinks and retained object custody; include authored controls, documentation and signed publication.
    • Implement journaled ext conditional namespace selection and all seven effects with original binding/permission evidence, shared transactions, explicit creation policy and directory ACL inheritance; include authored controls, documentation and signed publication.
    • Complete plain ext conditional namespace effects using explicitly selected original durable undo, atomic mount recovery, timestamps and unchanged filesystem format; include authored provider/media and VM controls, documentation and signed publication.
  • Resolve the existing held-directory pin restrictions against POSIX cwd/open-object rename/unlink expectations; implement safe object lifetime and namespace detachment without reverting to path-based reopening or stale grants.

    • Implement RAM open-file/symlink detachment and compatible replacement through original handles and acquisition keys, with counted reclamation, independent controls, native workload, documentation and signed publication.

    • Complete RAM hardlink edge/object separation and held-directory cwd/move/detachment semantics while preserving original root ceilings and alias custody. RAM source · Review.

    • Implement ext original-inode detachment, retained aliases, deferred final reclamation and recovery across failure without inode/generation or block reuse.

    • Implement FAT-family original-object detachment and deferred storage reclamation with selected catalog, original parent geometry, aliases and recovery.

    • Complete Vfsd and compatibility shared-description/cwd lifetime across namespace changes, cancellation and retirement without reopening paths or reviving stale grants.

    • Complete cross-provider native lifetime, resource/refusal, restart/recovery and identity-reuse controls; reconcile authority audits, documentation and the coherent signed graph.

    • Implement original independent FAT directory anchors with fresh source evidence, explicit ceiling proof, minimal counted imported ancestry and source-independent original cleanup; include provider/transport controls, inline/component/manual documentation and signed publication. Provider feature.

    • Implement conditional fixed-operation entry acquisition in LibIPC and RAM/ext/FAT, with distinct entry custody, fresh actual-parent/root admission, original root/key cleanup, native binding identity, appropriate controls, inline/component/manual contracts and signed publication. Design · LibIPC review · RAM review · ext review · FAT review.

    • Require actual retained native custody for exact immediate-entry metadata, permission snapshots/ACL pages and both file-resize follow-ups; remove ordinary permission APIs and fallback adapters, author original-route/lifetime/refusal controls, update documentation and publish signed source. Design · Vfsd review · Manual review.

    • Implement complete raw RAM entry and selection names with independently budgeted shared storage, pre-effect reservation, original owner retirement, full native enumeration, coordinated image policy, authored controls, inline/component/manual documentation and signed publication. Design · RAM review · Image review · Manual review.

    • Replace the fixed public exact-mutation envelope with complete counted raw destinations across LibIPC, original-custody Vfsd dispatch and Coreutils; share one-call status correlation, receipt retirement and scratch clearing with truncation; include literal/provider/transport/utility controls, inline/component/manual documentation and coordinated signed publication. Design · Vfsd review · Coreutils review · Manual review.

    • Complete counted exact-directory producer and consumer framing with raw names, actual capacity, original cursor and scope-generation custody, pre-publication reservation admission, independent metadata identity and known-size checks, original candidate/receipt retirement, literal/provider/transport/utility controls, inline/component/manual documentation and coordinated signed publication. Design · Vfsd review · Coreutils review · Manual review.

  • Implement truncate/ftruncate, sparse growth, fsync/fdatasync and durability contracts; test concurrent access, ENOSPC and interrupted failure.

    • Implement explicit original-device durability barriers, exact device/partition routing and supported/refused provider guarantees; author wire, failure and native workload controls, document and publish the graph. Implemented barrier.
    • Implement filesystem persistence boundaries and recovery ordering using original device guarantees, including complete FAT metadata.
    • Implement compatibility truncate/ftruncate and sparse growth with original held-object lifetime, exact size admission and ENOSPC behavior.
    • Implement compatibility fsync/fdatasync through the original held description, preserving interruption, cancellation and cleanup semantics.
    • Complete whole-item concurrent/failure/native controls, code and authority audits, documentation and coherent signed/public reconciliation.
  • Implement required mode/umask/ownership/access/ACL semantics with an explicit trusted metadata source. ACL byte preservation alone is not permission enforcement; unsupported provider behavior must be explicit.

    Design: mode, ownership and access operations.

    • Implement conditional original-object native/provider mode and owner changes with complete ACL coherence, transaction ordering and fresh permission revisions.
    • Implement descriptor and pathname mode/ownership consumers, restricted owner/group and special-bit policy, and original cleanup.
    • Implement real/effective-ID access queries with individual permission checks, complete prefix search and native ceilings; preserve umask/default-ACL behavior.
    • Complete authored wire/provider/service/VM controls, source authority and size review, documentation, and coherent signed/public reconciliation.
  • Implement mkstemp/temp-directory and atomic output replacement semantics within delegated tmp/output trees; no host /tmp or ambient search.

  • Implement required advisory locks with process/open-description lifetime, contention, cancellation and crash cleanup for Cargo/Git/build tools.

  • Implement poll/select readiness, timeout and cancellation using race-free event registration rather than periodic busy loops or fake timeouts. Readiness implementation · Review.

  • Provide only manifest-required local socket/socketpair semantics through bounded endpoints. Network sockets remain unavailable without later networking authority; device-node names alone grant no device access. Local stream socket design.

    • Complete exact manifested socket consumer requirements and interface ownership without claiming coverage from source strings.
    • Complete counted local-stream ABI, atomic socket/pair publication and defined unsupported-operation errors across required consumers.
    • Complete duplex byte/vector I/O, aliases, nonblocking/backpressure, required buffer options, half-close, peer closure and exact retirement.
    • Complete scoped bind/listen/connect/accept, original listener/backlog/connection lifetime and unlink/replacement semantics.
    • Complete original event-driven readiness, delegated deadlines, cancellation and signal interruption for all pending socket operations.
    • Implement independent deployment-counted original native Vfsd call custody, exact receiver/call generations and storage accounting before CLAIM.
    • Implement bounded fair native Vfsd progress and immediate intake behind blocked Wait, preserving one-shot exclusivity, legacy opportunity and original Close reply disposal.
    • Implement keyed original Posixd/Vfsd process-close prepare, Commit and grant-free receipt acknowledgment through caller uncertainty, with exact scope/candidate/key custody and no release of newer locks.
    • Implement counted original mediator intake and fair independent call progress on one native receiver, separate request/result and wake custody, original readiness mask observations, narrow deferred descriptor changes and full terminal drain without holding Close behind blocking Wait.
    • Implement original native process lifetime storage, sole capability-window policy and VSpace custody, validated initial execution associations and captured submission origin, preserving original owners through admission refusal/final cleanup and documenting independent controls.
    • Implement complete strict OIR2 framing and captured process/execution origin across shared codecs, native producer, process-only metadata, all current adapters/count geometry and Posixd initial execution admission; preserve status/custody, author independent native/refusal controls and maintain signed helper/catalog/manual adoption.
    • Implement authentic prepared native process members through actual held Process/stage authority and a noncopy budgeted Kernel factory, indexed shared CSpace/VSpace/window custody with one backing reference, member-only positive abort, retained dropped views, original group freeze/drain and refusal/reuse controls; maintain signed catalogs/manual while leaving runnable context/TLS/enrollment and full thread lifecycle open.
    • Complete authenticated native shared-process thread membership, shared process policy with distinct per-thread masks/TLS, and required consumer adoption; current single-TCB asynchronous calls do not satisfy this boundary.
    • Author complete independent positive/negative/failure/capacity controls and native same-process multi-client overlap/socket workload sources.
    • Complete libc socket/runtime and every manifest-required imported consumer without ambient pathname, network or device authority.
    • Complete final inline/component/manual contracts, missing-docs enforcement, code-size cleanup and removal of superseded assumptions for the whole socket feature.
    • Publish and reconcile the complete socket implementation and source/performance evidence through signed immutable graphs, owning reviews and phase tracking.
  • Test symlink/parent traversal, rename races, fd/PID reuse, shared offsets, directory lifetime, revoked handles and mutation outside scope.

  • Add multi-process build-style filesystem VMs for parallel files, atomic rename, locks, large trees, long paths and explicit resource exhaustion.

Memory, threads and blocking primitives

Weight: 6%. Owning issue · kernel PR 3.

Checklist
  • Inventory required allocation/mmap/protection/shared-memory/thread interfaces from selected tools and distinguish missing mechanisms from libc adapters over existing capabilities.

  • Implement authorized anonymous allocation and release for growing heaps/stacks, with checked alignment, zero initialization, quotas and OOM cleanup.

  • Implement required private/file-backed mmap, munmap, mprotect and synchronization behavior; preserve W^X, backing rights, dirty data and revocation.

    • Validate native frame access, W^X, current-grant protection
      restoration and retained backing.
    • Construct/populate/withdraw unpublished private hierarchies with owned
      tables and rollback.
    • Complete private-root routing, hardware readiness, activation and live
      retirement.
    • Implement POSIX private/file-backed mapping, unmapping and protection
      adapters.
    • Complete file synchronization, dirty-data and revocation behavior with
      real compatibility consumers.
  • Specify thread/process address-space ownership, thread start/exit/ join/detach, stack guards and cleanup with no unintended capability inheritance.
    Ownership specification: Kernel#44; kernel review, docs review, integration review. Native runtime implementation remains open.

  • Implement per-thread TLS allocation, access base and destructor lifetime, integrating ABI and loader contracts; isolate errno and thread data.

  • Implement mutex/condition/rwlock/once/TLS-key primitives required by libc/tools with correct atomic ordering, wakeup ownership and destruction.

  • Implement race-free check/register/block/wake and actual monotonic deadlines; test notify-before-wait, wake-after-cancel, spurious wakeups, lost wakeups, priority/fairness effects and generation reuse.

  • Define fork interactions with multiple threads, atfork handlers, runtime locks and child state; no inherited lock may require a vanished thread.

  • Specify unwind/exception support needed by imported C++/Rust tools separately from native abort-only components; do not enable unwinding across kernel, IPC or incompatible FFI boundaries.

  • Provide explicit clock and entropy access needed by runtimes. Distinguish reproducible timestamps/test randomness from security randomness; never satisfy a cryptographic entropy request with deterministic fixture data.

  • Add stress/failure VMs for mapping protection, concurrent allocation, threaded compilation, TLS isolation, wakeups, joins and teardown under OOM.

  • Profile allocation, faults, mapping transitions and synchronization; optimize only measured costs after safety and lifecycle tests pass.

Process, fork/exec/wait and signals

Weight: 6%. Owning issue · posixd PR 5.

Checklist
  • Specify fork's exact snapshot, return values, native generation, POSIX PID, shared open descriptions and allowed capability inheritance. A shell's descriptive subshell checkpoint is not a process fork.

  • Implement correctness-first private address-space copying unless a separately reviewed copy-on-write mechanism is justified; duplicate only selected memory/descriptor rights, never a service's private receive authority.

  • Implement atomic child publication and full unwind for allocation, mapping, transfer or startup failure; parent state remains usable and no half-started child or leaked authority remains.

  • Implement execve/exec-family replacement using exact executable identity, manifest, realm policy, argv/env, inherited descriptors and signal rules; success replaces the image, failure preserves the prior process.

  • Implement posix_spawn/file actions if required by imported tools; preserve the same inheritance/security semantics and test fork/exec equivalence where specified. Do not fake fork by always taking a spawn-only path.

  • Implement wait/waitpid and required wait options with exact child status, zombie retirement, multiple waiters, interruption and PID reuse safety.

  • Implement process groups/sessions and terminal foreground ownership entirely within delegated namespaces; numeric group IDs cannot grant control.

  • Implement sigaction, masks, pending delivery, default/ignore/caught dispositions, unblock ordering and supported signal sets with explicit state.
    Original initial-task actions/masks and cooperative self-signals are implemented.
    Original-supervisor/controller external generation and retained-I/O interruption
    are also implemented. Default SIGPIPE is also implemented. Full libc wrappers, other native default effects, multi-thread
    state and unblock ordering remain open; no complete-signal acceptance is claimed.

  • Implement safe user handler entry/return, alternate stack if required, validated restored context and async-signal-safe runtime paths; never unwind across unauthorized frames or trust caller-provided privileged CPU state.

  • Implement signal-driven EINTR/restart, SIGCHLD/wait ordering, SIGPIPE, stop/continue and terminal job-control behavior required by the profile.

  • Implement per-process CPU/resource queries and required limits with real counters; elapsed wall time and child CPU time remain distinct.

    • Implement real native task CPU accounting and generation-bound
      acknowledged final measurements.
    • Validate ordinary service CPU observations and exec-successor
      accounting in actual VMs.
    • Complete consumer restart/loss custody and all required compatibility
      resource-query adapters.
    • Implement workload-required resource limits and child accounting
      without substituting wall time.
  • Add fork/exec/wait VM matrices covering descriptor aliasing, close-on-exec, environment, cwd, TLS, signals, multi-thread fork, failures, concurrent children and termination while authority demand is pending.

  • Add cross-realm signal/control denial, stale-PID replay, descendant cleanup and repeated fork/exec exhaustion/recovery VMs; verify no residual caps.

C runtime and libc

Weight: 5%. Owning issue · Standard memory/string family · Required POSIX comparisons · Producer bindings · Manual/API.

Checklist
  • Define static/shared libc artifacts, C headers, symbol/export versioning, startup objects, calling conventions and supported C language ABI.

    • Define the implemented x86_64 C/Rust declarations, partial headers and
      explicit companion symbol policies.
    • Complete static/shared libc, startup objects, full headers and
      symbol/version contracts.
  • Implement C entry/exit, argc/argv/env/auxiliary data, atexit and initialized runtime state from validated launch input; no ambient discovery.

    • Implement authenticated C startup planning and counted mutable arguments and exported environment on the shared process heap.
    • Implement getenv/environ, ordered concurrent exit handlers and normal/immediate exit through a retained genuine process-group terminal owner.
    • Implement the original-source producer, ordinary command and image policy, native C fixtures, VM oracle source and component/manual contracts (C startup).
    • Complete warning-free supported-target formatting, strict Clippy, unit/header checks and actual native C startup workload acceptance.
    • Complete workload-required auxiliary data, initialized runtime state and C entry/exit adoption across compatibility and imported-tool consumers.
  • Implement memory/string/byte functions with overlap/alignment/ zero-length/overflow tests and documented FFI pointer contracts.

    • Implement and independently validate memcpy, memmove, memset and
      memcmp.
    • Implement and validate strlen, strcmp, strncmp, memchr, strchr and
      strrchr.
    • Implement and validate strcpy, strncpy, strcat and strncat.
    • Implement and validate strspn, strcspn, strpbrk and strnlen.
    • Implement and validate strstr, including its pointer, byte,
      ABI/guard/link, complete source-cohort and manual/API contracts.
    • Complete the remaining required memory/string interfaces from the
      final workload inventory.
    • Adopt the complete implementation in actual compatibility consumers
      and finish workload validation.
    • Implement and document stpcpy/stpncpy in the original
      companion, with authored return, range, ABI and failure controls.
    • Implement and document mempcpy representation copying and
      end-pointer results, with authored binary/range/C-Rust controls.
    • Support C/C++ partial memory/string headers on the same
      original C ABI, with authored linkage, hygiene and mixed-caller controls.
    • Implement and document heap-owned strdup/strndup, with authored allocation-failure, pointer and byte controls and native C fixture wiring (owned string copies).
    • Implement and document caller-owned strtok_r, with authored byte, pointer, ABI and guard controls and native C fixture wiring (tokenization).
  • Implement malloc/calloc/realloc/free/aligned allocation using Memory, threads and blocking primitives, covering ownership, failure atomicity, zeroing and threaded use.

    • Implement and document the checked allocation family over one process heap shared by C and Rust, with thread-local errors and failure atomicity.
    • Implement original-source production, separate packaged heap capacity and a genuine C/Rust/member workload while preserving older realm oracles.
    • Complete warning-free workspace formatting, strict Clippy, unit, rustdoc and C/C++ header checks across the supported targets.
    • Demonstrate allocation, thread-local errors, exhaustion recovery and retirement in the actual native guest workload.
    • Complete allocation adoption and backing lifetime across the required C runtime, compatibility consumers and imported workloads.
  • Implement errno and error strings per thread with stable native error mapping; unrelated calls/threads must not overwrite each other's state.

    • Implement the selected fixed C-locale catalog and whole caller-buffer
      copies; complete original ABI/guard/link checks and coherent source,
      Integration and manual/API adoption.
    • Complete native terminal-to-thread errno adapters, required assignments
      and workload mappings, preserving interruption and partial I/O.
    • Complete current/explicit locale error interfaces and mediated diagnostic
      streams with their lifetime and return contracts.
    • Demonstrate independent thread errors and complete native consumer/workload
      behavior through required VM and warning-free CI gates.
  • Implement buffered stdio, formatting/scanning and conversion surfaces required by tools; cover partial I/O, flush-on-exit, stream locking, binary data, locale, numeric bounds and varargs ABI.

    • Complete fixed C-locale LP64 integer conversions and full source, companion, C/Rust consumer, manual/API and independent control adoption.
    • Complete remaining numeric/locale conversion interfaces required by tools.
    • Complete buffered stdio, partial I/O, binary data, stream locking and flush-on-exit.
    • Complete required formatting interfaces and varargs ABI coverage.
    • Complete required scanning interfaces, locale and numeric-bound cases.
  • Implement libc file/directory/poll/terminal adapters over posixd; no direct provider routes or host-OS syscall fallback may bypass mediation. Mediated C byte I/O.

    • Implement and publish namespaced C/Rust read, write and close
      interfaces with an explicitly bound original Posixd realm, independent
      concurrent call storage, uninitialized read buffers, bounded write prefixes,
      current-thread errno and retirement before buffer release. Adopt the source
      companions, C fixtures, headers and manual in the native process-root graph.

    • Complete required file opening, duplication, status, positioning,
      metadata and filesystem control adapters through the mediated descriptor ABI.
      Retain relative directory bases through pending operations. Bind cwd reports to
      their full native recipient and retire report observers and idle reports without
      losing original request/reply evidence or the first failure. Measure native stack
      use and regenerate matching API references. Admit the C workload through an
      explicit private filesystem root, with writer-only authority and peer denial.
      Tracking: rooted scopes, cwd,
      C file adapters.

      • Publish namespaced C/Rust file and pipe frontends,
        headers, exports and current-thread errno contracts.
      • Publish the original-realm backend and mediator source
        for independent directory-base holds, timestamp updates and process-owned
        cwd reports, including call/report retirement and cleanup controls.
      • Publish the prepared filesystem C workload and existing
        VM scenario enrollment, with distinct held directory bases, multi-chunk
        cwd, cleanup controls and manual companions.
      • Complete the conventional tool-facing file/pipe entry
        points and compatibility-startup integration required by selected tools.
      • Measure native stack use during report initialization
        and reoccupation; remove unnecessary temporary copies and demonstrate
        headroom within the admitted process stack.
      • Complete source-bound native/unit/VM acceptance for file,
        pipe, timestamp, directory-base and cwd operations; regenerate any
        remaining affected API references from actual matching Rustdoc output.
    • Complete directory stream and entry adapters with defined
      ownership, cursor, error and teardown behavior.
      Tracking: mediated directory adapters.

    • Complete poll/select readiness adapters, interruption and
      timeout behavior through the reviewed service mechanisms.
      Tracking: C poll and select adapters.
      The namespaced erix_c_poll and erix_c_select interfaces are implemented;
      conventional aliases and C signal-handler delivery remain pending.

    • Complete terminal adapters and required controls without
      exposing direct provider authority.
      Tracking: Restricted terminal controls; C terminal adapters.

      • Publish typed native control rights and stream-bound views,
        retaining authenticated original issuer inputs, per-view operations and
        positive provider disposal independently of byte transport.

      • Provision the dedicated route only from authenticated
        wanted boot policy, with exact endpoint rights and independent counted
        storage. Preserve default session grants and original creator retirement.

      • Bind mediator control views to original byte descriptions
        and alias groups; retire each control caller and provider view before the
        last byte owner, including cancellation and uncertain cleanup.

      • Complete the required mediated C/Rust terminal adapters,
        terminal identification, window controls and termios behavior.

        • Publish namespaced C/Rust terminal identification and window adapters,
          the checked compatibility/native bridge and the explicit original-source
          C workload. Preserve view rights and alias cleanup.

        • Complete full termios, control characters, speeds, flow, drain/flush,
          break, foreground groups and required line-discipline behavior through
          matching native mechanisms and reviewed adapters.
          Termios parameters and attributes tracks the C
          parameter dependency and mediated attribute operations.

          • Publish the caller-owned parameter layout,
            constants and four pure C/Rust speed accessors with original companions,
            field-preservation and ABI controls, build enrollment and maintained
            documentation. Storage success does not attest native support.

          • Implement retained native attributes and required
            input/output processing, configurable characters and canonical line/EOF
            records, preserving buffered data and atomic state transitions.

          • Complete mediated C/Rust attribute observation
            and replacement with exact wire validation, explicit operation rights
            and original descriptor/caller lifetime through failure and cleanup.

          • Implement required native drain/flush, flow,
            break, speed application and noncanonical minimum/time read behavior
            with truthful queue/device effects and retained interruption cleanup.

          • Complete authenticated foreground groups and
            terminal signal/line-discipline behavior without deriving process
            authority from numeric selectors or broadening existing mode views.

      • Demonstrate the native C/Rust terminal workloads, required
        authority-negative, alias, failure and cleanup cases, and matching runtime
        API documentation from actual builds.

    • Supply conventional POSIX aliases after libc signal delivery
      and compatibility startup, then demonstrate the complete adapter set with
      native C workloads, failure and concurrent-retirement coverage.

  • Implement process/signal/thread adapters over reviewed native mechanisms; libc process-global state must have defined fork/exec behavior.

  • Implement time/sleep, locale/ctype/multibyte, environment, sorting, search and required math/runtime helpers with deterministic documented behavior.

    • Supply the fourteen fixed C-locale ASCII character calls with
      scalar ABI, companion products and documented contracts
      (runtime,
      manual).

    • Complete required conventional ctype and current-locale interfaces.

    • Implement required multibyte conversion and its encoding state.
      Tracking: Caller-owned multibyte conversion.

      • Implement the declared 22 conversion/state calls through one caller-owned ASCII/UTF-8 core, including restartable and UTF-16 state.
      • Publish the scalar errors, C header, root runtime, independent conversion/header controls and inline contracts coherently.
      • Link the original Cstd C probe into both heap workloads, preserving source ownership, export guards and thread/heap observations; publish matching component catalogs and technical-manual contracts.
      • Map required upstream multibyte interfaces and complete their conventional aliases and current-locale/state contracts.
      • Execute the integrated C workload through the actual native and VM paths, publish the new runtime API reference and complete end-to-end failure, concurrency and cleanup acceptance.
    • Implement time and sleep through reviewed native mechanisms.
      Tracking: Clock observations and owned sleep.

      • Implement checked time values and durations over the full
        signed seconds range, including canonical fractions and native conversion.

      • Publish calibrated native source resolution and owned UTC
        waits, preserving the original target through clock changes and positively
        retiring the timer before completion or replacement.

      • Implement the declared C observation and sleep calls,
        mediated compatibility bridge, root runtime and original C workload probe.

      • Complete the required calendar, current-zone, CPU-accounting
        and conventional interfaces and map required upstream tool usage.

      • Complete actual native/VM execution, runtime API references
        and end-to-end failure, concurrency and cleanup acceptance.

    • Implement process-owned environment access and mutation on the shared heap, including copied and borrowed values, alias retention, atomic failure and exit-handler access (environment APIs).

    • Complete sorting and search interfaces with explicit callback contracts.

    • Complete required math and runtime helpers with documented behavior.

  • Implement only required additional C/POSIX interfaces identified in Scope, repository and build inventory; track every unsupported extension with explicit behavior and tool configuration/port justification, not success-returning stubs.

  • Build independent C conformance probes for layout, linking, constructors, TLS, allocation, stdio, files, threads, signals and process lifecycle.

    • Run independent C/Rust layout, call/link, guarded-memory and negative
      companion-link probes.
    • Add constructors/TLS/allocation/stdio/file conformance probes.
    • Add thread/signal/process lifecycle and real compatibility execution
      probes.
  • Validate FFI safety and C/Rust interoperability under errors, malformed inputs and stress; publish rustdoc/header/manual contracts and pass full strict CI for lib-cstd and changed consumers.

    • Validate and document the implemented byte/string FFI with independent
      C/Rust controls and strict component CI.
    • Complete FFI/error/stress coverage and contracts for the remaining
      libc.
    • Validate all changed runtime consumers and the complete imported
      workload closure.

Compatibility ELF and runtime linking

Weight: 4%. Owning issue · dynlinkd PR 3.

Checklist
  • Inventory emitted ELF/interpreter/dynamic tags, relocations, symbol versions, TLS models, constructor/finalizer and exception metadata from exact selected compiler/runtime packages.

  • Define/version a compatibility artifact contract distinct from native abort-only/no-TLS/no-init-fini policy; preserve rejection of unsupported native artifacts instead of simply deleting existing guards.

  • Implement required relocations and dynamic symbol rules with exact bounds, dependency closure, cycle/duplicate behavior and no ambient library search.

  • Implement static/dynamic TLS layout and per-thread/module lifecycle with checked template/BSS alignment, unload rules and Memory, threads and blocking primitives synchronization.

    • Complete original ELF PT_TLS extraction with immutable prefix provenance, full checked file/memory geometry, duplicate/malformed/overflow/alignment refusal and complete caller-block prefix/zero initialization.
    • Complete caller-counted VariantII layout and immutable template/module retention, sparse IDs, exact alignment residue, 24-byte self/DTV/errno TCB, counted DTV and full image/refusal/spare-byte contracts without private count/size ceilings.
    • Complete original graph/module/symbol scopes and every TLS relocation/null-provider form required by exact imported artifacts; current pure exact-width runtime planning is a foundation.
    • Complete allocation-free prepared initial TLS native transport with complete original input integrity, exact positive reply correlation and refusal/uncertainty custody. LibIPC review.
    • Delegate exact caller-counted Procd packet storage through authenticated target deployment geometry and the image configuration path, with capacity refusal before CREATE and no hidden image ceiling. packet storage review.
    • Retain immutable loader-only TLS binding and sequential input, initialize through the actual original Process/stage before ordinary or staged commit, and positively clean up before erasure/reuse. Procd review.
    • Complete immutable exact-width linker/materialization patch framing, full raw-record preflight, original producer/consumer spans and plan order, and native failure cleanup custody without scalar truncation. LibIPC fix, patch contract.
    • Complete caller-counted immutable ERR1 source registry framing, original prefix/object correlation, duplicate/extent/refusal/spare contracts and the documented production TCB registry extension with fresh-image initialization. Full TLS, registry contract.
    • Complete actual authenticated Loaderd initial ELF/template/image production with dedicated explicit stack/guard/TLS/read-only registry geometry, complete original native input and target-derived caller/deployment budgets before CREATE. Full TLS, registry contract. storage producer review.
    • Complete original initialized-template fixups in separately resolved immutable registry and prospective initial image before publication, correlate two full original plan/count reads before child commit and retain exact failure cleanup custody. Full TLS, registry contract.
    • Complete Dynlinkd original registry/object-digest/image correlation, actual TLS-aware caller-arena planning and exact-width committed output, deriving required descriptor exports only from original executable graph code. Full TLS, registry contract.
    • Complete original per-thread errno/TLS-index/eager-descriptor primitives, explicit unsafe Rust/C contracts, exclusive caller byte-image preflight and original assembly with no global fallback or native authority from metadata. Complete libc, runtime contract.
    • Complete one bounded original memory/thread companion producer with distinct explicit roles, artifacts, ABI/receipt identities and pinned Integration source selection; remove superseded paths and forbid bootstrap memory substitution. Complete libc, runtime contract.
    • Complete authored bounded original thread object/alias/archive/text, guarded image, exact owned-signal/cleanup and missing/memory-only/duplicate-link controls with explicit tool/source ownership and retained older oracles. Complete libc, controls and packaging.
    • Complete explicit partial native compatibility object/archive packaging of original memory/string/thread bodies once, exact component/thread ABI and pinned source/receipt provenance, with no bootstrap or standalone-component substitution. Complete libc, controls and packaging.
    • Complete original native ingress-to-CLAIM/member/context/machine FP environment custody and environment-only fresh initialization with exact restore-format semantics, replay/Start and positive private erasure. Full native threads, original creator environment.
    • Author independent original FP init/format/fresh-byte/allocation/replay/asynchronous-creator/actor-refusal controls and actual CPL3 first-entry inherited-control/fresh-register oracles while preserving all older native requirements. Full native threads, original creator environment.
    • Complete actual-current native thread self-exit, explicit execution/process terminality, original result and departed-anchor/peer/shared-authority survival, serialized finalizer/Start arbitration and positive private member/accounting cleanup before ID reuse. Full native threads, native thread self-exit.
    • Author exact native self-exit codec/bridge and genuine original object/charge/refusal/replay/reuse controls plus a separate routed CPL3 self-exit/peer-survival scenario, preserving older VM scenarios, marker sets and finite budgets. Full native threads, native thread self-exit.
    • Complete actual native shared-object compatibility consumption with hidden policy, complete thread ABI/source/tool/owner/receipt provenance through artifacts and exact version-four registries/cache/prebuilt/direct consumers, retaining separate memory-only Kernel bootstrap and unchanged artifact TLS refusal. Complete libc, native C runtime consumers.
    • Remove superseded generic runtime adapters/flags/paths without forwarding aliases and author independent actual-consumer component/policy/target/schema/role/ABI/cache refusal controls, routing new coverage while preserving all older native scenarios, oracles and budgets. Complete libc, native C runtime consumers.
    • Complete held-member native READ exit-result observation through exact original binding/serial/noncopy execution/process/factory association, full-width pending/departed-zero framing, status/correlation bridge and retained cleanup/finalization custody without lookup, mutation or nested lifecycle acquisition. Full native threads, held-member exit results.
    • Author independent literal/bridge and genuine native rights/serial/kind/movement/charge/refusal/replay/retirement controls plus synchronized actual CPL3 pending/departed result queries and positive rendezvous-grant disposal, preserving all older scenarios, marker sets and finite budgets. Full native threads, held-member exit results.
    • Complete authenticated staged-client native factory production through original supervisor/client/realm/mediator/GRANT and actual Process scope, explicit same-realm thread budgets, exact current READ/minimal roles, unique original stage/factory result transfer, independent source absence and obsolete local-selector erasure without default thread authority. Full native threads, staged client factory producer.
    • Author independent complete factory request/response and canonical role/mask controls, scripted producer admission/scope/uncertainty/transfer/cleanup/erasure/budget controls and genuine Kernel paired stage/factory unique-result tests, preserving older native scenarios, oracles, target-derived geometry and finite budgets. Full native threads, staged client factory producer.
    • Complete explicit frozen per-client factory capacity and same-realm thread-budget admission, full canonical/public framing and version-seven three-column startup/image consumers, original paired caller/source-absence/retirement/native READ custody, zero-policy column discharge and unsupported mediator admission refusal without default authority. Full native threads, counted caller custody.
    • Author independent complete literal/budget/old-width, paired source/caller/result/cancel/retirement, one/multiple-client provisioning/refusal/quarantine and default seal-to-Start controls; correct stale counted witnesses, preserve older oracles/budgets and maintain coherent inline/component/manual/signed source and review evidence. Full native threads, counted caller custody.
    • Wire actual initial and additional Loaderd/Dynlinkd/Procd/Kernel thread TLS images and access bases to original file/process/stage/member/mapping authority before genuine execution.
    • Complete libc per-thread errno, TLS and descriptor resolvers, TLS keys and destructor ordering for every native/imported consumer.
    • Complete synchronized module admission/mutation/unload, original thread/image lifetime and positive retirement with native thread ownership lifecycle, exit/join/detach and failure custody.
    • Author complete independent runtime/module-race/cleanup/refusal controls and real native multi-thread TLS VM sources retaining every original integration oracle.
      Require a real nonswitching hardware interrupt to return to the original CPL3
      task after completing its CPU entry lease; retain separate hosted refusal and
      modeled lease controls.
    • Complete whole-feature inline/component/manual contracts, missing-docs and code-size cleanup, remove obsolete unsupported assumptions after migration and publish coherent signed graphs/reviews/master evidence.
    • Implement CPU-owned caller, entry and execution state with real AP state admission, a genuine CPL3 source fixture, Integration routing and inline/component/manual contracts.

    Complete TLS design, LibElf review, LibDynlink review.

  • Implement ordered constructors/finalizers and runtime teardown with failure handling; no initializer executes before validation and final mappings.

  • Implement declared runtime library loading needed by Python modules and compiler plugins/proc macros; restrict dlopen-like search to granted library roots and retire mappings/aliases only after their users are gone.

  • Implement required unwind registration/lookup in compatibility userspace only; validate metadata and keep native/kernel abort policy intact.

  • Enforce W^X, relocation/RELRO permissions, manifest identity and dependency closure for imported objects; reject text relocation/lazy binding/ IFUNC modes unless separately required, designed, tested and approved.

  • Test malformed ELF, dependency substitution, TLS races, constructor failure, symbol ambiguity, plugin teardown and out-of-realm library lookup.

  • Run actual compatibility ELF/TLS/C++ exception/Rust runtime VMs and native-loader regression scenarios with strict warning-free component CI.

Shell, utilities, help and manual pages

Weight: 5%. Owning issue · exsh PR 3.

Checklist
  • Compare exsh's maintained POSIX conformance register and actual build scripts against the selected POSIX shell standard; enumerate remaining syntax, expansion, built-in, signal, group and stopped-job gaps with tests.

  • Complete standard POSIX shell behavior needed for ordinary scripts and all remaining mandatory profile items; preserve native descriptor/job authority and distinguish true fork from in-process descriptive state copying.

  • Implement compatibility-program launch from exsh without executable-name/argv-specific authority semantics; tools request/fail operations on their own, within the launch envelope.

  • Complete pipeline/redirection/substitution/here-document/background/ wait/trap/job-control interactions against real POSIX processes and groups.

  • Test configure/build scripts with spaces, long argv/env, nested substitutions, many descriptors, interruption and concurrent output; remove incidental shell storage limits through caller/resource-owned growth.

    • Move shell transport/cleanup scratch into caller-owned workspace and
      validate its mapping bounds.
    • Finish source/effect/frame proof and remove remaining incidental
      storage limits.
    • Run actual configure/build script stress for long inputs, descriptors,
      interruption and concurrent output.
  • Inventory native utility command/option gaps against build recipes; implement required clean-room behavior in thematic modules and record where an explicitly inventoried extended GNU tool is required instead.

    • Finish the exact selected build-recipe command/option
      inventory and distinguish native versus imported tool requirements.
    • Implement and document native cmp streams, modes and statuses,
      with authored ownership, failure and guest controls.
    • Implement and document binary string/byte printf, including
      first-byte conversion, with authored native and guest controls.
    • Implement and document integer printf with checked fields,
      dual-channel diagnostics and authored native/guest failure controls.
    • Complete the other recipe-required native commands/options
      and explicitly document required imported-tool selections.
    • Publish the coherent utility/consumer graph and complete
      actual build-workload, guest and warning-free regression acceptance.
    • Implement and document native head/tail line/byte counts
      and start positions, with authored ownership, failure and guest controls.
  • Preserve history/editor/cursor/erase, independent and mirrored TTYs, serial/fbcon trusted consent, output drain and repeated-command behavior under build load; add focused and existing regression VM coverage.

  • Run shell/utility conformance fixtures plus a miniature parallel build workflow, checking exact output/status and zero authority leakage.

  • Specify an internal exsh help command with Bash-like behavior: no-argument topic listing, pattern/topic selection, short description (-d), manual-style output (-m), synopsis (-s), option errors and match/no-match exit statuses. Verify combinations against the selected Bash reference.

  • Implement help from exsh's authoritative built-in/topic registry, documenting actual exsh behavior rather than advertising unimplemented Bash extensions; it must not spawn an external executable or acquire filesystem authority for built-in help. Author original explanatory text.

  • Add unit and serial/PS2 harness tests for help listing, topic/pattern selection, flags, invalid requests, redirection, pipelines and exit statuses.

  • Specify coreutils man: section/name lookup, disambiguation, multiple pages, search/index behavior, terminal versus redirected output, missing-page errors and scoped manual-directory discovery.

  • Implement man as a native coreutils applet with readable paging, scrolling/search/quit and plain-text fallback for pipes; safely parse the chosen documented man format and never execute page macros, escapes or embedded commands.

  • Define stable manual sections/names for all CLI commands/built-ins, IPC interfaces and Rust/C linkage APIs; inventory every exported interface and require an indexed page or a clearly linked owning API page.

  • Write/package CLI manual pages covering syntax, options, examples, statuses, authority needs and errors for every tool, including help, man, boot-tool, sha2-tool, exsh and extop; include admitted extended-tool manuals only under their declared source/license/manifest policy.

    • Publish the complete Coreutils command corpus and catalog-bound manifest.
    • Complete Exsh and every builtin/language-topic page, with useful examples and registry/source freshness.
    • Publish boot-tool, sha2-tool and extop pages and reconcile ordinary command catalogs.
    • Complete manuals for maintained build and developer command interfaces.
    • Package admitted imported-tool manuals under their declared provenance policy.
  • Write/generate IPC and Rust/C API manual pages with ABI/version, request/reply layout or signatures, safety/ownership/lifetime/authority, errors, examples and cross-references to canonical rustdoc/header/manual text.

  • Install man pages/indexes on ext4 as build outputs with explicit read-only lookup authority; environment paths cannot broaden the manual scope or cause execution. Make docs available without network access on both images.

    • Implement the strict versioned store and exact read-only lookup authority.
    • Install readonly bytes with checked common dev/release copying and ext4 readback.
    • Resolve the complete CLI/API inventory offline in an actual development guest.
    • Resolve the complete CLI/API inventory offline in an actual release guest.
  • Add coverage/freshness and malformed-page tests plus serial/PS2 man navigation, resize, pipe/redirection, missing-page and denied-root VMs. Verify every CLI/interface inventory entry resolves to useful current content.

Extended payloads and image isolation

Weight: 4%. Owning issue · integration PR 12.

Checklist
  • Implement a versioned third-party payload manifest containing name, version, source digest, license/notices, target, recipe/patch digests, features, runtime dependency closure, dynamic dependencies and realm authority policy.

  • Define offline source ingestion and reproducible recipe storage; keep imported sources/patches separate from EriX-authored ISC implementation and never add imported libraries to trusted EriX Cargo dependencies.

  • Add explicit runtime.extended-dev.toml and runtime.extended-release.toml, labeled non-clean-room in metadata/output. Preserve existing clean runtime.dev.toml and runtime.release.toml semantics.

  • Enforce clean-profile exclusion across configuration inheritance, local overrides, aliases, caches, transitive libraries and packaged contents; test intentional imported-payload contamination fails closed.

  • Enforce a reviewed extended-release subset; exclude development-only generators/test harnesses/debuggers and unneeded dependency libraries.

  • Verify every admitted target ELF and declared DT_NEEDED closure, source/license/recipe record and authority envelope; reject unknown payloads, mismatched targets, dependency-only orphans and mutable unpinned sources.

  • Reconcile the phase inventory with newly discovered packaging and documentation dependencies before admission; update normative inventory, manifest schema/records and tests rather than silently expanding imports.

    • Identify packaging, filesystem, Markdown and TeX dependencies missing
      from the initial import list.
    • Resolve imported versus owned implementations and update normative
      inventories/schemas.
    • Verify and admit the complete dependency closure into the four image
      profiles.
  • Package admitted tools on ext4 with bounded executable/library manifests; the build realm gets no raw block/device/key/global discovery or network capability from extended-image selection.

  • Test all four profile builds, labels, artifact inventories and clean-room exclusion independently; extended-tool success never certifies clean-room implementation provenance.

EriX-hosted imported toolchain

Weight: 5%. Owning issue · integration PR 12.

Checklist
  • Pin exact upstream sources, compiler versions, recipe options and licenses for every selected tool/runtime; create a dependency-ordered offline bootstrap graph distinguishing build-machine, EriX-host and output targets.

  • Implement/review EriX target support and sysroot integration for Rust/LLVM/C tooling, including actual std OS bindings over lib-cstd, TLS, threads, process, files and time. A target JSON alone is not host support.

  • Build target core, alloc, std, proc_macro, compiler runtime and test libraries; separate imported runtime payloads from trusted native component dependencies and record each runtime link closure.

  • Cross-build EriX-hosted rustc, cargo, rustdoc, rustfmt, clippy-driver, LLVM code-generation libraries and Rust linker support from selected upstream sources against EriX libc/sysroot and Rust OS bindings; execute each within an EriX realm. Retain exact static/dynamic link closure evidence; copying or merely relabeling Linux binaries is not a compiler port.

  • Build from source and verify EriX-hosted LLVM tools against the EriX sysroot: clang, clang++, lld, llvm-ar, llvm-ranlib, llvm-nm, llvm-objcopy, llvm-strip, llvm-readobj, llvm-readelf, llvm-size, and llvm-config when the recipe requires it.

  • Build only declared compiler-rt, libunwind, C++ runtime and compression/runtime dependencies; test C/C++ allocation, TLS, threads and exceptions as required by those exact compiler binaries.

  • Port/verify Python 3 and required standard modules, including the selected compression, FFI and optional database extensions used by EriX scripts.

  • Port/verify CMake, Ninja, GNU make, pkgconf/pkg-config and declared bash use; test generated build rules, subprocess pipes and parallel job limits.

  • Port/verify offline Git operations: init/status/diff/log/checkout, exact local revision resolution and offline Cargo Git dependency use; disable fetch/network paths and preserve exact commit identity in manifests and caches.

  • Port/verify archive/compression tools: tar, gzip, xz, zstd and bzip2, with reproducible round trips, permissions, symlinks and path-escape rejection.

  • Port/verify required patch/diff/cmp/find/grep/sed/awk/sort/install and file/object-probe behavior not supplied by native tools; record exact options.

  • Port/verify extended-dev Autotools support: m4, autoconf, automake, libtool, bison, flex and Perl with a representative configure/build fixture.

  • Admit dependency-only zlib/bzip2/liblzma/zstd/libarchive/libuv/libffi/ sqlite/pcre2/expat/gettext/iconv/terminfo/readline components only when selected tools require them; disable optional TLS/download/network features for Phase 6.

  • Resolve required image/filesystem, Markdown and TeX tool dependencies through Extended payloads and image isolation or clean-room equivalents. No unlisted helper may run on the external host during the final build to fill a missing guest tool.

  • Require every tool's smoke command, deterministic exit and minimal startup capability test before admission; version output alone is insufficient.

  • Run functional fixtures: Rust program/crate, offline Cargo workspace, build script and proc macro, C/C++ compile/link, Python bootstrap scripts, CMake/Ninja/make, local Git and archive/text round trips.

  • Run each tool class under missing/revoked grants, uid 0 metadata, out-of-tree paths, device names and unavailable network; verify denial and teardown without a compiler/tool-specific launch exception.

  • Profile real compiler/workspace builds and fix evidenced substrate bottlenecks through Integration profiler and measured optimization, preserving per-job resource ceilings and exact errors.

  • Rebuild the selected upstream Rust/LLVM toolchain and required runtime closure inside an extended development EriX realm using the supplied offline sources, recipes, dependencies and cross-built EriX-hosted bootstrap compiler/sysroot. Require the delivered build to work without unrecorded porting changes, implicit downloads, Linux executables or host build delegation. Verify EriX libc/ABI linkage, execute the guest-built tools and compile/link/run Rust and C/C++ fixtures, including build scripts and proc macros. Use the rebuilt compiler for at least one required full EriX build. Retain exact source/patch/bootstrap/tool/runtime hashes, complete logs, actual outcomes and measured memory/time requirements under explicit build quotas. Cross-compilation and version output alone do not satisfy this acceptance.

Native tools and full build/packaging pipeline

Weight: 5%. Owning issue · integration PR 12.

Checklist
  • Provide a signed/hash-verified source bundle of all exact component revisions, locks, recipes, configs and local dependency metadata with no EriX precompiled output. Reject missing or unexpected sources before building.

  • Implement the build realm: immutable source/toolchain inputs, separate write-only-as-needed build/output/tmp trees, explicit execution and child lifecycle authority, fixed locale/time policy and bounded resources.

  • Resolve source-write assumptions by declaring writable generated worktrees separately from immutable originals; never silently grant compiler writes to the source authority root.

  • Adapt component orchestration and Cargo override/lock resolution for fully offline EriX execution; record every invoked guest tool, target, input/output digest and job dependency. Remove host /proc//sys assumptions.

  • Build EriX-hosted boot-tool, sha2-tool and every other maintained build helper inside EriX before using them to produce final artifacts; the first two use native EriX APIs through Native tools and full build/packaging pipeline, not a POSIX-only port.

  • Build the complete target/profile graph from Scope, repository and build inventory, including all services/libraries, kernel, EFI bootloader and Integration test artifacts; fail if a catalog entry is silently skipped due to missing build configuration.

    • Implement the initial executable offline component plan with original source, workspace and feature binding, covering native libraries, objects, EFI, host tools and source-only inputs. Implementation PR.
    • Complete maintained clean and extended dev/release runtime/profile inputs, preserving original configuration ownership and actual Cargo query selection. Profile matrix · Extended inputs. Full variant artifacts, image builds and guest runs remain separate gates.
    • Produce and verify the complete native artifact graph without skipped components or incompatible source/ABI closures.
    • Execute the complete target/profile graph inside EriX with the admitted guest toolchain and actual dependency/output evidence.
  • Generate complete dynamic/launch/boot manifests and signed boot.img inside EriX, with deterministic source epoch, ordering, padding, feature identity and no preassembled host artifact substitution.

  • Resolve current dd, debugfs, mkfs.fat, mkfs.ext4, mcopy, mmd, sgdisk, truncate/hash/compression and Python packaging dependencies. Prefer a reviewed image-file-only path using owned code where appropriate; any imported alternative needs Extended payloads and image isolation admission and actual guest functional tests.

  • Assemble GPT, FAT ESP and ext4 partitions into ordinary output image files inside EriX, without granting the build realm raw block, mount administration or access to the currently running disk device.

  • Build clean dev/release and explicitly selected extended profiles with equivalent validated boot/runtime closures; verify clean images exclude imported compiler payloads even though an imported compiler produced them.

  • Define least-authority artifact signing: a build requests signing of an exact reviewed artifact identity under a dedicated test/development key policy; no private key bytes, broad key service or release key enter the realm.

  • Produce checksums, compression, manifests, generated API references and complete technical manual within EriX using the declared tool closure. Run warning-free guest fmt/Clippy/unit/documentation checks on built sources.

  • Implement restartable build steps with verified input/output cache identities, bounded parallelism, meaningful progress and deterministic cleanup; final clean-build evidence must disable reuse of prior EriX outputs.

  • Test failed compiler, OOM/ENOSPC, interrupted build, malformed cache, signer denial and partial image creation; retain diagnostics and remove only owned temporary artifacts without corrupting source or running media.

  • Verify image-file parsing, signatures, partition/filesystem metadata, payload closures and reproducibility inside EriX before exporting results for independent host inspection/boot orchestration.

  • Separate boot-tool and sha2-tool command/format/hash logic from platform I/O; specify native EriX and Linux backends sharing exact CLI, errors, output and artifact formats without routing the EriX backend through libc.

  • Port sha2-tool to native startup/CLI/stdio/file capability APIs; stream large inputs, preserve stdin/file modes, bound temporary storage and retire all input/output grants on success, denial and interruption.

    • Publish and document the portable owned-region primitive, with no implicit allocation or endpoint authority and its unit/lint/CI checks complete.
    • Validate Kernel adoption with authenticated allocator backing, all required native profiles and allocator VM controls.
    • Publish correlated recipient-view disposal and actual provider interoperability in LibStdio and Launchd, with current documentation and CI.
    • Implement exact owned stream transport with recoverable original invocation custody, once-only receipt accounting and full-width errors; abandoning a wrapper must not lose its owners.
    • Authenticate native startup and every raw CLI operand occurrence against the exact granted inventory; exclude unwanted session, service and host authority.
    • Implement native streaming hashes for stdin and explicit files, bounded temporary storage, partial output progress and explicit EOF.
    • Retire or transfer original invocations, recipient views, grants, mappings and backing in the required order on success, denial and interruption.
    • Build and document the native SHA tool, with format, strict lint, unit/build checks and current CI free of warnings.
    • Pass new native VM cases for empty/large/malformed inputs, host/native parity, wrong or missing grants, lender survival and complete teardown.
  • Port boot-tool image operations to native EriX file/stream APIs; preserve build/inspect/verify/signing-payload semantics and the detached signer boundary. Neither platform backend may gain implicit private-key access.

    • Implement startup-bound single-parse preparation and original file occurrences/output descriptions without acquiring file or publisher grants.
    • Implement native entry, allocator, whole-file reads and stdio through shared EriX clients while keeping Linux behavior usable.
    • Implement exact prepared broker attenuation and atomic-output publication across the native client, Launchd, Vfsd and filesystem providers.
    • Preserve first errors, partial effects and original owner custody through success, denial, abort, interruption and complete final retirement.
    • Complete native component checks, meaningful backend/parity coverage and documentation for the full implemented command scope.
  • Keep Linux targets usable with the existing CLI and build recipes; test shared logic plus both backends and byte-identical image/hash output from the same fixture inputs, including empty, large and malformed files.

  • Package both native executables/metadata/man pages on ext4, add scoped launch contracts and new serial/PS2 in-OS CLI tests for both tools; test wrong/missing grants and partial-output cleanup without program-specific launch authorization.

    • Implement native SHA-2 build, workspace, command/launch metadata and ext4 installation producers without program-specific authority grants.
    • Implement the corresponding native Boot-tool packaging path.
    • Author complete serial/PS2 positive, wrong/missing-grant and partial-output cleanup scenarios for both native tools.
    • Build the actual ext4 images and pass these native guest cases.
  • Use the newly guest-built native tools in Two-generation self-hosting demonstration for image operations and checksums; show Linux regression CI remains green and no host fallback or POSIX adapter secretly performs their native guest operations.

Two-generation self-hosting demonstration

Weight: 6%. Owning issue · integration PR 12.

Checklist
  • Freeze the acceptance source/toolchain/recipe/image hashes, complete output inventory, resource/timeout policy and exact build command in a reviewed runbook. Fix all prerequisites before declaring the timed demonstration started.

  • Provision a private seed extended image with admitted EriX-hosted tools and source-only inputs. Use an empty output tree and no prior EriX object, incremental, image, generated-metadata or host tool cache.

  • Boot the seed EriX and record guest identity, native process/realm provenance, mounted authority inventory and tool versions; disable networking and host shared-directory/build-RPC fallbacks.

  • From exsh in that EriX session, execute the complete build command. Record each compile/link/generate/sign/package step as an EriX process with exact input/output evidence and actual exit status.

  • Complete all Scope, repository and build inventory outputs, including every EriX component, signed boot image, UEFI loader, clean dev/release disks, selected extended disks and generated documentation/manifests. Compare inventory cardinality and hashes; a missing target or substituted prebuilt output fails the demonstration.

  • Run guest fmt/strict Clippy/unit/doctest checks and relevant guest tool/authority-negative tests on that graph; preserve zero-warning full logs.

  • Validate partition/ELF/signature/source closure, then export only completed artifacts/evidence through an explicitly authorized path. The host may record, independently verify and boot them, but may not repair or assemble a missing build output.

  • Boot the newly guest-built clean dev and release images and run their canonical runtime probes; boot the guest-built extended-dev image for the second-generation build. Record exact booted image hashes.

  • In that newly built EriX, provision the same immutable sources/tools and fresh empty output/tmp trees, then perform a second complete build without importing first-generation compiled EriX artifacts or mutable caches.

  • Compare first/second-generation complete artifact inventories and deterministic bytes/signatures using the fixed inputs. Investigate every difference; normalization is allowed only for fields explicitly specified before the run, never to erase unexplained payload differences.

  • Run the complete maintained VM catalog and post-image probes on matching guest-built artifacts. The external supervisor may start test VMs; nested virtualization inside EriX is not required and must not conceal a host-side build step.

  • Demonstrate source read-only, output/tmp confinement, executable scope, no device/raw-block/key/network/global discovery and no cross-realm control; test denied access, interrupted build and complete realm teardown.

  • Profile the self-host builds, report actual elapsed/CPU/I/O/memory figures and apply the predeclared budgets; close proven bottlenecks through reviewed fixes and a new complete evidence cohort, not partial retries to green.

  • Publish a reproducible evidence bundle: source graph, manifests, tool licenses/recipes, commands, full logs, profile summaries, negative tests, output hashes/signatures, boot/test results and independent review.

  • Include Signing, rootfs verification and UEFI Secure Boot trust-chain verification in both generations: custom-key Secure Boot, signed boot image and all rootfs authority/code objects. Exercise tampering/revocation failures before declaring the guest-built result accepted.

  • Initiate/observe the build through Extensible serial/PS2 CLI input harness's real serial/PS2 CLI input paths, run native boot/hash tools, and verify Consoles, vttys, mouse, TUI and boot logo's independent TTY/default-clear behavior, vtty switching, mouse selection/paste, boot logo and help/man/extop acceptance on the newly produced images.

Final CI, audits and alpha-review handoff

Weight: 4%. Owning issue · integration PR 12.

Checklist
  • Run final fmt, default/all-valid-feature strict Clippy, unit tests, doctests, target/profile builds and rustdoc for every altered repository at its exact final signed revision, with no warnings and no unexplained skipped tests.

  • Verify every new runtime feature has positive, authority-negative, malformed-input, interruption/cleanup and bounded VM integration coverage.

  • Run the full old-plus-new VM catalog and all canonical/post-image probes; reconcile authored scenario counts, source/worker ownership, expected exits, images and retained failures. Existing 486 cases are a baseline, not a fixed future denominator that permits dropping tests.

  • Enforce real per-scenario hard/stall deadlines and owned-process cleanup in CI; test stalled guests/helpers fail and release their worker. Report progress throughout long full-build jobs without fabricating liveness.

  • Monitor exact-head CI for every repository, including nested crates and older unit/VM regressions; classify pending/cancelled/stale/missing evidence separately. Fix failures and warning-bearing green jobs before acceptance.

  • Keep Rust fmt/Clippy/tests in each crate's canonical ci.yml, including Integration's library job; remove unsupported Forgejo workflow permissions fields and use authorized integrations only for needed capabilities.

  • Re-run the independent whole-codebase Whole-codebase authority and quality audit, Rustdoc, missing_docs and documentation audit and check zero deprecated APIs, over-limit authored code files, missing inline docs and unresolved ambient/residual/unwanted explicit authority findings.

  • Verify compiler/dependency commit-pin policy, clean/extended image isolation, signed source/artifact provenance, reproducibility and rollback/ upgrade behavior for changed persistent or ABI contracts.

  • Re-run uninstrumented startup and declared build-performance gates on the final graph; an earlier candidate's speedup or predecessor CI cannot certify a later graph.

  • Reconcile every component's canonical README/ARCHITECTURE/ROADMAP, docs/phases/6.md, manual/API references and operator self-hosting runbook with observed behavior, supported limits and exact final evidence.

  • Push all final signed feature/posix-compat trees and coherent Integration pins; verify remote heads/signatures and their own terminal CIs. Do not silently merge, retag, rewrite history or replace main images.

  • Close canonical acceptance criteria using the linked acceptance contract, record final percentage and remaining later-phase non-goals, and request explicit promotion direction for accepted images. Do not declare Phase 6 complete before Two-generation self-hosting demonstration, Final CI, audits and alpha-review handoff actually pass.

  • Close the supplementary Public Forgejo issues and PRs, Extensible serial/PS2 CLI input harness, Signing, rootfs verification and UEFI Secure Boot, Consoles, vttys, mouse, TUI and boot logo and Whole-codebase authority and quality audit, Rustdoc, missing_docs and documentation/Shell, utilities, help and manual pages, Native tools and full build/packaging pipeline gates, including signed downloadable boot artifacts, all-file authority verification, real-input CLI coverage, native tools, manuals and human-legible documentation/code.

  • Reconcile public issues, PR checklists, evidence links and this tracker; remove "WIP: " only from genuinely accomplished PR goals and leave unresolved/dependent work visibly open.

  • Prepare the v1.0.0-alpha.1 manual-review dossier: complete source graph, self-host proof, security/CI/performance results, licenses, custom-key enrollment/recovery instructions and known non-goals. Wait for explicit manual approval before merges, version promotion, release tags or artifact promotion.

Public Forgejo issues and PRs

Weight: 2%. Owning issue · meta PR 4.

Checklist
  • Verify the deployed Forgejo version, authenticated identity and minimum organization/repository permissions using the authorized credential without exposing it; do not assume another version’s API support or silently widen privileges.

  • Create public work-package and bounded implementation/audit issues in the owning repositories, with descriptive titles, dependency links, acceptance criteria and authority rationale. Preserve confidential coordination identifiers and evidence.

  • Maintain an idempotent issue/PR mapping and update process; detect existing objects before creation, preserve human edits, and avoid duplicates or unsupported completion claims. Keep this master checklist, totals, dependencies and evidence current whenever scope or acceptance changes.

  • Ensure every altered repository, including docs/meta/new libraries, has a feature/posix-compat PR with the exact "WIP: " title prefix after its first pushed checkpoint; use draft mode as well if supported, not instead of the required prefix. Link dependent PRs and the matching component graph.

    • Maintain one matching current-head WIP feature PR for every altered
      repository.
    • Complete explicit dependent-PR and matching component-graph links in
      every affected review.
  • Keep PR descriptions current with implemented versus planned scope, security decisions, validation/failures, exact CI revisions and issue references. Publish concise meaningful progress rather than private raw logs.

    • Publish source-bound implementation, validation and failure
      checkpoints in owning PRs.
    • Reconcile stale descriptions and condense accumulated history into
      current reviewable scope.
    • Keep subsequent implementation and final coordinated CI descriptions
      current.
  • Make public updates through the user's authorized account/configured identity without mentioning AI-agent attribution; never assert the user has personally reviewed, approved or signed something when that has not occurred.

  • Keep API tokens, signing secrets, private paths/logs and sensitive vulnerability detail out of public issues, PRs and artifacts; restrict actual security reports as required while recording a non-sensitive tracking link.

  • For every new repo, verify absence, create remotely from meta as template, verify static-file inheritance, clone, branch, specialize and open its WIP PR. Add audit/CI/docs/manual/catalog and public issue records before consumers depend on it; no local-first blank repository substitution.

    • Verify absence and create the three compatibility repositories
      remotely from Meta.
    • Clone/branch them, verify governance inheritance and create owning
      issues and WIP PRs.
    • Complete runnable Posixd specialization and every new component
      catalog/consumer entry.
    • Complete audit, validation and documentation obligations before full
      consumer admission.
  • Close an issue and remove "WIP: " only when its declared goal and required cross-repository/CI gates actually pass; keep the coordinated Phase 6 PR WIP until the whole phase is accomplished. Readiness is not merge approval, and successful Phase 6 is not alpha-release approval.

  • Reconcile all altered repositories, open issues, PR states and local progress at each milestone/final handoff; link each accepted result to its signed revisions and public review evidence.

    • Reconcile current branches, 66 altered-repository WIP heads and the
      public issue mapping.
    • Retain signed-source and public readback evidence for implemented
      milestones.
    • Complete all remaining current-scope/CI discrepancies and final
      coordinated handoff.

Extensible serial/PS2 CLI input harness

Weight: 3%. Owning issue · integration PR 12.

Checklist
  • Inventory current serial/physical helpers, guest-script injection, direct orchestration launch and output oracles; separate genuine CLI tests from low-level protocol/kernel fixtures before migrating them.

    • Identify existing serial, physical-input, transcript and runner
      ownership paths in the maintained harness.
    • Complete the CLI-versus-low-level scenario inventory and
      migration/disposition map.
  • Define a versioned input-backend interface for capabilities, connect/select-session, send text, press/release keys, modifiers/chords, synchronization and teardown; keep scenario intent independent of transport.

  • Implement serial input over an explicitly selected UART/PTY route, including encoding, line endings, fragmented escapes, partial writes, reconnect policy and bounded backpressure without bypassing seriald/ttyd.

  • Implement PS/2 keyboard input through the emulated device path, including scan codes, make/break, modifiers, repeat, arrow/delete and secure attention; do not inject directly into the shell or trusted-input endpoint.

  • Make unsupported backend capabilities explicit and reject them before a test starts; document how a future USB/HID or other backend plugs in without changing every scenario or inventing synthetic trusted input.

  • Bind commands and observations to one exact TTY/session per run. For independent terminals, PS/2 completion must use its framebuffer/session output, not unrelated serial log stamps; never send a command through both backends and accept whichever output happens to arrive.

  • Implement transcript expectations for exact output, status, prompt, cursor/redraw, timeout and completion, with structured failure context; screenshots/framebuffer state must corroborate visual assertions where needed.

    • Retain exact command/prompt/status and bounded structured failure
      observations in current serial/physical helpers.
    • Complete shared session-bound cursor/redraw/visual expectation
      semantics.
    • Corroborate all required visual assertions with the selected
      framebuffer/session evidence.
  • Add fake-backend unit tests for partial input, key-up cleanup, malformed escapes, stuck modifiers, cancellation and stale sessions; hard-bound helper/QEMU lifetimes and retain original status on observation failure.

  • Add real serial and PS/2 VM tests for editing/history, pipelines, redirection, Ctrl-C, foreground/background jobs and y/n plus Enter consent; prove ordinary input cannot impersonate trusted approval or another TTY.

  • Migrate CLI/tool acceptance scenarios to the shared real-input API, including boot-tool, sha2-tool, help, man, extop and self-host build commands; preserve existing assertions and record every renamed/retired case mapping.

  • Keep low-level non-CLI protocol/negative fixtures when needed, but do not count directly launched test scripts or hidden rootd orchestration as primary evidence that a user can operate a CLI tool.

  • Run backend coverage in CI for serial-only, framebuffer/PS2-only, independent dual and explicitly mirrored modes; preserve existing hard/stall limits and exact source/image/session evidence.

  • Remove superseded one-off CLI input adapters after migration, document authoring a new backend/scenario, and add a coverage gate preventing new CLI acceptance tests from silently bypassing the primary input harness.

  • Make physical text injection layout-aware while keeping explicit raw key/scan-code fixtures available; run US/Finnish punctuation, modifier and trusted-input cases under the actual boot preference. Serial sends text bytes directly and must not be translated a second time as keyboard scan codes. Record layout and key sequences; use independent expected vectors rather than the production keyboard translator as its own test oracle.

  • Extend the physical backend with PS/2 mouse movement and explicit left/middle/right press/release actions, preserving packet boundaries and validated device ingress; never substitute host clipboard or direct guest terminal-state writes for mouse acceptance evidence.

  • Add explicit Ctrl+Alt+Fn selection and target-vtty expectations, including held/released modifiers, invalid targets and switching during output or prompts; observe the selected framebuffer vtty rather than a serial sibling.

  • Add reproducible visual/text assertions for hidden/revealed cursor, selection and pasted text, plus early boot-logo screenshots tied to exact image/asset hashes. Preserve bounded observation and input teardown on failures.

Signing, rootfs verification and UEFI Secure Boot

Weight: 5%. Owning issue · bootloader PR 3.

Checklist
  • Inventory the complete trust chain and all authority-controlling root-partition files: executables, libraries, scripts/interpreters, plugins, loader/runtime/launch manifests, service/mount/realm policies, key policy and configuration/includes that can change authority. No code object is exempt because it is imported, generated at runtime or not marked executable.

  • Define verification ownership and an authenticated chain from enrolled firmware trust to EFI loader, boot.img, rootfs policy and every admitted executable/library. Existing bare digests are not the requested signature proof.

  • Specify a per-file signature or signed catalogue entry authenticating exact final bytes, length, role, relevant metadata/path binding, format/version, dependency closure and signer/policy generation. Every covered file must have verifiable signed coverage; unsigned sidecar hashes are insufficient.

  • Specify an acyclic finalization/signing DAG: finish code generation, stripping and capacity/metadata patches before object signatures, finalize authority catalogues before their boot trust anchor, then sign/package final EFI/boot/disk outputs. Avoid circular digest dependencies and post-sign edits.

  • Separate firmware PK/KEK/db/dbx certificates/keys from boot/rootfs signing keys and development/build-realm keys; document trust roots, allowed signer roles, rotation/revocation and recovery without reusing a general key.

  • Implement signed authority-file generation and verification in maintained tooling with independent known-answer, malformed-format, wrong-role, wrong-key, truncation, tampering and signature-coverage tests.

  • Verify policy bytes before applying policy or delegating authority; verify executables and complete library/interpreter/module closures before execution/initializers. Integrity or signer identity alone grants no capability.

  • Preserve fresh-object binding from signature verification to use; reject replacement, symlink/race/substitution and stale cache attacks, including lazily read executable pages and reused file handles. Never verify one object and map/execute another or mutable bytes from the same reopened path.

  • Define authorized policy/code update and rollback behavior with atomic verified publication, cache invalidation, revocation and interrupted update recovery. Do not promise anti-rollback without a reviewed trusted version/revocation anchor beyond attacker-replaceable disk data.

  • Define scoped signing/admission for newly built test programs, Cargo build scripts, proc macros, plugins and compiler outputs before executing them. Bind development signatures to the build realm/output policy; no unsigned output exception or general trusted-system signing oracle is allowed. Separate transient realm-generation-bound admission from reproducible final artifact signatures under fixed declared keys/policy; do not normalize away unexpected final signature differences in Two-generation self-hosting demonstration.

  • Implement the build-output signing route with exact artifact identity, authorized operation, finite lifetime and complete cleanup; keep private key material out of ordinary build processes and boot-tool itself.

  • Add rootfs tamper VMs for every object/policy class, missing/wrong/ revoked signatures, catalogue substitution, mixed generations and dependency replacement; prove no code runs and no new authority is installed on failure.

  • Add an explicit CI signing configuration using a private key from Forgejo secrets for downloadable boot.img; separate local test-key builds from protected signed publication and fail closed when required secrets are missing. Never silently fall back to the repository test key for downloads.

  • Restrict signing secrets to approved trusted workflow/ref contexts and an isolated signing stage consuming immutable verified artifacts; untrusted PR/fork code and ordinary compile/test scripts receive no signing key.

  • Pass secrets through a reviewed non-logging channel to the narrow signer, scrub owned temporary material on success/failure/cancellation and exclude it from caches, dumps, job logs and uploaded artifacts. Verify secret absence without printing/search-reporting its actual bytes.

  • Preserve boot-tool's detached payload/signature/verification contract; record public key fingerprint, exact signing payload/artifact hashes, source graph and signing policy without exposing private credentials.

  • Publish an explicitly named signed boot.img plus verification material/provenance per profile/key cohort, and ensure every downloadable disk contains its corresponding exact tested signed payload and rootfs authority closure; verify downloaded bytes independently of local publisher status. Protected CI re-signing/repackaging creates a separately verified/tested cohort, not a byte-identical Two-generation self-hosting demonstration result or permission for hidden host build completion.

  • Test protected signing success, missing/wrong secret, untrusted-ref denial, modified input, signer failure and cancellation; publication must stop on failure and no unsigned/test-key output may be mislabeled trusted.

  • Implement full supported-platform UEFI Secure Boot packaging with a custom EriX/user-controlled certificate: sign the PE/COFF EFI loader in the firmware-required format and keep its verification material consistent with boot/rootfs trust. An Ed25519 boot.img signature is not firmware EFI signing.

  • Provide documented custom PK/KEK/db/dbx enrollment, owner-authorized updates, certificate distribution and revocation/recovery procedures without dependence on a Microsoft signature. Back up existing enrollment and require explicit approval before changing real firmware variables or owner keys.

  • Define enforced versus explicitly non-enforced development boot modes and check SecureBoot/SetupMode state where appropriate; never report successful enforcement while firmware is in setup mode or validation is off.

  • Add QEMU/OVMF Secure Boot fixtures with private firmware-variable storage and custom enrollment; prove correct-key boot and refusal of unsigned, wrong-key, tampered and revoked EFI images without a permissive fallback path.

  • Exercise the full enforced chain with tampered boot.img, rootfs policies, executables and shared libraries; firmware success alone cannot close downstream verification gates. Include both clean and extended profiles.

  • Test key rotation/revocation, interrupted updates and documented recovery using independent fixtures, preserving least authority and a usable owner recovery path rather than silently disabling verification.

  • Perform a manually approved real-firmware enrollment/boot/rejection validation on the supported hardware baseline; record firmware versions and limitations. OVMF evidence alone is not a claim of universal firmware support.

  • Audit signing/verification code and CI boundaries independently, update threat models/rustdoc/man/manual and include malformed crypto/container inputs without introducing third-party code into clean-room components.

  • Verify normal signed loading does not retain signer/admin authority in loaders or applications; profile verification overhead through Integration profiler and measured optimization and optimize only exact immutable identities with sound invalidation.

  • Include signing/trust tests in the full CI and both Two-generation self-hosting demonstration build generations, using scoped development keys for self-host proof and protected CI signing for downloadable outputs; document the distinct trust policies.

  • Produce an operator verification/enrollment/recovery runbook and alpha-review evidence showing the exact EFI→boot→rootfs trust chain, public verification keys and download hashes, with no private signing material.

  • Design/version a distinct unsigned user-preference section in boot.img, separate from signed executable/configuration/authority data. Whitelist non-authoritative typed settings, initially keyboard-layout ID; preferences cannot select trust roots, bypass verification, choose executables, alter capability/realm policy or grant device/namespace access.

  • Authenticate the container format and section directory/bounds, including the precise permitted unsigned extent. Exclude only that preference payload from the boot signature's authenticated message; verify every security- relevant byte and reject overlap, aliasing, truncation, confused versions and attempts to reinterpret signed bytes as preferences. Give the preference descriptor an authenticated explicit hash policy: no signed section hash may still depend on mutable preference bytes. Any optional corruption checksum for those bytes lives inside their unsigned extent.

  • Implement build/read/update tooling for preferences without private signing authority, preserving all authenticated bytes, section extents and signatures. Record separate full-container digest and signed-content identity: preference edits change the former, not the latter; refresh local artifact receipts without falsely claiming an edited image matches published checksums. Coordinate any outer boot-image/catalog authentication so it anchors signed core identity, not a whole-file digest that silently forbids unsigned edits; retain whole-file digests as exact distribution/integrity evidence.

  • Parse preferences as bounded untrusted input with deterministic absent/malformed/unsupported-value handling, defaulting keyboard layout to en_US. Malformed preference content may fall back, but malformed authenticated structure or signature failure must still fail closed, never enter fallback.

  • Carry the validated preference value to its consumers as explicitly non-authoritative data, distinct from trusted clear-completion and authority handoff fields. Only select packaged, signed, allowlisted keyboard definitions; preference text cannot load a script, plugin, arbitrary path or mapping code.

  • Add signature/container unit tests and VMs showing layout-only preference edits preserve Secure Boot/boot-content verification, while changing signed code, policy, bounds, key selection or verification flags is rejected. Test integer overflow, unknown/duplicate keys, padding and recovery defaults.

  • Version boot-image/handoff parsing and every consumer's trust classification for unsigned preferences; do not reuse MUTABLE_AFTER_BOOT or descriptors promising all bytes were signature-verified as an unsigned bypass. Update format/coverage vectors, boot-tool/manual docs and negative version tests together, then retire superseded intake under Whole-codebase authority and quality audit without a permissive fallback.

  • Keep the optional boot-logo bitmap and its type/dimensions/format under signed boot-image coverage, separate from unsigned user preferences; decode/render it only after authentication. Logo substitution cannot extend the unsigned region, select executable content or alter authority handoff.

Weight: 2%. Owning issue · ttyd PR 3.

Checklist
  • Add strictly boolean [features].fbcon_clear, default true, to runtime/build configuration, schema, parser, feature identity and documentation; reject malformed values and test omission, true and false.

  • Apply the option to early and userspace framebuffer initialization. Clear once before the first console output when enabled; when disabled neither initializer may erase existing content merely because it starts.

  • Carry validated framebuffer identity/geometry and an early-clear completion record through the trusted handoff; if early fbcon already cleared the screen, user fbcon adopts it without another clear. Do not treat arbitrary descriptive startup bytes as proof of a trusted completed clear.

  • Preserve pixel format/stride/padding, cursor and output continuity; replace conflicting unconditional release/early clears and test that late initialization never erases valid early logs. Normal explicit TUI clearing remains separate from this initialization-only build option.

  • Add unit and framebuffer VM coverage for early-only, user-only, both and neither console with clear enabled/disabled; assert exact clear count, final pixels and handoff failure behavior, not just a serial READY marker.

  • Set tty_mirror = false in both canonical dev/release images; align sample/extended defaults with independent terminals and retain explicit mirrored fixtures so the optional feature remains tested.

  • Validate both enabled paths create distinct shells/sessions with separate input/output/cwd/history/foreground jobs/consent and adequate declared capacity; single-path and no-TTY configurations still work without extra grants.

  • Preserve frozen Phase 5 handoff and remaining gates timing comparisons as their original cohort, then measure the new dual-shell default separately using Extensible serial/PS2 CLI input harness session-bound observations. Do not attribute a policy/workload change to a kernel speedup or relax the carried limits; report each terminal's full startup/command evidence.

  • Specify/version improved fbcond TUI operations: absolute/relative cursor position, visible cursor, erase regions, colors/attributes, rectangular cell updates, scrolling regions, viewport/resize and frame completion.

  • Implement bounded validated rendering batches/dirty regions, geometry/capacity checks and deterministic malformed-request behavior without granting raw framebuffer memory or global-screen ownership to clients.

  • Expose TUI through session-scoped tty mediation backed by fbcond, with clear renderer versus terminal ownership. Keep trusted powerbox chrome protected; ordinary clients cannot draw over it or steal focus/consent input.

  • Implement serial-terminal equivalents or advertised graceful fallbacks over the same session-level interface; define supported capabilities explicitly rather than claiming compatibility with every ncurses extension.

  • Extend the shared terminal parser with required cursor/erase/color and alternate-screen behavior, including extop's existing home/full-erase needs; test split escape sequences, unsupported controls and dimensions.

  • Port extop to the new TUI interface with efficient frame updates, resize/navigation, screen restoration and interrupt/exit cleanup; retain its exact process-inspection/control authorities and never add broad console caps.

  • Implement trusted-prompt suspension/restoration during a TUI session, ensuring modal input is not consumed by extop and no previous trusted text or stale ordinary frame is replayed after focus/session changes.

  • Add parser/renderer unit tests and serial/PS2 visual VMs for cursor, erase, colors, scrolling, resize, extop refresh/quit/Ctrl-C, independent TTYs, prompt interruption and complete session/capability cleanup.

  • Profile full versus partial redraw, IPC count and extop input-to- frame latency; fix measured bottlenecks without skipping visible completion, and update IPC/Rust API man pages, tool manuals and operator documentation.

  • Define keyboard-layout ownership over layout-independent physical key events; retain driver/inputd raw identity and implement text translation at ttyd or a reviewed shared pure layout layer. Provide signed, clean-room en_US and fi_FI mappings with modifiers, Caps Lock, AltGr, punctuation, Unicode and Finnish dead-key behavior. Keep physical identity, navigation and control chords distinguishable from text.

  • Initialize the keyboard text translator from Signing, rootfs verification and UEFI Secure Boot's validated boot preference, default en_US; preserve consistent layout behavior for every physical keyboard client/session without double-translating serial input. Initially select layout at boot; later runtime layout changes require their own state-transition contract, not reinterpretation of buffered input.

  • Add a git-ignored local build override selecting fi_FI and include it explicitly in image identity/test receipts. Keep canonical dev/release, extended profiles and clean CI defaulting to en_US; explicit CI layout fixtures test Finnish without allowing a developer override to leak into publication.

  • Preserve secure-attention key identity and trusted consent fences; preference changes must not synthesize approval, reinterpret buffered keys or let ordinary layout processing consume trusted y/n plus Enter. Document which chords are physical and which text is layout-selected and display prompts consistently with those rules.

  • Add unit/real-input VM tests for both layouts, default/invalid preference fallback, local override isolation, modifier/dead-key release, repeated input, Unicode editor/delete behavior and trusted consent. Test both independent terminals and verify serial byte input remains unchanged.

  • Document keyboard selection and preference editing in boot-tool help/man, image/build docs and the technical manual, explicitly identifying unsigned convenience data versus signed security policy and code.

  • Replace single-byte-only text emission with checked UTF-8 sequences and backpressure-safe atomic character delivery; define dead-key composition, unsupported combinations, modifier release and pending-state reset on focus/ session/consent changes. Test interrupted multi-byte delivery cannot corrupt commands, leak pending text to another TTY or reinterpret it as trusted input.

  • Define multiple framebuffer vttys as distinct live terminal/session generations with their own shell, screen/scrollback, cursor, editing/history, cwd, foreground jobs and input state. Keep virtual-terminal records separate from the existing two physical framebuffer/serial console bindings.

  • Specify signed resource/count and creation/retirement policy for configured vttys, with at least two exercised in acceptance. Allocate/reuse only explicitly authorized session resources; an Fn ordinal cannot create processes or grant launch authority. Test exhaustion and safe focus fallback when a shell/vtty exits, without imposing an incidental fixed table limit.

  • Implement physical Ctrl+Alt+Fn switching directly to the configured framebuffer vtty identified by Fn. Admit this exact authenticated gesture without a separate manual secure-attention step, independently of keyboard layout; preserve existing trusted controls and reject nonexistent/stale targets.

  • Switch display and ordinary input focus atomically by exact live session generation; keep events bound to their receipt-time destination and handle held modifiers/releases without injecting them into the wrong vtty. Independent serial focus remains unchanged; test explicit mirrored mode too.

  • Cancel a pending trusted prompt when switching away, retaining the existing cancellation/cleanup contract; never transfer approval state to the destination. Restore ordinary content only after renderer acknowledgement and preserve fresh-input fences if a later prompt is created.

  • Retain inactive-vtty output in its own bounded terminal state and restore screen/cursor/selection on activation; handle resize, scrolling and extop alternate-screen updates without exposing another vtty or trusted chrome.

  • Add unit and physical-keyboard VMs for direct Fn switching, repeated switching, background output, exit/recreation, stale IDs, modifiers, both layouts, serial isolation and prompt cancellation. Profile switching/memory use and record the multi-vtty workload separately from frozen startup comparisons.

  • Implement a framebuffer mouse pointer that starts hidden and becomes visible only on the first authenticated nonzero movement, not button-only, resize or focus events. Define per-seat visibility across vtty switches; distinguish this pointer from the shell's text caret.

  • Validate signed deltas, button transitions, geometry and coordinate arithmetic; clip cursor drawing to the viewport and restore underlying pixels correctly during movement, redraw, scrolling, resize and vtty changes.

  • Implement left-button press/drag/release text selection and visible highlighting from the owning vtty's ordinary text model, including wrapped lines, Unicode/cell boundaries and scrollback. Bind selection to session and content revision; define updates while output changes during a drag.

  • Use conventional primary selection: completing a left-button selection copies its text, and middle-button press pastes it. Keep selection bytes scoped to the owning terminal/session by default; cross-vtty transfer requires explicit user-directed source/destination and realm policy, never a global clipboard or arbitrary screen-reading capability.

  • Deliver middle-button paste through the exact destination's ordinary input path with backpressure-safe ordering and no duplicate bytes. Define bracketed-paste/multiline/control-byte behavior so shell paste does not silently execute embedded newlines; require normal explicit submission. Do not apply keyboard layout translation to already selected UTF-8 text.

  • Exclude trusted chrome, consent input and other vttys from selection. Mouse selection/paste cannot approve, edit or queue answers to a trusted prompt; reject untrusted escape-sequence clipboard access and keep the host/serial terminal clipboard separate. Retire retained text on owner teardown/reuse.

  • Add independent unit and real PS/2 mouse/keyboard tests for initial hiding, button-only packets, first movement, bounds, pixel restoration, selection during redraw/scroll/resize, Unicode, middle paste, backpressure, vtty isolation and prompt races; prove cleanup and zero unintended authority.

  • Use the logo asset as the original boot-logo source, recording its exact digest and asset provenance. It is currently a 1024×1024 RGBA PNG. Preserve its artwork/transparency; define deterministic preprocessing/scaling rather than generating a new logo.

  • Convert the source at build time into a simple, versioned, bounded bitmap payload with explicit dimensions/pixel/alpha format; package it as an optional signed non-executable boot.img section. Keep general PNG decoding out of the bootloader unless a separately justified design requires it.

  • In the bootloader, draw the available authenticated bitmap at the screen's bottom center using validated GOP geometry. Preserve aspect ratio, alpha blend against the existing background and define deterministic fitting/ margins for small resolutions; never stretch or draw outside the viewport.

  • Fully validate pixel length, width/height/stride, format, arithmetic, alpha and destination bounds before drawing; test RGBA/BGRA, padding, clipping and overflow independently. Image data grants no framebuffer mapping authority.

  • Integrate drawing after the configured one-time clear, in both dev and release paths, independent of early text-log enablement. Preserve the clear-completion handoff so later early/user console initialization does not immediately erase the logo; define temporary text/logo placement and normal console takeover without hiding required readiness/error output.

  • Boot normally without the optional logo or a usable framebuffer. Define safe cosmetic-error handling for an authenticated but malformed bitmap; container/signature failure still follows the existing fail-closed policy. Release temporary logo buffers/module authority once no consumer needs them.

  • Add Linux and in-EriX asset-conversion/package parity tests and put conversion inputs/tools in the Native tools and full build/packaging pipeline, Two-generation self-hosting demonstration build closure; the final guest-built images must not depend on an unrecorded host-side bitmap conversion.

  • Add bounded visual VM tests for logo present/absent, dev/release, clear true/false, early console on/off, both pixel formats and small/normal geometries; assert bottom-center placement/transparency and unchanged text. Test signed-logo tampering rejection and document the asset/format/build options in boot-tool man pages, canonical docs and the technical manual.

Alpha 1 execution, lifecycle and phase-review gates

These are required alongside complete self-hosting. The integrated microkernel gate remains the owning release checklist.

Alternatives and tradeoffs

Detailed designs and exact reproduction evidence belong in their owning records. Inventory, specification, source implementation and runtime acceptance remain distinct. Rebuilding selected upstream Rust/LLVM within EriX is required; independently implementing an EriX-owned compiler remains later work. Preserve the full guest and toolchain scope rather than substituting a smoke build.

Tracking and rollout

Related offline-build designs: inventory-bound source bundle and GPT image metadata writer, and native GPT image initialization.

Related build-input design: completed Cargo preparation progress.

Related regressions: manual table, SHA fixture provider, runtime fixture profiles, completed socket sends.

Related contract designs: Kernel #56, Kernel #57 caller-owned lexical continuations and bootstrap namespace lifetimes. Exsh #4 tracks the remaining native frame proof.

Related defects: native compiler target preflight, Vfsd stack exhaustion, Vfsd dependency graph, FAT catalog witness, initial-shell cleanup, Rootd marker inventory, disk error propagation, large ACL fixture, missing-Procd preparation, Bootloader path parsing, retired completion logging, C ABI observation, quiet-time fixture, and test-crate documentation lint, default Rootd build graph.

Complete checklist items end to end and retain coherent interfaces, source identities and original failure evidence. Use canonical feature_request, bug_report and PR templates with phase-6 and applicable topic labels. Keep this checklist, weights, dependencies and relevant links current.

Use comments for routine status and remaining work. Mention testing in status comments or commit messages when it concerns a linked defect. Edit bodies for checklists, requirements, design, scope and factual corrections. Write repository content, issues, PRs and comments in clear, natural engineering prose. Preserve human edits and verify each public change.

Related issues and PRs
Repository Issues PRs
blockd #1, #3 #2
boot-tool #1, #3, #6 #2
bootloader #1, #2 #3
coreutils #1 #2
crashd #1 #2
deviced #1, #4 #3
docs #1, #2, #11, #12 #4
drv-acpi #1 #2
drv-i8042 #1 #2
drv-ps2-keyboard #1 #2
drv-ps2-mouse #1 #2
drv-rtc-cmos #1 #2
drv-serial #1 #2
drv-virtio-block #1 #2
dynlinkd #1, #2, #4 #3
e2fsd #1, #5, #6, #7, #8, #9, #10, #11, #12, #13, #15, #16, #17, #18, #19, #20, #21, #23, #25 #3
exsh #1, #2, #4, #5, #9, #10, #11, #13, #14, #15, #16, #24, #25 #3
extop #1 #2
fatd #1, #4, #5, #6, #7, #8, #9, #10, #11, #12, #14, #15, #16 #3
fbcond #1 #2
hotplugd #1 #2
inputd #1 #2
integration #1, #2, #3, #4, #5, #6, #7, #8, #9, #10, #11, #18, #20, #30, #31, #37, #39, #40, #45, #47, #54, #56, #57, #58, #64, #65, #66, #67, #68, #69, #70, #71, #72, #73, #74, #75, #76, #77, #78, #79, #80, #81, #82, #83, #84, #85, #86, #87, #88, #89, #90, #91, #92, #93, #94, #95, #96, #97, #98, #99, #100, #102, #103, #104, #105, #106, issue 107, issue 108, #109, issue 110, issue 111, issue 112, #113, integration #114, #157 #12
irqd #1 #2
kernel #1, #2, #18, #19, #20, #21, #22, #23, #24, #25, #26, #27, #28, #29, #30, #31, #32, #33, #34, #35, #36, #37, #38, #39, #40, #41, #42, #43, #44, #45, #46, #47, #48, #49, #50, issue 51, issue 52, #53, kernel #54 #3
keyd #1 #2
launchd #1, #3, #4, #5, #6, #7, #8, #9, #10, #11, #12, #13, #14, #15, #17, #18, #19, #20, #21, #22, #23, #26, #27 #2
lib-aes #1 #2
lib-block #1 #2
lib-bootimg #1 #2
lib-bootstrap #1, #4 #2
lib-capabi #1, #4 #2
lib-cli #1 #2
lib-console #1 #2
lib-constant-time #1 #2
lib-crc #1 #2
lib-cstd #1, #2, #4, #5 #3
lib-deflate #1 #2
lib-device #1 #2
lib-driver #1 #2
lib-dynlink #1, #4, #5, #6 #3
lib-ed25519 #1 #2
lib-elf #1 #2
lib-fs-crypto #1 #2
lib-fs-name #1 #2
lib-handoff #1 #2
lib-input #1 #2
lib-interrupt #1 #2
lib-ipc #1, #3, #4, #5, #6, #7, #8, #12 #2
lib-log #1 #2
lib-partition #1 #2
lib-posixabi #1, #2, #4, #5, #6, #7 #2, #3
lib-service #1 #2
lib-sha2 #1 #2
lib-stdio #1, #3 #2
lib-time #1 #2
lib-tty #1 #2
lib-vfs #1 #2
loaderd #1, #5, #6, #7 #2
logd #1 #4
memd #1 #2
meta #2, #3, #5 #4
named #1 #2
pagerd #1 #2
lib-owned-region #1, #3: original-region resizing #2
posixd #1, #2, #3, #4, #7, #8, #9, #10, #11, #12, #13, #14, #15, #16, #17, #18, #19, #20, #21, #22, #23, #24, #25, #26, #27, #28, #29, #30, #31, #32, #33, #34, #35, #36, #37, #38, #39, issue 40, issue 41 #5
powerboxd #1 #2
probed #1 #2
procd #1, #4, #5, #6, #7, #8, #9, #10, #11, #12 #2
ramfsd #1, #3, #4, #6, #9, #10, #11, #12 #2
rootd #1, #6, #7 #2
seriald #1 #2
sha2-tool #1, #3 #2
timed #1, #3, #4 #2
ttyd #1, #2 #3
vfsd #1, #4, #5, #6, #7, #8, #9, #10, #11, #12, #13, #14, #15, #16, #25, #26, #27, #28, #29, #30, #32, #39 #3
vspaced #1 #2
Detailed contracts and source requirements
Repository Contracts
docs logo_transparent.png, 6.md
e2fsd conditional-namespace.md, detached-inodes.md, encrypted-file-growth.md, original-undo.md, extent-boundaries.md
fatd conditional-namespace.md, detached-objects.md, detached-objects.md#current-parent-observations, directory-observations.md, exfat-directory-mutation.md, native-namespace.md, original-catalog.md, original-undo.md
integration descriptor-readiness.md, ext-undo.md, fat-detached-recovery.md, native-c-runtime-consumers.md, native-thread-lifecycle.md, public-deadlines.md, local-ipc-requirements.toml, native-invocation-profiling.md, startup-profile-contract.md, startup-profiling.md, tcg-profiling.md, realm-binding-witness.md
kernel claimed-native-preparation.md, creator-floating-environment.md, independent-machine-state.md, initialized-native-context.md, native-context-memory.md, native-machine-state.md, native-member-carriers.md, native-member-exit-observation.md, native-thread-exit.md, prepared-native-members.md, process-lifetime-storage.md, process-thread-ownership.md, retained-member-mappings.md
launchd client-thread-factory.md
lib-aes c63d8660128f0dc0fd83ee7471c3a252f7d9cc55
lib-block durability.md, undo-journal.md
lib-cli 7a7327da50d2e0d28c9d34a4bfffb49870e2eba2
lib-console 5b832898e76cbfadd0b4ce2e921e4b9c5905e65c
lib-constant-time eed797dfb0c4ab3d2a6300e1dc40254b79d7c1a1
lib-cstd thread-runtime.md
lib-deflate 76a4d0abd57f69012ccba66c6b3b633f71554507
lib-device 91591b440d967e9e142e987e193a38f3825f84ef
lib-dynlink tls-registry.md
lib-elf 22b995d401dd5a8fcc2c244e53c8e932e5573648
lib-fs-name a555d9bc6473e7779e20ed8df9447ebac246b648
lib-handoff 16b9cb8dcfa5969745f5498c8abd887fcb2eabc4
lib-ipc conditional-namespace.md, conditional-permissions.md, native-activity.md, native-context-abi.md, native-deadlines.md, native-enrollment-abi.md, native-factory-abi.md, native-preparation-abi.md, native-start-abi.md, owned-invocation-abi.md, provider-cwd-retirement.md, public-deadlines.md, realm-clock.md, relocation-patches.md, seekable-directories.md, socket-admission.md, stream-metadata.md, stream-readiness.md
lib-posixabi local-stream-sockets.md, namespace.md, permission-operations.md, readiness.md
lib-sha2 a97176f9835c2cb97e4b5ff2565d18efab389647
posixd advisory-locks.md, descriptor-readiness.md, file-controls.md, inherited-stream-io.md, local-stream-sockets.md, namespace-mutations.md, permission-operations.md, pipes.md, temporary-output.md, thread-signals.md, thread-storage.md, realm-ownership.md
procd client-thread-factory.md, initial-tls-materialization.md
ramfsd open-object-lifetime.md
timed owned-clock.md
vfsd context-lifetime.md

Alpha 1 microkernel release gate

  • Complete the integrated microkernel demonstration: process isolation, capability security, userspace services, fault containment, exhaustion safety, independent processes, POSIX confinement, reproducible evidence and functional SMP on 2–4 CPUs. Run the release-image matrix with 1, 2 and 4 vCPUs, the authority audit, negative/fault-injection tests and repeated concurrency stress. This gate supplements the existing self-hosting acceptance.
## Problem and motivation Checked implementation items do not establish that pending tests, current CI or native execution have passed. The complete guest builds and in-guest Rust/LLVM rebuild remain undemonstrated. EriX needs POSIX compatibility and a complete development environment capable of building EriX within EriX. This issue tracks the full scope and supplementary requirements; detailed designs and evidence remain in the owning records. ## Proposed behavior and scope Implement the POSIX ABI/service, files and namespaces, memory and threads, processes/signals, libc/startup/sysroot, compatibility ELF/TLS/linking, shell and utilities, imported development tools, profiling and image assembly. Preserve required input, including [physical command delivery](https://git.erikinkinen.fi/erix/integration/issues/145), signing, consoles, TUI and boot-logo work. Build the entire EriX graph and bootable images inside EriX, boot a resulting image, and repeat the complete build there. Cross-bootstrap the selected external Rust/LLVM toolchain and C/C++ runtime against EriX's libc/sysroot; rebuild that toolchain inside EriX using explicit offline inputs, validate it, and use it for a complete EriX build. Both guest generations and the external toolchain rebuild are mandatory. [Partition-payload assembly](https://git.erikinkinen.fi/erix/boot-tool/issues/8) extends the image initializer with exact retained file reads and removes the product partition overlays. [Native FAT32 image creation](https://git.erikinkinen.fi/erix/boot-tool/issues/9) adds deterministic filesystem metadata and selected file contents through that assembly path, with adoption in the three ESP recipe routes. [Generated Cargo lock inputs](https://git.erikinkinen.fi/erix/integration/issues/192) extend the offline source inventory with exact final locks and their workspace/source bindings. [Portable Cargo dependency graphs](https://git.erikinkinen.fi/erix/integration/issues/193) add the completed package, target, feature and resolve graph to that inventory with original source-role coordinates. [Original Git object transport](https://git.erikinkinen.fi/erix/integration/issues/194) supplies explicit offline object inputs and a fresh source/Cargo preparation path, preserving original commits, locks and graph semantics. [Journaled ext4 image initialization](https://git.erikinkinen.fi/erix/boot-tool/issues/10) adds an explicit native filesystem format path. Complete typed population and product recipe replacement remain separate work. [Offline bundle preparation](https://git.erikinkinen.fi/erix/integration/issues/195) adds a maintained command for explicit tools, complete role selections, fresh Git and locked Cargo results, and original operation cleanup. [Typed ext4 product population](https://git.erikinkinen.fi/erix/boot-tool/issues/11) adds the complete declared product tree, explicit inode metadata and one original file input across mapped extents, with product recipe adoption. ## Authority, security and reliability Apply security, reliability, then performance. Eliminate ambient, residual and unwanted explicit authority. Audit original capability identity, recipients, minimal rights, delegation, lifetimes, partial effects, cancellation, restart and positive retirement before reuse. Names, IDs, paths and observations never confer authority. Preserve denied/uncertain states and independent cleanup obligations. Continuously remove deprecated APIs, redundant code and incidental restrictions; identify and eliminate measured bottlenecks with Integration's profiler. Keep authored code files below 1,000 physical lines through thematic refactoring. Document public and private invariants with rustdoc and enforce missing_docs in every crate. Keep trusted EriX code clean-room and separate from permitted imported payloads. Before publishing a shared supplier, run the authored-Rust documentation gate against actual Cargo target metadata, including integration-test crate roots, and the authored-code size gate. Preserve explicit source and helper revisions. Use self-contained per-feature branches and a separate PR for each branch (WIP while incomplete), squash dependency-pin-only churn into the owning feature, regular signed nonforce commits in canonical CONTRIBUTING format, [`main` for Cargo.toml Git dependencies with CI branch overrides](https://git.erikinkinen.fi/erix/integration/issues/142), and explicit immutable resolved revisions for catalogs, helpers, [packaged component receipts](https://git.erikinkinen.fi/erix/integration/issues/144) and build evidence, and coherent dependency publication. Maintain canonical governance/templates, README/ARCHITECTURE/ROADMAP formats, technical-manual TeX and API references. New repositories use meta as their remote template. Keep review PRs WIP until their full scope is accepted; merges and releases require separate approval. Keep secrets and suspected vulnerabilities private. ## Acceptance criteria - [ ] Publish useful CI job summaries across maintained repositories, including safe failure reporting, source identity and evidence links; complete the [shared implementation and repository rollout](https://git.erikinkinen.fi/erix/integration/issues/780). Complete each parent's full implementation scope; expose partial work through its existing children. Preserve meaningful positive, malformed-input, authority-negative, interruption and cleanup controls. Historical source acceptance under earlier testing waivers is not retrospective test proof. Run cargo fmt, strict Clippy, supported unit/feature/target/doctests, warning-denied builds and rustdoc/manual checks. Add and run necessary bounded VM tests; monitor all repository CI and older regressions. Parallel testing and CI must not block independent implementation. Resolve failures and warnings at source; skipped, pending and unrun checks are never passes. All repositories must pass CI before final completion. Preserve every same-repository pull-request duplicate-run guard without disabling fork, push or manual runs. ### Phase 5 handoff and remaining gates Weight: 2%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/6) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Preserve the archived tracker and an evidence index for the exact source graphs, CI logs, main-image hashes, rejected experiments and all failed timing observations; distinguish historical results from current-head gates. - [x] Preserve the original Phase 5 tracker, signed source selections and failed timing observations. - [x] Retain source-bound CI logs and image/artifact identities for subsequent checkpoints. - [ ] Consolidate the complete handoff index and verify every historical/current link. - [x] Observe CI 1549 to terminal status, audit every job/log and full scenario/post-image count, and classify remaining failures without weakening markers, source identity, worker ownership or deadlines. - [x] Review the held `10d57e98` checkpoint and record its disposition: preserve its signed ancestry when creating `feature/posix-compat`; publish a coherent new-branch graph only after the predecessor evidence is retained. Do not drop the locally committed pin or silently substitute an older graph. - [ ] Run the carried checkpoint's own exact-head full CI and a fresh repository-wide CI inventory; resolve any failures/warnings at their owners. - [x] Create the repository-wide branch, source and CI inventory. - [x] Refresh current component CI states against the selected feature heads. - [ ] Complete the carried checkpoint and dependent full Integration gates. - [ ] Resolve all remaining owner failures and warnings without weakening acceptance. - [ ] Revalidate the prepared direct-chunk private-image recipe against the chosen Phase 6 base before reuse; bind all source revisions, environments, cache keys, executable PT_LOAD bytes and rootd path/capacity differences. - [ ] Build/audit matching private dev/release images once admitted; retain original helper failures and the narrow proven locale-receipt handling. Do not reuse a predecessor's symbol addresses or compiled-object attribution. - [ ] Collect one adjacent audited control and two complete candidate startup observations, with no concurrent local VM/compiler, using unchanged 120 s total / 15 s silence / 10 s command collection limits. - [ ] Close the carried startup acceptance only after **both** candidate observations satisfy root-to-final-READY ≤5 s, largest service-ready gap ≤1 s, final-READY-to-full-editor-caret ≤1 s, and the exact four-command interval ≤2 s. Preserve the maintained oracle and command; never retry unchanged input to green. - [ ] Record remaining bottlenecks as [Integration profiler and measured optimization](https://git.erikinkinen.fi/erix/integration/issues/3) findings if [Phase 5 handoff and remaining gates](https://git.erikinkinen.fi/erix/integration/issues/6) fails; validate each eventual fix with strict component checks and matching VMs. - [x] Retain failing startup observations and identify mapping/switching candidates using actual captured code. - [ ] Finish the causal correction and required matching component/VM validation. - [ ] Meet the original uninstrumented startup bounds and reconcile the carried finding. - [ ] Update the carried acceptance report and component/manual status with actual results; retain all six old unchecked rows as covered by these items rather than counting duplicate validation prose as six independent gates. </details> ### Scope, repository and build inventory Weight: 3%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/1) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Inventory all existing repositories, nested Cargo workspaces and crates, targets, profiles, feature combinations, scripts and maintained tests. Record repository paths, remotes, exact heads, dirty state and build ownership. - [x] Inventory repository paths, remotes, exact heads, branches and dirty state. - [x] Inventory nested Cargo packages, targets, declared features/profiles, scripts and tests. - [ ] Review all supported feature combinations and complete target/test build ownership. - [x] Record/create `feature/posix-compat` before each repository's first edit; verify exact dependency pins and signed ancestry from the accepted base. - [x] Verify whether `lib-posixabi`, `lib-cstd` and `posixd` already exist remotely; create each missing required repository in Forgejo from `meta` before cloning. - [x] Scaffold those three components with explicit responsibility and authority boundaries, rustdoc, strict CI, tests and specialized canonical docs. Keep import recipes/profiler in Integration; do not invent extra daemons/repos without a concrete ownership need and recorded design review. - [x] Provide the documented, strictly tested lib-posixabi crate and component CI. - [x] Provide the documented, strictly tested lib-cstd crate and component CI. - [x] Provide Posixd responsibility, ownership and bootstrap design documents with CI. - [x] Add the Posixd runtime crate, strict Rust CI, tests and executable responsibility boundaries. - [ ] Add new components to Integration's commit-pinned catalogs and immutable dependency policy; validate the exact transitive source graph. - [x] Adopt the original lib-cstd memory implementation in the native component catalog and validate its selected graph. - [ ] Adopt the required lib-posixabi and runnable Posixd components with exact transitive selections. - [ ] Reconcile all three complete component versions across catalogs and immutable dependency checks. - [ ] Freeze a machine-readable full-build output inventory: every maintained EriX crate/library/binary, kernel, EFI bootloader, native build tools, boot image, dynamic/launch metadata, four image profiles and release manifests. - [x] Record the initial machine-readable repository/target and output-class inventory. - [x] Implement and test explicit-source build-scope and output-receipt validation. - [ ] Complete and review ownership/recipes for every maintained output and all four image profiles. - [ ] Freeze a complete accepted inventory with no missing or unclassified output. - [ ] Inventory all canonical generators, documentation/manual outputs, checksums/compression/signing steps and their host executables. Include these in the in-EriX build closure; distinguish external test execution from building. - [x] Identify current generators, image/signing/compression tools and documentation host dependencies. - [ ] Resolve the exact complete executable/version and generated-output closure. - [ ] Bind every required generator to its guest build recipe and distinguish execution-only external tests. - [x] Record the build-host versus emitted-target matrix: EriX-hosted tools and compatibility libraries for `x86_64-unknown-erix`, plus the existing bare-metal and UEFI targets needed to rebuild the OS. Do not rewrite native target ABIs merely to make imported tools run. - [ ] Produce an API/workload matrix from the exact intended Rust/LLVM, Cargo, Python, Git, shell, image and documentation recipes; map every required call/ELF feature to an owner, implementation item and independent test. - [ ] Define the POSIX specification edition/profile, C ABI/data model, locale baseline and optional extensions. Mark unsupported optional surfaces explicitly; never claim full POSIX certification from a selected build workload. - [ ] Resolve/document the existing Phase 6 close-on-exec-by-default policy versus standard descriptor inheritance expectations. Preserve native authority ceilings; specify any compatibility deviation before implementation. - [ ] Approve the architecture/threat model for `posixd` isolation, process mediation, TLS, fork snapshotting, signal delivery and build realms. Enumerate trusted components and keep POSIX policy out of the kernel/rootd. - [x] Specify native realm ownership, authenticated client ingress and mediator isolation. - [x] Specify retained installation/revocation custody and guarded staged bootstrap. - [ ] Complete TLS, fork snapshot, signal and build-realm threat models. - [ ] Review the complete trusted-component and policy-placement contract together. - [ ] Fix per-scenario resource budgets and progress/deadline contracts from measured workloads; distinguish ABI/hardware bounds, authorized quotas and accidental hard-coded limitations. - [ ] Define exact self-host success/failure criteria and evidence schema before implementation: source-only inputs, no host build delegation, two clean in-EriX builds, deterministic artifacts, boot result and authority-negative tests. - [x] Define source-only inputs, two complete guest builds and the required guest toolchain rebuild. - [x] Define source/output identity and receipt schemas without claiming guest execution from hashes. - [ ] Complete the end-to-end guest execution, reproducibility, boot and authority-negative evidence schema. - [ ] Extend inventories with rootfs authority-bearing files/signatures, firmware trust enrollment, native build-tool targets, man/help coverage and console/input interfaces; assign each an owning public issue and acceptance test. - [x] Assign public ownership and explicit acceptance requirements for signing, native tools, manuals and console/input extensions. - [ ] Complete their concrete file/interface/trust inventory and test mapping. - [x] Record `v1.0.0-alpha.1` as the intended manually reviewed release baseline, coordinating platform/component version policy without premature version bumps, tags, PR readiness or release publication. </details> ### Whole-codebase authority and quality audit Weight: 8%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/2) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Create an audit register keyed by stable finding ID, repository, file/symbol, category, severity, exact revision, invariant, reproduction, remediation owner, regression test, status and closure evidence. - [x] Retain per-finding source, reproduction, remediation and validation records plus canonical public bug reports. - [ ] Unify all findings into the complete keyed audit register with severity, owner, invariant and closure fields. - [ ] Reconcile every register entry with current source and independent closure evidence. - [ ] Inventory every startup/runtime capability: origin, receiving principal, object, operations, delegation ceiling, lifetime and all aliases. Include boot handoff, service registration, compatibility realms and tools. - [x] Map native VSpace/backing/table and staged-process installation/revocation owners. - [ ] Complete service, device, filesystem, terminal and compatibility runtime capability inventories. - [ ] Reconcile every origin, receiver, operation, alias, delegation ceiling and lifetime. - [ ] Find ambient authority from global selectors, default service discovery, cwd/PATH/env, numeric slots/PIDs, implicit devices, inherited routes, host filesystem fallbacks and cache metadata; replace it with explicit grants. - [x] Correct the validated native mapping/current-caller and explicit host-tool selection boundaries. - [ ] Complete startup/service-discovery, device and inherited-route authority removal. - [ ] Complete cwd/PATH/environment, filesystem and cache authority removal across build/runtime paths. - [ ] Independently validate whole-codebase absence of remaining ambient authority. - [ ] Find residual authority after success, error, cancellation, interruption, timeout, restart, failed reply/transfer, fork, exec and teardown. Prove every alias is retired or its necessary retention is documented. - [x] Implement and test retained native invocation, process and mapping cleanup ownership. - [x] Retain table allocations through publication/rollback and preserve backing through withdrawal. - [ ] Complete live private-root/CPU residency retirement and remaining consumer-loss paths. - [ ] Complete realm/fork/exec/interrupt/restart/transfer teardown and final alias audit. - [ ] Find unwanted explicit authority: oversized startup inventories, broad provider/admin endpoints, duplicate aliases, unnecessary read/write/exec rights and debug routes. Attenuate/remove it even when technically explicit. - [x] Implement root-capability-free staged construction and explicit install-grant attenuation. - [ ] Complete minimum runnable mediator/client bootstrap inventories and retire setup aliases. - [ ] Audit and minimize all remaining service, provider/admin, device and debug grants. - [ ] Audit generation reuse, replay, stale pending replies, confused deputy paths, endpoint impersonation and TOCTOU around path/object resolution. Test forged descriptive identity without the corresponding capability. - [x] Bind native owned invocation and terminal observation to actual caller/process generations. - [x] Validate native stale-generation, forwarded-sender, object-reuse and exact-grant controls. - [ ] Complete path/provider/realm replay and TOCTOU coverage across the remaining codebase. - [ ] Audit cleanup failure behavior: attempt independent retirements, preserve existing caller-specific error precedence, including cleanup uncertainty overriding the triggering error, and quarantine/terminate when required; never continue serving with an unaccounted grant. - [x] Implement acknowledged native terminal/retirement progress and retained cleanup failure ownership. - [ ] Complete ordinary consumer loss, running mediator retirement and independent provider cleanup. - [ ] Audit all callers for error precedence, quarantine and absence of unaccounted grants. - [ ] Audit unsafe code, FFI, wire parsing, range arithmetic, initialization, lifetimes, locks, interruption and publication order; give each unsafe block an exact safety argument and adversarial test where practical. - [x] Correct and validate owned hardware-table storage, geometry, rollback and publication boundaries. - [x] Validate the implemented C byte/string FFI and compatibility scalar/wire boundaries. - [ ] Complete the remaining unsafe, parsing, arithmetic, lifetime and concurrency audit. - [ ] Independently review every safety argument and applicable adversarial control. - [ ] Inventory redundant implementations, dead/fallback code, duplicated validators, obsolete wrappers and deprecated public/wire APIs with all callers. - [x] Identify duplicate memory-runtime ownership, retired invocation selectors and superseded frame-checker paths. - [ ] Finish the whole-codebase redundant/dead/fallback/API inventory with every caller. - [ ] Migrate callers and remove deprecated APIs/compatibility shims in coordinated signed graphs; test rejection of retired versions without silent permissive fallback. Do not retain an obsolete API solely to avoid caller edits. - [x] Migrate the native generation-bound invocation/terminal selectors and reject retired wire forms. - [x] Remove duplicate Integration memory implementations and superseded shell checker APIs. - [ ] Finish migration and removal of all remaining deprecated APIs and compatibility shims. - [ ] Validate the complete final consumer graph and retired-version refusal. - [ ] Classify every hard-coded size/count/depth/time restriction as ABI, hardware, explicit resource policy or accidental implementation limit. Replace accidental limits with checked caller-sized storage or authorized allocation. - [x] Remove the identified fixed owned-table storage ceiling with checked geometric ownership growth. - [ ] Classify all other size/count/depth/time bounds as ABI, hardware, explicit policy or incidental. - [ ] Replace remaining incidental limits with owned storage and preserved exhaustion behavior. - [ ] Test above every removed old boundary and at exact allocation/ABI boundaries; preserve resource exhaustion errors, denial-of-service protection and mandatory bounded waits instead of interpreting “no arbitrary limits” as “unlimited resources”. - [x] Validate expanded native table/mapping boundaries and allocation/rollback exhaustion controls. - [ ] Cover every remaining removed boundary, exact ABI/allocation endpoint and bounded-wait policy. - [x] Inventory all authored code files at/over 1,000 physical lines, including tests, scripts and generated-source templates. Refactor them into cohesive modules below 1,000 lines, preserving meaningful APIs and tests. - [x] Add a deterministic tracked-source size gate; exclude only genuine non-code data/external payload archives, not large authored tests or fixtures containing executable logic. Split generators and their generated code too. - [x] Run deterministic tracked-source file-size censuses including tests and authored scripts. - [x] Promote the reviewed classification into a maintained source-size gate. - [x] Add negative fixtures and CI coverage for authored/generated code without broad exclusions. - [ ] Audit production versus integration/dev-only feature gating and linked symbols. Move/delete remaining test orchestration/diagnostics from production rootd; carry every retained move/delete classification to closure. - [ ] Re-measure rootd semantic surface using the maintained baseline tooling; compare same-toolchain code size, imports, unsafe blocks, accepted messages and authority inventory, not incomparable historical LoC estimates. - [x] Retain same-toolchain Rootd code/symbol/authority baseline observations and corrected production audit artifacts. - [ ] Complete the current semantic-surface comparison and every retained move/delete classification. - [ ] Audit bootstrap service ownership and release/development authority parity; prevent new compatibility work from adding policy or routine test orchestration back into rootd. `initd`/bootd-style work stays Phase 7.3. - [ ] Audit all performance findings through [Integration profiler and measured optimization](https://git.erikinkinen.fi/erix/integration/issues/3) evidence before changing algorithms; deduplicate measured hot paths without caching successful access checks, broadening grants or leaving invalidatable state unowned. - [x] Measure and validate native invocation lookup/settlement improvements without cached authorization. - [x] Measure and remove repeated host frame-checker parsing/analysis work. - [ ] Finish causal mapping/startup optimization with unchanged end-to-end timing acceptance. - [ ] Complete measured build-workload optimization and whole-codebase performance review. - [ ] Audit build/CI scripts for secret exposure, mutable shared outputs, symlink escapes, unsafe deletion, unbounded subprocesses, silent warning suppression and accidental host dependencies. - [x] Correct demonstrated host-tool selection, source identity, subprocess and output-ownership defects. - [ ] Complete all build/CI script secret, symlink, deletion, shared-output and dependency audits. - [ ] Validate final script custody and warning behavior across the complete build closure. - [ ] Repeat the entire audit on final heads, independently review all security closures, and require zero unresolved in-scope authority, deprecated API, undocumented-code and over-1k-code findings before Phase 6 acceptance. - [ ] Inventory obsolete planning/migration documents, manifests, scripts, CI jobs, feature flags and migration-only tests, including dynlink migration checks and the superseded local planning archive. Preserve necessary evidence in historical artifacts/issues, then delete obsolete active files and references; retain current specifications and security assertions, not obsolete scaffolding. - [ ] Remove superseded static executable intake from every public launch, loader, policy, configuration and test path now replaced by dynlink intake. Map each former useful assertion to maintained coverage, reject retired input, and preserve genuinely required mount/bootstrap mechanisms with explicit scope. Inspect real consumers: a shared segment type used by dynamic materialization or the EFI loader's pre-runtime boot contract is not removed by name alone. - [ ] Audit symbols, filenames, flags, wire names and diagnostic tokens for milestone terminology; replace planning-based naming with semantic responsibility names and update all consumers/tests atomically. Allow useful historical comments/docs and real algorithmic concepts, not executable planning APIs hidden behind an exception. - [ ] Review code navigation, naming, control flow, error paths, module cohesion and inline explanations with a contributor/auditor walkthrough; merge semantically similar files where useful while staying below 1,000 lines. - [x] Split and document the changed Kernel, Integration and shell checker modules by responsibility. - [ ] Complete contributor/auditor walkthroughs of naming, control flow and errors in remaining components. - [ ] Finish justified consolidation and verify whole-code navigation and cohesion. - [ ] Identify repeated behavior across repositories suitable for an authority-free shared library; document genuine common semantics, variation, dependencies and boundaries before extracting it. Do not abstract merely similar syntax or combine unrelated trust domains. - [ ] For each justified extraction, create a new Forgejo repository from `meta` first, clone/branch it, implement documented/tested shared APIs, migrate callers, remove duplicates, and add catalog/CI/manual/man-page/audit/PR entries. Add explicit checklist rows for every resulting repository and use exact dependency commit pins without circular service/library dependencies. - [ ] Complete the authority, lifecycle, quality and documentation audit for `blockd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/blockd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `boot-tool`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/boot-tool/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [ ] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [ ] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `bootloader`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/bootloader/issues/2). [profile deadline](https://git.erikinkinen.fi/erix/bootloader/issues/7). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `coreutils`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/coreutils/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [ ] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [ ] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `crashd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/crashd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `deviced`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/deviced/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `docs`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/docs/issues/2). [API conversion design](https://git.erikinkinen.fi/erix/docs/issues/14) · [artifact publication design](https://git.erikinkinen.fi/erix/docs/issues/16) · [generated Coreutils note](https://git.erikinkinen.fi/erix/docs/issues/15) · [publisher startup](https://git.erikinkinen.fi/erix/docs/issues/17) · [manual builder](https://git.erikinkinen.fi/erix/docs/issues/18) · [TLS fixture parser](https://git.erikinkinen.fi/erix/docs/issues/19) · [publisher clock](https://git.erikinkinen.fi/erix/docs/issues/20). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [ ] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [ ] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `drv-acpi`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/drv-acpi/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `drv-i8042`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/drv-i8042/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `drv-ps2-keyboard`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/drv-ps2-keyboard/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `drv-ps2-mouse`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/drv-ps2-mouse/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `drv-rtc-cmos`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/drv-rtc-cmos/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `drv-serial`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/drv-serial/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `drv-virtio-block`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/drv-virtio-block/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `dynlinkd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/dynlinkd/issues/2). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `e2fsd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/e2fsd/issues/1). [Checker fixture collision](https://git.erikinkinen.fi/erix/e2fsd/issues/24). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `exsh`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/exsh/issues/2). [Signature certification diagnostics](https://git.erikinkinen.fi/erix/exsh/issues/17) must be resolved under the existing independent key/fingerprint contract. - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [ ] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `extop`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/extop/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `fatd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/fatd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `fbcond`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/fbcond/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `hotplugd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/hotplugd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `inputd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/inputd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `integration`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/integration/issues/11). [reserved signal admission](https://git.erikinkinen.fi/erix/integration/issues/118) · [parser fixture inputs](https://git.erikinkinen.fi/erix/integration/issues/119). [Native compiler prerequisite](https://git.erikinkinen.fi/erix/integration/issues/120). [Cargo catalog alignment](https://git.erikinkinen.fi/erix/integration/issues/121). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [ ] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `irqd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/irqd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `kernel`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/kernel/issues/2). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `keyd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/keyd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `launchd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/launchd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-aes`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-aes/issues/1). [fixed-work arithmetic](https://git.erikinkinen.fi/erix/lib-aes/issues/3). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-block`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-block/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-bootimg`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-bootimg/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-bootstrap`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-bootstrap/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-capabi`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-capabi/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-cli`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-cli/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [ ] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [ ] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-console`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-console/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-constant-time`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-constant-time/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [x] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [x] Complete the authority, lifecycle, quality and documentation audit for `lib-crc`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-crc/issues/1). - [x] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [x] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [x] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [x] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-deflate`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-deflate/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-device`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-device/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-driver`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-driver/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-dynlink`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-dynlink/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-ed25519`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-ed25519/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-elf`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-elf/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-fs-crypto`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-fs-crypto/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-fs-name`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-fs-name/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-handoff`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-handoff/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-input`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-input/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-interrupt`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-interrupt/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-ipc`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-ipc/issues/1). [Counted filesystem, bootstrap and launch path migration](https://git.erikinkinen.fi/erix/lib-ipc/issues/9) coordinates removal of the remaining fixed-width APIs and their callers. - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-log`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-log/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-partition`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-partition/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-service`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-service/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-sha2`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-sha2/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-stdio`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-stdio/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-time`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-time/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-tty`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-tty/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-vfs`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-vfs/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `loaderd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/loaderd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `logd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/logd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `memd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/memd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `meta`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/meta/issues/3). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `named`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/named/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `pagerd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/pagerd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `powerboxd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/powerboxd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `probed`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/probed/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `procd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/procd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `ramfsd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/ramfsd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `rootd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/rootd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `seriald`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/seriald/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `sha2-tool`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/sha2-tool/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [ ] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [ ] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `timed`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/timed/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `ttyd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/ttyd/issues/2). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `vfsd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/vfsd/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `vspaced`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/vspaced/issues/1). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-posixabi`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-posixabi/issues/2). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-cstd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/lib-cstd/issues/2). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `posixd`, including required tests and original CI; justify non-applicability per dimension. [Repository audit](https://git.erikinkinen.fi/erix/posixd/issues/4). - [ ] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [ ] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [ ] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. - [ ] Complete the authority, lifecycle, quality and documentation audit for `lib-owned-region`, including required tests and original CI; justify non-applicability per dimension. [Shared library](https://git.erikinkinen.fi/erix/lib-owned-region/issues/1). - [x] Complete capability, alias, replay, cleanup, unsafe/FFI and error-ordering audit. - [x] Complete redundancy/deprecated-API, incidental-limit, feature-boundary and performance review. - [x] Verify current authored code files remain below 1,000 physical lines. - [x] Inventory direct crate-root missing_docs declarations, or establish that this repository has no Rust target. - [x] Complete meaningful public/private inline documentation and all applicable lint-coverage review. - [x] Complete applicable component format/lint/test/build/documentation checks recorded locally or by original CI. - [x] Observe successful original component CI for this exact current feature head. - [ ] Reconcile complete warning-free logs, applicable consumer/VM gates and independent repository closure. </details> ### Rustdoc, missing_docs and documentation Weight: 5%. [Owning issue](https://git.erikinkinen.fi/erix/docs/issues/1) · [docs PR 4](https://git.erikinkinen.fi/erix/docs/pulls/4). <details> <summary>Checklist</summary> - [x] Inventory every crate root and target, including binary-only, build-script, test/example and nested crates; identify existing missing_docs enforcement and every local allow/expect/doc-hidden escape. - [ ] Document crate/module purpose, trust boundary, owned/borrowed state, lifecycle, authority and error contracts using `//!`/`///` rustdoc comments. - [x] Document the changed native ownership, invocation and hardware-table module contracts. - [x] Document implemented compatibility scalar/wire and C byte/string module boundaries. - [ ] Finish remaining service, driver, filesystem and terminal module lifecycle/authority contracts. - [ ] Complete crate/module documentation for added runtime/toolchain/build implementations. - [ ] Document every public item, field, variant, constant, associated item, macro and FFI export with semantics, units, ranges and failure behavior. - [x] Document and regenerate the implemented shared ABI, native invocation and C runtime API slices. - [ ] Review semantics, units, ranges and errors for every remaining existing public item. - [ ] Complete public item documentation for remaining Phase 6 implementations. - [ ] Document private functions, structures, fields and non-obvious algorithms as well; explain concurrency, mutation order, cleanup, complexity and invariants. `missing_docs` alone is not a private-code completeness audit. - [x] Document changed native table/cleanup algorithms and profiler/frame-checker internals. - [ ] Review remaining private functions, structures, fields and algorithms across all repositories. - [ ] Complete private concurrency, mutation, cleanup and complexity documentation for later implementations. - [ ] Give unsafe APIs `# Safety`, and fallible/panicking APIs accurate `# Errors`/`# Panics` sections where applicable. Document each unsafe block's concrete invariant and why safe alternatives do not cover the operation. - [x] Document implemented C FFI pointer/link contracts and changed native unsafe ownership boundaries. - [ ] Complete every remaining Safety/Errors/Panics contract and unsafe-block argument. - [ ] Independently review arguments against actual error, panic and safe-alternative behavior. - [ ] Enforce `#![deny(missing_docs)]` or an equally non-bypassable shared lint policy in every EriX-authored crate/target; reject weakening attributes. Do not use blanket allowances, dummy comments or doc-hidden to pass the gate. - [x] Verify direct missing_docs denial declarations in all current authored crate roots. - [x] Scan current tracked Rust for lint weakening and hidden-documentation escapes. - [x] Enforce rejection of weakening attributes in the maintained whole-source policy. - [ ] Finish meaningful-documentation review and enforcement for all remaining targets. - [ ] Add private-item documentation review/check coverage and run Rustdoc with `--document-private-items`; validate broken links and examples with `RUSTDOCFLAGS="-D warnings"` across supported target/feature profiles. - [x] Run warning-denied private rustdoc in the changed component validation matrices. - [ ] Complete private-documentation review/check coverage across all repositories. - [ ] Verify links/examples and every supported target/feature profile in the final graph. - [ ] Ensure CI actually checks missing_docs in default and alternate feature builds, not only one public-library configuration; add a negative fixture proving undocumented public API fails the shared policy check. - [x] Run existing default/alternate-feature strict CI for the implemented component checkpoints. - [x] Add a shared negative fixture proving undocumented public API fails policy. - [ ] Complete all crate/target/feature enforcement coverage and reject bypasses. - [ ] Document non-Rust authored code inline in its language's supported comment format, including shell/Python tools and assembly boundary contracts. Do not pretend rustdoc parses unrelated languages. - [x] Document the changed Python/Shell owners, profilers/checkers and C runtime assembly boundaries. - [ ] Complete meaningful inline documentation in remaining non-Rust authored code. - [ ] Review documentation for new generators, packaging and runtime boundary code. - [x] Update `meta` standards/templates and propagate necessary policy changes deliberately. Repair stale canonical GenAI policy links to `docs/policies/generative-ai-contributions.md`; keep attribution optional. - [ ] Update README/ARCHITECTURE/ROADMAP and relevant manual chapters for each implemented ABI, realm, POSIX service, toolchain, profiler and build step; keep historical measurements separate from current guarantees. - [x] Update canonical component and manual contracts for implemented ABI/libc, native custody and profiler work. - [ ] Complete documentation for remaining realm/POSIX/toolchain/build functionality. - [ ] Reconcile all final component documents and manual guarantees with current behavior. - [ ] Regenerate API references with the [native Rustdoc JSON producer](https://git.erikinkinen.fi/erix/integration/issues/197), test examples, build the whole manual, check final warnings/overflow/links and visually inspect changed rendered pages. Record toolchain/source provenance for the generated documentation. - [x] Generate source-bound API references for the implemented interface checkpoints. - [x] Build and test the current full manual with final warning/layout and changed-page visual checks. - [ ] Regenerate and validate every remaining Phase 6 interface/example and the final complete manual. - [ ] Update canonical templates and every repository README to remove current-status/progress/checkpoint sections; put concise current state in ROADMAP/ARCHITECTURE and detailed historical evidence in linked issue/reports. - [ ] Refactor long README/ARCHITECTURE/ROADMAP paragraphs and exhaustive lists into short summaries plus focused design/API/operator documents. Preserve canonical headings, discoverability and normative invariants; do not hide important authority limitations or move status into another README section. - [x] Extract focused ownership, bootstrap, profiler and build-scope design/operator documents. - [ ] Remove remaining exhaustive progress prose from canonical component documents. - [ ] Review all canonical headings, concise summaries and links without hiding limitations. - [ ] Keep help text, man pages, rustdoc, C headers, IPC specifications and technical manual consistent through shared semantic metadata where useful; validate coverage and examples, not merely that generated files exist. </details> ### Integration profiler and measured optimization Weight: 5%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/3) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Inventory existing READY/command timers and private QMP/PC evidence; define which collectors are reusable, incomplete, obsolete or unsafe to retain. - [x] Inventory maintained READY/command timers and the named historical QMP/PC captures. - [ ] Complete the reusable/incomplete/obsolete/unsafe classification and all retained diagnostic dispositions. - [ ] Specify a versioned profile format with source/image/config hashes, toolchain, hardware/QEMU/acceleration/CPU/memory/worker settings, time domain, capture interval, exact process generation and module identity. - [x] Version host startup metadata, source/image/configuration hashes and timing/resource fields. - [x] Record native host workload and exact executed-code capture identities with explicit attribution limits. - [ ] Complete authenticated guest process-generation/module identity and full build profile contracts. - [ ] Define explicit capture authority, lifecycle and permitted fields; exclude key material, capability contents, consent input and arbitrary process memory. Diagnostics must not confer process control or namespace access. - [x] Define explicit bounded host capture inputs, permitted scalar/code fields and owned teardown. - [x] Exclude implicit guest control/memory mutation, secrets and consent data from maintained host interfaces. - [ ] Define and validate any required guest capture authority, cross-realm policy and retirement. - [x] Add a bounded host collector with hard/silence limits, owned PID cleanup, interruption handling, raw-log preservation and true failure status. - [ ] Implement exact image/ELF/PT_LOAD/source binding and symbolization; reject stale maps and ambiguous userspace addresses without process/module identity. Do not infer process ownership from an overlapping virtual address. - [x] Bind startup admission to original source/features and exact packaged image/artifact bytes. - [x] Match TCG captured code to exact executable load bytes and symbols while retaining ambiguity. - [ ] Bind userspace attribution to actual process generation/module ownership and reject stale identities. - [ ] Add authenticated, opt-in guest timing/counter hooks where host samples cannot attribute a cost; compile/runtime gate them appropriately and prove their absence from clean release images when disabled. - [ ] Record boot service stages: image resolution/read, relocation, mapping/materialization, process start, startup delivery, initialization, publication, cleanup, final READY and full shell-caret display. - [x] Capture ordered service READY barriers, final readiness and the full shell caret. - [ ] Attribute image resolution/read, relocation, materialization and process start. - [ ] Attribute startup delivery, initialization, publication and cleanup within each service. - [ ] Record command stages: Enter acceptance, parse/expand/resolve, authority request/decision, file reads, link/load, spawn/scheduling, first execution/output, output drain, exit/wait and fresh caret. - [x] Retain the actual native command transcript, command interval and fresh-caret observations. - [ ] Attribute input, parse/expand/resolve, authority and file/link/load stages. - [ ] Attribute spawn/scheduling, execution/output, drain, exit and wait stages. - [ ] Measure IPC count/bytes/waits, runnable versus blocked time, context switches, mapping scans/batches, page allocation/faults, VFS/provider fanout, block request size/LBA, cache hits/misses and TTY/framebuffer work. - [x] Measure actual native invocation workloads and preserve setup/operation/cleanup counts and times. - [x] Record real task CPU counters separately from wall time and TCG instruction upper bounds. - [ ] Complete runnable/blocked, context-switch, allocation/fault and mapping counter attribution. - [ ] Complete VFS/block/cache and terminal/framebuffer measurement coverage. - [x] Bound buffers through explicit resource policy, report dropped records, clock discontinuities and partial captures; never label incomplete data a complete profile or fabricate a percentage of total CPU time. - [ ] Implement reproducible reports: service timeline, command critical path, per-component counts, latency distributions and symbol/sample summaries. Separate wall time, CPU time, blocking time and sampling observations. - [x] Produce bounded reproducible startup timelines and conservative command timing reports. - [x] Produce native workload distributions and exact-code/symbol candidate summaries. - [ ] Complete per-component guest critical paths and separate CPU/blocking/wall-time reports. - [ ] Add deterministic parser/attribution/error fixtures, malformed/stale identity tests, dropped-record tests and collector cancellation/timeout tests. - [x] Test host parser framing, stale/malformed inputs, budgets, discontinuities and partial captures. - [x] Test collector cancellation, timeout, process cleanup and real executed-code fixture admission. - [ ] Complete authenticated guest-generation/module attribution and cross-realm error fixtures. - [ ] Add VM profiler tests that identify known synthetic CPU, wait and I/O workloads, reject cross-realm capture and verify all capture authority is retired. Compare profiled versus unprofiled overhead without subtracting it from acceptance measurements. - [x] Run the real QEMU plugin fixture for known executed code, counters and bounded output refusal. - [ ] Identify guest CPU, wait and I/O workloads with actual authenticated ownership. - [ ] Prove cross-realm capture denial and complete authority retirement. - [ ] Complete profiled/unprofiled overhead comparison under unchanged acceptance bounds. - [ ] Establish controlled cold/warm startup and build baselines with isolated repeats, explicit resource limits and confidence/variance reporting. Preserve the stricter carried [Phase 5 handoff and remaining gates](https://git.erikinkinen.fi/erix/integration/issues/6) startup thresholds without moving endpoints. - [x] Retain controlled native host workload comparisons and original failed startup/control observations. - [ ] Establish complete cold/warm startup baselines with the required isolated repeats and variance. - [ ] Establish full compiler/build baselines under explicit resource and deadline policies. - [ ] Rank evidenced bottlenecks by measured end-to-end impact; create individual [Whole-codebase authority and quality audit](https://git.erikinkinen.fi/erix/integration/issues/2) findings with one causal hypothesis, owner and acceptance test. - [x] Rank native invocation/checker costs and exact-code mapping/switching candidates with documented limits. - [ ] Establish end-to-end impact and causal findings for complete startup and build workloads. - [ ] Optimize the highest-impact proven path, then reprofile and repeat: inspect loader/provider fanout, mapping/process startup, event waits, build dependency scheduling and terminal delivery according to evidence, not guesses. - [x] Implement and reprofile validated native invocation lookup/settlement improvements. - [x] Implement and reprofile measured host checker parsing/analysis improvements. - [ ] Complete measured startup-path improvement under the original guest timing oracle. - [ ] Profile and optimize remaining full build, I/O, scheduling and terminal bottlenecks. - [x] Eliminate repeated parser and runtime test fixture compilation through borrowed callbacks; retain original semantics and match both compiler profiles. All fourteen ordinary dev/release selections and strict host/native controls pass under unchanged limits; current CI unit/checker controls pass while the separate native frame proof remains open. [Implementation](https://git.erikinkinen.fi/erix/exsh/commit/ef26d89c45e7b65534e8157df0307edd36b73132), [compiler issue](https://git.erikinkinen.fi/erix/exsh/issues/9), [pull request](https://git.erikinkinen.fi/erix/exsh/pulls/3). - [ ] For each optimization, prove unchanged authorization, revocation, permissions, object identity, failure ordering, output semantics and fairness; retain strict tests and isolated same-configuration before/after measurements. - [x] Retain authorization/revocation/error-ordering controls and same-configuration measurements for accepted lookup/checker changes. - [ ] Complete equivalent semantic and isolated before/after proof for remaining startup/build optimizations. - [ ] Reconcile all optimization findings against the final original-source graph. - [ ] Add reviewed startup/build throughput and resource regression budgets to CI, using dedicated uncontended performance jobs and calibrated full-build deadlines. Ordinary functional jobs still have forced stall limits. - [x] Preserve and exercise the existing strict startup oracle and functional stall limits. - [ ] Add calibrated build-throughput/resource budgets and dedicated uncontended CI performance jobs. - [ ] Remove superseded diagnostic hooks/helpers and document how to capture, interpret and reproduce profiles. Keep only evidence-backed tooling. - [x] Document maintained startup, native workload and executed-code capture/report procedures. - [ ] Retire every superseded diagnostic implementation and finish reproducibility coverage. </details> ### POSIX ABI Weight: 3%. [Owning issue](https://git.erikinkinen.fi/erix/lib-posixabi/issues/1) · [lib-posixabi PR 3](https://git.erikinkinen.fi/erix/lib-posixabi/pulls/3). <details> <summary>Checklist</summary> - [ ] Define x86_64 C ABI sizes, signedness, alignment, byte order, calling conventions, structure layouts and ABI version negotiation. - [x] Define and independently probe implemented x86_64 LP64 scalar sizes, alignment and C call declarations. - [ ] Complete all required structure layouts, calling contracts and ABI version negotiation. - [ ] Define errno values and a complete native-error mapping table, including missing authority, absence, unsupported operation, interruption, would-block, exhaustion, stale identity and partial I/O. - [x] Define checked errno scalar values and explicit contextual native-completion classification. - [ ] Complete operation-specific native error mappings for all POSIX workloads. - [ ] Validate interruption, partial I/O and cleanup/error precedence through real adapters. - [x] Define fd/open-description, PID/process-generation, process-group, session, thread and realm identifiers as non-authoritative compatibility data. - [ ] Define file/status/mode/credential/ACL, seek/offset, directory, time, signal/action/set, wait and resource-limit types/constants. - [x] Define checked file modes/base status, file offsets and canonical time scalars. - [x] Complete credential/ACL, directory, signal/action/set, wait and resource-limit surfaces. Live sets/actions, client-local labels and mask/entry calculations are implemented, with compatibility1.10 action/mask/self-generation/handoff codecs. Remaining surfaces and full runtime obligations keep this substep open. - [ ] Bind those definitions to trusted metadata and required runtime operations. - [ ] Define IPC shapes with exact validation, request correlation, version/reserved-field rules and normalized capability transfer expectations; keep pure ABI parsing free of syscalls or service lookup. - [x] Implement the version-query wire codec with checked framing and authority-free parsing. - [x] Implement compatibility 1.1 Read/Write/Close wire codecs with exact framing, full correlation, counted payloads and atomic encoding. - [ ] Complete remaining POSIX operation request/reply shapes and correlation/version/flag rules. - [ ] Validate capability-transfer expectations through the native consumer adapters. - [ ] Define checked 64-bit file/time arithmetic, C pointer/length handling, integer conversion and deterministic overflow/error behavior. - [x] Implement checked full-width file/time arithmetic and canonical timespec normalization. - [x] Implement numeric byte-extent overflow checks without manufacturing pointer authority. - [ ] Complete operation sentinels, C pointer intake and native adapter semantics. - [ ] Provide reviewed C header declarations corresponding to Rust ABI definitions; test layout/constant agreement with independent C and Rust probes. - [x] Publish C declarations and independent C/Rust probes for implemented scalar/status interfaces. - [ ] Complete headers and layout/constant agreement for the remaining POSIX ABI. - [ ] Test malformed/old versions, unknown flags, invalid identifiers, overflow, nonzero reserved fields, extra capabilities and noncanonical errors. - [x] Test malformed versions/flags/reserved fields, invalid scalars and arithmetic boundaries in implemented codecs. - [ ] Complete all operation-specific malformed input, extra-capability and error-canonicalization controls. - [ ] Publish documented ABI compatibility rules and pass strict crate, header, cross-target and exact-head CI gates before consumers depend on it. - [x] Publish implemented compatibility contracts and pass strict host/header/freestanding component CI. - [ ] Complete ABI-wide compatibility rules, consumer coverage and final strict validation. </details> ### POSIX service and realm lifecycle Weight: 6%. [Owning issue](https://git.erikinkinen.fi/erix/posixd/issues/1) · [posixd PR 5](https://git.erikinkinen.fi/erix/posixd/pulls/5). <details> <summary>Checklist</summary> - [x] Specify per-realm/per-process ownership and isolation inside `posixd`; separate private native service routes from each client's narrow authenticated ingress and reject numeric-realm impersonation. - [x] Implement create/configure/seal/start/abort/retire realm states with generation-bound identities, validated resource ceilings and exact rollback. - [x] Implement root-capability-free native staged process construction with exact identities and rollback. - [x] Implement authenticated Procd/Launchd install-grant return and guarded unstarted preparation. - [x] Implement native ancestor/nested revocation custody and acknowledged terminal primitives. - [x] Install counted minimum startup/configuration receivers and acknowledge setup-authority disposal. - [x] Execute the actual Posixd mediator and authenticate receiver readiness. - [x] Implement pure counted configuration, ordinal pull, client startup and seal/terminal codecs with complete scalar correlation. - [x] Implement the native Posixd counted configuration, receiver admission, seal and byte-I/O consumer with host fault controls, strict component CI and verified debug/release executable layout. - [x] Complete Launchd runtime orchestration and coordinated producer/consumer adoption, then configure/seal/publish the realm and perform mediated client I/O in the native witness. - [x] Complete remaining abort/retire, supervisor-loss and resource-ceiling validation. - [x] Implement and validate the native RCS1 byte-client executable, including complete startup/capability census and retained byte-call custody. Component evidence: [Posixd 1aa9b76](https://git.erikinkinen.fi/erix/posixd/commit/1aa9b76fa61adee3e0e87f61dfcd6df720b4b30c),58 tests in four profiles, CI31/32. - [x] Implement and validate counted Launchd client rows, canonical plan storage, two-column capability reservation and LCH1 V4/88 admission. Component evidence: [Launchd f403dde](https://git.erikinkinen.fi/erix/launchd/commit/f403ddea50d33fa64deaff73227c60c93366df8c),403 tests in six selections, CI157/158. - [x] Implement and validate Loaderd root-derived layout binding, distinct client preparation and original process/linker/staged cleanup owners. Component evidence: [Loaderd e0562cd](https://git.erikinkinen.fi/erix/loaderd/commit/e0562cdc6a52b518ea7fe34341a49f57caa9b1d8),142 tests in four profiles, CI105/106. - [x] Implement and validate Procd counted client provisioning, seal, terminal/disposal notification and nonconsuming final CPU READ/ACK. Component evidence: [Procd 3b84f4b](https://git.erikinkinen.fi/erix/procd/commit/3b84f4b0155525876f1c79ca55171cddcb501adc),380/386 total tests per profile, CI312/313. - [x] Implement and validate Posixd's distinct never-started client disposal, retained through configuration with exact binding/delivery/receiver retirement and fixed control-reply custody after failed COMPLETE. Component evidence: [Posixd 3541ce5](https://git.erikinkinen.fi/erix/posixd/commit/3541ce5d621bfbf32e89df1882c3b15cb5ecd707),64 tests in four profiles, CI33/34. - [x] Implement and component-validate Launchd guarded client preparation, separate grant/provider custody and unstarted private Retire/Read/Ack cleanup with original native RELEASE and unknown-creation quarantine while independent peers retire. Current-source evidence: [Launchd 21635dba](https://git.erikinkinen.fi/erix/launchd/commit/21635dba3b5cf69b401129a8916eb7854647ddb8),451 tests in six selections, CI167/168. - [x] Implement and component-validate public canonical plan append and freeze with original caller/member admission, immutable record order, complete uniqueness/coverage/ring checks and accepted-effect loss cleanup. Remove the profiled quadratic validation bottleneck with exact byte restoration. Current-source evidence: [Launchd 21635dba](https://git.erikinkinen.fi/erix/launchd/commit/21635dba3b5cf69b401129a8916eb7854647ddb8),451 tests in six selections, CI167/168. - [x] Implement and component-validate counted stopped-client provisioning through public Start: exact grant/receive custody, complete startup hashing, ordered descriptor streaming, native RELEASE between stages and all client Commits before mediator Start. Preserve cancellation, unknown invocation and independent original cleanup; no client execution is claimed. Current-source evidence: [Launchd 21635dba](https://git.erikinkinen.fi/erix/launchd/commit/21635dba3b5cf69b401129a8916eb7854647ddb8),451 tests in six selections, CI167/168. - [x] Implement and component-validate authenticated configuration pulls after counted PrivateReady, with exact original context/order, immutable records, original RECV-only COPY and retained source/serving custody. Preserve malformed/lost-call cleanup and bounded idle progress without client execution. Current-source evidence: [Launchd 8a3b6a0b](https://git.erikinkinen.fi/erix/launchd/commit/8a3b6a0bb2558e92802cf28c6e1e2762face74c7),461 tests in six selections, CI169/170. - [x] Implement and component-validate public two-sided seal with original supervisor/cohort admission, continued configuration pull progress, exact Prepared and native RELEASE before original RECV/setup source disposal, and complete absence before CommitSeal. Retain failures and unknown custody; acknowledge Sealed only after exact result and original caller retirement. Current-source evidence: [Launchd 2fd8dff1](https://git.erikinkinen.fi/erix/launchd/commit/2fd8dff154d1ca35724284c2e8c82f606c659f8a),472 tests in six selections, CI171/172; [Docs c63da0d8](https://git.erikinkinen.fi/erix/docs/commit/c63da0d8b066b777e88aaea369be1b8eca3d3cb4),45 tests, full manual/visual checks and CI1079/1080. - [x] Implement and component-validate original sealed-client Start, role-preserving private WAIT and full terminal outcomes through retirement. Retain separate original supervisor/controller identities; commit checked client CPU once before exact ACK and original caller RELEASE. Preserve unknown custody, public/parent loss, independent event/accounting arrival, overflow and ACK loss; idle WAIT and completed mediator cleanup must yield without spinning. Current-source evidence: [Launchd d226af9c](https://git.erikinkinen.fi/erix/launchd/commit/d226af9cb8f47cec751702dcd040bda340274ea1),487 tests in six selections, CI175/176; [Launchd issue 9](https://git.erikinkinen.fi/erix/launchd/issues/9) corrected with producer-consistent red/green and substitution controls. - [x] Implement and component-validate mediator final Read/local once-only CPU recording/exact Ack with original native caller RELEASE before full retirement. Preserve the original supervisor, actual spontaneous event, distinct positive nonexecution, unknown/lost callers and checked overflow. Share checked aggregation between separate client and mediator lifetime sinks; native managed-row reuse is recorded below; final CPU/profiler values remain open. Current-source evidence: [Launchd 0b0788b5](https://git.erikinkinen.fi/erix/launchd/commit/0b0788b5530ce7607097eee97babe22e71d8c1b9),496 tests in six selections, CI177/178. - [x] Execute the native configured-client witness with an exact resident process budget, replace a retired realm while its peer stays live, reject stale selectors and verify the actual packaged process/paging counts. [Integration 3bfa40a6](https://git.erikinkinen.fi/erix/integration/commit/3bfa40a6978bd9fc811055ad4c89e8d506f7077c) passes with Procd38/Pagerd102,109 artifacts and57045 serial bytes. Final numeric CPU/profiler values and remaining loss/exhaustion gates stay open. - [x] Observe all eleven native final Measured snapshot additions and the surviving Launchd lifetime sums after retirement. Verify original code, actual returns, captured physical storage and inactive user-access denial. All original VM markers, native exit and 120/45-second gates pass without adding guest authority. [Accounting evidence](https://git.erikinkinen.fi/erix/procd/issues/5). - [x] Execute native full-table realm reservation refusal, preserving both sealed peers and all byte-I/O, actual exit, retirement and reuse checks. Verify the retained BootConfig and exact packaged record budgets with the original VM gates; older preparation/startup scenarios also pass. [Native image evidence](https://git.erikinkinen.fi/erix/integration/commit/bdd04a62e0419061f33f850cabca0b6216994545). - [x] Execute separate native client-record and plan-storage exhaustion with valid counts, exact refusals and preserved Guarded/Sealed peers. Require normal configuration before and after reclamation and every original execution, retirement and reuse gate; older preparation/startup VMs pass. [Native image evidence](https://git.erikinkinen.fi/erix/integration/commit/9299aa02c4ad8af3b6448eff316672e53ca5dd60). - [x] Dispose of two fully provisioned native clients before public START, then reuse their exact records while the original peer stays sealed. Preserve absent stale pairs, six actual successful client exits, all capacity refusals and original gates; client, preparation/startup and full CI1824 pass. Positive numerical NeverExecuted accounting remains a separate open requirement. [Native source](https://git.erikinkinen.fi/erix/integration/commit/4246853dfab3cb434f24ca1a169d5be60cf402c9), [CI1824](https://git.erikinkinen.fi/erix/integration/actions/runs/1824), [pull request](https://git.erikinkinen.fi/erix/integration/pulls/12). - [x] Bind read-only source/toolchain roots, output/tmp roots, executable directories, cwd/root selectors and inherited streams from actual receipts. - [x] Implement Vfsd-enforced directory attenuation: pin a new navigation ceiling, optionally remove writes, preserve restrictions through cwd, child resolution, redirection and redelegation, and retire independent provider anchors. Tests authored; execution waived by the user. [Vfsd review](https://git.erikinkinen.fi/erix/vfsd/pulls/3), [wire contract](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2). - [x] Extend canonical counted configuration and deployment storage for typed filesystem and inherited-stream bindings, preserving original generations, explicit counts and immutable plan identity without an incidental fixed cap. Shared framing, Launchd/Posixd custody and Procd target-layout adoption are implemented. RCS1 minor one now includes internal and external stream descriptors with exact frozen-plan counts and original D+A storage bounds. Rootd/Integration/Loaderd/Exsh adoption and the coherent immutable dependency graph are implemented and signed/pushed. The bounded native binding scenario is authored; tests and CI are waived without pass claims. - [x] Derive filesystem endpoints through Launchd's authenticated Vfsd route and streams from original caller I/O owners, retaining receipts and native ownership through publication, release, cancellation and uncertain cleanup. Authenticated directory and stream public preparation, canonical append, native delivery and seal handoff are implemented. Actual owned provider registration/serving and reply framing remain unfinished in [the transport defect](https://git.erikinkinen.fi/erix/integration/issues/100); legacy receivers cannot satisfy the mediator's owned invocation contract. This reopens the parent for code work despite waived testing. Stream request-loss lifetime is separately corrected in [Launchd](https://git.erikinkinen.fi/erix/launchd/issues/12). Testing is waived for completion; authored controls remain unrun. Retain the original root cleanup identity after operation-source disposal; only a correlated private-route provider result discharges that obligation. Dedicated recipient stream views must dispose their own provider custody before BOTH/CANCELLED acknowledgment, independently of offsets/access, while preserving the lender. Ordinary existing proxies are insufficient. - [x] Bind actual Posixd SEND receipts to the frozen plan after exact native receipt/QUERY agreement; reserve custody before effects and require source retirement before seal plus actual DROP/absence before reuse. Consumer intake, lookup, provider/caller/local retirement, complete source handoff and dedicated stream-view production are implemented. Coordinated image adoption remains covered by the separate deployment and publication substeps. Authored controls are unrun; testing is waived for completion. - [x] Author complete positive, replay, read-only, escape, two-realm and cleanup tests plus a bounded native binding scenario; update documentation, coordinated signed revisions and public tracking with testing deferred. Implemented with eleven new test functions and six inherited packaging controls, all unrun. [Scenario and scope](https://git.erikinkinen.fi/erix/integration/src/commit/7f1e4956ed21dbaec68593989e7a129fa0af62be/docs/realm-binding-witness.md), [client review](https://git.erikinkinen.fi/erix/posixd/pulls/5), [shell review](https://git.erikinkinen.fi/erix/exsh/pulls/3). Evidence and remaining scope: [realm binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4). - [x] Implement launch integration that creates a fresh compatibility process context, supplies only its selected routes, and never grants global `named`, provider, device, raw-block or kernel process-control endpoints. - [x] Add exact-executable guarded mediator staging with no ordinary-start fallback. - [x] Create and start the actual compatibility process context with only its selected private routes. - [x] Verify final client/mediator inventories and absence of global/provider/device/control grants. Implemented and audited with original rootless process/grant custody, ingress-only client census and complete final mediator inventory before Prepared. Eight controls are authored but unrun; testing is waived without pass claims. [Current ownership contract](https://git.erikinkinen.fi/erix/posixd/src/commit/5874f330293af475bf4c40c69ef4b94c4a4c4733/docs/realm-ownership.md), [Procd review](https://git.erikinkinen.fi/erix/procd/pulls/2), [Posixd review](https://git.erikinkinen.fi/erix/posixd/pulls/5), [external-count fix](https://git.erikinkinen.fi/erix/procd/issues/10), [empty-table fix](https://git.erikinkinen.fi/erix/procd/issues/11). - [ ] Implement deny-only uid/gid/group/mode/ACL checks after native capability admission; test uid 0, chmod/chown-like metadata and executable permission changes cannot manufacture access or bypass a capability ceiling. - [x] Define checked credential/group and access-ACL views with complete deny-only mode/ACL decisions, no UID-zero bypass, explicit borrowed storage and independent positive/malformed/large-input controls. - [x] Admit trusted per-client credentials bound to the original realm/process generations; request text, inherited environment and UID-zero labels cannot choose another identity or silently change group membership. - [ ] Complete sealed-client filesystem mediation for remaining native operations using trusted metadata and complete ACL evidence on the exact grant; preserve native ceilings under metadata updates, revocation and executable-permission changes. Counted bound-file resizing and directory access are accepted separately below; broader descriptor/pathname and operation-specific effects remain implementation work. - [ ] Author bounded native positive/negative/replay/cleanup coverage, update component/manual contracts and publish coordinated immutable pins, issues/PRs and the master checklist. Testing/CI are waived, not unfinished implementation. - [x] Define explicit retained-provider permission snapshot and conditional-effect wire contracts, distinguishing unknown ownership/ACL evidence from proven absence, with exact framing and atomic refusal controls. - [x] Implement Ramfsd retained-node permission snapshots and conditional truncation, shared per-node revision updates in both metadata setters, stale/restore/exhaustion controls, documentation and signed adoption. - [ ] Complete remaining operation-specific provider conditional effects required by native consumers, retaining full ownership/ACL evidence and the implemented persistent metadata/reference lifetimes. - [x] Implement E2fsd retained snapshots and conditional truncation from original checked inode metadata and complete local access ACLs; retain unique revisions/full fingerprints, invalidate metadata attempts, share resize behavior, author controls and publish documentation/catalog adoption. - [x] Transport complete canonical ACL entries in bounded pages on original retained revisions; implement actual ext dispatch, explicit Ramfsd refusal and caller-storage complete assembly with poison/cleanup semantics. Author controls and publish contracts, manual, coherent pins and tracking. - [x] Implement consumer-side inherited stream invocation custody: original CLAIM client and frozen binding selection, shared offsets, bounded staging, partial I/O/EOF, cancellation, fixed results and dedicated-view Close. Author host/native controls, document and publish the consumer; actual native provider intake is implemented in [provider intake](https://git.erikinkinen.fi/erix/integration/issues/100). - [x] Forward trusted permission snapshots and bounded ACL pages on original job-lifetime directory metadata endpoints; preserve exact operation ceilings, private provider correlation, object-ID rewriting, staging cleanup and owned result custody. Author controls, document and publish coherent pins. - [x] Implement original bound-directory access under sealed effective credentials, actual native write ceilings and complete streamed ACL evidence; retain both invocation owners through cancellation and one-shot completion. Author host/native controls, document and publish coherent signed revisions. - [x] Implement complete ext value-inode ACL acquisition, shared reference retirement and persistent mode/owner coherence; preserve named/default entries, per-reference quota charges, checksums, transaction/fail-stop and original provider epochs. Author media/provider controls and publish signed source, maintained documentation/manual and coherent catalog revisions. Native ACL metadata scenario and independent host-oracle controls are also authored, with separate helper/consumer/catalog identities and execution waived. - [x] Implement the explicit native RESIZE_FILE grant and conditional provider bridge: original file/write ceilings, snapshot/complete ACL pages, fixed result capacity before effects, trusted clock and private correlation, stale/uncertain separation, owned result retention and explicit disposal. Centralize operation recognition across IPC, launch, broker and session without expanding bootstrap defaults. Author 23 controls, update contracts and manual, publish signed immutable dependencies and synchronize tracking. - [x] Implement the complete counted bound-file resize path: authenticated fixed-purpose preparation, original scope/provider/alias custody, frozen per-client bindings, sealed mode/complete ACL policy and exactly-once conditional effect with fixed results and independent cleanup. Share filesystem ownership and permission machinery; remove obsolete APIs. Author 19 new host controls and extend the actual native workload with owner/nonowner/absent-selector cases and independent post-retirement reads. Update contracts/manual, fixture budgets and signed dependencies, fix the nested test module regression, and synchronize issues/PRs/phase tracking. E2fsd retained snapshots and conditional truncation are implemented for complete local access ACLs; [the ext scope](https://git.erikinkinen.fi/erix/e2fsd/issues/7) is closed with seventeen authored, unrun controls and signed catalog adoption. Complete local ACL transport and caller-storage acquisition are implemented in [the entry design](https://git.erikinkinen.fi/erix/lib-ipc/issues/3), with nineteen additional authored/unrun controls. Complete value acquisition, shared cleanup and persistent ACL metadata are implemented; operation-specific conditional native effects and scenario coverage remain open. Metadata policy and trusted credential intake are implemented. The shared provider wire contract and Ramfsd snapshot/conditional-truncation path are implemented, documented and signed, with ten additional controls authored but unrun. Native consumer enforcement and other providers' ACL evidence remain unfinished; the parent stays open. [Design](https://git.erikinkinen.fi/erix/posixd/issues/10), [library review](https://git.erikinkinen.fi/erix/lib-posixabi/pulls/3), [mediator review](https://git.erikinkinen.fi/erix/posixd/pulls/5), [catalog review](https://git.erikinkinen.fi/erix/integration/pulls/12), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4). - [ ] Implement explicit root/cwd/PATH resolution confined to delegated namespace/executable roots; environment text, absolute paths and `..` cannot escape the realm or select an undelegated service. - [ ] Implement resource accounting for process/thread/fd/memory/temp and in-flight work, with deterministic exhaustion and no fixed accidental table cap. - [ ] Implement noninteractive build policy: out-of-envelope operations fail promptly with documented errors, without hanging for a hidden prompt. - [ ] Implement realm teardown on normal exit, crash, denied transfer, launch abort, timeout and supervisor failure; retire all descendants/aliases and prove process/realm generation reuse cannot recover prior authority. - [x] Implement exact staged abort and native process/route lifetime prerequisites. - [ ] Complete running realm teardown for exit, crash, denied transfer and timeout. - [ ] Complete supervisor-loss/descendant cleanup and actual realm-generation reuse refusal. - [ ] Add two-realm isolation VMs for filesystem, process, credentials, descriptors, service routes and teardown; include malicious message replay. - [ ] Package/start `posixd` from ext4 after the required native services; keep compatibility orchestration out of rootd and preserve READY/shell ordering. - [ ] Implement runtime exceptional-authority requests from running compatibility processes through their authenticated launch/realm route; resolve only within the caller's existing delegated selector ceiling. - [ ] Bind every grant to exact process/job/realm generations, resolved object identity, permitted operation and explicit one-shot/invocation/transaction lifetime. Never turn approval into a broad directory or reusable admin grant. - [ ] Extend trusted prompt descriptions for compatibility programs to show executable provenance, operation, object and lifetime; escape untrusted labels and keep labels/argv/paths non-authoritative. - [ ] Preserve automatic same-session secure attention, trusted y/n plus Enter decisions, renderer acknowledgement and fresh-input fences on serial and framebuffer TTYs. Untrusted PTY output cannot approve or spoof a prompt. - [ ] Deliver approved grants to the exact still-running process using explicit caller-local slots and tracked revocable aliases; reject stale, replaced, cancelled or already-exited recipients and clean partial delivery. - [ ] Implement operation-completion/denial/timeout/cancellation/revoke cleanup, including process death during approval and errors after one-shot consumption. No grant remains reusable by a later process or shell command. - [ ] Support exact-entry unlink/rename/truncate and reviewed recursive transaction envelopes; require a fresh explicit policy for any traversal scope, and prove rollback/partial-progress rules without ambient parent-directory write. - [ ] Add interactive VMs for approve, deny, revoke, malformed grant, object replacement, process exit, wrong TTY, replay and two-realm isolation; add a noninteractive build VM proving no prompt or silent escalation occurs. </details> ### Files, descriptors and namespace semantics Weight: 6%. [Owning issue](https://git.erikinkinen.fi/erix/posixd/issues/2) · [posixd PR 5](https://git.erikinkinen.fi/erix/posixd/pulls/5). <details> <summary>Checklist</summary> - [x] Implement per-process fd tables distinct from shared open-file descriptions; record rights, offset, status flags, inheritance and alias count. - [x] Implement open/openat/close and dup/dup2/fcntl duplication with atomic replacement, lowest-free allocation and complete transfer cleanup. - [x] Implement authenticated lowest-free and exact fd duplication, same-fd behavior and independent inheritance flags over shared original access/status/cursor ownership. Connect literal framing, counted producer storage, actual serving, host/native controls, documentation and publication. - [x] Implement nonfinal/final Close and atomic target replacement with retained original source holds, provider/caller/local cleanup, stable generations, cancellation, refused-completion results and terminal disposal. Author failure and alias-lifetime controls and native workloads; publish the coherent signed graph and keep cleanup uncertainty fail-stopped. - [x] Implement dynamic open/openat acquisition under explicit directory authority and native permission evidence, with required creation, access/status flags, complete acquisition/transfer failure cleanup and descriptor installation. Connect producer/consumer/native workloads, contracts/manual, signed dependencies and issue/PR tracking in one pass. - [x] Implement read/write/pread/pwrite/readv/writev and lseek as required, covering zero/short I/O, shared offsets, append atomicity, EINTR and nonblocking. - [x] Implement scalar/vector file I/O with complete direction checks, zero/short progress, shared cursors, one gathered provider-atomic append, explicit signed limits and canonical transient versus uncertain admission. Publish the coordinated codecs/providers/consumer and authored controls. - [x] Implement positioned cursor preservation and SET/CUR/END/DATA/HOLE seeking through fresh original-object size, including write-only admission, signed boundary errors and unchanged state on refusal. Publish contracts, unit controls and the extended native realm workload. - [x] Implement scalar/vector nonblocking streams/channels and retained blocking channels with shared status replacement, zero/short progress, EOF/EPIPE readiness, exact caller cancellation, draining/terminal cleanup and no replay after completion refusal. Publish controls and native peers. - [x] Connect authenticated caught-signal delivery to actual retained I/O, returning EINTR only before progress and preserving positive progress, original native custody and cleanup across interruption and completion races. Implemented: original-supervisor/controller generation with full native identity, generation and digest proof; distinct signal custody without creation rollback; real pending caught state interrupts retained channel/file/stream calls before new effects. Positive progress, fixed results and original provider outcomes/cleanup survive races. Native USR2/callback/mask restoration and meaningful boundary/race controls are authored. - [x] Connect required blocking native-stream readiness through the original provider/description and caller lifetime; remove the current unsupported-mode refusal only when actual readiness and cancellation work. - [x] Implement pipe endpoints, EOF/hangup/broken-pipe semantics and bounded buffering; descriptor closure must wake exactly the affected waiters. - [x] Admit explicit counted pipe-pool rings and exact versioned wire framing, including pool-only plans and atomic resource refusal. - [x] Reserve the two lowest-free descriptors and independent descriptions atomically; publish after accepted COMPLETE or cancel both. - [x] Implement FIFO scalar/vector small-write atomicity and bounded blocking/nonblocking behavior without a maximum-write ceiling. - [x] Preserve original-description wait readiness, final-alias EOF/EPIPE, complete ring scrubbing, stale-generation refusal and safe reuse. - [x] Implement ignored/caught/blocked SIGPIPE and default native termination through the retained original controller, without new grants. - [x] Author unit/native/packaging controls, migrate producers and maintained contracts/manual, and apply rustfmt. - [x] Publish signed immutable revisions and reconcile exact issue, PR and master tracking. Signed source and all exact public readbacks are reconciled. No test execution, runtime or profiler pass is claimed. - [x] Implement stat/fstat/lstat/fstatat, readdir and seekable directory iteration with stable identity, correct dot entries, mode/size/link counts and source-qualified ctime/mtime/atime behavior. - [x] Define exact source-qualified status and directory wire contracts with independent hostile-input and atomic-encoding controls. - [x] Supply original provider identities, complete required metadata and honest signed time/source/precision, including volatile roots and mutations; fix E2fsd#14 without converting unknown time to Epoch. - [x] Route held-object metadata and mounted directory enumeration through Vfsd with exact original scope, no authority widening and full-width provider cursors. - [x] Implement compatibility path/fd stat families with correct follow/search/error behavior and original native cleanup. - [x] Implement shared-description readdir/tell/seek/rewind, dot entries, aliases, result-capacity admission and cancellation. - [x] Author meaningful unit/provider/native integration controls; audit/refactor touched code and update inline/component/manual documentation. - [x] Publish signed immutable revisions and reconcile owning issues, affected PRs and public master issue65 with exact metadata/readbacks. - [x] Implement mkdir/rmdir/unlink/link/symlink/readlink/rename variants required by the workload, with exact-entry authority and atomic visibility; cross-filesystem operations fail deterministically without partial mutation. Owning [namespace mutation and lifetime design](https://git.erikinkinen.fi/erix/posixd/issues/27). - [x] Define exact compatibility/native operation, outcome, counted payload and conditional original-entry contracts; migrate producers/consumers coherently. - [x] Complete FAT namespace primitives with original-parent/target admission, creation policy, links, times and atomic publication. - [x] Integrate original-client path/dirfd resolution, complete parent/target permission checks and one-use freshness into actual compatibility serving. - [x] Complete two-path rename/link behavior, final links, trailing separators, same-object rename and no-effect cross-filesystem refusal. - [x] Resolve held-object/directory detachment and alias lifetime dependencies; retain custody through cancellation, uncertainty, final retirement and reuse. - [x] Author unit/provider/native workloads, audit/refactor authority and code, and update inline/component/manual documentation. - [x] Publish the coherent signed immutable graph and reconcile linked reviews, owning issues and phase master. - [x] Implement raw readlink/readlinkat through original-client root/cwd/dirfd resolution, complete prefix policy, bounded raw pages and original cleanup; include authored service/native controls, documentation and signed publication. - [x] Implement RAM conditional namespace primitives with fixed-role original entries, permission freshness, creation policy, two-parent link/rename, raw symlinks and retained object custody; include authored controls, documentation and signed publication. - [x] Implement journaled ext conditional namespace selection and all seven effects with original binding/permission evidence, shared transactions, explicit creation policy and directory ACL inheritance; include authored controls, documentation and signed publication. - [x] Complete plain ext conditional namespace effects using explicitly selected original durable undo, atomic mount recovery, timestamps and unchanged filesystem format; include authored provider/media and VM controls, documentation and signed publication. - [x] Resolve the existing held-directory pin restrictions against POSIX cwd/open-object rename/unlink expectations; implement safe object lifetime and namespace detachment without reverting to path-based reopening or stale grants. - [x] Implement RAM open-file/symlink detachment and compatible replacement through original handles and acquisition keys, with counted reclamation, independent controls, native workload, documentation and signed publication. - [x] Complete RAM hardlink edge/object separation and held-directory cwd/move/detachment semantics while preserving original root ceilings and alias custody. [RAM source](https://git.erikinkinen.fi/erix/ramfsd/commit/d159c5a33f4ed23b51385a697d3fc7f3d709276e) · [Review](https://git.erikinkinen.fi/erix/ramfsd/pulls/2). - [x] Implement ext original-inode detachment, retained aliases, deferred final reclamation and recovery across failure without inode/generation or block reuse. - [x] Implement FAT-family original-object detachment and deferred storage reclamation with selected catalog, original parent geometry, aliases and recovery. - [x] Complete Vfsd and compatibility shared-description/cwd lifetime across namespace changes, cancellation and retirement without reopening paths or reviving stale grants. - [x] Complete cross-provider native lifetime, resource/refusal, restart/recovery and identity-reuse controls; reconcile authority audits, documentation and the coherent signed graph. - [x] Implement original independent FAT directory anchors with fresh source evidence, explicit ceiling proof, minimal counted imported ancestry and source-independent original cleanup; include provider/transport controls, inline/component/manual documentation and signed publication. [Provider feature](https://git.erikinkinen.fi/erix/fatd/issues/12). - [x] Implement conditional fixed-operation entry acquisition in LibIPC and RAM/ext/FAT, with distinct entry custody, fresh actual-parent/root admission, original root/key cleanup, native binding identity, appropriate controls, inline/component/manual contracts and signed publication. [Design](https://git.erikinkinen.fi/erix/vfsd/issues/16) · [LibIPC review](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2) · [RAM review](https://git.erikinkinen.fi/erix/ramfsd/pulls/2) · [ext review](https://git.erikinkinen.fi/erix/e2fsd/pulls/3) · [FAT review](https://git.erikinkinen.fi/erix/fatd/pulls/3). - [x] Require actual retained native custody for exact immediate-entry metadata, permission snapshots/ACL pages and both file-resize follow-ups; remove ordinary permission APIs and fallback adapters, author original-route/lifetime/refusal controls, update documentation and publish signed source. [Design](https://git.erikinkinen.fi/erix/vfsd/issues/16) · [Vfsd review](https://git.erikinkinen.fi/erix/vfsd/pulls/3) · [Manual review](https://git.erikinkinen.fi/erix/docs/pulls/4). - [x] Implement complete raw RAM entry and selection names with independently budgeted shared storage, pre-effect reservation, original owner retirement, full native enumeration, coordinated image policy, authored controls, inline/component/manual documentation and signed publication. [Design](https://git.erikinkinen.fi/erix/ramfsd/issues/1) · [RAM review](https://git.erikinkinen.fi/erix/ramfsd/pulls/2) · [Image review](https://git.erikinkinen.fi/erix/integration/pulls/12) · [Manual review](https://git.erikinkinen.fi/erix/docs/pulls/4). - [x] Replace the fixed public exact-mutation envelope with complete counted raw destinations across LibIPC, original-custody Vfsd dispatch and Coreutils; share one-call status correlation, receipt retirement and scratch clearing with truncation; include literal/provider/transport/utility controls, inline/component/manual documentation and coordinated signed publication. [Design](https://git.erikinkinen.fi/erix/lib-ipc/issues/1) · [Vfsd review](https://git.erikinkinen.fi/erix/vfsd/pulls/3) · [Coreutils review](https://git.erikinkinen.fi/erix/coreutils/pulls/2) · [Manual review](https://git.erikinkinen.fi/erix/docs/pulls/4). - [x] Complete counted exact-directory producer and consumer framing with raw names, actual capacity, original cursor and scope-generation custody, pre-publication reservation admission, independent metadata identity and known-size checks, original candidate/receipt retirement, literal/provider/transport/utility controls, inline/component/manual documentation and coordinated signed publication. [Design](https://git.erikinkinen.fi/erix/lib-ipc/issues/1) · [Vfsd review](https://git.erikinkinen.fi/erix/vfsd/pulls/3) · [Coreutils review](https://git.erikinkinen.fi/erix/coreutils/pulls/2) · [Manual review](https://git.erikinkinen.fi/erix/docs/pulls/4). - [x] Implement truncate/ftruncate, sparse growth, fsync/fdatasync and durability contracts; test concurrent access, ENOSPC and interrupted failure. - [x] Implement explicit original-device durability barriers, exact device/partition routing and supported/refused provider guarantees; author wire, failure and native workload controls, document and publish the graph. [Implemented barrier](https://git.erikinkinen.fi/erix/blockd/issues/3). - [x] Implement filesystem persistence boundaries and recovery ordering using original device guarantees, including complete FAT metadata. - [x] Implement compatibility truncate/ftruncate and sparse growth with original held-object lifetime, exact size admission and ENOSPC behavior. - [x] Implement compatibility fsync/fdatasync through the original held description, preserving interruption, cancellation and cleanup semantics. - [x] Complete whole-item concurrent/failure/native controls, code and authority audits, documentation and coherent signed/public reconciliation. - [x] Implement required mode/umask/ownership/access/ACL semantics with an explicit trusted metadata source. ACL byte preservation alone is not permission enforcement; unsupported provider behavior must be explicit. Design: [mode, ownership and access operations](https://git.erikinkinen.fi/erix/posixd/issues/29). - [x] Implement conditional original-object native/provider mode and owner changes with complete ACL coherence, transaction ordering and fresh permission revisions. - [x] Implement descriptor and pathname mode/ownership consumers, restricted owner/group and special-bit policy, and original cleanup. - [x] Implement real/effective-ID access queries with individual permission checks, complete prefix search and native ceilings; preserve umask/default-ACL behavior. - [x] Complete authored wire/provider/service/VM controls, source authority and size review, documentation, and coherent signed/public reconciliation. - [x] Implement mkstemp/temp-directory and atomic output replacement semantics within delegated tmp/output trees; no host `/tmp` or ambient search. - [x] Implement required advisory locks with process/open-description lifetime, contention, cancellation and crash cleanup for Cargo/Git/build tools. - [x] Implement poll/select readiness, timeout and cancellation using race-free event registration rather than periodic busy loops or fake timeouts. [Readiness implementation](https://git.erikinkinen.fi/erix/posixd/issues/33) · [Review](https://git.erikinkinen.fi/erix/posixd/pulls/5). - [ ] Provide only manifest-required local socket/socketpair semantics through bounded endpoints. Network sockets remain unavailable without later networking authority; device-node names alone grant no device access. [Local stream socket design](https://git.erikinkinen.fi/erix/posixd/issues/34). - [ ] Complete exact manifested socket consumer requirements and interface ownership without claiming coverage from source strings. - [ ] Complete counted local-stream ABI, atomic socket/pair publication and defined unsupported-operation errors across required consumers. - [x] Complete duplex byte/vector I/O, aliases, nonblocking/backpressure, required buffer options, half-close, peer closure and exact retirement. - [x] Complete scoped bind/listen/connect/accept, original listener/backlog/connection lifetime and unlink/replacement semantics. - [ ] Complete original event-driven readiness, delegated deadlines, cancellation and signal interruption for all pending socket operations. - [x] Implement independent deployment-counted original native Vfsd call custody, exact receiver/call generations and storage accounting before CLAIM. - [x] Implement bounded fair native Vfsd progress and immediate intake behind blocked Wait, preserving one-shot exclusivity, legacy opportunity and original Close reply disposal. - [x] Implement keyed original Posixd/Vfsd process-close prepare, Commit and grant-free receipt acknowledgment through caller uncertainty, with exact scope/candidate/key custody and no release of newer locks. - [x] Implement counted original mediator intake and fair independent call progress on one native receiver, separate request/result and wake custody, original readiness mask observations, narrow deferred descriptor changes and full terminal drain without holding Close behind blocking Wait. - [x] Implement original native process lifetime storage, sole capability-window policy and VSpace custody, validated initial execution associations and captured submission origin, preserving original owners through admission refusal/final cleanup and documenting independent controls. - [x] Implement complete strict OIR2 framing and captured process/execution origin across shared codecs, native producer, process-only metadata, all current adapters/count geometry and Posixd initial execution admission; preserve status/custody, author independent native/refusal controls and maintain signed helper/catalog/manual adoption. - [x] Implement authentic prepared native process members through actual held Process/stage authority and a noncopy budgeted Kernel factory, indexed shared CSpace/VSpace/window custody with one backing reference, member-only positive abort, retained dropped views, original group freeze/drain and refusal/reuse controls; maintain signed catalogs/manual while leaving runnable context/TLS/enrollment and full thread lifecycle open. - [ ] Complete authenticated native shared-process thread membership, shared process policy with distinct per-thread masks/TLS, and required consumer adoption; current single-TCB asynchronous calls do not satisfy this boundary. - [x] Author complete independent positive/negative/failure/capacity controls and native same-process multi-client overlap/socket workload sources. - [ ] Complete libc socket/runtime and every manifest-required imported consumer without ambient pathname, network or device authority. - [ ] Complete final inline/component/manual contracts, missing-docs enforcement, code-size cleanup and removal of superseded assumptions for the whole socket feature. - [ ] Publish and reconcile the complete socket implementation and source/performance evidence through signed immutable graphs, owning reviews and phase tracking. - [ ] Test symlink/parent traversal, rename races, fd/PID reuse, shared offsets, directory lifetime, revoked handles and mutation outside scope. - [ ] Add multi-process build-style filesystem VMs for parallel files, atomic rename, locks, large trees, long paths and explicit resource exhaustion. </details> ### Memory, threads and blocking primitives Weight: 6%. [Owning issue](https://git.erikinkinen.fi/erix/kernel/issues/1) · [kernel PR 3](https://git.erikinkinen.fi/erix/kernel/pulls/3). <details> <summary>Checklist</summary> - [ ] Inventory required allocation/mmap/protection/shared-memory/thread interfaces from selected tools and distinguish missing mechanisms from libc adapters over existing capabilities. - [ ] Implement authorized anonymous allocation and release for growing heaps/stacks, with checked alignment, zero initialization, quotas and OOM cleanup. - [ ] Implement required private/file-backed mmap, munmap, mprotect and synchronization behavior; preserve W^X, backing rights, dirty data and revocation. - [x] Validate native frame access, W^X, current-grant protection restoration and retained backing. - [x] Construct/populate/withdraw unpublished private hierarchies with owned tables and rollback. - [ ] Complete private-root routing, hardware readiness, activation and live retirement. - [ ] Implement POSIX private/file-backed mapping, unmapping and protection adapters. - [ ] Complete file synchronization, dirty-data and revocation behavior with real compatibility consumers. - [x] Specify thread/process address-space ownership, thread start/exit/ join/detach, stack guards and cleanup with no unintended capability inheritance. Ownership specification: [Kernel#44](https://git.erikinkinen.fi/erix/kernel/issues/44); [kernel review](https://git.erikinkinen.fi/erix/kernel/pulls/3), [docs review](https://git.erikinkinen.fi/erix/docs/pulls/4), [integration review](https://git.erikinkinen.fi/erix/integration/pulls/12). Native runtime implementation remains open. - [ ] Implement per-thread TLS allocation, access base and destructor lifetime, integrating ABI and loader contracts; isolate errno and thread data. - [ ] Implement mutex/condition/rwlock/once/TLS-key primitives required by libc/tools with correct atomic ordering, wakeup ownership and destruction. - [ ] Implement race-free check/register/block/wake and actual monotonic deadlines; test notify-before-wait, wake-after-cancel, spurious wakeups, lost wakeups, priority/fairness effects and generation reuse. - [ ] Define fork interactions with multiple threads, atfork handlers, runtime locks and child state; no inherited lock may require a vanished thread. - [ ] Specify unwind/exception support needed by imported C++/Rust tools separately from native abort-only components; do not enable unwinding across kernel, IPC or incompatible FFI boundaries. - [ ] Provide explicit clock and entropy access needed by runtimes. Distinguish reproducible timestamps/test randomness from security randomness; never satisfy a cryptographic entropy request with deterministic fixture data. - [ ] Add stress/failure VMs for mapping protection, concurrent allocation, threaded compilation, TLS isolation, wakeups, joins and teardown under OOM. - [ ] Profile allocation, faults, mapping transitions and synchronization; optimize only measured costs after safety and lifecycle tests pass. </details> ### Process, fork/exec/wait and signals Weight: 6%. [Owning issue](https://git.erikinkinen.fi/erix/posixd/issues/3) · [posixd PR 5](https://git.erikinkinen.fi/erix/posixd/pulls/5). <details> <summary>Checklist</summary> - [x] Specify fork's exact snapshot, return values, native generation, POSIX PID, shared open descriptions and allowed capability inheritance. A shell's descriptive subshell checkpoint is not a process fork. - [ ] Implement correctness-first private address-space copying unless a separately reviewed copy-on-write mechanism is justified; duplicate only selected memory/descriptor rights, never a service's private receive authority. - [ ] Implement atomic child publication and full unwind for allocation, mapping, transfer or startup failure; parent state remains usable and no half-started child or leaked authority remains. - [ ] Implement execve/exec-family replacement using exact executable identity, manifest, realm policy, argv/env, inherited descriptors and signal rules; success replaces the image, failure preserves the prior process. - [ ] Implement posix_spawn/file actions if required by imported tools; preserve the same inheritance/security semantics and test fork/exec equivalence where specified. Do not fake fork by always taking a spawn-only path. - [ ] Implement wait/waitpid and required wait options with exact child status, zombie retirement, multiple waiters, interruption and PID reuse safety. - [ ] Implement process groups/sessions and terminal foreground ownership entirely within delegated namespaces; numeric group IDs cannot grant control. - [ ] Implement sigaction, masks, pending delivery, default/ignore/caught dispositions, unblock ordering and supported signal sets with explicit state. Original initial-task actions/masks and cooperative self-signals are implemented. Original-supervisor/controller external generation and retained-I/O interruption are also implemented. Default SIGPIPE is also implemented. Full libc wrappers, other native default effects, multi-thread state and unblock ordering remain open; no complete-signal acceptance is claimed. - [ ] Implement safe user handler entry/return, alternate stack if required, validated restored context and async-signal-safe runtime paths; never unwind across unauthorized frames or trust caller-provided privileged CPU state. - [ ] Implement signal-driven EINTR/restart, SIGCHLD/wait ordering, SIGPIPE, stop/continue and terminal job-control behavior required by the profile. - [ ] Implement per-process CPU/resource queries and required limits with real counters; elapsed wall time and child CPU time remain distinct. - [x] Implement real native task CPU accounting and generation-bound acknowledged final measurements. - [x] Validate ordinary service CPU observations and exec-successor accounting in actual VMs. - [ ] Complete consumer restart/loss custody and all required compatibility resource-query adapters. - [ ] Implement workload-required resource limits and child accounting without substituting wall time. - [ ] Add fork/exec/wait VM matrices covering descriptor aliasing, close-on-exec, environment, cwd, TLS, signals, multi-thread fork, failures, concurrent children and termination while authority demand is pending. - [ ] Add cross-realm signal/control denial, stale-PID replay, descendant cleanup and repeated fork/exec exhaustion/recovery VMs; verify no residual caps. </details> ### C runtime and libc Weight: 5%. [Owning issue](https://git.erikinkinen.fi/erix/lib-cstd/issues/1) · [Standard memory/string family](https://git.erikinkinen.fi/erix/lib-cstd/pulls/93) · [Required POSIX comparisons](https://git.erikinkinen.fi/erix/lib-cstd/issues/94) · [Producer bindings](https://git.erikinkinen.fi/erix/integration/pulls/613) · [Manual/API](https://git.erikinkinen.fi/erix/docs/pulls/93). <details> <summary>Checklist</summary> - [ ] Define static/shared libc artifacts, C headers, symbol/export versioning, startup objects, calling conventions and supported C language ABI. - [x] Define the implemented x86_64 C/Rust declarations, partial headers and explicit companion symbol policies. - [ ] Complete static/shared libc, startup objects, full headers and symbol/version contracts. - [ ] Implement C entry/exit, argc/argv/env/auxiliary data, atexit and initialized runtime state from validated launch input; no ambient discovery. - [x] Implement authenticated C startup planning and counted mutable arguments and exported environment on the shared process heap. - [x] Implement getenv/environ, ordered concurrent exit handlers and normal/immediate exit through a retained genuine process-group terminal owner. - [x] Implement the original-source producer, ordinary command and image policy, native C fixtures, VM oracle source and component/manual contracts ([C startup](https://git.erikinkinen.fi/erix/lib-cstd/issues/9)). - [ ] Complete warning-free supported-target formatting, strict Clippy, unit/header checks and actual native C startup workload acceptance. - [ ] Complete workload-required auxiliary data, initialized runtime state and C entry/exit adoption across compatibility and imported-tool consumers. - [ ] Implement memory/string/byte functions with overlap/alignment/ zero-length/overflow tests and documented FFI pointer contracts. - [x] Implement and independently validate memcpy, memmove, memset and memcmp. - [x] Implement and validate strlen, strcmp, strncmp, memchr, strchr and strrchr. - [x] Implement and validate strcpy, strncpy, strcat and strncat. - [x] Implement and validate strspn, strcspn, strpbrk and strnlen. - [x] Implement and validate strstr, including its pointer, byte, ABI/guard/link, complete source-cohort and manual/API contracts. - [ ] Complete the remaining required memory/string interfaces from the final workload inventory. - [ ] Adopt the complete implementation in actual compatibility consumers and finish workload validation. - [x] Implement and document stpcpy/stpncpy in the original companion, with authored return, range, ABI and failure controls. - [x] Implement and document mempcpy representation copying and end-pointer results, with authored binary/range/C-Rust controls. - [x] Support C/C++ partial memory/string headers on the same original C ABI, with authored linkage, hygiene and mixed-caller controls. - [x] Implement and document heap-owned strdup/strndup, with authored allocation-failure, pointer and byte controls and native C fixture wiring ([owned string copies](https://git.erikinkinen.fi/erix/lib-cstd/issues/10)). - [x] Implement and document caller-owned strtok_r, with authored byte, pointer, ABI and guard controls and native C fixture wiring ([tokenization](https://git.erikinkinen.fi/erix/lib-cstd/issues/11)). - [ ] Implement malloc/calloc/realloc/free/aligned allocation using [Memory, threads and blocking primitives](https://git.erikinkinen.fi/erix/kernel/issues/1), covering ownership, failure atomicity, zeroing and threaded use. - [x] Implement and document the checked allocation family over one process heap shared by C and Rust, with thread-local errors and failure atomicity. - [x] Implement original-source production, separate packaged heap capacity and a genuine C/Rust/member workload while preserving older realm oracles. - [ ] Complete warning-free workspace formatting, strict Clippy, unit, rustdoc and C/C++ header checks across the supported targets. - [ ] Demonstrate allocation, thread-local errors, exhaustion recovery and retirement in the actual native guest workload. - [ ] Complete allocation adoption and backing lifetime across the required C runtime, compatibility consumers and imported workloads. - [ ] Implement errno and error strings per thread with stable native error mapping; unrelated calls/threads must not overwrite each other's state. - [x] Implement the selected fixed C-locale catalog and whole caller-buffer copies; complete original ABI/guard/link checks and coherent source, Integration and manual/API adoption. - [ ] Complete native terminal-to-thread errno adapters, required assignments and workload mappings, preserving interruption and partial I/O. - [ ] Complete current/explicit locale error interfaces and mediated diagnostic streams with their lifetime and return contracts. - [ ] Demonstrate independent thread errors and complete native consumer/workload behavior through required VM and warning-free CI gates. - [ ] Implement buffered stdio, formatting/scanning and conversion surfaces required by tools; cover partial I/O, flush-on-exit, stream locking, binary data, locale, numeric bounds and varargs ABI. - [x] Complete fixed C-locale LP64 integer conversions and full source, companion, C/Rust consumer, manual/API and independent control adoption. - [ ] Complete remaining numeric/locale conversion interfaces required by tools. - [ ] Complete buffered stdio, partial I/O, binary data, stream locking and flush-on-exit. - [ ] Complete required formatting interfaces and varargs ABI coverage. - [ ] Complete required scanning interfaces, locale and numeric-bound cases. - [ ] Implement libc file/directory/poll/terminal adapters over `posixd`; no direct provider routes or host-OS syscall fallback may bypass mediation. [Mediated C byte I/O](https://git.erikinkinen.fi/erix/lib-cstd/issues/13). - [x] Implement and publish namespaced C/Rust read, write and close interfaces with an explicitly bound original Posixd realm, independent concurrent call storage, uninitialized read buffers, bounded write prefixes, current-thread errno and retirement before buffer release. Adopt the source companions, C fixtures, headers and manual in the native process-root graph. - [ ] Complete required file opening, duplication, status, positioning, metadata and filesystem control adapters through the mediated descriptor ABI. Retain relative directory bases through pending operations. Bind cwd reports to their full native recipient and retire report observers and idle reports without losing original request/reply evidence or the first failure. Measure native stack use and regenerate matching API references. Admit the C workload through an explicit private filesystem root, with writer-only authority and peer denial. Tracking: [rooted scopes](https://git.erikinkinen.fi/erix/launchd/issues/28), [cwd](https://git.erikinkinen.fi/erix/posixd/issues/44), [C file adapters](https://git.erikinkinen.fi/erix/lib-cstd/issues/14). - [x] Publish namespaced C/Rust file and pipe frontends, headers, exports and current-thread errno contracts. - [x] Publish the original-realm backend and mediator source for independent directory-base holds, timestamp updates and process-owned cwd reports, including call/report retirement and cleanup controls. - [x] Publish the prepared filesystem C workload and existing VM scenario enrollment, with distinct held directory bases, multi-chunk cwd, cleanup controls and manual companions. - [ ] Complete the conventional tool-facing file/pipe entry points and compatibility-startup integration required by selected tools. - [ ] Measure native stack use during report initialization and reoccupation; remove unnecessary temporary copies and demonstrate headroom within the admitted process stack. - [ ] Complete source-bound native/unit/VM acceptance for file, pipe, timestamp, directory-base and cwd operations; regenerate any remaining affected API references from actual matching Rustdoc output. - [ ] Complete directory stream and entry adapters with defined ownership, cursor, error and teardown behavior. Tracking: [mediated directory adapters](https://git.erikinkinen.fi/erix/lib-cstd/issues/15). - [x] Complete poll/select readiness adapters, interruption and timeout behavior through the reviewed service mechanisms. Tracking: [C poll and select adapters](https://git.erikinkinen.fi/erix/lib-cstd/issues/16). The namespaced `erix_c_poll` and `erix_c_select` interfaces are implemented; conventional aliases and C signal-handler delivery remain pending. - [ ] Complete terminal adapters and required controls without exposing direct provider authority. Tracking: [Restricted terminal controls](https://git.erikinkinen.fi/erix/ttyd/issues/5); [C terminal adapters](https://git.erikinkinen.fi/erix/lib-cstd/issues/19). - [x] Publish typed native control rights and stream-bound views, retaining authenticated original issuer inputs, per-view operations and positive provider disposal independently of byte transport. - [x] Provision the dedicated route only from authenticated wanted boot policy, with exact endpoint rights and independent counted storage. Preserve default session grants and original creator retirement. - [x] Bind mediator control views to original byte descriptions and alias groups; retire each control caller and provider view before the last byte owner, including cancellation and uncertain cleanup. - [ ] Complete the required mediated C/Rust terminal adapters, terminal identification, window controls and termios behavior. - [x] Publish namespaced C/Rust terminal identification and window adapters, the checked compatibility/native bridge and the explicit original-source C workload. Preserve view rights and alias cleanup. - [ ] Complete full termios, control characters, speeds, flow, drain/flush, break, foreground groups and required line-discipline behavior through matching native mechanisms and reviewed adapters. [Termios parameters and attributes](https://git.erikinkinen.fi/erix/lib-cstd/issues/20) tracks the C parameter dependency and mediated attribute operations. - [x] Publish the caller-owned parameter layout, constants and four pure C/Rust speed accessors with original companions, field-preservation and ABI controls, build enrollment and maintained documentation. Storage success does not attest native support. - [ ] Implement retained native attributes and required input/output processing, configurable characters and canonical line/EOF records, preserving buffered data and atomic state transitions. - [ ] Complete mediated C/Rust attribute observation and replacement with exact wire validation, explicit operation rights and original descriptor/caller lifetime through failure and cleanup. - [ ] Implement required native drain/flush, flow, break, speed application and noncanonical minimum/time read behavior with truthful queue/device effects and retained interruption cleanup. - [ ] Complete authenticated foreground groups and terminal signal/line-discipline behavior without deriving process authority from numeric selectors or broadening existing mode views. - [ ] Demonstrate the native C/Rust terminal workloads, required authority-negative, alias, failure and cleanup cases, and matching runtime API documentation from actual builds. - [ ] Supply conventional POSIX aliases after libc signal delivery and compatibility startup, then demonstrate the complete adapter set with native C workloads, failure and concurrent-retirement coverage. - [ ] Implement process/signal/thread adapters over reviewed native mechanisms; libc process-global state must have defined fork/exec behavior. - [ ] Implement time/sleep, locale/ctype/multibyte, environment, sorting, search and required math/runtime helpers with deterministic documented behavior. - [x] Supply the fourteen fixed C-locale ASCII character calls with scalar ABI, companion products and documented contracts ([runtime](https://git.erikinkinen.fi/erix/lib-cstd/pulls/3), [manual](https://git.erikinkinen.fi/erix/docs/pulls/4)). - [ ] Complete required conventional ctype and current-locale interfaces. - [ ] Implement required multibyte conversion and its encoding state. Tracking: [Caller-owned multibyte conversion](https://git.erikinkinen.fi/erix/lib-cstd/issues/17). - [x] Implement the declared 22 conversion/state calls through one caller-owned ASCII/UTF-8 core, including restartable and UTF-16 state. - [x] Publish the scalar errors, C header, root runtime, independent conversion/header controls and inline contracts coherently. - [x] Link the original Cstd C probe into both heap workloads, preserving source ownership, export guards and thread/heap observations; publish matching component catalogs and technical-manual contracts. - [ ] Map required upstream multibyte interfaces and complete their conventional aliases and current-locale/state contracts. - [ ] Execute the integrated C workload through the actual native and VM paths, publish the new runtime API reference and complete end-to-end failure, concurrency and cleanup acceptance. - [ ] Implement time and sleep through reviewed native mechanisms. Tracking: [Clock observations and owned sleep](https://git.erikinkinen.fi/erix/lib-cstd/issues/18). - [x] Implement checked time values and durations over the full signed seconds range, including canonical fractions and native conversion. - [x] Publish calibrated native source resolution and owned UTC waits, preserving the original target through clock changes and positively retiring the timer before completion or replacement. - [x] Implement the declared C observation and sleep calls, mediated compatibility bridge, root runtime and original C workload probe. - [ ] Complete the required calendar, current-zone, CPU-accounting and conventional interfaces and map required upstream tool usage. - [ ] Complete actual native/VM execution, runtime API references and end-to-end failure, concurrency and cleanup acceptance. - [x] Implement process-owned environment access and mutation on the shared heap, including copied and borrowed values, alias retention, atomic failure and exit-handler access ([environment APIs](https://git.erikinkinen.fi/erix/lib-cstd/issues/12)). - [x] Complete sorting and search interfaces with explicit callback contracts. - [ ] Complete required math and runtime helpers with documented behavior. - [ ] Implement only required additional C/POSIX interfaces identified in [Scope, repository and build inventory](https://git.erikinkinen.fi/erix/integration/issues/1); track every unsupported extension with explicit behavior and tool configuration/port justification, not success-returning stubs. - [ ] Build independent C conformance probes for layout, linking, constructors, TLS, allocation, stdio, files, threads, signals and process lifecycle. - [x] Run independent C/Rust layout, call/link, guarded-memory and negative companion-link probes. - [ ] Add constructors/TLS/allocation/stdio/file conformance probes. - [ ] Add thread/signal/process lifecycle and real compatibility execution probes. - [ ] Validate FFI safety and C/Rust interoperability under errors, malformed inputs and stress; publish rustdoc/header/manual contracts and pass full strict CI for `lib-cstd` and changed consumers. - [x] Validate and document the implemented byte/string FFI with independent C/Rust controls and strict component CI. - [ ] Complete FFI/error/stress coverage and contracts for the remaining libc. - [ ] Validate all changed runtime consumers and the complete imported workload closure. </details> ### Compatibility ELF and runtime linking Weight: 4%. [Owning issue](https://git.erikinkinen.fi/erix/dynlinkd/issues/1) · [dynlinkd PR 3](https://git.erikinkinen.fi/erix/dynlinkd/pulls/3). <details> <summary>Checklist</summary> - [ ] Inventory emitted ELF/interpreter/dynamic tags, relocations, symbol versions, TLS models, constructor/finalizer and exception metadata from exact selected compiler/runtime packages. - [x] Define/version a compatibility artifact contract distinct from native abort-only/no-TLS/no-init-fini policy; preserve rejection of unsupported native artifacts instead of simply deleting existing guards. - [ ] Implement required relocations and dynamic symbol rules with exact bounds, dependency closure, cycle/duplicate behavior and no ambient library search. - [ ] Implement static/dynamic TLS layout and per-thread/module lifecycle with checked template/BSS alignment, unload rules and [Memory, threads and blocking primitives](https://git.erikinkinen.fi/erix/kernel/issues/1) synchronization. - [x] Complete original ELF PT_TLS extraction with immutable prefix provenance, full checked file/memory geometry, duplicate/malformed/overflow/alignment refusal and complete caller-block prefix/zero initialization. - [x] Complete caller-counted VariantII layout and immutable template/module retention, sparse IDs, exact alignment residue, 24-byte self/DTV/errno TCB, counted DTV and full image/refusal/spare-byte contracts without private count/size ceilings. - [ ] Complete original graph/module/symbol scopes and every TLS relocation/null-provider form required by exact imported artifacts; current pure exact-width runtime planning is a foundation. - [x] Complete allocation-free prepared initial TLS native transport with complete original input integrity, exact positive reply correlation and refusal/uncertainty custody. [LibIPC review](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2). - [x] Delegate exact caller-counted Procd packet storage through authenticated target deployment geometry and the image configuration path, with capacity refusal before CREATE and no hidden image ceiling. [packet storage review](https://git.erikinkinen.fi/erix/integration/pulls/297). - [x] Retain immutable loader-only TLS binding and sequential input, initialize through the actual original Process/stage before ordinary or staged commit, and positively clean up before erasure/reuse. [Procd review](https://git.erikinkinen.fi/erix/procd/pulls/2). - [x] Complete immutable exact-width linker/materialization patch framing, full raw-record preflight, original producer/consumer spans and plan order, and native failure cleanup custody without scalar truncation. [LibIPC fix](https://git.erikinkinen.fi/erix/lib-ipc/issues/7), [patch contract](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/relocation-patches.md). - [x] Complete caller-counted immutable ERR1 source registry framing, original prefix/object correlation, duplicate/extent/refusal/spare contracts and the documented production TCB registry extension with fresh-image initialization. [Full TLS](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [registry contract](https://git.erikinkinen.fi/erix/lib-dynlink/src/branch/feature/posix-compat/docs/tls-registry.md). - [x] Complete actual authenticated Loaderd initial ELF/template/image production with dedicated explicit stack/guard/TLS/read-only registry geometry, complete original native input and target-derived caller/deployment budgets before CREATE. [Full TLS](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [registry contract](https://git.erikinkinen.fi/erix/lib-dynlink/src/branch/feature/posix-compat/docs/tls-registry.md). [storage producer review](https://git.erikinkinen.fi/erix/integration/pulls/300). - [x] Complete original initialized-template fixups in separately resolved immutable registry and prospective initial image before publication, correlate two full original plan/count reads before child commit and retain exact failure cleanup custody. [Full TLS](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [registry contract](https://git.erikinkinen.fi/erix/lib-dynlink/src/branch/feature/posix-compat/docs/tls-registry.md). - [x] Complete Dynlinkd original registry/object-digest/image correlation, actual TLS-aware caller-arena planning and exact-width committed output, deriving required descriptor exports only from original executable graph code. [Full TLS](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [registry contract](https://git.erikinkinen.fi/erix/lib-dynlink/src/branch/feature/posix-compat/docs/tls-registry.md). - [x] Complete original per-thread errno/TLS-index/eager-descriptor primitives, explicit unsafe Rust/C contracts, exclusive caller byte-image preflight and original assembly with no global fallback or native authority from metadata. [Complete libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [runtime contract](https://git.erikinkinen.fi/erix/lib-cstd/src/branch/feature/posix-compat/docs/thread-runtime.md). - [x] Complete one bounded original memory/thread companion producer with distinct explicit roles, artifacts, ABI/receipt identities and pinned Integration source selection; remove superseded paths and forbid bootstrap memory substitution. [Complete libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [runtime contract](https://git.erikinkinen.fi/erix/lib-cstd/src/branch/feature/posix-compat/docs/thread-runtime.md). - [x] Complete authored bounded original thread object/alias/archive/text, guarded image, exact owned-signal/cleanup and missing/memory-only/duplicate-link controls with explicit tool/source ownership and retained older oracles. [Complete libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [controls and packaging](https://git.erikinkinen.fi/erix/lib-cstd/src/branch/feature/posix-compat/docs/thread-runtime.md). - [x] Complete explicit partial native compatibility object/archive packaging of original memory/string/thread bodies once, exact component/thread ABI and pinned source/receipt provenance, with no bootstrap or standalone-component substitution. [Complete libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [controls and packaging](https://git.erikinkinen.fi/erix/lib-cstd/src/branch/feature/posix-compat/docs/thread-runtime.md). - [x] Complete original native ingress-to-CLAIM/member/context/machine FP environment custody and environment-only fresh initialization with exact restore-format semantics, replay/Start and positive private erasure. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [original creator environment](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/creator-floating-environment.md). - [x] Author independent original FP init/format/fresh-byte/allocation/replay/asynchronous-creator/actor-refusal controls and actual CPL3 first-entry inherited-control/fresh-register oracles while preserving all older native requirements. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [original creator environment](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/creator-floating-environment.md). - [x] Complete actual-current native thread self-exit, explicit execution/process terminality, original result and departed-anchor/peer/shared-authority survival, serialized finalizer/Start arbitration and positive private member/accounting cleanup before ID reuse. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [native thread self-exit](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-thread-exit.md). - [x] Author exact native self-exit codec/bridge and genuine original object/charge/refusal/replay/reuse controls plus a separate routed CPL3 self-exit/peer-survival scenario, preserving older VM scenarios, marker sets and finite budgets. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [native thread self-exit](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-thread-exit.md). - [x] Complete actual native shared-object compatibility consumption with hidden policy, complete thread ABI/source/tool/owner/receipt provenance through artifacts and exact version-four registries/cache/prebuilt/direct consumers, retaining separate memory-only Kernel bootstrap and unchanged artifact TLS refusal. [Complete libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [native C runtime consumers](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/native-c-runtime-consumers.md). - [x] Remove superseded generic runtime adapters/flags/paths without forwarding aliases and author independent actual-consumer component/policy/target/schema/role/ABI/cache refusal controls, routing new coverage while preserving all older native scenarios, oracles and budgets. [Complete libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [native C runtime consumers](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/native-c-runtime-consumers.md). - [x] Complete held-member native READ exit-result observation through exact original binding/serial/noncopy execution/process/factory association, full-width pending/departed-zero framing, status/correlation bridge and retained cleanup/finalization custody without lookup, mutation or nested lifecycle acquisition. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [held-member exit results](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-member-exit-observation.md). - [x] Author independent literal/bridge and genuine native rights/serial/kind/movement/charge/refusal/replay/retirement controls plus synchronized actual CPL3 pending/departed result queries and positive rendezvous-grant disposal, preserving all older scenarios, marker sets and finite budgets. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [held-member exit results](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-member-exit-observation.md). - [x] Complete authenticated staged-client native factory production through original supervisor/client/realm/mediator/GRANT and actual Process scope, explicit same-realm thread budgets, exact current READ/minimal roles, unique original stage/factory result transfer, independent source absence and obsolete local-selector erasure without default thread authority. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [staged client factory producer](https://git.erikinkinen.fi/erix/procd/src/branch/feature/posix-compat/docs/client-thread-factory.md). - [x] Author independent complete factory request/response and canonical role/mask controls, scripted producer admission/scope/uncertainty/transfer/cleanup/erasure/budget controls and genuine Kernel paired stage/factory unique-result tests, preserving older native scenarios, oracles, target-derived geometry and finite budgets. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [staged client factory producer](https://git.erikinkinen.fi/erix/procd/src/branch/feature/posix-compat/docs/client-thread-factory.md). - [x] Complete explicit frozen per-client factory capacity and same-realm thread-budget admission, full canonical/public framing and version-seven three-column startup/image consumers, original paired caller/source-absence/retirement/native READ custody, zero-policy column discharge and unsupported mediator admission refusal without default authority. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [counted caller custody](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/client-thread-factory.md). - [x] Author independent complete literal/budget/old-width, paired source/caller/result/cancel/retirement, one/multiple-client provisioning/refusal/quarantine and default seal-to-Start controls; correct stale counted witnesses, preserve older oracles/budgets and maintain coherent inline/component/manual/signed source and review evidence. [Full native threads](https://git.erikinkinen.fi/erix/kernel/issues/47), [counted caller custody](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/client-thread-factory.md). - [ ] Wire actual initial and additional Loaderd/Dynlinkd/Procd/Kernel thread TLS images and access bases to original file/process/stage/member/mapping authority before genuine execution. - [ ] Complete libc per-thread errno, TLS and descriptor resolvers, TLS keys and destructor ordering for every native/imported consumer. - [ ] Complete synchronized module admission/mutation/unload, original thread/image lifetime and positive retirement with native thread ownership lifecycle, exit/join/detach and failure custody. - [ ] Author complete independent runtime/module-race/cleanup/refusal controls and real native multi-thread TLS VM sources retaining every original integration oracle. Require a real nonswitching hardware interrupt to return to the original CPL3 task after completing its CPU entry lease; retain separate hosted refusal and modeled lease controls. - [ ] Complete whole-feature inline/component/manual contracts, missing-docs and code-size cleanup, remove obsolete unsupported assumptions after migration and publish coherent signed graphs/reviews/master evidence. - [x] Implement CPU-owned caller, entry and execution state with real AP state admission, a genuine CPL3 source fixture, Integration routing and inline/component/manual contracts. [Complete TLS design](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [LibElf review](https://git.erikinkinen.fi/erix/lib-elf/pulls/2), [LibDynlink review](https://git.erikinkinen.fi/erix/lib-dynlink/pulls/3). - [ ] Implement ordered constructors/finalizers and runtime teardown with failure handling; no initializer executes before validation and final mappings. - [ ] Implement declared runtime library loading needed by Python modules and compiler plugins/proc macros; restrict dlopen-like search to granted library roots and retire mappings/aliases only after their users are gone. - [ ] Implement required unwind registration/lookup in compatibility userspace only; validate metadata and keep native/kernel abort policy intact. - [ ] Enforce W^X, relocation/RELRO permissions, manifest identity and dependency closure for imported objects; reject text relocation/lazy binding/ IFUNC modes unless separately required, designed, tested and approved. - [ ] Test malformed ELF, dependency substitution, TLS races, constructor failure, symbol ambiguity, plugin teardown and out-of-realm library lookup. - [ ] Run actual compatibility ELF/TLS/C++ exception/Rust runtime VMs and native-loader regression scenarios with strict warning-free component CI. </details> ### Shell, utilities, help and manual pages Weight: 5%. [Owning issue](https://git.erikinkinen.fi/erix/exsh/issues/1) · [exsh PR 3](https://git.erikinkinen.fi/erix/exsh/pulls/3). <details> <summary>Checklist</summary> - [ ] Compare exsh's maintained POSIX conformance register and actual build scripts against the selected POSIX shell standard; enumerate remaining syntax, expansion, built-in, signal, group and stopped-job gaps with tests. - [ ] Complete standard POSIX shell behavior needed for ordinary scripts and all remaining mandatory profile items; preserve native descriptor/job authority and distinguish true fork from in-process descriptive state copying. - [ ] Implement compatibility-program launch from exsh without executable-name/argv-specific authority semantics; tools request/fail operations on their own, within the launch envelope. - [ ] Complete pipeline/redirection/substitution/here-document/background/ wait/trap/job-control interactions against real POSIX processes and groups. - [ ] Test configure/build scripts with spaces, long argv/env, nested substitutions, many descriptors, interruption and concurrent output; remove incidental shell storage limits through caller/resource-owned growth. - [x] Move shell transport/cleanup scratch into caller-owned workspace and validate its mapping bounds. - [ ] Finish source/effect/frame proof and remove remaining incidental storage limits. - [ ] Run actual configure/build script stress for long inputs, descriptors, interruption and concurrent output. - [ ] Inventory native utility command/option gaps against build recipes; implement required clean-room behavior in thematic modules and record where an explicitly inventoried extended GNU tool is required instead. - [ ] Finish the exact selected build-recipe command/option inventory and distinguish native versus imported tool requirements. - [x] Implement and document native cmp streams, modes and statuses, with authored ownership, failure and guest controls. - [x] Implement and document binary string/byte printf, including first-byte conversion, with authored native and guest controls. - [x] Implement and document integer printf with checked fields, dual-channel diagnostics and authored native/guest failure controls. - [ ] Complete the other recipe-required native commands/options and explicitly document required imported-tool selections. - [ ] Publish the coherent utility/consumer graph and complete actual build-workload, guest and warning-free regression acceptance. - [x] Implement and document native head/tail line/byte counts and start positions, with authored ownership, failure and guest controls. - [ ] Preserve history/editor/cursor/erase, independent and mirrored TTYs, serial/fbcon trusted consent, output drain and repeated-command behavior under build load; add focused and existing regression VM coverage. - [ ] Run shell/utility conformance fixtures plus a miniature parallel build workflow, checking exact output/status and zero authority leakage. - [x] Specify an internal exsh `help` command with Bash-like behavior: no-argument topic listing, pattern/topic selection, short description (`-d`), manual-style output (`-m`), synopsis (`-s`), option errors and match/no-match exit statuses. Verify combinations against the selected Bash reference. - [x] Implement `help` from exsh's authoritative built-in/topic registry, documenting actual exsh behavior rather than advertising unimplemented Bash extensions; it must not spawn an external executable or acquire filesystem authority for built-in help. Author original explanatory text. - [ ] Add unit and serial/PS2 harness tests for help listing, topic/pattern selection, flags, invalid requests, redirection, pipelines and exit statuses. - [x] Specify `coreutils man`: section/name lookup, disambiguation, multiple pages, search/index behavior, terminal versus redirected output, missing-page errors and scoped manual-directory discovery. - [x] Implement `man` as a native coreutils applet with readable paging, scrolling/search/quit and plain-text fallback for pipes; safely parse the chosen documented man format and never execute page macros, escapes or embedded commands. - [ ] Define stable manual sections/names for all CLI commands/built-ins, IPC interfaces and Rust/C linkage APIs; inventory every exported interface and require an indexed page or a clearly linked owning API page. - [ ] Write/package CLI manual pages covering syntax, options, examples, statuses, authority needs and errors for every tool, including `help`, `man`, `boot-tool`, `sha2-tool`, exsh and extop; include admitted extended-tool manuals only under their declared source/license/manifest policy. - [x] Publish the complete Coreutils command corpus and catalog-bound manifest. - [x] Complete Exsh and every builtin/language-topic page, with useful examples and registry/source freshness. - [x] Publish boot-tool, sha2-tool and extop pages and reconcile ordinary command catalogs. - [ ] Complete manuals for maintained build and developer command interfaces. - [ ] Package admitted imported-tool manuals under their declared provenance policy. - [ ] Write/generate IPC and Rust/C API manual pages with ABI/version, request/reply layout or signatures, safety/ownership/lifetime/authority, errors, examples and cross-references to canonical rustdoc/header/manual text. - [ ] Install man pages/indexes on ext4 as build outputs with explicit read-only lookup authority; environment paths cannot broaden the manual scope or cause execution. Make docs available without network access on both images. - [x] Implement the strict versioned store and exact read-only lookup authority. - [x] Install readonly bytes with checked common dev/release copying and ext4 readback. - [ ] Resolve the complete CLI/API inventory offline in an actual development guest. - [ ] Resolve the complete CLI/API inventory offline in an actual release guest. - [ ] Add coverage/freshness and malformed-page tests plus serial/PS2 `man` navigation, resize, pipe/redirection, missing-page and denied-root VMs. Verify every CLI/interface inventory entry resolves to useful current content. </details> ### Extended payloads and image isolation Weight: 4%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/4) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [x] Implement a versioned third-party payload manifest containing name, version, source digest, license/notices, target, recipe/patch digests, features, runtime dependency closure, dynamic dependencies and realm authority policy. - [x] Define offline source ingestion and reproducible recipe storage; keep imported sources/patches separate from EriX-authored ISC implementation and never add imported libraries to trusted EriX Cargo dependencies. - [x] Add explicit `runtime.extended-dev.toml` and `runtime.extended-release.toml`, labeled non-clean-room in metadata/output. Preserve existing clean `runtime.dev.toml` and `runtime.release.toml` semantics. - [ ] Enforce clean-profile exclusion across configuration inheritance, local overrides, aliases, caches, transitive libraries and packaged contents; test intentional imported-payload contamination fails closed. - [ ] Enforce a reviewed extended-release subset; exclude development-only generators/test harnesses/debuggers and unneeded dependency libraries. - [ ] Verify every admitted target ELF and declared DT_NEEDED closure, source/license/recipe record and authority envelope; reject unknown payloads, mismatched targets, dependency-only orphans and mutable unpinned sources. - [ ] Reconcile the phase inventory with newly discovered packaging and documentation dependencies before admission; update normative inventory, manifest schema/records and tests rather than silently expanding imports. - [x] Identify packaging, filesystem, Markdown and TeX dependencies missing from the initial import list. - [ ] Resolve imported versus owned implementations and update normative inventories/schemas. - [ ] Verify and admit the complete dependency closure into the four image profiles. - [ ] Package admitted tools on ext4 with bounded executable/library manifests; the build realm gets no raw block/device/key/global discovery or network capability from extended-image selection. - [ ] Test all four profile builds, labels, artifact inventories and clean-room exclusion independently; extended-tool success never certifies clean-room implementation provenance. </details> ### EriX-hosted imported toolchain Weight: 5%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/7) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Pin exact upstream sources, compiler versions, recipe options and licenses for every selected tool/runtime; create a dependency-ordered offline bootstrap graph distinguishing build-machine, EriX-host and output targets. - [ ] Implement/review EriX target support and sysroot integration for Rust/LLVM/C tooling, including actual `std` OS bindings over `lib-cstd`, TLS, threads, process, files and time. A target JSON alone is not host support. - [ ] Build target `core`, `alloc`, `std`, `proc_macro`, compiler runtime and `test` libraries; separate imported runtime payloads from trusted native component dependencies and record each runtime link closure. - [ ] Cross-build EriX-hosted `rustc`, `cargo`, `rustdoc`, `rustfmt`, `clippy-driver`, LLVM code-generation libraries and Rust linker support from selected upstream sources against EriX libc/sysroot and Rust OS bindings; execute each within an EriX realm. Retain exact static/dynamic link closure evidence; copying or merely relabeling Linux binaries is not a compiler port. - [ ] Build from source and verify EriX-hosted LLVM tools against the EriX sysroot: `clang`, `clang++`, `lld`, `llvm-ar`, `llvm-ranlib`, `llvm-nm`, `llvm-objcopy`, `llvm-strip`, `llvm-readobj`, `llvm-readelf`, `llvm-size`, and `llvm-config` when the recipe requires it. - [ ] Build only declared compiler-rt, libunwind, C++ runtime and compression/runtime dependencies; test C/C++ allocation, TLS, threads and exceptions as required by those exact compiler binaries. - [ ] Port/verify Python 3 and required standard modules, including the selected compression, FFI and optional database extensions used by EriX scripts. - [ ] Port/verify CMake, Ninja, GNU make, pkgconf/pkg-config and declared bash use; test generated build rules, subprocess pipes and parallel job limits. - [ ] Port/verify offline Git operations: init/status/diff/log/checkout, exact local revision resolution and offline Cargo Git dependency use; disable fetch/network paths and preserve exact commit identity in manifests and caches. - [ ] Port/verify archive/compression tools: tar, gzip, xz, zstd and bzip2, with reproducible round trips, permissions, symlinks and path-escape rejection. - [ ] Port/verify required patch/diff/cmp/find/grep/sed/awk/sort/install and file/object-probe behavior not supplied by native tools; record exact options. - [ ] Port/verify extended-dev Autotools support: m4, autoconf, automake, libtool, bison, flex and Perl with a representative configure/build fixture. - [ ] Admit dependency-only zlib/bzip2/liblzma/zstd/libarchive/libuv/libffi/ sqlite/pcre2/expat/gettext/iconv/terminfo/readline components only when selected tools require them; disable optional TLS/download/network features for Phase 6. - [ ] Resolve required image/filesystem, Markdown and TeX tool dependencies through [Extended payloads and image isolation](https://git.erikinkinen.fi/erix/integration/issues/4) or clean-room equivalents. No unlisted helper may run on the external host during the final build to fill a missing guest tool. - [ ] Require every tool's smoke command, deterministic exit and minimal startup capability test before admission; version output alone is insufficient. - [ ] Run functional fixtures: Rust program/crate, offline Cargo workspace, build script and proc macro, C/C++ compile/link, Python bootstrap scripts, CMake/Ninja/make, local Git and archive/text round trips. - [ ] Run each tool class under missing/revoked grants, uid 0 metadata, out-of-tree paths, device names and unavailable network; verify denial and teardown without a compiler/tool-specific launch exception. - [ ] Profile real compiler/workspace builds and fix evidenced substrate bottlenecks through [Integration profiler and measured optimization](https://git.erikinkinen.fi/erix/integration/issues/3), preserving per-job resource ceilings and exact errors. - [ ] Rebuild the selected upstream Rust/LLVM toolchain and required runtime closure inside an extended development EriX realm using the supplied offline sources, recipes, dependencies and cross-built EriX-hosted bootstrap compiler/sysroot. Require the delivered build to work without unrecorded porting changes, implicit downloads, Linux executables or host build delegation. Verify EriX libc/ABI linkage, execute the guest-built tools and compile/link/run Rust and C/C++ fixtures, including build scripts and proc macros. Use the rebuilt compiler for at least one required full EriX build. Retain exact source/patch/bootstrap/tool/runtime hashes, complete logs, actual outcomes and measured memory/time requirements under explicit build quotas. Cross-compilation and version output alone do not satisfy this acceptance. </details> ### Native tools and full build/packaging pipeline Weight: 5%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/8) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [x] Provide a signed/hash-verified source bundle of all exact component revisions, locks, recipes, configs and local dependency metadata with no EriX precompiled output. Reject missing or unexpected sources before building. - [ ] Implement the build realm: immutable source/toolchain inputs, separate write-only-as-needed build/output/tmp trees, explicit execution and child lifecycle authority, fixed locale/time policy and bounded resources. - [ ] Resolve source-write assumptions by declaring writable generated worktrees separately from immutable originals; never silently grant compiler writes to the source authority root. - [ ] Adapt component orchestration and Cargo override/lock resolution for fully offline EriX execution; record every invoked guest tool, target, input/output digest and job dependency. Remove host `/proc`/`/sys` assumptions. - [ ] Build EriX-hosted `boot-tool`, `sha2-tool` and every other maintained build helper inside EriX before using them to produce final artifacts; the first two use native EriX APIs through [Native tools and full build/packaging pipeline](https://git.erikinkinen.fi/erix/integration/issues/8), not a POSIX-only port. - [ ] Build the complete target/profile graph from [Scope, repository and build inventory](https://git.erikinkinen.fi/erix/integration/issues/1), including all services/libraries, kernel, EFI bootloader and Integration test artifacts; fail if a catalog entry is silently skipped due to missing build configuration. - [x] Implement the initial executable offline component plan with original source, workspace and feature binding, covering native libraries, objects, EFI, host tools and source-only inputs. [Implementation PR](https://git.erikinkinen.fi/erix/integration/pulls/479). - [x] Complete maintained clean and extended dev/release runtime/profile inputs, preserving original configuration ownership and actual Cargo query selection. [Profile matrix](https://git.erikinkinen.fi/erix/integration/pulls/538) · [Extended inputs](https://git.erikinkinen.fi/erix/integration/pulls/546). Full variant artifacts, image builds and guest runs remain separate gates. - [ ] Produce and verify the complete native artifact graph without skipped components or incompatible source/ABI closures. - [ ] Execute the complete target/profile graph inside EriX with the admitted guest toolchain and actual dependency/output evidence. - [ ] Generate complete dynamic/launch/boot manifests and signed `boot.img` inside EriX, with deterministic source epoch, ordering, padding, feature identity and no preassembled host artifact substitution. - [ ] Resolve current `dd`, `debugfs`, `mkfs.fat`, `mkfs.ext4`, `mcopy`, `mmd`, `sgdisk`, truncate/hash/compression and Python packaging dependencies. Prefer a reviewed image-file-only path using owned code where appropriate; any imported alternative needs [Extended payloads and image isolation](https://git.erikinkinen.fi/erix/integration/issues/4) admission and actual guest functional tests. - [ ] Assemble GPT, FAT ESP and ext4 partitions into ordinary output image files inside EriX, without granting the build realm raw block, mount administration or access to the currently running disk device. - [ ] Build clean dev/release and explicitly selected extended profiles with equivalent validated boot/runtime closures; verify clean images exclude imported compiler payloads even though an imported compiler produced them. - [ ] Define least-authority artifact signing: a build requests signing of an exact reviewed artifact identity under a dedicated test/development key policy; no private key bytes, broad key service or release key enter the realm. - [ ] Produce checksums, compression, manifests, generated API references and complete technical manual within EriX using the declared tool closure. Run warning-free guest fmt/Clippy/unit/documentation checks on built sources. - [ ] Implement restartable build steps with verified input/output cache identities, bounded parallelism, meaningful progress and deterministic cleanup; final clean-build evidence must disable reuse of prior EriX outputs. - [ ] Test failed compiler, OOM/ENOSPC, interrupted build, malformed cache, signer denial and partial image creation; retain diagnostics and remove only owned temporary artifacts without corrupting source or running media. - [ ] Verify image-file parsing, signatures, partition/filesystem metadata, payload closures and reproducibility inside EriX before exporting results for independent host inspection/boot orchestration. - [x] Separate `boot-tool` and `sha2-tool` command/format/hash logic from platform I/O; specify native EriX and Linux backends sharing exact CLI, errors, output and artifact formats without routing the EriX backend through libc. - [ ] Port `sha2-tool` to native startup/CLI/stdio/file capability APIs; stream large inputs, preserve stdin/file modes, bound temporary storage and retire all input/output grants on success, denial and interruption. - [x] Publish and document the portable [owned-region primitive](https://git.erikinkinen.fi/erix/lib-owned-region/issues/1), with no implicit allocation or endpoint authority and its unit/lint/CI checks complete. - [ ] Validate Kernel adoption with authenticated allocator backing, all required native profiles and allocator VM controls. - [ ] Publish correlated recipient-view disposal and actual provider interoperability in [LibStdio](https://git.erikinkinen.fi/erix/lib-stdio/pulls/2) and [Launchd](https://git.erikinkinen.fi/erix/launchd/pulls/2), with current documentation and CI. - [ ] Implement exact owned stream transport with recoverable original invocation custody, once-only receipt accounting and full-width errors; abandoning a wrapper must not lose its owners. - [x] Authenticate native startup and every raw CLI operand occurrence against the exact granted inventory; exclude unwanted session, service and host authority. - [x] Implement native streaming hashes for stdin and explicit files, bounded temporary storage, partial output progress and explicit EOF. - [ ] Retire or transfer original invocations, recipient views, grants, mappings and backing in the required order on success, denial and interruption. - [ ] Build and document the [native SHA tool](https://git.erikinkinen.fi/erix/sha2-tool/issues/1), with format, strict lint, unit/build checks and current CI free of warnings. - [ ] Pass new native VM cases for empty/large/malformed inputs, host/native parity, wrong or missing grants, lender survival and complete teardown. - [ ] Port `boot-tool` image operations to native EriX file/stream APIs; preserve build/inspect/verify/signing-payload semantics and the detached signer boundary. Neither platform backend may gain implicit private-key access. - [x] Implement startup-bound single-parse preparation and original file occurrences/output descriptions without acquiring file or publisher grants. - [ ] Implement native entry, allocator, whole-file reads and stdio through shared EriX clients while keeping Linux behavior usable. - [ ] Implement exact prepared broker attenuation and atomic-output publication across the native client, Launchd, Vfsd and filesystem providers. - [ ] Preserve first errors, partial effects and original owner custody through success, denial, abort, interruption and complete final retirement. - [ ] Complete native component checks, meaningful backend/parity coverage and documentation for the full implemented command scope. - [ ] Keep Linux targets usable with the existing CLI and build recipes; test shared logic plus both backends and byte-identical image/hash output from the same fixture inputs, including empty, large and malformed files. - [ ] Package both native executables/metadata/man pages on ext4, add scoped launch contracts and new serial/PS2 in-OS CLI tests for both tools; test wrong/missing grants and partial-output cleanup without program-specific launch authorization. - [x] Implement native SHA-2 build, workspace, command/launch metadata and ext4 installation producers without program-specific authority grants. - [ ] Implement the corresponding native Boot-tool packaging path. - [ ] Author complete serial/PS2 positive, wrong/missing-grant and partial-output cleanup scenarios for both native tools. - [ ] Build the actual ext4 images and pass these native guest cases. - [ ] Use the newly guest-built native tools in [Two-generation self-hosting demonstration](https://git.erikinkinen.fi/erix/integration/issues/9) for image operations and checksums; show Linux regression CI remains green and no host fallback or POSIX adapter secretly performs their native guest operations. </details> ### Two-generation self-hosting demonstration Weight: 6%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/9) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Freeze the acceptance source/toolchain/recipe/image hashes, complete output inventory, resource/timeout policy and exact build command in a reviewed runbook. Fix all prerequisites before declaring the timed demonstration started. - [ ] Provision a private seed extended image with admitted EriX-hosted tools and source-only inputs. Use an empty output tree and no prior EriX object, incremental, image, generated-metadata or host tool cache. - [ ] Boot the seed EriX and record guest identity, native process/realm provenance, mounted authority inventory and tool versions; disable networking and host shared-directory/build-RPC fallbacks. - [ ] From exsh in that EriX session, execute the complete build command. Record each compile/link/generate/sign/package step as an EriX process with exact input/output evidence and actual exit status. - [ ] Complete all [Scope, repository and build inventory](https://git.erikinkinen.fi/erix/integration/issues/1) outputs, including every EriX component, signed boot image, UEFI loader, clean dev/release disks, selected extended disks and generated documentation/manifests. Compare inventory cardinality and hashes; a missing target or substituted prebuilt output fails the demonstration. - [ ] Run guest fmt/strict Clippy/unit/doctest checks and relevant guest tool/authority-negative tests on that graph; preserve zero-warning full logs. - [ ] Validate partition/ELF/signature/source closure, then export only completed artifacts/evidence through an explicitly authorized path. The host may record, independently verify and boot them, but may not repair or assemble a missing build output. - [ ] Boot the newly guest-built clean dev and release images and run their canonical runtime probes; boot the guest-built extended-dev image for the second-generation build. Record exact booted image hashes. - [ ] In that newly built EriX, provision the same immutable sources/tools and fresh empty output/tmp trees, then perform a second complete build without importing first-generation compiled EriX artifacts or mutable caches. - [ ] Compare first/second-generation complete artifact inventories and deterministic bytes/signatures using the fixed inputs. Investigate every difference; normalization is allowed only for fields explicitly specified before the run, never to erase unexplained payload differences. - [ ] Run the complete maintained VM catalog and post-image probes on matching guest-built artifacts. The external supervisor may start test VMs; nested virtualization inside EriX is not required and must not conceal a host-side build step. - [ ] Demonstrate source read-only, output/tmp confinement, executable scope, no device/raw-block/key/network/global discovery and no cross-realm control; test denied access, interrupted build and complete realm teardown. - [ ] Profile the self-host builds, report actual elapsed/CPU/I/O/memory figures and apply the predeclared budgets; close proven bottlenecks through reviewed fixes and a new complete evidence cohort, not partial retries to green. - [ ] Publish a reproducible evidence bundle: source graph, manifests, tool licenses/recipes, commands, full logs, profile summaries, negative tests, output hashes/signatures, boot/test results and independent review. - [ ] Include [Signing, rootfs verification and UEFI Secure Boot](https://git.erikinkinen.fi/erix/bootloader/issues/1) trust-chain verification in both generations: custom-key Secure Boot, signed boot image and all rootfs authority/code objects. Exercise tampering/revocation failures before declaring the guest-built result accepted. - [ ] Initiate/observe the build through [Extensible serial/PS2 CLI input harness](https://git.erikinkinen.fi/erix/integration/issues/5)'s real serial/PS2 CLI input paths, run native boot/hash tools, and verify [Consoles, vttys, mouse, TUI and boot logo](https://git.erikinkinen.fi/erix/ttyd/issues/1)'s independent TTY/default-clear behavior, vtty switching, mouse selection/paste, boot logo and help/man/extop acceptance on the newly produced images. </details> ### Final CI, audits and alpha-review handoff Weight: 4%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/10) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Run final fmt, default/all-valid-feature strict Clippy, unit tests, doctests, target/profile builds and rustdoc for every altered repository at its exact final signed revision, with no warnings and no unexplained skipped tests. - [ ] Verify every new runtime feature has positive, authority-negative, malformed-input, interruption/cleanup and bounded VM integration coverage. - [ ] Run the full old-plus-new VM catalog and all canonical/post-image probes; reconcile authored scenario counts, source/worker ownership, expected exits, images and retained failures. Existing 486 cases are a baseline, not a fixed future denominator that permits dropping tests. - [ ] Enforce real per-scenario hard/stall deadlines and owned-process cleanup in CI; test stalled guests/helpers fail and release their worker. Report progress throughout long full-build jobs without fabricating liveness. - [ ] Monitor exact-head CI for every repository, including nested crates and older unit/VM regressions; classify pending/cancelled/stale/missing evidence separately. Fix failures and warning-bearing green jobs before acceptance. - [ ] Keep Rust fmt/Clippy/tests in each crate's canonical `ci.yml`, including Integration's library job; remove unsupported Forgejo workflow permissions fields and use authorized integrations only for needed capabilities. - [ ] Re-run the independent whole-codebase [Whole-codebase authority and quality audit](https://git.erikinkinen.fi/erix/integration/issues/2), [Rustdoc, missing_docs and documentation](https://git.erikinkinen.fi/erix/docs/issues/1) audit and check zero deprecated APIs, over-limit authored code files, missing inline docs and unresolved ambient/residual/unwanted explicit authority findings. - [ ] Verify compiler/dependency commit-pin policy, clean/extended image isolation, signed source/artifact provenance, reproducibility and rollback/ upgrade behavior for changed persistent or ABI contracts. - [ ] Re-run uninstrumented startup and declared build-performance gates on the final graph; an earlier candidate's speedup or predecessor CI cannot certify a later graph. - [ ] Reconcile every component's canonical README/ARCHITECTURE/ROADMAP, `docs/phases/6.md`, manual/API references and operator self-hosting runbook with observed behavior, supported limits and exact final evidence. - [ ] Push all final signed `feature/posix-compat` trees and coherent Integration pins; verify remote heads/signatures and their own terminal CIs. Do not silently merge, retag, rewrite history or replace main images. - [ ] Close [canonical acceptance criteria](https://git.erikinkinen.fi/erix/docs/src/branch/main/phases/6.md) using the linked acceptance contract, record final percentage and remaining later-phase non-goals, and request explicit promotion direction for accepted images. Do not declare Phase 6 complete before [Two-generation self-hosting demonstration](https://git.erikinkinen.fi/erix/integration/issues/9), [Final CI, audits and alpha-review handoff](https://git.erikinkinen.fi/erix/integration/issues/10) actually pass. - [ ] Close the supplementary [Public Forgejo issues and PRs](https://git.erikinkinen.fi/erix/meta/issues/2), [Extensible serial/PS2 CLI input harness](https://git.erikinkinen.fi/erix/integration/issues/5), [Signing, rootfs verification and UEFI Secure Boot](https://git.erikinkinen.fi/erix/bootloader/issues/1), [Consoles, vttys, mouse, TUI and boot logo](https://git.erikinkinen.fi/erix/ttyd/issues/1) and [Whole-codebase authority and quality audit](https://git.erikinkinen.fi/erix/integration/issues/2), [Rustdoc, missing_docs and documentation](https://git.erikinkinen.fi/erix/docs/issues/1)/[Shell, utilities, help and manual pages](https://git.erikinkinen.fi/erix/exsh/issues/1), [Native tools and full build/packaging pipeline](https://git.erikinkinen.fi/erix/integration/issues/8) gates, including signed downloadable boot artifacts, all-file authority verification, real-input CLI coverage, native tools, manuals and human-legible documentation/code. - [ ] Reconcile public issues, PR checklists, evidence links and this tracker; remove "WIP: " only from genuinely accomplished PR goals and leave unresolved/dependent work visibly open. - [ ] Prepare the `v1.0.0-alpha.1` manual-review dossier: complete source graph, self-host proof, security/CI/performance results, licenses, custom-key enrollment/recovery instructions and known non-goals. Wait for explicit manual approval before merges, version promotion, release tags or artifact promotion. </details> ### Public Forgejo issues and PRs Weight: 2%. [Owning issue](https://git.erikinkinen.fi/erix/meta/issues/2) · [meta PR 4](https://git.erikinkinen.fi/erix/meta/pulls/4). <details> <summary>Checklist</summary> - [x] Verify the deployed Forgejo version, authenticated identity and minimum organization/repository permissions using the authorized credential without exposing it; do not assume another version’s API support or silently widen privileges. - [x] Create public work-package and bounded implementation/audit issues in the owning repositories, with descriptive titles, dependency links, acceptance criteria and authority rationale. Preserve confidential coordination identifiers and evidence. - [x] Maintain an idempotent issue/PR mapping and update process; detect existing objects before creation, preserve human edits, and avoid duplicates or unsupported completion claims. Keep this master checklist, totals, dependencies and evidence current whenever scope or acceptance changes. - [ ] Ensure every altered repository, including docs/meta/new libraries, has a `feature/posix-compat` PR with the exact "WIP: " title prefix after its first pushed checkpoint; use draft mode as well if supported, not instead of the required prefix. Link dependent PRs and the matching component graph. - [x] Maintain one matching current-head WIP feature PR for every altered repository. - [ ] Complete explicit dependent-PR and matching component-graph links in every affected review. - [ ] Keep PR descriptions current with implemented versus planned scope, security decisions, validation/failures, exact CI revisions and issue references. Publish concise meaningful progress rather than private raw logs. - [x] Publish source-bound implementation, validation and failure checkpoints in owning PRs. - [x] Reconcile stale descriptions and condense accumulated history into current reviewable scope. - [ ] Keep subsequent implementation and final coordinated CI descriptions current. - [ ] Make public updates through the user's authorized account/configured identity without mentioning AI-agent attribution; never assert the user has personally reviewed, approved or signed something when that has not occurred. - [ ] Keep API tokens, signing secrets, private paths/logs and sensitive vulnerability detail out of public issues, PRs and artifacts; restrict actual security reports as required while recording a non-sensitive tracking link. - [ ] For every new repo, verify absence, create remotely from `meta` as template, verify static-file inheritance, clone, branch, specialize and open its WIP PR. Add audit/CI/docs/manual/catalog and public issue records before consumers depend on it; no local-first blank repository substitution. - [x] Verify absence and create the three compatibility repositories remotely from Meta. - [x] Clone/branch them, verify governance inheritance and create owning issues and WIP PRs. - [ ] Complete runnable Posixd specialization and every new component catalog/consumer entry. - [ ] Complete audit, validation and documentation obligations before full consumer admission. - [ ] Close an issue and remove "WIP: " only when its declared goal and required cross-repository/CI gates actually pass; keep the coordinated Phase 6 PR WIP until the whole phase is accomplished. Readiness is not merge approval, and successful Phase 6 is not alpha-release approval. - [ ] Reconcile all altered repositories, open issues, PR states and local progress at each milestone/final handoff; link each accepted result to its signed revisions and public review evidence. - [x] Reconcile current branches, 66 altered-repository WIP heads and the public issue mapping. - [x] Retain signed-source and public readback evidence for implemented milestones. - [ ] Complete all remaining current-scope/CI discrepancies and final coordinated handoff. </details> ### Extensible serial/PS2 CLI input harness Weight: 3%. [Owning issue](https://git.erikinkinen.fi/erix/integration/issues/5) · [integration PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). <details> <summary>Checklist</summary> - [ ] Inventory current serial/physical helpers, guest-script injection, direct orchestration launch and output oracles; separate genuine CLI tests from low-level protocol/kernel fixtures before migrating them. - [x] Identify existing serial, physical-input, transcript and runner ownership paths in the maintained harness. - [ ] Complete the CLI-versus-low-level scenario inventory and migration/disposition map. - [ ] Define a versioned input-backend interface for capabilities, connect/select-session, send text, press/release keys, modifiers/chords, synchronization and teardown; keep scenario intent independent of transport. - [ ] Implement serial input over an explicitly selected UART/PTY route, including encoding, line endings, fragmented escapes, partial writes, reconnect policy and bounded backpressure without bypassing seriald/ttyd. - [ ] Implement PS/2 keyboard input through the emulated device path, including scan codes, make/break, modifiers, repeat, arrow/delete and secure attention; do not inject directly into the shell or trusted-input endpoint. - [ ] Make unsupported backend capabilities explicit and reject them before a test starts; document how a future USB/HID or other backend plugs in without changing every scenario or inventing synthetic trusted input. - [ ] Bind commands and observations to one exact TTY/session per run. For independent terminals, PS/2 completion must use its framebuffer/session output, not unrelated serial log stamps; never send a command through both backends and accept whichever output happens to arrive. - [ ] Implement transcript expectations for exact output, status, prompt, cursor/redraw, timeout and completion, with structured failure context; screenshots/framebuffer state must corroborate visual assertions where needed. - [x] Retain exact command/prompt/status and bounded structured failure observations in current serial/physical helpers. - [ ] Complete shared session-bound cursor/redraw/visual expectation semantics. - [ ] Corroborate all required visual assertions with the selected framebuffer/session evidence. - [ ] Add fake-backend unit tests for partial input, key-up cleanup, malformed escapes, stuck modifiers, cancellation and stale sessions; hard-bound helper/QEMU lifetimes and retain original status on observation failure. - [ ] Add real serial and PS/2 VM tests for editing/history, pipelines, redirection, Ctrl-C, foreground/background jobs and y/n plus Enter consent; prove ordinary input cannot impersonate trusted approval or another TTY. - [ ] Migrate CLI/tool acceptance scenarios to the shared real-input API, including boot-tool, sha2-tool, help, man, extop and self-host build commands; preserve existing assertions and record every renamed/retired case mapping. - [ ] Keep low-level non-CLI protocol/negative fixtures when needed, but do not count directly launched test scripts or hidden rootd orchestration as primary evidence that a user can operate a CLI tool. - [ ] Run backend coverage in CI for serial-only, framebuffer/PS2-only, independent dual and explicitly mirrored modes; preserve existing hard/stall limits and exact source/image/session evidence. - [ ] Remove superseded one-off CLI input adapters after migration, document authoring a new backend/scenario, and add a coverage gate preventing new CLI acceptance tests from silently bypassing the primary input harness. - [ ] Make physical text injection layout-aware while keeping explicit raw key/scan-code fixtures available; run US/Finnish punctuation, modifier and trusted-input cases under the actual boot preference. Serial sends text bytes directly and must not be translated a second time as keyboard scan codes. Record layout and key sequences; use independent expected vectors rather than the production keyboard translator as its own test oracle. - [ ] Extend the physical backend with PS/2 mouse movement and explicit left/middle/right press/release actions, preserving packet boundaries and validated device ingress; never substitute host clipboard or direct guest terminal-state writes for mouse acceptance evidence. - [ ] Add explicit Ctrl+Alt+Fn selection and target-vtty expectations, including held/released modifiers, invalid targets and switching during output or prompts; observe the selected framebuffer vtty rather than a serial sibling. - [ ] Add reproducible visual/text assertions for hidden/revealed cursor, selection and pasted text, plus early boot-logo screenshots tied to exact image/asset hashes. Preserve bounded observation and input teardown on failures. </details> ### Signing, rootfs verification and UEFI Secure Boot Weight: 5%. [Owning issue](https://git.erikinkinen.fi/erix/bootloader/issues/1) · [bootloader PR 3](https://git.erikinkinen.fi/erix/bootloader/pulls/3). <details> <summary>Checklist</summary> - [ ] Inventory the complete trust chain and all authority-controlling root-partition files: executables, libraries, scripts/interpreters, plugins, loader/runtime/launch manifests, service/mount/realm policies, key policy and configuration/includes that can change authority. No code object is exempt because it is imported, generated at runtime or not marked executable. - [ ] Define verification ownership and an authenticated chain from enrolled firmware trust to EFI loader, boot.img, rootfs policy and every admitted executable/library. Existing bare digests are not the requested signature proof. - [ ] Specify a per-file signature or signed catalogue entry authenticating exact final bytes, length, role, relevant metadata/path binding, format/version, dependency closure and signer/policy generation. Every covered file must have verifiable signed coverage; unsigned sidecar hashes are insufficient. - [ ] Specify an acyclic finalization/signing DAG: finish code generation, stripping and capacity/metadata patches before object signatures, finalize authority catalogues before their boot trust anchor, then sign/package final EFI/boot/disk outputs. Avoid circular digest dependencies and post-sign edits. - [ ] Separate firmware PK/KEK/db/dbx certificates/keys from boot/rootfs signing keys and development/build-realm keys; document trust roots, allowed signer roles, rotation/revocation and recovery without reusing a general key. - [ ] Implement signed authority-file generation and verification in maintained tooling with independent known-answer, malformed-format, wrong-role, wrong-key, truncation, tampering and signature-coverage tests. - [ ] Verify policy bytes before applying policy or delegating authority; verify executables and complete library/interpreter/module closures before execution/initializers. Integrity or signer identity alone grants no capability. - [ ] Preserve fresh-object binding from signature verification to use; reject replacement, symlink/race/substitution and stale cache attacks, including lazily read executable pages and reused file handles. Never verify one object and map/execute another or mutable bytes from the same reopened path. - [ ] Define authorized policy/code update and rollback behavior with atomic verified publication, cache invalidation, revocation and interrupted update recovery. Do not promise anti-rollback without a reviewed trusted version/revocation anchor beyond attacker-replaceable disk data. - [ ] Define scoped signing/admission for newly built test programs, Cargo build scripts, proc macros, plugins and compiler outputs before executing them. Bind development signatures to the build realm/output policy; no unsigned output exception or general trusted-system signing oracle is allowed. Separate transient realm-generation-bound admission from reproducible final artifact signatures under fixed declared keys/policy; do not normalize away unexpected final signature differences in [Two-generation self-hosting demonstration](https://git.erikinkinen.fi/erix/integration/issues/9). - [ ] Implement the build-output signing route with exact artifact identity, authorized operation, finite lifetime and complete cleanup; keep private key material out of ordinary build processes and `boot-tool` itself. - [ ] Add rootfs tamper VMs for every object/policy class, missing/wrong/ revoked signatures, catalogue substitution, mixed generations and dependency replacement; prove no code runs and no new authority is installed on failure. - [ ] Add an explicit CI signing configuration using a private key from Forgejo secrets for downloadable `boot.img`; separate local test-key builds from protected signed publication and fail closed when required secrets are missing. Never silently fall back to the repository test key for downloads. - [ ] Restrict signing secrets to approved trusted workflow/ref contexts and an isolated signing stage consuming immutable verified artifacts; untrusted PR/fork code and ordinary compile/test scripts receive no signing key. - [ ] Pass secrets through a reviewed non-logging channel to the narrow signer, scrub owned temporary material on success/failure/cancellation and exclude it from caches, dumps, job logs and uploaded artifacts. Verify secret absence without printing/search-reporting its actual bytes. - [ ] Preserve boot-tool's detached payload/signature/verification contract; record public key fingerprint, exact signing payload/artifact hashes, source graph and signing policy without exposing private credentials. - [ ] Publish an explicitly named signed `boot.img` plus verification material/provenance per profile/key cohort, and ensure every downloadable disk contains its corresponding exact tested signed payload and rootfs authority closure; verify downloaded bytes independently of local publisher status. Protected CI re-signing/repackaging creates a separately verified/tested cohort, not a byte-identical [Two-generation self-hosting demonstration](https://git.erikinkinen.fi/erix/integration/issues/9) result or permission for hidden host build completion. - [ ] Test protected signing success, missing/wrong secret, untrusted-ref denial, modified input, signer failure and cancellation; publication must stop on failure and no unsigned/test-key output may be mislabeled trusted. - [ ] Implement full supported-platform UEFI Secure Boot packaging with a custom EriX/user-controlled certificate: sign the PE/COFF EFI loader in the firmware-required format and keep its verification material consistent with boot/rootfs trust. An Ed25519 boot.img signature is not firmware EFI signing. - [ ] Provide documented custom PK/KEK/db/dbx enrollment, owner-authorized updates, certificate distribution and revocation/recovery procedures without dependence on a Microsoft signature. Back up existing enrollment and require explicit approval before changing real firmware variables or owner keys. - [ ] Define enforced versus explicitly non-enforced development boot modes and check SecureBoot/SetupMode state where appropriate; never report successful enforcement while firmware is in setup mode or validation is off. - [ ] Add QEMU/OVMF Secure Boot fixtures with private firmware-variable storage and custom enrollment; prove correct-key boot and refusal of unsigned, wrong-key, tampered and revoked EFI images without a permissive fallback path. - [ ] Exercise the full enforced chain with tampered boot.img, rootfs policies, executables and shared libraries; firmware success alone cannot close downstream verification gates. Include both clean and extended profiles. - [ ] Test key rotation/revocation, interrupted updates and documented recovery using independent fixtures, preserving least authority and a usable owner recovery path rather than silently disabling verification. - [ ] Perform a manually approved real-firmware enrollment/boot/rejection validation on the supported hardware baseline; record firmware versions and limitations. OVMF evidence alone is not a claim of universal firmware support. - [ ] Audit signing/verification code and CI boundaries independently, update threat models/rustdoc/man/manual and include malformed crypto/container inputs without introducing third-party code into clean-room components. - [ ] Verify normal signed loading does not retain signer/admin authority in loaders or applications; profile verification overhead through [Integration profiler and measured optimization](https://git.erikinkinen.fi/erix/integration/issues/3) and optimize only exact immutable identities with sound invalidation. - [ ] Include signing/trust tests in the full CI and both [Two-generation self-hosting demonstration](https://git.erikinkinen.fi/erix/integration/issues/9) build generations, using scoped development keys for self-host proof and protected CI signing for downloadable outputs; document the distinct trust policies. - [ ] Produce an operator verification/enrollment/recovery runbook and alpha-review evidence showing the exact EFI→boot→rootfs trust chain, public verification keys and download hashes, with no private signing material. - [ ] Design/version a distinct **unsigned user-preference section in `boot.img`**, separate from signed executable/configuration/authority data. Whitelist non-authoritative typed settings, initially keyboard-layout ID; preferences cannot select trust roots, bypass verification, choose executables, alter capability/realm policy or grant device/namespace access. - [ ] Authenticate the container format and section directory/bounds, including the precise permitted unsigned extent. Exclude only that preference payload from the boot signature's authenticated message; verify every security- relevant byte and reject overlap, aliasing, truncation, confused versions and attempts to reinterpret signed bytes as preferences. Give the preference descriptor an authenticated explicit hash policy: no signed section hash may still depend on mutable preference bytes. Any optional corruption checksum for those bytes lives inside their unsigned extent. - [ ] Implement build/read/update tooling for preferences without private signing authority, preserving all authenticated bytes, section extents and signatures. Record separate full-container digest and signed-content identity: preference edits change the former, not the latter; refresh local artifact receipts without falsely claiming an edited image matches published checksums. Coordinate any outer boot-image/catalog authentication so it anchors signed core identity, not a whole-file digest that silently forbids unsigned edits; retain whole-file digests as exact distribution/integrity evidence. - [ ] Parse preferences as bounded untrusted input with deterministic absent/malformed/unsupported-value handling, defaulting keyboard layout to `en_US`. Malformed preference content may fall back, but malformed authenticated structure or signature failure must still fail closed, never enter fallback. - [ ] Carry the validated preference value to its consumers as explicitly non-authoritative data, distinct from trusted clear-completion and authority handoff fields. Only select packaged, signed, allowlisted keyboard definitions; preference text cannot load a script, plugin, arbitrary path or mapping code. - [ ] Add signature/container unit tests and VMs showing layout-only preference edits preserve Secure Boot/boot-content verification, while changing signed code, policy, bounds, key selection or verification flags is rejected. Test integer overflow, unknown/duplicate keys, padding and recovery defaults. - [ ] Version boot-image/handoff parsing and every consumer's trust classification for unsigned preferences; do not reuse `MUTABLE_AFTER_BOOT` or descriptors promising all bytes were signature-verified as an unsigned bypass. Update format/coverage vectors, boot-tool/manual docs and negative version tests together, then retire superseded intake under [Whole-codebase authority and quality audit](https://git.erikinkinen.fi/erix/integration/issues/2) without a permissive fallback. - [ ] Keep the optional boot-logo bitmap and its type/dimensions/format under signed boot-image coverage, separate from unsigned user preferences; decode/render it only after authentication. Logo substitution cannot extend the unsigned region, select executable content or alter authority handoff. </details> ### Consoles, vttys, mouse, TUI and boot logo Weight: 2%. [Owning issue](https://git.erikinkinen.fi/erix/ttyd/issues/1) · [ttyd PR 3](https://git.erikinkinen.fi/erix/ttyd/pulls/3). <details> <summary>Checklist</summary> - [ ] Add strictly boolean `[features].fbcon_clear`, default `true`, to runtime/build configuration, schema, parser, feature identity and documentation; reject malformed values and test omission, true and false. - [ ] Apply the option to early and userspace framebuffer initialization. Clear once before the first console output when enabled; when disabled neither initializer may erase existing content merely because it starts. - [ ] Carry validated framebuffer identity/geometry and an early-clear completion record through the trusted handoff; if early fbcon already cleared the screen, user fbcon adopts it without another clear. Do not treat arbitrary descriptive startup bytes as proof of a trusted completed clear. - [ ] Preserve pixel format/stride/padding, cursor and output continuity; replace conflicting unconditional release/early clears and test that late initialization never erases valid early logs. Normal explicit TUI clearing remains separate from this initialization-only build option. - [ ] Add unit and framebuffer VM coverage for early-only, user-only, both and neither console with clear enabled/disabled; assert exact clear count, final pixels and handoff failure behavior, not just a serial READY marker. - [ ] Set `tty_mirror = false` in both canonical dev/release images; align sample/extended defaults with independent terminals and retain explicit mirrored fixtures so the optional feature remains tested. - [ ] Validate both enabled paths create distinct shells/sessions with separate input/output/cwd/history/foreground jobs/consent and adequate declared capacity; single-path and no-TTY configurations still work without extra grants. - [ ] Preserve frozen [Phase 5 handoff and remaining gates](https://git.erikinkinen.fi/erix/integration/issues/6) timing comparisons as their original cohort, then measure the new dual-shell default separately using [Extensible serial/PS2 CLI input harness](https://git.erikinkinen.fi/erix/integration/issues/5) session-bound observations. Do not attribute a policy/workload change to a kernel speedup or relax the carried limits; report each terminal's full startup/command evidence. - [ ] Specify/version improved fbcond TUI operations: absolute/relative cursor position, visible cursor, erase regions, colors/attributes, rectangular cell updates, scrolling regions, viewport/resize and frame completion. - [ ] Implement bounded validated rendering batches/dirty regions, geometry/capacity checks and deterministic malformed-request behavior without granting raw framebuffer memory or global-screen ownership to clients. - [ ] Expose TUI through session-scoped tty mediation backed by fbcond, with clear renderer versus terminal ownership. Keep trusted powerbox chrome protected; ordinary clients cannot draw over it or steal focus/consent input. - [ ] Implement serial-terminal equivalents or advertised graceful fallbacks over the same session-level interface; define supported capabilities explicitly rather than claiming compatibility with every ncurses extension. - [ ] Extend the shared terminal parser with required cursor/erase/color and alternate-screen behavior, including extop's existing home/full-erase needs; test split escape sequences, unsupported controls and dimensions. - [ ] Port extop to the new TUI interface with efficient frame updates, resize/navigation, screen restoration and interrupt/exit cleanup; retain its exact process-inspection/control authorities and never add broad console caps. - [ ] Implement trusted-prompt suspension/restoration during a TUI session, ensuring modal input is not consumed by extop and no previous trusted text or stale ordinary frame is replayed after focus/session changes. - [ ] Add parser/renderer unit tests and serial/PS2 visual VMs for cursor, erase, colors, scrolling, resize, extop refresh/quit/Ctrl-C, independent TTYs, prompt interruption and complete session/capability cleanup. - [ ] Profile full versus partial redraw, IPC count and extop input-to- frame latency; fix measured bottlenecks without skipping visible completion, and update IPC/Rust API man pages, tool manuals and operator documentation. - [ ] Define keyboard-layout ownership over layout-independent physical key events; retain driver/inputd raw identity and implement text translation at ttyd or a reviewed shared pure layout layer. Provide signed, clean-room `en_US` and `fi_FI` mappings with modifiers, Caps Lock, AltGr, punctuation, Unicode and Finnish dead-key behavior. Keep physical identity, navigation and control chords distinguishable from text. - [ ] Initialize the keyboard text translator from [Signing, rootfs verification and UEFI Secure Boot](https://git.erikinkinen.fi/erix/bootloader/issues/1)'s validated boot preference, default `en_US`; preserve consistent layout behavior for every physical keyboard client/session without double-translating serial input. Initially select layout at boot; later runtime layout changes require their own state-transition contract, not reinterpretation of buffered input. - [ ] Add a git-ignored local build override selecting `fi_FI` and include it explicitly in image identity/test receipts. Keep canonical dev/release, extended profiles and clean CI defaulting to `en_US`; explicit CI layout fixtures test Finnish without allowing a developer override to leak into publication. - [ ] Preserve secure-attention key identity and trusted consent fences; preference changes must not synthesize approval, reinterpret buffered keys or let ordinary layout processing consume trusted y/n plus Enter. Document which chords are physical and which text is layout-selected and display prompts consistently with those rules. - [ ] Add unit/real-input VM tests for both layouts, default/invalid preference fallback, local override isolation, modifier/dead-key release, repeated input, Unicode editor/delete behavior and trusted consent. Test both independent terminals and verify serial byte input remains unchanged. - [ ] Document keyboard selection and preference editing in boot-tool help/man, image/build docs and the technical manual, explicitly identifying unsigned convenience data versus signed security policy and code. - [ ] Replace single-byte-only text emission with checked UTF-8 sequences and backpressure-safe atomic character delivery; define dead-key composition, unsupported combinations, modifier release and pending-state reset on focus/ session/consent changes. Test interrupted multi-byte delivery cannot corrupt commands, leak pending text to another TTY or reinterpret it as trusted input. - [ ] Define multiple framebuffer vttys as distinct live terminal/session generations with their own shell, screen/scrollback, cursor, editing/history, cwd, foreground jobs and input state. Keep virtual-terminal records separate from the existing two physical framebuffer/serial console bindings. - [ ] Specify signed resource/count and creation/retirement policy for configured vttys, with at least two exercised in acceptance. Allocate/reuse only explicitly authorized session resources; an Fn ordinal cannot create processes or grant launch authority. Test exhaustion and safe focus fallback when a shell/vtty exits, without imposing an incidental fixed table limit. - [ ] Implement physical Ctrl+Alt+Fn switching directly to the configured framebuffer vtty identified by Fn. Admit this exact authenticated gesture without a separate manual secure-attention step, independently of keyboard layout; preserve existing trusted controls and reject nonexistent/stale targets. - [ ] Switch display and ordinary input focus atomically by exact live session generation; keep events bound to their receipt-time destination and handle held modifiers/releases without injecting them into the wrong vtty. Independent serial focus remains unchanged; test explicit mirrored mode too. - [ ] Cancel a pending trusted prompt when switching away, retaining the existing cancellation/cleanup contract; never transfer approval state to the destination. Restore ordinary content only after renderer acknowledgement and preserve fresh-input fences if a later prompt is created. - [ ] Retain inactive-vtty output in its own bounded terminal state and restore screen/cursor/selection on activation; handle resize, scrolling and extop alternate-screen updates without exposing another vtty or trusted chrome. - [ ] Add unit and physical-keyboard VMs for direct Fn switching, repeated switching, background output, exit/recreation, stale IDs, modifiers, both layouts, serial isolation and prompt cancellation. Profile switching/memory use and record the multi-vtty workload separately from frozen startup comparisons. - [ ] Implement a framebuffer mouse pointer that starts hidden and becomes visible only on the first authenticated nonzero movement, not button-only, resize or focus events. Define per-seat visibility across vtty switches; distinguish this pointer from the shell's text caret. - [ ] Validate signed deltas, button transitions, geometry and coordinate arithmetic; clip cursor drawing to the viewport and restore underlying pixels correctly during movement, redraw, scrolling, resize and vtty changes. - [ ] Implement left-button press/drag/release text selection and visible highlighting from the owning vtty's ordinary text model, including wrapped lines, Unicode/cell boundaries and scrollback. Bind selection to session and content revision; define updates while output changes during a drag. - [ ] Use conventional primary selection: completing a left-button selection copies its text, and middle-button press pastes it. Keep selection bytes scoped to the owning terminal/session by default; cross-vtty transfer requires explicit user-directed source/destination and realm policy, never a global clipboard or arbitrary screen-reading capability. - [ ] Deliver middle-button paste through the exact destination's ordinary input path with backpressure-safe ordering and no duplicate bytes. Define bracketed-paste/multiline/control-byte behavior so shell paste does not silently execute embedded newlines; require normal explicit submission. Do not apply keyboard layout translation to already selected UTF-8 text. - [ ] Exclude trusted chrome, consent input and other vttys from selection. Mouse selection/paste cannot approve, edit or queue answers to a trusted prompt; reject untrusted escape-sequence clipboard access and keep the host/serial terminal clipboard separate. Retire retained text on owner teardown/reuse. - [ ] Add independent unit and real PS/2 mouse/keyboard tests for initial hiding, button-only packets, first movement, bounds, pixel restoration, selection during redraw/scroll/resize, Unicode, middle paste, backpressure, vtty isolation and prompt races; prove cleanup and zero unintended authority. - [ ] Use [the logo asset](https://git.erikinkinen.fi/erix/docs/src/branch/main/logo_transparent.png) as the original boot-logo source, recording its exact digest and asset provenance. It is currently a 1024×1024 RGBA PNG. Preserve its artwork/transparency; define deterministic preprocessing/scaling rather than generating a new logo. - [ ] Convert the source at build time into a simple, versioned, bounded bitmap payload with explicit dimensions/pixel/alpha format; package it as an optional signed non-executable boot.img section. Keep general PNG decoding out of the bootloader unless a separately justified design requires it. - [ ] In the bootloader, draw the available authenticated bitmap at the screen's bottom center using validated GOP geometry. Preserve aspect ratio, alpha blend against the existing background and define deterministic fitting/ margins for small resolutions; never stretch or draw outside the viewport. - [ ] Fully validate pixel length, width/height/stride, format, arithmetic, alpha and destination bounds before drawing; test RGBA/BGRA, padding, clipping and overflow independently. Image data grants no framebuffer mapping authority. - [ ] Integrate drawing after the configured one-time clear, in both dev and release paths, independent of early text-log enablement. Preserve the clear-completion handoff so later early/user console initialization does not immediately erase the logo; define temporary text/logo placement and normal console takeover without hiding required readiness/error output. - [ ] Boot normally without the optional logo or a usable framebuffer. Define safe cosmetic-error handling for an authenticated but malformed bitmap; container/signature failure still follows the existing fail-closed policy. Release temporary logo buffers/module authority once no consumer needs them. - [ ] Add Linux and in-EriX asset-conversion/package parity tests and put conversion inputs/tools in the [Native tools and full build/packaging pipeline](https://git.erikinkinen.fi/erix/integration/issues/8), [Two-generation self-hosting demonstration](https://git.erikinkinen.fi/erix/integration/issues/9) build closure; the final guest-built images must not depend on an unrecorded host-side bitmap conversion. - [ ] Add bounded visual VM tests for logo present/absent, dev/release, clear true/false, early console on/off, both pixel formats and small/normal geometries; assert bottom-center placement/transparency and unchanged text. Test signed-logo tampering rejection and document the asset/format/build options in boot-tool man pages, canonical docs and the technical manual. </details> ### Alpha 1 execution, lifecycle and phase-review gates These are required alongside complete self-hosting. The [integrated microkernel gate](https://git.erikinkinen.fi/erix/integration/issues/207) remains the owning release checklist. - [ ] [Support full configurable preemption for Alpha 1](https://git.erikinkinen.fi/erix/kernel/issues/129) - [ ] [Define parent-death and orphan cleanup for Alpha 1](https://git.erikinkinen.fi/erix/procd/issues/61) - [ ] [Define essential-service failure behavior for Alpha 1](https://git.erikinkinen.fi/erix/rootd/issues/61) - [ ] [Provide orderly shutdown and reboot for Alpha 1](https://git.erikinkinen.fi/erix/rootd/issues/62) - [ ] [Demonstrate recovery to a known-good signed Alpha 1 image](https://git.erikinkinen.fi/erix/integration/issues/781) - [ ] [Define IPC progress and cancellation under contention for Alpha 1](https://git.erikinkinen.fi/erix/kernel/issues/130) - [ ] [Demonstrate forced termination of spinning and blocked processes](https://git.erikinkinen.fi/erix/procd/issues/62) - [ ] [Qualify clock domains and wall-time changes for Alpha 1](https://git.erikinkinen.fi/erix/timed/issues/14) - [ ] [Qualify secure entropy initialization and failure for Alpha 1](https://git.erikinkinen.fi/erix/integration/issues/782) - [ ] [Continuously find and fill gaps in the OS and toolchain phases](https://git.erikinkinen.fi/erix/docs/issues/96) - [ ] Complete the extended [resource-exhaustion acceptance](https://git.erikinkinen.fi/erix/integration/issues/202). ## Alternatives and tradeoffs Detailed designs and exact reproduction evidence belong in their owning records. Inventory, specification, source implementation and runtime acceptance remain distinct. Rebuilding selected upstream Rust/LLVM within EriX is required; independently implementing an EriX-owned compiler remains later work. Preserve the full guest and toolchain scope rather than substituting a smoke build. ## Tracking and rollout Related offline-build designs: [inventory-bound source bundle](https://git.erikinkinen.fi/erix/integration/issues/191) and [GPT image metadata writer](https://git.erikinkinen.fi/erix/lib-partition/issues/3), and [native GPT image initialization](https://git.erikinkinen.fi/erix/boot-tool/issues/7). Related build-input design: [completed Cargo preparation progress](https://git.erikinkinen.fi/erix/integration/issues/187). Related regressions: [manual table](https://git.erikinkinen.fi/erix/docs/issues/26), [SHA fixture provider](https://git.erikinkinen.fi/erix/integration/issues/188), [runtime fixture profiles](https://git.erikinkinen.fi/erix/integration/issues/189), [completed socket sends](https://git.erikinkinen.fi/erix/integration/issues/190). Related contract designs: [Kernel #56](https://git.erikinkinen.fi/erix/kernel/issues/56), [Kernel #57](https://git.erikinkinen.fi/erix/kernel/issues/57) [caller-owned lexical continuations](https://git.erikinkinen.fi/erix/exsh/issues/25) and [bootstrap namespace lifetimes](https://git.erikinkinen.fi/erix/lib-ipc/issues/12). [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) tracks the remaining native frame proof. Related defects: [native compiler target preflight](https://git.erikinkinen.fi/erix/integration/issues/170), [Vfsd stack exhaustion](https://git.erikinkinen.fi/erix/vfsd/issues/33), [Vfsd dependency graph](https://git.erikinkinen.fi/erix/vfsd/issues/34), [FAT catalog witness](https://git.erikinkinen.fi/erix/integration/issues/124), [initial-shell cleanup](https://git.erikinkinen.fi/erix/integration/issues/125), [Rootd marker inventory](https://git.erikinkinen.fi/erix/integration/issues/126), [disk error propagation](https://git.erikinkinen.fi/erix/integration/issues/127), [large ACL fixture](https://git.erikinkinen.fi/erix/integration/issues/128), [missing-Procd preparation](https://git.erikinkinen.fi/erix/integration/issues/129), [Bootloader path parsing](https://git.erikinkinen.fi/erix/bootloader/issues/8), [retired completion logging](https://git.erikinkinen.fi/erix/rootd/issues/8), [C ABI observation](https://git.erikinkinen.fi/erix/lib-posixabi/issues/8), [quiet-time fixture](https://git.erikinkinen.fi/erix/exsh/issues/18), and [test-crate documentation lint](https://git.erikinkinen.fi/erix/lib-ipc/issues/10), [default Rootd build graph](https://git.erikinkinen.fi/erix/integration/issues/789). Complete checklist items end to end and retain coherent interfaces, source identities and original failure evidence. Use canonical feature_request, bug_report and PR templates with phase-6 and applicable topic labels. Keep this checklist, weights, dependencies and relevant links current. Use comments for routine status and remaining work. Mention testing in status comments or commit messages when it concerns a linked defect. Edit bodies for checklists, requirements, design, scope and factual corrections. Write repository content, issues, PRs and comments in clear, natural engineering prose. Preserve human edits and verify each public change. <details> <summary>Related issues and PRs</summary> | Repository | Issues | PRs | | --- | --- | --- | | blockd | [#1](https://git.erikinkinen.fi/erix/blockd/issues/1), [#3](https://git.erikinkinen.fi/erix/blockd/issues/3) | [#2](https://git.erikinkinen.fi/erix/blockd/pulls/2) | | boot-tool | [#1](https://git.erikinkinen.fi/erix/boot-tool/issues/1), [#3](https://git.erikinkinen.fi/erix/boot-tool/issues/3), [#6](https://git.erikinkinen.fi/erix/boot-tool/issues/6) | [#2](https://git.erikinkinen.fi/erix/boot-tool/pulls/2) | | bootloader | [#1](https://git.erikinkinen.fi/erix/bootloader/issues/1), [#2](https://git.erikinkinen.fi/erix/bootloader/issues/2) | [#3](https://git.erikinkinen.fi/erix/bootloader/pulls/3) | | coreutils | [#1](https://git.erikinkinen.fi/erix/coreutils/issues/1) | [#2](https://git.erikinkinen.fi/erix/coreutils/pulls/2) | | crashd | [#1](https://git.erikinkinen.fi/erix/crashd/issues/1) | [#2](https://git.erikinkinen.fi/erix/crashd/pulls/2) | | deviced | [#1](https://git.erikinkinen.fi/erix/deviced/issues/1), [#4](https://git.erikinkinen.fi/erix/deviced/issues/4) | [#3](https://git.erikinkinen.fi/erix/deviced/pulls/3) | | docs | [#1](https://git.erikinkinen.fi/erix/docs/issues/1), [#2](https://git.erikinkinen.fi/erix/docs/issues/2), [#11](https://git.erikinkinen.fi/erix/docs/issues/11), [#12](https://git.erikinkinen.fi/erix/docs/issues/12) | [#4](https://git.erikinkinen.fi/erix/docs/pulls/4) | | drv-acpi | [#1](https://git.erikinkinen.fi/erix/drv-acpi/issues/1) | [#2](https://git.erikinkinen.fi/erix/drv-acpi/pulls/2) | | drv-i8042 | [#1](https://git.erikinkinen.fi/erix/drv-i8042/issues/1) | [#2](https://git.erikinkinen.fi/erix/drv-i8042/pulls/2) | | drv-ps2-keyboard | [#1](https://git.erikinkinen.fi/erix/drv-ps2-keyboard/issues/1) | [#2](https://git.erikinkinen.fi/erix/drv-ps2-keyboard/pulls/2) | | drv-ps2-mouse | [#1](https://git.erikinkinen.fi/erix/drv-ps2-mouse/issues/1) | [#2](https://git.erikinkinen.fi/erix/drv-ps2-mouse/pulls/2) | | drv-rtc-cmos | [#1](https://git.erikinkinen.fi/erix/drv-rtc-cmos/issues/1) | [#2](https://git.erikinkinen.fi/erix/drv-rtc-cmos/pulls/2) | | drv-serial | [#1](https://git.erikinkinen.fi/erix/drv-serial/issues/1) | [#2](https://git.erikinkinen.fi/erix/drv-serial/pulls/2) | | drv-virtio-block | [#1](https://git.erikinkinen.fi/erix/drv-virtio-block/issues/1) | [#2](https://git.erikinkinen.fi/erix/drv-virtio-block/pulls/2) | | dynlinkd | [#1](https://git.erikinkinen.fi/erix/dynlinkd/issues/1), [#2](https://git.erikinkinen.fi/erix/dynlinkd/issues/2), [#4](https://git.erikinkinen.fi/erix/dynlinkd/issues/4) | [#3](https://git.erikinkinen.fi/erix/dynlinkd/pulls/3) | | e2fsd | [#1](https://git.erikinkinen.fi/erix/e2fsd/issues/1), [#5](https://git.erikinkinen.fi/erix/e2fsd/issues/5), [#6](https://git.erikinkinen.fi/erix/e2fsd/issues/6), [#7](https://git.erikinkinen.fi/erix/e2fsd/issues/7), [#8](https://git.erikinkinen.fi/erix/e2fsd/issues/8), [#9](https://git.erikinkinen.fi/erix/e2fsd/issues/9), [#10](https://git.erikinkinen.fi/erix/e2fsd/issues/10), [#11](https://git.erikinkinen.fi/erix/e2fsd/issues/11), [#12](https://git.erikinkinen.fi/erix/e2fsd/issues/12), [#13](https://git.erikinkinen.fi/erix/e2fsd/issues/13), [#15](https://git.erikinkinen.fi/erix/e2fsd/issues/15), [#16](https://git.erikinkinen.fi/erix/e2fsd/issues/16), [#17](https://git.erikinkinen.fi/erix/e2fsd/issues/17), [#18](https://git.erikinkinen.fi/erix/e2fsd/issues/18), [#19](https://git.erikinkinen.fi/erix/e2fsd/issues/19), [#20](https://git.erikinkinen.fi/erix/e2fsd/issues/20), [#21](https://git.erikinkinen.fi/erix/e2fsd/issues/21), [#23](https://git.erikinkinen.fi/erix/e2fsd/issues/23), [#25](https://git.erikinkinen.fi/erix/e2fsd/issues/25) | [#3](https://git.erikinkinen.fi/erix/e2fsd/pulls/3) | | exsh | [#1](https://git.erikinkinen.fi/erix/exsh/issues/1), [#2](https://git.erikinkinen.fi/erix/exsh/issues/2), [#4](https://git.erikinkinen.fi/erix/exsh/issues/4), [#5](https://git.erikinkinen.fi/erix/exsh/issues/5), [#9](https://git.erikinkinen.fi/erix/exsh/issues/9), [#10](https://git.erikinkinen.fi/erix/exsh/issues/10), [#11](https://git.erikinkinen.fi/erix/exsh/issues/11), [#13](https://git.erikinkinen.fi/erix/exsh/issues/13), [#14](https://git.erikinkinen.fi/erix/exsh/issues/14), [#15](https://git.erikinkinen.fi/erix/exsh/issues/15), [#16](https://git.erikinkinen.fi/erix/exsh/issues/16), [#24](https://git.erikinkinen.fi/erix/exsh/issues/24), [#25](https://git.erikinkinen.fi/erix/exsh/issues/25) | [#3](https://git.erikinkinen.fi/erix/exsh/pulls/3) | | extop | [#1](https://git.erikinkinen.fi/erix/extop/issues/1) | [#2](https://git.erikinkinen.fi/erix/extop/pulls/2) | | fatd | [#1](https://git.erikinkinen.fi/erix/fatd/issues/1), [#4](https://git.erikinkinen.fi/erix/fatd/issues/4), [#5](https://git.erikinkinen.fi/erix/fatd/issues/5), [#6](https://git.erikinkinen.fi/erix/fatd/issues/6), [#7](https://git.erikinkinen.fi/erix/fatd/issues/7), [#8](https://git.erikinkinen.fi/erix/fatd/issues/8), [#9](https://git.erikinkinen.fi/erix/fatd/issues/9), [#10](https://git.erikinkinen.fi/erix/fatd/issues/10), [#11](https://git.erikinkinen.fi/erix/fatd/issues/11), [#12](https://git.erikinkinen.fi/erix/fatd/issues/12), [#14](https://git.erikinkinen.fi/erix/fatd/issues/14), [#15](https://git.erikinkinen.fi/erix/fatd/issues/15), [#16](https://git.erikinkinen.fi/erix/fatd/issues/16) | [#3](https://git.erikinkinen.fi/erix/fatd/pulls/3) | | fbcond | [#1](https://git.erikinkinen.fi/erix/fbcond/issues/1) | [#2](https://git.erikinkinen.fi/erix/fbcond/pulls/2) | | hotplugd | [#1](https://git.erikinkinen.fi/erix/hotplugd/issues/1) | [#2](https://git.erikinkinen.fi/erix/hotplugd/pulls/2) | | inputd | [#1](https://git.erikinkinen.fi/erix/inputd/issues/1) | [#2](https://git.erikinkinen.fi/erix/inputd/pulls/2) | | integration | [#1](https://git.erikinkinen.fi/erix/integration/issues/1), [#2](https://git.erikinkinen.fi/erix/integration/issues/2), [#3](https://git.erikinkinen.fi/erix/integration/issues/3), [#4](https://git.erikinkinen.fi/erix/integration/issues/4), [#5](https://git.erikinkinen.fi/erix/integration/issues/5), [#6](https://git.erikinkinen.fi/erix/integration/issues/6), [#7](https://git.erikinkinen.fi/erix/integration/issues/7), [#8](https://git.erikinkinen.fi/erix/integration/issues/8), [#9](https://git.erikinkinen.fi/erix/integration/issues/9), [#10](https://git.erikinkinen.fi/erix/integration/issues/10), [#11](https://git.erikinkinen.fi/erix/integration/issues/11), [#18](https://git.erikinkinen.fi/erix/integration/issues/18), [#20](https://git.erikinkinen.fi/erix/integration/issues/20), [#30](https://git.erikinkinen.fi/erix/integration/issues/30), [#31](https://git.erikinkinen.fi/erix/integration/issues/31), [#37](https://git.erikinkinen.fi/erix/integration/issues/37), [#39](https://git.erikinkinen.fi/erix/integration/issues/39), [#40](https://git.erikinkinen.fi/erix/integration/issues/40), [#45](https://git.erikinkinen.fi/erix/integration/issues/45), [#47](https://git.erikinkinen.fi/erix/integration/issues/47), [#54](https://git.erikinkinen.fi/erix/integration/issues/54), [#56](https://git.erikinkinen.fi/erix/integration/issues/56), [#57](https://git.erikinkinen.fi/erix/integration/issues/57), [#58](https://git.erikinkinen.fi/erix/integration/issues/58), [#64](https://git.erikinkinen.fi/erix/integration/issues/64), [#65](https://git.erikinkinen.fi/erix/integration/issues/65), [#66](https://git.erikinkinen.fi/erix/integration/issues/66), [#67](https://git.erikinkinen.fi/erix/integration/issues/67), [#68](https://git.erikinkinen.fi/erix/integration/issues/68), [#69](https://git.erikinkinen.fi/erix/integration/issues/69), [#70](https://git.erikinkinen.fi/erix/integration/issues/70), [#71](https://git.erikinkinen.fi/erix/integration/issues/71), [#72](https://git.erikinkinen.fi/erix/integration/issues/72), [#73](https://git.erikinkinen.fi/erix/integration/issues/73), [#74](https://git.erikinkinen.fi/erix/integration/issues/74), [#75](https://git.erikinkinen.fi/erix/integration/issues/75), [#76](https://git.erikinkinen.fi/erix/integration/issues/76), [#77](https://git.erikinkinen.fi/erix/integration/issues/77), [#78](https://git.erikinkinen.fi/erix/integration/issues/78), [#79](https://git.erikinkinen.fi/erix/integration/issues/79), [#80](https://git.erikinkinen.fi/erix/integration/issues/80), [#81](https://git.erikinkinen.fi/erix/integration/issues/81), [#82](https://git.erikinkinen.fi/erix/integration/issues/82), [#83](https://git.erikinkinen.fi/erix/integration/issues/83), [#84](https://git.erikinkinen.fi/erix/integration/issues/84), [#85](https://git.erikinkinen.fi/erix/integration/issues/85), [#86](https://git.erikinkinen.fi/erix/integration/issues/86), [#87](https://git.erikinkinen.fi/erix/integration/issues/87), [#88](https://git.erikinkinen.fi/erix/integration/issues/88), [#89](https://git.erikinkinen.fi/erix/integration/issues/89), [#90](https://git.erikinkinen.fi/erix/integration/issues/90), [#91](https://git.erikinkinen.fi/erix/integration/issues/91), [#92](https://git.erikinkinen.fi/erix/integration/issues/92), [#93](https://git.erikinkinen.fi/erix/integration/issues/93), [#94](https://git.erikinkinen.fi/erix/integration/issues/94), [#95](https://git.erikinkinen.fi/erix/integration/issues/95), [#96](https://git.erikinkinen.fi/erix/integration/issues/96), [#97](https://git.erikinkinen.fi/erix/integration/issues/97), [#98](https://git.erikinkinen.fi/erix/integration/issues/98), [#99](https://git.erikinkinen.fi/erix/integration/issues/99), [#100](https://git.erikinkinen.fi/erix/integration/issues/100), [#102](https://git.erikinkinen.fi/erix/integration/issues/102), [#103](https://git.erikinkinen.fi/erix/integration/issues/103), [#104](https://git.erikinkinen.fi/erix/integration/issues/104), [#105](https://git.erikinkinen.fi/erix/integration/issues/105), [#106](https://git.erikinkinen.fi/erix/integration/issues/106), [issue 107](https://git.erikinkinen.fi/erix/integration/issues/107), [issue 108](https://git.erikinkinen.fi/erix/integration/issues/108), [#109](https://git.erikinkinen.fi/erix/integration/issues/109), [issue 110](https://git.erikinkinen.fi/erix/integration/issues/110), [issue 111](https://git.erikinkinen.fi/erix/integration/issues/111), [issue 112](https://git.erikinkinen.fi/erix/integration/issues/112), [#113](https://git.erikinkinen.fi/erix/integration/issues/113), [integration #114](https://git.erikinkinen.fi/erix/integration/issues/114), [#157](https://git.erikinkinen.fi/erix/integration/issues/157) | [#12](https://git.erikinkinen.fi/erix/integration/pulls/12) | | irqd | [#1](https://git.erikinkinen.fi/erix/irqd/issues/1) | [#2](https://git.erikinkinen.fi/erix/irqd/pulls/2) | | kernel | [#1](https://git.erikinkinen.fi/erix/kernel/issues/1), [#2](https://git.erikinkinen.fi/erix/kernel/issues/2), [#18](https://git.erikinkinen.fi/erix/kernel/issues/18), [#19](https://git.erikinkinen.fi/erix/kernel/issues/19), [#20](https://git.erikinkinen.fi/erix/kernel/issues/20), [#21](https://git.erikinkinen.fi/erix/kernel/issues/21), [#22](https://git.erikinkinen.fi/erix/kernel/issues/22), [#23](https://git.erikinkinen.fi/erix/kernel/issues/23), [#24](https://git.erikinkinen.fi/erix/kernel/issues/24), [#25](https://git.erikinkinen.fi/erix/kernel/issues/25), [#26](https://git.erikinkinen.fi/erix/kernel/issues/26), [#27](https://git.erikinkinen.fi/erix/kernel/issues/27), [#28](https://git.erikinkinen.fi/erix/kernel/issues/28), [#29](https://git.erikinkinen.fi/erix/kernel/issues/29), [#30](https://git.erikinkinen.fi/erix/kernel/issues/30), [#31](https://git.erikinkinen.fi/erix/kernel/issues/31), [#32](https://git.erikinkinen.fi/erix/kernel/issues/32), [#33](https://git.erikinkinen.fi/erix/kernel/issues/33), [#34](https://git.erikinkinen.fi/erix/kernel/issues/34), [#35](https://git.erikinkinen.fi/erix/kernel/issues/35), [#36](https://git.erikinkinen.fi/erix/kernel/issues/36), [#37](https://git.erikinkinen.fi/erix/kernel/issues/37), [#38](https://git.erikinkinen.fi/erix/kernel/issues/38), [#39](https://git.erikinkinen.fi/erix/kernel/issues/39), [#40](https://git.erikinkinen.fi/erix/kernel/issues/40), [#41](https://git.erikinkinen.fi/erix/kernel/issues/41), [#42](https://git.erikinkinen.fi/erix/kernel/issues/42), [#43](https://git.erikinkinen.fi/erix/kernel/issues/43), [#44](https://git.erikinkinen.fi/erix/kernel/issues/44), [#45](https://git.erikinkinen.fi/erix/kernel/issues/45), [#46](https://git.erikinkinen.fi/erix/kernel/issues/46), [#47](https://git.erikinkinen.fi/erix/kernel/issues/47), [#48](https://git.erikinkinen.fi/erix/kernel/issues/48), [#49](https://git.erikinkinen.fi/erix/kernel/issues/49), [#50](https://git.erikinkinen.fi/erix/kernel/issues/50), [issue 51](https://git.erikinkinen.fi/erix/kernel/issues/51), [issue 52](https://git.erikinkinen.fi/erix/kernel/issues/52), [#53](https://git.erikinkinen.fi/erix/kernel/issues/53), [kernel #54](https://git.erikinkinen.fi/erix/kernel/issues/54) | [#3](https://git.erikinkinen.fi/erix/kernel/pulls/3) | | keyd | [#1](https://git.erikinkinen.fi/erix/keyd/issues/1) | [#2](https://git.erikinkinen.fi/erix/keyd/pulls/2) | | launchd | [#1](https://git.erikinkinen.fi/erix/launchd/issues/1), [#3](https://git.erikinkinen.fi/erix/launchd/issues/3), [#4](https://git.erikinkinen.fi/erix/launchd/issues/4), [#5](https://git.erikinkinen.fi/erix/launchd/issues/5), [#6](https://git.erikinkinen.fi/erix/launchd/issues/6), [#7](https://git.erikinkinen.fi/erix/launchd/issues/7), [#8](https://git.erikinkinen.fi/erix/launchd/issues/8), [#9](https://git.erikinkinen.fi/erix/launchd/issues/9), [#10](https://git.erikinkinen.fi/erix/launchd/issues/10), [#11](https://git.erikinkinen.fi/erix/launchd/issues/11), [#12](https://git.erikinkinen.fi/erix/launchd/issues/12), [#13](https://git.erikinkinen.fi/erix/launchd/issues/13), [#14](https://git.erikinkinen.fi/erix/launchd/issues/14), [#15](https://git.erikinkinen.fi/erix/launchd/issues/15), [#17](https://git.erikinkinen.fi/erix/launchd/issues/17), [#18](https://git.erikinkinen.fi/erix/launchd/issues/18), [#19](https://git.erikinkinen.fi/erix/launchd/issues/19), [#20](https://git.erikinkinen.fi/erix/launchd/issues/20), [#21](https://git.erikinkinen.fi/erix/launchd/issues/21), [#22](https://git.erikinkinen.fi/erix/launchd/issues/22), [#23](https://git.erikinkinen.fi/erix/launchd/issues/23), [#26](https://git.erikinkinen.fi/erix/launchd/issues/26), [#27](https://git.erikinkinen.fi/erix/launchd/issues/27) | [#2](https://git.erikinkinen.fi/erix/launchd/pulls/2) | | lib-aes | [#1](https://git.erikinkinen.fi/erix/lib-aes/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-aes/pulls/2) | | lib-block | [#1](https://git.erikinkinen.fi/erix/lib-block/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-block/pulls/2) | | lib-bootimg | [#1](https://git.erikinkinen.fi/erix/lib-bootimg/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-bootimg/pulls/2) | | lib-bootstrap | [#1](https://git.erikinkinen.fi/erix/lib-bootstrap/issues/1), [#4](https://git.erikinkinen.fi/erix/lib-bootstrap/issues/4) | [#2](https://git.erikinkinen.fi/erix/lib-bootstrap/pulls/2) | | lib-capabi | [#1](https://git.erikinkinen.fi/erix/lib-capabi/issues/1), [#4](https://git.erikinkinen.fi/erix/lib-capabi/issues/4) | [#2](https://git.erikinkinen.fi/erix/lib-capabi/pulls/2) | | lib-cli | [#1](https://git.erikinkinen.fi/erix/lib-cli/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-cli/pulls/2) | | lib-console | [#1](https://git.erikinkinen.fi/erix/lib-console/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-console/pulls/2) | | lib-constant-time | [#1](https://git.erikinkinen.fi/erix/lib-constant-time/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-constant-time/pulls/2) | | lib-crc | [#1](https://git.erikinkinen.fi/erix/lib-crc/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-crc/pulls/2) | | lib-cstd | [#1](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [#2](https://git.erikinkinen.fi/erix/lib-cstd/issues/2), [#4](https://git.erikinkinen.fi/erix/lib-cstd/issues/4), [#5](https://git.erikinkinen.fi/erix/lib-cstd/issues/5) | [#3](https://git.erikinkinen.fi/erix/lib-cstd/pulls/3) | | lib-deflate | [#1](https://git.erikinkinen.fi/erix/lib-deflate/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-deflate/pulls/2) | | lib-device | [#1](https://git.erikinkinen.fi/erix/lib-device/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-device/pulls/2) | | lib-driver | [#1](https://git.erikinkinen.fi/erix/lib-driver/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-driver/pulls/2) | | lib-dynlink | [#1](https://git.erikinkinen.fi/erix/lib-dynlink/issues/1), [#4](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [#5](https://git.erikinkinen.fi/erix/lib-dynlink/issues/5), [#6](https://git.erikinkinen.fi/erix/lib-dynlink/issues/6) | [#3](https://git.erikinkinen.fi/erix/lib-dynlink/pulls/3) | | lib-ed25519 | [#1](https://git.erikinkinen.fi/erix/lib-ed25519/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-ed25519/pulls/2) | | lib-elf | [#1](https://git.erikinkinen.fi/erix/lib-elf/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-elf/pulls/2) | | lib-fs-crypto | [#1](https://git.erikinkinen.fi/erix/lib-fs-crypto/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-fs-crypto/pulls/2) | | lib-fs-name | [#1](https://git.erikinkinen.fi/erix/lib-fs-name/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-fs-name/pulls/2) | | lib-handoff | [#1](https://git.erikinkinen.fi/erix/lib-handoff/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-handoff/pulls/2) | | lib-input | [#1](https://git.erikinkinen.fi/erix/lib-input/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-input/pulls/2) | | lib-interrupt | [#1](https://git.erikinkinen.fi/erix/lib-interrupt/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-interrupt/pulls/2) | | lib-ipc | [#1](https://git.erikinkinen.fi/erix/lib-ipc/issues/1), [#3](https://git.erikinkinen.fi/erix/lib-ipc/issues/3), [#4](https://git.erikinkinen.fi/erix/lib-ipc/issues/4), [#5](https://git.erikinkinen.fi/erix/lib-ipc/issues/5), [#6](https://git.erikinkinen.fi/erix/lib-ipc/issues/6), [#7](https://git.erikinkinen.fi/erix/lib-ipc/issues/7), [#8](https://git.erikinkinen.fi/erix/lib-ipc/issues/8), [#12](https://git.erikinkinen.fi/erix/lib-ipc/issues/12) | [#2](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2) | | lib-log | [#1](https://git.erikinkinen.fi/erix/lib-log/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-log/pulls/2) | | lib-partition | [#1](https://git.erikinkinen.fi/erix/lib-partition/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-partition/pulls/2) | | lib-posixabi | [#1](https://git.erikinkinen.fi/erix/lib-posixabi/issues/1), [#2](https://git.erikinkinen.fi/erix/lib-posixabi/issues/2), [#4](https://git.erikinkinen.fi/erix/lib-posixabi/issues/4), [#5](https://git.erikinkinen.fi/erix/lib-posixabi/issues/5), [#6](https://git.erikinkinen.fi/erix/lib-posixabi/issues/6), [#7](https://git.erikinkinen.fi/erix/lib-posixabi/issues/7) | [#2](https://git.erikinkinen.fi/erix/lib-posixabi/pulls/2), [#3](https://git.erikinkinen.fi/erix/lib-posixabi/pulls/3) | | lib-service | [#1](https://git.erikinkinen.fi/erix/lib-service/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-service/pulls/2) | | lib-sha2 | [#1](https://git.erikinkinen.fi/erix/lib-sha2/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-sha2/pulls/2) | | lib-stdio | [#1](https://git.erikinkinen.fi/erix/lib-stdio/issues/1), [#3](https://git.erikinkinen.fi/erix/lib-stdio/issues/3) | [#2](https://git.erikinkinen.fi/erix/lib-stdio/pulls/2) | | lib-time | [#1](https://git.erikinkinen.fi/erix/lib-time/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-time/pulls/2) | | lib-tty | [#1](https://git.erikinkinen.fi/erix/lib-tty/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-tty/pulls/2) | | lib-vfs | [#1](https://git.erikinkinen.fi/erix/lib-vfs/issues/1) | [#2](https://git.erikinkinen.fi/erix/lib-vfs/pulls/2) | | loaderd | [#1](https://git.erikinkinen.fi/erix/loaderd/issues/1), [#5](https://git.erikinkinen.fi/erix/loaderd/issues/5), [#6](https://git.erikinkinen.fi/erix/loaderd/issues/6), [#7](https://git.erikinkinen.fi/erix/loaderd/issues/7) | [#2](https://git.erikinkinen.fi/erix/loaderd/pulls/2) | | logd | [#1](https://git.erikinkinen.fi/erix/logd/issues/1) | [#4](https://git.erikinkinen.fi/erix/logd/pulls/4) | | memd | [#1](https://git.erikinkinen.fi/erix/memd/issues/1) | [#2](https://git.erikinkinen.fi/erix/memd/pulls/2) | | meta | [#2](https://git.erikinkinen.fi/erix/meta/issues/2), [#3](https://git.erikinkinen.fi/erix/meta/issues/3), [#5](https://git.erikinkinen.fi/erix/meta/issues/5) | [#4](https://git.erikinkinen.fi/erix/meta/pulls/4) | | named | [#1](https://git.erikinkinen.fi/erix/named/issues/1) | [#2](https://git.erikinkinen.fi/erix/named/pulls/2) | | pagerd | [#1](https://git.erikinkinen.fi/erix/pagerd/issues/1) | [#2](https://git.erikinkinen.fi/erix/pagerd/pulls/2) | | lib-owned-region | [#1](https://git.erikinkinen.fi/erix/lib-owned-region/issues/1), [#3: original-region resizing](https://git.erikinkinen.fi/erix/lib-owned-region/issues/3) | [#2](https://git.erikinkinen.fi/erix/lib-owned-region/pulls/2) | | posixd | [#1](https://git.erikinkinen.fi/erix/posixd/issues/1), [#2](https://git.erikinkinen.fi/erix/posixd/issues/2), [#3](https://git.erikinkinen.fi/erix/posixd/issues/3), [#4](https://git.erikinkinen.fi/erix/posixd/issues/4), [#7](https://git.erikinkinen.fi/erix/posixd/issues/7), [#8](https://git.erikinkinen.fi/erix/posixd/issues/8), [#9](https://git.erikinkinen.fi/erix/posixd/issues/9), [#10](https://git.erikinkinen.fi/erix/posixd/issues/10), [#11](https://git.erikinkinen.fi/erix/posixd/issues/11), [#12](https://git.erikinkinen.fi/erix/posixd/issues/12), [#13](https://git.erikinkinen.fi/erix/posixd/issues/13), [#14](https://git.erikinkinen.fi/erix/posixd/issues/14), [#15](https://git.erikinkinen.fi/erix/posixd/issues/15), [#16](https://git.erikinkinen.fi/erix/posixd/issues/16), [#17](https://git.erikinkinen.fi/erix/posixd/issues/17), [#18](https://git.erikinkinen.fi/erix/posixd/issues/18), [#19](https://git.erikinkinen.fi/erix/posixd/issues/19), [#20](https://git.erikinkinen.fi/erix/posixd/issues/20), [#21](https://git.erikinkinen.fi/erix/posixd/issues/21), [#22](https://git.erikinkinen.fi/erix/posixd/issues/22), [#23](https://git.erikinkinen.fi/erix/posixd/issues/23), [#24](https://git.erikinkinen.fi/erix/posixd/issues/24), [#25](https://git.erikinkinen.fi/erix/posixd/issues/25), [#26](https://git.erikinkinen.fi/erix/posixd/issues/26), [#27](https://git.erikinkinen.fi/erix/posixd/issues/27), [#28](https://git.erikinkinen.fi/erix/posixd/issues/28), [#29](https://git.erikinkinen.fi/erix/posixd/issues/29), [#30](https://git.erikinkinen.fi/erix/posixd/issues/30), [#31](https://git.erikinkinen.fi/erix/posixd/issues/31), [#32](https://git.erikinkinen.fi/erix/posixd/issues/32), [#33](https://git.erikinkinen.fi/erix/posixd/issues/33), [#34](https://git.erikinkinen.fi/erix/posixd/issues/34), [#35](https://git.erikinkinen.fi/erix/posixd/issues/35), [#36](https://git.erikinkinen.fi/erix/posixd/issues/36), [#37](https://git.erikinkinen.fi/erix/posixd/issues/37), [#38](https://git.erikinkinen.fi/erix/posixd/issues/38), [#39](https://git.erikinkinen.fi/erix/posixd/issues/39), [issue 40](https://git.erikinkinen.fi/erix/posixd/issues/40), [issue 41](https://git.erikinkinen.fi/erix/posixd/issues/41) | [#5](https://git.erikinkinen.fi/erix/posixd/pulls/5) | | powerboxd | [#1](https://git.erikinkinen.fi/erix/powerboxd/issues/1) | [#2](https://git.erikinkinen.fi/erix/powerboxd/pulls/2) | | probed | [#1](https://git.erikinkinen.fi/erix/probed/issues/1) | [#2](https://git.erikinkinen.fi/erix/probed/pulls/2) | | procd | [#1](https://git.erikinkinen.fi/erix/procd/issues/1), [#4](https://git.erikinkinen.fi/erix/procd/issues/4), [#5](https://git.erikinkinen.fi/erix/procd/issues/5), [#6](https://git.erikinkinen.fi/erix/procd/issues/6), [#7](https://git.erikinkinen.fi/erix/procd/issues/7), [#8](https://git.erikinkinen.fi/erix/procd/issues/8), [#9](https://git.erikinkinen.fi/erix/procd/issues/9), [#10](https://git.erikinkinen.fi/erix/procd/issues/10), [#11](https://git.erikinkinen.fi/erix/procd/issues/11), [#12](https://git.erikinkinen.fi/erix/procd/issues/12) | [#2](https://git.erikinkinen.fi/erix/procd/pulls/2) | | ramfsd | [#1](https://git.erikinkinen.fi/erix/ramfsd/issues/1), [#3](https://git.erikinkinen.fi/erix/ramfsd/issues/3), [#4](https://git.erikinkinen.fi/erix/ramfsd/issues/4), [#6](https://git.erikinkinen.fi/erix/ramfsd/issues/6), [#9](https://git.erikinkinen.fi/erix/ramfsd/issues/9), [#10](https://git.erikinkinen.fi/erix/ramfsd/issues/10), [#11](https://git.erikinkinen.fi/erix/ramfsd/issues/11), [#12](https://git.erikinkinen.fi/erix/ramfsd/issues/12) | [#2](https://git.erikinkinen.fi/erix/ramfsd/pulls/2) | | rootd | [#1](https://git.erikinkinen.fi/erix/rootd/issues/1), [#6](https://git.erikinkinen.fi/erix/rootd/issues/6), [#7](https://git.erikinkinen.fi/erix/rootd/issues/7) | [#2](https://git.erikinkinen.fi/erix/rootd/pulls/2) | | seriald | [#1](https://git.erikinkinen.fi/erix/seriald/issues/1) | [#2](https://git.erikinkinen.fi/erix/seriald/pulls/2) | | sha2-tool | [#1](https://git.erikinkinen.fi/erix/sha2-tool/issues/1), [#3](https://git.erikinkinen.fi/erix/sha2-tool/issues/3) | [#2](https://git.erikinkinen.fi/erix/sha2-tool/pulls/2) | | timed | [#1](https://git.erikinkinen.fi/erix/timed/issues/1), [#3](https://git.erikinkinen.fi/erix/timed/issues/3), [#4](https://git.erikinkinen.fi/erix/timed/issues/4) | [#2](https://git.erikinkinen.fi/erix/timed/pulls/2) | | ttyd | [#1](https://git.erikinkinen.fi/erix/ttyd/issues/1), [#2](https://git.erikinkinen.fi/erix/ttyd/issues/2) | [#3](https://git.erikinkinen.fi/erix/ttyd/pulls/3) | | vfsd | [#1](https://git.erikinkinen.fi/erix/vfsd/issues/1), [#4](https://git.erikinkinen.fi/erix/vfsd/issues/4), [#5](https://git.erikinkinen.fi/erix/vfsd/issues/5), [#6](https://git.erikinkinen.fi/erix/vfsd/issues/6), [#7](https://git.erikinkinen.fi/erix/vfsd/issues/7), [#8](https://git.erikinkinen.fi/erix/vfsd/issues/8), [#9](https://git.erikinkinen.fi/erix/vfsd/issues/9), [#10](https://git.erikinkinen.fi/erix/vfsd/issues/10), [#11](https://git.erikinkinen.fi/erix/vfsd/issues/11), [#12](https://git.erikinkinen.fi/erix/vfsd/issues/12), [#13](https://git.erikinkinen.fi/erix/vfsd/issues/13), [#14](https://git.erikinkinen.fi/erix/vfsd/issues/14), [#15](https://git.erikinkinen.fi/erix/vfsd/issues/15), [#16](https://git.erikinkinen.fi/erix/vfsd/issues/16), [#25](https://git.erikinkinen.fi/erix/vfsd/issues/25), [#26](https://git.erikinkinen.fi/erix/vfsd/issues/26), [#27](https://git.erikinkinen.fi/erix/vfsd/issues/27), [#28](https://git.erikinkinen.fi/erix/vfsd/issues/28), [#29](https://git.erikinkinen.fi/erix/vfsd/issues/29), [#30](https://git.erikinkinen.fi/erix/vfsd/issues/30), [#32](https://git.erikinkinen.fi/erix/vfsd/issues/32), [#39](https://git.erikinkinen.fi/erix/vfsd/issues/39) | [#3](https://git.erikinkinen.fi/erix/vfsd/pulls/3) | | vspaced | [#1](https://git.erikinkinen.fi/erix/vspaced/issues/1) | [#2](https://git.erikinkinen.fi/erix/vspaced/pulls/2) | </details> <details> <summary>Detailed contracts and source requirements</summary> | Repository | Contracts | | --- | --- | | docs | [logo_transparent.png](https://git.erikinkinen.fi/erix/docs/src/branch/main/logo_transparent.png), [6.md](https://git.erikinkinen.fi/erix/docs/src/branch/main/phases/6.md) | | e2fsd | [conditional-namespace.md](https://git.erikinkinen.fi/erix/e2fsd/src/branch/feature/posix-compat/docs/conditional-namespace.md), [detached-inodes.md](https://git.erikinkinen.fi/erix/e2fsd/src/branch/feature/posix-compat/docs/detached-inodes.md), [encrypted-file-growth.md](https://git.erikinkinen.fi/erix/e2fsd/src/branch/feature/posix-compat/docs/encrypted-file-growth.md), [original-undo.md](https://git.erikinkinen.fi/erix/e2fsd/src/branch/feature/posix-compat/docs/original-undo.md), [extent-boundaries.md](https://git.erikinkinen.fi/erix/e2fsd/src/commit/433a6e86bf50f79acb412c84ecf629d7561eefa3/docs/extent-boundaries.md) | | fatd | [conditional-namespace.md](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/conditional-namespace.md), [detached-objects.md](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/detached-objects.md), [detached-objects.md#current-parent-observations](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/detached-objects.md#current-parent-observations), [directory-observations.md](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/directory-observations.md), [exfat-directory-mutation.md](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/exfat-directory-mutation.md), [native-namespace.md](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/native-namespace.md), [original-catalog.md](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/original-catalog.md), [original-undo.md](https://git.erikinkinen.fi/erix/fatd/src/branch/feature/posix-compat/docs/original-undo.md) | | integration | [descriptor-readiness.md](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/descriptor-readiness.md), [ext-undo.md](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/ext-undo.md), [fat-detached-recovery.md](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/fat-detached-recovery.md), [native-c-runtime-consumers.md](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/native-c-runtime-consumers.md), [native-thread-lifecycle.md](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/native-thread-lifecycle.md), [public-deadlines.md](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/public-deadlines.md), [local-ipc-requirements.toml](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/local-ipc-requirements.toml), [native-invocation-profiling.md](https://git.erikinkinen.fi/erix/integration/src/commit/46ae17e84abdc1e72e89fd7c50c766c54f3bcc03/docs/native-invocation-profiling.md), [startup-profile-contract.md](https://git.erikinkinen.fi/erix/integration/src/commit/46ae17e84abdc1e72e89fd7c50c766c54f3bcc03/docs/startup-profile-contract.md), [startup-profiling.md](https://git.erikinkinen.fi/erix/integration/src/commit/46ae17e84abdc1e72e89fd7c50c766c54f3bcc03/docs/startup-profiling.md), [tcg-profiling.md](https://git.erikinkinen.fi/erix/integration/src/commit/46ae17e84abdc1e72e89fd7c50c766c54f3bcc03/docs/tcg-profiling.md), [realm-binding-witness.md](https://git.erikinkinen.fi/erix/integration/src/commit/7f1e4956ed21dbaec68593989e7a129fa0af62be/docs/realm-binding-witness.md) | | kernel | [claimed-native-preparation.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/claimed-native-preparation.md), [creator-floating-environment.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/creator-floating-environment.md), [independent-machine-state.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/independent-machine-state.md), [initialized-native-context.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/initialized-native-context.md), [native-context-memory.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-context-memory.md), [native-machine-state.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-machine-state.md), [native-member-carriers.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-member-carriers.md), [native-member-exit-observation.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-member-exit-observation.md), [native-thread-exit.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-thread-exit.md), [prepared-native-members.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/prepared-native-members.md), [process-lifetime-storage.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/process-lifetime-storage.md), [process-thread-ownership.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/process-thread-ownership.md), [retained-member-mappings.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/retained-member-mappings.md) | | launchd | [client-thread-factory.md](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/client-thread-factory.md) | | lib-aes | [c63d8660128f0dc0fd83ee7471c3a252f7d9cc55](https://git.erikinkinen.fi/erix/lib-aes/src/commit/c63d8660128f0dc0fd83ee7471c3a252f7d9cc55) | | lib-block | [durability.md](https://git.erikinkinen.fi/erix/lib-block/src/branch/feature/posix-compat/docs/durability.md), [undo-journal.md](https://git.erikinkinen.fi/erix/lib-block/src/branch/feature/posix-compat/docs/undo-journal.md) | | lib-cli | [7a7327da50d2e0d28c9d34a4bfffb49870e2eba2](https://git.erikinkinen.fi/erix/lib-cli/src/commit/7a7327da50d2e0d28c9d34a4bfffb49870e2eba2) | | lib-console | [5b832898e76cbfadd0b4ce2e921e4b9c5905e65c](https://git.erikinkinen.fi/erix/lib-console/src/commit/5b832898e76cbfadd0b4ce2e921e4b9c5905e65c) | | lib-constant-time | [eed797dfb0c4ab3d2a6300e1dc40254b79d7c1a1](https://git.erikinkinen.fi/erix/lib-constant-time/src/commit/eed797dfb0c4ab3d2a6300e1dc40254b79d7c1a1) | | lib-cstd | [thread-runtime.md](https://git.erikinkinen.fi/erix/lib-cstd/src/branch/feature/posix-compat/docs/thread-runtime.md) | | lib-deflate | [76a4d0abd57f69012ccba66c6b3b633f71554507](https://git.erikinkinen.fi/erix/lib-deflate/src/commit/76a4d0abd57f69012ccba66c6b3b633f71554507) | | lib-device | [91591b440d967e9e142e987e193a38f3825f84ef](https://git.erikinkinen.fi/erix/lib-device/src/commit/91591b440d967e9e142e987e193a38f3825f84ef) | | lib-dynlink | [tls-registry.md](https://git.erikinkinen.fi/erix/lib-dynlink/src/branch/feature/posix-compat/docs/tls-registry.md) | | lib-elf | [22b995d401dd5a8fcc2c244e53c8e932e5573648](https://git.erikinkinen.fi/erix/lib-elf/src/commit/22b995d401dd5a8fcc2c244e53c8e932e5573648) | | lib-fs-name | [a555d9bc6473e7779e20ed8df9447ebac246b648](https://git.erikinkinen.fi/erix/lib-fs-name/src/commit/a555d9bc6473e7779e20ed8df9447ebac246b648) | | lib-handoff | [16b9cb8dcfa5969745f5498c8abd887fcb2eabc4](https://git.erikinkinen.fi/erix/lib-handoff/src/commit/16b9cb8dcfa5969745f5498c8abd887fcb2eabc4) | | lib-ipc | [conditional-namespace.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/conditional-namespace.md), [conditional-permissions.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/conditional-permissions.md), [native-activity.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-activity.md), [native-context-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-context-abi.md), [native-deadlines.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-deadlines.md), [native-enrollment-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-enrollment-abi.md), [native-factory-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-factory-abi.md), [native-preparation-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-preparation-abi.md), [native-start-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-start-abi.md), [owned-invocation-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/owned-invocation-abi.md), [provider-cwd-retirement.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/provider-cwd-retirement.md), [public-deadlines.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/public-deadlines.md), [realm-clock.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/realm-clock.md), [relocation-patches.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/relocation-patches.md), [seekable-directories.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/seekable-directories.md), [socket-admission.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/socket-admission.md), [stream-metadata.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/stream-metadata.md), [stream-readiness.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/stream-readiness.md) | | lib-posixabi | [local-stream-sockets.md](https://git.erikinkinen.fi/erix/lib-posixabi/src/branch/feature/posix-compat/docs/local-stream-sockets.md), [namespace.md](https://git.erikinkinen.fi/erix/lib-posixabi/src/branch/feature/posix-compat/docs/namespace.md), [permission-operations.md](https://git.erikinkinen.fi/erix/lib-posixabi/src/branch/feature/posix-compat/docs/permission-operations.md), [readiness.md](https://git.erikinkinen.fi/erix/lib-posixabi/src/branch/feature/posix-compat/docs/readiness.md) | | lib-sha2 | [a97176f9835c2cb97e4b5ff2565d18efab389647](https://git.erikinkinen.fi/erix/lib-sha2/src/commit/a97176f9835c2cb97e4b5ff2565d18efab389647) | | posixd | [advisory-locks.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/advisory-locks.md), [descriptor-readiness.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/descriptor-readiness.md), [file-controls.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/file-controls.md), [inherited-stream-io.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/inherited-stream-io.md), [local-stream-sockets.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/local-stream-sockets.md), [namespace-mutations.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/namespace-mutations.md), [permission-operations.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/permission-operations.md), [pipes.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/pipes.md), [temporary-output.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/temporary-output.md), [thread-signals.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/thread-signals.md), [thread-storage.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/thread-storage.md), [realm-ownership.md](https://git.erikinkinen.fi/erix/posixd/src/commit/5874f330293af475bf4c40c69ef4b94c4a4c4733/docs/realm-ownership.md) | | procd | [client-thread-factory.md](https://git.erikinkinen.fi/erix/procd/src/branch/feature/posix-compat/docs/client-thread-factory.md), [initial-tls-materialization.md](https://git.erikinkinen.fi/erix/procd/src/branch/feature/posix-compat/docs/initial-tls-materialization.md) | | ramfsd | [open-object-lifetime.md](https://git.erikinkinen.fi/erix/ramfsd/src/branch/feature/posix-compat/docs/open-object-lifetime.md) | | timed | [owned-clock.md](https://git.erikinkinen.fi/erix/timed/src/branch/feature/posix-compat/docs/owned-clock.md) | | vfsd | [context-lifetime.md](https://git.erikinkinen.fi/erix/vfsd/src/branch/feature/posix-compat/docs/context-lifetime.md) | </details> ### Alpha 1 microkernel release gate - [ ] Complete the [integrated microkernel demonstration](https://git.erikinkinen.fi/erix/integration/issues/207): process isolation, capability security, userspace services, fault containment, exhaustion safety, independent processes, POSIX confinement, reproducible evidence and functional SMP on 2–4 CPUs. Run the release-image matrix with 1, 2 and 4 vCPUs, the authority audit, negative/fault-injection tests and repeated concurrency stress. This gate supplements the existing self-hosting acceptance.
Author
Owner

The guarded thread client and its packaging are published, and the native members fixture now completes its original terminal-receipt and retirement path. Work continues on exclusive join/departure handling and the isolated compiler invocation owner. The checklist now includes previously unrecorded component checks, with Integration's unfinished complete-check item reopened. Both full EriX guest generations and rebuilding Rust/LLVM inside EriX remain required.

The guarded thread client and its packaging are published, and [the native members fixture](https://git.erikinkinen.fi/erix/kernel/issues/50) now completes its original terminal-receipt and retirement path. Work continues on exclusive join/departure handling and the [isolated compiler invocation owner](https://git.erikinkinen.fi/erix/exsh/issues/15). The checklist now includes previously unrecorded component checks, with Integration's unfinished complete-check item reopened. Both full EriX guest generations and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

The documentation policy now covers all 261 discovered Cargo targets, including automatic tests, examples and build scripts. The signed fixes are adopted through the shared component graph and the independently compiled helper. The native departure design and ordinary join/detach design are published, and native implementation has started. A maintained lint-weakening gate and the isolated compiler supervisor are being implemented in parallel. The full guest builds and external toolchain rebuild remain open.

The documentation policy now covers all 261 discovered Cargo targets, including automatic tests, examples and build scripts. The signed fixes are adopted through the shared component graph and the independently compiled helper. The [native departure design](https://git.erikinkinen.fi/erix/kernel/issues/52) and [ordinary join/detach design](https://git.erikinkinen.fi/erix/posixd/issues/41) are published, and native implementation has started. A maintained lint-weakening gate and the isolated compiler supervisor are being implemented in parallel. The full guest builds and external toolchain rebuild remain open.
Author
Owner

Published the native execution runtime and diagnostics, shared ordinary thread codecs, isolated compiler supervisor and dependency-owner preflight. Posixd join/detach, the new Kernel guest failures, native query compatibility, and nested interpreter execution remain active work.

The checklists are reconciled at 22.13% weighted progress. Both complete EriX guest build generations and the external Rust/LLVM guest rebuild remain open.

Published the native execution runtime and diagnostics, shared ordinary thread codecs, isolated compiler supervisor and dependency-owner preflight. Posixd join/detach, the new Kernel guest failures, [native query compatibility](https://git.erikinkinen.fi/erix/integration/issues/113), and [nested interpreter execution](https://git.erikinkinen.fi/erix/integration/issues/114) remain active work. The checklists are reconciled at 22.13% weighted progress. Both complete EriX guest build generations and the external Rust/LLVM guest rebuild remain open.
Author
Owner

The payload-manifest format is complete, including its parser, dependency closure, tests and maintained manual. Whole-item acceptance is now 34 of 460 parents. Posixd’s shared join/detach source and three-birth workload are also signed; their full guest acceptance remains open.

Current CI results reopen 55 previous CI checkboxes after the helper update. Existing component checks retain their evidence where source inputs match. With both changes accounted for, weighted progress is 22.05%, and 460 of 1002 sub-items are complete. The runner compatibility failure remains tracked in Integration #113.

The payload-manifest format is complete, including its parser, dependency closure, tests and maintained manual. Whole-item acceptance is now 34 of 460 parents. Posixd’s shared join/detach source and three-birth workload are also signed; their full guest acceptance remains open. Current CI results reopen 55 previous CI checkboxes after the helper update. Existing component checks retain their evidence where source inputs match. With both changes accounted for, weighted progress is 22.05%, and 460 of 1002 sub-items are complete. The runner compatibility failure remains tracked in [Integration #113](https://git.erikinkinen.fi/erix/integration/issues/113).
Author
Owner

All six native Kernel lifecycle VMs now pass on the coherent signed graph, and Kernel #54 is closed. The original assertions, ordered unique markers, QEMU exit gate and deadlines remain. Measured lifecycle profiling continues, while the ordinary Posixd/libc workload and both EriX plus Rust/LLVM guest rebuilds stay open.

The payload-manifest item is complete and the new manual head passes full CI. Current weighted progress is 22.06%, with 34 accepted parents and 461 completed sub-items. The remaining full-CI failures are tracked separately in Integration #113.

All six native Kernel lifecycle VMs now pass on the coherent signed graph, and [Kernel #54](https://git.erikinkinen.fi/erix/kernel/issues/54) is closed. The original assertions, ordered unique markers, QEMU exit gate and deadlines remain. Measured lifecycle profiling continues, while the ordinary Posixd/libc workload and both EriX plus Rust/LLVM guest rebuilds stay open. The payload-manifest item is complete and the new manual head passes full CI. Current weighted progress is 22.06%, with 34 accepted parents and 461 completed sub-items. The remaining full-CI failures are tracked separately in [Integration #113](https://git.erikinkinen.fi/erix/integration/issues/113).
Author
Owner

The signed Exsh descriptor repair retains acquisitions and partial I/O through cancellation, requires exact owner coverage before closure, and avoids replaying uncertain cleanup. Integration selects that source while preserving the compiled helper.

The bounded host repair is complete. Full compiler input/frame proof and inherited actor inventory remain open. Work continues in parallel on native lifecycle profiling and offline payload ingestion/recipe storage. Both EriX guest build generations and the Rust/LLVM guest rebuild still require demonstration.

Checklist completion remains 22.06%, with 34 of 460 parent items and 461 of 1002 sub-items complete. This prerequisite repair adds no full-feature acceptance.

The [signed Exsh descriptor repair](https://git.erikinkinen.fi/erix/exsh/commit/229ea950a8b5adc0acec2e995465baed957d3abd) retains acquisitions and partial I/O through cancellation, requires exact owner coverage before closure, and avoids replaying uncertain cleanup. [Integration selects that source](https://git.erikinkinen.fi/erix/integration/commit/3fe7fce618cbd68d5576a470fcb9fa45268fc7ab) while preserving the compiled helper. The bounded host repair is complete. Full compiler input/frame proof and inherited actor inventory remain open. Work continues in parallel on native lifecycle profiling and offline payload ingestion/recipe storage. Both EriX guest build generations and the Rust/LLVM guest rebuild still require demonstration. Checklist completion remains 22.06%, with 34 of 460 parent items and 461 of 1002 sub-items complete. This prerequisite repair adds no full-feature acceptance.
Author
Owner

Offline ingestion and recipe storage are complete, with the source and manual published. Accounting is now 22.50% weighted progress and 35/460 accepted parents; the 461/1002 completed sub-items are unchanged. Native TCG captures are complete for six lifecycle scenarios, but code ambiguity and the missing baseline firmware proof prevent a speedup claim. Both guest build generations and the Rust/LLVM guest rebuild remain open.

Offline ingestion and recipe storage are complete, with [the source](https://git.erikinkinen.fi/erix/integration/commit/f14be3cd082c410e4c43125bc8c9f975feb76ef9) and [manual](https://git.erikinkinen.fi/erix/docs/commit/8ee44cc676465ae2a60192f7cdfc856e48a4944a) published. Accounting is now 22.50% weighted progress and 35/460 accepted parents; the 461/1002 completed sub-items are unchanged. Native TCG captures are complete for six lifecycle scenarios, but code ambiguity and the missing baseline firmware proof prevent a speedup claim. Both guest build generations and the Rust/LLVM guest rebuild remain open.
Author
Owner

The sealed-source and pin repair and matching source catalogs are published. Genuine signed-helper preparation, four-profile wiring and manual checks are progressing in parallel. Completion remains 22.50% weighted, with 35 complete parent items; these custody repairs add no whole-item acceptance. Both full EriX guest build generations and the Rust/LLVM guest rebuild remain required.

The [sealed-source and pin repair](https://git.erikinkinen.fi/erix/exsh/commit/237c8875bd41d62d128746226ccdde7a9550372a) and [matching source catalogs](https://git.erikinkinen.fi/erix/integration/commit/df2c4243ecdd466da821e98ee41153da036b9f4f) are published. Genuine signed-helper preparation, four-profile wiring and manual checks are progressing in parallel. Completion remains 22.50% weighted, with 35 complete parent items; these custody repairs add no whole-item acceptance. Both full EriX guest build generations and the Rust/LLVM guest rebuild remain required.
Author
Owner

The complete LibConstantTime inline review is accepted in its issue and PR. Checklist progress is now 22.51% weighted, with 462/1002 sub-items complete; whole-item acceptance remains 10.99%, or 35/460 parents. The four-profile image implementation and complete compiler capture continue in parallel. Both full EriX guest generations and the external Rust/LLVM guest rebuild remain open.

The complete LibConstantTime inline review is accepted in [its issue](https://git.erikinkinen.fi/erix/lib-constant-time/issues/1) and [PR](https://git.erikinkinen.fi/erix/lib-constant-time/pulls/2). Checklist progress is now 22.51% weighted, with 462/1002 sub-items complete; whole-item acceptance remains 10.99%, or 35/460 parents. The four-profile image implementation and complete compiler capture continue in parallel. Both full EriX guest generations and the external Rust/LLVM guest rebuild remain open.
Author
Owner

The LibCRC inline review is accepted and the manual refresh includes the published byte and CRC contracts. Checklist progress is 22.52% weighted, with 463/1002 sub-items complete; whole-item acceptance remains 10.99%, or 35/460 parents. Image-profile transport and compiler/source work continue. Both full EriX guest generations and the external Rust/LLVM guest rebuild remain open.

The [LibCRC inline review](https://git.erikinkinen.fi/erix/lib-crc/issues/1) is accepted and the [manual refresh](https://git.erikinkinen.fi/erix/docs/pulls/4) includes the published byte and CRC contracts. Checklist progress is 22.52% weighted, with 463/1002 sub-items complete; whole-item acceptance remains 10.99%, or 35/460 parents. Image-profile transport and compiler/source work continue. Both full EriX guest generations and the external Rust/LLVM guest rebuild remain open.
Author
Owner

Docs now has a concise current roadmap and a linked checkpoint history. Earlier source selections, failures, limits and unfinished requirements are preserved. This cleanup adds no implementation completion; both EriX guest build generations and the Rust/LLVM guest rebuild remain open.

Docs now has a concise [current roadmap](https://git.erikinkinen.fi/erix/docs/src/commit/1b7bd5d01d1ba699eebef18f9c2a8661f8721315/ROADMAP.md) and a linked [checkpoint history](https://git.erikinkinen.fi/erix/docs/src/commit/1b7bd5d01d1ba699eebef18f9c2a8661f8721315/history.md). Earlier source selections, failures, limits and unfinished requirements are preserved. This cleanup adds no implementation completion; both EriX guest build generations and the Rust/LLVM guest rebuild remain open.
Author
Owner

Four explicit image profiles are implemented in bae5480a. Extended profiles inherit the corresponding clean runtime configuration and retain their non-clean-room labels through appliance and disk packaging. Fixed consumers receive complete configuration packets, and packaging rechecks the retained source, configuration and profile records.

The explicit-profile criterion in the packaging issue is complete. Imported-tool admission, complete installed-content checks and all four full image builds remain open. The manual describes the configuration contract.

Four explicit image profiles are implemented in [bae5480a](https://git.erikinkinen.fi/erix/integration/commit/bae5480a21749440481c144ad7b7d50c064dbfce). Extended profiles inherit the corresponding clean runtime configuration and retain their non-clean-room labels through appliance and disk packaging. Fixed consumers receive complete configuration packets, and packaging rechecks the retained source, configuration and profile records. The explicit-profile criterion in [the packaging issue](https://git.erikinkinen.fi/erix/integration/issues/4) is complete. Imported-tool admission, complete installed-content checks and all four full image builds remain open. [The manual](https://git.erikinkinen.fi/erix/docs/commit/3a2a84b1879108b0a99dcdaee62f57baf1dd8ad6) describes the configuration contract.
Author
Owner

The full push run for d5e877cf fails during native admission: the Rust job records error 22, and image-profile preflight now reports the original OSError; errno=22. Its Markdown job passes. The earlier profile message did not retain an errno, so its cause remains recorded as unknown. The current runner prerequisite remains open.

Tracked in the runner issue; full CI completion remains open.

The full push run for [d5e877cf](https://git.erikinkinen.fi/erix/integration/commit/d5e877cf878f61cf8d07438699b1bd4a9b483789) fails during native admission: the Rust job records error 22, and image-profile preflight now reports the original `OSError; errno=22`. Its Markdown job passes. The earlier profile message did not retain an errno, so its cause remains recorded as unknown. The current runner prerequisite remains open. Tracked in [the runner issue](https://git.erikinkinen.fi/erix/integration/issues/113); full CI completion remains open.
Author
Owner

906cfb5a removes temporary token slices and repeated parsing of unchanged LLVM lines. Each verifier still parses its own original input independently. Across nine modules, complete derived bytes, mappings and semantic lists match.

Plain wall time in the paired experiment fell from 97.66 to 91.19 seconds; the instrumented variant fell from 100.51 to 99.38 seconds. These were single baseline-first pairs on the host, with some modules slower and no observer overhead subtracted. The result supports the narrow redundant-work removal; complete compiler and guest-build requirements remain open.

[906cfb5a](https://git.erikinkinen.fi/erix/exsh/commit/906cfb5af32c0befee27126ae1d8847afe6647ee) removes temporary token slices and repeated parsing of unchanged LLVM lines. Each verifier still parses its own original input independently. Across nine modules, complete derived bytes, mappings and semantic lists match. Plain wall time in the paired experiment fell from 97.66 to 91.19 seconds; the instrumented variant fell from 100.51 to 99.38 seconds. These were single baseline-first pairs on the host, with some modules slower and no observer overhead subtracted. The result supports the narrow redundant-work removal; complete compiler and guest-build requirements remain open.
Author
Owner

Integration now selects the measured Exsh parser optimization in both catalogs. The manual's AES dependency and owned-buffer erasure description is also corrected. These changes do not complete another checklist item. The complete compiler capture, full guest builds and toolchain rebuild remain open.

Integration now selects the [measured Exsh parser optimization in both catalogs](https://git.erikinkinen.fi/erix/integration/commit/21c6de00c9bf559a907ad36634815e6016b69785). The [manual's AES dependency and owned-buffer erasure description](https://git.erikinkinen.fi/erix/docs/commit/e555a7055fa2574c892d981dfeb9a0c692a1a90a) is also corrected. These changes do not complete another checklist item. The complete compiler capture, full guest builds and toolchain rebuild remain open.
Author
Owner

The counted-path migration design covers the remaining fixed-width filesystem, bootstrap and launch interfaces. It includes the complete 20-file native filename workload, with 255-byte names and full paths, through the existing read-only client scope. Implementation and guest evidence remain open.

The [counted-path migration design](https://git.erikinkinen.fi/erix/lib-ipc/issues/9) covers the remaining fixed-width filesystem, bootstrap and launch interfaces. It includes the complete 20-file native filename workload, with 255-byte names and full paths, through the existing read-only client scope. Implementation and guest evidence remain open.
Author
Owner

The complete signed-source Exsh compiler diagnostic now finishes in 227.63 seconds with the original time and byte limits. Its raw IR/ELF and derived artifacts are retained, and the loan-aware relay keeps the original actor reservations intact. Signature certification warnings still need correction. This is a Linux-host diagnostic; source/frame admission and the EriX-hosted builds remain open, so checklist completion is unchanged.

The complete signed-source Exsh compiler diagnostic now finishes in 227.63 seconds with the original time and byte limits. Its raw IR/ELF and derived artifacts are retained, and the loan-aware relay keeps the original actor reservations intact. [Signature certification warnings](https://git.erikinkinen.fi/erix/exsh/issues/17) still need correction. This is a Linux-host diagnostic; source/frame admission and the EriX-hosted builds remain open, so checklist completion is unchanged.
Author
Owner

The source-signature warning fix is published in Exsh a6aa6b48 and selected by Integration 8b0292d2. A complete freestanding compiler capture confirms that the fifteen certification warnings reported in Exsh #17 are gone.

Checklist progress remains 22.97%, with 11.44% whole-item acceptance. The encrypted-filename fixture and complete image inventory are under implementation; their composed image/guest gates remain open. Two full builds inside EriX and the guest Rust/LLVM rebuild are still required.

The source-signature warning fix is published in [Exsh a6aa6b48](https://git.erikinkinen.fi/erix/exsh/commit/a6aa6b48295fbc1a28ef7ed212e642383b691dcf) and selected by [Integration 8b0292d2](https://git.erikinkinen.fi/erix/integration/commit/8b0292d25b1a2f8aa9af2535eb10c1f6e01bb7f1). A complete freestanding compiler capture confirms that the fifteen certification warnings reported in [Exsh #17](https://git.erikinkinen.fi/erix/exsh/issues/17) are gone. Checklist progress remains **22.97%**, with **11.44% whole-item acceptance**. The encrypted-filename fixture and complete image inventory are under implementation; their composed image/guest gates remain open. Two full builds inside EriX and the guest Rust/LLVM rebuild are still required.
Author
Owner

Deadline contexts now retain the first error and independent restoration errors through entry, phase changes and cleanup. A caught phase failure remains a failure, and attempted effects cannot be replayed. The source, fixtures and CI entry are updated in this commit; the deadline contract describes the records and ownership limits.

Complete native mask composition, image exclusion and creator/descendant lifetime remain open. The size gate and complete encrypted media handoff are progressing in parallel.

Deadline contexts now retain the first error and independent restoration errors through entry, phase changes and cleanup. A caught phase failure remains a failure, and attempted effects cannot be replayed. The source, fixtures and CI entry are updated in [this commit](https://git.erikinkinen.fi/erix/integration/commit/c9f2b52b149bd056856b2594e497595c8b49365e); the [deadline contract](https://git.erikinkinen.fi/erix/integration/src/commit/c9f2b52b149bd056856b2594e497595c8b49365e/docs/startup-deadlines.md) describes the records and ownership limits. Complete native mask composition, image exclusion and creator/descendant lifetime remain open. The size gate and complete encrypted media handoff are progressing in parallel.
Author
Owner

The tracked-source size gate is complete in the signed Integration change. The final census covers all 76 repositories and 7,215 tracked files; tests and generated code stay within the same physical line limit. The owning audit criteria and PR #12 are linked to this change.

Accounting now shows 23.02% weighted progress and 11.52% whole-item acceptance: 37 of 460 parents and 465 of 1,002 sub-items. The guest builds and guest toolchain rebuild remain outstanding.

The [tracked-source size gate](https://git.erikinkinen.fi/erix/integration/src/commit/94344102689818a9d0099f6af66e8c41ccb05bdd/docs/source-size-policy.md) is complete in [the signed Integration change](https://git.erikinkinen.fi/erix/integration/commit/94344102689818a9d0099f6af66e8c41ccb05bdd). The final census covers all 76 repositories and 7,215 tracked files; tests and generated code stay within the same physical line limit. The owning [audit criteria](https://git.erikinkinen.fi/erix/integration/issues/2) and [PR #12](https://git.erikinkinen.fi/erix/integration/pulls/12) are linked to this change. Accounting now shows **23.02% weighted progress** and **11.52% whole-item acceptance**: 37 of 460 parents and 465 of 1,002 sub-items. The guest builds and guest toolchain rebuild remain outstanding.
Author
Owner

The substring implementation, manual/API and Integration adoption are complete for their declared source/host scope. The checklist now exposes that completed operation: weighted progress is 23.04%, with 466/1003 sub-items complete. Whole-item acceptance remains 11.52% and 37/460 parents; no parent scope was reduced.

Missing SHA2 job logs are now tracked separately from native runner compatibility. Both full EriX guest generations and the external Rust/LLVM rebuild inside EriX remain mandatory and unperformed.

The substring implementation, [manual/API](https://git.erikinkinen.fi/erix/docs/commit/f3218351ed57a6c61c7ab5d27e1bdf16d1e159a1) and [Integration adoption](https://git.erikinkinen.fi/erix/integration/commit/feaea0bed0bc97be79d952920dae8c5c1cc5b990) are complete for their declared source/host scope. The checklist now exposes that completed operation: weighted progress is 23.04%, with 466/1003 sub-items complete. Whole-item acceptance remains 11.52% and 37/460 parents; no parent scope was reduced. [Missing SHA2 job logs](https://git.erikinkinen.fi/erix/integration/issues/116) are now tracked separately from [native runner compatibility](https://git.erikinkinen.fi/erix/integration/issues/113). Both full EriX guest generations and the external Rust/LLVM rebuild inside EriX remain mandatory and unperformed.
Author
Owner

The remaining 72 PR descriptions now give the current implementation scope without accumulated status history. Their combined body size fell by about 89%; six titles now reflect the actual changes. Related issue links, metadata and meaningful review criteria are preserved. Unsupported current-CI checks are open, and earlier local results retain their original scope.

That description-reconciliation item is complete. Checklist progress is 23.10%, with 467 of 1003 sub-items complete; whole-item acceptance remains 11.52% (37 of 460). Both full EriX guest build generations and the external toolchain rebuild inside EriX remain required and unperformed.

The remaining 72 PR descriptions now give the current implementation scope without accumulated status history. Their combined body size fell by about 89%; six titles now reflect the actual changes. Related issue links, metadata and meaningful review criteria are preserved. Unsupported current-CI checks are open, and earlier local results retain their original scope. That description-reconciliation item is complete. Checklist progress is 23.10%, with 467 of 1003 sub-items complete; whole-item acceptance remains 11.52% (37 of 460). Both full EriX guest build generations and the external toolchain rebuild inside EriX remain required and unperformed.
Author
Owner

The fixed C-locale error catalog is complete with Integration and manual/API support. Its checklist now separates the remaining thread adapters, locale interfaces and native workload acceptance. Weighted progress is 23.21%, with 468 of 1,007 sub-items complete; 37 of 460 parent items are accepted. Both full guest build generations and the guest toolchain rebuild remain open.

The fixed C-locale error catalog is complete with Integration and manual/API support. Its checklist now separates the remaining thread adapters, locale interfaces and native workload acceptance. Weighted progress is 23.21%, with 468 of 1,007 sub-items complete; 37 of 460 parent items are accepted. Both full guest build generations and the guest toolchain rebuild remain open.
Author
Owner

Weighted checklist progress remains 23.21%, with 468/1007 sub-items and 37/460 whole items accepted. The ERANGE extension completes the current catalog graph without adding another share to its already accepted checklist item. The profiler CLI defect and GNU archive defect are closed. Cstd b15c0452 adds four fixed C-locale integer conversions; their complete consumer and manual adoption is in progress. Both full guest build generations and rebuilding Rust/LLVM inside EriX remain required.

Weighted checklist progress remains 23.21%, with 468/1007 sub-items and 37/460 whole items accepted. The ERANGE extension completes the current catalog graph without adding another share to its already accepted checklist item. The [profiler CLI defect](https://git.erikinkinen.fi/erix/integration/issues/117) and [GNU archive defect](https://git.erikinkinen.fi/erix/lib-cstd/issues/6) are closed. [Cstd b15c0452](https://git.erikinkinen.fi/erix/lib-cstd/commit/b15c045255a3030bb9d36e82d9b2a4da2ef2fb4a) adds four fixed C-locale integer conversions; their complete consumer and manual adoption is in progress. Both full guest build generations and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

The fixed C-locale integer-conversion operation is complete across Cstd, Integration and the manual/API pages. Completion is 23.30%, with 470 of 1,012 sub-items checked and 37 of 460 whole items accepted. Both full guest build generations and the external toolchain rebuild inside EriX remain open.

The fixed C-locale integer-conversion operation is complete across [Cstd](https://git.erikinkinen.fi/erix/lib-cstd/commit/b15c045255a3030bb9d36e82d9b2a4da2ef2fb4a), [Integration](https://git.erikinkinen.fi/erix/integration/commit/4ee33eb85d4257536abb07c208ba52b0def2b995) and the [manual/API pages](https://git.erikinkinen.fi/erix/docs/commit/e66ff4497f2d8237c4152f56a28bdbc6297cfb83). Completion is 23.30%, with 470 of 1,012 sub-items checked and 37 of 460 whole items accepted. Both full guest build generations and the external toolchain rebuild inside EriX remain open.
Author
Owner

The explicit API conversion is complete across signed Docs and Integration changes. Completion is 23.29%, with 469 of 1,012 sub-items checked and 37 of 460 whole items accepted. The previous Docs CI acceptance cannot carry forward to a new source head, so that item is reopened while its original run is monitored. Runner compatibility, the publisher startup defect, and both full guest generations plus the toolchain rebuild remain open.

The [explicit API conversion](https://git.erikinkinen.fi/erix/docs/issues/14) is complete across signed [Docs](https://git.erikinkinen.fi/erix/docs/commit/3fb1be808d1cda25880489712d2e7198bf355eef) and [Integration](https://git.erikinkinen.fi/erix/integration/commit/50b12fccb3d009044ed50f48a24b095b23fadf7d) changes. Completion is 23.29%, with 469 of 1,012 sub-items checked and 37 of 460 whole items accepted. The previous Docs CI acceptance cannot carry forward to a new source head, so that item is reopened while its original run is monitored. [Runner compatibility](https://git.erikinkinen.fi/erix/integration/issues/113), the [publisher startup defect](https://git.erikinkinen.fi/erix/docs/issues/17), and both full guest generations plus the toolchain rebuild remain open.
Author
Owner

Published the reserved-signal repair, parser fixture repair, fixed AES arithmetic and matching filesystem consumers. All repository CI helper selections now use the repaired native command owner. Docs also includes the matching conversion contract and revised AES manual text.

The complete current source-size audit covers all 76 repositories and 7,278 tracked files, with no policy errors and a maximum code size of 999 lines. The checklist counts only successful workflows at the current commits; successor runs still waiting or running remain open. The separate E2fsd checker-image race is being repaired. Full native frame admission and the required guest builds remain unfinished.

Published the [reserved-signal repair](https://git.erikinkinen.fi/erix/integration/issues/118), [parser fixture repair](https://git.erikinkinen.fi/erix/integration/issues/119), fixed AES arithmetic and matching filesystem consumers. All repository CI helper selections now use the repaired native command owner. Docs also includes the matching conversion contract and revised AES manual text. The complete current source-size audit covers all 76 repositories and 7,278 tracked files, with no policy errors and a maximum code size of 999 lines. The checklist counts only successful workflows at the current commits; successor runs still waiting or running remain open. The separate [E2fsd checker-image race](https://git.erikinkinen.fi/erix/e2fsd/issues/24) is being repaired. Full native frame admission and the required guest builds remain unfinished.
Author
Owner

Fixed the parallel filesystem checker collision in E2fsd #24 and completed the filesystem adoption of fixed-work AES. Both issues are closed. The cryptography manual is updated, and all 76 current repository trees meet the code-file size limit.

At 13:04 UTC, 74 current repository workflows pass. Exsh still needs the full compiler-input and cleanup-frame proof; Integration is queued with the missing clang prerequisite installed. The checklist has been reconciled with these results. Guest self-hosting and the Rust/LLVM rebuild remain open.

Fixed the parallel filesystem checker collision in [E2fsd #24](https://git.erikinkinen.fi/erix/e2fsd/issues/24) and completed the filesystem adoption of [fixed-work AES](https://git.erikinkinen.fi/erix/lib-aes/issues/3). Both issues are closed. The cryptography manual is updated, and all 76 current repository trees meet the code-file size limit. At 13:04 UTC, 74 current repository workflows pass. Exsh still needs the full compiler-input and cleanup-frame proof; Integration is queued with the [missing clang prerequisite](https://git.erikinkinen.fi/erix/integration/issues/120) installed. The checklist has been reconciled with these results. Guest self-hosting and the Rust/LLVM rebuild remain open.
Author
Owner

Published the Exsh trace-wait primitive; compiler integration and the complete frame proof remain open. The Cargo catalog repair is running in Integration CI 2615, with Rust and Markdown complete. Checklist completion remains 24.01% (542/1012 sub-items); this intermediate Exsh change does not close the broader acceptance item.

Published the [Exsh trace-wait primitive](https://git.erikinkinen.fi/erix/exsh/commit/13d15fb8f7e45d7ed409241f2ad663a5910ab14a); compiler integration and the [complete frame proof](https://git.erikinkinen.fi/erix/exsh/issues/4) remain open. The [Cargo catalog repair](https://git.erikinkinen.fi/erix/integration/issues/121) is running in [Integration CI 2615](https://git.erikinkinen.fi/erix/integration/actions/runs/2615), with Rust and Markdown complete. Checklist completion remains **24.01% (542/1012 sub-items)**; this intermediate Exsh change does not close the broader acceptance item.
Author
Owner

The original CI 2615 passes the repaired source-catalog gate and reaches the VM catalog. Its first 13 scenarios then fail at shared RTC staged commit, before their intended assertions. Issue #122 tracks that separate startup failure; investigation is underway.

The original [CI 2615](https://git.erikinkinen.fi/erix/integration/actions/runs/2615) passes the repaired source-catalog gate and reaches the VM catalog. Its first 13 scenarios then fail at shared RTC staged commit, before their intended assertions. [Issue #122](https://git.erikinkinen.fi/erix/integration/issues/122) tracks that separate startup failure; investigation is underway.
Author
Owner

Published Exsh’s trace-operation owner; the complete frame proof remains open. A local run from the exact failing component revisions also reproduces the RTC staged-commit failure. Investigation is focused on the Process control route selected for initial TLS. Checklist completion remains 24.01% (542/1012 sub-items).

Published Exsh’s [trace-operation owner](https://git.erikinkinen.fi/erix/exsh/commit/34c91497a4c02806a5cfbcc001dc75bf06e135e7); the [complete frame proof](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. A local run from the exact failing component revisions also reproduces the [RTC staged-commit failure](https://git.erikinkinen.fi/erix/integration/issues/122). Investigation is focused on the Process control route selected for initial TLS. Checklist completion remains **24.01% (542/1012 sub-items)**.
Author
Owner

Integration b31ac269 now selects the Procd route repair and Exsh tracing operations. The current Procd and Docs workflows pass, bringing the count to 74 repositories with successful current-head CI. The source-size scan passes across all 76 repositories.

RTC startup still fails with the corrected Procd route. Exsh’s compiler-input and frame check also remains incomplete; both repairs continue in parallel.

The checklist is reconciled at 24.01%, with 542/1012 sub-items complete. The guest EriX builds and external Rust/LLVM rebuild remain open.

[Integration b31ac269](https://git.erikinkinen.fi/erix/integration/commit/b31ac269ec7cd7171b50c8b8c89a7e8b228b753f) now selects the Procd route repair and Exsh tracing operations. The current Procd and Docs workflows pass, bringing the count to 74 repositories with successful current-head CI. The source-size scan passes across all 76 repositories. [RTC startup](https://git.erikinkinen.fi/erix/integration/issues/122) still fails with the corrected Procd route. [Exsh’s compiler-input and frame check](https://git.erikinkinen.fi/erix/exsh/issues/4) also remains incomplete; both repairs continue in parallel. The checklist is reconciled at **24.01%**, with **542/1012** sub-items complete. The guest EriX builds and external Rust/LLVM rebuild remain open.
Author
Owner

The metadata layout repair fixes the remaining cause of RTC startup failure #122. The original lookup-manifest VM passes with its existing assertions and limits. The issue now has its repair and regression items checked; the full VM catalog remains open.

The manual and source classifications are updated. The census covers all 76 current heads and 7,284 tracked leaves, with no code file above 999 lines. Integration CI exposed a missing entry in the syntax-order test expectation, which is being corrected. Exsh compiler tracing continues in parallel.

Progress is 24.00%, with 541/1012 sub-items complete. The new manual revision awaits its own CI, temporarily reopening that one CI sub-item; its previous successful render remains recorded. Full guest EriX and toolchain rebuilds remain open.

The [metadata layout repair](https://git.erikinkinen.fi/erix/integration/commit/10d91c79e61f9bfeb243a3e54b93d1e60ea1073c) fixes the remaining cause of [RTC startup failure #122](https://git.erikinkinen.fi/erix/integration/issues/122). The original lookup-manifest VM passes with its existing assertions and limits. The issue now has its repair and regression items checked; the full VM catalog remains open. The [manual](https://git.erikinkinen.fi/erix/docs/commit/dff61aca3a817d2ca0d2287d1ffcfc52f7ee38c6) and source classifications are updated. The census covers all 76 current heads and 7,284 tracked leaves, with no code file above 999 lines. Integration CI exposed a missing entry in the syntax-order test expectation, which is being corrected. Exsh compiler tracing continues in parallel. Progress is 24.00%, with 541/1012 sub-items complete. The new manual revision awaits its own CI, temporarily reopening that one CI sub-item; its previous successful render remains recorded. Full guest EriX and toolchain rebuilds remain open.
Author
Owner

Docs’ current workflow passes, including the complete manual render. Its CI sub-item is restored: progress is 24.01%, with 542/1012 sub-items complete and 74 current repository workflows passing.

Integration b0cea358 includes the corrected syntax-test expectation; its integration job is running. The current source census covers all 76 signed heads with no code file above 999 lines. The complete VM catalog, Exsh frame check and guest build demonstrations remain open.

Docs’ [current workflow](https://git.erikinkinen.fi/erix/docs/actions/runs/1614) passes, including the complete manual render. Its CI sub-item is restored: progress is 24.01%, with 542/1012 sub-items complete and 74 current repository workflows passing. [Integration b0cea358](https://git.erikinkinen.fi/erix/integration/commit/b0cea358d53451a9991154e094b702b13afd5273) includes the corrected syntax-test expectation; its integration job is running. The current source census covers all 76 signed heads with no code file above 999 lines. The complete VM catalog, Exsh frame check and guest build demonstrations remain open.
Author
Owner

The toolchain inventory now includes pinned TeX sources and separate build-host and EriX roles. Its remaining recipe and license requirements are still open.

Completion remains 24.01%, with 542/1,012 sub-items and 37/460 whole items complete. Both full EriX builds and the Rust/LLVM rebuild inside EriX remain required and unfinished.

The [toolchain inventory](https://git.erikinkinen.fi/erix/integration/issues/7) now includes pinned TeX sources and separate build-host and EriX roles. Its remaining recipe and license requirements are still open. Completion remains **24.01%**, with **542/1,012 sub-items** and **37/460 whole items** complete. Both full EriX builds and the Rust/LLVM rebuild inside EriX remain required and unfinished.
Author
Owner

Completion is now 24.02%: 543/1012 sub-items and 37/460 complete parent items. Vfsd’s quality checks are accepted and the current Vfsd/Docs CI credits are restored. Whole repository audits remain open.

The launch-stack repair for Vfsd #33 and the toolchain catalog are published. Repaired guest confirmation, external-tool ports and both full EriX guest build generations are still required.

Completion is now 24.02%: 543/1012 sub-items and 37/460 complete parent items. Vfsd’s quality checks are accepted and the current Vfsd/Docs CI credits are restored. Whole repository audits remain open. The launch-stack repair for [Vfsd #33](https://git.erikinkinen.fi/erix/vfsd/issues/33) and the [toolchain catalog](https://git.erikinkinen.fi/erix/integration/issues/7) are published. Repaired guest confirmation, external-tool ports and both full EriX guest build generations are still required.
Author
Owner

The classification regression is resolved: the repaired complete repository audit and the affected original CI source-size gate pass.

The real guest catalog still fails initial shell materialization under Vfsd #33. The next correction covers the native exact-object read and reply path that the earlier component regression omitted. Overall CI and guest-build acceptance remain open.

[The classification regression](https://git.erikinkinen.fi/erix/integration/issues/123) is resolved: the repaired complete repository audit and the affected original CI source-size gate pass. The real guest catalog still fails initial shell materialization under [Vfsd #33](https://git.erikinkinen.fi/erix/vfsd/issues/33). The next correction covers the native exact-object read and reply path that the earlier component regression omitted. Overall CI and guest-build acceptance remain open.
Author
Owner

The checklist is now at 23.42%: 37 accepted parent items and 482 completed sub-items. The IPC documentation defect is closed. Forty-five consumers now select the corrected dependencies. Integration’s orchestration library is at 32fb0a10; final image catalogs follow the remaining eight consumers.

The checklist is now at 23.42%: 37 accepted parent items and 482 completed sub-items. [The IPC documentation defect](https://git.erikinkinen.fi/erix/lib-ipc/issues/10) is closed. Forty-five consumers now select the corrected dependencies. Integration’s orchestration library is at `32fb0a10`; final image catalogs follow the remaining eight consumers.
Author
Owner

Phase 6 completion is 24.07%: 37 whole items and 548 of 1,012 sub-items. The IPC repair cascade and final catalogs are published. The full VM catalog and Exsh cleanup proof remain open. The EriX builds and external Rust/LLVM rebuild inside EriX remain required.

Phase 6 completion is 24.07%: 37 whole items and 548 of 1,012 sub-items. The IPC repair cascade and [final catalogs](https://git.erikinkinen.fi/erix/integration/pulls/12) are published. The [full VM catalog](https://git.erikinkinen.fi/erix/integration/issues/124) and [Exsh cleanup proof](https://git.erikinkinen.fi/erix/exsh/issues/4) remain open. The EriX builds and external Rust/LLVM rebuild inside EriX remain required.
Author
Owner

The published catalog now includes Exsh’s observer and cancellation fixes, Rootd’s initial-shell failure recorder, and the matching manual. Exsh’s timing-fixture regression #18 is closed; its compiler/frame-proof work remains open in #4.

The multi-PTY case is running on the updated sources to identify the cleanup failure in #125. Complete guest builds, both self-hosting generations, and rebuilding Rust/LLVM inside EriX remain required.

The published catalog now includes Exsh’s observer and cancellation fixes, Rootd’s initial-shell failure recorder, and the matching manual. Exsh’s timing-fixture regression [#18](https://git.erikinkinen.fi/erix/exsh/issues/18) is closed; its compiler/frame-proof work remains open in [#4](https://git.erikinkinen.fi/erix/exsh/issues/4). The multi-PTY case is running on the updated sources to identify the cleanup failure in [#125](https://git.erikinkinen.fi/erix/integration/issues/125). Complete guest builds, both self-hosting generations, and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

Exsh 0849638 adds conservative immediate-mask arithmetic to frame analysis. The full proof remains open in Exsh #4. The joined Timed/LibIPC clock regression now has its original source and Cargo metadata prepared; host checks are next.

Completion remains 24.14%: 556 of 1,012 sub-items and 37 of 460 parent items. The new instruction support closes no broader checklist item. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.

Exsh [0849638](https://git.erikinkinen.fi/erix/exsh/commit/084963895e0093e28cf42490576292b4198d8dde) adds conservative immediate-mask arithmetic to frame analysis. The full proof remains open in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). The joined Timed/LibIPC clock regression now has its original source and Cargo metadata prepared; host checks are next. Completion remains 24.14%: 556 of 1,012 sub-items and 37 of 460 parent items. The new instruction support closes no broader checklist item. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.
Author
Owner

Integration e5c0a7f adopts the Rootd completion and Bootloader named-input fixes. The clock regression joins the real Timed and LibIPC code and keeps service refusal distinct from transport error 5. The guest startup failure remains open in #125.

Exsh dff37e2 retains refused instruction and jump-table inputs for the remaining frame analysis failures.

Completion remains 24.14%: 556 of 1,012 sub-items and 37 of 460 parent items. These changes close no broader checklist item. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.

Integration [e5c0a7f](https://git.erikinkinen.fi/erix/integration/commit/e5c0a7ffe59c2c5f94730f5545e0bdf14f402469) adopts the Rootd completion and Bootloader named-input fixes. The [clock regression](https://git.erikinkinen.fi/erix/integration/commit/94f14f6cedd9427522074b8155288786b5cf21d1) joins the real Timed and LibIPC code and keeps service refusal distinct from transport error `5`. The guest startup failure remains open in [#125](https://git.erikinkinen.fi/erix/integration/issues/125). Exsh [dff37e2](https://git.erikinkinen.fi/erix/exsh/commit/dff37e2e5e2350de980a99478d6c2c41addf4f78) retains refused instruction and jump-table inputs for the remaining [frame analysis failures](https://git.erikinkinen.fi/erix/exsh/issues/4). Completion remains 24.14%: 556 of 1,012 sub-items and 37 of 460 parent items. These changes close no broader checklist item. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.
Author
Owner

TTYd 17477bf6 adds hosted coverage for two bootstrap sessions with separate clock observations, routes and metadata. A refused second receiver must preserve the first live session and leave the unpublished slots reusable. The guest startup failure remains open in Integration #125.

Completion is 24.14%: 555 of 1,012 sub-items and 37 of 460 parent items. TTYd’s exact-head CI checkbox is open until the new workflow succeeds; its previous successful run remains recorded. The full EriX and Rust/LLVM rebuilds inside EriX remain outstanding.

TTYd [17477bf6](https://git.erikinkinen.fi/erix/ttyd/commit/17477bf6bad97db4810fa8f48ff5cbe6f7c220da) adds hosted coverage for two bootstrap sessions with separate clock observations, routes and metadata. A refused second receiver must preserve the first live session and leave the unpublished slots reusable. The guest startup failure remains open in [Integration #125](https://git.erikinkinen.fi/erix/integration/issues/125). Completion is 24.14%: 555 of 1,012 sub-items and 37 of 460 parent items. TTYd’s exact-head CI checkbox is open until the new workflow succeeds; its previous successful run remains recorded. The full EriX and Rust/LLVM rebuilds inside EriX remain outstanding.
Author
Owner

The Rootd orchestration library is published in 7769fb52, with consumer and catalog adoption still underway in the Rootd review. The extraction stays open until that scope is complete.

Checklist progress is unchanged at 24.14%, with 555/1012 sub-items and 37/460 whole items accepted.

The Rootd orchestration library is published in [7769fb52](https://git.erikinkinen.fi/erix/integration/commit/7769fb520cd95da1d32d28077033f5c8fa8cc7b7), with consumer and catalog adoption still underway in the [Rootd review](https://git.erikinkinen.fi/erix/rootd/pulls/2). The extraction stays open until that scope is complete. Checklist progress is unchanged at **24.14%**, with **555/1012** sub-items and **37/460** whole items accepted.
Author
Owner

Published the Rootd extraction and catalog adoption, the manual update, and the pipe-client CI coverage fix.

The checklist is reconciled at 24.14%, with 556/1,012 sub-items complete and 37/460 parents accepted. The new Rootd and Docs CI checks are restored, and Posixd component checks are complete. Affected guests, remaining workflows, and both the EriX and external-toolchain self-build demonstrations remain open.

Published the [Rootd extraction and catalog adoption](https://git.erikinkinen.fi/erix/integration/commit/d52656765dbe03ec9cd71e9a422176bd0f5058b1), the [manual update](https://git.erikinkinen.fi/erix/docs/commit/7248829737be143d753e6f4f45532efd662c69d6), and the [pipe-client CI coverage fix](https://git.erikinkinen.fi/erix/posixd/issues/42). The checklist is reconciled at **24.14%**, with **556/1,012 sub-items** complete and **37/460 parents** accepted. The new Rootd and Docs CI checks are restored, and Posixd component checks are complete. Affected guests, remaining workflows, and both the EriX and external-toolchain self-build demonstrations remain open.
Author
Owner

Published Kernel nested-call coverage and the Exsh instruction and profiling improvements. The checklist remains 24.14%, with 555/1,012 sub-items complete: only the new Kernel commit's CI check reopened, while its component-check credit is retained.

The Rootd guest graph is being prepared from exact source commits. Exsh #4, the remaining workflows and guest regressions, and both self-build demonstrations remain open.

Published [Kernel nested-call coverage](https://git.erikinkinen.fi/erix/kernel/commit/187c03fc1251b7ccf584fc6b59188fb08103222e) and the [Exsh instruction and profiling improvements](https://git.erikinkinen.fi/erix/exsh/commit/64f7b7d0427ea2ce78b6f82f42838a56f8161913). The checklist remains **24.14%**, with **555/1,012 sub-items** complete: only the new Kernel commit's CI check reopened, while its component-check credit is retained. The Rootd guest graph is being prepared from exact source commits. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4), the remaining workflows and guest regressions, and both self-build demonstrations remain open.
Author
Owner

Kernel 187c03fc now passes CI 917, with both complete logs free of warnings. This restores one CI checklist entry: 556/1012 sub-items, 24.14% weighted progress. Accepted parents remain 37/460.

Integration, Exsh, Posixd and TTYd still need complete current-source CI. The guest self-build and Rust/LLVM rebuild demonstrations remain open.

Kernel [187c03fc](https://git.erikinkinen.fi/erix/kernel/commit/187c03fc1251b7ccf584fc6b59188fb08103222e) now passes [CI 917](https://git.erikinkinen.fi/erix/kernel/actions/runs/917), with both complete logs free of warnings. This restores one CI checklist entry: 556/1012 sub-items, 24.14% weighted progress. Accepted parents remain 37/460. Integration, Exsh, Posixd and TTYd still need complete current-source CI. The guest self-build and Rust/LLVM rebuild demonstrations remain open.
Author
Owner

Integration 104fdec3 installs the Rust components required by the VM preflight, addressing #130. Its automatic CI run is still pending.

The original timed-deadline guest case passes on the published Rootd changes. Eight affected guest cases remain. Checklist progress stays at 556/1012 sub-items (24.14% weighted); the full guest build and in-guest Rust/LLVM rebuild remain open.

Integration [104fdec3](https://git.erikinkinen.fi/erix/integration/commit/104fdec3a5cae54c582c7bbb110052dbc1e04a6d) installs the Rust components required by the VM preflight, addressing #130. Its automatic CI run is still pending. The original timed-deadline guest case passes on the published Rootd changes. Eight affected guest cases remain. Checklist progress stays at 556/1012 sub-items (24.14% weighted); the full guest build and in-guest Rust/LLVM rebuild remain open.
Author
Owner

The Exsh capture ownership repair is pushed. The original timed-deadline and FAT catalog/directory-growth guest cases pass; seven affected cases remain. The current Integration run has passed its Rust and Markdown jobs and is running the complete VM catalog.

Checklist progress remains 24.14%, with 556/1012 sub-items complete. The full build and external toolchain rebuild inside EriX remain open.

The [Exsh capture ownership repair](https://git.erikinkinen.fi/erix/exsh/commit/6fc7334fcaf2cfcd458917c08165354d5f68142f) is pushed. The original timed-deadline and FAT catalog/directory-growth guest cases pass; seven affected cases remain. The current Integration run has passed its Rust and Markdown jobs and is running the complete VM catalog. Checklist progress remains **24.14%**, with **556/1012** sub-items complete. The full build and external toolchain rebuild inside EriX remain open.
Author
Owner

Three of the nine selected guest cases now pass: timed deadlines, FAT catalog/directory growth, and the expanded VFS API. The manual update is pushed.

Its new original CI run is pending, so the Docs current-head CI check is reopened. That makes 555/1012 sub-items complete; weighted progress still rounds to 24.14%.

Three of the nine selected guest cases now pass: timed deadlines, FAT catalog/directory growth, and the expanded VFS API. The [manual update](https://git.erikinkinen.fi/erix/docs/commit/63aff04888e2f837dce36566955a97097c70def7) is pushed. Its new original CI run is pending, so the Docs current-head CI check is reopened. That makes **555/1012** sub-items complete; weighted progress still rounds to **24.14%**.
Author
Owner

Docs CI 1631 passes on 63aff048. Both complete original job logs are verified; the final manual render is clean. The current-head CI check is restored, returning the checklist to 556/1012 sub-items and 24.14% weighted progress.

Four of the nine selected guest cases now pass, including the pre-Procd dynamic-linking case.

[Docs CI 1631](https://git.erikinkinen.fi/erix/docs/actions/runs/1631) passes on `63aff048`. Both complete original job logs are verified; the final manual render is clean. The current-head CI check is restored, returning the checklist to **556/1012** sub-items and **24.14%** weighted progress. Four of the nine selected guest cases now pass, including the pre-Procd dynamic-linking case.
Author
Owner

The libc character companion now supplies fourteen fixed C-locale functions with safe scalar Rust calls. Manual/API adoption is in progress.

Its new source is awaiting CI, so the exact-head CI item is open again: 555/1012 sub-items, 24.14% weighted progress. Five of the nine selected Rootd guest cases are accepted. The full guest build and Rust/LLVM rebuild remain open.

The [libc character companion](https://git.erikinkinen.fi/erix/lib-cstd/pulls/3#issuecomment-21611) now supplies fourteen fixed C-locale functions with safe scalar Rust calls. Manual/API adoption is in progress. Its new source is awaiting CI, so the exact-head CI item is open again: **555/1012** sub-items, **24.14%** weighted progress. Five of the nine selected Rootd guest cases are accepted. The full guest build and Rust/LLVM rebuild remain open.
Author
Owner

All nine selected boot and runtime regression cases now pass, including the Procd spawn path, production disk and release quiet-output case. Two artifact captures needed continuation after reaching their storage allowance; neither guest was replayed. The full CI matrix and the EriX/toolchain self-hosting demonstrations remain open.

All nine selected boot and runtime regression cases now pass, including the Procd spawn path, production disk and release quiet-output case. Two artifact captures needed continuation after reaching their storage allowance; neither guest was replayed. The full CI matrix and the EriX/toolchain self-hosting demonstrations remain open.
Author
Owner

e61b81c1 selects the ACL completion repair and Vfsd launch-path stack reduction together. Both component CIs pass; the unchanged directory-script and ACL guests are next. A separate supplier repair is underway for the obsolete EXT verifier expectations in #131.

The libc-helper checklist now shows the completed character calls separately from its six remaining families. Full EriX and external-toolchain builds inside EriX remain open.

`e61b81c1` selects the [ACL completion repair](https://git.erikinkinen.fi/erix/rootd/issues/8) and [Vfsd launch-path stack reduction](https://git.erikinkinen.fi/erix/vfsd/issues/33) together. Both component CIs pass; the unchanged directory-script and ACL guests are next. A separate supplier repair is underway for the obsolete EXT verifier expectations in [#131](https://git.erikinkinen.fi/erix/integration/issues/131). The libc-helper checklist now shows the completed character calls separately from its six remaining families. Full EriX and external-toolchain builds inside EriX remain open.
Author
Owner

Completed the C runtime sorting/search slice and its manual/API update. Progress is 24.25%, with 557/1,019 sub-items complete.

The unchanged ACL metadata guest now passes, closing Rootd #8. The directory workflow still fails during cleanup and is tracked separately in #132. The EXT verifier repair is published; Rootd adoption and the six original regression cases follow. Full guest builds and the external toolchain rebuild inside EriX remain open.

Completed the C runtime sorting/search slice and its [manual/API update](https://git.erikinkinen.fi/erix/docs/commit/5ab270b6489d0f8f0f8a177c32ed9b35c742f8e9). Progress is 24.25%, with 557/1,019 sub-items complete. The unchanged ACL metadata guest now passes, closing [Rootd #8](https://git.erikinkinen.fi/erix/rootd/issues/8). The directory workflow still fails during cleanup and is tracked separately in [#132](https://git.erikinkinen.fi/erix/integration/issues/132). The [EXT verifier repair](https://git.erikinkinen.fi/erix/integration/issues/131) is published; Rootd adoption and the six original regression cases follow. Full guest builds and the external toolchain rebuild inside EriX remain open.
Author
Owner

Progress is 24.27%, with 559/1,019 sub-items and 37/460 parent items complete.

The repaired catalog now selects the updated EXT verifier, Rootd, Kernel, LibCStd and manual. EXT2 links and rename pass; EXT3, EXT4 and the directory regression remain pending. Posixd’s missing pipe-client CI coverage is resolved.

Exsh preserves more byte-value precision, while its complete frame proof remains open. Both full guest build generations and the Rust/LLVM rebuild inside EriX are still required.

Progress is **24.27%**, with 559/1,019 sub-items and 37/460 parent items complete. The repaired catalog now selects the updated EXT verifier, Rootd, Kernel, LibCStd and manual. EXT2 links and rename pass; EXT3, EXT4 and the directory regression remain pending. [Posixd’s missing pipe-client CI coverage](https://git.erikinkinen.fi/erix/posixd/issues/42) is resolved. Exsh preserves more byte-value precision, while [its complete frame proof](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. Both full guest build generations and the Rust/LLVM rebuild inside EriX are still required.
Author
Owner

Integration #131 is closed after all six unchanged EXT2/3/4 link and rename scenarios passed on the repaired component graph. The directory regression in #132 remains open.

Exsh e2f80172 now records compiler/tool versions and ELF hashes to help diagnose its frame-analysis timeouts. Exsh CI534 is running; the complete current Integration suite is still queued. Accepted CI coverage remains 74 of 76 current published heads.

Checklist progress is 24.28% (560/1019 sub-items; 37/460 whole items). Full EriX builds inside EriX and rebuilding Rust/LLVM inside EriX remain required and unperformed.

[Integration #131](https://git.erikinkinen.fi/erix/integration/issues/131) is closed after all six unchanged EXT2/3/4 link and rename scenarios passed on the repaired component graph. The directory regression in [#132](https://git.erikinkinen.fi/erix/integration/issues/132) remains open. [Exsh e2f80172](https://git.erikinkinen.fi/erix/exsh/commit/e2f801723edd363a87a6793f75103f3caaad69a6) now records compiler/tool versions and ELF hashes to help diagnose its frame-analysis timeouts. [Exsh CI534](https://git.erikinkinen.fi/erix/exsh/actions/runs/534) is running; the complete current Integration suite is still queued. Accepted CI coverage remains 74 of 76 current published heads. Checklist progress is 24.28% (560/1019 sub-items; 37/460 whole items). Full EriX builds inside EriX and rebuilding Rust/LLVM inside EriX remain required and unperformed.
Author
Owner

Published Exsh bf9b909e, adding checked forward stack-copy analysis. CI536 is active; the full-frame issue remains open.

Kernel #55 tracks the separate process-exit logging defect found in the unchanged directory scenario. Its focused repair and manual update are being checked. Integration #131 is closed after all six EXT2/3/4 link and rename scenarios passed.

Progress remains 24.28% (560/1019 sub-items; 37/460 whole items). The required full builds and external-toolchain rebuild inside EriX remain unperformed.

Published [Exsh bf9b909e](https://git.erikinkinen.fi/erix/exsh/commit/bf9b909e630c3c8c59e0144f8b361b741933b450), adding checked forward stack-copy analysis. [CI536](https://git.erikinkinen.fi/erix/exsh/actions/runs/536) is active; the full-frame issue remains open. [Kernel #55](https://git.erikinkinen.fi/erix/kernel/issues/55) tracks the separate process-exit logging defect found in the unchanged directory scenario. Its focused repair and manual update are being checked. [Integration #131](https://git.erikinkinen.fi/erix/integration/issues/131) is closed after all six EXT2/3/4 link and rename scenarios passed. Progress remains 24.28% (560/1019 sub-items; 37/460 whole items). The required full builds and external-toolchain rebuild inside EriX remain unperformed.
Author
Owner

Published the matching manual update. Docs CI1639 is running. Its new source reopens only its current-source CI check: progress is temporarily 24.27% (559/1019 sub-items; 37/460 whole items). Completed implementation checks remain accepted. The Kernel repair is still progressing through its native and feature checks, before coherent adoption and the unchanged directory scenario.

Published the matching [manual update](https://git.erikinkinen.fi/erix/docs/commit/4d908342f984d1eec7d3665975862578be487cd9). [Docs CI1639](https://git.erikinkinen.fi/erix/docs/actions/runs/1639) is running. Its new source reopens only its current-source CI check: progress is temporarily 24.27% (559/1019 sub-items; 37/460 whole items). Completed implementation checks remain accepted. The Kernel repair is still progressing through its native and feature checks, before coherent adoption and the unchanged directory scenario.
Author
Owner

Docs 4d908342 now has a complete passing CI1639, restoring its current-source CI checkbox. Progress is 24.28% with 560 of 1,019 sub-items complete.

The kernel logging repair is finishing its feature matrix. Exsh still hits the frame-analysis deadline; Exsh #4 tracks the remaining work.

Docs `4d908342` now has a complete passing [CI1639](https://git.erikinkinen.fi/erix/docs/actions/runs/1639), restoring its current-source CI checkbox. Progress is 24.28% with 560 of 1,019 sub-items complete. The kernel logging repair is finishing its feature matrix. Exsh still hits the frame-analysis deadline; [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) tracks the remaining work.
Author
Owner

Published the kernel logging repair as 68a65a86. Kernel #55 now has its implementation and feature-matrix criteria checked; the unchanged guest regression remains open. Integration catalog adoption is being prepared.

Progress is 24.27%, with 559 of 1,019 sub-items complete. Only the kernel’s current-source CI child reopened for the new commit; completed implementation remains checked. Its CI921 is running.

Published the kernel logging repair as [`68a65a86`](https://git.erikinkinen.fi/erix/kernel/commit/68a65a866a78bc966696939d74592540896dda15). [Kernel #55](https://git.erikinkinen.fi/erix/kernel/issues/55) now has its implementation and feature-matrix criteria checked; the unchanged guest regression remains open. Integration catalog adoption is being prepared. Progress is 24.27%, with 559 of 1,019 sub-items complete. Only the kernel’s current-source CI child reopened for the new commit; completed implementation remains checked. Its [CI921](https://git.erikinkinen.fi/erix/kernel/actions/runs/921) is running.
Author
Owner

Published the Exsh analysis profiler, kernel/manual catalog update and Docs policy correction. The unchanged directory guest is being prepared for Kernel #55.

Progress is 24.27%, with 559 of 1,019 sub-items complete. Only the Docs current-source CI child reopened for its new commit; completed implementation stays checked. The separate manual-builder repair is now in progress.

Published the [Exsh analysis profiler](https://git.erikinkinen.fi/erix/exsh/commit/bd9b9173bb8e1c565c1ca92e2a66a3751df6269d), [kernel/manual catalog update](https://git.erikinkinen.fi/erix/integration/commit/ab6a8d59491c132544490fbd1eda1ba56d6bfbb4) and [Docs policy correction](https://git.erikinkinen.fi/erix/docs/commit/97b58a920ca5fd1f93110f9e8696ebe8d559a11e). The unchanged directory guest is being prepared for [Kernel #55](https://git.erikinkinen.fi/erix/kernel/issues/55). Progress is 24.27%, with 559 of 1,019 sub-items complete. Only the Docs current-source CI child reopened for its new commit; completed implementation stays checked. The separate manual-builder repair is now in progress.
Author
Owner

Completion is 24.28%: 560/1,019 sub-items and 37/460 accepted parents. Docs’ current-source CI item is restored after CI1641; proofs now cover 74 current heads. Exsh’s profiling run and Integration’s full suite remain open. The changed-kernel directory workflow is ready for a new VM observation; its earlier failures remain retained.

Completion is **24.28%**: 560/1,019 sub-items and 37/460 accepted parents. Docs’ current-source CI item is restored after [CI1641](https://git.erikinkinen.fi/erix/docs/actions/runs/1641); proofs now cover 74 current heads. Exsh’s profiling run and Integration’s full suite remain open. The changed-kernel directory workflow is ready for a new VM observation; its earlier failures remain retained.
Author
Owner

Kernel #55 is closed: the unchanged directory scenario passes with intact diagnostics and confirmed cleanup on the updated catalog. Integration #132 remains unresolved.

Exsh’s live profiler now localizes the remaining frame-analysis cost; immutable body preparation and bounded input capture are in progress alongside the manual-builder repair. Completion remains 24.28%, with 560/1,019 sub-items and 37/460 accepted parents; the regression fix adds no separate planning credit.

[Kernel #55](https://git.erikinkinen.fi/erix/kernel/issues/55) is closed: the unchanged directory scenario passes with intact diagnostics and confirmed cleanup on the updated catalog. [Integration #132](https://git.erikinkinen.fi/erix/integration/issues/132) remains unresolved. Exsh’s live profiler now localizes the remaining frame-analysis cost; immutable body preparation and bounded input capture are in progress alongside the manual-builder repair. Completion remains **24.28%**, with 560/1,019 sub-items and 37/460 accepted parents; the regression fix adds no separate planning credit.
Author
Owner

Published Exsh input capture to support the remaining frame-check investigation. In parallel, the manual builder work uncovered output buffering between nested callers: an active TeX pass appeared silent to its parent. That fix is underway. Completion remains 24.28%, with 560/1019 sub-items and 37/460 parents accepted; self-hosting and the external toolchain rebuild are still outstanding.

Published [Exsh input capture](https://git.erikinkinen.fi/erix/exsh/commit/fe35259d57cf82fdb8838b26c8f099ff3bcd4dcf) to support the [remaining frame-check investigation](https://git.erikinkinen.fi/erix/exsh/issues/4). In parallel, the manual builder work uncovered output buffering between nested callers: an active TeX pass appeared silent to its parent. That fix is underway. Completion remains **24.28%**, with **560/1019** sub-items and **37/460** parents accepted; self-hosting and the external toolchain rebuild are still outstanding.
Author
Owner

The command owner now supports bounded live output forwarding in c33ad9c8. Manual builder adoption is underway to prevent active TeX work from appearing stalled.

Exsh #20 is closed: CI 542 produced a complete runtime/dev capture, and the production decoder independently verified all six bodies. Exsh CI still fails all six original frame deadlines; profiling can now use the exact captured disassembly.

Integration #133 tracks the missing metadata catalog in the writable FAT fixtures. Its fix preserves the original provider refusals and guest assertions. A separate diagnostic uses the existing process-exit trace to investigate the status-route failures.

Weighted checklist completion remains 24.28%: 560/1,019 sub-items and 37/460 accepted parents. These regression repairs add no checklist units. Full guest builds and rebuilding Rust/LLVM inside EriX remain unfinished.

The command owner now supports bounded live output forwarding in [`c33ad9c8`](https://git.erikinkinen.fi/erix/integration/commit/c33ad9c8107cbe12a48ed606fe0f37680e73fa3e). Manual builder adoption is underway to prevent active TeX work from appearing stalled. [Exsh #20](https://git.erikinkinen.fi/erix/exsh/issues/20) is closed: CI 542 produced a complete runtime/dev capture, and the production decoder independently verified all six bodies. Exsh CI still fails all six original frame deadlines; profiling can now use the exact captured disassembly. [Integration #133](https://git.erikinkinen.fi/erix/integration/issues/133) tracks the missing metadata catalog in the writable FAT fixtures. Its fix preserves the original provider refusals and guest assertions. A separate diagnostic uses the existing process-exit trace to investigate the status-route failures. Weighted checklist completion remains **24.28%**: 560/1,019 sub-items and 37/460 accepted parents. These regression repairs add no checklist units. Full guest builds and rebuilding Rust/LLVM inside EriX remain unfinished.
Author
Owner

Integration 2d3916ff provisions catalog metadata for the writable FAT CLI fixtures (#133); the two original guests remain the acceptance checks. Docs 0f53e8a5 publishes the explicit manual builder and live bounded output (Docs #16). Exsh #20 is closed after decoding a complete original CI capture; Exsh #4 remains open because all six frame deadlines still fail.

Completion remains 24.28%. These regression repairs add no checklist units.

Integration `2d3916ff` provisions catalog metadata for the writable FAT CLI fixtures ([#133](https://git.erikinkinen.fi/erix/integration/issues/133)); the two original guests remain the acceptance checks. Docs `0f53e8a5` publishes the explicit manual builder and live bounded output ([Docs #16](https://git.erikinkinen.fi/erix/docs/issues/16)). Exsh #20 is closed after decoding a complete original CI capture; [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open because all six frame deadlines still fail. Completion remains **24.28%**. These regression repairs add no checklist units.
Author
Owner

7aa2487f makes the Docs cm-super root explicit and adds selected-input diagnostics. CI now names a missing texfonts.map; Docs #22 stays open while the owning Debian package is added.

The first FAT create run exposed a separate verifier error: it reads raw directory calendar fields instead of the selected catalog timestamps. Integration #134 tracks the strict catalog observer repair and fresh create/truncate acceptance. The failed run remains recorded.

Exsh CI 544 still reaches all six frame deadlines; Exsh #4 remains open. Current Integration CI 2708 has passed Rust and Markdown and is still running the VM matrix. Checklist progress remains 24.28% (37 accepted parents; 560 completed sub-items).

`7aa2487f` makes the Docs cm-super root explicit and adds selected-input diagnostics. CI now names a missing `texfonts.map`; [Docs #22](https://git.erikinkinen.fi/erix/docs/issues/22) stays open while the owning Debian package is added. The first FAT create run exposed a separate verifier error: it reads raw directory calendar fields instead of the selected catalog timestamps. [Integration #134](https://git.erikinkinen.fi/erix/integration/issues/134) tracks the strict catalog observer repair and fresh create/truncate acceptance. The failed run remains recorded. Exsh CI 544 still reaches all six frame deadlines; [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. Current Integration CI 2708 has passed Rust and Markdown and is still running the VM matrix. Checklist progress remains 24.28% (37 accepted parents; 560 completed sub-items).
Author
Owner

Published the FAT catalog observer (f0da4ac0, #134) and clean Launchd resolver rejection handling (5d8cddb0, Launchd #20). Fresh FAT create/truncate guests and selection of the updated Launchd remain open.

Docs now installs the explicit provider of texfonts.map (24e8dd48, Docs #22); its strict render is running. Exsh’s measured operand parsing change passes all 919 checker tests and is finishing source checks before publication. The frame checker issue remains open.

Checklist progress is still 24.28%. These regression repairs do not add planning units.

Published the FAT catalog observer (`f0da4ac0`, [#134](https://git.erikinkinen.fi/erix/integration/issues/134)) and clean Launchd resolver rejection handling (`5d8cddb0`, [Launchd #20](https://git.erikinkinen.fi/erix/launchd/issues/20)). Fresh FAT create/truncate guests and selection of the updated Launchd remain open. Docs now installs the explicit provider of `texfonts.map` (`24e8dd48`, [Docs #22](https://git.erikinkinen.fi/erix/docs/issues/22)); its strict render is running. Exsh’s measured operand parsing change passes all 919 checker tests and is finishing source checks before publication. [The frame checker issue](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. Checklist progress is still 24.28%. These regression repairs do not add planning units.
Author
Owner

Exsh’s operand parsing optimization is published as 893dd9c8; all 919 checker tests pass. The frame proof remains open, and CI 546 is running.

Launchd #20 is closed after CI 398 passed on the published repair. Docs CI 1647 now gets through preparation into TeX, where Debian’s older runtime requires an additional declared input; Docs #22 stays open.

Fresh FAT guests for #133 and #134 are being prepared within the existing storage budget. Completed caches are being removed while failed media and retained evidence are preserved. Recalculated checklist progress remains 24.28%: 37 accepted parents and 560 completed sub-items.

Exsh’s operand parsing optimization is published as `893dd9c8`; all 919 checker tests pass. [The frame proof](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open, and CI 546 is running. [Launchd #20](https://git.erikinkinen.fi/erix/launchd/issues/20) is closed after CI 398 passed on the published repair. Docs CI 1647 now gets through preparation into TeX, where Debian’s older runtime requires an additional declared input; [Docs #22](https://git.erikinkinen.fi/erix/docs/issues/22) stays open. Fresh FAT guests for [#133](https://git.erikinkinen.fi/erix/integration/issues/133) and [#134](https://git.erikinkinen.fi/erix/integration/issues/134) are being prepared within the existing storage budget. Completed caches are being removed while failed media and retained evidence are preserved. Recalculated checklist progress remains 24.28%: 37 accepted parents and 560 completed sub-items.
Author
Owner

Docs #22 now has its two missing kernel compatibility inputs declared in 1fabae51; all 170 unit tests pass. The next Debian render remains pending.

Selected cache cleanup has finished, and the fresh FAT create guest is being prepared within the existing storage limits. Failed media and retained evidence remain protected. Checklist progress is unchanged at 24.28%, with 37 accepted parents and 560 completed sub-items.

[Docs #22](https://git.erikinkinen.fi/erix/docs/issues/22) now has its two missing kernel compatibility inputs declared in `1fabae51`; all 170 unit tests pass. The next Debian render remains pending. Selected cache cleanup has finished, and the fresh FAT create guest is being prepared within the existing storage limits. Failed media and retained evidence remain protected. Checklist progress is unchanged at 24.28%, with 37 accepted parents and 560 completed sub-items.
Author
Owner

The fresh FAT create guest passes on f0da4ac0, with the original payload and strict persisted timestamp checks. Truncate remains open in #133 and #134.

Exsh #4 still blocks its CI: all six frame analyses reach their original deadline. The new returned-cell analysis remains under review. Docs publisher adoption passes its 244 tests, including six isolated loopback TLS cases; source checks continue. Checklist progress remains 24.28%.

The fresh FAT create guest passes on `f0da4ac0`, with the original payload and strict persisted timestamp checks. Truncate remains open in [#133](https://git.erikinkinen.fi/erix/integration/issues/133) and [#134](https://git.erikinkinen.fi/erix/integration/issues/134). [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) still blocks its CI: all six frame analyses reach their original deadline. The new returned-cell analysis remains under review. Docs publisher adoption passes its 244 tests, including six isolated loopback TLS cases; source checks continue. Checklist progress remains 24.28%.
Author
Owner

The Debian manual runtime regression Docs#22 is resolved by the original successful CI1649. The new bounded publisher builds the manual but fails during publication; Docs#23 tracks the repair.

Completion is 24.27%, with 559/1019 sub-items and 37/460 parents accepted. Only the Docs current-CI checkbox reopened for its new signed source; implementation completion is unchanged. FAT create passes; truncate remains pending after preserving retained evidence and removing verified working duplicates.

The Debian manual runtime regression [Docs#22](https://git.erikinkinen.fi/erix/docs/issues/22) is resolved by the original successful CI1649. The new bounded publisher builds the manual but fails during publication; [Docs#23](https://git.erikinkinen.fi/erix/docs/issues/23) tracks the repair. Completion is 24.27%, with 559/1019 sub-items and 37/460 parents accepted. Only the Docs current-CI checkbox reopened for its new signed source; implementation completion is unchanged. FAT create passes; truncate remains pending after preserving retained evidence and removing verified working duplicates.
Author
Owner

The original FAT create and truncate guests now pass on f0da4ac0, including the strict persisted payload, catalog identity and timestamp checks. Integration#133 and #134 are resolved. This closes regressions and adds no duplicate checklist credit.

Docs 50f2266f repairs explicit job-token selection; Docs#23 awaits its original CI result. Completion remains 24.27% (559/1019 sub-items, 37/460 parents).

The original FAT create and truncate guests now pass on `f0da4ac0`, including the strict persisted payload, catalog identity and timestamp checks. [Integration#133](https://git.erikinkinen.fi/erix/integration/issues/133) and [#134](https://git.erikinkinen.fi/erix/integration/issues/134) are resolved. This closes regressions and adds no duplicate checklist credit. Docs `50f2266f` repairs explicit job-token selection; [Docs#23](https://git.erikinkinen.fi/erix/docs/issues/23) awaits its original CI result. Completion remains 24.27% (559/1019 sub-items, 37/460 parents).
Author
Owner

Integration ede995b7 adopts the published Launchd resolver failure handling in both maintained catalogs. The selected component graph and fresh exit-status/redirection guests remain to be checked. This does not yet establish the cause of the earlier native launch failures.

[Integration `ede995b7`](https://git.erikinkinen.fi/erix/integration/commit/ede995b73ee90d67d48a0382e5c04ad9805998da) adopts the published Launchd resolver failure handling in both maintained catalogs. The selected component graph and fresh exit-status/redirection guests remain to be checked. This does not yet establish the cause of the earlier native launch failures.
Author
Owner

The Docs publication repair is pushed. Docs #23 now has the URL-binding and diagnostic implementation criteria checked; the original CI publication job remains its final gate. Weighted completion remains 24.27% (37/460 parent items; 559/1019 sub-items).

The [Docs publication repair](https://git.erikinkinen.fi/erix/docs/commit/035c33927faf85223c85d0df788b62be2ecc531c) is pushed. [Docs #23](https://git.erikinkinen.fi/erix/docs/issues/23) now has the URL-binding and diagnostic implementation criteria checked; the original CI publication job remains its final gate. Weighted completion remains 24.27% (37/460 parent items; 559/1019 sub-items).
Author
Owner

The current Docs head 035c3392 passes CI1655, including the complete manual build and publication. Docs #23 is closed; PR #4 contains the repair. The checklist now records 560/1019 sub-items and 24.28% weighted progress, with 37/460 parent items accepted.

The current Docs head `035c3392` passes CI1655, including the complete manual build and publication. [Docs #23](https://git.erikinkinen.fi/erix/docs/issues/23) is closed; [PR #4](https://git.erikinkinen.fi/erix/docs/pulls/4) contains the repair. The checklist now records 560/1019 sub-items and 24.28% weighted progress, with 37/460 parent items accepted.
Author
Owner

Exsh 688de047 now derives numeric bounds from definitely written callee-returned stack bytes and shares immutable body preparation. Complete frame acceptance remains open in Exsh #4; the captured graph still reaches its original deadline. Further profiling and dependency batching are in progress.

Checklist completion remains 24.28%. This checkpoint adds no acceptance credit.

Exsh [688de047](https://git.erikinkinen.fi/erix/exsh/commit/688de0477d297222521072a766ef40d344da3d6c) now derives numeric bounds from definitely written callee-returned stack bytes and shares immutable body preparation. Complete frame acceptance remains open in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4); the captured graph still reaches its original deadline. Further profiling and dependency batching are in progress. Checklist completion remains 24.28%. This checkpoint adds no acceptance credit.
Author
Owner

Exsh 97b47b0a adds dependency batching, immutable contents reuse and more focused profiler rows. Its original frame deadline still fails; frame acceptance remains open.

A fresh native exit-status guest with the published Launchd fix builds and packages, then reports command not executable. #135 tracks the unresolved cause. The failed image and inputs are retained; focused resolver diagnostics are next.

Current CI is green for 74 repositories. Exsh CI550 has passed Markdown and is running Rust; Integration CI2714 has passed its host jobs and is running VM cases. Completion remains 24.28%, with 560/1019 sub-items and 37/460 parents accepted. Full EriX and Rust/LLVM rebuilds inside EriX remain unperformed.

Exsh [97b47b0a](https://git.erikinkinen.fi/erix/exsh/commit/97b47b0af60d1c60662dc6b05169eb7b6699672a) adds dependency batching, immutable contents reuse and more focused profiler rows. Its original frame deadline still fails; [frame acceptance](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. A fresh native exit-status guest with the published Launchd fix builds and packages, then reports `command not executable`. [#135](https://git.erikinkinen.fi/erix/integration/issues/135) tracks the unresolved cause. The failed image and inputs are retained; focused resolver diagnostics are next. Current CI is green for 74 repositories. Exsh CI550 has passed Markdown and is running Rust; Integration CI2714 has passed its host jobs and is running VM cases. Completion remains **24.28%**, with 560/1019 sub-items and 37/460 parents accepted. Full EriX and Rust/LLVM rebuilds inside EriX remain unperformed.
Author
Owner

Published Launchd dcbb1cc8 with seven fixed resolver diagnostic tags, and Exsh a65f1264 with checked saved-register state reuse.

Launchd CI400 passes. Exsh CI552 is running, and its original graph deadline remains unresolved. Integration CI2714 finishes 491 passed / 34 failed / 525 VM cases; its failure groups are being reviewed. The native launch failure still needs an explicit traced diagnostic. Catalog adoption and the next Exsh optimization are proceeding in parallel.

Completion is 24.28%, with 560/1019 sub-items and 37/460 parents accepted. Launchd's current-source CI item is restored after CI400; this adds no planning credit. Full EriX builds and Rust/LLVM rebuilds inside EriX remain unperformed.

Published Launchd [dcbb1cc8](https://git.erikinkinen.fi/erix/launchd/commit/dcbb1cc8b8be9540867cf1dab6fc1e1b70388fca) with seven fixed resolver diagnostic tags, and Exsh [a65f1264](https://git.erikinkinen.fi/erix/exsh/commit/a65f1264b88eed4f67097e14e8737fe93390d795) with checked saved-register state reuse. Launchd CI400 passes. Exsh CI552 is running, and its original graph deadline remains unresolved. Integration CI2714 finishes **491 passed / 34 failed / 525 VM cases**; its failure groups are being reviewed. The [native launch failure](https://git.erikinkinen.fi/erix/integration/issues/135) still needs an explicit traced diagnostic. Catalog adoption and the next Exsh optimization are proceeding in parallel. Completion is **24.28%**, with **560/1019 sub-items** and **37/460 parents** accepted. Launchd's current-source CI item is restored after CI400; this adds no planning credit. Full EriX builds and Rust/LLVM rebuilds inside EriX remain unperformed.
Author
Owner

Published Exsh c0763ff4 for shared instruction decoding and Integration 7bdb0ca2 for Launchd diagnostics. Their current CIs are running. The original frame-analysis deadline and native exit-status failure remain open.

Completion remains 24.28%: 560/1,019 sub-items and 37/460 accepted parent items. These repairs add no planning units. The next work is the profiler refactor and the traced guest investigation. Full builds and toolchain rebuilds inside EriX remain unperformed.

Published Exsh `c0763ff4` for shared instruction decoding and Integration `7bdb0ca2` for Launchd diagnostics. Their current CIs are running. The original frame-analysis deadline and native exit-status failure remain open. Completion remains **24.28%**: **560/1,019** sub-items and **37/460** accepted parent items. These repairs add no planning units. The next work is the profiler refactor and the traced guest investigation. Full builds and toolchain rebuilds inside EriX remain unperformed.
Author
Owner

Exsh now decodes immutable instruction operands lazily and spends less time dispatching profiler callbacks. The frame-check deadline remains unresolved in Exsh #4: the latest CI still exceeds the existing 60-second limit. An opt-in diagnostic to identify the active function is being checked next.

Integration now selects Launchd’s reply-path diagnostic in both component catalogs. The next traced VM run will investigate the missing executable result tracked in Integration #135.

Checklist progress remains 24.28%. These repairs add no completion credit. The full EriX build inside EriX, boot-and-repeat demonstration, and rebuilding Rust/LLVM inside EriX remain outstanding.

Exsh now decodes immutable instruction operands lazily and spends less time dispatching profiler callbacks. The frame-check deadline remains unresolved in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4): the latest CI still exceeds the existing 60-second limit. An opt-in diagnostic to identify the active function is being checked next. Integration now selects Launchd’s reply-path diagnostic in both component catalogs. The next traced VM run will investigate the missing executable result tracked in [Integration #135](https://git.erikinkinen.fi/erix/integration/issues/135). Checklist progress remains **24.28%**. These repairs add no completion credit. The full EriX build inside EriX, boot-and-repeat demonstration, and rebuilding Rust/LLVM inside EriX remain outstanding.
Author
Owner

Signed Exsh commit 7168ee34 adds an explicit eight-phase profiler mode. The original frame deadline still expires; Exsh #4 remains open. The independent cleanup defect now has its own report and fix in progress.

The traced exit-status guest still cannot launch its command. The next change preserves the typed rejection through the existing stderr path. Weighted completion remains 24.28%; these repairs do not close another phase requirement. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.

Signed Exsh commit `7168ee34` adds an explicit eight-phase profiler mode. The original frame deadline still expires; [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. The independent cleanup defect now has its own [report](https://git.erikinkinen.fi/erix/exsh/issues/21) and fix in progress. The traced [exit-status guest](https://git.erikinkinen.fi/erix/integration/issues/135) still cannot launch its command. The next change preserves the typed rejection through the existing stderr path. Weighted completion remains **24.28%**; these repairs do not close another phase requirement. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.
Author
Owner

The cleanup correction is signed in Exsh 682740c3; Exsh #21 tracks the remaining current-CI check. The next profiler optimization reuses fully equal immutable state components and is being checked against that published correction.

Integration’s complete current CI finishes 493 passes, 32 failures, 525 total. Its distinct failures remain under investigation; the traced launch diagnostic is not yet a demonstrated fix. Weighted phase completion remains 24.28%.

The cleanup correction is signed in Exsh `682740c3`; [Exsh #21](https://git.erikinkinen.fi/erix/exsh/issues/21) tracks the remaining current-CI check. The next profiler optimization reuses fully equal immutable state components and is being checked against that published correction. Integration’s complete current CI finishes **493 passes, 32 failures, 525 total**. Its distinct failures remain under investigation; the traced launch diagnostic is not yet a demonstrated fix. Weighted phase completion remains **24.28%**.
Author
Owner

Published ordinary command rejection diagnostics and analysis reuse, with the corresponding manual update. Integration's existing physical/COM1 probe is being extended to check the typed cause and status 126. The genuine guest result remains pending in the launch failure issue.

The fixed join workload improves by 25.7%, but the complete frame still exceeds its deadline; the frame issue stays open. Weighted checklist progress remains 24.28%, with 37 parent items and 560 sub-items accepted. These changes do not yet satisfy another acceptance item.

Published [ordinary command rejection diagnostics and analysis reuse](https://git.erikinkinen.fi/erix/exsh/commit/835dcea2d6b55ce75599f1947c07378a2da9487c), with the corresponding [manual update](https://git.erikinkinen.fi/erix/docs/commit/2cce0e0a1e4093690843454a2f5914cdb91cc2f8). Integration's existing physical/COM1 probe is being extended to check the typed cause and status 126. The genuine guest result remains pending in [the launch failure issue](https://git.erikinkinen.fi/erix/integration/issues/135). The fixed join workload improves by 25.7%, but the complete frame still exceeds its deadline; [the frame issue](https://git.erikinkinen.fi/erix/exsh/issues/4) stays open. Weighted checklist progress remains 24.28%, with 37 parent items and 560 sub-items accepted. These changes do not yet satisfy another acceptance item.
Author
Owner

Published the native command-rejection probe and component pins. The physical and COM1 probes require a fresh typed cause and status 126 for a directory invocation. A genuine run remains pending in the launch failure issue.

Docs CI passes on the new manual revision. Exsh's new CI passes its Rust and Python suites, then all six frame checks exceed their original deadline; the frame issue remains open. The next profiler change will measure work discarded during context dependency discovery. Checklist progress remains 24.28%; no acceptance state has changed.

Published the [native command-rejection probe and component pins](https://git.erikinkinen.fi/erix/integration/commit/64251db82ef8150ada5515feccab92354df2b3b8). The physical and COM1 probes require a fresh typed cause and status 126 for a directory invocation. A genuine run remains pending in [the launch failure issue](https://git.erikinkinen.fi/erix/integration/issues/135). Docs CI passes on the new manual revision. Exsh's new CI passes its Rust and Python suites, then all six frame checks exceed their original deadline; [the frame issue](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. The next profiler change will measure work discarded during context dependency discovery. Checklist progress remains 24.28%; no acceptance state has changed.
Author
Owner

The shell profiler now distinguishes discarded dependency passes from completed and open passes. In the retained historical input, discarded completed passes account for 37.65% of direct grammar visits in completed contextual passes; this is a work count, not a speedup. The full frame analysis still reaches its deadline.

The native rejection probe also exposed a final-wrapper mismatch, tracked in #136. Its fix shares one strict event ledger between the live driver and final verifier. The actual final-verifier controls pass; genuine guest results are still pending. Checklist completion remains 24.28%.

The shell profiler now distinguishes discarded dependency passes from completed and open passes. In the retained historical input, discarded completed passes account for 37.65% of direct grammar visits in completed contextual passes; this is a work count, not a speedup. The full frame analysis still reaches its deadline. The native rejection probe also exposed a final-wrapper mismatch, tracked in #136. Its fix shares one strict event ledger between the live driver and final verifier. The actual final-verifier controls pass; genuine guest results are still pending. Checklist completion remains 24.28%.
Author
Owner

The final runtime-error verifier fix is published in 36d565b3 and tracked in #136. It shares the live probe’s strict event contract and schedules both development guest routes. Host controls pass; genuine guest execution remains open.

The full Python suite is running with fresh module interpreters to prevent host thread signal handlers from contaminating later process-owner tests. Profiler implementation and preparation of the next native guest build continue in parallel. Checklist completion remains 24.28%.

The final runtime-error verifier fix is published in `36d565b3` and tracked in #136. It shares the live probe’s strict event contract and schedules both development guest routes. Host controls pass; genuine guest execution remains open. The full Python suite is running with fresh module interpreters to prevent host thread signal handlers from contaminating later process-owner tests. Profiler implementation and preparation of the next native guest build continue in parallel. Checklist completion remains 24.28%.
Author
Owner

The shared Python runner is published in 94a19951 and tracked in #137. All 146 modules and 1,663 tests pass; the implementation replaces 91 separate CI calls and preserves strict native process admission.

This completes the existing Integration host-check item. Weighted checklist progress is now 24.29%, with 561/1019 sub-items complete and 37/460 parents accepted. Published-source CI, genuine VM checks and the full builds inside EriX remain open.

The shared Python runner is published in `94a19951` and tracked in #137. All 146 modules and 1,663 tests pass; the implementation replaces 91 separate CI calls and preserves strict native process admission. This completes the existing Integration host-check item. Weighted checklist progress is now **24.29%**, with **561/1019 sub-items** complete and **37/460 parents** accepted. Published-source CI, genuine VM checks and the full builds inside EriX remain open.
Author
Owner

Exsh 997673f6 now defers unused report assembly while preserving the existing checks and complete ready reports. The fixed comparison preserves behavior but does not establish a repeatable speedup. The full-graph check still reaches its original 60-second limit.

The next native fixture build exposed a missing optional selector default. Its fix passes the focused regressions and is completing broader checks. The original build stopped before packaging or guest execution.

Completion remains 24.29%, with 561 sub-items complete and 37 accepted parent items. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.

Exsh `997673f6` now defers unused report assembly while preserving the existing checks and complete ready reports. The fixed comparison preserves behavior but does not establish a repeatable speedup. [The full-graph check](https://git.erikinkinen.fi/erix/exsh/issues/4) still reaches its original 60-second limit. The next native fixture build exposed [a missing optional selector default](https://git.erikinkinen.fi/erix/integration/issues/138). Its fix passes the focused regressions and is completing broader checks. The original build stopped before packaging or guest execution. Completion remains **24.29%**, with **561 sub-items complete** and **37 accepted parent items**. The full EriX and external-toolchain rebuilds inside EriX remain outstanding.
Author
Owner

Integration b7b17f96 fixes the missing direct-build selector default, preserving explicit selections and their validation. All 1,669 Python tests pass while the next native build is prepared; the original failed build remains retained.

The existing library cache passes its original integrity gates, allowing the next build to reuse those measured outputs. No guest boot or full build inside EriX has passed. Completion remains 24.29%; these repairs add no checklist units.

Integration `b7b17f96` fixes [the missing direct-build selector default](https://git.erikinkinen.fi/erix/integration/issues/138), preserving explicit selections and their validation. All 1,669 Python tests pass while the next native build is prepared; the original failed build remains retained. The existing library cache passes its original integrity gates, allowing the next build to reuse those measured outputs. No guest boot or full build inside EriX has passed. Completion remains **24.29%**; these repairs add no checklist units.
Author
Owner

The direct native build now passes with the optional binding unset, closing #138. 0e93075a also fixes the explicit CI environment for Debian filesystem tools; #139 remains open until the full workflow reaches VM execution.

Exsh #4 still blocks green CI: all six frame targets expire at 60 seconds after the unit suites pass. The next work is targeted profiling and a fresh packaged guest run. Completion remains 24.29%; the full build and toolchain rebuild inside EriX have not been demonstrated.

The direct native build now passes with the optional binding unset, closing [#138](https://git.erikinkinen.fi/erix/integration/issues/138). `0e93075a` also fixes the explicit CI environment for Debian filesystem tools; [#139](https://git.erikinkinen.fi/erix/integration/issues/139) remains open until the full workflow reaches VM execution. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) still blocks green CI: all six frame targets expire at 60 seconds after the unit suites pass. The next work is targeted profiling and a fresh packaged guest run. Completion remains 24.29%; the full build and toolchain rebuild inside EriX have not been demonstrated.
Author
Owner

9e9d708f fixes the long-temporary-path fixtures in #140; the full changed suite is still running. The filesystem-tool fix in #139 is awaiting its CI scenario result.

Docs 49df60b adds the module-isolation contract to the manual and now has green CI. The next packaged guest run is being prepared from the current executor. Exsh #4 remains open; a narrower profiler has retained transfer and merge observations for the next correction.

Completion remains 24.29%. The Cargo dependency requirement above now reflects the requested main tracking with CI branch overrides; repository policy alignment remains pending.

`9e9d708f` fixes the long-temporary-path fixtures in [#140](https://git.erikinkinen.fi/erix/integration/issues/140); the full changed suite is still running. The filesystem-tool fix in [#139](https://git.erikinkinen.fi/erix/integration/issues/139) is awaiting its CI scenario result. Docs `49df60b` adds the module-isolation contract to the manual and now has green CI. The next packaged guest run is being prepared from the current executor. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open; a narrower profiler has retained transfer and merge observations for the next correction. Completion remains 24.29%. The Cargo dependency requirement above now reflects the requested `main` tracking with CI branch overrides; repository policy alignment remains pending.
Author
Owner

Closed the filesystem-tool lookup defect: CI 2732 passes all 1,670 Python tests and reaches VM scenarios. The long temporary-path fixture repair also passes the full updated 1,671-test suite.

Guest failures remain. The current selector-race observation is recorded on #64, and the recurring extop serial stall now has its own report. A fresh nested-script attempt reaches QEMU but still stalls; its typed launch rejection led to a resolver-search fix under review. Overall checklist progress remains 24.29%; these regression repairs add no completion units.

Closed [the filesystem-tool lookup defect](https://git.erikinkinen.fi/erix/integration/issues/139): CI 2732 passes all 1,670 Python tests and reaches VM scenarios. The [long temporary-path fixture repair](https://git.erikinkinen.fi/erix/integration/issues/140) also passes the full updated 1,671-test suite. Guest failures remain. The current selector-race observation is recorded on [#64](https://git.erikinkinen.fi/erix/integration/issues/64), and the recurring extop serial stall now has [its own report](https://git.erikinkinen.fi/erix/integration/issues/141). A fresh nested-script attempt reaches QEMU but still stalls; its typed launch rejection led to [a resolver-search fix under review](https://git.erikinkinen.fi/erix/launchd/issues/21). Overall checklist progress remains 24.29%; these regression repairs add no completion units.
Author
Owner

The Cargo branch-policy migration is tracked in #142. Manifests will follow main, while CI selects and freezes matching feature branches. Integration catalogs continue to select exact commits. The migration includes source identity checks, lock handling, CI consumers and shared documentation.

The Cargo branch-policy migration is tracked in [#142](https://git.erikinkinen.fi/erix/integration/issues/142). Manifests will follow main, while CI selects and freezes matching feature branches. Integration catalogs continue to select exact commits. The migration includes source identity checks, lock handling, CI consumers and shared documentation.
Author
Owner

Pushed the resolver repair. Launchd #21 now has its first two criteria checked, and CI402 is green. The original nested-script guest remains pending against the repaired runtime. The latest full repository snapshot has 74 passing CIs, Exsh failing and Integration still running its VM matrix.

The narrower shell retirement optimization is also being withheld: mixed wall time differs by only 0.55%, four of six paired rounds are slower, and one small caller case regresses 10.49%. Its tests and source checks pass, but that does not establish a useful whole-workload improvement. A separate loop implementation is being investigated.

Dependency-policy work now has isolated declaration, branch-selection and object-file tests ready to run while implementation continues. Source verification is being changed to exclude local Git configuration, implicit object stores and index flags.

Checklist progress remains 24.29%; this repair does not close another phase requirement. The full in-EriX build and toolchain rebuild demonstrations remain outstanding.

Pushed the [resolver repair](https://git.erikinkinen.fi/erix/launchd/commit/25efde7aab9ddd6b1bc324ee7a2c3ed1a2fe2d8e). [Launchd #21](https://git.erikinkinen.fi/erix/launchd/issues/21) now has its first two criteria checked, and CI402 is green. The original nested-script guest remains pending against the repaired runtime. The latest full repository snapshot has 74 passing CIs, Exsh failing and Integration still running its VM matrix. The narrower [shell retirement optimization](https://git.erikinkinen.fi/erix/exsh/issues/4) is also being withheld: mixed wall time differs by only 0.55%, four of six paired rounds are slower, and one small caller case regresses 10.49%. Its tests and source checks pass, but that does not establish a useful whole-workload improvement. A separate loop implementation is being investigated. [Dependency-policy work](https://git.erikinkinen.fi/erix/integration/issues/142) now has isolated declaration, branch-selection and object-file tests ready to run while implementation continues. Source verification is being changed to exclude local Git configuration, implicit object stores and index flags. Checklist progress remains 24.29%; this repair does not close another phase requirement. The full in-EriX build and toolchain rebuild demonstrations remain outstanding.
Author
Owner

179801c selects the Launchd resolver search and cleanup repair in both runtime catalogs. The nested-script guest still needs confirmation.

Exsh fba2402 removes per-cell generators from stack retirement. All twelve direct cases improved, while the mixed body workload showed no overall speedup. The frame timeout remains open.

The complete host run exposed five more socket fixtures that fail under a long temporary root. #143 tracks their shared repair; the native-permission fix remains effective.

Progress remains 24.29% weighted, with 11.52% whole-item acceptance. The full in-EriX build and Rust/LLVM rebuild demonstrations remain unperformed.

[179801c](https://git.erikinkinen.fi/erix/integration/commit/179801c0e927c3fbf6ee386df2bd87348d7b58c8) selects the Launchd resolver search and cleanup repair in both runtime catalogs. The nested-script guest still needs confirmation. [Exsh fba2402](https://git.erikinkinen.fi/erix/exsh/commit/fba240218d70f0738beccc7c9dfbb7cac6330d4b) removes per-cell generators from stack retirement. All twelve direct cases improved, while the mixed body workload showed no overall speedup. [The frame timeout](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. The complete host run exposed five more socket fixtures that fail under a long temporary root. [#143](https://git.erikinkinen.fi/erix/integration/issues/143) tracks their shared repair; the native-permission fix remains effective. Progress remains 24.29% weighted, with 11.52% whole-item acceptance. The full in-EriX build and Rust/LLVM rebuild demonstrations remain unperformed.
Author
Owner

Two host regressions are fixed: Exsh #22 in f3e0db3, and Integration #143 in b950621d. Both issue checklists are complete. Their full Python suites pass: 1,098 Exsh tests and 1,674 Integration tests.

At 17:06 UTC, Exsh CI 572 was running and Integration CI 2741 was waiting. The earlier Integration VM run was still active.

Phase 6 remains at 24.29%. Fresh image artifacts are being prepared for the next guest run with the selected Launchd resolver fix. The full EriX build inside EriX and the Rust/LLVM rebuild demonstrations remain pending.

Two host regressions are fixed: [Exsh #22](https://git.erikinkinen.fi/erix/exsh/issues/22) in [f3e0db3](https://git.erikinkinen.fi/erix/exsh/commit/f3e0db357a3bc432e35d5408be4b4d3dd3910e63), and [Integration #143](https://git.erikinkinen.fi/erix/integration/issues/143) in [b950621d](https://git.erikinkinen.fi/erix/integration/commit/b950621d428ca39ded2443678738b3a6d7462c27). Both issue checklists are complete. Their full Python suites pass: 1,098 Exsh tests and 1,674 Integration tests. At 17:06 UTC, [Exsh CI 572](https://git.erikinkinen.fi/erix/exsh/actions/runs/572) was running and [Integration CI 2741](https://git.erikinkinen.fi/erix/integration/actions/runs/2741) was waiting. The earlier Integration VM run was still active. Phase 6 remains at 24.29%. Fresh image artifacts are being prepared for the next guest run with the selected Launchd resolver fix. The full EriX build inside EriX and the Rust/LLVM rebuild demonstrations remain pending.
Author
Owner

The host build with the Launchd resolver fixes now completes without warnings. Packaging and the guest check for Launchd #21 are next; the full build inside EriX and native Rust/LLVM rebuild remain outstanding.

The Cargo branch-policy work now resolves original Git objects and submodules through real offline lockfile generation and locked metadata. The CI command and repository-wide migration are still in progress.

Exsh #4 remains open. Profiling is using the failing run’s actual captured inputs; no frame-analysis fix is claimed yet.

The host build with the Launchd resolver fixes now completes without warnings. Packaging and the guest check for [Launchd #21](https://git.erikinkinen.fi/erix/launchd/issues/21) are next; the full build inside EriX and native Rust/LLVM rebuild remain outstanding. The [Cargo branch-policy work](https://git.erikinkinen.fi/erix/integration/issues/142) now resolves original Git objects and submodules through real offline lockfile generation and locked metadata. The CI command and repository-wide migration are still in progress. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. Profiling is using the failing run’s actual captured inputs; no frame-analysis fix is claimed yet.
Author
Owner

The original nested-script exit-status guest now passes with the published Launchd resolver-slot repair, preserving its script, grants and time limits. Independent source and ELF checks confirm the selected Launchd in the package. Related launch/status failures remain open.

The run exposed stale component revision metadata in workspace packages; its fix is underway. The full build inside EriX and native Rust/LLVM rebuild remain pending. Checklist progress is unchanged at 24.29%; these regression fixes earn no additional planning units.

The original nested-script exit-status guest now passes with the published [Launchd resolver-slot repair](https://git.erikinkinen.fi/erix/launchd/issues/21), preserving its script, grants and time limits. Independent source and ELF checks confirm the selected Launchd in the package. [Related launch/status failures](https://git.erikinkinen.fi/erix/integration/issues/135) remain open. The run exposed [stale component revision metadata in workspace packages](https://git.erikinkinen.fi/erix/integration/issues/144); its fix is underway. The full build inside EriX and native Rust/LLVM rebuild remain pending. Checklist progress is unchanged at 24.29%; these regression fixes earn no additional planning units.
Author
Owner

Published the appliance receipt fix and physical command delivery checks in PR 12, tracked by #144 and #145. The manual update and original physical guest cases remain open. Full builds inside EriX and the native Rust/LLVM rebuild have not been demonstrated.

Published the [appliance receipt fix](https://git.erikinkinen.fi/erix/integration/commit/443288573aff8cc378b581ab1bb186bb34b74144) and [physical command delivery checks](https://git.erikinkinen.fi/erix/integration/commit/5c28ab2d1137cc71a6e1de8b125360026eafd599) in [PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12), tracked by [#144](https://git.erikinkinen.fi/erix/integration/issues/144) and [#145](https://git.erikinkinen.fi/erix/integration/issues/145). The manual update and original physical guest cases remain open. Full builds inside EriX and the native Rust/LLVM rebuild have not been demonstrated.
Author
Owner

Published the operational manual update in Docs 8e2af9b9 and its source-size metadata in Integration d324d475. #144 is closed. The two original guest regressions in #145 remain open.

The Cargo migration found a missing transport path for Git submodules; that fix is in progress. The latest Exsh performance candidate was set aside because it did not establish a meaningful overall gain.

Completion remains 24.29% weighted, with 37/460 parents and 561/1019 sub-items accepted. These regression repairs add no phase credit. Full builds inside EriX and the native Rust/LLVM rebuild remain unperformed.

Published the operational manual update in [Docs 8e2af9b9](https://git.erikinkinen.fi/erix/docs/commit/8e2af9b913a06c31c108e4da6e8654ab90b6d52f) and its source-size metadata in [Integration d324d475](https://git.erikinkinen.fi/erix/integration/commit/d324d4750227f858799ad1b0ec9d9d9e876e2edd). [#144](https://git.erikinkinen.fi/erix/integration/issues/144) is closed. The two original guest regressions in [#145](https://git.erikinkinen.fi/erix/integration/issues/145) remain open. The [Cargo migration](https://git.erikinkinen.fi/erix/integration/issues/142) found a missing transport path for Git submodules; that fix is in progress. The latest [Exsh performance candidate](https://git.erikinkinen.fi/erix/exsh/issues/4) was set aside because it did not establish a meaningful overall gain. Completion remains **24.29%** weighted, with **37/460** parents and **561/1019** sub-items accepted. These regression repairs add no phase credit. Full builds inside EriX and the native Rust/LLVM rebuild remain unperformed.
Author
Owner

The original physical launch-handle scenario now passes through the normal host-driven build, signing, disk-image and guest path. Live cat input and one physical Ctrl+C reach the required status and authority checks. The character-loss issue remains open for the original replay scenario and the loss-layer diagnosis.

The Cargo main migration now has 39 passing consumer/catalog checks; the fleet rollout and maintained locks are still pending. A full build inside EriX, followed by rebuilding the external toolchain there, remains required.

The original physical launch-handle scenario now passes through the normal host-driven build, signing, disk-image and guest path. Live cat input and one physical Ctrl+C reach the required status and authority checks. [The character-loss issue](https://git.erikinkinen.fi/erix/integration/issues/145#issuecomment-22296) remains open for the original replay scenario and the loss-layer diagnosis. The [Cargo main migration](https://git.erikinkinen.fi/erix/integration/issues/142#issuecomment-22295) now has 39 passing consumer/catalog checks; the fleet rollout and maintained locks are still pending. A full build inside EriX, followed by rebuilding the external toolchain there, remains required.
Author
Owner

Published the coordinated dependency migration across all 76 repositories: Cargo declarations track main, CI resolves explicit feature branches, and catalogs retain exact commits. Both maintained lockfiles were generated by Cargo. #142 tracks the remaining CI acceptance.

Also fixed the disabled-program override error in #146; guest confirmation is still open. Phase completion remains 24.29%, with 37 of 460 parent items accepted and 561 of 1,019 sub-items complete. These regression repairs add no phase checklist credit. Full builds and the Rust/LLVM rebuild inside EriX remain open.

Published the coordinated dependency migration across all 76 repositories: Cargo declarations track `main`, CI resolves explicit feature branches, and catalogs retain exact commits. Both maintained lockfiles were generated by Cargo. [#142](https://git.erikinkinen.fi/erix/integration/issues/142) tracks the remaining CI acceptance. Also fixed the disabled-program override error in [#146](https://git.erikinkinen.fi/erix/integration/issues/146); guest confirmation is still open. Phase completion remains 24.29%, with 37 of 460 parent items accepted and 561 of 1,019 sub-items complete. These regression repairs add no phase checklist credit. Full builds and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

Fixed the two component-preparation failures tracked in #147 and #148. The repaired helper is pushed; its adoption across 72 component workflows is underway. Four README lint repairs are included.

Docs CI now passes on its current revision, including the manual build. The full Integration suite and remaining fleet CI are still being checked. Phase completion remains 24.29%; these supporting repairs do not add checklist credit. Full builds and the Rust/LLVM rebuild inside EriX remain open.

Fixed the two component-preparation failures tracked in [#147](https://git.erikinkinen.fi/erix/integration/issues/147) and [#148](https://git.erikinkinen.fi/erix/integration/issues/148). The repaired helper is pushed; its adoption across 72 component workflows is underway. Four README lint repairs are included. Docs CI now passes on its current revision, including the manual build. The full Integration suite and remaining fleet CI are still being checked. Phase completion remains 24.29%; these supporting repairs do not add checklist credit. Full builds and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

Python entry-point repairs are published in 8004dfda; the first three criteria are complete. The complete-suite run still needs to pass. The latest fleet snapshot also exposes a new Git acquisition refusal, which is being investigated.

Completion remains 24.29% weighted, with 37/460 parent items and 561/1019 sub-items complete. Regression repairs add no planning units.

[Python entry-point repairs](https://git.erikinkinen.fi/erix/integration/issues/149) are published in [8004dfda](https://git.erikinkinen.fi/erix/integration/commit/8004dfdada6bfd4a57ed9e6635cc30d804bc5c85); the first three criteria are complete. The complete-suite run still needs to pass. The latest fleet snapshot also exposes a new Git acquisition refusal, which is being investigated. Completion remains **24.29% weighted**, with **37/460** parent items and **561/1019** sub-items complete. Regression repairs add no planning units.
Author
Owner

The packed-fetch repair is published and selected by all 72 affected component workflows. The corrected complete Python suite passes 1,905 tests across 172 modules without warnings.

Next are the final lockfile and catalog updates and current-source CI. Phase completion remains 24.29%; these regression repairs add no checklist credit. The full EriX build and external toolchain rebuild inside EriX remain required.

The [packed-fetch repair](https://git.erikinkinen.fi/erix/integration/issues/150) is published and selected by all 72 affected component workflows. The corrected [complete Python suite](https://git.erikinkinen.fi/erix/integration/issues/149) passes 1,905 tests across 172 modules without warnings. Next are the final lockfile and catalog updates and current-source CI. Phase completion remains 24.29%; these regression repairs add no checklist credit. The full EriX build and external toolchain rebuild inside EriX remain required.
Author
Owner

Published the refreshed dependency locks and catalog update in b59c6cbc. LibIPC's target setup fix and LibCstd's same-source recovery now have successful current-source CI; their reports are closed.

The 01:55 UTC check on 17 October shows 49 of 76 current revisions passing, 21 running, five queued and one failing. Integration stops at source-policy verification; #152 tracks that failure.

Completion is corrected to 24.05% (536/1019 sub-items). Twenty-five CI checks had retained success from superseded commits and are now open pending the current runs. Implementation checks and all 37 accepted parent items are unchanged.

Published the refreshed dependency locks and catalog update in b59c6cbc. LibIPC's target setup fix and LibCstd's same-source recovery now have successful current-source CI; their reports are closed. The 01:55 UTC check on 17 October shows 49 of 76 current revisions passing, 21 running, five queued and one failing. Integration stops at source-policy verification; [#152](https://git.erikinkinen.fi/erix/integration/issues/152) tracks that failure. Completion is corrected to **24.05%** (536/1019 sub-items). Twenty-five CI checks had retained success from superseded commits and are now open pending the current runs. Implementation checks and all 37 accepted parent items are unchanged.
Author
Owner

At 02:43 UTC, 68 of 76 current-source CI runs pass, including all 15 separate recovery runs tracked in #153. This restores 19 existing CI checks and brings checklist progress to 24.23% (555/1019 sub-items); the 37 accepted parent items are unchanged.

The repair in #152 passes the current Rust job. Integration still has a Markdown line-length error, while its VM job continues. Exsh still reaches the six frame-analysis deadlines tracked in Exsh #4. The remaining failed components and the C-probe fix remain open.

At 02:43 UTC, 68 of 76 current-source CI runs pass, including all 15 separate recovery runs tracked in [#153](https://git.erikinkinen.fi/erix/integration/issues/153). This restores 19 existing CI checks and brings checklist progress to 24.23% (555/1019 sub-items); the 37 accepted parent items are unchanged. The repair in [#152](https://git.erikinkinen.fi/erix/integration/issues/152) passes the current Rust job. Integration still has a Markdown line-length error, while its VM job continues. Exsh still reaches the six frame-analysis deadlines tracked in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). The remaining failed components and the C-probe fix remain open.
Author
Owner

The latest current-source check has 73 of 76 repositories passing. Exsh still reaches its frame-analysis deadlines; LibPosixABI’s freestanding probe repair is tracked in #10. Integration’s Rust and Markdown jobs pass while VM scenarios run. Docs and Vfsd both pass at their new commits.

Five existing CI checks are restored. Completion is now 24.28%, with 560/1,019 sub-items complete; 37 whole items remain accepted. The wait/resource metadata and manual updates are published.

The latest current-source check has 73 of 76 repositories passing. Exsh still reaches its frame-analysis deadlines; LibPosixABI’s freestanding probe repair is tracked in [#10](https://git.erikinkinen.fi/erix/lib-posixabi/issues/10). Integration’s Rust and Markdown jobs pass while VM scenarios run. Docs and Vfsd both pass at their new commits. Five existing CI checks are restored. Completion is now 24.28%, with 560/1,019 sub-items complete; 37 whole items remain accepted. The wait/resource metadata and manual updates are published.
Author
Owner

LibPosixABI now passes at c0027de3, bringing the current total to 74 of 76 repositories. Its C ABI probe completes host calls and freestanding static links with GCC and Clang at O0/O2; LibPosixABI #9 and #10 are closed.

Integration’s VM job stops during host setup, before guest scenarios: the Timed setup selects an unpopulated checkout directory. The repair and regression are tracked in #154. Exsh’s frame-analysis deadlines remain the other failure. Completion is 24.29%, with 561/1,019 sub-items complete and 37 accepted whole items.

LibPosixABI now passes at c0027de3, bringing the current total to 74 of 76 repositories. Its C ABI probe completes host calls and freestanding static links with GCC and Clang at O0/O2; [LibPosixABI #9](https://git.erikinkinen.fi/erix/lib-posixabi/issues/9) and [#10](https://git.erikinkinen.fi/erix/lib-posixabi/issues/10) are closed. Integration’s VM job stops during host setup, before guest scenarios: the Timed setup selects an unpopulated checkout directory. The repair and regression are tracked in [#154](https://git.erikinkinen.fi/erix/integration/issues/154). Exsh’s frame-analysis deadlines remain the other failure. Completion is 24.29%, with 561/1,019 sub-items complete and 37 accepted whole items.
Author
Owner

The signal-information and child-wait metadata changes are now signed locally, with nine new semantic tests and matching manual updates. Their native checks and publication are pending, so the two current-source CI entries are open again. Earlier passed runs remain unchanged; no accepted implementation item has been reopened. Progress is 24.27%, with 559/1019 sub-items and 37/460 parent items accepted.

The Timed checkout fix is published in 213ce6a8; Rust and Markdown pass while its VM job runs. The retained Exsh input takes 72.73 seconds without profiling. Profiling reached its separate diagnostic deadline and retained partial measurements. Four valid shifts rejected by the checker are tracked separately in Exsh #23.

The signal-information and child-wait metadata changes are now signed locally, with nine new semantic tests and matching manual updates. Their native checks and publication are pending, so the two current-source CI entries are open again. Earlier passed runs remain unchanged; no accepted implementation item has been reopened. Progress is 24.27%, with 559/1019 sub-items and 37/460 parent items accepted. The Timed checkout fix is published in [213ce6a8](https://git.erikinkinen.fi/erix/integration/commit/213ce6a86d2e242527cf0ac33adcd520a1b1bd53); Rust and Markdown pass while its VM job runs. The retained Exsh input takes 72.73 seconds without profiling. Profiling reached its separate diagnostic deadline and retained partial measurements. Four valid shifts rejected by the checker are tracked separately in [Exsh #23](https://git.erikinkinen.fi/erix/exsh/issues/23).
Author
Owner

The pure signal-information and child-observation types are complete at published 09e9c033, with CI 260 passing all required crate, documentation, no_std and C-probe checks. Runtime delivery, waiting and the complete C ABI remain open. Checklist progress is now 24.39%, with 561/1019 sub-items and 37/460 parent items accepted.

Loaderd's catalog regression and both Timed setup regressions are closed. The complete Integration 2777 log confirms its clock checks pass, then exposes a separate documentation-gate failure for non-Cargo repositories. The narrow repair is published as 1428cb5b, tracked in #155.

Exsh's explicit count-one shift correction is published; its six focused regressions pass. Its production frame deadline and full guest-build requirements remain open.

The pure signal-information and child-observation types are complete at published `09e9c033`, with [CI 260](https://git.erikinkinen.fi/erix/lib-posixabi/actions/runs/260) passing all required crate, documentation, no_std and C-probe checks. Runtime delivery, waiting and the complete C ABI remain open. Checklist progress is now **24.39%**, with **561/1019 sub-items** and **37/460 parent items** accepted. Loaderd's catalog regression and both Timed setup regressions are closed. The complete [Integration 2777 log](https://git.erikinkinen.fi/erix/integration/actions/runs/2777) confirms its clock checks pass, then exposes a separate documentation-gate failure for non-Cargo repositories. The narrow repair is published as [`1428cb5b`](https://git.erikinkinen.fi/erix/integration/commit/1428cb5b1a0a88eaeae70d3c25890267004c5dbb), tracked in [#155](https://git.erikinkinen.fi/erix/integration/issues/155). Exsh's explicit count-one shift correction is published; its six focused regressions pass. Its production frame deadline and full guest-build requirements remain open.
Author
Owner

Progress is 24.85%: 38 of 460 parent items and 560 of 1,019 sub-items complete. The fork snapshot specification is published in Posixd and the manual. Native copying and libc remain open. Two exact-current CI sub-items reopened for the new Posixd and Docs heads; no implementation work was removed.

Exsh #23 is closed after the four retained shift sites and full cleanup suite pass. Current CI580 still hits all six frame-analysis deadlines under #4. The performance candidate has passed focused semantic controls; whole-work timing is still required.

Progress is 24.85%: 38 of 460 parent items and 560 of 1,019 sub-items complete. The fork snapshot specification is published in [Posixd](https://git.erikinkinen.fi/erix/posixd/issues/3#issuecomment-22976) and the manual. Native copying and libc remain open. Two exact-current CI sub-items reopened for the new Posixd and Docs heads; no implementation work was removed. [Exsh #23](https://git.erikinkinen.fi/erix/exsh/issues/23) is closed after the four retained shift sites and full cleanup suite pass. Current CI580 still hits all six frame-analysis deadlines under [#4](https://git.erikinkinen.fi/erix/exsh/issues/4). The performance candidate has passed focused semantic controls; whole-work timing is still required.
Author
Owner

Progress is 24.87%, with 38/460 parent items and 562/1019 sub-items complete. The fork snapshot contract is specified; native fork execution remains open.

The component rustdoc defect #155 is closed. The next build failure, #156, is repaired in bf1eb3d8; its final CI criterion remains open. Full builds within EriX and rebuilding the external toolchain there are still required.

Progress is **24.87%**, with **38/460 parent items** and **562/1019 sub-items** complete. The fork snapshot contract is specified; native fork execution remains open. The component rustdoc defect [#155](https://git.erikinkinen.fi/erix/integration/issues/155) is closed. The next build failure, [#156](https://git.erikinkinen.fi/erix/integration/issues/156), is repaired in [bf1eb3d8](https://git.erikinkinen.fi/erix/integration/commit/bf1eb3d8f7dbebd64afb6c59f821959894b9ab3a); its final CI criterion remains open. Full builds within EriX and rebuilding the external toolchain there are still required.
Author
Owner

Five signed build-tool and manual commits are published. The shared command libraries now separate image/hash logic from Linux I/O; native backends are still required.

Progress is 24.84%, with 38/460 parent items and 559/1019 sub-items complete. Publishing three new heads reopens their current-CI observations; no implementation was removed. Both complete EriX build generations and rebuilding Rust/LLVM inside EriX remain required.

Five signed build-tool and manual commits are published. The shared command libraries now separate image/hash logic from Linux I/O; [native backends](https://git.erikinkinen.fi/erix/integration/issues/8) are still required. Progress is **24.84%**, with **38/460** parent items and **559/1019** sub-items complete. Publishing three new heads reopens their current-CI observations; no implementation was removed. Both complete EriX build generations and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

Shared command/I/O separation is complete in boot-tool#2 and sha2-tool#2, with the manuals updated in docs#4. The output-panic bug is closed.

Completion is now 25.07%: 39/460 parent items and 559/1019 sub-items. Native tool backends, complete guest-built EriX generations and rebuilding Rust/LLVM inside EriX remain required.

Shared command/I/O separation is complete in [boot-tool#2](https://git.erikinkinen.fi/erix/boot-tool/pulls/2) and [sha2-tool#2](https://git.erikinkinen.fi/erix/sha2-tool/pulls/2), with the manuals updated in [docs#4](https://git.erikinkinen.fi/erix/docs/pulls/4). [The output-panic bug](https://git.erikinkinen.fi/erix/boot-tool/issues/4) is closed. Completion is now 25.07%: 39/460 parent items and 559/1019 sub-items. Native tool backends, complete guest-built EriX generations and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

Published lib-owned-region and migrated Kernel’s reserved heap to the shared implementation. Kernel retains its backing, lock and native probe. Consumer and manual work are still in progress.

The repository addition exposed Meta #5, now fixed and closed. Launchd #22 tracks failure-context diagnostics for the unresolved realm-directory rejection.

Checklist progress is 25.10%; 39 of 461 parent items and 565 of 1,027 sub-items are complete. Full guest builds and the in-guest toolchain rebuild remain open.

Published [lib-owned-region](https://git.erikinkinen.fi/erix/lib-owned-region/pulls/2) and migrated [Kernel’s reserved heap](https://git.erikinkinen.fi/erix/kernel/pulls/3) to the shared implementation. Kernel retains its backing, lock and native probe. Consumer and manual work are still in progress. The repository addition exposed [Meta #5](https://git.erikinkinen.fi/erix/meta/issues/5), now fixed and closed. [Launchd #22](https://git.erikinkinen.fi/erix/launchd/issues/22) tracks failure-context diagnostics for the unresolved realm-directory rejection. Checklist progress is 25.10%; 39 of 461 parent items and 565 of 1,027 sub-items are complete. Full guest builds and the in-guest toolchain rebuild remain open.
Author
Owner

Weighted checklist progress is 24.91%: 39 accepted parent items and 546/1,027 completed sub-items. Twenty current-CI checkboxes still referred to earlier source revisions; they are now unchecked. The new Docs commit also reopens its two applicable checks. No completed implementation or parent item was removed.

The current-source CI snapshot shows 54 successful runs, 21 failed, one waiting and one running. Full failure logs are being collected. The shallow-source fix passes its 73 targeted tests; #157 remains open for the Kernel consumer result. The allocator chapter and API reference are published in Docs #4.

Weighted checklist progress is **24.91%**: 39 accepted parent items and 546/1,027 completed sub-items. Twenty current-CI checkboxes still referred to earlier source revisions; they are now unchecked. The new Docs commit also reopens its two applicable checks. No completed implementation or parent item was removed. The current-source CI snapshot shows 54 successful runs, 21 failed, one waiting and one running. Full failure logs are being collected. The shallow-source fix passes its 73 targeted tests; [#157](https://git.erikinkinen.fi/erix/integration/issues/157) remains open for the Kernel consumer result. The allocator chapter and API reference are published in [Docs #4](https://git.erikinkinen.fi/erix/docs/pulls/4).
Author
Owner

Published the realm-directory diagnostic across LibIPC, Launchd, Exsh and Integration, with the matching manual. The diagnostic design still tracks the unresolved guest failure.

The shallow Cargo handoff defect is closed after the affected Kernel host checks pass. Five checks reopened for the newly changed sources: completion is 24.86%, with 541/1,027 sub-items complete and 39/461 parents accepted. The checklist reflects those exact revisions.

Published the realm-directory diagnostic across LibIPC, Launchd, Exsh and Integration, with the matching manual. [The diagnostic design](https://git.erikinkinen.fi/erix/launchd/issues/22) still tracks the unresolved guest failure. [The shallow Cargo handoff defect](https://git.erikinkinen.fi/erix/integration/issues/157) is closed after the affected Kernel host checks pass. Five checks reopened for the newly changed sources: completion is 24.86%, with 541/1,027 sub-items complete and 39/461 parents accepted. The checklist reflects those exact revisions.
Author
Owner

Phase 6 is at 25.05% weighted completion: 39/461 accepted parent items and 560/1,027 completed sub-items. Seventeen current-CI entries are restored; the remaining failures and pending runs stay open.

The opt-in realm-directory diagnostic is integrated across LibIPC, Launchd, Exsh and the manual. Exsh #24 is closed; frame-analysis timeouts and Launchd diagnostic completion remain open. The allocator Kernel image is linked, with guest checks still outstanding. Both complete EriX builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.

Phase 6 is at **25.05%** weighted completion: 39/461 accepted parent items and 560/1,027 completed sub-items. Seventeen current-CI entries are restored; the remaining failures and pending runs stay open. The opt-in realm-directory diagnostic is integrated across LibIPC, Launchd, Exsh and the manual. [Exsh #24](https://git.erikinkinen.fi/erix/exsh/issues/24) is closed; [frame-analysis timeouts](https://git.erikinkinen.fi/erix/exsh/issues/4) and [Launchd diagnostic completion](https://git.erikinkinen.fi/erix/launchd/issues/22) remain open. The allocator Kernel image is linked, with guest checks still outstanding. Both complete EriX builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

The checklist is now 25.08% complete, with 563/1,027 sub-items and 39/461 accepted parent items. Docs has completed its applicable checks, including all 261 tests and the manual build. Launchd’s current CI is green and erix/launchd#24 is closed. Integration selects that fix; its new CI run is still queued.

Exsh’s six frame-analysis timeouts remain open in erix/exsh#4. The next measurement compares the candidate against the unchanged baseline using the retained CI input.

The checklist is now 25.08% complete, with 563/1,027 sub-items and 39/461 accepted parent items. Docs has completed its applicable checks, including all 261 tests and the manual build. Launchd’s current CI is green and erix/launchd#24 is closed. Integration selects that fix; its new CI run is still queued. Exsh’s six frame-analysis timeouts remain open in erix/exsh#4. The next measurement compares the candidate against the unchanged baseline using the retained CI input.
Author
Owner

Cancelled seven superseded Integration runs while preserving the active VM run and the latest source run. The latest run is still queued behind the active one.

LibCapABI now passes its local checks with 202 unit tests and no warnings. Its remote setup failure remains open. The Boot-tool cleanup fix and Exsh profiling are continuing in parallel.

Cancelled seven superseded Integration runs while preserving the active VM run and the latest source run. The latest run is still queued behind the active one. LibCapABI now passes its local checks with 202 unit tests and no warnings. Its remote setup failure remains open. The Boot-tool cleanup fix and Exsh profiling are continuing in parallel.
Author
Owner

Published the Boot temporary-cleanup fix and matching manual update. Boot #5 records the defect and its two regression controls; the fix passes local checks and CI65. The new manual is still rendering.

Completion is 25.07% (562/1,027 sub-items; 39/461 whole items). One manual-check item is open again for the newly published revision; earlier results remain recorded against their original source. The Exsh register-join comparison and read-only storage fixture repair are in progress.

Published the Boot temporary-cleanup fix and matching manual update. [Boot #5](https://git.erikinkinen.fi/erix/boot-tool/issues/5) records the defect and its two regression controls; the fix passes local checks and CI65. The new manual is still rendering. Completion is 25.07% (562/1,027 sub-items; 39/461 whole items). One manual-check item is open again for the newly published revision; earlier results remain recorded against their original source. The Exsh register-join comparison and read-only storage fixture repair are in progress.
Author
Owner

Published b8bbf455 to fix the documentation classifications that blocked Integration CI before Python and VM tests (#159). The complete source check and 20 policy tests pass; the new workflow is pending. The read-only durability fix is published, with its original guest test still open under #158.

Checklist progress remains 25.09%; this supporting repair adds no phase completion credit.

Published `b8bbf455` to fix the documentation classifications that blocked Integration CI before Python and VM tests ([#159](https://git.erikinkinen.fi/erix/integration/issues/159)). The complete source check and 20 policy tests pass; the new workflow is pending. The read-only durability fix is published, with its original guest test still open under [#158](https://git.erikinkinen.fi/erix/integration/issues/158). Checklist progress remains 25.09%; this supporting repair adds no phase completion credit.
Author
Owner

Reconciled successful CI for the current LibCapABI, FsName and lib-sha2 sources. Completion is now 25.12%, with 567/1027 sub-items complete. Original failed push runs remain recorded; the broader audits and CapABI’s newer dependency graph remain open.

Integration CI 2819 clears #159 and passes all 175 Python modules/1,925 tests. The remaining workflow and VM matrix are still ongoing.

The updated Boot-tool manual section is checked in the current PDF. The Exsh candidate passes 312 focused controls; a matched workload comparison is underway for Exsh #4.

Reconciled successful CI for the current LibCapABI, FsName and lib-sha2 sources. Completion is now **25.12%**, with **567/1027 sub-items** complete. Original failed push runs remain recorded; the broader audits and CapABI’s newer dependency graph remain open. [Integration CI 2819](https://git.erikinkinen.fi/erix/integration/actions/runs/2819) clears [#159](https://git.erikinkinen.fi/erix/integration/issues/159) and passes all 175 Python modules/1,925 tests. The remaining workflow and VM matrix are still ongoing. The updated Boot-tool manual section is checked in the current PDF. The Exsh candidate passes 312 focused controls; a matched workload comparison is underway for [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4).
Author
Owner

Published the Kernel dependency-record repair under #160. CI2819 passed Rust, Python, Markdown and the full Rustdoc policy scan, then stopped because Kernel's allocator dependency and manifest digest were stale. The new push needs to clear that gate before image and VM work can be assessed. Checklist completion is unchanged.

Published the [Kernel dependency-record repair](https://git.erikinkinen.fi/erix/integration/commit/f06bf72280eff2f49248ce816c327f8a3760a4f4) under [#160](https://git.erikinkinen.fi/erix/integration/issues/160). CI2819 passed Rust, Python, Markdown and the full Rustdoc policy scan, then stopped because Kernel's allocator dependency and manifest digest were stale. The new push needs to clear that gate before image and VM work can be assessed. Checklist completion is unchanged.
Author
Owner

The checklist is now at 25.13% weighted progress: 568/1,027 sub-items complete, with 39/461 whole items accepted. The shared allocator’s current feature head passes both CI jobs; its earlier failed push remains recorded.

The Kernel dependency-record fix for #160 is published. The new Integration run passes Rust, Markdown and all Python modules and is still running the later gates. Recipient-view disposal is implemented in LibStdio and Launchd; the matching consumer checks remain pending. The Exsh timeout work is measuring a candidate that limits preservation analysis to the required dependency closure.

The checklist is now at 25.13% weighted progress: 568/1,027 sub-items complete, with 39/461 whole items accepted. The shared allocator’s current feature head passes both CI jobs; its earlier failed push remains recorded. The Kernel dependency-record fix for #160 is published. The new Integration run passes Rust, Markdown and all Python modules and is still running the later gates. Recipient-view disposal is implemented in LibStdio and Launchd; the matching consumer checks remain pending. The Exsh timeout work is measuring a candidate that limits preservation analysis to the required dependency closure.
Author
Owner

Expanded the native SHA checklist to show the completed allocator work separately from Kernel backing, stream transport, startup authority, teardown and guest acceptance. Recalculated progress is 25.15%: 569/1,036 sub-items complete and 39/461 whole items accepted.

The recipient-view API still awaits the corrected Launchd cohort and manual refresh. The private SHA transport is being redesigned so abandoning an I/O wrapper leaves its original invocation, grants and storage reachable for cleanup.

Expanded the native SHA checklist to show the completed allocator work separately from Kernel backing, stream transport, startup authority, teardown and guest acceptance. Recalculated progress is 25.15%: 569/1,036 sub-items complete and 39/461 whole items accepted. The recipient-view API still awaits the corrected Launchd cohort and manual refresh. The private SHA transport is being redesigned so abandoning an I/O wrapper leaves its original invocation, grants and storage reachable for cleanup.
Author
Owner

Recipient-view disposal is published in LibStdio and Launchd. The manual update is in progress. Native SHA still needs authenticated startup, complete owner retirement and guest execution.

The dependency-record regression is closed: the current Integration run clears that gate and reaches VM tests. Current selector-race and extop failures are tracked in #64 and #141.

Weighted checklist progress is 25.13% (567/1036 sub-items; 39/461 whole items). Two CI entries are pending again because their repositories now have new revisions. Their earlier green runs remain recorded.

Recipient-view disposal is published in [LibStdio](https://git.erikinkinen.fi/erix/lib-stdio/commit/70d8fa50cd2b10d63293ee6c6608463f8678b24a) and [Launchd](https://git.erikinkinen.fi/erix/launchd/commit/a1020322a2c293e65c9a4d90040d8e1dbdf25e75). The manual update is in progress. Native SHA still needs authenticated startup, complete owner retirement and guest execution. [The dependency-record regression](https://git.erikinkinen.fi/erix/integration/issues/160) is closed: the current Integration run clears that gate and reaches VM tests. Current selector-race and extop failures are tracked in [#64](https://git.erikinkinen.fi/erix/integration/issues/64) and [#141](https://git.erikinkinen.fi/erix/integration/issues/141). Weighted checklist progress is 25.13% (567/1036 sub-items; 39/461 whole items). Two CI entries are pending again because their repositories now have new revisions. Their earlier green runs remain recorded.
Author
Owner

The recipient-view disposal change is published in LibStdio and Launchd, with the manual and matching catalogs. Native SHA startup, operand grants and final cleanup remain open.

Progress is 25.13%: 567/1,036 sub-items and 39/461 parents. LibStdio’s current CI item is complete; Docs’ item now awaits its newly published head.

The recipient-view disposal change is published in [LibStdio](https://git.erikinkinen.fi/erix/lib-stdio/pulls/2) and [Launchd](https://git.erikinkinen.fi/erix/launchd/pulls/2), with the [manual](https://git.erikinkinen.fi/erix/docs/pulls/4) and [matching catalogs](https://git.erikinkinen.fi/erix/integration/pulls/12). Native SHA startup, operand grants and final cleanup remain open. Progress is 25.13%: 567/1,036 sub-items and 39/461 parents. LibStdio’s current CI item is complete; Docs’ item now awaits its newly published head.
Author
Owner

Startup frame grants now distinguish read-only startup pages from writable realm workspaces. SHA preparation preserves original operand positions, and disk VM workers retain original failed-case metadata before reusing build outputs. The process service, SHA tool, Integration and manual contain the changes. Native startup authentication, full guest builds and rebuilding the toolchain inside EriX remain open.

Integration #161 tracks the read-only host verifier requiring a write marker. Its fix and host regressions are included in the published checkpoint.

Six local and current CI checks reopened for the new heads. Progress is now 25.09%, with 562 of 1,036 sub-items complete; earlier successful observations remain recorded.

Startup frame grants now distinguish read-only startup pages from writable realm workspaces. SHA preparation preserves original operand positions, and disk VM workers retain original failed-case metadata before reusing build outputs. The [process service](https://git.erikinkinen.fi/erix/procd/pulls/2), [SHA tool](https://git.erikinkinen.fi/erix/sha2-tool/pulls/2), [Integration](https://git.erikinkinen.fi/erix/integration/pulls/12) and [manual](https://git.erikinkinen.fi/erix/docs/pulls/4) contain the changes. Native startup authentication, full guest builds and rebuilding the toolchain inside EriX remain open. [Integration #161](https://git.erikinkinen.fi/erix/integration/issues/161) tracks the read-only host verifier requiring a write marker. Its fix and host regressions are included in the published checkpoint. Six local and current CI checks reopened for the new heads. Progress is now 25.09%, with 562 of 1,036 sub-items complete; earlier successful observations remain recorded.
Author
Owner

Progress is now 25.14%: 568/1,036 sub-items and 39/461 complete parent items. The recent Procd, SHA and manual checkpoints have their applicable component checks complete.

The next repairs target the pipeline receipt allocation, realm seal failure, and remaining acceptance for the read-only verifier fix. Full in-guest EriX and Rust/LLVM builds remain open.

Progress is now **25.14%**: 568/1,036 sub-items and 39/461 complete parent items. The recent Procd, SHA and manual checkpoints have their applicable component checks complete. The next repairs target the [pipeline receipt allocation](https://git.erikinkinen.fi/erix/integration/issues/91), [realm seal failure](https://git.erikinkinen.fi/erix/integration/issues/162), and remaining acceptance for the [read-only verifier fix](https://git.erikinkinen.fi/erix/integration/issues/161). Full in-guest EriX and Rust/LLVM builds remain open.
Author
Owner

The pipeline receipt fix is pushed in Launchd 0039c4d1, with its manual contract in Docs 6e00c621. Integration 05a511ec selects both revisions and repairs the runner and storage-verifier fixtures.

Progress is 25.11%, with 565/1036 sub-items and 39/461 whole items complete. Three checks reopened because Launchd and Docs have new source revisions; their previous passing results remain recorded. The pipeline VM #91, read-only verifier #161 and realm-seal regression #162 remain open. Full EriX builds and Rust/LLVM rebuilding inside EriX are still required.

The pipeline receipt fix is pushed in [Launchd 0039c4d1](https://git.erikinkinen.fi/erix/launchd/commit/0039c4d1bc9e4edfba0388ec19c3f3f49b99c8e6), with its manual contract in [Docs 6e00c621](https://git.erikinkinen.fi/erix/docs/commit/6e00c6214c85a318db81e2a4c18efd39e5b2c299). [Integration 05a511ec](https://git.erikinkinen.fi/erix/integration/commit/05a511ec958ce0cfa7f0486b9eb11f14c40dac73) selects both revisions and repairs the runner and storage-verifier fixtures. Progress is **25.11%**, with **565/1036 sub-items** and **39/461 whole items** complete. Three checks reopened because Launchd and Docs have new source revisions; their previous passing results remain recorded. The pipeline VM [#91](https://git.erikinkinen.fi/erix/integration/issues/91), read-only verifier [#161](https://git.erikinkinen.fi/erix/integration/issues/161) and realm-seal regression [#162](https://git.erikinkinen.fi/erix/integration/issues/162) remain open. Full EriX builds and Rust/LLVM rebuilding inside EriX are still required.
Author
Owner

The repeated-run metadata collision in #163 is fixed, with its host regression criteria complete. The pipeline receipt fix in #91 passes Launchd CI 422; the full local matrix is running and the guest case remains open.

Exsh's sparse-join candidate passes 454 focused controls. Complete graph equivalence and timing still need to establish whether it improves the measured bottleneck. It remains private.

Checklist progress remains 25.12%, with 566/1036 sub-items and 39/461 parents accepted. The current Integration and Docs workflows, realm-seal failures, and self-hosting requirements remain open.

The repeated-run metadata collision in [#163](https://git.erikinkinen.fi/erix/integration/issues/163) is fixed, with its host regression criteria complete. The pipeline receipt fix in [#91](https://git.erikinkinen.fi/erix/integration/issues/91) passes Launchd CI 422; the full local matrix is running and the guest case remains open. Exsh's sparse-join candidate passes 454 focused controls. Complete graph equivalence and timing still need to establish whether it improves the measured bottleneck. It remains private. Checklist progress remains **25.12%**, with **566/1036 sub-items** and **39/461 parents** accepted. The current Integration and Docs workflows, realm-seal failures, and self-hosting requirements remain open.
Author
Owner

The realm-seal investigation found a missing supplementary-group term in Launchd's completed-record check. The fix, three regressions, documentation and matching catalogs are signed and pushed; #162 tracks the remaining host and five-case guest acceptance.

The preceding Launchd revision passed the full local matrix: 689 default and 695 all-feature tests, strict host/native Clippy, doctests and private documentation. Its current-CI acceptance reopens for the new source, so progress is 25.11%, with 565/1036 sub-items and 39/461 parents accepted. Earlier results remain recorded against their actual revision.

The realm-seal investigation found a missing supplementary-group term in Launchd's completed-record check. The fix, three regressions, documentation and matching catalogs are signed and pushed; [#162](https://git.erikinkinen.fi/erix/integration/issues/162) tracks the remaining host and five-case guest acceptance. The preceding Launchd revision passed the full local matrix: 689 default and 695 all-feature tests, strict host/native Clippy, doctests and private documentation. Its current-CI acceptance reopens for the new source, so progress is **25.11%**, with **565/1036 sub-items** and **39/461 parents** accepted. Earlier results remain recorded against their actual revision.
Author
Owner

Integration now selects the corrected realm seal fixtures. The new unit run and five realm VM cases remain open in the seal issue.

The sparse-join experiment produced identical graph and proof output but ran 2.52% slower in the captured comparison, so the current implementation stays in place (details).

Integration now selects the [corrected realm seal fixtures](https://git.erikinkinen.fi/erix/launchd/commit/406a1508354bc37a43e53f0ce91277faef0d6295). The new unit run and five realm VM cases remain open in [the seal issue](https://git.erikinkinen.fi/erix/integration/issues/162). The sparse-join experiment produced identical graph and proof output but ran 2.52% slower in the captured comparison, so the current implementation stays in place ([details](https://git.erikinkinen.fi/erix/exsh/issues/4#issuecomment-23327)).
Author
Owner

Historical CI 2825 finished with 514 of 525 VM cases passing and 11 failing. The selector-race, pipeline-descriptor and Powerbox approval cases recovered, with no newly failing cases in the same cohort. That run used Launchd a1020322; the later receipt and seal-count fixes still need guest coverage. Current Integration CI 2843 has passing Markdown, with Rust and VM jobs last observed running.

The complete Exsh caller profile matches the original graph and proof dependencies. Repeated contextual analysis is its largest recorded cost, and the next change targets that repeated work. The production 60-second gates remain unchanged.

Historical [CI 2825](https://git.erikinkinen.fi/erix/integration/actions/runs/2825) finished with 514 of 525 VM cases passing and 11 failing. The selector-race, pipeline-descriptor and Powerbox approval cases recovered, with no newly failing cases in the same cohort. That run used Launchd `a1020322`; the later receipt and seal-count fixes still need guest coverage. Current Integration CI 2843 has passing Markdown, with Rust and VM jobs last observed running. The complete Exsh caller profile matches the original graph and proof dependencies. Repeated contextual analysis is its largest recorded cost, and the next change targets that repeated work. The production 60-second gates remain unchanged.
Author
Owner

Current feature-branch CI is passing in 74 of 77 repositories. The remaining failures are Exsh, Launchd CI 426 and Integration CI 2843. Docs CI 1691 now passes both jobs; its current CI checklist item is restored. Full current logs and warning checks remain separate.

The new Exsh prefix-reuse candidate passes all 447 focused controls, including 21 new cases. Full Python/IO checks and the unchanged production timing gates are next. The previous slower candidate remains rejected.

Completion is 25.13%: 567/1036 sub-items and 39/461 whole items. Full guest builds and rebuilding Rust/LLVM inside EriX remain open.

Current feature-branch CI is passing in 74 of 77 repositories. The remaining failures are Exsh, Launchd CI 426 and Integration CI 2843. Docs CI 1691 now passes both jobs; its current CI checklist item is restored. Full current logs and warning checks remain separate. The new Exsh prefix-reuse candidate passes all 447 focused controls, including 21 new cases. Full Python/IO checks and the unchanged production timing gates are next. The previous slower candidate remains rejected. Completion is 25.13%: 567/1036 sub-items and 39/461 whole items. Full guest builds and rebuilding Rust/LLVM inside EriX remain open.
Author
Owner

Published the Procd row-reservation repair in Procd PR #2. Its current CI passes; Integration still needs the corresponding catalog update.

Exsh’s prefix-reuse candidate passes all 1,125 tests in the complete Python suite. The whole-graph comparison and six production frame deadlines remain open in Exsh #4.

Integration’s current VM job stops in the cache-reuse host fixture before the 525-case VM matrix starts. A worker archive permission fix and regression controls are prepared. Launchd’s server logs are missing, so its current revision is undergoing the full local checks. Docs’ current manual build passes without final-pass warnings. Checklist completion remains 25.13%; no additional acceptance items have closed.

Published the Procd row-reservation repair in [Procd PR #2](https://git.erikinkinen.fi/erix/procd/pulls/2). Its current CI passes; Integration still needs the corresponding catalog update. Exsh’s prefix-reuse candidate passes all 1,125 tests in the complete Python suite. The whole-graph comparison and six production frame deadlines remain open in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). Integration’s current VM job stops in the cache-reuse host fixture before the 525-case VM matrix starts. A worker archive permission fix and regression controls are prepared. Launchd’s server logs are missing, so its current revision is undergoing the full local checks. Docs’ current manual build passes without final-pass warnings. Checklist completion remains 25.13%; no additional acceptance items have closed.
Author
Owner

Launchd’s current revision now passes CI 428: 698 Rust test executions and 23 Markdown files, with no warning lines. This completes its current local quality and CI checklist entries; guest acceptance remains open. The earlier failed run’s missing logs remain unresolved.

Integration #164 tracks the reproduced worker archive permission problem. The transfer and metadata controls pass; publication and the full VM run remain open. Exsh’s performance gate also remains open.

Weighted progress is 25.15%, with 569/1,036 sub-items complete. Whole-item acceptance remains 39/461.

Launchd’s current revision now passes CI 428: 698 Rust test executions and 23 Markdown files, with no warning lines. This completes its current local quality and CI checklist entries; guest acceptance remains open. The earlier failed run’s missing logs remain unresolved. [Integration #164](https://git.erikinkinen.fi/erix/integration/issues/164) tracks the reproduced worker archive permission problem. The transfer and metadata controls pass; publication and the full VM run remain open. Exsh’s performance gate also remains open. Weighted progress is 25.15%, with 569/1,036 sub-items complete. Whole-item acceptance remains 39/461.
Author
Owner

Integration’s archive permission and error-handling fix is published as 3be7eb07, alongside the catalog update for Procd’s row reservation repair. CI 2846 is running; issue #164 tracks reaching the VM catalog.

Weighted progress remains 25.15%, with 569/1,036 sub-items complete. Exsh’s performance gate and the guest build requirements remain open.

Integration’s archive permission and error-handling fix is published as `3be7eb07`, alongside the catalog update for Procd’s row reservation repair. [CI 2846](https://git.erikinkinen.fi/erix/integration/actions/runs/2846) is running; [issue #164](https://git.erikinkinen.fi/erix/integration/issues/164) tracks reaching the VM catalog. Weighted progress remains 25.15%, with 569/1,036 sub-items complete. Exsh’s performance gate and the guest build requirements remain open.
Author
Owner

Published Integration bbfefc4a with complete worker source verification and explicit plain-directory selection. It preserves original command failures and the first copy comparison. The 24 focused controls pass; current VM and full CI acceptance remain open.

Progress remains 25.15%: 569/1,036 sub-items and 39/461 accepted parent items. This repair adds no checklist credit.

Published Integration `bbfefc4a` with complete worker source verification and explicit plain-directory selection. It preserves original command failures and the first copy comparison. The 24 focused controls pass; current VM and full CI acceptance remain open. Progress remains **25.15%**: 569/1,036 sub-items and 39/461 accepted parent items. This repair adds no checklist credit.
Author
Owner

Published Integration 6a597b8f to fix the worker guide’s Markdown line length. Source-policy and catalog checks pass; full current CI and the complete VM catalog remain open. The earlier run’s worker-start messages are host fixtures, so they do not establish guest progress.

Progress remains 25.15%: 569/1,036 sub-items and 39/461 accepted parent items. The documentation repair adds no checklist credit.

Published Integration `6a597b8f` to fix the worker guide’s Markdown line length. Source-policy and catalog checks pass; full current CI and the complete VM catalog remain open. The earlier run’s worker-start messages are host fixtures, so they do not establish guest progress. Progress remains **25.15%**: 569/1,036 sub-items and 39/461 accepted parent items. The documentation repair adds no checklist credit.
Author
Owner

Published the worker-source manual update and its Integration catalog entry.

Progress is 25.14%: 568/1,036 sub-items and 39/461 parent items. Only the manual’s current-CI entry reopened for the new revision; its previous successful run remains historical evidence. In-guest system and toolchain rebuilds remain open.

Published the [worker-source manual update](https://git.erikinkinen.fi/erix/docs/commit/52aeb04fd17166b05d5dc6df1d07b0592700b4a5) and its [Integration catalog entry](https://git.erikinkinen.fi/erix/integration/commit/3dd658e25ed5c2922684404c95c85810bc7e5ed0). Progress is **25.14%**: 568/1,036 sub-items and 39/461 parent items. Only the manual’s current-CI entry reopened for the new revision; its previous successful run remains historical evidence. In-guest system and toolchain rebuilds remain open.
Author
Owner

The manual update’s current-CI item is complete again. Progress is 25.15%: 569/1,036 sub-items and 39/461 parent items.

The next implementation work is Exsh’s fixed-point profiler and the typed IPC call boundary. Full system and Rust/LLVM rebuilds inside EriX remain open.

The manual update’s current-CI item is complete again. Progress is **25.15%**: 569/1,036 sub-items and 39/461 parent items. The next implementation work is Exsh’s fixed-point profiler and the typed IPC call boundary. Full system and Rust/LLVM rebuilds inside EriX remain open.
Author
Owner

Integration now checks selected Rustdoc source bytes before parsing and requires an explicit environment from library callers. Exsh now has optional fixed-point work counts that retain every context row without supplying proof evidence. Both changes are documented in the technical manual.

The Integration change and Exsh profiler are pushed. A guide correction fixes the new Markdown failure.

Completion is 25.14% with 568/1,036 sub-items and 39/461 parents complete. The current documentation CI checkbox is open while its new manual build runs. Full guest builds, rebuilding Rust/LLVM in EriX and the Exsh performance deadline remain open.

Integration now checks selected Rustdoc source bytes before parsing and requires an explicit environment from library callers. Exsh now has optional fixed-point work counts that retain every context row without supplying proof evidence. Both changes are documented in the [technical manual](https://git.erikinkinen.fi/erix/docs/commit/8ecb067ee68475f435d41bcc301a171c131956c2). The [Integration change](https://git.erikinkinen.fi/erix/integration/commit/144114876bac1f87abc8937daa06f55128230904) and [Exsh profiler](https://git.erikinkinen.fi/erix/exsh/commit/434869ccad87714a9cc99657fac4aab245d31aa7) are pushed. A [guide correction](https://git.erikinkinen.fi/erix/exsh/commit/4e13207bc1e394e8e8cc350581d6fed9bdc307d1) fixes the new Markdown failure. Completion is 25.14% with 568/1,036 sub-items and 39/461 parents complete. The current documentation CI checkbox is open while its new manual build runs. Full guest builds, rebuilding Rust/LLVM in EriX and the Exsh performance deadline remain open.
Author
Owner

The register-copy candidate took 83.27 seconds versus 95.12 seconds for the current code in one unprofiled comparison, with identical graph output. Full regression checks are next; the production 60-second gate remains open. The six C-runtime modules also passed after selecting the intended checkout.

Integration run 2846 finished with 516 of 525 scenarios passing and nine failures. Docs run 1695 failed, but its task log is missing; that is tracked in lib-bootstrap #3.

The register-copy candidate took 83.27 seconds versus 95.12 seconds for the current code in one unprofiled comparison, with identical graph output. Full regression checks are next; the production 60-second gate remains open. The six C-runtime modules also passed after selecting the intended checkout. [Integration run 2846](https://git.erikinkinen.fi/erix/integration/actions/runs/2846) finished with 516 of 525 scenarios passing and nine failures. [Docs run 1695](https://git.erikinkinen.fi/erix/docs/actions/runs/1695/jobs/0/attempt/1) failed, but its task log is missing; that is tracked in [lib-bootstrap #3](https://git.erikinkinen.fi/erix/lib-bootstrap/issues/3).
Author
Owner

Exsh 3ce8164e is published. Cached clobber positions reduced one measured checker run from 95.12s to 83.27s with the same graph and proof output; the production 60-second gate remains open.

Current Integration CI fails before VM execution because a test fixture hardcodes an unavailable Python interpreter. #165 tracks the fix. Its Rust and Markdown jobs pass; the nine failures in the earlier complete VM run remain separate.

[Exsh 3ce8164e](https://git.erikinkinen.fi/erix/exsh/commit/3ce8164e087dbea2e25ac98427565821e05d2325) is published. Cached clobber positions reduced one measured checker run from 95.12s to 83.27s with the same graph and proof output; the production 60-second gate remains open. Current Integration CI fails before VM execution because a test fixture hardcodes an unavailable Python interpreter. [#165](https://git.erikinkinen.fi/erix/integration/issues/165) tracks the fix. Its Rust and Markdown jobs pass; the nine failures in the earlier complete VM run remain separate.
Author
Owner

Integration 82db8968 fixes the pre-guest interpreter failure in #165 and updates the Docs/Exsh revisions. Exsh’s latest Rust CI has failed; its terminal log is being collected. The multi-PTY input fix now passes its host controls and is being prepared for publication. Guest failures and the full self-hosting demonstration remain open.

[Integration 82db8968](https://git.erikinkinen.fi/erix/integration/commit/82db89685b4b5daa18450de0036376762f6490fc) fixes the pre-guest interpreter failure in #165 and updates the Docs/Exsh revisions. Exsh’s latest Rust CI has failed; its terminal log is being collected. The multi-PTY input fix now passes its host controls and is being prepared for publication. Guest failures and the full self-hosting demonstration remain open.
Author
Owner

Integration now waits for each guest echo while typing the multi-PTY probe command (#166); the interpreter repair is tracked in #165. Both changes are published.

Docs’ current manual CI passes on its second attempt. Exsh’s remaining CI failures are six 60-second cleanup-analysis deadlines (#4); the current-source profile points to state transfers and joins for the next optimization.

Checklist progress is 25.15%, with 569/1,036 sub-items complete and 39/461 parent items accepted. The full in-guest EriX and Rust/LLVM rebuilds remain open.

Integration now waits for each guest echo while typing the multi-PTY probe command ([#166](https://git.erikinkinen.fi/erix/integration/issues/166)); the interpreter repair is tracked in [#165](https://git.erikinkinen.fi/erix/integration/issues/165). Both changes are published. Docs’ current manual CI passes on its second attempt. Exsh’s remaining CI failures are six 60-second cleanup-analysis deadlines ([#4](https://git.erikinkinen.fi/erix/exsh/issues/4)); the current-source profile points to state transfers and joins for the next optimization. Checklist progress is **25.15%**, with **569/1,036 sub-items** complete and **39/461 parent items** accepted. The full in-guest EriX and Rust/LLVM rebuilds remain open.
Author
Owner

Docs’ successful current-head CI is now recorded alongside its document-build checks. Checklist progress is 25.16%, with 570/1,036 sub-items complete; 39/461 parent items are accepted. The remaining Docs audit and PDF layout review stay open.

Docs’ successful current-head CI is now recorded alongside its document-build checks. Checklist progress is **25.16%**, with **570/1,036 sub-items** complete; **39/461 parent items** are accepted. The remaining Docs audit and PDF layout review stay open.
Author
Owner

Published 44a5bc5b to align Exsh’s Cargo and component selections. The mismatch had stopped Integration before VM testing; #167 tracks the repair and its pending CI acceptance.

The interpreter fixture now passes all 13 tests in the original CI run, so #165 is closed. Exsh’s next join optimization passes 216 focused tests and is being timed against the current version under the same inputs and limits (#4).

Checklist progress remains 25.16%: 570/1,036 sub-items, with 39/461 parents accepted. The full in-guest EriX build and Rust/LLVM rebuild remain open.

Published [44a5bc5b](https://git.erikinkinen.fi/erix/integration/commit/44a5bc5b6c52225d12aa9cff50bd95a8c5c3a533) to align Exsh’s Cargo and component selections. The mismatch had stopped Integration before VM testing; [#167](https://git.erikinkinen.fi/erix/integration/issues/167) tracks the repair and its pending CI acceptance. The interpreter fixture now passes all 13 tests in the original CI run, so [#165](https://git.erikinkinen.fi/erix/integration/issues/165) is closed. Exsh’s next join optimization passes 216 focused tests and is being timed against the current version under the same inputs and limits ([#4](https://git.erikinkinen.fi/erix/exsh/issues/4)). Checklist progress remains **25.16%**: **570/1,036 sub-items**, with **39/461 parents** accepted. The full in-guest EriX build and Rust/LLVM rebuild remain open.
Author
Owner

Published 6f20e691 with matching Cargo/component selections for the Exsh and Extop fixes, plus a revision-mismatch regression check. #165, #166 and #167 are closed; the original multi-PTY guest case passed.

Extop #3 has passing component CI and still needs its repaired Integration guest case. Exsh's recovered-input comparison preserved the complete graph and work counts but showed no speedup in this pair; its deadlines and missing call/table proofs remain open under Exsh #4.

Completion remains 25.16%: 570/1036 sub-items and 39/461 accepted parents. Both complete EriX builds inside EriX and the in-guest Rust/LLVM rebuild remain open.

Published [6f20e691](https://git.erikinkinen.fi/erix/integration/commit/6f20e691142054bfae65eaf52d0fa5c3788879f8) with matching Cargo/component selections for the Exsh and Extop fixes, plus a revision-mismatch regression check. [#165](https://git.erikinkinen.fi/erix/integration/issues/165), [#166](https://git.erikinkinen.fi/erix/integration/issues/166) and [#167](https://git.erikinkinen.fi/erix/integration/issues/167) are closed; the original multi-PTY guest case passed. [Extop #3](https://git.erikinkinen.fi/erix/extop/issues/3) has passing component CI and still needs its repaired Integration guest case. Exsh's recovered-input comparison preserved the complete graph and work counts but showed no speedup in this pair; its deadlines and missing call/table proofs remain open under [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). Completion remains **25.16%**: 570/1036 sub-items and 39/461 accepted parents. Both complete EriX builds inside EriX and the in-guest Rust/LLVM rebuild remain open.
Author
Owner

Published f0316cd5 with matching selections for Exsh's bounds fix and Vfsd's mounted-root fix. Vfsd now revalidates the selected mounted child without acquiring unrelated siblings; its original guest criterion remains open.

Kernel #56 tracks the selected build and explicit syscall return contract for Exsh's remaining analysis. Completion remains 25.16%, with 570/1036 sub-items and 39/461 parents accepted. Both complete EriX builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.

Published [f0316cd5](https://git.erikinkinen.fi/erix/integration/commit/f0316cd54482af075da8d9c4963ce5235b6f9d8e) with matching selections for [Exsh's bounds fix](https://git.erikinkinen.fi/erix/exsh/commit/89e91b74bebd95b44c99a61b50fb931a78387c32) and [Vfsd's mounted-root fix](https://git.erikinkinen.fi/erix/vfsd/issues/36). Vfsd now revalidates the selected mounted child without acquiring unrelated siblings; its original guest criterion remains open. [Kernel #56](https://git.erikinkinen.fi/erix/kernel/issues/56) tracks the selected build and explicit syscall return contract for Exsh's remaining analysis. Completion remains **25.16%**, with 570/1036 sub-items and 39/461 parents accepted. Both complete EriX builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

95cc7541 publishes matching Exsh/Kernel/Vfsd selections, the live syscall-contract producer and the detached-directory guest extension. Extop #3 is closed after its original two-CPU guest case passes. Exsh #4, Kernel #56 and Vfsd #37 retain their remaining criteria.

Completion is 25.15%, with 569/1036 sub-items and 39/461 accepted parents. Only Kernel's current-source CI child was reopened for its new revision. Both full EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.

[95cc7541](https://git.erikinkinen.fi/erix/integration/commit/95cc7541c75c6936726cff29a3aa3e4431c7fec4) publishes matching Exsh/Kernel/Vfsd selections, the live syscall-contract producer and the detached-directory guest extension. [Extop #3](https://git.erikinkinen.fi/erix/extop/issues/3) is closed after its original two-CPU guest case passes. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4), [Kernel #56](https://git.erikinkinen.fi/erix/kernel/issues/56) and [Vfsd #37](https://git.erikinkinen.fi/erix/vfsd/issues/37) retain their remaining criteria. Completion is **25.15%**, with 569/1036 sub-items and 39/461 accepted parents. Only Kernel's current-source CI child was reopened for its new revision. Both full EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

30580361 selects the repair for Fatd #17. The original parser rejects the recommended formatter table at its final literal; the repaired provider passes its source/local criteria. Its original guest criterion remains open.

Kernel CI 931 passes on the new declaration revision, restoring its current-source child. Fatd's newly published source awaits its own CI, so that child is reopened instead. Completion remains 25.15%: 569/1036 sub-items and 39/461 accepted parents. Both full EriX guest builds and the in-guest Rust/LLVM rebuild remain open.

[30580361](https://git.erikinkinen.fi/erix/integration/commit/305803617d2b23995e314abfafce797e81e19036) selects the repair for [Fatd #17](https://git.erikinkinen.fi/erix/fatd/issues/17). The original parser rejects the recommended formatter table at its final literal; the repaired provider passes its source/local criteria. Its original guest criterion remains open. Kernel CI 931 passes on the new declaration revision, restoring its current-source child. Fatd's newly published source awaits its own CI, so that child is reopened instead. Completion remains **25.15%**: 569/1036 sub-items and 39/461 accepted parents. Both full EriX guest builds and the in-guest Rust/LLVM rebuild remain open.
Author
Owner

Published the larger-cluster repair in Fatd 4cf3847a and selected it in both Integration catalogs. Fatd #18 retains the large-cluster guest criterion; Exsh #4 still tracks the complete frame-analysis timeout.

Completion is 25.15%, with 569/1036 sub-items and 39/461 accepted parents. Only Fatd's current-source CI child reopened for its new revision. Both complete EriX builds and the Rust/LLVM rebuild inside EriX remain open.

Published the larger-cluster repair in [Fatd 4cf3847a](https://git.erikinkinen.fi/erix/fatd/commit/4cf3847a24709428391472cbbf3e83560f2b02ac) and selected it in both [Integration catalogs](https://git.erikinkinen.fi/erix/integration/commit/0b58a24fb3e7ed37c000103717cd69d8ae5c8cca). [Fatd #18](https://git.erikinkinen.fi/erix/fatd/issues/18) retains the large-cluster guest criterion; [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) still tracks the complete frame-analysis timeout. Completion is **25.15%**, with 569/1036 sub-items and 39/461 accepted parents. Only Fatd's current-source CI child reopened for its new revision. Both complete EriX builds and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

Exsh 3964e913 publishes exact scalar propagation across native calls, selected by Integration e38c9571. Kernel #56 now accepts its producer/consumer and refusal controls; the complete frame timeout remains in Exsh #4. Fatd CI 313 passes its exact current source, restoring that CI child.

Completion is 25.16%, with 570/1036 sub-items and 39/461 accepted parents. Both complete EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.

[Exsh 3964e913](https://git.erikinkinen.fi/erix/exsh/commit/3964e913354136f265b73e84455ae451d8b03f2a) publishes exact scalar propagation across native calls, selected by [Integration e38c9571](https://git.erikinkinen.fi/erix/integration/commit/e38c9571f3ee77100297c9f54b298a283359c7d9). [Kernel #56](https://git.erikinkinen.fi/erix/kernel/issues/56) now accepts its producer/consumer and refusal controls; the complete frame timeout remains in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). [Fatd CI 313](https://git.erikinkinen.fi/erix/fatd/actions/runs/313) passes its exact current source, restoring that CI child. Completion is **25.16%**, with 570/1036 sub-items and 39/461 accepted parents. Both complete EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

Published 7d3e7b3f with the separate 128 KiB cluster case, corrected image geometry, host upcase handling and nested output forwarding. The narrow host-fixture issues #25 and #53 are closed on their original criteria. The remaining observer work is tracked in #168 and #169.

Completion remains 25.16%: 570/1036 sub-items and 39/461 accepted parents. Both complete EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.

Published [7d3e7b3f](https://git.erikinkinen.fi/erix/integration/commit/7d3e7b3f845d1fea372a4f682126ccb3c3b9496b) with the separate 128 KiB cluster case, corrected image geometry, host upcase handling and nested output forwarding. The narrow host-fixture issues [#25](https://git.erikinkinen.fi/erix/integration/issues/25) and [#53](https://git.erikinkinen.fi/erix/integration/issues/53) are closed on their original criteria. The remaining observer work is tracked in [#168](https://git.erikinkinen.fi/erix/integration/issues/168) and [#169](https://git.erikinkinen.fi/erix/integration/issues/169). Completion remains **25.16%**: 570/1036 sub-items and 39/461 accepted parents. Both complete EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

Published Docs 275fcbed and Integration 260cd47e. Kernel #56 is closed on its original contract criteria; the full frame proof remains in Exsh #4. The prepared host suite passes all 185 modules and 2,064 tests, advancing #169.

Completion is 25.15%: 569/1036 sub-items and 39/461 accepted parents. Only the new Docs revision's CI checkbox was reopened; its prior result is preserved. Both complete EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.

Published Docs [275fcbed](https://git.erikinkinen.fi/erix/docs/commit/275fcbedc25d11e33f55d6058beba1ec261d6238) and Integration [260cd47e](https://git.erikinkinen.fi/erix/integration/commit/260cd47e7b74bc723b05f3a7aa8ca83cc62580c7). [Kernel #56](https://git.erikinkinen.fi/erix/kernel/issues/56) is closed on its original contract criteria; the full frame proof remains in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). The prepared host suite passes all 185 modules and 2,064 tests, advancing [#169](https://git.erikinkinen.fi/erix/integration/issues/169). Completion is **25.15%**: 569/1036 sub-items and 39/461 accepted parents. Only the new Docs revision's CI checkbox was reopened; its prior result is preserved. Both complete EriX guest builds and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

Docs CI 1697 passes the new manual source, restoring its current-CI checkbox. Completion is 25.16%, with 570/1036 sub-items and 39/461 accepted parents. The complete Exsh frame proof, current Integration CI and the dedicated new filesystem guest cases remain open. Both full EriX guest builds and the Rust/LLVM rebuild inside EriX are still required.

[Docs CI 1697](https://git.erikinkinen.fi/erix/docs/actions/runs/1697) passes the new manual source, restoring its current-CI checkbox. Completion is **25.16%**, with 570/1036 sub-items and 39/461 accepted parents. The complete Exsh frame proof, current Integration CI and the dedicated new filesystem guest cases remain open. Both full EriX guest builds and the Rust/LLVM rebuild inside EriX are still required.
Author
Owner

Exsh CI 600 failed its six 60-second frame checks. Forgejo also marks its Markdown job failed but reports a missing log file, so that job has no usable diagnostic yet. The frame-analysis issue remains open.

Completion remains 25.16%: 570/1,036 sub-items and 39/461 parent items accepted.

[Exsh CI 600](https://git.erikinkinen.fi/erix/exsh/actions/runs/600) failed its six 60-second frame checks. Forgejo also marks its Markdown job failed but reports a missing log file, so that job has no usable diagnostic yet. The [frame-analysis issue](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. Completion remains 25.16%: 570/1,036 sub-items and 39/461 parent items accepted.
Author
Owner

The latest sweep confirms 75 repositories have passing CI at their current feature-branch heads. Integration CI 2897 is queued; Exsh CI 600 remains failed under Exsh #4. The earlier nine TLS status-read errors are resolved in this observation.

Completion remains 25.16%: 570/1,036 sub-items and 39/461 parent items accepted.

The latest sweep confirms 75 repositories have passing CI at their current feature-branch heads. [Integration CI 2897](https://git.erikinkinen.fi/erix/integration/actions/runs/2897) is queued; [Exsh CI 600](https://git.erikinkinen.fi/erix/exsh/actions/runs/600) remains failed under [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). The earlier nine TLS status-read errors are resolved in this observation. Completion remains 25.16%: 570/1,036 sub-items and 39/461 parent items accepted.
Author
Owner

Exsh 04a191e is published through exsh#3; exsh#4 remains open. Checklist progress is still 25.16%, with 570/1,036 sub-items and 39/461 whole items accepted. Repeated checks and regression fixes add no completion units. Both guest-built EriX generations and rebuilding Rust/LLVM inside EriX remain open.

Exsh [04a191e](https://git.erikinkinen.fi/erix/exsh/commit/04a191e1af5eddf8f376dabf6747479a730c81e2) is published through [exsh#3](https://git.erikinkinen.fi/erix/exsh/pulls/3); [exsh#4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. Checklist progress is still **25.16%**, with **570/1,036 sub-items** and **39/461 whole items** accepted. Repeated checks and regression fixes add no completion units. Both guest-built EriX generations and rebuilding Rust/LLVM inside EriX remain open.
Author
Owner

The latest Exsh CI run still reaches all six frame-analysis deadlines; Exsh #4 remains open. The completed Integration run passed 512 of 525 VM scenarios, with eight appliance realm/selector failures and five FAT recovery failures. The current Integration run is active, with Rust and Markdown passing.

Work continues on product build size, worker cleanup and the explicit endpoint-query contract in Kernel #57. Checklist progress remains 25.16% (570/1,036 sub-items); neither the two guest-built EriX generations nor the in-guest Rust/LLVM rebuild has been demonstrated.

The latest Exsh CI run still reaches all six frame-analysis deadlines; [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. The completed Integration run passed 512 of 525 VM scenarios, with eight appliance realm/selector failures and five FAT recovery failures. The current Integration run is active, with Rust and Markdown passing. Work continues on product build size, worker cleanup and the explicit endpoint-query contract in [Kernel #57](https://git.erikinkinen.fi/erix/kernel/issues/57). Checklist progress remains 25.16% (570/1,036 sub-items); neither the two guest-built EriX generations nor the in-guest Rust/LLVM rebuild has been demonstrated.
Author
Owner

Published Integration 5ad0a2b4, Rootd 9e57ea88, Kernel ca2c4735 and Docs 5b6f22dc. These include exact process waits, fixed product launch records, checks of the captured product executable and the endpoint-query producer contract.

Completion is 25.13%, with 567/1036 sub-items and 39/461 parents accepted. Three CI checks reopen for their new source heads; implementation credit is unchanged. Coordinated Exsh/catalog adoption and the remaining VM failures are open. Both full builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.

Published [Integration 5ad0a2b4](https://git.erikinkinen.fi/erix/integration/commit/5ad0a2b40a9cbc25a90a0472bef46c1fff529286), [Rootd 9e57ea88](https://git.erikinkinen.fi/erix/rootd/commit/9e57ea88dd9cee00bf1edbef56f8dc1011382158), [Kernel ca2c4735](https://git.erikinkinen.fi/erix/kernel/commit/ca2c473520c9c97c8e1244e152cdd21e68ed7e67) and [Docs 5b6f22dc](https://git.erikinkinen.fi/erix/docs/commit/5b6f22dcf66709bb8207a958f45046d9a95b8492). These include exact process waits, fixed product launch records, checks of the captured product executable and the endpoint-query producer contract. Completion is **25.13%**, with **567/1036** sub-items and **39/461** parents accepted. Three CI checks reopen for their new source heads; implementation credit is unchanged. Coordinated Exsh/catalog adoption and the remaining VM failures are open. Both full builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

Published Integration 0d87ec65 for complete standalone worker ownership and the query-contract adoption, and Fatd f50ee8a5 for failed cache refills.

Completion is 25.16%, with 570/1036 sub-items and 39/461 parents accepted. Rootd, Kernel, Docs and FAT now have successful CI for their published source. Exsh’s parser change and matching catalog adoption are still being finished; the frame-proof and guest failures remain open. Both full builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.

Published [Integration 0d87ec65](https://git.erikinkinen.fi/erix/integration/commit/0d87ec6533530b44185e430dd2ba19913a05acae) for complete standalone worker ownership and the query-contract adoption, and [Fatd f50ee8a5](https://git.erikinkinen.fi/erix/fatd/commit/f50ee8a5c8ebb266b0beed2b23ffe90993f173b4) for failed cache refills. Completion is **25.16%**, with **570/1036** sub-items and **39/461** parents accepted. Rootd, Kernel, Docs and FAT now have successful CI for their published source. Exsh’s parser change and matching catalog adoption are still being finished; the frame-proof and guest failures remain open. Both full builds inside EriX and rebuilding Rust/LLVM inside EriX remain required.
Author
Owner

Published the coordinated Exsh, Integration and manual changes. Exsh's local component checks now meet their checklist criterion: 571/1036 sub-items, 25.17% weighted; 39/461 whole items.

Frame proof, compiled-wrapper and guest coverage, both in-guest EriX build generations and rebuilding Rust/LLVM inside EriX remain open.

Published the coordinated [Exsh](https://git.erikinkinen.fi/erix/exsh/pulls/3), [Integration](https://git.erikinkinen.fi/erix/integration/pulls/12) and [manual](https://git.erikinkinen.fi/erix/docs/pulls/4) changes. Exsh's local component checks now meet their checklist criterion: **571/1036 sub-items, 25.17% weighted; 39/461 whole items**. [Frame proof](https://git.erikinkinen.fi/erix/exsh/issues/4), [compiled-wrapper and guest coverage](https://git.erikinkinen.fi/erix/kernel/issues/57), both in-guest EriX build generations and rebuilding Rust/LLVM inside EriX remain open.
Author
Owner

Published the native compiler preflight fix. The lexer, paired workspace layout, manual and native reply-budget API now have signed source checkpoints. Lexer checks and the original native query scenarios are running.

Checklist accounting remains 571/1036 sub-items, 25.17% weighted; 39/461 whole items. Full frame proof, guest acceptance and both self-hosted build generations remain open.

Published the [native compiler preflight fix](https://git.erikinkinen.fi/erix/integration/issues/170). The lexer, paired workspace layout, manual and native reply-budget API now have signed source checkpoints. Lexer checks and the original native query scenarios are running. Checklist accounting remains **571/1036 sub-items, 25.17% weighted; 39/461 whole items**. Full frame proof, guest acceptance and both self-hosted build generations remain open.
Author
Owner

Published the catalog classification repair; all 78 source snapshots pass locally, and the original CI result remains pending. The compiler preflight bug is closed after both native query guests passed.

The lexer migration passes both unit configurations, including all 19 new controls, and both strict host Clippy selections; native checks are running. Checklist accounting remains 571/1036 sub-items, 25.17% weighted; 39/461 whole items. The remaining frame, consumer and self-hosting obligations stay open.

Published the [catalog classification repair](https://git.erikinkinen.fi/erix/integration/issues/159); all 78 source snapshots pass locally, and the original CI result remains pending. The [compiler preflight bug](https://git.erikinkinen.fi/erix/integration/issues/170) is closed after both native query guests passed. The lexer migration passes both unit configurations, including all 19 new controls, and both strict host Clippy selections; native checks are running. Checklist accounting remains **571/1036 sub-items, 25.17% weighted; 39/461 whole items**. The remaining frame, consumer and self-hosting obligations stay open.
Author
Owner

Published the Kernel and LibIPC CLAIM budget witness. The namespace codecs and typed client are next. The caller-owned lexer and version-23 producers pass their local unit and producer checks; native builds and documentation are running. No additional whole checklist criterion is complete: weighted progress remains 25.17%, with 571/1,036 sub-items and 39/461 parents accepted.

Published the Kernel and LibIPC [CLAIM budget witness](https://git.erikinkinen.fi/erix/lib-ipc/issues/12). The namespace codecs and typed client are next. The [caller-owned lexer](https://git.erikinkinen.fi/erix/exsh/issues/25) and version-23 producers pass their local unit and producer checks; native builds and documentation are running. No additional whole checklist criterion is complete: weighted progress remains **25.17%**, with **571/1,036 sub-items** and **39/461 parents** accepted.
Author
Owner

Published the caller-owned lexer and coordinated workspace producers; four feature criteria are complete. Native builds and local documentation checks pass, while the generated API/manual and full native frame/VM scope remain open. LibVfs client and Vfsd producer implementation continues in parallel. Phase accounting is unchanged at 25.17%: 571/1,036 sub-items and 39/461 parents accepted.

Published the [caller-owned lexer and coordinated workspace producers](https://git.erikinkinen.fi/erix/exsh/issues/25); four feature criteria are complete. Native builds and local documentation checks pass, while the generated API/manual and full native frame/VM scope remain open. LibVfs client and Vfsd producer implementation continues in parallel. Phase accounting is unchanged at **25.17%**: **571/1,036 sub-items** and **39/461 parents** accepted.
Author
Owner

Integration #159 is closed after its original CI run passed the complete source gate. The final shell API JSON is also ready for manual coordination. Work continues on the namespace client, producer and matching image storage. Phase accounting remains 25.17%, with 571/1,036 sub-items and 39/461 parents accepted; these intermediate checks do not close additional phase requirements.

[Integration #159](https://git.erikinkinen.fi/erix/integration/issues/159) is closed after its original CI run passed the complete source gate. The final shell API JSON is also ready for [manual coordination](https://git.erikinkinen.fi/erix/exsh/issues/25). Work continues on the namespace client, producer and matching image storage. Phase accounting remains **25.17%**, with **571/1,036 sub-items** and **39/461 parents** accepted; these intermediate checks do not close additional phase requirements.
Author
Owner

Provider-default creation tracks the remaining CREATE policy boundary in the owned namespace migration. It preserves each mounted provider’s defaults without adding caller-selected owner, group or permission fields. Its criteria remain open and add no phase completion credit.

[Provider-default creation](https://git.erikinkinen.fi/erix/lib-ipc/issues/13) tracks the remaining CREATE policy boundary in the owned namespace migration. It preserves each mounted provider’s defaults without adding caller-selected owner, group or permission fields. Its criteria remain open and add no phase completion credit.
Author
Owner

Published Docs f3f144b, selected by Integration 61b0d41, and LibIPC 9e32c52. The Exsh manual/layout criterion and the first two CREATE criteria are complete. Filesystem adapters, the persistent client and counted Vfsd producer remain in progress.

Exsh #4 remains the current CI blocker. The captured input exposed discarded graph scans; a candidate scheduler change is undergoing semantic checks and profiling with the original deadline.

Published [Docs f3f144b](https://git.erikinkinen.fi/erix/docs/commit/f3f144b0f4aeccbaf724ccfa91199a1fcb0cc0d4), selected by [Integration 61b0d41](https://git.erikinkinen.fi/erix/integration/commit/61b0d414f12469f06249841ac9261cadae67af0d), and [LibIPC 9e32c52](https://git.erikinkinen.fi/erix/lib-ipc/commit/9e32c525f13c1c3a15cd36dcb8e2b6e77f091a7a). The Exsh manual/layout criterion and the first two [CREATE criteria](https://git.erikinkinen.fi/erix/lib-ipc/issues/13) are complete. Filesystem adapters, the persistent client and counted Vfsd producer remain in progress. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains the current CI blocker. The captured input exposed discarded graph scans; a candidate scheduler change is undergoing semantic checks and profiling with the original deadline.
Author
Owner

Published LibVfs ccf5854 and Ramfsd d0a292c. The client retains original invocation and provider cleanup custody, and memory-file creation preserves the provider’s existing defaults. Loaderd migration is underway alongside Vfsd and the remaining filesystem adapters.

The measured Exsh scheduler candidate passes its semantic suite but still exceeds the original profiling deadline. Exsh #4 remains open while that result is investigated.

Published [LibVfs ccf5854](https://git.erikinkinen.fi/erix/lib-vfs/commit/ccf58540d513f57b9c31168d25e2d950ab57b752) and [Ramfsd d0a292c](https://git.erikinkinen.fi/erix/ramfsd/commit/d0a292c018b10ad222d836e6619a2452c18d824c). The client retains original invocation and provider cleanup custody, and memory-file creation preserves the provider’s existing defaults. Loaderd migration is underway alongside Vfsd and the remaining filesystem adapters. The measured Exsh scheduler candidate passes its semantic suite but still exceeds the original profiling deadline. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open while that result is investigated.
Author
Owner

Published Fatd 9753c56 with the catalog-backed provider-default creation path. Memory and FAT/exFAT adapters are complete; E2fsd and Vfsd remain in progress. Loaderd adoption and the client’s explicit wait interface are being completed together.

Published [Fatd 9753c56](https://git.erikinkinen.fi/erix/fatd/commit/9753c562e3171bb92b771e3236cd1dfa874bb602) with the catalog-backed provider-default creation path. Memory and FAT/exFAT adapters are complete; E2fsd and Vfsd remain in progress. Loaderd adoption and the client’s explicit wait interface are being completed together.
Author
Owner

Published E2fsd's provider-default creation, completing the three filesystem adapters in LibIPC #13. LibVfs now exposes borrowed lease inspection for service wait loops, and the manual describes the client and creation contracts. Vfsd and Loaderd integration are in progress; the coordinated runtime catalog remains open.

Published [E2fsd's provider-default creation](https://git.erikinkinen.fi/erix/e2fsd/commit/053db7f3780c4e0f485a905d537c442ab5bb3bcd), completing the three filesystem adapters in [LibIPC #13](https://git.erikinkinen.fi/erix/lib-ipc/issues/13). [LibVfs](https://git.erikinkinen.fi/erix/lib-vfs/commit/47b8deafa9dab779a7a3d7d93034cce408dd1992) now exposes borrowed lease inspection for service wait loops, and the [manual](https://git.erikinkinen.fi/erix/docs/commit/505c870e2a5e900068cad24041389a8effb86395) describes the client and creation contracts. Vfsd and Loaderd integration are in progress; the coordinated runtime catalog remains open.
Author
Owner

Published the coordinated Exsh checker update and Integration selections. Semantic tests pass; the local profile still times out, so performance acceptance remains open. CI retains the six original frame checks and their 60-second limits. Vfsd and Loaderd namespace work continues in parallel.

Published the coordinated [Exsh checker update](https://git.erikinkinen.fi/erix/exsh/commit/ac52d2e83c758afede234bfe028abf90f11df36e) and [Integration selections](https://git.erikinkinen.fi/erix/integration/commit/f7154703cbc7fd40d34beb0c4d8b92e40b18c56f). Semantic tests pass; the local profile still times out, so performance acceptance remains open. CI retains the six original frame checks and their 60-second limits. Vfsd and Loaderd namespace work continues in parallel.
Author
Owner

Restored Docs branch publication to the readable ci-feature-posix-compat name in 2e9e77c, matching Integration's existing convention. Docs #24 is closed after the current manual was published at that tag.

Restored Docs branch publication to the readable [ci-feature-posix-compat](https://git.erikinkinen.fi/erix/docs/releases/tag/ci-feature-posix-compat) name in [2e9e77c](https://git.erikinkinen.fi/erix/docs/commit/2e9e77cf33d08f09c03bd50453254da4ebd36278), matching Integration's existing convention. [Docs #24](https://git.erikinkinen.fi/erix/docs/issues/24) is closed after the current manual was published at that tag.
Author
Owner

Vfsd’s namespace migration is published at dae0e1f4, including provider-default CREATE. Vfsd #38 is fixed and closed after its original CI run passed. Rootd and Loaderd adoption continues in LibIPC #12. The weighted checklist remains 25.17% (571/1,036 sub-items); completing this regression adds no planning units.

Vfsd’s namespace migration is published at `dae0e1f4`, including provider-default CREATE. [Vfsd #38](https://git.erikinkinen.fi/erix/vfsd/issues/38) is fixed and closed after its original CI run passed. Rootd and Loaderd adoption continues in [LibIPC #12](https://git.erikinkinen.fi/erix/lib-ipc/issues/12). The weighted checklist remains 25.17% (571/1,036 sub-items); completing this regression adds no planning units.
Author
Owner

Published Exsh 5d6239c6 removes duplicate immutable liveness preparation. Exsh #4 now has a complete retained local graph within the original deadline, with its remaining proof gaps recorded. Rootd and Loaderd adoption continues in LibIPC #12. Checklist progress remains 25.17%; this repair adds no planning units.

Published Exsh `5d6239c6` removes duplicate immutable liveness preparation. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) now has a complete retained local graph within the original deadline, with its remaining proof gaps recorded. Rootd and Loaderd adoption continues in [LibIPC #12](https://git.erikinkinen.fi/erix/lib-ipc/issues/12). Checklist progress remains 25.17%; this repair adds no planning units.
Author
Owner

Published Loaderd adoption at 06dd7cbb. Rootd and the coordinated Integration changes remain in progress under LibIPC #12. Progress is 25.16% while the new Loaderd head awaits its original CI result; the completed local implementation checks remain accepted.

Published [Loaderd adoption](https://git.erikinkinen.fi/erix/loaderd/pulls/2) at `06dd7cbb`. Rootd and the coordinated Integration changes remain in progress under [LibIPC #12](https://git.erikinkinen.fi/erix/lib-ipc/issues/12). Progress is 25.16% while the new Loaderd head awaits its original CI result; the completed local implementation checks remain accepted.
Author
Owner

Loaderd’s current checkpoint is accepted, restoring checklist progress to 25.17% (571/1,036 sub-items). LibIPC #12 records the completed namespace contracts and counted producer storage. Rootd’s narrow fixture correction is running through its full component checks while the coordinated image and manual updates continue.

Loaderd’s current checkpoint is accepted, restoring checklist progress to 25.17% (571/1,036 sub-items). [LibIPC #12](https://git.erikinkinen.fi/erix/lib-ipc/issues/12) records the completed namespace contracts and counted producer storage. Rootd’s narrow fixture correction is running through its full component checks while the coordinated image and manual updates continue.
Author
Owner

The current-head CI survey finds 75 of 77 repositories passing. Exsh #4 remains open after all six original frame cases hit their deadlines. Integration’s current run 2927 is still waiting behind predecessor 2915; its API exposes no current step or server timeout, so the cause inside that active run is unconfirmed. Rootd implementation and the coordinated namespace/manual work continue independently. Checklist progress remains 25.17%.

The current-head CI survey finds 75 of 77 repositories passing. [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open after all six original frame cases hit their deadlines. Integration’s current run 2927 is still waiting behind predecessor 2915; its API exposes no current step or server timeout, so the cause inside that active run is unconfirmed. Rootd implementation and the coordinated namespace/manual work continue independently. Checklist progress remains 25.17%.
Author
Owner

Published the namespace manual and API references. Rootd’s remaining checks exposed a size heuristic that counts source-path data as code; its replacement will measure executable sections and retain data inventories separately. Exsh work continues on retaining each original PIC/LLVM emission.

Integration’s preceding run completed 526 scenarios, with three serial-stall failures, but its outer job has not exited. The current run remains queued while the runner’s cleanup state is investigated.

Checklist progress is 25.16%, with 570/1036 sub-items complete. Only the new Docs head’s CI entry reopened; accepted implementation is unchanged.

Published [the namespace manual and API references](https://git.erikinkinen.fi/erix/docs/commit/76daadf9f7f26766985f1409e7d73a88ecff99ba). Rootd’s remaining checks exposed a size heuristic that counts source-path data as code; its replacement will measure executable sections and retain data inventories separately. Exsh work continues on retaining each original PIC/LLVM emission. Integration’s preceding run completed 526 scenarios, with three serial-stall failures, but its outer job has not exited. The current run remains queued while the runner’s cleanup state is investigated. Checklist progress is 25.16%, with 570/1036 sub-items complete. Only the new Docs head’s CI entry reopened; accepted implementation is unchanged.
Author
Owner

Docs CI1709 passes for 76daadf9, including the complete manual and readable branch publication. Its CI checklist entry is checked again: progress is 25.17%, with 571/1036 sub-items complete.

Rootd’s final checks and Exsh’s new source tests are running in parallel. Implementation of the native namespace cancellation guest has also started. Exsh and Integration still prevent a green fleet.

[Docs CI1709](https://git.erikinkinen.fi/erix/docs/actions/runs/1709) passes for 76daadf9, including the complete manual and readable branch publication. Its CI checklist entry is checked again: progress is 25.17%, with 571/1036 sub-items complete. Rootd’s final checks and Exsh’s new source tests are running in parallel. Implementation of the native namespace cancellation guest has also started. Exsh and Integration still prevent a green fleet.
Author
Owner

Published the Exsh PIC/LLVM handoff through b0d37e66. Native checks are under way; the full frame proof remains open. Rootd’s baseline fix and the namespace cancellation guest are being completed in parallel. Progress remains 25.17%, with 571/1,036 sub-items and 39/461 whole items accepted. These fixes add no completion units.

Published the [Exsh PIC/LLVM handoff](https://git.erikinkinen.fi/erix/exsh/pulls/3) through b0d37e66. Native checks are under way; the full frame proof remains open. Rootd’s baseline fix and the namespace cancellation guest are being completed in parallel. Progress remains **25.17%**, with **571/1,036 sub-items** and **39/461 whole items** accepted. These fixes add no completion units.
Author
Owner

Rootd’s twelve verification reads now use counted namespace acquisition and retirement in e413c3a3. The coordinated guest run remains open. Integration 7fa39495 also fixes the fresh Kernel evidence-parent failure tracked in #171. Work continues on cancellation through the original lease and on Exsh’s loss of a proven indirect target across a stack spill and reload.

Rootd’s twelve verification reads now use counted namespace acquisition and retirement in [`e413c3a3`](https://git.erikinkinen.fi/erix/rootd/commit/e413c3a333b77b039adbb705b20058c7bcd8dab1). The coordinated guest run remains open. Integration [`7fa39495`](https://git.erikinkinen.fi/erix/integration/commit/7fa39495acf92cca340bbe313cfb0160da2c70c1) also fixes the fresh Kernel evidence-parent failure tracked in [#171](https://git.erikinkinen.fi/erix/integration/issues/171). Work continues on cancellation through the original lease and on Exsh’s loss of a proven indirect target across a stack spill and reload.
Author
Owner

Published the distinct cancellation receipt in LibVfs af306910. The provider and Rootd controller are implemented, and their coordinated guest test is being prepared. Exsh d35289ad preserves an existing proven target through an exact local stack spill/reload and adopts the Kernel output-parent fix. Native frame and guest acceptance remain open.

Published the distinct cancellation receipt in [LibVfs `af306910`](https://git.erikinkinen.fi/erix/lib-vfs/commit/af3069104c4fb75906343cb4f254cab13bbe74ed). The provider and Rootd controller are implemented, and their coordinated guest test is being prepared. [Exsh `d35289ad`](https://git.erikinkinen.fi/erix/exsh/commit/d35289ad56c12fb636292696beb30717921fe97a) preserves an existing proven target through an exact local stack spill/reload and adopts the Kernel output-parent fix. Native frame and guest acceptance remain open.
Author
Owner

The cancellation provider and controller are now published in Vfsd 4b6b3b73 and Rootd 87a03553. Their coordinated Integration source selects the published client and suppliers, with a dedicated guest case. The guest run is still pending. Review also found that Exsh’s matrix needs to distinguish an incomplete graph from capture or cleanup failure before continuing to another case; that boundary is being tightened.

The cancellation provider and controller are now published in [Vfsd `4b6b3b73`](https://git.erikinkinen.fi/erix/vfsd/commit/4b6b3b7328de2d3e313d2fa004fe898b96cece5a) and [Rootd `87a03553`](https://git.erikinkinen.fi/erix/rootd/commit/87a03553159b3b9ee0dd27b3963c39b2aaa080b9). Their coordinated Integration source selects the published client and suppliers, with a dedicated guest case. The guest run is still pending. Review also found that Exsh’s matrix needs to distinguish an incomplete graph from capture or cleanup failure before continuing to another case; that boundary is being tightened.
Author
Owner

Rootd 87a03553 and Vfsd 4b6b3b73 now pass their original push CIs. Integration #171 is closed: Exsh CI 620 reaches all six original frame cases without the missing evidence-directory error. Their analysis deadlines still expire; Exsh #4 remains open. The coherent namespace-cancellation host and VM checks are running.

Rootd `87a03553` and Vfsd `4b6b3b73` now pass their original push CIs. [Integration #171](https://git.erikinkinen.fi/erix/integration/issues/171) is closed: [Exsh CI 620](https://git.erikinkinen.fi/erix/exsh/actions/runs/620) reaches all six original frame cases without the missing evidence-directory error. Their analysis deadlines still expire; [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4) remains open. The coherent namespace-cancellation host and VM checks are running.
Author
Owner

Published Docs 1b8561df adds the pending-Begin cancellation contract and regenerates the matching LibVfs reference. Checklist progress is temporarily 25.16%: the new Docs head’s original CI is running, so its current-CI criterion is open. Previously accepted implementation work remains accepted.

Published [Docs `1b8561df`](https://git.erikinkinen.fi/erix/docs/commit/1b8561df85b204bd8f38fb194600f4d05fb47907) adds the pending-Begin cancellation contract and regenerates the matching LibVfs reference. Checklist progress is temporarily 25.16%: the new Docs head’s [original CI](https://git.erikinkinen.fi/erix/docs/actions/runs/1711) is running, so its current-CI criterion is open. Previously accepted implementation work remains accepted.
Author
Owner

Docs’ original run has completed successfully for the updated API reference and 3,458-page manual. Its current-source CI checklist entry is complete again. Overall progress is 25.17%, with 571/1,036 sub-items and 39/461 whole items complete.

Docs’ original run has completed successfully for the updated API reference and 3,458-page manual. Its current-source CI checklist entry is complete again. Overall progress is **25.17%**, with **571/1,036 sub-items** and **39/461 whole items** complete.
Author
Owner

The Vfsd dispatcher change is published, and its original CI run is green. The coordinated namespace changes now pass the host checks; the guest exercise remains open. Review found a build-script omission in forwarding Rootd’s dependency features, which is being fixed before the next native build. Checklist progress remains 25.17%: 571/1,036 sub-items and 39/461 whole items complete.

The Vfsd dispatcher change is published, and its original CI run is green. The coordinated namespace changes now pass the host checks; the guest exercise remains open. Review found a build-script omission in forwarding Rootd’s dependency features, which is being fixed before the next native build. Checklist progress remains **25.17%**: **571/1,036 sub-items** and **39/461 whole items** complete.
Author
Owner

Exsh’s checker cleanup fixes are published. All six native cases now retain their outcomes, but their analyses still reach the original deadline; Exsh CI remains unresolved. Work continues on the repeated transfer calculations identified by profiling.

The namespace VM build has passed shared-library compilation and reached image packaging. An offline boot-tool dependency lookup now blocks the guest run. The CI process-cleanup repair has passed its new low-descriptor regressions; two startup timing failures are being investigated.

Completion remains 25.17% (571/1,036 sub-items; 39/461 parents). The full builds inside EriX and the Rust/LLVM rebuild remain open.

Exsh’s checker cleanup fixes are published. All six native cases now retain their outcomes, but their analyses still reach the original deadline; Exsh CI remains unresolved. Work continues on the repeated transfer calculations identified by profiling. The namespace VM build has passed shared-library compilation and reached image packaging. An offline boot-tool dependency lookup now blocks the guest run. The CI process-cleanup repair has passed its new low-descriptor regressions; two startup timing failures are being investigated. Completion remains **25.17%** (571/1,036 sub-items; 39/461 parents). The full builds inside EriX and the Rust/LLVM rebuild remain open.
Author
Owner

The process-cleanup fix for long VM runs is published, and the replacement Integration CI is running. The earlier stalled run has been cancelled after preserving its failed-case logs and images.

The next guest build is blocked by offline boot-tool packaging. Exsh also needs a diagnostic for its silent CI refusal before that failure can be explained.

Completion remains 25.17% (571/1,036 sub-items; 39/461 parents). Both full builds inside EriX and the Rust/LLVM rebuild remain open.

The process-cleanup fix for long VM runs is published, and the replacement Integration CI is running. The earlier stalled run has been cancelled after preserving its failed-case logs and images. The next guest build is blocked by [offline boot-tool packaging](https://git.erikinkinen.fi/erix/integration/issues/172). Exsh also needs a diagnostic for its silent CI refusal before that failure can be explained. Completion remains **25.17%** (571/1,036 sub-items; 39/461 parents). Both full builds inside EriX and the Rust/LLVM rebuild remain open.
Author
Owner

Published the coordinated offline boot-tool inputs and final Rootd/Bootloader selections in PR 12. Bootloader’s current CI 184 and Rootd’s current CI 1335 pass; their two current-source CI boxes are restored. Completion is 25.17%, with 571/1036 sub-items and 39/461 parents; these restorations add no implementation units.

The kernel fixture profile regression is tracked in #173, and actual offline image packaging/guest execution remains #172. The full host suite continues while its first cancellation-fixture path failure is repaired. Exsh’s remaining CI failure is the unfinished frame and source/type proof in Exsh #4. Both in-guest EriX build generations and the Rust/LLVM rebuild inside EriX remain open.

Published the coordinated offline boot-tool inputs and final Rootd/Bootloader selections in [PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12). Bootloader’s current CI 184 and Rootd’s current CI 1335 pass; their two current-source CI boxes are restored. Completion is **25.17%**, with 571/1036 sub-items and 39/461 parents; these restorations add no implementation units. The kernel fixture profile regression is tracked in [#173](https://git.erikinkinen.fi/erix/integration/issues/173), and actual offline image packaging/guest execution remains [#172](https://git.erikinkinen.fi/erix/integration/issues/172). The full host suite continues while its first cancellation-fixture path failure is repaired. Exsh’s remaining CI failure is the unfinished frame and source/type proof in [Exsh #4](https://git.erikinkinen.fi/erix/exsh/issues/4). Both in-guest EriX build generations and the Rust/LLVM rebuild inside EriX remain open.
Author
Owner

The namespace-cancellation image build now reaches image preparation, where a boot-tool work directory overlaps its catalog source. The ownership check correctly refuses it; the placement fix is tracked in #172.

The separate local host run completed all 199 modules: 198 passed, and one cancellation fixture hit the socket-path limit tracked in #174. Latest CI passed Rust and Markdown, then exhausted the host-suite deadline near the end of the Python tests. The fixture correction and CI cost investigation are underway.

Completion remains 25.17%. Image and guest acceptance are still open.

The namespace-cancellation image build now reaches image preparation, where a boot-tool work directory overlaps its catalog source. The ownership check correctly refuses it; the placement fix is tracked in [#172](https://git.erikinkinen.fi/erix/integration/issues/172). The separate local host run completed all 199 modules: 198 passed, and one cancellation fixture hit the socket-path limit tracked in [#174](https://git.erikinkinen.fi/erix/integration/issues/174). Latest CI passed Rust and Markdown, then exhausted the host-suite deadline near the end of the Python tests. The fixture correction and CI cost investigation are underway. Completion remains **25.17%**. Image and guest acceptance are still open.
Author
Owner

Published a27acd3a6c fixes the long socket path in #174. All 14 changed module tests now pass locally and in CI; the rest of the CI host job is still running. The packaging directory fix for #172 is signed and awaiting focused checks.

#175 tracks the host-suite deadline. Its repair separates host tests into two jobs with the same test limits and checks complete coverage before starting the VM job. Exsh compiler-input tracing remains in implementation.

Completion remains 25.17%; no new image, guest or self-hosting result is claimed.

Published a27acd3a6cb4db13e821bb5cca28cb2ec0fda453 fixes the long socket path in [#174](https://git.erikinkinen.fi/erix/integration/issues/174). All 14 changed module tests now pass locally and in CI; the rest of the CI host job is still running. The packaging directory fix for [#172](https://git.erikinkinen.fi/erix/integration/issues/172) is signed and awaiting focused checks. [#175](https://git.erikinkinen.fi/erix/integration/issues/175) tracks the host-suite deadline. Its repair separates host tests into two jobs with the same test limits and checks complete coverage before starting the VM job. Exsh compiler-input tracing remains in implementation. Completion remains **25.17%**; no new image, guest or self-hosting result is claimed.
Author
Owner

The socket regression #174 is closed after a27 CI completed all 199 host modules and 2,198 cases. Its remaining integration stages are still running.

Published 8baabcb32f fixes the packaging directory overlap in #172. Its 27 focused controls pass; the original image and guest run are next. The separate host-shard repair remains under #175.

Completion remains 25.17%. These regression repairs add no phase checklist units.

The socket regression [#174](https://git.erikinkinen.fi/erix/integration/issues/174) is closed after a27 CI completed all 199 host modules and 2,198 cases. Its remaining integration stages are still running. Published 8baabcb32f54259cd8ebc3129289a8d798672de7 fixes the packaging directory overlap in [#172](https://git.erikinkinen.fi/erix/integration/issues/172). Its 27 focused controls pass; the original image and guest run are next. The separate host-shard repair remains under [#175](https://git.erikinkinen.fi/erix/integration/issues/175). Completion remains **25.17%**. These regression repairs add no phase checklist units.
Author
Owner

Offline image packaging now compiles the selected boot tool, signs and verifies the image, and launches QEMU. #172 is closed. The guest reaches the namespace-cancellation success marker and completes /tmp I/O, then fails during extended VFS checks; #176 tracks that remaining failure. The complete VM scenario and in-EriX build demonstrations remain open.

The affected kernel feature-selection self-test also passed in CI, closing #173. The host-test split for #175 is implemented and undergoing its focused and full-coverage checks. These regression repairs add no phase checklist units; completion remains 25.17%.

Offline image packaging now compiles the selected boot tool, signs and verifies the image, and launches QEMU. [#172](https://git.erikinkinen.fi/erix/integration/issues/172) is closed. The guest reaches the namespace-cancellation success marker and completes `/tmp` I/O, then fails during extended VFS checks; [#176](https://git.erikinkinen.fi/erix/integration/issues/176) tracks that remaining failure. The complete VM scenario and in-EriX build demonstrations remain open. The affected kernel feature-selection self-test also passed in CI, closing [#173](https://git.erikinkinen.fi/erix/integration/issues/173). The host-test split for [#175](https://git.erikinkinen.fi/erix/integration/issues/175) is implemented and undergoing its focused and full-coverage checks. These regression repairs add no phase checklist units; completion remains 25.17%.
Author
Owner

The fix for the host-suite timeout is pushed in 8dcca3f2 and tracked in PR #12. Host tests use two separate jobs with the existing deadlines and an exact coverage check before VM testing. Complete shard runs and CI remain pending.

Phase completion remains 25.17%; this regression repair adds no checklist credit.

The fix for [the host-suite timeout](https://git.erikinkinen.fi/erix/integration/issues/175) is pushed in [8dcca3f2](https://git.erikinkinen.fi/erix/integration/commit/8dcca3f296330c1140bf4fefbea2c9475c92d32e) and tracked in [PR #12](https://git.erikinkinen.fi/erix/integration/pulls/12). Host tests use two separate jobs with the existing deadlines and an exact coverage check before VM testing. Complete shard runs and CI remain pending. Phase completion remains **25.17%**; this regression repair adds no checklist credit.
Author
Owner

The host-suite split passed all 201 modules / 2,219 tests in CI, including the downstream coverage check. 8501d3f5 fixes the later source-layout regression; CI 2954 is running.

The fleet remains at 75 passing current heads, with Integration and Exsh still failing. Phase completion remains 25.17%; regression repairs add no checklist credit.

The [host-suite split](https://git.erikinkinen.fi/erix/integration/issues/175) passed all **201 modules / 2,219 tests** in CI, including the downstream coverage check. [8501d3f5](https://git.erikinkinen.fi/erix/integration/commit/8501d3f52a8ae6019c9db9572da3c9577fab49f5) fixes the later [source-layout regression](https://git.erikinkinen.fi/erix/integration/issues/177); [CI 2954](https://git.erikinkinen.fi/erix/integration/actions/runs/2954) is running. The fleet remains at 75 passing current heads, with Integration and Exsh still failing. Phase completion remains **25.17%**; regression repairs add no checklist credit.
Author
Owner

Integration now retains the catalog-selected Boot-tool inputs through image assembly (#178). A separate cancellation-test assertion that rejected valid forced retirement is also fixed, with a real SIGTERM-ignoring child as coverage (#179). Both changes are signed and pushed through 5eed43c1.

CI 2951's complete 201-module/2,219-case host result is confirmed. The current fleet has 75 successful repositories, Exsh failing and Integration's repair running. Full guest acceptance, both in-EriX build generations and rebuilding Rust/LLVM inside EriX remain open.

Weighted checklist completion remains 25.17%; these regression repairs add no checklist units.

Integration now retains the catalog-selected Boot-tool inputs through image assembly ([#178](https://git.erikinkinen.fi/erix/integration/issues/178)). A separate cancellation-test assertion that rejected valid forced retirement is also fixed, with a real SIGTERM-ignoring child as coverage ([#179](https://git.erikinkinen.fi/erix/integration/issues/179)). Both changes are signed and pushed through [5eed43c1](https://git.erikinkinen.fi/erix/integration/commit/5eed43c1c0931740f1fe7719eaacdffa3a261445). CI 2951's complete 201-module/2,219-case host result is confirmed. The current fleet has 75 successful repositories, Exsh failing and Integration's repair running. Full guest acceptance, both in-EriX build generations and rebuilding Rust/LLVM inside EriX remain open. Weighted checklist completion remains 25.17%; these regression repairs add no checklist units.
Author
Owner

Published the optional Exsh tracing backend in bb3b6ac0, with the matching prose classifications in 8166288b. Compiler input tracing and the six Exsh frame-analysis timeouts remain open. The namespace refusal changes are undergoing their strict component checks.

Progress remains 25.17% weighted, with 571/1,036 sub-items and 39/461 whole items accepted. These repairs add no completion units. Neither in-EriX build generation nor the Rust/LLVM rebuild has been demonstrated.

Published the optional Exsh tracing backend in [bb3b6ac0](https://git.erikinkinen.fi/erix/exsh/commit/bb3b6ac04a49919dfd1df7ebab7604b109c85b20), with the matching prose classifications in 8166288b. Compiler input tracing and the six Exsh frame-analysis timeouts remain open. The namespace refusal changes are undergoing their strict component checks. Progress remains **25.17%** weighted, with **571/1,036** sub-items and **39/461** whole items accepted. These repairs add no completion units. Neither in-EriX build generation nor the Rust/LLVM rebuild has been demonstrated.
Author
Owner

Published the coordinated namespace changes in LibVfs feb949af, Rootd b4c7c4b7 and Vfsd 00d6a73c. Expected application refusals can now retain the caller’s result after confirmed disposal; independent failures remain strict. The new hosted producer/client test passes, and the next guest image is being prepared for #176.

The separate CI setup stall is tracked in #180 and is being investigated on the runner host. Exsh’s solver optimization is undergoing its full checker suite. Both in-EriX build generations and the external toolchain rebuild remain open.

Published the coordinated namespace changes in LibVfs feb949af, Rootd b4c7c4b7 and Vfsd 00d6a73c. Expected application refusals can now retain the caller’s result after confirmed disposal; independent failures remain strict. The new hosted producer/client test passes, and the next guest image is being prepared for #176. The separate CI setup stall is tracked in #180 and is being investigated on the runner host. Exsh’s solver optimization is undergoing its full checker suite. Both in-EriX build generations and the external toolchain rebuild remain open.
Author
Owner

Accepted the complete CRC component audit, including both storage consumers. Recalculated progress: 25.20% weighted, 40/461 whole items and 574/1036 sub-items. The checklist and all section weights are reconciled.

Cancellation regression 179 is closed after the complete 201-module, 2,229-case host suite passes. Runner setup incident 180 remains open while newer revisions reach checkout. The coherent namespace image and guest run are now executing.

The Exsh proof-reuse experiment still reaches the original 60-second deadline on the captured compiler input. It stays unpublished; the next change targets repeated static instruction decoding identified in those profiles. Full in-EriX builds and rebuilding Rust/LLVM remain outstanding.

Accepted the complete [CRC component audit](https://git.erikinkinen.fi/erix/lib-crc/issues/1), including both storage consumers. Recalculated progress: **25.20% weighted**, **40/461 whole items** and **574/1036 sub-items**. The checklist and all section weights are reconciled. [Cancellation regression 179](https://git.erikinkinen.fi/erix/integration/issues/179) is closed after the complete 201-module, 2,229-case host suite passes. [Runner setup incident 180](https://git.erikinkinen.fi/erix/integration/issues/180) remains open while newer revisions reach checkout. The coherent namespace image and guest run are now executing. The Exsh proof-reuse experiment still reaches the original 60-second deadline on the captured compiler input. It stays unpublished; the next change targets repeated static instruction decoding identified in those profiles. Full in-EriX builds and rebuilding Rust/LLVM remain outstanding.
Author
Owner

The namespace manual is published in Docs 876e227, with the scoped-refusal contract and six additional LibVfs API routes. Integration 9155e915 records the exact documentation classifications. CI 2963 now reaches the VM catalog after both host shards and helper checks pass, meeting the remaining criteria for the host split and the source-layout fix. Weighted checklist progress is 25.19%, with 40 accepted parents and 573 completed sub-items. Only the new Docs revision’s CI item reopens: its PDF build passes, publication times out, and Markdown has not reached checkout. Earlier results remain retained.

The namespace manual is published in [Docs 876e227](https://git.erikinkinen.fi/erix/docs/commit/876e227ae9de39b342c6ae56c12ac88d4cef3fe3), with the scoped-refusal contract and six additional LibVfs API routes. [Integration 9155e915](https://git.erikinkinen.fi/erix/integration/commit/9155e91535c798aaf2ed23cdba6cf4b0a39ec752) records the exact documentation classifications. [CI 2963](https://git.erikinkinen.fi/erix/integration/actions/runs/2963) now reaches the VM catalog after both host shards and helper checks pass, meeting the remaining criteria for [the host split](https://git.erikinkinen.fi/erix/integration/issues/175) and [the source-layout fix](https://git.erikinkinen.fi/erix/integration/issues/177). Weighted checklist progress is 25.19%, with 40 accepted parents and 573 completed sub-items. Only the new Docs revision’s CI item reopens: its PDF build passes, publication times out, and Markdown has not reached checkout. Earlier results remain retained.
Author
Owner

Published original service-source declarations, including explicit generated-source handling and matching cache identities.

The host-suite deadline and source-layout blockers, #175 and #177, are closed: the affected workflow passed both host shards and reached VM checks. The active VM job and the current Docs attempt remain in progress.

Published [original service-source declarations](https://git.erikinkinen.fi/erix/integration/commit/e6402f05d640fd1fc4fe58d4014a06303f042085), including explicit generated-source handling and matching cache identities. The host-suite deadline and source-layout blockers, [#175](https://git.erikinkinen.fi/erix/integration/issues/175) and [#177](https://git.erikinkinen.fi/erix/integration/issues/177), are closed: the affected workflow passed both host shards and reached VM checks. The active VM job and the current Docs attempt remain in progress.
Author
Owner

Published native shell help, basename/dirname and fresh additional-thread TLS. Their manual documentation is published, and Integration catalog/scenario adoption is in progress. The help specification is complete; its implementation and harness requirements remain separately tracked. Native manual reading is underway in Coreutils #4.

Published native [shell help](https://git.erikinkinen.fi/erix/exsh/commit/78691e6730bf8326000d5814af58c9be659e617b), [basename/dirname](https://git.erikinkinen.fi/erix/coreutils/issues/3) and [fresh additional-thread TLS](https://git.erikinkinen.fi/erix/posixd/commit/edeff8c73f56cb79d9f463671b6570040a772602). Their [manual documentation](https://git.erikinkinen.fi/erix/docs/commit/2968e728ec2be97fd4cc0afb9951b45337a8cf11) is published, and Integration catalog/scenario adoption is in progress. The help specification is complete; its implementation and harness requirements remain separately tracked. Native manual reading is underway in [Coreutils #4](https://git.erikinkinen.fi/erix/coreutils/issues/4).
Author
Owner

Shell help, the native manual reader and all 23 Coreutils command pages are now published. Integration has the initial read-only manual-store installer and guest scenarios. Native-console cursor positioning/display erase is also published for pager redraw. Terminal sizing, complete manifest adoption and Exsh/builtin manuals are underway. Full guest builds, including rebuilding Rust/LLVM inside EriX, remain required.

Shell help, the native manual reader and all 23 Coreutils command pages are now published. Integration has the initial read-only manual-store installer and guest scenarios. Native-console cursor positioning/display erase is also published for pager redraw. Terminal sizing, complete manifest adoption and Exsh/builtin manuals are underway. Full guest builds, including rebuilding Rust/LLVM inside EriX, remain required.
Author
Owner

Offline manuals now compose 23 utility pages, the shell overview and 33 builtin/language-topic pages through explicit component manifests. Image adoption is underway; the selected utility corpus is already installed. Extop now has its own source-bound operator page. The checklist exposes completed corpus and installation work under the remaining whole-inventory requirements; progress is 26.51%, with 44 parents accepted.

Offline manuals now compose 23 utility pages, the shell overview and 33 builtin/language-topic pages through explicit component manifests. Image adoption is underway; the selected utility corpus is already installed. Extop now has its own source-bound operator page. The checklist exposes completed corpus and installation work under the remaining whole-inventory requirements; progress is 26.51%, with 44 parents accepted.
Author
Owner

The offline inventory now covers all 27 ordinary command names and 33 Exsh topics. Integration 6abd74c7 composes those 60 pages for both image profiles. Build/developer command manuals, API coverage and guest resolution remain open.

Physical-row paging and UTF-8 cell accounting are published in Coreutils f9eb4439 and LibConsole e8faed60; Docs 5870fe51 describes their shared behavior. Native SHA-2 support and authenticated owner-driven resize are in progress. The checklist is now 26.61% complete, with 578/1045 sub-items; whole-item acceptance remains 44/461.

The offline inventory now covers all 27 ordinary command names and 33 Exsh topics. Integration `6abd74c7` composes those 60 pages for both image profiles. Build/developer command manuals, API coverage and guest resolution remain open. Physical-row paging and UTF-8 cell accounting are published in Coreutils `f9eb4439` and LibConsole `e8faed60`; Docs `5870fe51` describes their shared behavior. Native SHA-2 support and authenticated owner-driven resize are in progress. The checklist is now 26.61% complete, with 578/1045 sub-items; whole-item acceptance remains 44/461.
Author
Owner

The native SHA-2 backend is published at erix/sha2-tool@140f0ef8, using shared file/lease and stream clients from LibCli and LibStdio. Coreutils now uses those clients too. The checklist records native startup/input binding and streaming hashes as implemented. Image packaging, guest execution and complete build acceptance remain open.

The native SHA-2 backend is published at erix/sha2-tool@140f0ef8, using shared file/lease and stream clients from LibCli and LibStdio. Coreutils now uses those clients too. The checklist records native startup/input binding and streaming hashes as implemented. Image packaging, guest execution and complete build acceptance remain open.
Author
Owner

Native Sha2 command packaging and the owner-driven manual fixture are now wired in Integration 9c90cdf6 and Rootd 6d7e3ad2. Sha2 keeps its exact file READ ceiling; the pager observes terminal state while Rootd retains resize ownership. Matching-image acceptance remains tracked in Ttyd#4.

Native Sha2 command packaging and the owner-driven manual fixture are now wired in [Integration 9c90cdf6](https://git.erikinkinen.fi/erix/integration/commit/9c90cdf64d274c95c00d5168400f765b2fbb9b3c) and [Rootd 6d7e3ad2](https://git.erikinkinen.fi/erix/rootd/commit/6d7e3ad2ca9635871a3e1c14fd0eea315658dc4c). Sha2 keeps its exact file READ ceiling; the pager observes terminal state while Rootd retains resize ownership. Matching-image acceptance remains tracked in [Ttyd#4](https://git.erikinkinen.fi/erix/ttyd/issues/4).
Author
Owner

Native SHA-2 packaging and the owner-driven manual controller are published with matching Rootd support. The SHA workload now checks SHA-256/SHA-512 through file, redirected and piped input, denied reads followed by an allowed input, and duplicate stdin selection (PR #12). Boot-tool #6 now has original operand provenance; Launchd #26 tracks the narrowed broker needed for its native backend. The checklist separates implemented SHA packaging producers from image and guest acceptance.

Native SHA-2 packaging and the owner-driven manual controller are published with matching Rootd support. The SHA workload now checks SHA-256/SHA-512 through file, redirected and piped input, denied reads followed by an allowed input, and duplicate stdin selection ([PR #12](https://git.erikinkinen.fi/erix/integration/pulls/12)). [Boot-tool #6](https://git.erikinkinen.fi/erix/boot-tool/issues/6) now has original operand provenance; [Launchd #26](https://git.erikinkinen.fi/erix/launchd/issues/26) tracks the narrowed broker needed for its native backend. The checklist separates implemented SHA packaging producers from image and guest acceptance.
Author
Owner

The snapshot profiler and persistence change is published and selected by both source catalogs. It reduced mean snapshot time by 29.8% on the measured 159-object local workload while preserving every file flush. See the profiling guide for the measurements and scope. Full guest builds remain open.

The [snapshot profiler and persistence change](https://git.erikinkinen.fi/erix/integration/commit/e1350dac4837fbf344056fa5cbf513cfcabb008b) is published and selected by both source catalogs. It reduced mean snapshot time by 29.8% on the measured 159-object local workload while preserving every file flush. See the [profiling guide](https://git.erikinkinen.fi/erix/integration/src/commit/e1350dac4837fbf344056fa5cbf513cfcabb008b/docs/source-snapshot-performance.md) for the measurements and scope. Full guest builds remain open.
Author
Owner

The GPT writer and explicit backup parser are published. Boot-tool’s image initializer, the product image recipe and manual changes are committed locally; coordinated publication is pending. This removes sgdisk creation and geometry queries from the recipe. Partition-payload assembly, native filesystem formatting, both complete guest build generations and the Rust/LLVM rebuild remain open.

The [GPT writer and explicit backup parser](https://git.erikinkinen.fi/erix/lib-partition/pulls/2) are published. [Boot-tool’s image initializer](https://git.erikinkinen.fi/erix/boot-tool/issues/7), the product image recipe and manual changes are committed locally; coordinated publication is pending. This removes sgdisk creation and geometry queries from the recipe. Partition-payload assembly, native filesystem formatting, both complete guest build generations and the Rust/LLVM rebuild remain open.
Author
Owner

Partition-payload assembly and generated Cargo lock inputs are implemented and committed locally, including their component and technical-manual documentation. The image recipe now assembles completed partition files through one publication; lock export retains the actual completing owner and keeps generated files separate from original Git trees.

Coordinated publication is pending. Full guest builds, native filesystem formatting, portable dependency metadata and the Rust/LLVM rebuild remain open.

[Partition-payload assembly](https://git.erikinkinen.fi/erix/boot-tool/issues/8) and [generated Cargo lock inputs](https://git.erikinkinen.fi/erix/integration/issues/192) are implemented and committed locally, including their component and technical-manual documentation. The image recipe now assembles completed partition files through one publication; lock export retains the actual completing owner and keeps generated files separate from original Git trees. Coordinated publication is pending. Full guest builds, native filesystem formatting, portable dependency metadata and the Rust/LLVM rebuild remain open.
Author
Owner

FAT32 creation is implemented locally across Boot-tool, Integration and Fatd,
with the matching manual update. The three ESP recipes now select the original
packaged producer, explicit format values and exact file inputs:
Boot-tool#9.

Cargo graph export is
also committed locally. Work on original Git object transport
adds fresh offline source and Cargo preparation. These changes still need
coherent publication and the complete in-EriX builds, including Rust/LLVM.

FAT32 creation is implemented locally across Boot-tool, Integration and Fatd, with the matching manual update. The three ESP recipes now select the original packaged producer, explicit format values and exact file inputs: [Boot-tool#9](https://git.erikinkinen.fi/erix/boot-tool/issues/9). [Cargo graph export](https://git.erikinkinen.fi/erix/integration/issues/193) is also committed locally. Work on [original Git object transport](https://git.erikinkinen.fi/erix/integration/issues/194) adds fresh offline source and Cargo preparation. These changes still need coherent publication and the complete in-EriX builds, including Rust/LLVM.
Author
Owner

Signed local changes add original Git object transport and empty journaled ext4 creation. Remaining work includes typed product-file population, guest tool installation and the full EriX and external-toolchain builds inside EriX.

Signed local changes add [original Git object transport](https://git.erikinkinen.fi/erix/integration/issues/194) and [empty journaled ext4 creation](https://git.erikinkinen.fi/erix/boot-tool/issues/10). Remaining work includes typed product-file population, guest tool installation and the full EriX and external-toolchain builds inside EriX.
Author
Owner

File assembly has host/native compiler and strict-lint failures tracked in Boot-tool#12. Source corrections for the alignment predicate, read-owner import and typed host error conversion are included in the current product-population work.

File assembly has host/native compiler and strict-lint failures tracked in [Boot-tool#12](https://git.erikinkinen.fi/erix/boot-tool/issues/12). Source corrections for the alignment predicate, read-owner import and typed host error conversion are included in the current product-population work.
Author
Owner

Signed local checkpoints now contain the offline preparation command and populated ext4 product route. The command prepares fresh Git and locked Cargo results from explicit inputs. The image route replaces imported product formatting and installation with typed entries, explicit inode metadata and a stable tree plan.

Explicit SHA-2 artifact verification tracks the next coordinated change: exact length and digest checks, file and recipient-stream read limits, genuine EOF probes and input retirement before verdicts. It includes the shared protocol, provider, profile and image-scenario work.

Signed local checkpoints now contain the [offline preparation command](https://git.erikinkinen.fi/erix/integration/issues/195) and [populated ext4 product route](https://git.erikinkinen.fi/erix/boot-tool/issues/11). The command prepares fresh Git and locked Cargo results from explicit inputs. The image route replaces imported product formatting and installation with typed entries, explicit inode metadata and a stable tree plan. [Explicit SHA-2 artifact verification](https://git.erikinkinen.fi/erix/sha2-tool/issues/6) tracks the next coordinated change: exact length and digest checks, file and recipient-stream read limits, genuine EOF probes and input retirement before verdicts. It includes the shared protocol, provider, profile and image-scenario work.
Author
Owner

Signed local Boot-tool and Integration checkpoints now bind native assembly reads to the declared source length and check real EOF without reading an extra byte, including empty and mapped sources. SHA workspace selections also account for the verifier's independent failure records.

The shared artifact verifier and shell/service handoff are still being implemented. That handoff preserves original streams, terminal and working-directory ownership across exec; image population uses the same bounded input path.

Signed local Boot-tool and Integration checkpoints now bind native assembly reads to the declared source length and check real EOF without reading an extra byte, including empty and mapped sources. SHA workspace selections also account for the verifier's independent failure records. The shared [artifact verifier](https://git.erikinkinen.fi/erix/sha2-tool/issues/6) and shell/service handoff are still being implemented. That handoff preserves original streams, terminal and working-directory ownership across `exec`; [image population](https://git.erikinkinen.fi/erix/boot-tool/issues/11) uses the same bounded input path.
Author
Owner

The native verifier now limits READ on the original receiver and checks EOF without consuming extra data. Verdicts wait for positive input retirement. Signed local changes also preserve the original streams, terminal and cwd across exec, and register verifier workflows for both seats and image profiles. Coherent deployment remains open; SHA verification tracks the coordinated work.

The native verifier now limits READ on the original receiver and checks EOF without consuming extra data. Verdicts wait for positive input retirement. Signed local changes also preserve the original streams, terminal and cwd across exec, and register verifier workflows for both seats and image profiles. Coherent deployment remains open; [SHA verification](https://git.erikinkinen.fi/erix/sha2-tool/issues/6) tracks the coordinated work.
Author
Owner

Exsh#27 tracks faithful closed and sparse descriptor inheritance. It covers explicitly closed standard descriptors and surviving descriptors such as fd3/fd4 through ordinary launches and exec, with counted storage and the original stream lifetimes.

[Exsh#27](https://git.erikinkinen.fi/erix/exsh/issues/27) tracks faithful closed and sparse descriptor inheritance. It covers explicitly closed standard descriptors and surviving descriptors such as fd3/fd4 through ordinary launches and exec, with counted storage and the original stream lifetimes.
Author
Owner

Procd #13 specifies the coordinated receiver layout for descriptor inheritance. Ordinary native commands reserve child receiver slot 4 outside the delegated capability range; local installer-grant coordinates keep their existing meaning.

[Procd #13](https://git.erikinkinen.fi/erix/procd/issues/13) specifies the coordinated receiver layout for [descriptor inheritance](https://git.erikinkinen.fi/erix/exsh/issues/27). Ordinary native commands reserve child receiver slot 4 outside the delegated capability range; local installer-grant coordinates keep their existing meaning.
Author
Owner

Native byte comparison is tracked in Coreutils #11. The scope includes streaming comparison, exact READ grants, command/manual packaging and guest workflows using existing capability ceilings.

Native byte comparison is tracked in [Coreutils #11](https://git.erikinkinen.fi/erix/coreutils/issues/11). The scope includes streaming comparison, exact READ grants, command/manual packaging and guest workflows using existing capability ceilings.
Author
Owner

Native binary string formatting is tracked in Coreutils #12. It adds NUL/octal output, %b and streaming of large string results through the existing original streams, with matching manuals and guest workflows. Numeric formatting remains a separate gap.

Native binary string formatting is tracked in [Coreutils #12](https://git.erikinkinen.fi/erix/coreutils/issues/12). It adds NUL/octal output, `%b` and streaming of large string results through the existing original streams, with matching manuals and guest workflows. Numeric formatting remains a separate gap.
Author
Owner

Integer printf formatting and diagnostics are tracked in Coreutils#13. The scope covers decimal, octal and hexadecimal conversions, checked field widths and precision, and recoverable errors through the original stdout/stderr streams.

Integer printf formatting and diagnostics are tracked in [Coreutils#13](https://git.erikinkinen.fi/erix/coreutils/issues/13). The scope covers decimal, octal and hexadecimal conversions, checked field widths and precision, and recoverable errors through the original stdout/stderr streams.
Author
Owner

Native head/tail stream selection tracks byte prefixes/suffixes and start-relative line/byte output through the existing standard streams.

[Native head/tail stream selection](https://git.erikinkinen.fi/erix/coreutils/issues/14) tracks byte prefixes/suffixes and start-relative line/byte output through the existing standard streams.
Author
Owner

The process heap work is tracked in LibCstd #8. It adds one explicitly supplied allocator shared by C and Rust, with a native client and genuine thread errno. Anonymous growth, general C startup and the full guest toolchain rebuild remain separate acceptance requirements.

The process heap work is tracked in [LibCstd #8](https://git.erikinkinen.fi/erix/lib-cstd/issues/8). It adds one explicitly supplied allocator shared by C and Rust, with a native client and genuine thread errno. Anonymous growth, general C startup and the full guest toolchain rebuild remain separate acceptance requirements.
Author
Owner

Ordinary C startup is tracked in LibCstd #9, following the shared process heap. The scope covers authenticated launch arguments and environment, a real C main entry, exit handlers and process termination with retained backing. Full sysroot and imported-tool acceptance remain separate requirements.

Ordinary C startup is tracked in [LibCstd #9](https://git.erikinkinen.fi/erix/lib-cstd/issues/9), following the [shared process heap](https://git.erikinkinen.fi/erix/lib-cstd/issues/8). The scope covers authenticated launch arguments and environment, a real C main entry, exit handlers and process termination with retained backing. Full sysroot and imported-tool acceptance remain separate requirements.
Author
Owner

LibCstd #10 tracks strdup and strndup over the shared process heap, including headers, native exports and ordinary C consumer coverage. It builds on the heap and C startup.

[LibCstd #10](https://git.erikinkinen.fi/erix/lib-cstd/issues/10) tracks `strdup` and `strndup` over the shared process heap, including headers, native exports and ordinary C consumer coverage. It builds on [the heap](https://git.erikinkinen.fi/erix/lib-cstd/issues/8) and [C startup](https://git.erikinkinen.fi/erix/lib-cstd/issues/9).
Author
Owner

LibCstd #11 tracks strtok_r with caller-owned parsing state, original runtime symbols and C consumer coverage. It extends the string interfaces needed by native C programs.

[LibCstd #11](https://git.erikinkinen.fi/erix/lib-cstd/issues/11) tracks `strtok_r` with caller-owned parsing state, original runtime symbols and C consumer coverage. It extends the string interfaces needed by native C programs.
Author
Owner

The source changes for caller-owned strtok_r, its C startup fixture and the image source roles are committed locally. Startup descriptions also carry their stream ownership kind through Launchd and Procd, with matching cleanup in Extop, Coreutils, Boot and Sha2-tool. The master checklist now includes the completed source work for tokenization and owned string copies.

The source changes for caller-owned `strtok_r`, its C startup fixture and the image source roles are committed locally. Startup descriptions also carry their stream ownership kind through Launchd and Procd, with matching cleanup in Extop, Coreutils, Boot and Sha2-tool. The master checklist now includes the completed source work for tokenization and owned string copies.
Author
Owner

Environment mutation is tracked in Mutate the process environment on the shared heap. The scope includes current-table getenv, caller-owned putenv strings, atomic heap failures and ownership-safe replacement.

Environment mutation is tracked in [Mutate the process environment on the shared heap](https://git.erikinkinen.fi/erix/lib-cstd/issues/12). The scope includes current-table getenv, caller-owned putenv strings, atomic heap failures and ownership-safe replacement.
Author
Owner

Process environment access and mutation are implemented, with matching native C probes, manual changes and Integration producer/oracle updates. The checklist now records that implementation separately from its pending native acceptance. Both completion figures have been recalculated from the checklists.

[Process environment access and mutation](https://git.erikinkinen.fi/erix/lib-cstd/issues/12) are implemented, with matching native C probes, manual changes and Integration producer/oracle updates. The checklist now records that implementation separately from its pending native acceptance. Both completion figures have been recalculated from the checklists.
Author
Owner

Published the namespaced C/Rust descriptor I/O source milestone, including explicit original-realm binding, independent concurrent call storage, root-only provider linkage, headers and the updated manual/source graph. Design. The adapter parent remains open.

Conventional aliases, libc signal delivery, compatibility startup and guest acceptance remain open.

Published the namespaced C/Rust descriptor I/O source milestone, including explicit original-realm binding, independent concurrent call storage, root-only provider linkage, headers and the updated manual/source graph. [Design](https://git.erikinkinen.fi/erix/lib-cstd/issues/13). The adapter parent remains open. Conventional aliases, libc signal delivery, compatibility startup and guest acceptance remain open.
Author
Owner

The C file-interface source milestone is published across Cstd, Posixd, the manual and Integration. It adds 35 namespaced operations through the existing realm, with independent request/vector snapshots and an additional native C workload.

The complete file-adapter requirement remains open for timestamp/cwd support and the conventional ABI. The EriX and external toolchain builds inside EriX also remain open.

The [C file-interface source milestone](https://git.erikinkinen.fi/erix/lib-cstd/issues/14) is published across Cstd, Posixd, the manual and Integration. It adds 35 namespaced operations through the existing realm, with independent request/vector snapshots and an additional native C workload. The complete file-adapter requirement remains open for timestamp/cwd support and the conventional ABI. The EriX and external toolchain builds inside EriX also remain open.
Author
Owner

Published the coordinated file timestamp source, including signed values, Now/Omit, original-object policy, conditional filesystem updates and the C consumer. Both catalogs select the matching components and manual.

Current-directory support and the complete conventional ABI remain part of the file-adapter work. The required EriX and external toolchain builds inside EriX remain open.

Published the coordinated [file timestamp source](https://git.erikinkinen.fi/erix/posixd/issues/43), including signed values, Now/Omit, original-object policy, conditional filesystem updates and the C consumer. Both catalogs select the matching components and manual. Current-directory support and the complete conventional ABI remain part of the [file-adapter work](https://git.erikinkinen.fi/erix/lib-cstd/issues/14). The required EriX and external toolchain builds inside EriX remain open.
Author
Owner

The rooted filesystem scope and original-source Rustdoc producer are now implemented and selected in Integration. The Exsh profiler also identified redundant scalar transfers; the change skips unchanged state after the original checks. Guest execution, stack measurements and API regeneration remain open. The full EriX build, second generation and external Rust/LLVM rebuild inside EriX are still required.

The [rooted filesystem scope](https://git.erikinkinen.fi/erix/launchd/issues/28) and [original-source Rustdoc producer](https://git.erikinkinen.fi/erix/integration/issues/197) are now implemented and selected in [Integration](https://git.erikinkinen.fi/erix/integration/commit/acdeaf70b2b83143e9e4bb911ec67be45582a11c). The Exsh profiler also identified redundant scalar transfers; [the change](https://git.erikinkinen.fi/erix/exsh/commit/86fa48de084c95c816fcf06c3bee83aa12d645bd) skips unchanged state after the original checks. Guest execution, stack measurements and API regeneration remain open. The full EriX build, second generation and external Rust/LLVM rebuild inside EriX are still required.
Author
Owner

Mediated directory iteration now has its C/Rust interfaces, backend, C workload, packaging and manual changes in the feature branches. The Rustdoc producer has also completed its native-target fixture. Matching library references, native workload acceptance and the full in-EriX builds remain open.

[Mediated directory iteration](https://git.erikinkinen.fi/erix/lib-cstd/issues/15) now has its C/Rust interfaces, backend, C workload, packaging and manual changes in the feature branches. The [Rustdoc producer](https://git.erikinkinen.fi/erix/integration/issues/197) has also completed its native-target fixture. Matching library references, native workload acceptance and the full in-EriX builds remain open.
Author
Owner

Namespaced poll/select is implemented across LibCstd, Posixd, the native producer and the manual. The design covers counted caller storage, mediated timeouts and independent original-call retirement.

Native C/VM acceptance, imported-tool use and API-reference regeneration remain open. Conventional aliases and C signal-handler delivery also remain pending.

Namespaced poll/select is implemented across [LibCstd](https://git.erikinkinen.fi/erix/lib-cstd/commit/5ee02280128f6ba583a5f378866d3861ab48214b), [Posixd](https://git.erikinkinen.fi/erix/posixd/commit/e048a034c4b335551f7f3d3b81a11d44375e0422), [the native producer](https://git.erikinkinen.fi/erix/integration/commit/eb37be0a42f61c89404c7328271268ddb1fdb683) and [the manual](https://git.erikinkinen.fi/erix/docs/commit/7c6a32b52a6e5e4af8e427075130764339dfe82c). [The design](https://git.erikinkinen.fi/erix/lib-cstd/issues/16) covers counted caller storage, mediated timeouts and independent original-call retirement. Native C/VM acceptance, imported-tool use and API-reference regeneration remain open. Conventional aliases and C signal-handler delivery also remain pending.
Author
Owner

Added namespaced C pipe creation through the existing counted pipe service. The C fixture creates nonblocking and default pairs, reuses the byte/EOF/close checks and keeps the existing ring and descriptor capacity.

C runtime, Posixd, native workload, manual.

Added namespaced C pipe creation through the existing counted pipe service. The C fixture creates nonblocking and default pairs, reuses the byte/EOF/close checks and keeps the existing ring and descriptor capacity. [C runtime](https://git.erikinkinen.fi/erix/lib-cstd/pulls/3), [Posixd](https://git.erikinkinen.fi/erix/posixd/pulls/5), [native workload](https://git.erikinkinen.fi/erix/integration/pulls/12), [manual](https://git.erikinkinen.fi/erix/docs/pulls/4).
Author
Owner

The six regenerated API references now include the C file, pipe and readiness interfaces. Generation and an independent second conversion completed while the original producers retained their sources and JSON outputs.

The native command owner also retains failed status publication on its original invocation and handles cancellation after completed retirement. The C runtime and documentation builds now select these fixes through the coordinated consumers. Guest C execution and the complete build inside EriX remain outstanding.

The six [regenerated API references](https://git.erikinkinen.fi/erix/docs/commit/91374fb0a139cee1d4f346ce2d25fd08eae8e8f3) now include the C file, pipe and readiness interfaces. Generation and an independent second conversion completed while the original producers retained their sources and JSON outputs. The [native command owner](https://git.erikinkinen.fi/erix/integration/commit/7bf80c35d2b5a950d6525418a7e0487bffad95ba) also retains failed status publication on its original invocation and handles cancellation after completed retirement. The C runtime and documentation builds now select these fixes through the [coordinated consumers](https://git.erikinkinen.fi/erix/integration/commit/fbe198a23ea9adc65df0ca01042daadfc4f84422). Guest C execution and the complete build inside EriX remain outstanding.
Author
Owner

Caller-owned multibyte conversion now has its core, C runtime/header, original-source C consumer and both heap-profile producers. The checklist records those three completed source scopes. Native/VM execution, the new API reference and upstream/conventional-interface coverage remain open. Related work: conversion, C runtime PR, Posixd PR, Integration PR and manual PR.

Caller-owned multibyte conversion now has its core, C runtime/header, original-source C consumer and both heap-profile producers. The checklist records those three completed source scopes. Native/VM execution, the new API reference and upstream/conventional-interface coverage remain open. Related work: [conversion](https://git.erikinkinen.fi/erix/lib-cstd/issues/17), [C runtime PR](https://git.erikinkinen.fi/erix/lib-cstd/pulls/3), [Posixd PR](https://git.erikinkinen.fi/erix/posixd/pulls/5), [Integration PR](https://git.erikinkinen.fi/erix/integration/pulls/12) and [manual PR](https://git.erikinkinen.fi/erix/docs/pulls/4).
Author
Owner

The checklist now separates completed time arithmetic and native clock mechanisms from the remaining C runtime, conventional interfaces and end-to-end acceptance. See clock observations and owned sleep for the provider changes.

The checklist now separates completed time arithmetic and native clock mechanisms from the remaining C runtime, conventional interfaces and end-to-end acceptance. See [clock observations and owned sleep](https://git.erikinkinen.fi/erix/lib-cstd/issues/18) for the provider changes.
Author
Owner

Published the time/sleep bridge and the native restricted terminal-control route. The checklist now records the completed source scopes, with Phase 6 at 22.74% and alpha 1 at 27.62%. The C terminal adapters, complete termios support and full EriX and toolchain builds inside EriX remain open.

Published the [time/sleep bridge](https://git.erikinkinen.fi/erix/lib-cstd/issues/18) and the native [restricted terminal-control route](https://git.erikinkinen.fi/erix/ttyd/issues/5). The checklist now records the completed source scopes, with Phase 6 at 22.74% and alpha 1 at 27.62%. The [C terminal adapters](https://git.erikinkinen.fi/erix/lib-cstd/issues/19), complete termios support and full EriX and toolchain builds inside EriX remain open.
Author
Owner

Published the complete source path for C terminal identification and window controls, including the real-PTY workload and manual. The checklist now separates that implemented slice from full termios: Phase 6 is 22.75%, alpha 1 is 27.63%. Native/VM acceptance and both full EriX guest builds, including the external Rust/LLVM rebuild, remain open.

Published the complete source path for [C terminal identification and window controls](https://git.erikinkinen.fi/erix/lib-cstd/issues/19), including the real-PTY workload and manual. The checklist now separates that implemented slice from full termios: Phase 6 is 22.75%, alpha 1 is 27.63%. Native/VM acceptance and both full EriX guest builds, including the external Rust/LLVM rebuild, remain open.
Author
Owner

Published caller-owned termios parameters and speed accessors, with build and manual companions. The checklist now separates that completed dependency from native attributes, mediated operations, queue/timing behavior and foreground groups needed for full termios.

Published [caller-owned termios parameters and speed accessors](https://git.erikinkinen.fi/erix/lib-cstd/issues/20), with build and manual companions. The checklist now separates that completed dependency from native attributes, mediated operations, queue/timing behavior and foreground groups needed for full termios.
Author
Owner

The file-adapter checklist now records the published frontends, mediator and filesystem workload separately. Remaining tool-facing interfaces, stack measurements and runtime acceptance stay open. Weighted completion is 22.80% for Phase 6 and 27.66% for alpha 1; this change exposes completed source work without changing existing weights or claiming guest execution.

The file-adapter checklist now records the published frontends, mediator and filesystem workload separately. Remaining tool-facing interfaces, stack measurements and runtime acceptance stay open. Weighted completion is 22.80% for Phase 6 and 27.66% for alpha 1; this change exposes completed source work without changing existing weights or claiming guest execution.
erikinkinen added this to the Alpha 1 milestone 2026-10-30 09:34:15 +01:00
Author
Owner

TLS deployment storage now has separate reviews for the packet producer and complete loader/linker producer, with client framing retained as a prerequisite. The producer accounts for both registries, thread images, native packets and explicit stacks, and rejects invalid geometry or partly unloaded descriptors.

Matching native provider composition and execution remain open; the guest-build and toolchain-rebuild gates are unchanged.

TLS deployment storage now has separate reviews for the [packet producer](https://git.erikinkinen.fi/erix/integration/pulls/297) and [complete loader/linker producer](https://git.erikinkinen.fi/erix/integration/pulls/300), with [client framing](https://git.erikinkinen.fi/erix/integration/pulls/296) retained as a prerequisite. The producer accounts for both registries, thread images, native packets and explicit stacks, and rejects invalid geometry or partly unloaded descriptors. Matching native provider composition and execution remain open; the guest-build and toolchain-rebuild gates are unchanged.
Author
Owner

The Boot-tool producer now gives VM, negative-image and appliance packaging their own selected offline Cargo operation through Bootloader’s fixture interface. It checks the original source before and after compilation, retains the existing compiler clock and uses the surviving descendant owner for cancellation.

Native-image composition and compiler-origin acceptance remain open. This host producer does not establish either in-EriX build generation or the external toolchain rebuild.

[The Boot-tool producer](https://git.erikinkinen.fi/erix/integration/pulls/314) now gives VM, negative-image and appliance packaging their own selected offline Cargo operation through [Bootloader’s fixture interface](https://git.erikinkinen.fi/erix/bootloader/pulls/21). It checks the original source before and after compilation, retains the existing compiler clock and uses the surviving descendant owner for cancellation. Native-image composition and compiler-origin acceptance remain open. This host producer does not establish either in-EriX build generation or the external toolchain rebuild.
Author
Owner

The source splits now cover original C memory support, command catalog packaging and session/publication policy. Native artifact builds use LibCstd’s assembler producer for memory support. Session policy carries explicit creation labels and independent broker storage through image preparation.

Matching provider-image composition and guest acceptance remain open, including the coordinated command-owner update. These source changes do not establish either in-EriX build generation or the external toolchain rebuild.

The source splits now cover [original C memory support](https://git.erikinkinen.fi/erix/integration/pulls/322), [command catalog packaging](https://git.erikinkinen.fi/erix/integration/pulls/319) and [session/publication policy](https://git.erikinkinen.fi/erix/integration/pulls/320). Native artifact builds use LibCstd’s assembler producer for memory support. Session policy carries explicit creation labels and independent broker storage through image preparation. Matching provider-image composition and guest acceptance remain open, including the coordinated command-owner update. These source changes do not establish either in-EriX build generation or the external toolchain rebuild.
Author
Owner

The native Boot workload now has a retained host reference, exact READ/publication scopes and serial/mirrored PS/2 scenarios in #339. Its storage prerequisites are split into target-derived transport buffers and independent lexical continuation storage. Recipient stream-view packaging preserves the SHA command’s required flag without adding broker rights.

The complete native supplier graph, guest execution, both self-hosting generations and the in-EriX toolchain rebuild remain open.

The native Boot workload now has a retained host reference, exact READ/publication scopes and serial/mirrored PS/2 scenarios in [#339](https://git.erikinkinen.fi/erix/integration/pulls/339). Its storage prerequisites are split into [target-derived transport buffers](https://git.erikinkinen.fi/erix/integration/pulls/337) and [independent lexical continuation storage](https://git.erikinkinen.fi/erix/integration/pulls/338). [Recipient stream-view packaging](https://git.erikinkinen.fi/erix/integration/pulls/335) preserves the SHA command’s required flag without adding broker rights. The complete native supplier graph, guest execution, both self-hosting generations and the in-EriX toolchain rebuild remain open.
Author
Owner

Product GPT creation is split into #346, and all three maintained ESP construction routes use the retained FAT32 producer in #347. Each image process selects real source work and rebuilds under a retained owner; saved executable receipts are not used as compile-origin credentials. Compiler budgets and original image deadlines stay separate.

Matching supplier records, actual image-format/release-image acceptance and in-EriX self-hosting remain open.

Product GPT creation is split into [#346](https://git.erikinkinen.fi/erix/integration/pulls/346), and all three maintained ESP construction routes use the retained FAT32 producer in [#347](https://git.erikinkinen.fi/erix/integration/pulls/347). Each image process selects real source work and rebuilds under a retained owner; saved executable receipts are not used as compile-origin credentials. Compiler budgets and original image deadlines stay separate. Matching supplier records, actual image-format/release-image acceptance and in-EriX self-hosting remain open.
Author
Owner

Pathname and shell-help workflows now have a separate feature PR. The text scenario includes lexical pathname cases alongside both SHA routes; the help workflow exercises twenty commands over PS/2 and COM1, including redirection, status handling and function shadowing. Complete supplier selection and guest acceptance remain open.

[Pathname and shell-help workflows](https://git.erikinkinen.fi/erix/integration/pulls/350) now have a separate feature PR. The text scenario includes lexical pathname cases alongside both SHA routes; the help workflow exercises twenty commands over PS/2 and COM1, including redirection, status handling and function shadowing. Complete supplier selection and guest acceptance remain open.
Author
Owner

Offline manual stores now have a separate feature PR. The image route binds complete page inventories, carries the selected store through both product profiles, and installs an exact read-only snapshot. The text workload reads pages, searches the index and rejects an ungranted root through one exact-file READ ceiling. Supplier selection and guest acceptance remain open.

[Offline manual stores](https://git.erikinkinen.fi/erix/integration/pulls/351) now have a separate feature PR. The image route binds complete page inventories, carries the selected store through both product profiles, and installs an exact read-only snapshot. The text workload reads pages, searches the index and rejects an ungranted root through one exact-file READ ceiling. Supplier selection and guest acceptance remain open.
Author
Owner

The native process heap feature now has a complete host-side producer and standalone source cohort. The fresh build produced the native C/Rust client with a 64 KiB heap, completed all 37 compiler/linker operations and retired their owners cleanly. The later CI-only changes retain the same defining producer inputs.

Guest allocation behavior, global release-image adoption, signal-restoration completion and rebuilding EriX plus Rust/LLVM inside EriX remain open.

[The native process heap feature](https://git.erikinkinen.fi/erix/integration/pulls/353) now has a complete host-side producer and standalone source cohort. The fresh build produced the native C/Rust client with a 64 KiB heap, completed all 37 compiler/linker operations and retired their owners cleanly. The later CI-only changes retain the same defining producer inputs. Guest allocation behavior, global release-image adoption, signal-restoration completion and rebuilding EriX plus Rust/LLVM inside EriX remain open.
Author
Owner

The ordinary C startup producer is working in #357, using Posixd #149 and LibCstd #80. It produces an EriX-target ELF with a shared C/Rust heap. The matching release source graph and guest startup/exit sequence remain open; this is a host build, not an in-EriX build.

The ordinary C startup producer is working in [#357](https://git.erikinkinen.fi/erix/integration/pulls/357), using [Posixd #149](https://git.erikinkinen.fi/erix/posixd/pulls/149) and [LibCstd #80](https://git.erikinkinen.fi/erix/lib-cstd/pulls/80). It produces an EriX-target ELF with a shared C/Rust heap. The matching release source graph and guest startup/exit sequence remain open; this is a host build, not an in-EriX build.
Author
Owner

Typed ext4 product construction is now separated in #360, following the explicit initializer in #358. The product route declares the complete namespace and inode metadata, shares the current launch validators, and retains original inputs through native use and uncertain retirement. Existing-media fixtures keep their separate installer. Docs #74 documents the boundary.

Canonical catalog-provider acquisition is separated in #359; the retained service driver is still in progress. Complete selected-producer, release-image and in-EriX build acceptance remain open.

Typed ext4 product construction is now separated in [#360](https://git.erikinkinen.fi/erix/integration/pulls/360), following the explicit initializer in [#358](https://git.erikinkinen.fi/erix/integration/pulls/358). The product route declares the complete namespace and inode metadata, shares the current launch validators, and retains original inputs through native use and uncertain retirement. Existing-media fixtures keep their separate installer. [Docs #74](https://git.erikinkinen.fi/erix/docs/pulls/74) documents the boundary. Canonical catalog-provider acquisition is separated in [#359](https://git.erikinkinen.fi/erix/integration/pulls/359); the retained service driver is still in progress. Complete selected-producer, release-image and in-EriX build acceptance remain open.
Author
Owner

The ACL workload now has separate PRs for persistent metadata and default inheritance. The inheritance slice creates and retires siblings under small and full-size parent defaults, requests only WRITE for creation results, and keeps construction separate from post-guest decoding.

Caller-retirement changes are in Seriald #13 and Logd #11. Manual companions are in Docs #75 and Docs #76.

The ACL workload now has separate PRs for [persistent metadata](https://git.erikinkinen.fi/erix/integration/pulls/363) and [default inheritance](https://git.erikinkinen.fi/erix/integration/pulls/364). The inheritance slice creates and retires siblings under small and full-size parent defaults, requests only WRITE for creation results, and keeps construction separate from post-guest decoding. Caller-retirement changes are in [Seriald #13](https://git.erikinkinen.fi/erix/seriald/pulls/13) and [Logd #11](https://git.erikinkinen.fi/erix/logd/pulls/11). Manual companions are in [Docs #75](https://git.erikinkinen.fi/erix/docs/pulls/75) and [Docs #76](https://git.erikinkinen.fi/erix/docs/pulls/76).
Author
Owner

The native C runtime work is now split into separate PRs: descriptor I/O, multibyte conversion, readiness, pipe creation, active dependency closure, and termios parameters.

These remain WIP for their outstanding native image and companion-profile requirements. The filesystem, time and terminal integrations are still being completed; this does not establish an in-EriX build.

The native C runtime work is now split into separate PRs: [descriptor I/O](https://git.erikinkinen.fi/erix/integration/pulls/368), [multibyte conversion](https://git.erikinkinen.fi/erix/integration/pulls/369), [readiness](https://git.erikinkinen.fi/erix/integration/pulls/370), [pipe creation](https://git.erikinkinen.fi/erix/integration/pulls/371), [active dependency closure](https://git.erikinkinen.fi/erix/integration/pulls/372), and [termios parameters](https://git.erikinkinen.fi/erix/integration/pulls/373). These remain WIP for their outstanding native image and companion-profile requirements. The filesystem, time and terminal integrations are still being completed; this does not establish an in-EriX build.
Author
Owner

The filesystem, clock and terminal process-root producers now build native ELF outputs from their selected runtime inputs. The filesystem work is in #379/#380, clock in #381, terminal in #382/#383, and capacity integration in #384.

The complete service artifact and image path, guest acceptance, and the EriX and external-toolchain rebuilds inside EriX remain open.

The filesystem, clock and terminal process-root producers now build native ELF outputs from their selected runtime inputs. The filesystem work is in [#379](https://git.erikinkinen.fi/erix/integration/pulls/379)/[#380](https://git.erikinkinen.fi/erix/integration/pulls/380), clock in [#381](https://git.erikinkinen.fi/erix/integration/pulls/381), terminal in [#382](https://git.erikinkinen.fi/erix/integration/pulls/382)/[#383](https://git.erikinkinen.fi/erix/integration/pulls/383), and capacity integration in [#384](https://git.erikinkinen.fi/erix/integration/pulls/384). The complete service artifact and image path, guest acceptance, and the EriX and external-toolchain rebuilds inside EriX remain open.
Author
Owner

Coreutils now has a standalone retained-source build route for the complete 24-applet family, including cmp, scoped manuals and inherited-stream cleanup: #392. Checkout rejects inherited Git configuration, hooks and URL rewrites.

The route has produced a freestanding Cargo ELF from the selected provider graph. Dynamic image packaging, default OS adoption and guest execution remain open; this does not establish an in-EriX build.

The separate Rootd policy, product launch records and EXT verifier slices are also available for the matching service image.

Coreutils now has a standalone retained-source build route for the complete 24-applet family, including `cmp`, scoped manuals and inherited-stream cleanup: [#392](https://git.erikinkinen.fi/erix/integration/pulls/392). Checkout rejects inherited Git configuration, hooks and URL rewrites. The route has produced a freestanding Cargo ELF from the selected provider graph. Dynamic image packaging, default OS adoption and guest execution remain open; this does not establish an in-EriX build. The separate [Rootd policy](https://git.erikinkinen.fi/erix/integration/pulls/389), [product launch records](https://git.erikinkinen.fi/erix/integration/pulls/390) and [EXT verifier](https://git.erikinkinen.fi/erix/integration/pulls/391) slices are also available for the matching service image.
Author
Owner

The remaining source split now has separate PRs for VFS delivery storage (#396), namespace cancellation (#397), runtime fixture policy (#398), comparison workflows (#399), binary/integer formatting (#400), and the composed Rootd orchestration API (#401). The documentation policy checker is separate in #402.

The VFS branches form one dependency chain; comparison and formatting follow the SHA-2 workflows. Pending image, guest and CI-helper adoption is tracked in the individual PR checklists. The original aggregate branch remains preserved.

The remaining source split now has separate PRs for VFS delivery storage (#396), namespace cancellation (#397), runtime fixture policy (#398), comparison workflows (#399), binary/integer formatting (#400), and the composed Rootd orchestration API (#401). The documentation policy checker is separate in #402. The VFS branches form one dependency chain; comparison and formatting follow the SHA-2 workflows. Pending image, guest and CI-helper adoption is tracked in the individual PR checklists. The original aggregate branch remains preserved.
Author
Owner

Native C runtime builds now use the retained service source helper selection (#406). Documentation policy is connected to the same maintained helper that prepares its Cargo inputs (#407).

The bootloader and progress runners now retain their original native child and descendants, with a separate retained result channel (#408). The Coreutils provider’s CI identity is isolated from the Integration checkout (#409).

Complete shared-library production and matching image/guest acceptance remain open. The full in-EriX build and toolchain rebuild are still required.

Native C runtime builds now use the retained service source helper selection (#406). Documentation policy is connected to the same maintained helper that prepares its Cargo inputs (#407). The bootloader and progress runners now retain their original native child and descendants, with a separate retained result channel (#408). The Coreutils provider’s CI identity is isolated from the Integration checkout (#409). Complete shared-library production and matching image/guest acceptance remain open. The full in-EriX build and toolchain rebuild are still required.
Author
Owner

Two more source families now have separate branches: failed-VM metadata retention in #418, and input-helper completion custody in #419. The latter supplies the nested-cleanup prerequisite for standalone worker ownership. Current-image and full CI acceptance remain open.

Two more source families now have separate branches: failed-VM metadata retention in [#418](https://git.erikinkinen.fi/erix/integration/pulls/418), and input-helper completion custody in [#419](https://git.erikinkinen.fi/erix/integration/pulls/419). The latter supplies the nested-cleanup prerequisite for standalone worker ownership. Current-image and full CI acceptance remain open.
Author
Owner

Standalone VM worker custody is now isolated in #420, building on the completion handling in #419. Preparation and execution share the original native owner, and the moved worker body preserves current source admission and metadata handling. Current-image and full CI acceptance remain open.

Standalone VM worker custody is now isolated in [#420](https://git.erikinkinen.fi/erix/integration/pulls/420), building on the completion handling in #419. Preparation and execution share the original native owner, and the moved worker body preserves current source admission and metadata handling. Current-image and full CI acceptance remain open.
Author
Owner

The original-source Rustdoc JSON producer is now a separate supplementary documentation branch in #421. It retains source, runtime, capture and output owners through conversion and retirement. Actual native Rustdoc production and converter handoff remain open.

The original-source Rustdoc JSON producer is now a separate supplementary documentation branch in [#421](https://git.erikinkinen.fi/erix/integration/pulls/421). It retains source, runtime, capture and output owners through conversion and retirement. Actual native Rustdoc production and converter handoff remain open.
Author
Owner

Native descriptor-inheritance workloads are now isolated in #422, with development/release image coverage over both COM1 and physical input. The observer checks exact guest output and statuses for closed descriptors, sparse aliases, exec and time. Matching guest executions remain open.

Native descriptor-inheritance workloads are now isolated in [#422](https://git.erikinkinen.fi/erix/integration/pulls/422), with development/release image coverage over both COM1 and physical input. The observer checks exact guest output and statuses for closed descriptors, sparse aliases, exec and time. Matching guest executions remain open.
Author
Owner

The retained ordinary-service DSO route is now isolated in #424. A fresh native fixture builds two transitive shared libraries, the actual C companion and an inspected service ELF under the same retained operation, with confirmed cleanup. Complete current-service artifacts, image composition and guest acceptance remain open.

The retained ordinary-service DSO route is now isolated in [#424](https://git.erikinkinen.fi/erix/integration/pulls/424). A fresh native fixture builds two transitive shared libraries, the actual C companion and an inspected service ELF under the same retained operation, with confirmed cleanup. Complete current-service artifacts, image composition and guest acceptance remain open.
Author
Owner

Retained compilation inputs are now isolated in #425, following #424. The consumer keeps actual source and checkout descriptors while preserving current byte, namespace, lock and tool checks. A fresh native service fixture passes. Complete current-service performance and guest acceptance remain open; separate Cargo producers still require their own phase admission.

Retained compilation inputs are now isolated in [#425](https://git.erikinkinen.fi/erix/integration/pulls/425), following #424. The consumer keeps actual source and checkout descriptors while preserving current byte, namespace, lock and tool checks. A fresh native service fixture passes. Complete current-service performance and guest acceptance remain open; separate Cargo producers still require their own phase admission.
Author
Owner

Split source comparison and read accounting into #426 and #427, stacked on #425. Comparisons retain the compilation consumer’s original file owners and still read current bytes and check the complete namespace. Accounting preserves the full row totals and error order while reducing repeated path work. Both remain WIP for current-service, image and guest acceptance.

Split source comparison and read accounting into #426 and #427, stacked on #425. Comparisons retain the compilation consumer’s original file owners and still read current bytes and check the complete namespace. Accounting preserves the full row totals and error order while reducing repeated path work. Both remain WIP for current-service, image and guest acceptance.
Author
Owner

The file-identity optimization is split into #430. It constructs the same nine-field observation directly and shares it with the service scope, preserving fresh source checks and original failure order. Full current-service timing and image/guest acceptance remain open.

The file-identity optimization is split into #430. It constructs the same nine-field observation directly and shares it with the service scope, preserving fresh source checks and original failure order. Full current-service timing and image/guest acceptance remain open.
Author
Owner

Restored the omitted command-owner control families in #431, #432 and #433: cleanup diagnostics, binary output and signal policy. Each has its own branch and complete original cases, uses the maintained engine and participates in the host/syntax inventories. The deprecated metadata facade remains absent.

Restored the omitted command-owner control families in #431, #432 and #433: cleanup diagnostics, binary output and signal policy. Each has its own branch and complete original cases, uses the maintained engine and participates in the host/syntax inventories. The deprecated metadata facade remains absent.
Author
Owner

Source and ordinary-service cleanup now share inert diagnostic annotation in #435. Notes read builtin exception storage without invoking exception or argument hooks; actual owners retain the original failure and raw secondary errors. Recording fallback and once-only retirement behavior remain intact.

Source and ordinary-service cleanup now share inert diagnostic annotation in #435. Notes read builtin exception storage without invoking exception or argument hooks; actual owners retain the original failure and raw secondary errors. Recording fallback and once-only retirement behavior remain intact.
Author
Owner

The C runtime CI source-graph adoption is published in lib-cstd#81. It retains the complete selected provider/helper graph and original manifest, lock and namespace checks through command cleanup. Dependency policy runs within retained original inputs, with outputs outside the checkout. Exact-branch CI, ordinary-main, image and guest acceptance remain open.

The C runtime CI source-graph adoption is published in [lib-cstd#81](https://git.erikinkinen.fi/erix/lib-cstd/pulls/81). It retains the complete selected provider/helper graph and original manifest, lock and namespace checks through command cleanup. Dependency policy runs within retained original inputs, with outputs outside the checkout. Exact-branch CI, ordinary-main, image and guest acceptance remain open.
Author
Owner

Cstd’s selected-source CI adoption in lib-cstd#81 now passes its memory, thread and documentation workflows. Integration #438 composes the matching host fixtures and current cleanup assertions on top of #436’s external-report fix. Default image providers and native ownership checks remain unchanged; image, guest and self-hosting acceptance are still open.

Cstd’s selected-source CI adoption in [lib-cstd#81](https://git.erikinkinen.fi/erix/lib-cstd/pulls/81) now passes its memory, thread and documentation workflows. Integration #438 composes the matching host fixtures and current cleanup assertions on top of #436’s external-report fix. Default image providers and native ownership checks remain unchanged; image, guest and self-hosting acceptance are still open.
Author
Owner

Native conversion and compatibility consumers are published in #444 on the coherent host/bootstrap stack. They retain original products through exact export, archive and code-image checks and real freestanding cases, using the existing isolated host inventory. #442 also routes acquisition fetches through the original shared capture and clock limits. Whole CI, image, guest and in-EriX self-hosting acceptance remain open.

Native conversion and compatibility consumers are published in #444 on the coherent host/bootstrap stack. They retain original products through exact export, archive and code-image checks and real freestanding cases, using the existing isolated host inventory. #442 also routes acquisition fetches through the original shared capture and clock limits. Whole CI, image, guest and in-EriX self-hosting acceptance remain open.
Author
Owner

Feature-aware Cargo preparation is implemented in #472. Nested workspaces now resolve their explicit feature selections through the original metadata producer, and consuming commands must use the prepared configuration.

The full build plan is being connected to these preparations. Final service artifacts, image assembly and the in-EriX build remain open.

Feature-aware Cargo preparation is implemented in [#472](https://git.erikinkinen.fi/erix/integration/pulls/472). Nested workspaces now resolve their explicit feature selections through the original metadata producer, and consuming commands must use the prepared configuration. The full build plan is being connected to these preparations. Final service artifacts, image assembly and the in-EriX build remain open.
Author
Owner

The executable boot-component plan is implemented in #479, covering all 77 source roles with original workspace and feature binding. #478 combines its validation prerequisites.

The complete profile matrix, final native artifacts and execution of the whole graph inside EriX remain open. Both guest generations and the external Rust/LLVM rebuild are still required.

The executable boot-component plan is implemented in [#479](https://git.erikinkinen.fi/erix/integration/pulls/479), covering all 77 source roles with original workspace and feature binding. [#478](https://git.erikinkinen.fi/erix/integration/pulls/478) combines its validation prerequisites. The complete profile matrix, final native artifacts and execution of the whole graph inside EriX remain open. Both guest generations and the external Rust/LLVM rebuild are still required.
Author
Owner

The retained primary artifact producer now covers the 40 primary service and command roles, with source preparation, dependencies, native C support and linking held by one operation. A connected Timed build produced its final ELF.

The complete native artifact graph, release image and builds inside EriX remain open.

The [retained primary artifact producer](https://git.erikinkinen.fi/erix/integration/pulls/483) now covers the 40 primary service and command roles, with source preparation, dependencies, native C support and linking held by one operation. A connected Timed build produced its final ELF. The complete native artifact graph, release image and builds inside EriX remain open.
Author
Owner

The versioned compatibility artifact contract and Loaderd intake are implemented in LibDynlink #16, Loaderd #32 and Docs #85. Intake binds requirements to the authenticated artifact digest and rejects mechanisms that are not implemented. Existing native restrictions remain enforced. Constructor, unwind, dynamic-module and guest execution remain separate work.

The versioned compatibility artifact contract and Loaderd intake are implemented in [LibDynlink #16](https://git.erikinkinen.fi/erix/lib-dynlink/pulls/16), [Loaderd #32](https://git.erikinkinen.fi/erix/loaderd/pulls/32) and [Docs #85](https://git.erikinkinen.fi/erix/docs/pulls/85). Intake binds requirements to the authenticated artifact digest and rejects mechanisms that are not implemented. Existing native restrictions remain enforced. Constructor, unwind, dynamic-module and guest execution remain separate work.
Author
Owner

The host-side builds now produce the native SHA2 command and the C/Rust directory workload with matching SDK selections. #533 and #540 track these prerequisites. Both cases still need to execute in a fresh image; compilation does not close their guest acceptance checks.

The complete artifact graph also reached real service compilation and replay. #541 addresses the repeated retained-input scans found during final-link preparation.

The host-side builds now produce the native SHA2 command and the C/Rust directory workload with matching SDK selections. [#533](https://git.erikinkinen.fi/erix/integration/pulls/533) and [#540](https://git.erikinkinen.fi/erix/integration/pulls/540) track these prerequisites. Both cases still need to execute in a fresh image; compilation does not close their guest acceptance checks. The complete artifact graph also reached real service compilation and replay. [#541](https://git.erikinkinen.fi/erix/integration/pulls/541) addresses the repeated retained-input scans found during final-link preparation.
Author
Owner

The maintained runtime/profile input matrix is complete in #546, building on #538. All four variants preserve the complete component/action plan and pass the selected runtime and SMP features into original Cargo queries. Extended variants require an explicit nonempty payload metadata closure for the EriX executing target; clean variants reject those inputs.

This completes input selection, not imported-tool admission or full variant builds. Artifact, image, guest and in-guest toolchain acceptance remain open.

The maintained runtime/profile input matrix is complete in [#546](https://git.erikinkinen.fi/erix/integration/pulls/546), building on [#538](https://git.erikinkinen.fi/erix/integration/pulls/538). All four variants preserve the complete component/action plan and pass the selected runtime and SMP features into original Cargo queries. Extended variants require an explicit nonempty payload metadata closure for the EriX executing target; clean variants reject those inputs. This completes input selection, not imported-tool admission or full variant builds. Artifact, image, guest and in-guest toolchain acceptance remain open.
Author
Owner

The counted boot-object interface is implemented across LibHandoff, Bootloader, Kernel, LibIPC, Rootd, Procd and the manual. Names use checked spans into the retained store; mapping uses catalog indices and the retired pointer modes are rejected.

The Directory scenario producer preserves the baseline image graph and adds a genuine client companion. Coherent image and guest acceptance remain open in the interface design and scenario design.

The counted boot-object interface is implemented across [LibHandoff](https://git.erikinkinen.fi/erix/lib-handoff/pulls/6), [Bootloader](https://git.erikinkinen.fi/erix/bootloader/pulls/24), [Kernel](https://git.erikinkinen.fi/erix/kernel/pulls/127), [LibIPC](https://git.erikinkinen.fi/erix/lib-ipc/pulls/188), [Rootd](https://git.erikinkinen.fi/erix/rootd/pulls/59), [Procd](https://git.erikinkinen.fi/erix/procd/pulls/59) and [the manual](https://git.erikinkinen.fi/erix/docs/pulls/90). Names use checked spans into the retained store; mapping uses catalog indices and the retired pointer modes are rejected. [The Directory scenario producer](https://git.erikinkinen.fi/erix/integration/pulls/598) preserves the baseline image graph and adds a genuine client companion. Coherent image and guest acceptance remain open in [the interface design](https://git.erikinkinen.fi/erix/lib-handoff/issues/5) and [scenario design](https://git.erikinkinen.fi/erix/integration/issues/594).
Author
Owner

The Coreutils text scenario can now be selected through the owned native graph without adding or replacing baseline products. Matching image and guest acceptance remain open in the design checklist.

The missing per-thread runtime storage and conventional locale interfaces have coordinated designs in LibCstd #85 and #86.

[The Coreutils text scenario](https://git.erikinkinen.fi/erix/integration/pulls/600) can now be selected through the owned native graph without adding or replacing baseline products. Matching image and guest acceptance remain open in [the design checklist](https://git.erikinkinen.fi/erix/integration/issues/599). The missing per-thread runtime storage and conventional locale interfaces have coordinated designs in [LibCstd #85](https://git.erikinkinen.fi/erix/lib-cstd/issues/85) and [#86](https://git.erikinkinen.fi/erix/lib-cstd/issues/86).
Author
Owner

The standard memory/string family is implemented in Cstd #93, with producer bindings and the manual/API contracts. The broader workload inventory found two further required POSIX comparisons, tracked in Cstd #94. Full native image acceptance and both guest/toolchain build generations remain open.

The standard memory/string family is implemented in [Cstd #93](https://git.erikinkinen.fi/erix/lib-cstd/pulls/93), with [producer bindings](https://git.erikinkinen.fi/erix/integration/pulls/613) and the [manual/API contracts](https://git.erikinkinen.fi/erix/docs/pulls/93). The broader workload inventory found two further required POSIX comparisons, tracked in [Cstd #94](https://git.erikinkinen.fi/erix/lib-cstd/issues/94). Full native image acceptance and both guest/toolchain build generations remain open.
Author
Owner

Added explicit local object inventory and production source export in #632 and #633. The exporter shares the same original sources across Cargo queries and writes all three offline input roots for fresh admission. These changes are composed in #628. The complete production bundle and in-EriX build remain open.

Added explicit local object inventory and production source export in [#632](https://git.erikinkinen.fi/erix/integration/pulls/632) and [#633](https://git.erikinkinen.fi/erix/integration/pulls/633). The exporter shares the same original sources across Cargo queries and writes all three offline input roots for fresh admission. These changes are composed in [#628](https://git.erikinkinen.fi/erix/integration/pulls/628). The complete production bundle and in-EriX build remain open.
Author
Owner

Offline source execution from #662 is now composed into #628 at 8f107625. The native pipeline retains admitted sources and their original captures through the connected producers. Build-script compiler/caller integration continues in #665. The complete native artifact graph and in-EriX build requirements remain unchecked.

Offline source execution from #662 is now composed into #628 at `8f107625`. The native pipeline retains admitted sources and their original captures through the connected producers. Build-script compiler/caller integration continues in #665. The complete native artifact graph and in-EriX build requirements remain unchecked.
Author
Owner

The hash-verified source bundle now covers all 77 selected EriX repositories at Integration b752b087 (#662): 75 generated locks, 83 manifest bindings, 75 portable dependency resolutions and 77 object packs. The archive is 72,705,947 bytes, SHA-256 2ae36562b6b64d842201318fbf654c8079598c98ab77b4cfa8ee98db41b5980c. Two independent admissions and original source retirement completed. Native artifacts, images, in-EriX builds and the external toolchain rebuild remain open.

The hash-verified source bundle now covers all 77 selected EriX repositories at Integration `b752b087` (#662): 75 generated locks, 83 manifest bindings, 75 portable dependency resolutions and 77 object packs. The archive is 72,705,947 bytes, SHA-256 `2ae36562b6b64d842201318fbf654c8079598c98ab77b4cfa8ee98db41b5980c`. Two independent admissions and original source retirement completed. Native artifacts, images, in-EriX builds and the external toolchain rebuild remain open.
Author
Owner

The startup-allocation wire prerequisite is implemented in lib-handoff #9, tracked by lib-handoff #8. BootKernel v2.1 describes the original table arena, BSP stack and optional AP startup allocations without granting authority from their addresses. The matching bootloader producer, native kernel ownership consumer and multicore image acceptance remain open; private-root activation is not complete.

The startup-allocation wire prerequisite is implemented in [lib-handoff #9](https://git.erikinkinen.fi/erix/lib-handoff/pulls/9), tracked by [lib-handoff #8](https://git.erikinkinen.fi/erix/lib-handoff/issues/8). BootKernel v2.1 describes the original table arena, BSP stack and optional AP startup allocations without granting authority from their addresses. The matching bootloader producer, native kernel ownership consumer and multicore image acceptance remain open; private-root activation is not complete.
Author
Owner

The technical manual now specifies the BootKernel v2.1 startup-allocation extension in Docs #98, alongside lib-handoff #9. It records exact offsets, original allocation duties and retention through uncertain AP startup. The matching bootloader and native kernel work remains separate; this does not establish multicore startup or private-root acceptance.

The technical manual now specifies the BootKernel v2.1 startup-allocation extension in [Docs #98](https://git.erikinkinen.fi/erix/docs/pulls/98), alongside [lib-handoff #9](https://git.erikinkinen.fi/erix/lib-handoff/pulls/9). It records exact offsets, original allocation duties and retention through uncertain AP startup. The matching bootloader and native kernel work remains separate; this does not establish multicore startup or private-root acceptance.
Author
Owner

Captured processor topology is now component-complete in Bootloader #32 and Kernel #142. The genuine dynamic image reaches Kernel entry and reports the captured processor identities on 1, 2 and 4 vCPUs. The data path no longer needs Kernel firmware-table traversal.

The paired image also uncovered and exercised the explicit runtime-provider repair in Bootloader #36, Integration #783 and Docs #101.

These are topology data and dynamic-linking milestones. AP execution, source-owned supervisor mappings, full preemption and the complete in-EriX build/toolchain rebuild remain separate open requirements.

Captured processor topology is now component-complete in [Bootloader #32](https://git.erikinkinen.fi/erix/bootloader/pulls/32) and [Kernel #142](https://git.erikinkinen.fi/erix/kernel/pulls/142). The genuine dynamic image reaches Kernel entry and reports the captured processor identities on 1, 2 and 4 vCPUs. The data path no longer needs Kernel firmware-table traversal. The paired image also uncovered and exercised the explicit runtime-provider repair in [Bootloader #36](https://git.erikinkinen.fi/erix/bootloader/pulls/36), [Integration #783](https://git.erikinkinen.fi/erix/integration/pulls/783) and [Docs #101](https://git.erikinkinen.fi/erix/docs/pulls/101). These are topology data and dynamic-linking milestones. AP execution, source-owned supervisor mappings, full preemption and the complete in-EriX build/toolchain rebuild remain separate open requirements.
Sign in to join this conversation.
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
erix/integration#65
No description provided.