[FEATURE] Supply authorized memory, TLS, threads and race-free blocking for runtimes #1
Labels
No labels
alpha-1
bug
ci
docs
duplicate
enhancement
help wanted
invalid
performance
phase-6
question
refactor
security
wontfix
No project
No assignees
1 participant
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
erix/kernel#1
Loading…
Reference in a new issue
No description provided.
Delete branch "%!s()"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Problem and motivation
Imported Rust/C++ runtimes need real growing heaps, protected mappings, isolated TLS, threads and blocking synchronization. Global errno, spin-only waits and fabricated clocks cannot support correct parallel compilation.
Proposed behavior and scope
Private mediator execution design — 24 September 2026 (implementation pending): the next native witness executes the actual Posixd binary using the existing serialized process mapping path. Private address-space-root routing remains separate work; source review found no dependency that requires it before this witness.
The shared contract will add a distinct counted RBS1 startup image: exact version/byte extent; original realm and generation; native child, Launchd supervisor and Procd controller identity pairs; ordered endpoint and writable-workspace records; explicit capability-window and request/result/receipt storage budgets. The initial schema admits exactly a control RECV endpoint and a configuration SEND endpoint, with no root object, Process route or factory. Reject unknown roles, surplus records, duplicate slots, reserved bits, arithmetic overflow and overlapping storage. Counts describe the supported bootstrap roles, while deployment inputs set storage budgets. Startup bytes are child-read-only/NX; Procd verifies installed inventory and separate private RW/NX workspace before execution. The consumer checks actual local capability types/rights. The complete canonical bytes are SHA-256 correlated in readiness and the independent control challenge; parsing and digests grant no authority.
Provisioning finishes by consuming the existing GRANT-only installer through native child-lifetime binding (operation 58), without adding MINT or another installer. Record uncertain binding/start effects before replying. Native start independently requires an empty installer census. Adopt generation-bound native running termination through a new Process operation 61: original child/generation and kill reason, zero reserved fields, no extra route or rights. The generation comparison and terminal transition share native lifecycle serialization; stale requests must never select a replacement. Its acknowledgment is distinct from terminal observation, invocation retirement and native destruction.
Posixd will register only its declared control receiver and use immediate owned operations to submit readiness through its declared configuration SEND while continuing bounded control progress. Launchd authenticates readiness from actual CLAIM origin. Procd independently challenges its retained control endpoint; COLLECT payloads do not attest a server identity. Both exchanges carry exact original identities and startup digest, admit no capabilities at this bootstrap stage, and retain every accepted native handle even on unusual immediate status. Configuration, sealing and client publication remain later separate gates.
Required evidence includes strict codecs and actual inventory denial; committed-effect/lost-reply ownership; wrong/stale caller and generation denial; running-child retirement; supervisor loss; and a maintained VM executing Posixd with native readiness and challenge. Existing unstarted staging regressions remain required. Subsequent acceptance still requires two mediators, two clients each, mediated byte I/O, cross-realm refusal and full retirement, followed by the external toolchain rebuild and both complete guest OS build generations.
Detailed scope and contracts
Ordinary frame protection through current grants — 22 September 2026
Permit in-place replacement of an ordinary managed/device mapping's access with any state that the architecture can enforce and the selected current frame grant authorizes: no access, R, RW or RX. The same rule applies while inactive or active. WRITE or EXECUTE requires requested READ, and W+X remains prohibited. This removes the need to unmap and recreate a mapping solely to restore access already authorized by the caller's retained capabilities.
The caller-local VSpace capability must carry MAP. The explicitly selected frame capability must independently carry MAP and every requested right; another held alias cannot supplement it. Establish current authority over the exact existing backing: managed mappings require their actual allocation identity and complete page containment, while device mappings require the complete existing physical page to lie inside the selected current device grant. Retained slot numbers, addresses supplied without a grant, and mapping permission metadata cannot replace those checks. Same-backing aliases may authorize protection, including a reused local slot holding a current valid grant to that backing. Unrelated, missing, retired or insufficient grants must fail before mutation; reuse for unrelated backing supplies no authority. Preserve managed/device/anonymous kind boundaries, backing identity and reference counts, original-leaf restoration and failure cleanup.
Use the existing MAP_FRAME request envelope with no new flags, capability type or fallback. Ordinary frame permissions describe current user access, not irreversible sealing of authority the issuer still holds. Irreversible handoff must dispose of the issuer's control grants. Kernel-owned anonymous loader materialization retains its separate internal contract; this work does not by itself implement all POSIX mprotect behavior or narrow the existing Process endpoint's target scope. Document and test those boundaries explicitly.
Acceptance requires paired in-place/unmap-remap controls for R/RW/RX in active and inactive states; same-backing aliases; insufficient, missing and reused grants; managed/device kind separation; complete range bounds; preserved refusal and allocation lifetime. Extend actual CPL3 coverage with an allocator-selected managed frame from the canonical validated boot reservations and usable-RAM inventory. Retire allocator authority before user entry. Actual user instructions must write a function under RW, remove access, restore RX and execute it, restore RW to change its bytes, and execute the changed function under RX. Check selected alias authority, retained mapping custody after final frame-grant disposal, final unmap reclamation, unchanged earlier witnesses and the original caller window and deadline. Preserve batch preparation/error ordering, fresh translation and TLB invalidation. Run all altered repository tests, formatting, strict Clippy, native builds, maintained native/service VMs and warning-free final documentation checks. Preserve original source and artifact identity, update the existing reviews and phase checklist, and monitor the exact CI runs. No performance or complete self-hosting acceptance is inferred from this change.
Staged construction without root capabilities — 15 September 2026
Add kernel-control operation 54, CREATE_STAGED_PROCESS_WITHOUT_ROOT_CAPS, and checked StagedProcessWithoutRootCapsV1 scalar framing. Successful creation returns a live Created process and nonzero generation whose CSpace contains exactly its requested primary endpoint, with no CNode, VSpace or TCB capabilities. Native CSpace/TCB/VSpace objects and the process's VSpace lifetime reference still exist. No child code executes during construction. The endpoint initially retains its ordinary full endpoint rights; operation 53 independently narrows it before bootstrap execution.
Keep the existing creation operation 32 and its producer behavior unchanged. The new selector is independently recognized: an older kernel refuses it, and callers must not fall back to old ignored flags or a child self-report. Admit it only on the existing Process endpoint family, without adding a capability type, endpoint factory or ChildPopulate creation authority.
Use the existing fixed request envelope. arg0 contains the caller-local install-grant destination in its low 32 bits; its upper half is zero. arg1 low/high halves contain child-local primary endpoint and caller-local endpoint-master destinations. arg2 low/high halves contain the child window base and optional caller-local VSpace destination. arg3 contains the 32-bit window length, with a zero upper half. Flag bit 0 means that the VSpace receipt is requested; all other flag bits are zero. When the bit is clear, arg2's upper half must be zero. This explicit presence bit distinguishes an omitted receipt from a real receipt in slot zero. All slot fields retain their full unsigned width; slot zero and otherwise vacant former root positions are ordinary requested slots, subject to native bounds, actual caller-window visibility and occupancy. The checked codec validates framing, not native capacity or authority. The native constructor requires a valid child window containing the primary endpoint.
The caller receives only its actual unique stage-bound install grant, endpoint master and optional MAP-only VSpace receipt. The grant is bound to the returned process/generation and exact child window. Existing capability ceilings, actual object identity and explicit disposal rules remain in force. Temporary native setup bindings must be gone before constructing the final primary endpoint and publishing the grant; otherwise former root positions would remain an unnecessary destination restriction. The TCB's independently held VSpace reference must keep backing alive even without any child or parent VSpace capability.
On failure, destroy the partial child and dispose only successfully created parent receipts. Preserve pre-existing or overlapping destinations and the original failure; uncertain cleanup fail-stops. Never treat a requested slot as evidence that its capability was created. The new contract supplies an initial inventory, not a permanent prohibition on later explicitly authorized installations or a sealed realm. The returned grant remains a real pre-start population authority that its owner must account for and retire.
Required checks include full-width codec/reserved-field cases, omitted versus slot-zero VSpace receipts, zero/former-root/last-slot endpoint destinations, invalid or inaccessible windows, occupied/overlapping outputs, exact parent and child inventories, no residual native objects, mapping/startup backing retention, attenuation through the actual grant and abort/terminal cleanup. Actual CPL3 creation/refusal/disposal must complement host tests. Procd adoption must select this operation only for the mediator role and preserve all ordinary start gates until authenticated grant return, minimum typed startup, retained native/nested guards, readiness, configuration/seal and fair retirement are independently implemented. No runnable realm or guest build is established by this constructor alone.
Native staged endpoint attenuation — 15 September 2026
Add kernel-control operation 53, ATTENUATE_STAGED_ENDPOINT_WITH_GRANT, with a checked ProcessBoundEndpointAttenuationV1 request. This is a new recognized operation; an older kernel must refuse it, and producers must never fall back to an unchecked or post-execution self-report. No syscall number or service endpoint permission is added.
Use the existing fixed KernelControlRequestV1 layout: arg0 low/high halves are the caller's actual install-grant slot and child endpoint destination; arg1 is the exact 32-bit rights mask, with its upper half zero; arg2 low/high halves are expected process and staging generation; arg3 and flags are zero. Both identity components are nonzero. Zero rights means exactly zero, never inheritance. Successful response values are zero.
The native handler must validate the actually held GRANT-bearing install grant, its record, exact expected process/generation, live Created child, grant window, endpoint type ceiling and actual primary endpoint slot. Its rights ceiling must cover the current endpoint rights as well as the requested result; a narrow installer cannot manage a broader existing binding. The new rights must be known, valid for endpoints and a subset of current rights. Update only that existing binding's rights, preserving native object identity, all other bindings and revocation associations. The change allocates no alias and needs no new destination. Repeating the same attenuation may succeed; restoring a removed right must fail. Running, dead, stale, foreign, missing and wrong-type targets must fail without effects.
Admit the operation only on the same Process and ChildPopulate control kinds as exact process-bound installation. Endpoint possession and descriptive IDs alone are insufficient: the actual held scoped grant remains mandatory. The immediate consumer is the future Procd bootstrap transaction, after the actual broad grant returns from Launchd. It will reduce the staged mediator's initial full endpoint to RECV before any private execution, providing independent native proof of that boundary.
Required coverage includes codec/reserved-field rejection, missing and moved grant, wrong process/generation, wrong target/type/window/ceiling, exact attenuation and retry, attempted amplification, post-start refusal, actual CPL3 effect checks and full cleanup. This primitive alone does not admit mediator execution: authenticated grant return, native lifetime and nested revoker custody, minimal root/bootstrap inventory, readiness, configuration/seal and fair retirement remain separate gates. The current ordinary start prohibition stays in force.
Implement the missing native memory/thread/wait mechanisms and their service adapters, including quotas, mmap/protection, TLS, wakeup races, fork interactions and required unwind boundaries. Profile their actual allocation and scheduling costs after lifecycle correctness is established.
This issue records planned work; its unchecked criteria are not implementation proof. The normative basis is Phase 6 and AC1–AC24.
Planned native terminal-generation contract — 17 September 2026: Introduce operation 55 for exact native process/staging-generation/event-kind/status observations. The request has zero flags and arguments; malformed requests fail before dequeue. Successful responses preserve all four 32-bit fields, captured with the actual native terminal transition and retained after destruction. Empty queues return RETRY with zero values. These records constrain existing authority and confer no process-control capability.
Kernel, shared IPC, Procd and Rootd migrate together. Procd must match the native process/generation pair before cleanup, CPU-time observation, restart or service-event publication. Remove the superseded identity-free native selector after all maintained consumers migrate, with no fallback on unsupported kernels. Preserve queue reservation, ordering, wake and failure semantics. Validate actual exit/kill, generation reuse, empty/malformed input and cleanup failure, then strict component checks and original bounded native VMs on a coherent immutable revision graph.
This is the terminal-observation prerequisite for typed mediator bootstrap. The actual returned install grant already has a generation-checked endpoint-attenuation primitive for the first bootstrap effect. Guard custody, final receiver readiness, sealed publication, two mediators with real client I/O and both full guest builds remain separate mandatory work; this planned contract implements none of those by itself.
Authority, security and reliability
Memory and thread operations consume explicit capabilities and resource budgets. Preserve W^X, backing rights, zero initialization, generation-bound wakeup ownership and complete OOM/cancellation cleanup. Clock and entropy sources must be explicit; deterministic fixtures cannot satisfy cryptographic entropy requests.
Apply the priority order: security, reliability, then performance. Keep suspected vulnerabilities in the repository’s restricted SECURITY.md reporting channel.
Acceptance criteria
Checklist
selected tools and distinguish missing mechanisms from libc adapters over existing
capabilities.
with checked alignment, zero initialization, quotas and OOM cleanup.
behavior; preserve W^X, backing rights, dirty data and revocation.
stack guards and cleanup with no unintended capability inheritance.
integrating ABI and loader contracts; isolate errno and thread data.
with correct atomic ordering, wakeup ownership and destruction.
notify-before-wait, wake-after-cancel, spurious wakeups, lost wakeups, priority/fairness
effects and generation reuse.
child state; no inherited lock may require a vanished thread.
native abort-only components; do not enable unwinding across kernel, IPC or incompatible FFI
boundaries.
reproducible timestamps/test randomness from security randomness; never satisfy a
cryptographic entropy request with deterministic fixture data.
compilation, TLS isolation, wakeups, joins and teardown under OOM.
measured costs after safety and lifecycle tests pass.
For each implementation slice, retain actual formatting, strict Clippy, unit/doctest and warning-denied build results for all altered Rust repositories and valid configurations. Add relevant runtime VM coverage, monitor older unit/VM regressions in exact-head CI, and update canonical component documents and affected technical-manual/API material. Every authored code file must remain below 1,000 physical lines, with meaningful inline documentation and missing_docs enforcement in Rust crates.
Alternatives and tradeoffs
Linux syscall emulation is not implied by these runtime requirements. Reuse existing native mechanisms where sound and add only the mechanisms demonstrated missing by the selected tool workload.
The actual allocator rejection control fails the original signed library with next ID 5 instead of 4; the corrected test covers repeated failed growth, initialization failure and allocation-free reuse.
Copy, attenuated copy and move reject unbound endpoint metadata before destination installation; the original control materializes an endpoint and fails the new invariant. Explicit construction then preserves exact object identity and SEND-only rights. The focused owned-invocation design defines actual caller/server generations, exact receiver registration, retained SEND carrier lineage, request/result byte and capability custody, fresh collection, exactly-once grants, invalidated deliveries, draining and terminal cleanup.
Preparation failure changes no capability inventory or unique-grant custody. Commit and pre-delivery rollback require no allocation under existing BSP serialization. Five actual-object controls cover a 62-capability mixed batch, real allocator rejection, exact backing and grant scope, nested revocation and same-CSpace transfer. Its private records cannot survive userspace scheduling and own no retained source authority.
They derive actual TCB/stage/CSpace identity, retain real request/result bytes and capabilities in a private CSpace, and keep a SEND-only carrier alias in its original revocation lineage. Twelve actual-object controls cover caller/receiver scope, source-buffer mutation, duplicate destinations, moved unique grants and reused source slots, actual admission allocation rejection, six native object types, revocation, process death, replay and FIFO after registry vacancy reuse. Reachable backend disposal-failure coverage, sustained invocation-workload profiling, realm producer adoption, whole-codebase authority/private-rustdoc closure and both complete EriX-in-EriX build generations remain open. No new syscall number or wire record is assigned; the existing CALL/RECV/REPLY ABI is unchanged.
The process ID and staged generation come from the retained submitting actor in the native CREATE_STAGED_PROCESS identity domain; payload fields, receiving identity and equal numeric carrier slots cannot replace them. The pair exposes no private CSpace, grants no authority and promises no later liveness. Services must correlate it with exact retained process/realm ownership and revalidate after blocking effects. A two-submitter control sends mutually impersonating payloads through the same real carrier and validates both actual origins plus independent caller-local selector refusal. Sustained invocation-workload profiling, syscall wire and fresh-buffer/fault/overlap validation, actual owned CPL3 peers, reachable backend disposal-failure coverage, realm producer adoption, whole authority/private-rustdoc closure and both complete EriX-in-EriX build generations remain open.
Every sample checks exact bytes and SEND capability bindings, authenticated origin, foreign selection, duplicate completion refusal, FIFO position reuse, one-time collection and final invocation disposal. The next bounded change will retain only non-authoritative numeric search positions: every fast path must still check current capability type/rights, endpoint identity/in-use state and exact CSpace/slot binding, with complete lookup on a stale hint. Original workload bytes and sample policy must remain unchanged for comparison. Native syscall adapters, actual owned CPL3 peers, reachable backend disposal-failure coverage, realm adoption, full authority/private-documentation closure and both complete EriX-in-EriX build generations remain open.
Measured native invocation lookup refinement — 15 September 2026: Signed Kernel
8349d68636382cc7e25a3347f5f1df216554203aretains only numeric carrier-search positions. No successful authorization, capability or reference is cached. These are host operation wall times, not guest startup/build acceptance or a statistical guarantee. Current full-suite CI remains required; stopped cohorts are not polled again. Owned syscall wire adapters, actual owned CPL3 peers, fresh-buffer validation, reachable backend disposal-failure coverage, realm adoption, full authority/private-documentation closure and both complete EriX-in-EriX build generations remain open.Owned invocation wire and native acceptance — 15 September 2026: Signed Kernel
5f497adaefa526108a0439e0e071717dddb85334, shared IPCde968da19898bef532ddb3b5974bb9562f51dee5, capability ABIa001a26f0eb3aebec3f5fd02a28d98f1bc23f8a0and Integration9030b217c490db6ad3ec60a799cb025eccbfcdb1implement and exercise the immediate owned invocation boundary. Destination capacity and descriptive receipt capacity are independent; spare capacity acquires no authority and repeated collection cannot duplicate transfers. The real three-process CPL3 scenario passes all eight operations, full-span pointer/rights/overflow/reserved-field rejection, actual returned selectors, payload/capability/origin checks, collection after server exit and repeated receipts. A second request rejects premature relinquishment, enters draining on caller release and retires only after the exact server acknowledgment. All 162 maintained Integration helper commands pass; three prior correct concurrent-run lock refusals are retained and their sequential checks pass on unchanged executable inputs. Current full-suite acceptance remains open, as does the intermittent quota cause in Integration issue 18. Reachable backend disposal-failure coverage, broader revocation/generation-reuse scenarios, producer adoption, realm runtime, complete authority/inline-documentation audits and both full EriX-in-EriX build generations remain open.Process-bound native acceptance — 15 September 2026: Signed Kernel
60da5858d7198185efd103f0e91e5ac2e0b63e67implements control operation 52, checking the actual moved install grant against expected process/generation with exact rights, including zero, under existing endpoint policies. Signed Procdf1105706cc19ed024a6cca79a29abc57c90c6661uses this operation in its actual ordinary launch-description producer while retaining the narrow SEND receipt, pending state and exact failure cleanup. All 162 Integration helpers pass after updating the exact policy assertion to require the new marker; its initial mismatch remains recorded. Typed realm bootstrap, mediator startup/readiness/configuration/seal, complete consumer image adoption, fair terminal/provider retirement, broader native disposal failures and both full EriX-in-EriX build generations remain open. The new inventory covers 76 repositories, 2,950 code files below 1,000 lines and 158 direct missing_docs crate-root gates; complete inline documentation and whole-codebase authority closure remain open.Actual grant-return provisioning, authenticated receiver readiness, configuration/seal, client I/O, fair retirement, whole-codebase authority/documentation closure and both complete guest build generations remain required. No runnable Posixd realm or guest-build acceptance is claimed.
Native creation rollback acceptance — 15 September 2026: Staged construction now retains a receipt for each successful parent copy until commit. On later failure it destroys the child and disposes only those new endpoint/VSpace copies, preserving pre-existing or overlapping output bindings. The transaction has a separate documented module. Eight actual constructor refusal cases check complete parent inventory and native VSpace counts. Kernel
b853d51cfbpasses 649/673 default/all tests, strict host/native development/release Clippy, private rustdoc, formatting and ten native builds, with three existing ignores. Matching CI 566/567 passes with four complete warning-free logs. Integration 3c4e26025668fa2a171b2c80017fd2b8bcb1924f passes both actual native VMs with empty QEMU stderr and clean teardown. The lifetime fixture now includes seven creation/refusal/disposal calls alongside the thirteen installation calls; the existing owned-invocation oracle is preserved. Integration Rust/helper sources are unchanged and retain their completed 320/321-test strict matrix and all 162 helper results; changed native catalog inputs have fresh policy and VM checks. Full Integration CI 1627/1628 remains pending. Typed grant-return provisioning, independently constrained bootstrap authority before mediator execution, readiness, configuration/seal, client I/O, fair retirement and both complete guest build generations remain open. The code inventory covers 76 repositories and 2959 files below 1000 lines; all 158 scanned Rust roots enforce missing_docs. Whole-codebase semantic authority and private-item documentation audits remain incomplete.Separate one-CPU and two-CPU diagnostic VMs pass the unchanged native command sequence. A read-only hardware observer matches all 233,755 selected coreutils executable bytes, verifies CPL3 and enabled paging/execute-disable state, and confirms both observed RELRO pages are user-readable, read-only and non-executable; the current stack is user-writable and non-executable. Both processors report execute-disable enabled. This is an exact process-entry/table observation, not an injected instruction-fault test or whole-system permission proof. The diagnostic image SHA-256 is
8c3c24639e8e1ca8c4f2ad4e485323abf32ec07408241c3e4fa9713f6e07e812.Signed Docs
d221e725c2543316680e63fc5e8314ce0fe3bdf1documents the mapping and processor contracts. All 45 documentation tests and canonical checks pass; the 2,375-page manual has 434,308 in-bounds word boxes and zero final warnings, with three changed pages visually reviewed. Exported API snapshots are unchanged. Kernel CI 574/575 passes with four complete warning-free logs (708,112 bytes), including existing optimized workload examples. Docs CI 891/892 passes all four complete logs (762,176 bytes), with 45 tests per manual job and zero final warnings. The later maintained permission regression is recorded below. Full frame proof, whole-codebase authority/documentation review, runnable realms and both complete guest build generations remain open.Actual one-CPU and two-CPU runs on the repaired diagnostic image pass the original native-time command sequence and the expanded hardware checks: all 58 selected code pages are user-readable, read-only and executable; both RELRO pages are read-only/non-executable; the current stack is writable/non-executable. Complete executable bytes match and NX interpretation is enabled on every selected processor. An earlier image is rejected by the maintained observer. Both child outcomes, exact original input bytes and temporary cleanup are retained, with empty debugger stderr in both positive runs. The final cleanup code also preserves reaping when a direct child exits between poll and termination.
The command's image CI gate awaits adoption of a coherent product catalog containing both required component fixes. Its explicit diagnostic invocations do not silently replace the older maintained image graph. Signed Docs
3fb0b12ff55d044cc4bbe142418ab7a5b07bb42ddocuments the maintained operator contract. All 45 tests and canonical checks pass; the 2,377-page manual has 434,563 in-bounds word boxes with zero final warnings, and the changed subsection passes visual review. Exported API snapshots are unchanged. Matching Docs CI 893/894 passes with all four complete logs (762,616 bytes) and zero final warnings. Current Integration CI, complete frame proof, whole-codebase authority/documentation closure, runnable realms and both guest-build generations remain open.Explicit query caller context — 17 September 2026: isolate query-local-cap dispatch in a documented module. Resolve the kernel-attributed current TCB record once, validate the requested slot against that same record, and pass its explicit CSpace identity to both capability and endpoint-kind lookup. A descriptive source slot or process ID must never select a different owner, and a missing caller must retain DENIED rather than use the bootstrap root fallback.
Share the pure checked window predicate with the existing current-caller checks. Preserve parameter/error precedence, result-register encoding, diagnostics and the register-only wire interface. Add focused controls for a private CSpace shadowing root slots, denied/missing callers, malformed parameters and metadata observations without capability mutation. Keep new definitions documented and split the almost-full dispatch source by responsibility.
This removes repeated ambient CSpace selection and makes the memory-effect audit smaller; it does not itself certify the retained older kernel ELF. Keep the original syscall preservation refusal until selected kernel/source/artifact evidence and the relevant memory effects are grounded. Validate strict kernel feature matrices, applicable native/runtime controls, documentation and original automatic CI before claiming acceptance.
Four strict development/release default/all-feature matrices pass 670/694 unit tests plus two external controls, with three existing ignores. Formatting, host/native Clippy, private rustdoc and thirteen native binaries pass without warnings. Original kernel CI 578/579 both pass; all four complete terminal logs contain no warnings.
The selected native image passes fifteen actual CPL3 queries with exact metadata, RSP, six saved-register and sixteen live-stack-word comparisons across three private owners, then all existing invocation custody/retirement checks. The separate lifetime/revocation scenario also passes all original markers. Both use one TCG CPU and unchanged 60-second deadlines. The first canary fixture failure is retained in kernel issue 16; the corrected fixture explicitly selects its owned stack before testing syscall preservation. This is finite selected-image evidence, not a generic kernel memory guarantee or full guest build.
No capability, mapping or slot authority is added.
Four strict development/release default/all-feature matrices pass 670/694 unit tests plus two external controls, with three existing ignores. Formatting, host/native Clippy, private rustdoc and 19 native builds pass without warnings. Original CI 580 and CI 581 both pass; all four complete terminal logs contain no warnings.
The standard native wrapper passes invocation, entry-direction and lifetime scenarios on this signed Kernel. Thirty caller-local queries exercise both user direction states, retaining exact returned flags, metadata, RSP, six saved-register and sixteen live-stack-word checks. The separate UD2 scenario requires live forward direction, retained fault flags and the expected fatal exit. All original marker requirements and 60-second deadlines remain. This finite evidence does not establish general syscall memory preservation or a full guest build.
All native and full-build evidence retains its exact source scope; consumer adoption and both complete guest build generations remain open.
The complete syscall memory footprint, ordinary graph adoption and both full guest builds remain open.
VSpace fixture follow-up — 17 September 2026: Original diagnostic-cleanup CI 586 fails and 587 passes; all four complete logs contain zero warnings. Issue #17 tracks deterministic predecessor-attribution failures in the synthetic and mapping fixtures. The correction preserves production authority and all original test assertions, shares explicit test-only attribution setup, and partitions the large mapping suite. Strict corrected matrices are running. Earlier native entry and diagnostic VM results retain their exact source/feature scope.
Issues #4, #5 and #17 close for their bounded host-fixture corrections, while full source/frame and guest-build acceptance remain open.
Borrowed capture checkpoint — 17 September 2026: signed
f2489242be47654342c91ef3f05a2a12cdc15a4brequires complete initialized frame ownership before native syscall dispatch. Five new controls cover real allocation rejection, non-dispatch of a requested
capability drop, attribution, layout, stable copies and teardown.
VSpace cleanup checkpoint — 17 September 2026: signed
1af934ff48e6d5ad33fd1227c8d1ffdc40c7a06drecords access-withdrawal progress and exact frame-reference consumption while
rejecting ordinary use during retirement. Surrounding process-cleanup review, ordinary-image adoption
and both complete guest builds remain open.
Ordinary-image, whole-code semantic and both complete guest-build gates remain open.
Malformed waits cannot dequeue; selector 7 is retired. The added CPL3 fixture checks every response word; corrected endpoint-refusal framing passes both native profiles.
Nine CPL3 terminal calls check malformed nonconsumption, retired-selector rejection without a fabricated response, original exit/kill generations and canonical empty queue. Typed mediator bootstrap, ordinary service-image adoption and both complete EriX builds inside EriX remain open.
Planned exact-generation native cleanup — 17 September 2026: Define distinct native terminal-destruction and
staged-abort operations 56 and 57. A checked request carries the nonzero original
process/generation pair in the low/high 32-bit halves of arg0; flags and all other
arguments are zero. Retire selectors 8 and 35 without reinterpreting them or
adding a compatibility fallback. The existing held Process or Root route remains
required; descriptive identities do not grant authority.
Match the exact pair under the same TCB record lock that enters retained cleanup.
Preserve terminal-versus-Created eligibility, partial disposal and retry custody.
An absent or different generation acknowledges absence of only the requested
instance, with zero response values; it cannot mutate a replacement. Migrate
every native caller and carry creation/event generation through deferred retries.
Account for processes created before a service's own managed ledger without
reconstructing historical identity from the current record. Maintain separate
terminal observation, cleanup custody, provider completion and native absence.
Required evidence includes exact wire and reserved-field controls, actual-object
generation/reuse and failed-release controls, consumer cleanup tests, and bounded
CPL3 native coverage. Update all operation inventories, Rootd's measured audit
contracts, canonical documentation and manual/API references. Validate coherent
original commit dependencies, complete strict component matrices and repository
CI checks, then monitor original workflows. Ordinary mediator start, whole-image
admission and both complete builds inside EriX remain separate open gates.
All earlier lifetime oracles remain required; both packaged Kernels match their normally stripped original builds and all 15 component trees are clean. Runnable mediator bootstrap, fair retirement and both complete builds inside EriX remain separate open acceptance requirements.
Caller-local grant relocation design — 18 September 2026: Add immediate x86_64 syscall
0x54,RELOCATE_LOCAL_GRANT, taking source slot in argument 0 and destination slot in argument 1. Both fit u32, are nonzero and distinct; arguments 2–5 are zero. The return is the exact result in rax with zero auxiliary value. Admission uses the actual current Running native process and nonzero generation, checks both slots against its syscall window, and accepts only an actual held INSTALL_GRANT or REVOCATION_GRANT with its matching native record. Movement uses the existing unique-record rebinding within that same native CSpace; rights, child/generation installation scope and revocation lineage are preserved. No grant is constructed, copied, attenuated or retargeted. Malformed register shape rejects before context lookup; caller/window checks precede source lookup, then type/binding checks precede empty-destination admission. Ordinary validation refusal leaves inventory unchanged. The transition is serialized with process-terminal and reply-authority lifecycle changes. Owned CLAIM already selects receiving destinations before exposing request bytes; this operation lets a producer validate the received grant and then relocate it into an existing per-process custody slot. The operation itself does not validate a bootstrap request, install child authority or acknowledge application retirement. It adds no Process endpoint selector or general CNode route. Literal register, foreign/terminal caller, missing/fake binding, occupied destination, exact-rights/scope and actual CPL3 controls are required, followed by coordinated producer/consumer adoption and the remaining realm VM gates.Caller-local grant relocation native acceptance — 18 September 2026: Signed Kernel
56d398e077c140c58e23f9cc2d8b79f19bc4cc2fimplements register-only syscall 0x54 using the actual Running caller, both admitted local slots and native unique install/revocation binding owners. The lifetime fixture executes thirty-nine new CPL3 relocation calls before its existing installation, revocation, terminal, inventory, queue and page checks; user instructions validate results and observers never replace them. This is native local custody evidence only: actual owned service adoption, consumer VM execution, complete realm fairness and both full builds inside EriX remain open.Owned receiver request-budget contract — 18 September 2026: Extend register-only REGISTER (0x4C) to take the actual local RECV slot, maximum request payload bytes and maximum request capability count in arguments 0–2; arguments 3–5 remain zero and successful RDX is zero. Both budget values are explicit receiver declarations. Zero/zero admits only empty requests. The byte/slot/receipt receive layout must be addressable and capability capacity must fit native private CSpace storage. The actual Running generation and held generic RECV endpoint remain the registration authority. Exact repeated registration is idempotent only with the same budget; a different budget or owner conflicts without modifying the original registration. Replacement follows the existing actual receiver-binding removal and exact native retirement rules. SUBMIT compares actual payload length and capability count against that exact registration before request allocation, private-space reservation, native transfer or invocation serial acceptance. Oversized requests return ordinary INVALID_ARGUMENT with zero owner ID and unchanged source custody. The packet decoder passes its checked capability iterator directly to native preparation, removing its redundant temporary vector. Accepted invocation, result-budget, delivery, draining and retirement contracts remain explicit. Migrate every producer and fixture to the new signature without a deprecated unbounded fallback. These budgets describe service-owned receiving storage; they add no global CALL-size ceiling, user-pointer retention, foreign selector or capability grant. Literal malformed/zero/exact registration controls, rejected-inventory checks, actual CPL3 calls and existing VM oracles are required. Then connect the owned Procd/Launchd bootstrap path through its held private route, actual claimed caller identity, server-chosen grant receipt and local relocation, retaining each committed/draining owner through exhaustive cleanup. Actual consumer VMs, complete fair realm progress and both full guest builds remain open acceptance requirements.
Explicit owned receiver admission acceptance — 18 September 2026: Signed
7034572037d1217b841c04dd9f45d5b254122a91. REGISTER binds explicit byte/capability request limits to the actual receiver generation and RECV binding. Oversize is refused before native request allocation, transfer or invocation acceptance. Allocation controls observe no requests on oversized refusal and equal direct-native/packet submission allocation. Actual owned Procd/Launchd service adoption, consumer VM execution, complete realm fairness/readiness/sealing and both full builds inside EriX remain open.Matching catalogs, source-bound consumer VMs, complete realm operation and both full guest builds remain required.
Original coherent realm source CI acceptance — 18 September 2026: Signed
bd127228f62cd5320e87642e79aa7c1cd8212e24passes CI 605 and CI 604. Coherent catalog publication, actual consumer VMs and full guest-build acceptance remain separate open requirements.Tracking and rollout
Matched native performance evidence — 28 September 2026: both original startup captures pass the unchanged 120/45-second gates without warnings. The matched old/new Kernel comparison uses identical tools, firmware, normalized VM configuration and all 66 other runtime ELF/shared-object artifacts. Translated-instruction upper bounds fall from 38,281,446,500 to 37,372,677,139 (2.37%); the reported mapping-batch candidate groups fall from 11,178,003,410 to 10,355,082,032 (7.36%). These bounded counters indicate less work, not completed-instruction counts or an elapsed-time speedup: the instrumented runs take 55.36 and 55.75 seconds respectively. The rejected earlier comparison remains retained because its producer graph differed.
This completes the borrowed-mapping dependency's matched performance validation and the fourteen-snapshot numerical nonexecution witness already recorded here. Signed roadmap-only updates (kernel 1363f0c5, docs d72f0a57, integration 324cc4da, lib-cstd 50b9d289) record the results; selected runtime, helper, catalog and manual source bytes are unchanged and retain their exact prior evidence. Fresh documentation/policy/diff and applicable formatting checks pass. New original CI is registered independently. Whole lifecycle acceptance remains open through supervisor-loss and remaining partial-cleanup/exhaustion checks; complete guest EriX and external Rust/LLVM rebuilds remain required and unproved. No new checklist credit is claimed.
Docs original CI1103/1104 fails, with one fully validated manual job and three failed job logs returning HTTP 500. Docs bug 11 records exact jobs and unknown cause. Kernel CI706/707 and Lib-cstd CI13/14 pass; original Integration runs remain monitored. Integration receipt bug 99 has coordinated host/native evidence but remains open pending original CI. No unchanged failing CI was rerun for acceptance.
Native numerical accounting acceptance — 28 September 2026: signed Integration e4ffe2ef, Kernel 928aee12 and Lib-cstd a76f6faa pass the coordinated native regressions.
The complete numerical capture now passes all fourteen actual snapshot additions: six Measured mediators, six Measured clients and two positively NeverExecuted clients with exactly zero CPU. Independent review reconciles the final lifetime sums from 137 original backing pages after retirement, checks inactive user access denial, retires all hardware breakpoints, verifies complete code identity and confirms bounded child cleanup. The original 120-second gate passes; no guest bytes, grants or registers changed and no observer overhead was subtracted. Two positive and twenty adversarial observer controls pass. The older failed observations remain retained.
This closes numerical nonexecution evidence only. Remaining supervisor-loss, exhaustion and partial-cleanup validation must complete the active lifecycle requirement before unrelated work. The receipt defect also has coordinated native evidence, but remains open pending original Integration CI review. Lib-cstd CI13/14 and Kernel CI706/707 pass; other original CI remains monitored without unchanged reruns. The changed startup profiler capture passes, but its first comparison exposed producer metadata and Rootd verification differences; a fresh old-Kernel baseline under the same current producer graph is being built before any performance conclusion. Both full EriX builds and the external Rust/LLVM toolchain rebuild inside EriX remain required and unproved. No new checkbox or acceptance percentage is added for this dependency checkpoint.
Four default/all-feature development/release configurations pass 918/942 library tests and two integration controls each, retaining three ignored cases. Strict host/native Clippy, eighteen native build/Clippy configurations, private rustdoc, formatting and policy checks pass without warnings. Original Kernel CI706/707 is being monitored. The fleet structural audit covers 76 repositories and 3,196 authored code files below 1,000 lines, 264 immutable Git selectors and all 98 conventional/manifest crate roots enforcing missing_docs; this is not complete semantic authority acceptance.
This dependency follows the actual configured-client accounting timeout. A changed host-only profiler diagnostic retained eight actual commits, including both zero-CPU NeverExecuted client snapshots, but hit the original 120-second deadline before all fourteen commits and final reconciliation. Its complete counter capture identifies mapping-batch code for investigation, without elapsed-time attribution or a speedup claim. Both failed observations remain unaccepted. The manual update, coordinated image, native regressions and equivalent successful profiler captures are still required. The active lifecycle item remains open through numerical accounting, remaining abort/retire/partial cleanup, supervisor loss and resource ceilings. No checklist credit is added; the whole-item execution priority and both complete EriX/external-toolchain guest-build requirements remain unchanged.
Original roadmap-only Docs CI1101/1102 passes 45 tests and the complete 2,657-page manual without final warnings. Exsh CI293/294 passes 988 units and 355 checker controls but retains the known incomplete frame proofs. Complete logs are reviewed; Integration CI1825/1826 remains in progress. No unchanged CI was rerun.
Original CI704 and CI705 pass. All four complete logs verify 930,354 bytes with zero warnings; no unchanged CI was rerun. This component alignment does not establish the coordinated configured-client VM, complete authority closure, managed-row reuse, profiler observation or either full build inside EriX. Those remain open under the phase checklist.
The earlier generation-bound termination checkpoint retains its exact-source lifetime VM acceptance. Native execution of the updated producer graph remains pending; this pin adoption does not establish actual mediator readiness, complete authority closure or either full in-guest rebuild. CI for the new checkpoint is pending the next combined observation; no earlier CI result is attributed to this revision.
One actual QEMU lifetime run passes the original 60-second deadline and all ordered/unique markers, including reused numeric identity with a new generation, stale-generation refusal preserving its replacement, route denial, exact terminal events and executing-child ancestor termination.
Signed Integration checkpoint adopts the exact Kernel/shared pins in the dedicated lifetime catalog. All 172 maintained helper tests pass freshly, plus formatting and source/document policy checks. Unchanged Rust inputs retain their prior strict validation. Procd uses exact-generation termination, and Posixd has a validated freestanding bootstrap, readiness and challenge loop. The manual documents these contracts; all 45 documentation tests and the complete 2,469-page build pass with zero final warnings.
Actual Posixd execution is still pending. Active work adds counted provisioning, authenticated controller discovery, retained private Start/Retire exchanges and the separate two-mediator native startup witness. Configuration/seal, client I/O, full in-guest EriX builds and rebuilding the external toolchain remain open.
Integration remains pending; existing regression reports remain open.
Detailed scope and contracts
Runtime dependency alignment — 15 September 2026
Coherent product catalog adoption and product VM acceptance remain pending.
Coherent runtime source adoption — 15 September 2026
Full commit selectors remain mandatory.
Construction without child root capabilities — 15 September 2026
Kernel operation 54 admits only actual Process endpoint holders and constructs a Created child with exactly one primary endpoint and no root capabilities. Six added host controls cover 30 valid layouts, exact refusal inventories, actual caller windows and backing through abort or start/kill/destroy.
Procd adoption, authenticated grant return, guarded bootstrap authority, private mediator execution, readiness, configuration/seal, client I/O, fair retirement and both complete guest build generations remain open.
Staged endpoint attenuation checkpoint — 15 September 2026
The grant must cover the current rights as well as the requested result. Exact zero and repeated reduction preserve object identity, other aliases and revocation associations; restored rights, stale or foreign targets, malformed fields and started children refuse.
Authenticated grant return, independently minimal bootstrap/root authority, retained native and nested guards, private mediator execution, configuration/seal, client I/O, fair retirement and both complete guest build generations remain open.
Dependencies identify required contracts and closure gates; preparatory inventory/design can proceed in parallel under one owner per edited file. Link bounded implementation issues and their PRs here before claiming acceptance.
Close criteria only with their own reviewed deliverables and validation evidence.
Process-start census correction — 19 September 2026: signed Kernel
b762e19d0c16acd605d0f6123994a586cc6fcde1requires a successful install-grant absence census before process start. An unavailable census returns the existing refusal and preserves the whole staged child and grant state.The static census covers 3,127 authored code files below 1,000 lines, 74 manifests, 259 original Git pins, 170 direct missing_docs gates and 92 conventional crate roots; complete semantic authority and private-documentation closure remain open.
Complete mediator execution, full source/effect/frame proof, upstream Rust/LLVM rebuilding and both full EriX build generations inside EriX remain required. No whole acceptance item is newly completed.
This completes the terminal-refactor prerequisite in child lifetime design #19; it introduces no lifetime binding, new opcode or additional authority.
Full semantic authority and private rustdoc closure remain open. Native child-lifetime custody, running mediator lifecycle, full frame proof, upstream Rust/LLVM rebuilding and both full EriX build generations inside EriX remain required. No whole phase acceptance item is added.
Fourteen new real-object controls cover refusals, rollback, nested stopping, a 257-descendant tree, late preflight failure, exact reuse and failed explicit abort after unlinking.
A real CPL3 supervisor proves ChildPopulate refusal, malformed/generation refusal, actual Process-route binding, start and exit.
Executing-child, no-successor native idle, allocation/partial-effect failure coverage, Procd adoption, running-mediator failure, provider completion, complete source/effect/frame proof, upstream Rust/LLVM rebuilding and both full EriX-in-EriX generations remain open. No whole phase acceptance leaf is added.
A supervisor binds and starts a child; that child binds a staged grandchild and kills its supervisor through its own explicit Process SEND route. Read-only witnesses require terminal caller storage to survive dispatch, then exact child/grandchild absence before the independent observer reads child-before-supervisor events. All four additional lifetimes and twenty-two mapped pages must be disposed for
ERIX_KERNEL:CHILD_EXECUTION_OK.Signed Integration c14c5a61 requires the additional marker while preserving every earlier marker and the original 60-second limit.
The original install-grant constructor still gives
GRANT | MINTwhile binding needs onlyGRANT; move-only transfer preserves exact rights. Full source/effect/frame proof, the Pagerd gate, native external Rust/LLVM/runtime rebuilding and both full EriX-in-EriX generations remain mandatory. No whole acceptance leaf is added: 15/460, 3.48% weighted.The child kills that supervisor through its own explicit Process SEND route. Immediate faulting sentinels forbid either terminal payload from resuming.
A diagnostic-only read-only witness then requires empty CPU accounting, only terminal retained records, no bound cleanup duties or event reservations, exact child identity/CSpace/mapping absence and both unconsumed child-before-supervisor events.
Signed Integration 4d6f4fe8 requires the additional marker while preserving all earlier assertions and both 60-second scenario limits.
The static audit passes 3,140 authored code files below 1,000 lines, 74 manifests, 259 full Git selections, 171 direct missing_docs gates and 92 conventional crate roots; semantic authority and complete private-rustdoc closure remain open.
Further native failure controls, grant-rights minimization, terminal accounting, Procd adoption and complete service lifecycle acceptance remain open. Existing install-grant creation still supplies GRANT | MINT while binding needs GRANT, so minimum authority is not claimed. Full source/effect/frame proof, the 128-page Pagerd gate, profiler attribution, native external Rust/LLVM/runtime rebuilding and both full EriX-in-EriX generations remain mandatory. No whole acceptance leaf is added: 15/460, 3.48% weighted.
Native terminal-event allocation refusal — 19 September 2026: signed Kernel ba03995f extends the actual executing-child sequence with one deliberately refused heap allocation.
Read-only witnesses require complete reservation rollback, an empty event queue, unchanged exact records and capabilities, and preserved code/stack/message mapping ranges. Actual CPL3 instructions validate the refusal reply before the next ordinary ancestor kill succeeds with allocation available. Every earlier terminal, descendant-disposal, independent-process and no-successor idle assertion remains required.
ERIX_KERNEL:TERMINAL_EVENT_RESERVATION_OKrequires one consumed allocator refusal and no remaining armed fault. No witness supplies a syscall result, cleanup effect or scheduler choice.Signed Integration cf5b2f5f requires the new marker without changing either 60-second limit.
Complete semantic authority and private-rustdoc closure remain open.
Its separate private-mediator branch does not take the same query path; adoption must state which lifetimes require retained metrics and preserve their original generation without fabricated zero/wall-clock values. Independent release-failure coverage, grant-rights minimization, accounting, Procd adoption and full mediator lifecycle remain open. Full source/effect/frame proof, the 128-page Pagerd gate, profiler attribution, native Rust/LLVM/runtime rebuilding and both full EriX-in-EriX generations remain mandatory. No whole acceptance leaf is added: 15/460, 3.48% weighted.
Independent native child release recovery — 19 September 2026: signed Kernel 82d88b60 extends actual supervisor-exit coverage with two deliberate refusals at the original staged child's final VSpace-release callback, after capability disposal and unlinking. Read-only observations around two ordinary CPL3 observer yields require the original full record, generation, abort custody and first error retained, an empty original CSpace and retained mapped backing. The independent running child must already be absent from native TCB, CSpace and VSpace directories.
The third callback must perform normal VSpace release before all original terminal-event, generation and resource-absence checks pass.
ERIX_KERNEL:CHILD_RELEASE_ISOLATION_OKrequires exactly two refusals and complete eventual disposal. This establishes injected callback-refusal coverage, not an observed hardware or allocator malfunction. All earlier nested-child, allocation-refusal and no-successor pre-halt assertions remain required.Signed Integration 294a467a requires the added marker with both original 60-second limits unchanged.
Static audit passes 3,143 authored code files below 1,000 lines, 74 manifests, 259 original Git pins, 171 direct missing_docs gates and 92 conventional roots; complete semantic authority/private-rustdoc closure remains open.
The grant-rights audit confirms actual Procd derivation callers and exact GRANT | MINT receipt checks in Procd and Launchd. Grant authority minimization must coordinate those consumers and distinguish the grant's own rights from its installation ceiling. Original generation-bound terminal accounting, Procd adoption, provider completion, hardware halt/wakeup and complete mediator lifecycle remain open. Full source/effect/frame proof, the 128-page Pagerd gate, profiler attribution, native external Rust/LLVM/runtime rebuilding and both full EriX-in-EriX generations remain mandatory. No whole acceptance leaf is added: 15/460, 3.48% weighted.
Derivation requires actual MINT and subsets of both own rights and installation scope. The new actual CPL3 derivation/disposal controls and GRANT-only relocation/installation compile; their matching VM execution remains pending.
Procd's move-only handoff cannot attenuate the original delegating grant: it now derives a GRANT-only final receipt into the already-disposed VSpace receipt slot and drops the source before returning that receipt. Nonderiving materialization and rootless mediator paths request GRANT directly. Procd, Launchd, Rootd, Loaderd and Deviced pass their default unit suites; their full strict matrices and coherent guest validation remain open.
This is partial implementation evidence, not completed lifecycle or self-hosting acceptance. Full terminal accounting, provider completion, consumer lifecycle, source/effect/frame proof, the 128-page Pagerd gate, profiler attribution, native external Rust/LLVM/runtime rebuilding and both complete EriX-in-EriX generations remain required.
Lifetime now exercises 27 ordinary CPL3 grant-right controls and requires INSTALL_GRANT_RIGHTS_OK before its existing cleanup assertions. These minimal native scenarios establish neither full service-image acceptance nor a guest build.
Those filesystem failures require separate analysis.
Canonical acceptance remains 15 of 460 leaves, 3.48% weighted. Complete lifecycle and terminal accounting, provider completion, source/effect/frame proof, the 128-page Pagerd gate, profiler attribution, native external Rust/LLVM/runtime rebuilding and both full EriX-in-EriX generations remain required.
An isolated rewrite produced the same 17 instructions and 63 bytes, so it was rejected as an optimization.
The profiler and unchanged startup timing gates remain open in Integration 3 and Integration 72. The phase checklist stays at 15/460 accepted leaves, weighted 3.48%; external Rust/LLVM rebuilding inside EriX and both full guest-build generations remain mandatory and unproven.
The next work in Kernel 22 must resolve the supervisor baseline, bootstrap/saved-frame overlays and inactive-space population before adding root ownership, residency and retirement. Startup timing acceptance, complete authority cleanup and the profiler's measured speedup remain open. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX, then completing both full EriX guest-build generations, remains mandatory and unproven.
Bootstrap provenance, independent hardware roots, complete authority cleanup and measured startup improvement remain open. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and completing both full EriX guest-build generations remain mandatory and unproven.
Empty and MANAGE-only aliases are denied; MAP-only access remains valid.
Actual CPL3 calls preserve the authorized RW/NX page across restricted-alias refusals and drop all five temporary grants.
Integration 1721/1722 remains queued; it receives no CI acceptance credit.
Canonical acceptance remains 15/460 leaves, weighted 3.48%. Independent hardware roots, complete authority cleanup and measured startup improvement remain open. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX, then completing both full EriX guest-build generations, remains mandatory and unproven.
Explicit READ now governs admission and hardware activation. No-access mappings retain backing with USER/WRITE clear and NX set; write-only and execute-only requests are rejected without adding READ.
Twenty-four actual CPL3 calls preserve earlier witnesses and cover no-access protection, write-only refusal, MAP-only frame derivation, denied READ and unmap after both frame grants are dropped.
Integration 1723/1724 remains queued; it receives no CI acceptance credit.
Canonical acceptance remains 15/460 leaves, weighted 3.48%. Authorized protection restoration, independent hardware roots, complete authority cleanup and measured startup improvement remain open. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and completing both full EriX guest-build generations remain mandatory and unproven.
The Kernel implementation permits representable no-access/R/RW/RX changes through current exact-backing grants and aliases while active or inactive. It removes historical access ceilings and original-slot equality while preserving current VSpace MAP, selected frame rights, kind/range/identity checks, W^X, explicit READ, backing custody and failure ordering.
Actual user instructions write, execute, rewrite and execute managed RAM, check narrow alias authority and final disposal, while a reused device slot cannot authorize unrelated backing. Every prior marker remains required.
Full semantic authority review remains open. Integration 1725/1726 remains queued and receives no completed CI acceptance. The separate older ext4 deadline report remains open.
Canonical acceptance remains 15/460 leaves, weighted 3.48%. Complete POSIX protection support, Process endpoint scope, independent hardware roots, complete authority cleanup and measured startup improvement remain open. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and completing both full EriX guest-build generations remain mandatory and unproven.
Original 60/120-second guest limits, existing markers, exact component signatures and retained packaged artifacts remain required; image warnings and QEMU stderr are absent. No startup speedup or independent hardware-root acceptance is inferred.
Integration 1727/1728 remains queued and has no completed acceptance; earlier ext4 deadlines remain tracked in Integration report 73. Complete authority cleanup, external toolchain rebuilding within EriX and both full guest build generations remain open. Canonical acceptance remains 15/460 leaves (3.48% weighted).
Full semantic authority and inline-documentation review remain open. Integration 1729/1730 remains queued and has no completed acceptance; earlier ext4 CI deadline failures remain unresolved. Canonical acceptance stays 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and completing both full EriX guest-build generations remain mandatory and unproven.
The unreachable raw-VA fallback is removed, and complete preflight rejects missing or ambiguous backing metadata before any range effects. No new userspace operation or capability grant is introduced. This is preparatory work for owned address spaces; independent roots and their switching/reclamation proof remain open.
Both allocator scenarios require the new same-VA/different-backing byte-and-leaf proof after complete cleanup, retaining every preceding marker and the original 60/120-second deadlines.
Complete semantic authority and inline-documentation review remain open. Integration 1731/1732 remains queued and has no completed acceptance. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and its runtime inside EriX and completing both full EriX guest-build generations remain mandatory and unproven.
User leaves, malformed geometry and invalid recursive identity are refused.
Both allocator scenarios require successful baseline capture before their original marker sequence, with capability grants and original 60/120-second deadlines preserved.
Integration 1733/1734 remains queued at the latest retained observation and has no completed acceptance. Per-VSpace population, CR3 activation, invalidation and live-root reclamation remain open, and no speedup is claimed. Full semantic authority and inline-documentation review also remain open. Canonical acceptance stays 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and completing both full EriX guest-build generations remain mandatory and unproven.
No new userspace authority, original native exploit or universal boot failure is claimed.
Integration 1735/1736 remains queued and has no completed acceptance. Private root population, CR3 activation, live-root reclamation and full semantic authority/documentation review remain open; no speedup is claimed. Canonical acceptance stays 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and both full EriX guest-build generations remain mandatory and unproven.
Ordinary anonymous stack materialization now rejects addresses outside the existing user domain, and direct bootstrap writes require retained writable registered backing.
Private root population, CR3 activation, CPU residency, live-root reclamation and complete semantic authority/documentation review remain open; no speedup is claimed. Canonical acceptance stays 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and both full EriX guest-build generations remain mandatory and unproven.
Canonical phase acceptance remains 15/460, weighted 3.48%.
It adds no user grant or real TCB context mutation; original user-mode witnesses and deadlines remain.
Full semantic authority/documentation closure, private-root readiness/activation and live-root retirement remain open. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Every allocation is retained before parent/recursive rebasing; failed construction or capability publication releases unpublished storage, and final teardown disposes never-activated tables after mapping cleanup. Process mappings, readiness, actual CPU residency and live-root retirement remain open under the owned address-space design.
No temporary grants survive.
Seven host controls pass; a fresh 4 KiB allocation consumes 4 KiB instead of 8 KiB, and a bounded storage trace reduces refusals from 20 to 15 without establishing latency improvement. Both native allocator scenarios require actual global-allocation geometry and payload-reuse checks, then pass all prior service-readiness gates under the unchanged 80 MiB reservation and 60/120-second deadlines.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Complete CI review remains required; earlier image/input failures remain separately tracked without unchanged retries. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Physical addresses never become pointers. This prepares the population boundary in the owned address-space design; process mapping population, readiness, activation, CPU residency and live-root retirement remain open.
Eight added host controls cover actual independent traversal, a peer's physical edge, malformed directory/parent metadata, path bounds, absent and huge paths, real Vec capacity refusal, independent disposal and a 72-table directory.
The lifetime witness rejects a peer's physical edge and restores the original before error propagation, while retaining all prior independent-copy, failed-publication and exact-disposal checks. It requires the ordered, unique index-byte metric before custody success.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Complete CI review remains required. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Numeric leaf entries confer no authority; the exact caller and backing custody remain prerequisites.
UNPUBLISHED_LEAF_EDIT_OK requires actual retained backing and distinct private leaf entries at one VA, protection, withdrawal and peer survival.
Complete semantic authority and inline-documentation closure remain open.
Complete CI review remains required. Live mapping transactions must coordinate frame/registered/physical inventories and withdraw private references before releasing backing; process readiness, activation, CPU residency, invalidation and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding the external Rust/LLVM toolchain and runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Run any still-required shared-active effect after preparation; on failure discard the guard before releasing newly retained backing.
Unmap must restore the selected root's supervisor-template policy and withdraw its process-backing reference before release. Final teardown and subsystem reset must dispose never-activated table ownership before relinquishing mapped backing. Native coverage must inspect actual private leaves after ordinary admitted mapping/protection/unmap calls, including current rights, backing identity, peer independence and cleanup. Registered image/stack and physical/device range inventories still require their own coherent range transactions and per-leaf cache/permission policy.
Existing source, warning, authority and timing gates remain required. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both full EriX guest-build generations remain mandatory and unproven.
Ordinary private mapping population — 23 September 2026: the signed Kernel now connects admitted ordinary managed/DeviceFrame and Kernel-anonymous mappings to exact never-activated private leaves. Refusal preserves its error and drops staging before backing rollback; success commits without allocation and then publishes the row or changed rights.
PRIVATE_MAPPING_POPULATION_OK follows actual CPL3 managed/DeviceFrame operations whose private leaves must match admitted backing, permissions and final supervisor restoration. All earlier witnesses, grants and deadlines remain required.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Complete CI review remains required. Previous Kernel 664/665 and Docs 1029/1030 succeeded with eight reviewed complete logs and zero final warnings; their Integration runs and earlier separately tracked failures retain independent acceptance. Registered image/stack and physical/device range transactions, supervisor-backing reconciliation, readiness, activation, CPU residency, invalidation and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding external Rust/LLVM/runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
All nineteen timeout transcripts lack VFS_IO readiness and contain no scenario-forbidden fault markers.
The ext4 report remains open. Complete corrected CI acceptance for Kernel #33 and Kernel #34 also remains open; passing selected allocator cases does not stand in for unreached workflow gates. Newer private mapping population checks and their CI remain separate, and full external-toolchain/runtime and EriX guest rebuilding are still required.
All prior grants, deadlines and witnesses remain required.
Static checks cover 3,221 authored code files below 1,000 lines, 75 manifests, 259 exact Git pins, 174 direct missing_docs gates and 93 conventional crate roots; whole-code semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Complete corrected CI remains required before bug closure. Registered image/stack and physical/device range transactions, readiness, CR3 activation, residency, invalidation and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding external Rust/LLVM/runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Both new full runs pass the ext4 scenarios; the original timeout cause is still unproven, so Integration #73 remains open for attribution and timing review.
Later leaf/population/ancestor cohorts retain their own CI acceptance. Complete semantic authority review, root activation, external Rust/LLVM/runtime rebuilding and both complete EriX guest-build generations remain required. Canonical acceptance stays 15/460 leaves, weighted 3.48%.
Six new controls cover preparation refusal, ordering, geometry, outside leaves, explicit flags and GLOBAL invalidation. Exact source signatures and packaged artifacts verify with no image warnings or QEMU stderr, under unchanged grants and deadlines.
Complete semantic authority and inline documentation closure remain open.
Integration regression acceptance remains open. Complete corrected CI remains required before this bug closes. Later source cohorts retain their own acceptance, and original ext4 timeout attribution remains open in Integration #73. Private range transactions, complete multi-range activation, readiness, CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%. Rebuilding external Rust/LLVM/runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Private physical-range population — 23 September 2026: the signed Kernel now mirrors admitted complete ranges in never-activated VSpace tables before inventory publication. An exclusive rollback guard copies each touched original table once, retains new child pages, and restores original entry bytes before dropping new storage on allocation/resolution failure, cancellation or shared-effect refusal. No activation handle, new capability or fixed page-count ceiling is added.
Native prepared-range refusal restores prior leaves and table count. All earlier markers, grants and 60/120-second deadlines remain required.
Static checks cover 3,228 authored code files below 1,000 lines, 75 manifests, 259 exact Git pins, 174 direct missing_docs gates and 93 conventional crate roots; complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Registered image/stack population and withdrawal, boot-backing retirement, whole multi-range activation, readiness, CPU residency, invalidation and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
This closes CI review for this exact private-leaf construction graph; subsequent mapping/range implementations retain their own CI acceptance.
Registered image/stack population, readiness, actual root residency, invalidation, complete semantic authority review and external Rust/LLVM/runtime rebuilding plus both complete EriX guest-build generations remain required. Canonical acceptance stays 15/460 leaves, weighted 3.48%.
The new native marker requires real range API denial before table effects and complete original cleanup.
Complete semantic authority and private inline-documentation closure remain open. Integration regression acceptance remains open. Complete corrected CI is still required before this bug closes. Registered private image/stack population and withdrawal, baseline retirement, readiness, actual root residency, invalidation and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; rebuilding external Rust/LLVM/runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
A later geometry, allocation, resolution or shared-effect refusal restores every prepared private edit before new table storage is released. Numeric geometry and leaf descriptions confer no authority, and these tables remain never activated.
The existing lifetime witness prepares three discontiguous private intervals and verifies their complete rollback after shared-effect refusal, preserving peer state and retained backing. Every prior grant, marker and 60/120-second deadline remains required. Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Registered image/stack import, withdrawal, coherent baseline/source retirement, readiness, actual CR3 residency, invalidation and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; rebuilding external Rust/LLVM/runtime inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
No input selector, capability or backing lifetime is broadened.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Complete corrected CI is required before the report closes. Registered image/stack import and withdrawal, coherent baseline/all-root retirement, readiness, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Private user leaves clear GLOBAL and reject W+X.
Three added independent policy controls cover backing presence, cache preservation, effective permissions, metadata drift and W+X refusal.
The new lifetime witness verifies late W+X refusal with complete rollback, exact data/image backing and permissions, idempotent data registration, complete supervisor restoration, peer survival and backing cleanup. Every prior grant, marker and deadline remains required. These observations concern never-activated private tables; they do not establish CR3 residency or a performance improvement.
Complete semantic authority and inline-documentation closure remain open.
Coherent baseline/all-root boot-source retirement, readiness, both AP paths, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
This closes CI review for this exact ordinary private mapping graph; subsequent mapping/range implementations retain their own CI acceptance.
The latest registered data/image checkpoint has separate selected native acceptance and pending CI. Coherent baseline/all-root retirement, readiness, actual root residency, invalidation and complete semantic authority review and external Rust/LLVM/runtime rebuilding plus both complete EriX guest-build generations remain required. Canonical acceptance stays 15/460 leaves, weighted 3.48%.
Later-owner, allocation, source and effect refusal restore the prepared group.
Both mapping contracts require the new ordered unique retirement witness after the prior invalidation marker. It checks effect refusal, reader policy, independent backing, saved restoration, future copies and full scratch cleanup after actual shared retirement. Every earlier grant, witness and 60/120-second deadline remains required. These are never-activated private tables; no CR3 residency or performance improvement is inferred.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Readiness, both AP paths, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Missing, huge or drifted paths refuse before alias publication.
Twelve focused physical-access controls cover ordered malformed-path refusal, backing/policy drift, byte bounds, restoration and partial failures.
The lifetime contract requires the new ordered unique SUPERVISOR_WINDOW_CUSTODY_OK after range-geometry denial and before aggregate table-custody acceptance. Every earlier grant, witness and 60/120-second deadline remains required.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Remaining late structural writers, readiness, both AP paths, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Existing owner-isolation controls remain required. The initial strict Clippy refusal concerned a redundant test-fixture expression; the simplified and formatted changed source passes the complete matrix.
Both mapping contracts require ordered unique NONMUTATING_LEAF_OBSERVATION_OK after huge-leaf geometry. The witness observes every page of a real 2-MiB PAT mapping, repeats through an ordinary PT, refuses an absent parent without creating a child, and checks a readonly ancestor while CR0.WP is enabled. All earlier lifetime, retirement, range and service witnesses, grants and 60/120-second deadlines remain required.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Remaining structural writers, root readiness, both AP paths, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Reservation refusal leaves previous ownership, parent and root binding unchanged. Only successful publication binds the first observed active root; later mismatches refuse.
Both mapping contracts require ordered unique SHARED_TABLE_OWNERSHIP_OK after nonmutating leaf observation. All earlier lifetime, retirement, range and service witnesses, grants and 60/120-second deadlines remain required.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Routing every structural mutation through its actual root owner, supervisor reachability, both AP paths, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Each original observation error survives mandatory fixture cleanup. Earlier markers, grants and original 60/120-second deadlines remain required.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Full structural-writer routing, supervisor reachability, both AP paths, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Later borrowing refuses missing custody or a different root before recursive access, then rechecks that edge under table and local interrupt guards.
Operation-local hints cannot outlive this custody.
Seven new production binding controls cover one-time adoption, invalid identity and policy, absence, mismatch before callback, preserved state after refusal and independent hardware metadata.
Each requires ordered unique BOOTSTRAP_ROOT_CUSTODY_OK before its earlier witnesses and forbids adoption failure. Earlier markers, grants, cleanup and original 60/120-second deadlines remain required.
Complete semantic authority and inline-documentation closure remain open.
Integration regression acceptance remains open. Private-root writer routing, supervisor reachability, both AP paths, actual CR3 residency and live-root retirement remain open under the owned address-space design. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Retaining the table binding cannot preserve withdrawn source access, rebind the original tables or establish physical RAM reclamation.
Private-root readiness and activation remain open under Kernel #22, with Kernel review, manual review and Phase 6 completion. Acceptance remains 15/460 leaves, weighted 3.48%; external toolchain/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
Every previous marker, grant, cleanup assertion and original 60/120-second deadline remains required.
The original pre-entry startup-silence failure remains open. No unchanged failed input was retried for acceptance. The three new reports use bug_report with applicable bug, security, ci, refactor and phase-6 labels; the two corrected defects remain open for publication CI review.
Owning Kernel review, Bootloader review, Integration review, manual review and Phase 6 completion remain unfinished. Owned address-space routing and residency, semantic authority and inline-documentation closure, and older CI regressions including release physical-directory input remain open. Canonical acceptance remains 15/460 leaves, weighted 3.48%; external Rust/LLVM/runtime rebuilding inside EriX and both complete EriX guest-build generations remain mandatory and unproven.
All previous grants, timing and cleanup requirements remain required.
The storage report remains open for complete CI review. The separately retained pre-entry startup stall, development COM1 directory failure and other older regressions remain open without unchanged-input acceptance retries. Kernel PR 3, Integration PR 12, manual PR 4, owned address-space routing and Phase 6 completion remain unfinished. Actual private-root routing, readiness, residency, invalidation, complete authority and inline-documentation closure, external Rust/LLVM/runtime rebuilding and both complete EriX guest-build generations remain mandatory and unproven. Acceptance remains 15/460 checklist items, weighted 3.48%.
Native process/thread ownership specification — 4 October 2026
The complete ownership specification defines one original process with shared CSpace/VSpace, capability/fd/action/cwd/creation-mask policy and distinct authenticated native execution occupations. An explicitly sealed original-process factory and retained thread handles authorize Prepare/Start and cleanup; clients gain no global Process route, root or MAP grant. The actual original creator and counted enrollment precede Start. Native membership and caller origin never come from payload labels or copied ClientSlot policy.
The contract separates thread-only exit from process exit. Initial-thread departure preserves peers and shared resources. Last-thread preparation serializes creation/Start, settles potentially startable original members and retains the final context for process finalization. Whole-group retirement drains every original member/provider before shared authority reclamation and emits one process event. Join/detach arbitrate one original target, preserve joinability on cancelled uncommitted joins and reconcile committed disposition through reply loss without affecting a replacement generation.
Stack/guard, caller-owned storage, TLS/errno/module/destructor and complete architecture state have explicit original lifetime and reclamation boundaries. Current OIR1's 64-byte header uses bytes 56–63 for terminal status; the proposed versioned OIR2 extent is 72 bytes, adding thread identity/generation at 64–71. No runtime ABI/codec is changed by this specification. Mediator process policy remains shared while real enrolled threads own distinct masks/handlers. Fork/exec, native provisioning, target geometry, memory/loader/linker/libc and real workload adoption are coordinated requirements.
Integration's native lifecycle contract records independent actual membership, blocked-peer progress, initial/last exit, TLS/context, guards, join/detach, failure/reuse, group loss, profiling and tool-consumer evidence. The imported-tool source/version/options and transitive interface matrix remains unresolved. Current one-TCB asynchronous calls do not implement native shared-process threads.
Specification acceptance completes the ownership specification only. Native process/member/factory/origin mechanisms, thread-only exit, join/detach, per-thread TLS, libc/imported consumers and real profiling remain open. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.
Three signed commits across Kernel, Docs and Integration publish 17 paths: 14 maintained documentation sources and three catalog files containing four selector updates. No runtime or Cargo source changes; no Rustfmt inputs. Read-only source/Git inventory records all 269 compiled edges and 162 catalog selections coherent, 4,346 code files below 1,000 lines, retained missing-docs gates, and 153 guards across 76 workflows. All 76 feature trees are clean except preserved Meta cache. Rootd and helper catalog entries retain independent compiled helper
cc878220040dfa741491249434d6b8f8fe2252f7.Signed documentation/adoption: docs af376f65, integration 5daf30c3, kernel 9660dacf.
Tracking: ownership specification, native implementation, socket consumers, libc, compatibility ELF/TLS, phase completion.
The complete ownership specification is source-accepted. Every native runtime, thread/TLS, imported consumer, profiling and guest-build implementation/evidence requirement retains its existing open scope.
Original process lifetime storage — 4 October 2026
Process-window observations consult the current owner; copied metadata cannot enroll another member or acquire authority.
Admission requires a reserved native identity and actual objects, reserves both publication directories before retaining backing, and publishes no half-owner on refusal.
Seven new controls are authored and unrun: sole window sealing/current observation, contradictory association refusal before hardware effects, copied-peer refusal without an extra backing reference, actual storage failure at both admission allocations, constructor cap-collision rollback, failed final release and generation reuse, and captured origin through actual cleanup/reuse. Invalid VSpaces now refuse at admission; initial-stack failure uses an unregistered high range in the real original VSpace.
Genuine member factories/enrollment, versioned thread origins, thread-only exit, departed-leader survival, join/detach, TLS and complete libc/upstream consumers remain required and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.
Rootless construction observes the sole actual ceiling, and malformed-window controls verify refusal without altering copied metadata.
Authenticated process and execution origins — 4 October 2026
CLAIM requires both complete keys; COLLECT requires neither. Old/partial/mixed origins refuse before native transfer/output effects.
Copied metadata and parsed bytes grant no authority, liveness or native attestation.
Posixd preserves full successful CLAIM origin in its original counted call record before interpretation and refuses unknown execution IDs or stale thread generations before request effects. Additional native members still require the open factory/enrollment implementation. Independent modeled controls preserve the denied original owner, empty refusal, unrelated pending peer and lease generation; only an enrolled writer can unblock that peer.
Genuine shared-process membership/factories, departed-leader survival, thread-only exit, join/detach, per-thread masks/TLS and full libc/imported-tool consumers remain required and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.
Original prepared native member custody — 4 October 2026
A noncopy process-bound Kernel factory requires actual held Process SEND of native Process kind in the Running caller's window plus an actual exact-stage GRANT install grant naming a Created initial process. The grant supplies target evidence, never Process authority; scope and rights remain unchanged. An explicit u64 total occupation budget includes the initial execution, and zero/exhausted capacity refuses.
Stale or exhausted factory admission refuses before prospective ID/global execution generation allocation. Native keys and factory serials never wrap. Parsed metadata, copied snapshots, ordinary endpoints, inert rights, foreign/stale targets and outside-window grants cannot authorize creation.
Factory release refuses until preparations withdraw, preserving the original view and quota. Old member/factory observations cannot dispose replacement occupations. Group terminal/cleanup freezes admission and preflights/drains original preparations before shared inventory effects; a refused final backing release retains the original process owner/reference and cleanup-only initial record for retry. Additional preparations cannot enter legacy initial Start/current-context/window/receiver/child/process mapping/write, install/revocation target, dynamic-link cleanup, CPU-time or process termination/destruction paths. Created native activity notifications have no effects.
Nine independent actual-object controls are authored and unrun: shared objects/window and total capacity; native authority negatives; legacy initial-path/copied-peer refusal; member/factory reuse; actual TCB/member allocation failure; dropped member views and final release failure; group terminality and one event; dropped factory retention; nonpristine refusal and exact cleanup retry.
No userspace factory capability/wire carrier or runnable member is published. Genuine Start/context, original stack/TLS, mediator enrollment, running-peer scheduling, thread-only exit, departed-leader survival, join/detach, whole-group CPU aggregation, per-thread masks and libc/imported consumers remain mandatory and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.
Checklist acceptance records source implementation under the testing waiver.
Retained original member mapping backing — 4 October 2026
Checked byte ranges carry access observations, no process selector or grant. The actual VSpace retains noncopy original reference records; a dropped view leaves native custody and cannot duplicate the same member continuation.
Unmap/remap of the same virtual or physical address cannot validate an old context. Old detached release has no hardware effect on a replacement VA. Live validation requires the same original occupation and current required/forbidden permissions; stored access never restores a withdrawn grant.
Positive release records each completed page and retains the same cleanup-only continuation through later managed-frame refusal. Last process backing release and final VSpace teardown refuse before effects while context/detached custody remains. Production initialization cannot erase retained contexts, process references or active roots.
Eight actual-object controls are authored and unrun: retained old backing and untouched remapped bytes; overlapping observations/multiple members/dropped views; malformed, borrowed and contradictory ranges; actual capture/detachment storage failures; permission attenuation and last managed backing release; completed-prefix refusal followed by native abort retry; dropped group context and refused last process reference; and mapping/context serial exhaustion.
The full native carrier/context/enrollment/Start issue stays OPEN with all eight complete-transaction criteria pending. Complete capability transfer/rollback/removal, original creator continuation, code/stack/guard/TLS/architecture, positive mediator enrollment, genuine once-only Start, all-running-member group stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Full thread lifecycle, departed-leader survival, thread-only exit, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.
Source completion of this prerequisite does not accept the unfinished initialized-running-member criterion.
Original native member carrier custody — 11 October 2026
Factory READ/MINT/MANAGE/GRANT and member READ/WRITE/EXECUTE/MANAGE/GRANT have separate observation, construction/context/Start, retirement and unique delegation meanings.
Publishers require the actual original source and Running custodian/window, reserve real metadata/native storage before consumption, and preserve the same noncopy source on refusal. Fabricated metadata, numerical targets, copied observations and old serials cannot construct or select native custody. One native stack lease preserves original storage through callbacks outside directory locks; busy owners cannot be erased or reused.
Unique delegation requires actual GRANT, active original scope and exact subset rights. Owned invocation intake authenticates source GRANT; private custody retains only the requested recipient mask plus the original GRANT needed for handoff. Final recipient masks/receipts remain exact, including zero; repeated collection cannot recreate a native object.
Factory admission freezes before refusal while members remain; metadata restoration cannot resume ordinary authority. Busy/refused cleanup retains the same original group, quota and remaining owners. Production reset refuses actual custody; host quiescent reset preserves carrier serials.
Fourteen independent actual-object controls are authored and unrun: fabricated metadata; actual publication/window/mask refusal; serial/slot reuse; unique attenuation and original rollback; READ-only local relocation; failed factory removal with actual admission frozen; remote group abort; busy original group refusal/retry; occupied/widened/inert moves; real destination allocation failure; allocation-free prepared transport commit/rollback; private owned request handoff versus final rights; returned unique collection/descriptive replay; and exact zero owned recipient rights.
The complete native capability/context/enrollment/Start design stays OPEN with all eight complete-transaction criteria pending. Full operation framing/native/user adapters, actual creator CLAIM and original counted enrollment intent/replay, original code/module/stack/guard/TLS/complete architecture, positive mediator enrollment, once-only genuine Start, all-running-member stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Thread-only exit, departed-leader survival, join/detach and complete compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.
Original claimed native preparation — 11 October 2026
Original claimed native preparation now requires actual held factory MINT and actual original successful Serving CLAIM under the same live registered receiver. Parsed origins, numerical identities and labels cannot construct the borrowed proof. The captured caller's process must equal the actual factory scope. Completion, replaced/removed RECV registration, original caller retirement, route loss or group freeze refuses before construction.
Changed intent refuses. Histories retain data only, with no extra backing/cap alias/process event; group disposal withdraws original remote custody before native identity/shared disposal.
They cover one genuine member/full-quota same-member and retired replay, changed intent/destination/rights/epoch, actual queued/completed/removed RECV refusal, foreign genuine creator, moved historical replay, actual continuation allocation refusal/retry, replaced receiver registration, foreign MINT plus equal RECV possession, fresh quota refusal before allocation, claimed member/group cleanup with one event, literal byte positions, every reserved byte and obsolete/partial/trailing/missing-selector frames.
The complete native control design stays OPEN with all eight full-transaction criteria pending. Full factory/member operation/native-user adapters, actual counted creator/enrollment intent, original code/module/stack/guard/TLS/complete architecture, positive enrollment, once-only genuine Start, all-running-member stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Complete thread lifecycle, departed-leader survival, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.
Immediate native preparation packet boundary — 11 October 2026
Already serialized admission avoids recursive lifecycle locking; hosted numeric addresses are never dereferenced.
Actual held factory MINT, original carrier scope/serial and live registered RECV for the same genuine outstanding Serving CLAIM remain mandatory. Creator/process attribution comes from the actual Kernel invocation owner, never payload labels. Every error preserves original intent and earlier custody; uncertainty cannot justify changed selectors or a successor.
Fourteen additional independent controls are authored and unrun: four literal/framing/identity/intent codec controls, four local-refusal/status/uncertainty bridge controls and six genuine native-packet/register/mapping controls. They cover replay across retired/replaced destinations, refusal before constructor/quota effects, absent genuine CLAIM, changed serial/wrong rights, exact zero rights, destination conflict, reserved registers and complete current writable mapping admission including gaps, revocation, stale VSpace and invalid addresses. Actual installed user instructions must check refusal and unchanged bytes before the original complete scenario oracle can pass.
Factory construction/provisioning, the complete operation surface, actual counted mediator row adoption and positive enrollment, original code/module/stack/guard/TLS/complete architecture, once-only Start, all-running-member stop/drain and real supervisor/loader/mediator provisioning remain required by the full native control design. All eight complete-transaction criteria stay OPEN. No whole running-thread acceptance is inferred from an unstarted packet boundary.
Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 sub-items under 167 decomposed parents. Full source acceptance remains independent of deferred execution.
Original native factory provisioning and READ — 11 October 2026
Original native factory control now exposes actual user factory creation/reconciliation at 0x5D and exact READ observations at 0x5E beside claimed preparation at 0x5C. Fresh creation independently needs actual held Process SEND and exact GRANT evidence for the original Created initial target. Carrier/CSpace/history storage reserve before publication; wrong own rights and zero/exhausted budget refuse before history allocation.
Indexed histories use Kernel-captured original current process/execution and the same operation key, never a payload actor. Complete original route/stage/destination/rights/budget intent reconciles the same factory after uncertain reply, setup-grant withdrawal, initial target Start, transfer, removal refusal or retirement. Changed parameters refuse. Held observations read current rights; transferred/retired descriptors are cleanup-only data and cannot recreate a cap, factory, identity or quota. A legitimate fresh key still requires independently held setup authority and an eligible Created target. Production reset refuses both live owners and retained histories.
TFC1 request64/TFR1 reply48 use one 112-byte creation packet; NTO1 request24/NTD1 reply48 use one 72-byte READ packet. Actual READ, current window, original serial and actual native indexed owner must agree; fake cap metadata or old serial cannot follow replacements.
Seventeen additional controls are authored and unrun: ten genuine native-object creation/READ/uncertainty/refusal controls, four independent literal codec controls and three checked bridge controls. They cover no-allocation same-original replay, changed parameters, grant withdrawal/initial Start, transfer/retirement/reuse, ordinary/weak/fabricated authority, actual allocation failure and occupied destinations, wrong rights/zero quota before storage, exact zero rights/full-width budgets, foreign actual execution, genuine factory/member/cleanup READ, reserved/partial/trailing frames, type-specific identity, original key/scope/budget/rights correlation, native status, uncertain output and local hosted refusal.
The maintained owned-invocation VM source adds 18 positive CPL3 calls for user creation/reconciliation, checked initial client Start after stage-grant disposal, genuine successful original CLAIM preparation/full-quota replay, actual factory/member READ, retired history, positive disposal and setup/carrier absence. Temporary Process SEND is removed before ordinary service work; only factory READ/MINT and member READ are retained for required operations. Hooks only observe original instructions/results, never perform effects or replace output. The new factory/preparation marker and original complete oracle require every new witness/user check.
The complete native control design stays OPEN with all eight full-transaction criteria pending. Real supervisor/loader/mediator deployment, target-generated counted thread storage/adoption, original code/module/stack/guard/TLS/complete architecture, positive original enrollment, once-only member Start and all-running-member stop/drain remain required. Full thread-only exit, departed-leader survival, join/detach and compatibility consumers remain open.
Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress stays 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 sub-items under 167 decomposed parents. Full source acceptance remains independent of deferred execution.
Counted startup tail repair — 11 October 2026
No old/trailing/partial/overwritten-tail fallback or new authority is added.
A disabled literal image requires zero count words and rejects obsolete overwritten-tail bytes. The maintained realm-startup VM source preserves its full oracle for two actual private mediators, authenticated readiness, peer-independent retirement/stale-handle refusal and ordinary successful shell exit. Its description now names the same canonical framing; no acceptance or marker is relaxed.
Bug source acceptance closes after complete repair, authored controls, documentation and coherent signed adoption, independently of deferred testing. The full native control design stays OPEN with all eight complete-transaction criteria pending. Actual counted thread storage/adoption, complete code/module/stack/guard/TLS/architecture, positive original enrollment, once-only member Start, all-running-member drain and real supervisor/loader/mediator deployment remain required. Full thread exit, departed-leader survival, join/detach and compatibility consumers remain open.
Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred execution.
Counted original execution storage — 11 October 2026
Older schemas/widths reject without aliases, inferred counts or fallback.
Public payload IDs, matching process labels or spare capacity cannot enroll another execution. Unknown/stale/unsealed/failed/native-draining delivery retains its ordinary native custody and refusal obligations. This introduces no extra receiver, process capability, member enrollment or runnable context.
Eleven additional execution/arena controls are authored and unrun: empty-capacity refusal, all-original-key admission, retirement/reconstruction prevention, incomplete identity atomicity, missing/previously occupied engine capacity, canonical row association, successful CLAIM/completion/retirement, errored CLAIM custody, spare-row unknown/stale refusal, real target ThreadSlot geometry/disjoint extents and independent grown geometry.
Two spare execution rows remain inert while the full existing oracle still requires two actual private mediators, authenticated readiness, independent peer retirement, stale-handle refusal and ordinary successful shell exit.
The full native member control and Start design remains OPEN with all eight original complete-transaction criteria pending. Additional prepared members, current original code/module/stack/guard/TLS and complete architecture state, positive original enrollment, once-only Start and all-running-member stop/drain remain required. Per-thread masks/TLS, thread exit, departed-leader survival, join/detach and all required compatibility consumers remain open.
Read-only source inventories record all 4,387 code files below1,000 lines, missing_docs denial at all 98 Cargo crate roots, and153 duplicate PR guards across76 workflows.
Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred execution.
Original complete member memory custody — 11 October 2026
Stack/TLS/code geometry and module/guard contradictions refuse before native reference publication.
Caller-slice mutation or dropped views cannot forget these conditions. Another original complete memory recipe cannot alias retained stack/TLS bytes until positive same-reference release.
Positive original release retains completed prefixes and refused native cleanup.
Nine independent actual-object controls are authored/unrun: complete original recipe and dropped-view custody, current guard mapping/copied condition ownership, malformed/overlapping/missing geometry, distinct-member exclusive stack/TLS, all capture allocation refusals, original TLS replacement/new-byte preservation, every user-visible guard inventory, current role/module contradictions, and frozen-scope positive cleanup. Existing native VM oracles retain their complete acceptance; this trusted Kernel API introduces no guest context operation or runnable member.
The full native member context/enrollment/Start design stays OPEN with all eight original complete criteria pending. Strict native context/user adapters and replay, real supervisor/loader/mediator adoption, all-running-member stop/drain, thread exit, departed-leader survival, join/detach and required compatibility consumers remain mandatory. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.
Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction is still unimplemented.
Original native machine custody and entry ABI — 11 October 2026
Private noncopy aligned images follow genuine execution and process generations through allocation refusal, dropped views, positive cleanup and ID reuse.
Hosted model images never provide privileged transfer or native execution proof.
Thirteen independent unit controls are authored/unrun: eight geometry/storage/default/refusal controls and five actual-object allocation/replay/TLS-change/identity-reuse/drop/host-transfer controls. The additional NATIVE_MACHINE_STATE_OK marker requires every existing full native oracle and user check.
The full native member context/enrollment/Start design stays OPEN with all eight original complete criteria pending. Full running-member drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread exit, departed-leader survival, join/detach and required compatibility consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.
Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.
Original native state reconciliation preflight — 11 October 2026
Existing private storage cannot bypass this admission. An additional original-object control covers missing-baseline allocation refusal, unchanged Created identity/image, same-original Start retry and allocation-free unchanged fully prepared replay; it is authored and unrun. Private noncopy aligned images follow genuine execution and process generations through allocation refusal, dropped views, positive cleanup and ID reuse.
Hosted model images never provide privileged transfer or native execution proof.
Fourteen independent unit controls are authored/unrun: eight geometry/storage/default/refusal controls and six actual-object allocation/replay/TLS-change/identity-reuse/drop/host-transfer controls. The additional NATIVE_MACHINE_STATE_OK marker requires every existing full native oracle and user check.
The full native member context/enrollment/Start design stays OPEN with all eight original complete criteria pending. Full running-member drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread exit, departed-leader survival, join/detach and required compatibility consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.
Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.
Retained initialized native context — 11 October 2026
Actual current CPU policy, private initialized FS/FP/vector state and independent processor baseline remain mandatory.
Remapping cannot substitute backing between validation and effects. Write refusal retains the native pending record, original machine/reference custody and immutable input/completed-prefix progress. Same input retries without another context occupation or allocation; changed arguments/TLS/geometry refuses.
Ordinary original memory-reference release refuses while that context depends on it. A retired serial cannot erase a later context on the same unstarted member.
Eleven actual-object controls are authored/unrun: exact initialized bytes/private GPR defaults, full-quota allocation-free replay and changed input, allocation refusal before effects with exact retry, input extent/initial-stack ABI refusal, cross-member memory denial, dependent release/stale same-member refusal, dropped views/member cleanup, frozen cleanup, original TLS replacement with untouched new bytes, whole-group disposal and actual page-write refusal with immutable pending input/completed-prefix retry.
The full native member context/enrollment/Start design remains OPEN with all eight original complete criteria pending. Positive mediator enrollment, once-only Start, running-group drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread lifecycle and required consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.
Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.
Original independently usable native state — 11 October 2026
Original PKRU is retained with the same noncopy FS/GS/feature-disable owner, initialized Kernel zero precedes scoped dispatch and selected-original return restores exact state with the required register inputs and compiler memory boundary. Actual instruction availability cannot silently narrow the preserved state. Current profile changes refuse old-image admission. Ordinary images enable no hardware, allocate no protection keys and change no native mapped authority through this boundary.
The separately selected native diagnostic requires actual PKU/XSAVE support and owns isolated BSP CPU configuration before any original native execution. Three original CPL3 participants require initialized zero and distinct PKRU values across every native return, handoff, blocking and hardware deadline wake. Privileged dispatch independently observes actual zero and unmanaged components1/9; hooks supply no register effects.
Native deadlines/stall/exit and ordered/unique marker acceptance stay intact. One independent descriptor/default/host-refusal control, strict scenario/direct-builder selection controls and the actual native diagnostic are authored and unrun.
The full native member context/enrollment/Start design remains OPEN with all eight complete criteria pending. Strict actual member-WRITE user context/creator/intent/caller-copy controls, positive mediator enrollment, once-only Start, running-group drain and real supervisor/loader/mediator deployment remain mandatory. Required thread lifecycle/consumers and both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.
Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.
Original counted member context — 11 October 2026
Unknown roles, malformed input and dirty reply reservations refuse.
A noncopy member continuation retains immutable original input and genuine memory/context views through refusal. Exact replay uses the same original occupation; changed intent, a withdrawn ready view or replaced backing cannot recreate a context.
A separate packet page preserves original unmapped-gap refusals. Both maintained positive scenarios keep every complete factory/machine/invocation/protection-key oracle and additionally require NATIVE_MEMBER_CONTEXT_OK. Hooks supply no context effect.
The full native context/enrollment/Start design remains OPEN with all eight complete criteria pending. Positive original mediator enrollment, revalidated once-only member Start, running-group drain and actual supervisor/loader/mediator deployment remain mandatory. Required thread lifecycle/consumers, both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.
Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.
Positive original native enrollment — 11 October 2026
Actual current member WRITE, expected member/context serials, ready original context, active native scope and identical successful still-Serving creator CLAIM/row captured during preparation are independently required. Sealed noncopy admission borrows genuine member/context/native claim; scalar labels and descriptive receipts cannot construct it.
Changed context/creator/row, stale current authority or closed/replaced claim refuses. Ordinary context withdrawal cannot erase positive enrollment.
It binds immutable member/context input before native enrollment, and requires exact output matching the earlier initialized process/thread observation before committing distinct-member intake.
Both complete CPL3 scenarios additionally require NATIVE_MEMBER_ENROLLMENT_OK: actual user instructions use returned member/context keys and successful CLAIM, check inaccessible spans/reserved fields/row refusal and exact replay, then positively dispose the same unstarted member. Hooks perform no effect; every original context/machine/protection/invocation oracle remains.
The full native context/enrollment/Start design stays OPEN with all eight complete criteria pending. Revalidated once-only Start, all-running-member drain, actual ordinary thread-creation/deployed supervisor/loader/mediator provisioning and required per-thread lifecycle/masks/ELF/TLS/consumers remain mandatory. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.
Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.
Original member Start and group retirement — 11 October 2026
Current actual member EXECUTE, original positive context/enrollment and counted row are independently required. Sealed noncopy admission borrows genuine native objects; process/thread IDs, creator delivery, saved pointers and copied receipts supply no authority.
Pager, child supervision and final CPU totals belong to the shared process; a running member may bind a child while its initial peer blocks through actual held GRANT.
Destruction refuses original active user/kernel intervals and runnable/blocked members before cleanup custody or remote/shared effects. Positive drain settles mappings, erases private context/machine/register storage and folds member CPU totals before identity reuse; refusal retains original custody and positive release progress.
Local acknowledged replay is a descriptive observation and performs no new native effect.
The separate kernel-running-members-positive scenario requires both original invocation and protection-key fixtures and preserves every existing factory/context/enrollment/machine/protection/invocation/activity/watch/deadline/terminal oracle, additionally requiring NATIVE_RUNNING_MEMBERS_OK.
The complete native context/enrollment/Start design remains OPEN with its original eight full criteria pending. Ordinary production creation/deployment, loader ELF/TLS construction, per-thread masks, join/detach, lifecycle and required consumers remain unfinished. Both full EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Complete native creation/deployment and required consumers remain unfinished.
Original per-thread signal ownership — 11 October 2026
Payload IDs, handler labels and copied receipts supply no peer authority.
Shared actions remain one process policy: unavailable defaults preflight all task/process pending state, Ignore discards unselected group conditions, and reset-hand selection cannot overwrite a later shared action change.
Wrong-task or other settlement refusal preserves the original token; successful matching cancellation/selection is once-only. Selected occurrence stays with its task while another member's self signal cannot interrupt a peer wait. Refused/uncertain caught publication retains original native owner/result and freezes only its original task; eligible default termination and authentic terminal retirement retain whole-process duties.
Seven additional counted mediator/policy controls are authored and unrun for creator mask inheritance, shared actions, separate process/self consumption, peer-pending refusal and Ignore, task-only uncertain handoff, default eligibility, retained member readiness and wrong-task token refusal/retry/once-only settlement.
The complete native context/enrollment/Start design remains OPEN with its original eight full criteria pending. Normal production creation/deployment, ELF/TLS, join/detach, lifecycle and complete libc/native consumers remain unfinished. Both full EriX guest build generations and rebuilding external Rust/LLVM inside EriX remain mandatory and unperformed.
Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Complete native creation/deployment and required consumers remain unfinished.
Original initial-process TLS native custody — 12 October 2026
Original initial-process TLS now has a distinct native operation 0x62 with ITI1/ITR1, independently requiring the actual Running caller's Process SEND endpoint and exact Created initial-process stage GRANT. Scalar labels, copied receipts and current execution alone cannot construct it. Caller-counted module/guard/template framing validates every field/extent/count/reserved byte without private count/size limits, preauthorizes before copied-input allocation and preserves refusal/spare bytes.
Machine or byte refusal retains pending original custody; changed input/creator/occupation/mapping cannot adopt it. Actual complete caller READ/WRITE span preflights before copy/effects, and the same original caller/span revalidates before complete reply publication.
Initial Start refuses pending state, changed entry/top, invalidated original mappings/guards or machine policy before runnable publication.
They cover complete framing/overflow/refusal/correlation, actual Process/grant/initial role, prefix/zero/stack/startup preservation, same-original ready replay, peer/changed-input refusal, guard and remap conditions, allocation cut points, unauthorized allocation refusal and positive abort/reuse. No hook supplies effects.
Actual Loaderd/Dynlinkd/Procd ELF image/patch producers, LibCstd errno/TLS/descriptor accessors, ordinary native creation/deployment, inherited FP state, exit/join/detach/module/unload/destructors and all required consumers remain unfinished. Existing executable/artifact TLS refusal stays until every initial and additional producer is migrated. Both complete EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. No narrower native or parser endpoint replaces complete acceptance.
Full native/TLS/runtime/lifecycle/consumer acceptance remains open.
Tracking: complete TLS, full native thread acceptance, libc, thread consumers, phase completion.
Initial TLS materialization storage and native readiness — 12 October 2026
Old 64/88-byte bodies reject. Procd inserts independently retained actual Process SEND route, exact stage grant, native created identity and original intent; the payload cannot select them. Identical repeats retain progress; changed descriptions refuse. Stale, empty, reordered, overflowing and overlong input refuses before mutation; fragments cannot overwrite the private native header or reply reservation.
Both ordinary and staged commit require complete mappings/patches/canonical TLS input and actual native operation 0x62 while the original stage grant remains held, before grant disposal, transfer or Start. The allocation-free client hashes complete original input across transport and requires exact positive extent and complete identity/intent/TP correlation. Only the complete original native result publishes readiness; repeat gating cannot reset live bytes. Loaderd's noncopy materialization owner retains acknowledged-abort responsibility after a lost streaming reply and refuses incomplete commit or input replacement.
Eighteen new unit controls and an independent capacity/descriptor/refusal suite are authored and unrun. Coverage includes complete original correlation, capacity refusal before creation/cleanup, input order/header/reply/spare protection, malformed/incomplete input before native effects, once-only readiness, uncertain native/abort outcomes, refusal of original owner replacement, positive cleanup erasure and lost streaming replies.
Actual authenticated ELF template/immutable registry/image production, dedicated stack/guard/TLS/registry geometry, Dynlinkd original module correlation/exact-width patch streaming, libc errno/TLS/descriptor accessors, ordinary additional thread birth/deployment/creator FP inheritance, exit/join/detach/module/unload/destructors and required imported/native consumers remain unfinished. Existing artifact/production ELF TLS refusal stays until these paths migrate. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Complete native and TLS acceptance remains open; this materialization source is a prerequisite, not a replacement for full acceptance.
Related records and contracts
[FEATURE] [P08] Supply authorized memory, TLS, threads and race-free blocking for runtimesto [FEATURE] Supply authorized memory, TLS, threads and race-free blocking for runtimeserikinkinen referenced this issue from erix/lib-ipc2026-09-15 12:49:11 +02:00
erikinkinen referenced this issue from erix/docs2026-09-15 12:49:15 +02:00
erikinkinen referenced this issue from erix/integration2026-09-15 12:54:08 +02:00
erikinkinen referenced this issue from erix/procd2026-09-15 14:20:43 +02:00
erikinkinen referenced this issue from erix/docs2026-09-22 03:38:04 +02:00
erikinkinen referenced this issue from erix/docs2026-10-04 13:21:29 +02:00
erikinkinen referenced this issue from erix/integration2026-10-04 13:21:29 +02:00