[FEATURE] Implement isolated compatibility realms and exact grant lifecycles #1

Open
opened 2026-09-12 07:56:25 +02:00 by erikinkinen · 0 comments
Owner

Problem and motivation

Compatibility programs need process-local filesystem, execution and stream routes without receiving global service authority. They also need bounded exceptional operations and reliable teardown across launch, approval, crash and cancellation.

Proposed behavior and scope

UID zero has no bypass, matched classes cannot fall through, duplicate qualifiers are refused and a combined group request must be covered by one matching entry.

Native admission and exact original client/provider provenance remain mandatory. Unknown ACL support cannot become absence. Trusted per-client credential intake, coherent provider snapshots and actual native operation gates are still unfinished implementation. The helper must not be indiscriminately inserted before reads/writes of already opened descriptors. The feature issue remains open with enhancement, security and phase-6 metadata.

Twelve original controls are authored but unrun, covering direct permission outcomes, masks and combined requests, UID zero, special bits, full-width IDs, malformed metadata and large caller-owned storage. Rust formatting was applied. Tests, builds, lint checks, rustdoc, manual builds, profiler runs and CI observation remain deferred; no pass or warning-free result is claimed. The metadata substep is implemented, while the complete permission-enforcement item remains open. Both EriX guest-build generations and the guest Rust/LLVM rebuild remain unproved. Permission contract, runtime design, Phase 6 completion.

Completion is 16.07% weighted, 20/460 parents and 428/888 sub-items across 158 decomposed parents. Reviews: library, mediator, catalogs, manual.

Complete client entry census and independent zero-right placeholder disposal leave only the guarded SEND ingress.

The mediator closes configuration acquisition, scans the complete local capability window one query per turn, then verifies each distinct original control, client receiver and selected source owner. No new alias can be acquired during this interval. Equal cardinality plus each exact owner proves no surplus alias remains; unknown queries, malformed absence and changed kinds/rights refuse preparation. This keeps control progress bounded, retains original custody and uses linear queries with constant additional stack storage and unchanged arena geometry.

The audit fixed external-descriptor start/seal refusal and empty-table receiver-source disposal, both recorded with the bug-report template. Procd admits D..=D+A while Launchd derives the exact stream subset from its frozen plan; directory bindings add no descriptors. An empty Commit performs the same original DROP/absence barrier following Begin caller retirement, without requiring a dummy descriptor or grant.

Five new Posixd controls and three Procd controls are authored but unrun. Existing materialization, client census, seal, disposal and bounded VM controls remain; no new VM selector or relaxed acceptance gate is needed. Component architecture, applicable README, roadmaps, focused realm contract and technical manual are updated. Rust formatting was applied. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred; no execution or warnings-free result is claimed.

The fresh-process launch checklist item is complete under the testing override. Deny-only compatibility credentials/mode/ACL checks follow. Completion is 15.99%, with 20/460 parents and 427/884 sub-items. Both complete EriX guest-build generations and rebuilding Rust/LLVM inside EriX remain unproved. Reviews: Posixd, Procd, Integration, manual. Design ownership remains in Launchd, Procd and Posixd.

The separate rootless client requires two reciprocal descriptors plus one exact external Write descriptor at i32::MAX. It retains ingress-only native census, immutable startup/workspace ownership and cleanup. Shared lifecycle code requires six actual successful exits, retirement before START, absent stale clients, record reuse and a surviving peer. The final marker uses the original stdout lender after view retirement. Integration budgets 32 sources and 2640 canonical plan bytes, preserving ordinary exit and deadline gates.

Eleven new test functions and six inherited packaging controls are authored but unrun. Existing attenuation and source controls cover read-only mutation, redelegation, parent/symlink escape, replay, receipts and cleanup. Component documentation and the manual describe the bounded scenario. Formatting was applied. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred; no execution or warnings-free result is claimed. The witness covers binding metadata and disposal; it does not establish external backend byte I/O or complete caller-loss coverage.

The binding checklist item is complete under the testing override. Fresh compatibility-process launch and final inventory acceptance are next. Completion is 15.78%, with 19/460 parents and 425/884 sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. Reviews: Posixd, Exsh, Integration, manual. Design ownership: Launchd, Procd, Posixd.

The graph uses one original signed commit per shared dependency. The separately committed orchestration helper precedes its Rootd consumer and final catalog selection. All three catalogs retain immutable hashes without source replacement or branch fallback. Source inventory records 263 exact manifest edges. Two new source-budget controls and extended wire, alignment, layout and owner-loss controls are authored but unrun. The contracts and technical manual are updated.

Counted configuration and deployment storage are complete under the testing override. Complete bounded native binding scenario authoring remains open, so the containing binding item stays open. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred; no execution result is claimed. Completion is 15.72%, with 18/460 parents and 424/884 sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. Relevant reviews: Rootd, Loaderd, Exsh, Integration, manual; design ownership remains with Launchd, Procd and Posixd.

Directory authorities contribute no descriptor and old startup minors reject without fallback.

launchd 99b2fc19 counts and emits the same allocation-free frozen-plan record selection and requires cursor exhaustion before committing the original startup hash. procd 5586e0f5 admits the exact requested count within the original mediator's checked D+A storage ceiling, retaining all native relation, receipt and lifecycle gates. It also adopts the authority-aware target layout and C+A+6 native capability extent, and removes an unused direct time-library dependency. posixd 7e4450c2 adopts the new scalar startup format while preserving the full rootless client census. No provider SEND is installed into the client; its guarded mediator ingress remains the only operation route.

docs eea18ab3 updates the manual. Seven new controls are authored but unrun: one codec/version test, three descriptor-selection tests, two provisioning/count tests and one client-inventory test. Existing literal/malformed controls and target-layout bounds are updated; the public stream handoff/seal control now inspects actual external-only startup records. Formatting was applied. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction; no execution result is claimed.

Coordinated Rootd/Integration/Loaderd/Exsh adoption and complete bounded native binding scenario authoring remain open. This finishes external-descriptor accounting but adds no checkbox credit for a still-open deployment step. Completion remains 15.65%, 18/460 parents and 423/884 sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See startup provisioning, binding design, shared API review, Bootstrap review, compatibility ABI review, Launchd review, Procd review, Posixd review, manual review and master completion.

launchd 88eb2573 authenticates the original Running supervisor and guarded client, admits an actual caller-held SEND receipt, and creates the dedicated view from an explicitly budgeted provider pair. Complete generations survive success and refusal.

The serial intake shares original receipt and reply-loss machinery with directory preparation. Lost admitted replies cancel the original cohort; stale or foreign requests exhaust their actual receipts without acquiring cancellation authority. A fresh native caller proof precedes successful publication. Provider cleanup preserves the lender. docs cf566ff1 documents the public wire contract and ownership ordering.

Four wire and six public runtime controls are authored but unrun, covering exact framing, atomic refusal, access/descriptor bounds, complete generations, actual view identity, replay, surplus or contradictory receipts, reply loss and caller replacement. The existing native delivery/seal control now obtains its views through public requests. Formatting was applied; tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction. No executed test or image result is claimed.

The filesystem/stream producer and frozen-plan receipt-binding substeps are implemented, including the published Posixd consumer. Their checkboxes now reflect implementation completion under the testing override. External-descriptor accounting, coordinated deployment/image adoption and the complete bounded native scenario authoring remain unfinished, so the enclosing binding item stays open. Recalculated completion is 15.65%, 18/460 parents and 423/884 sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See stream ownership, binding design, shared API review, Bootstrap review, Launchd review, manual review and master completion.

Counted realm stream source ownership — 29 September 2026: signed launchd 892f8fc0 adds a semantic producer authenticated against the original Running supervisor, guarded client and actual SEND receipt. Explicitly budgeted provider pairs and the existing serialized movement column produce separate SEND-only recipient views.

Disposed providers remain reserved until their exact source owner accepts reply completion. Realm retirement rotates provider/source cleanup, lender cleanup waits for the original borrowing realms, and occupied realm/client receiver identity prevents self CALLs. Zero provider capacity disables creation without fallback. First uncertainty survives later absence while other owners retire. Disposal before seal cancels the immutable cohort; later disposal can remain client-local.

docs 908209cf updates the manual. Eight new controls are authored but unrun, covering actual object identity, native handoff/seal, descriptor bounds, disposed reservations, partial effects, caller loss, peer cleanup and local receiver identity. Formatting was applied; tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction. No executed test or image result is claimed.

Public stream request codecs and authenticated dispatch/reply ownership, external-descriptor accounting and coherent image adoption remain unfinished. Completion stays 15.53%, 18/460 parents and 421/884 sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See recipient stream ownership, binding design, Launchd review, manual review and master completion.

BOTH/CANCELLED disposes only its retained backend SEND and independently proves absence before acknowledgment, without data-access/offset restrictions or a lender status/CLOSE call.

Source audit also fixed Launchd issue 11: repeating generic delivery completion could drop an installed proxy backend from the former factory-source column. The state guard now refuses that phase before effects. Nine controls are authored but unrun, including actual sibling/lender preservation, stale generations, malformed requests, reply capacity, inventory contradiction and partial cleanup. docs 5b43c817 updates the manual. Formatting was applied; tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction. No executed reproduction, public runtime trigger or test pass is claimed.

Public realm stream reservation, original caller/held-I/O admission, arbitrary descriptor binding, endpoint-pool realm ownership, counted stream source handoff and coordinated image adoption remain unfinished; the public realm path does not yet select this disposal mode. Completion stays 15.53%, 18/460 parents and 421/884 sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See recipient-view contract, binding design, Launchd review, manual review and master completion.

Native completion advances delivery; mediator Prepared and caller RELEASE precede disposal of original client RECV and directory SEND aliases.

lib-bootstrap 12b11fac aligns the immutable IPC dependency; docs 7e9491ca updates the manual. Two wire and six runtime controls are authored but unrun, covering malformed/stale/duplicate appends, reversed physical source order, exact native delivery, seal ordering and cleanup failures. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by user instruction, with no pass claimed.

Dedicated recipient stream views and coordinated image adoption remain unfinished. Completion stays 15.53%, 18/460 parents and 421/884 sub-items; no additional acceptance credit is assigned to this partial checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See directory ownership, binding design, Launchd review, shared IPC review, manual review and master completion.

launchd 0caeb423 authenticates the original Running supervisor and guarded client, admits actual SEND scope receipts and prepares original roots into counted custody. Lost admitted reservation/preparation replies cancel the original fixed realm cohort; malformed, stale, foreign, surplus and oversized requests dispose refused receipts without fallback or unearned cancellation ownership.

lib-bootstrap 76882bd3 aligns the immutable IPC dependency; docs c146117f updates the manual. Five wire and six public-runtime controls are authored but unrun, alongside the previously published nine ownership controls. Source review corrected the earlier owner fixture's provider source identity and kept new fixture destinations within native CSpace bounds. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by user instruction, with no pass claimed.

Canonical source append/native delivery, seal handoff, dedicated recipient stream views and coordinated image adoption remain unfinished. Completion stays 15.53%, 18/460 parents and 421/884 sub-items; no additional acceptance credit is assigned to this partial checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See directory ownership, binding design, Launchd review, shared IPC review, manual review and master completion.

Actual SEND receipts require matching native QUERY.

docs 37ddc4ad updates the manual and corrects the configuration reservation width. Nine new admission, receipt movement, partial-effect, loss and cleanup regressions are authored but unrun. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by the user, with no pass claimed.

Public source request decoding and authenticated dispatch, canonical source append/native delivery, seal handoff, dedicated recipient stream views and coordinated image adoption remain unfinished. Completion stays 15.53%, 18/460 parents and 421/884 sub-items; no additional acceptance credit is assigned to this partial checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See directory ownership, binding design, Launchd review, manual review and master completion.

Directory cleanup after handoff — 29 September 2026: signed lib-ipc b0b42939, vfsd 8f34a3e2 and launchd 79bcc9d4 add cap-free retirement through Launchd's held private resolver after the operation SEND alias is discarded. The digest includes a non-reused object identity; plain cwd and inherited descendants are ineligible, and stale requests cannot select reused records.

Launchd requires exact reply identity, matching header/body status and provider OK or NOT_FOUND. Transport absence does not prove provider disposal. Every injected receipt is retired independently. lib-bootstrap b00c8732 and lib-time 49b5e713 align immutable dependencies; docs 1c13c2e8 updates the manual. Fourteen codec, provider and transport regressions are authored but unrun. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by the user, with no pass claimed.

This completes a cleanup prerequisite. Authenticated public source preparation, counted original-source custody, seal handoff, dedicated recipient stream views and coordinated image adoption remain unfinished. The published Posixd consumer and Vfsd close barrier remain part of the binding contract. Completion stays 15.53%, 18/460 parents and 421/884 sub-items; no additional acceptance credit is assigned to this checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See directory ownership, binding design, Launchd review, Vfsd review and master completion.

Counted authority consumer — 29 September 2026: signed Posixd 799cc1e0, compatibility dependency 17b8346c and manual a9906120 publish actual noncopyable SEND owners, counted framing and target-generated authority-row geometry. Indexed admission matches the frozen plan and rejects native-slot, complete binding-key and internal/stream descriptor collisions without an additional count ceiling. Preparation rechecks actual senders; typed lookup requires an exact live native client after seal.

Client disposal now waits for each provider result, acknowledged original caller retirement and local SEND DROP/independent absence before its receiver or control acknowledgment. Nonzero SUBMIT owners survive refusal; missing callers before acknowledged draining release are not cleanup evidence. Cleanup uses a retained client range and alternates with ordinary client turns. Sixteen new owner/table/service tests and the preceding receipt regressions are authored but unrun, covering all roles, malformed results, digest-correct duplicate bindings, caller loss, cleanup failures, exact original-route selection and peer isolation. Signed final source review 442a805c removes an unconditional lender-live fixture assertion and adds contradictory NOT_FOUND metadata after DROP: the first failure retains the destination even after later absence. Lender preservation requires coverage in the unfinished stream-view producer. All changed code files remain below 1,000 lines. Formatting was applied; tests, builds, lint checks, VM runs, manual builds and CI observation remain deferred by the user, with no pass claimed.

The ownership contract requires Vfsd's published provider-before-reply directory barrier. Stream teardown requires a dedicated recipient view that accepts BOTH/CANCELLED independently of byte offsets and access, disposes its own provider custody before acknowledgment and preserves its lender. Existing ordinary Launchd proxies do not satisfy that full contract. Authenticated original-source preparation, dedicated stream-view production, source-owner handoff and coordinated Rootd/Integration/Procd/Loaderd/Exsh adoption remain unfinished. The image catalog still selects its earlier graph; fixture behavior does not establish production stream cleanup.

Complete binding acceptance remains open. Recalculated accounting stays 15.53%, 18/460 parents and 421/884 sub-items complete. Both full EriX build generations and the external-toolchain rebuild inside EriX remain unproved. See binding design, Posixd review, Launchd review and master completion.

Eight regression tests are authored but unrun, including real directory pins, parent preservation, either provider-close failure, terminal-caller loss and receiver-disposal failure. The exact runtime is extracted into a focused module; changed code files remain below 1,000 lines. Formatting was applied. Tests, builds, lint checks, VM runs, manual builds and CI observation remain deferred by the user. The source-confirmed close-ordering defect uses the bug-report template and is implementation-closed under that testing waiver, with no runtime pass claimed.

Actual Launchd source preparation and delivery, Posixd retained provider callers and local alias disposal, Rootd/Integration publication and coordinated dependency selection remain unfinished. The image catalog still selects its earlier graph. Full binding acceptance remains open; recalculated accounting stays 15.53%, 18/460 parents and 421/884 sub-items complete. Both full EriX build generations and the external-toolchain rebuild inside EriX remain unproved. See binding design, Vfsd review, Posixd review and master completion.

Unused source columns still require independent retirement; unexpected occupants quarantine the original realm without adoption or deletion, and generations survive reuse.

Launchd also adopts the counted shared framing, allocation-free authority-key/collision validation with exact byte restoration, and record-specific capability rights through QUERY and native COMPLETE. Regression tests are authored but unrun; formatting was applied. Tests, builds, lint checks, manual builds and CI observation remain deferred by the user, with no pass claimed.

Authenticated directory/stream source preparation and delivery, complete Posixd provider retirement, Rootd/Integration publication and coordinated dependency selection remain unfinished. The image catalog still selects its earlier committed graph. Storage admission alone cannot freeze or publish source authority. Binding acceptance stays open; accounting remains 15.53%, 18/460 parents and 421/884 sub-items complete. Both full EriX build generations and the external-toolchain rebuild inside EriX remain unproved. See binding design, Launchd review, Posixd review and master completion.

Older schemas reject without fallback. Complete scalar admission rejects duplicate bindings and stream descriptors colliding with internal channels; clients may have no internal channels or initial descriptors.

Independent wire, overflow, aligned-storage, collision, receipt-count and empty-client regressions are authored but unrun. Formatting was applied. Tests, builds, lint checks, manual builds and CI observation remain deferred by the user; no pass is claimed. This supersedes the preceding scalar-only codec scope. Runtime consumer adoption, explicit Launchd deployment storage, original source preparation and complete Posixd receipt/provider retirement remain unfinished. Integration still selects its earlier coherent dependency graph. The binding item and its four remaining substeps stay open; weighted completion remains 15.53% with 18/460 parents and 421/884 sub-items complete. Full EriX and external-toolchain builds inside EriX remain unproved. See binding design, Launchd review, Posixd review and master completion.

It encodes no capability slot and grants no native authority.

The codec is not yet admitted by the counted configuration stream. Explicit authority counts, target owner-row layout, coordinated startup/provisioning framing, original Launchd custody and actual Posixd delivery remain implementation work. The existing five-step binding plan now has an explicit public sub-checklist: directory attenuation is complete, while the other four steps and the whole binding item remain open. Recalculated weighted progress is 15.53%, with 18/460 parents and 421/884 sub-items complete. Existing section/parent weights are unchanged; this exposes completed prerequisite work and does not claim complete realm binding, a validation pass or either full guest build. See binding design, Vfsd review, Launchd review and master completion.

Counted authority-record extension — 29 September 2026 (design before implementation): append an explicitly counted authority section after clients, internal descriptors and channels. Each 64-byte record describes a canonical client index (u64), role selector (u64), typed role (u32), maximum operation access (u32), original-source identity digest (32 bytes) and reserved-zero tail (8 bytes). Roles distinguish source, toolchain, output, temporary, executable, root, cwd and inherited stream. Root/cwd use selector zero because each process has one of each; other directory roles allow full-width selectors. A stream selector is a nonnegative compatibility descriptor and must not collide with internal-channel descriptors. Source/toolchain/executable records require read-only policy. Other directory records select read-only or inherited read/write ceiling, never write-only directory authority; streams allow read, write or both. Access is a maximum bound, not evidence that the original native object grants those operations. The source digest is descriptive provenance from the original Vfsd object or stream lender, never a native object-identity substitute.

Configuration admission must reject duplicate client/role/selector keys and stream-fd collisions before freezing. A client with no byte channels is valid, including a completely authority-free initial context. Every declared channel still needs an actual descriptor binding and its counted payload budget. Add a separate authority count and target-compiled owner-row layout; update exact startup/provisioning widths and versions together so older peers reject unsupported extensions. Authority pulls require one actual SEND receipt, while existing client pulls require one RECV receipt. Reserve recipient custody before COLLECT and preserve the original source until two-sided seal retirement. Public configuration must derive authority records from authenticated owner-specific preparation; it may not accept a caller-invented digest or arbitrary local slot as proof. Native lifetime, cancellation and cleanup remain implementation requirements, including distinct provider-object release and local alias deletion.

Reply correlation, actual endpoint/SEND receipt and local QUERY must agree. Refusal never retries with weaker flags; original alias release and uncertain cleanup remain separate ownership obligations. Root evidence alone carries no authority.

Ten new policy, identity, receipt, loss and cleanup tests are authored but unrun. Documentation describes the native custody contract. Counted root/stream records, retained configuration owners and actual delivery to Posixd remain implementation work. Integration has not adopted this prerequisite into its image graph. No binding-item completion credit, validation pass or full guest build is claimed. Tests and CI observation remain deferred. Tracking: realm binding design, Launchd review, completion.

Vfsd retains the effective policy behind the exact endpoint through cwd changes, redirection and redelegation; clearing request flags cannot recover access. The wire codec rejects operation-inappropriate flags, and older receivers reject unknown bits.

Codec, confinement, write-denial, receipt-destination and cleanup tests are authored but unrun. Component documentation and the filesystem-service manual describe the contract. The Vfsd dependency closure is pinned coherently; Integration still selects its earlier coherent graph. Counted root/stream configuration, Launchd custody, actual Posixd receipt binding and the native binding scenario remain implementation work. This prerequisite does not complete filesystem/stream binding or add checklist credit. Testing and CI observation remain deferred; no validation pass or full guest build is claimed. Tracking: filesystem design, realm binding design, master completion.

Receipt-bound filesystem and stream configuration design — 29 September 2026 (implementation in progress): complete the binding of read-only source/toolchain directories, writable output/tmp directories, executable directories, root/cwd selectors and inherited streams to actual native receipts. The existing counted configuration only binds internal byte channels. Role names, path strings and a Generic SEND receipt do not themselves establish a directory's read/write or navigation ceiling.

First extend Vfsd's existing scoped launch-directory request with two directory-only flags: DIRECTORY_ROOT (bit 1) pins the selected directory as the new navigation ceiling; DIRECTORY_READ_ONLY (bit 2, valid only together with DIRECTORY_ROOT) removes write authority. Existing zero-flag cwd derivation keeps its original ceiling; executable and manifest requests reject these directory flags. Unknown bits remain errors, so an old receiver cannot silently accept weaker semantics. Store the effective write ceiling behind the exact endpoint and carry it through cwd changes, nested directory resolution and redirection. Intersect it with the original namespace session; clearing request flags must never restore write authority. Anchor the new root to the selected provider object, retain original-object identity checks, and retire all independent pins on failure and close. Source and toolchain roots request both restrictions; output/tmp roots request a fresh ceiling without increasing their parent's access. Existing endpoint generation, release and uncertain-cleanup rules remain mandatory.

Then extend the canonical configuration and explicit arena/deployment counts with typed root and stream records. Launchd resolves roots through its authenticated Vfsd route under the original owner's held directory capabilities and selects inherited streams from the same caller's live I/O owners. It retains original receipts and transfer ownership until exact source retirement. Posixd reserves custody before collecting each receipt, checks exact native QUERY/type/rights/slot evidence against the frozen realm/owner/role record, and seals only after transport ownership is fully retired. Numeric selectors never create routes. Teardown drops actual aliases and confirms absence before reuse, including cancellation and partial delivery. Storage remains explicitly counted without a fixed number of roots, directories or streams.

Author focused codec, confinement, stale/replayed receipt, two-realm and cleanup regressions and a bounded native binding scenario; keep test execution and CI observation deferred under the user's current instruction. Publish coordinated producer/consumer revisions and update the manual and master completion issue. This design does not claim completed root/stream binding or either full guest build.

Private provisioning transport refinement — 24 September 2026 (implementation pending): the guarded preparation request remains non-starting. Add separate typed Procd operations for Provision (0x433), private Start (0x434) and exact Retire (0x435), all admitted only from the original Launchd generation on its held private receiver. Provision carries a 48-byte request with exact child and realm identity plus explicit request/result byte budgets, and exactly one moved Generic SEND configuration receipt. Procd derives the actual child capability extent from its retained creation geometry, installs configuration at child slot 5, and computes page-rounded startup/workspace mappings beyond the recorded executable extent. Its successful 224-byte response returns the canonical 208-byte startup record after a 16-byte correlation/result/state prefix; failure carries no startup bytes. Start and Retire each carry 64 bytes with the original child/realm and canonical startup digest, preventing cross-stage substitution. These bytes constrain actual held routes and never confer authority.

Procd has no existing own-process identity in its startup payload. Reuse native caller attribution through a separate 64-byte configuration ContextProbe/Ack before RBS1 construction. The probe carries correlation, realm/child and original Launchd identity, with zero controller fields; Launchd obtains the Procd pair from actual CLAIM, retains that original pair and echoes it in the correlated acknowledgment. Procd retains the accepted invocation through retirement before committing the resulting context. This adds no kernel identity query, process endpoint or permission to trust an arbitrary first challenge. Posixd still requires its supplied controller to match the challenge's actual native caller.

Launchd explicitly reserves four capability columns per admitted realm in its authenticated deployment geometry. It creates the configuration receiver before exporting SEND, binds an ancestor revoker to its own native lifetime, keeps a separate nested revoker for early retirement, and removes all bypass source aliases. Original executable-scope storage may be reused for temporary construction only after its absence is acknowledged. Procd retains the received configuration sender in an already empty role-owned scratch column, accounts for every mapped frame and setup alias, consumes the actual GRANT through operation 58 only after provisioning, and records uncertain start disposition before the native start effect. No grant-derived MINT capability or ordinary-start fallback is added.

Private Start completes only after native start and the independent control challenge have completed their owned caller cleanup; readiness uses Launchd's separate actual-child CLAIM and full startup digest. Invocation handles and application owners remain retained on cancellation, malformed response, lost reply, supervisor loss and partial disposal. Retire selects running termination after any possibly committed start and waits for exact terminal observation/destruction before acknowledging final retirement. Frame allocation and each handshake must preserve explicit ownership and bounded progress; ordinary staging and all existing refusal/cleanup witnesses remain required. Provision, Start, readiness, seal, publication and client I/O remain distinct acceptance steps.

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

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.

Staged mediator handoff contract — 15 September 2026

Reserve Loaderd operation 0x654 (PREPARE_REALM) using the existing exact-executable preparation request/response layout. The operation selects the new Procd lifecycle class 0x448 (REALM_MEDIATOR); role values describe lifecycle policy and confer no capability authority. Launchd explicitly selects this operation after authenticating its executable object. The ordinary operation 0x652 keeps its existing behavior. Responses must echo the selected operation; no fallback is permitted.

Loaderd validates the same sole exact-executable SEND receipt, authenticates the complete image graph, and uses the existing semantic materialization pipeline. The mediator's temporary initial endpoint occupies child-local slot 4, after native root slots 1–3. This slot is an ABI destination, not a realm-count or resource-budget restriction. The child remains staged. Procd retains the actual endpoint master in the existing managed scratch endpoint column; it never exports that master to Loaderd or Launchd. Only the actual move-only install grant travels Procd → Loaderd → Launchd. The derived ordinary stream installer is absent for this class. Reply loss aborts the exact stage and accounts for the retained endpoint, grant and VSpace; cleanup uncertainty remains fail-stop.

Launchd may inspect, abort and stop only its owned lifecycle classes. Root, driver and powerbox routes cannot use the mediator class; generic staged-start, ordinary startup/stream installation and automatic restart reject it. The future separate bootstrap transaction must receive the actual grant back, authenticate the live caller, install a typed receiver/rendezvous inventory using exact process-bound installation, dispose temporary aliases and configure the startup bytes before private execution. No existing start path may bypass that gate.

This staged handoff is the first implementation increment of typed realm bootstrap. Acceptance for this increment requires malformed/foreign operation rejection, exact executable and grant receipts, unstarted materialization, private master retention, no derived stream grant, and rollback coverage across the actual producer paths. It does not establish mediator execution, seal, publication, client I/O, retirement fairness or either complete guest build generation. Those remain required under the existing acceptance criteria. Native VM coverage of the coordinated producer graph is required before claiming runtime acceptance.

Implement realm create/configure/seal/start/abort/retire states, namespace ceilings, deny-only compatibility credentials, resource accounting and ext4-based service startup. Integrate authenticated exceptional grants to exact live processes, including trusted consent and noninteractive build denial.

The updated ownership design is published in WIP PR #5 at signed 4f1a964cd32e0b46ccf73f87a3be2efbb5f128ec. Its focused contract requires guarded SEND-branch custody before export, final-process receiver readiness before releasing the producer's sender, and private configuration pulls with capability-bearing owner replies. Ordinary control and client senders do not gain GRANT.

Typed provisioning must consume the actual moved process-bound install grant; staged-process records and the retained SEND-only derived installer do not replace it. Procd is the proposed route-guard owner for mediator/Launchd loss. Procd loss needs a distinct ancestor guard, a surviving native holder and an independent trigger. Product Rootd exits after bootstrap. Quarantine, alias absence, process destruction and operation/provider completion remain separate facts. No upstream holder, wire field or runtime behavior is assigned by this documentation change.

All 10 Markdown files, 19 local links, canonical sections, six governance files, original source correlation and whitespace checks pass for the three-file correction. Both current component push CI 3 and PR CI 4 pass, checking all 10 Markdown files with zero lint errors. Both complete logs total 7,232 bytes and are bound to the signed source. This is documentation validation, with no runtime acceptance. Matching Docs 928ff81a1d6dea09145f49fd4fbe07ab84525000 in Docs PR #4 is signed and published. Its nineteen API routes select original seventeen-function library 4207509, and the realm narrative matches the guarded custody design. All 44 documentation tests, selected API consistency and 55 Markdown files pass. The complete 2,331-page manual has zero final warnings and all 423,064 word boxes fit; nine selected pages pass visual review. An initial page-selection bound failure and a finalization-prefix collision remain retained and are corrected without render, extraction, API or runtime replay. Matching Docs push CI 833 and PR CI 834 both pass for signed928ff81a, ending at 04:51:47 UTC on September 13. Each manual job passes 44 tests and produces 2,331 pages with zero final-pass warnings; each Markdown job checks 55 files with zero errors. All four complete logs are retained (750,388 bytes). Thirty first-pass and one second-pass convergence warnings per manual resolve before the final pass. The logged final PDF size is 4,090,720 bytes; CI artifact bytes and geometry were not independently inspected. Prior Docs b11a745 and CI831/832 validate only the preceding fourteen-function manual. Prior source 91b18c9199ff8c9219a5e47718d951266722761c passed CI1/2 and its preceding manual passed Docs CI821/822; those results remain specific to the prior design. The initial prior Markdown failure remains retained.

The repository has no implementation crate. Native acceptance must include two actual mediator processes, two clients per realm, real mediated byte I/O, authenticated denial and complete owned retirement. Rust/VM checks are inapplicable to this documentation-only change; no runtime acceptance or completion credit is claimed.

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

Detailed scope and contracts

Failure-only lifecycle cleanup

After a sealed service records its first error, ordinary advancement, member admission and signaling remain frozen. Bootstrap retains its original watched control receiver and authenticates the controller CLAIM, exact context/digest and distinct terminal/disposal kind. A cleanup-only control entry accepts those original lifecycle requests, closes only the named original client, and retains the complete request beside its retirement owner.

Cleanup advancement selects only that client's generation-checked retained invocation rows. It cancels original external, readiness and publication work, then retires the original callers, semantic provider owners, factories and receiver without ordinary CLAIM, COMPLETE replay or new operation submission. Every source still requires its independent acknowledgment and absence proof; uncertainty preserves the first diagnostic and all remaining owners.

The native loop must reach this path after a service error, retaining unrelated peer/lender state until independently authenticated closure. Bootstrap/control uncertainty still terminates the process. Positive, malformed-input, foreign/stale controller, refused cleanup, once-only completion and unaffected-peer controls must prove the boundary; ordinary advancement continues returning the original failure. This extends cleanup reachability without clearing uncertainty or narrowing full POSIX/native/guest requirements.

Ordinary byte-I/O uses one retained serving delivery and one complete result
region per configured client, with fair turns for other clients and private
control. Authenticate the actual registered receiver and native CLAIM origin
before descriptor lookup or effect. Prepare the exact result before queue or
binding mutation; each accepted delivery commits at most once and retains those
bytes through native completion or acknowledged invalidation/retirement. Read
and Write validate access even when their count is zero, permit short progress,
and preserve the specified EBADF/EAGAIN/EPIPE/EOF and close-once semantics.

The configured result-storage ceiling is distinct from the native result budget
chosen for a particular invocation. The existing CLAIM receipt does not expose
that budget. A caller that supplies too little native result capacity can cause
COMPLETE to refuse a result after the mediator has committed an effect. The
mediator must preserve the exact result and original delivery, never re-execute
or roll back that effect, and continue unrelated clients and control. Only actual
caller invalidation or exact client termination followed by acknowledged native
retirement permits reusing the retained row. A still-serving owner that refuses
RELINQUISH remains pending; absence without prior retirement evidence is not
cleanup. No additional Kernel authority or budget-query API is introduced.

An unauthorized, unsealed or malformed claimed delivery performs no descriptor
or channel operation. Its refusal may complete the native delivery with an empty
capability-free payload; that payload deliberately is not a valid compatibility
result and conveys no other client's metadata or asserted correlation. The
caller must reject it and retire its invocation. Failed refusal completion
retains the original serving owner under the same bounded cleanup rules.

The immutable target layout descriptor derives from the actual compiled client,
descriptor and channel runtime types used by the native mediator. It is not a
host estimate or a placeholder record size. Checked, disjoint arena slices hold
those rows, canonical plan bytes, ring storage, per-client exact results and
reused packet scratch. This contract requires focused fault-injection tests and
an actual native client witness; it does not claim complete POSIX semantics,
libc or a self-hosted EriX/toolchain build.

Bind capabilities and revocable aliases to process/job/realm generations, resolved objects, permitted operations and finite lifetimes. Numeric realms, uid 0, PATH and labels cannot mint access. Keep native private receive routes internal, and retire all descendants and partial transfers when the realm ends.

Apply the priority order: security, reliability, then performance. Keep suspected vulnerabilities in the repository’s restricted SECURITY.md reporting channel.

Acceptance criteria

Checklist
  • Specify per-realm/per-process ownership and isolation inside posixd; separate
    private native service routes from each client's narrow authenticated ingress and reject
    numeric-realm impersonation.
  • Implement create/configure/seal/start/abort/retire realm states with
    generation-bound identities, validated resource ceilings and exact rollback.
  • Bind read-only source/toolchain roots, output/tmp roots, executable directories,
    cwd/root selectors and inherited streams from actual receipts.
  • Implement launch integration that creates a fresh compatibility process context,
    supplies only its selected routes, and never grants global named, provider, device,
    raw-block or kernel process-control endpoints.
  • Implement deny-only uid/gid/group/mode/ACL checks after native capability
    admission; test uid 0, chmod/chown-like metadata and executable permission changes cannot
    manufacture access or bypass a capability ceiling.
  • Implement explicit root/cwd/PATH resolution confined to delegated
    namespace/executable roots; environment text, absolute paths and .. cannot escape the realm
    or select an undelegated service.
  • Implement resource accounting for process/thread/fd/memory/temp and in-flight work,
    with deterministic exhaustion and no fixed accidental table cap.
  • Implement noninteractive build policy: out-of-envelope operations fail promptly
    with documented errors, without hanging for a hidden prompt.
  • Implement realm teardown on normal exit, crash, denied transfer, launch abort,
    timeout and supervisor failure; retire all descendants/aliases and prove process/realm
    generation reuse cannot recover prior authority.
  • Add two-realm isolation VMs for filesystem, process, credentials, descriptors,
    service routes and teardown; include malicious message replay.
  • Package/start posixd from ext4 after the required native services; keep
    compatibility orchestration out of rootd and preserve READY/shell ordering.
  • Implement runtime exceptional-authority requests from running compatibility
    processes through their authenticated launch/realm route; resolve only within the caller's
    existing delegated selector ceiling.
  • Bind every grant to exact process/job/realm generations, resolved object identity,
    permitted operation and explicit one-shot/invocation/transaction lifetime. Never turn approval
    into a broad directory or reusable admin grant.
  • Extend trusted prompt descriptions for compatibility programs to show executable
    provenance, operation, object and lifetime; escape untrusted labels and keep labels/argv/paths
    non-authoritative.
  • Preserve automatic same-session secure attention, trusted y/n plus Enter decisions,
    renderer acknowledgement and fresh-input fences on serial and framebuffer TTYs. Untrusted PTY
    output cannot approve or spoof a prompt.
  • Deliver approved grants to the exact still-running process using explicit
    caller-local slots and tracked revocable aliases; reject stale, replaced, cancelled or
    already-exited recipients and clean partial delivery.
  • Implement operation-completion/denial/timeout/cancellation/revoke cleanup,
    including process death during approval and errors after one-shot consumption. No grant
    remains reusable by a later process or shell command.
  • Support exact-entry unlink/rename/truncate and reviewed recursive transaction
    envelopes; require a fresh explicit policy for any traversal scope, and prove
    rollback/partial-progress rules without ambient parent-directory write.
  • Add interactive VMs for approve, deny, revoke, malformed grant, object replacement,
    process exit, wrong TTY, replay and two-realm isolation; add a noninteractive build VM proving
    no prompt or silent escalation occurs.

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

A global POSIX namespace or broad approval grant would exceed native capability ceilings. Mediate each client through its own authenticated route and keep compatibility orchestration out of rootd.

Validation checkpoint — 14 September 2026: Signed Posixd 52ef820d33399490c121aad3af1409139e4a8f44 selects the proposed realm custody owner: Procd deposits an ancestor SEND-lineage revoker into its exact native generation before export and retains a nested guard for earlier realm retirement. Exported aliases descend from the nested guard; ancestor-only bypass and setup aliases must be removed before publication. Runtime producer adoption, realm byte I/O and both complete guest build generations remain open.

Owned invocation wire and native acceptance — 15 September 2026: Signed Posixd 3118b9008a85977b48babc342ba0587ddc99dd57 corrects stale upstream status and records producer adoption prerequisites. Merely adding a realm table cannot establish bounded cleanup progress: the implementation must separately own and schedule native terminal intake, SEND-branch retirement and provider completion, retain actual moved install/guard custody, authenticate exact generation-bound readiness/configuration, dispose setup authority and only then seal. Two realms with two clients each performing mediated byte I/O, broader failure/reuse evidence, full audits and both complete EriX-in-EriX build generations remain open.

Typed realm bootstrap installation design — 15 September 2026: The next bootstrap producer step requires validating the actual moved install grant against the intended child before any installation. Add Kernel-control operation 52, INSTALL_WITH_GRANT_FOR_PROCESS, using the existing fixed request/reply envelope: flags and arg3 are zero; arg0 packs grant slot in bits 0..31 and source slot in bits 32..63; arg1 packs child destination slot and exact requested rights; arg2 packs nonzero process ID and nonzero staged generation. Both response values remain zero. The operation is admitted only where grant installation is already allowed (process-control and child-population endpoints, with existing bootstrap control policy preserved). The held unique grant remains the authority; the supplied process/generation pair is an additional equality constraint, never a target-selection grant. Revalidate exact native grant binding, GRANT possession, child/staged identity and current staged liveness, slot and type/rights ceilings, actual source binding and empty destination before transfer. Unlike legacy zero-means-inherit installation, this operation always uses the exact supplied rights, including zero. Reject nonzero reserved input and zero identities deterministically; mismatched target identity must produce no installed alias or new revocation lineage. Keep old producer semantics unchanged until explicitly migrated. Share the native installation implementation and split the existing near-1000-line control dispatcher by responsibility. Tests must use actual moved install grants for distinct staged children, wrong/stale generations, occupied destinations, explicit zero rights, invalid fields, denied endpoint policy, preserved source/grant custody and native lifetime/revocation behavior. Connect the new checked operation to typed Procd bootstrap provisioning; a standalone scalar codec or host-only table is not realm runtime acceptance. Complete receiver readiness, setup-authority disposal, fair terminal/provider scheduling, two-realm byte I/O and both full guest builds remain required.

Process-bound native acceptance — 15 September 2026: Signed Kernel 60da5858d7198185efd103f0e91e5ac2e0b63e67 implements control operation 52, checking the actual moved install grant against expected process/generation with exact rights, including zero, under existing endpoint policies. Signed Procd f1105706cc19ed024a6cca79a29abc57c90c6661 uses 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.

The mediator class cannot use ordinary start, immediate commit, TTY provisioning, powerbox installation or automatic restart. Procd has forty native binary builds and six new mediator refusal/cleanup regressions. No Posixd executable or coordinated realm VM acceptance is claimed. Actual grant-return provisioning, authenticated caller ownership, typed startup memory/inventory, readiness, configuration/seal, client I/O, fair retirement, complete consumer image adoption and both full guest build generations remain open.

Detailed scope and contracts

Native bootstrap destination correction — 15 September 2026

The temporary endpoint destination is now child-local slot 4, after the mandatory CSpace, VSpace and TCB roots in slots 1–3. This proves the constructor boundary; coordinated mediator startup, seal, client I/O, retirement and full guest builds 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.

Typed mediator bootstrap, ordinary service-image adoption and both complete EriX builds inside EriX remain open.

The existing held Process or Root route remains
required; descriptive identities do not grant authority.

An absent or different generation acknowledges absence of only the requested
instance, with zero response values; it cannot mutate a replacement.

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. Ordinary mediator start, whole-image
admission and both complete builds inside EriX remain separate open gates.

Generation-bound cleanup consumer acceptance — 18 September 2026: Signed revision 2aefcaa7b2d847a6982d5d24fefac89a536e6bf8 is pushed. Runnable mediator bootstrap, fair retirement and both complete builds inside EriX remain open.

The native pending caller must match a retained running
Launchd generation. The actual sole receipt must be INSTALL_GRANT with exactly
GRANT|MINT. Previously guarded, started, stale,
ordinary-role and malformed stages refuse before new effects.

Use the real returned grant and native
operation 53 to narrow the Created child's primary endpoint to RECV. Establish
an ancestor SEND branch under Kernel lifetime custody and a distinct nested
explicit revoker before any export.

Lost reply, rollback, abort, supervisor loss and terminal
cleanup must account for every reused scratch column, actual guard and exact
child identity.

Counted final receivers/configuration,
owned fair intake/provider/retirement progress, private execution, authenticated
readiness, initial receiver disposal, seal/publication, real two-realm client I/O
and both complete builds inside EriX remain required. Host models or this guarded
stage acknowledgment cannot substitute for those acceptance gates.

Tracking and rollout

Native configured-client acceptance — 25 September 2026: the exact signed Integration 7a42fa26 graph passes the configured-client, preparation and startup VMs with all original markers, deadlines and cleanup gates. The configured witness seals two isolated realms, observes six successful byte-client exits across three realm instances, checks independent retirement, rejects stale client selectors and reuses a Launchd realm record with a new generation. This proves the native configure/seal/publish/mediated-I/O criterion; full Procd managed-row/final CPU reclamation, supervisor loss and resource ceilings remain separate requirements.

Launchd 372ab70e retains only the required result-carrier GRANT and preserves RECV-only client copies plus complete setup retirement. All six strict 497-test configurations and original CI179/180 pass. Loaderd 5bcf522c retains the counted grant destination; four strict 145-test configurations and original CI107/108 pass. The original red tests, failed native runs and admitted host TCG diagnostic remain preserved. Docs 6a1a9686 passes the full 2,655-page manual and 45 tests locally and in original CI1085/1086; four complete CI logs total 824,660 bytes and final warnings are zero.

The configuration carrier defect, counted grant defect and configured-client stall are resolved by this component and native evidence. The Exsh fixture report retains its pending release compiler/frame validation despite the three native passes. Complete Integration CI1801/1802 is still queued. Whole-fleet authority/source/effect/frame acceptance, final accounting/profiler observation, rebuilding the external Rust/LLVM/runtime toolchain inside EriX and both full EriX guest-build generations remain open.

Original prerequisite Integration CI1793/1794 each passes 490/491 scenarios; Rust and Markdown pass, and six complete logs total 27,432,406 bytes with zero warnings. CI1794 retains the ext4 quota timeout. CI1793 instead exposes a distinct one-shot replay QMP connection loss, recorded using the canonical bug template and phase label. No original workflow was rerun, and no deadline or authority check was relaxed.

Only the existing native-witness sub-item gains credit: 15.42% weighted progress, 413/873 sub-items. Whole acceptance remains 3.86%, 17/460 parents.

Disposal consumer CI and component acceptance — 25 September 2026: original Posixd CI33 and CI34 pass at signed 3541ce5d. The completion checklist now exposes this implemented consumer disposal component; PR5 remains unfinished for coordinated execution. Full configure/seal/client I/O, supervisor/lost-reply recovery, native failure/reuse and both guest rebuilds remain required.

Wrong origin/digest/kind, stale clients and changed pending requests are refused; uncertain receiver cleanup and failed COMPLETE preserve custody without replay. PR5 remains unfinished: Launchd runtime orchestration, coherent four-client configuration/seal/I/O, full loss/reuse and both guest rebuilds remain required.

It validates complete RCS1 startup and the actual capability inventory, disposes the zero-right placeholder, and uses only the supplied SEND ingress for cap-free QueryABI/Read/Write/Close calls. Each original invocation remains retained through correlated collection and acknowledged retirement; uncertain results cannot cause replay or reuse. Its reciprocal workload checks realm-bound bytes, short progress, descriptor-rights refusal, close-once behavior and EOF without shell, filesystem, clock, logger or process-control authority.

All four local feature/profile configurations pass 58 tests. Strict host/native Clippy, private rustdoc, formatting and warning-denied builds pass. Independent review verifies 39 terminal checks, both executables' debug/release entry and stack geometry, and the mediator's unchanged read-only/nonexecutable layout descriptor. Every Rust file is below 1,000 lines. Original CI31 and CI32 now pass at this exact head: four complete logs, 123,933 bytes, zero warnings/errors and 58 tests in each of four configurations per Rust job. No failed input was retried. Coherent native producer adoption and the two-realm/four-client configuration, seal and byte-I/O VM witness remain open in the implementation PR. This checkpoint adds no native execution or guest-build acceptance.

The phase checklist now exposes the completed native consumer implementation and component-validation sub-item. Weighted progress is15.37%, with400/861 sub-items; whole acceptance remains3.86%,17/460 parents. Original parent scope and section weights are unchanged. Coordinated producer adoption, configuration/seal/client-I/O VM evidence and complete loss/reuse/accounting cleanup remain open. The new RCS1 byte-client executable is separate development work and receives no acceptance credit from these earlier runs.

Complete client admission/lifecycle design — 25 September 2026: the shared codec design now defines public Launchd operations6D5–6DD using only original owned realm/client handles; private Procd provisioning43D–441; distinct authenticated never-started client disposal messages; and LCH1v4 counted client-row/plan-byte storage. No public caller nominates a native process or capability identity. Freeze verifies the complete canonical plan before effects; private provisioning preserves grant MOVE, receiver COPY and independent source/caller retirement. Client Start follows the two-sided seal, and exact terminal outcomes remain in counted storage until realm retirement. The first immutable byte cohort is explicitly scoped; it is no permanent POSIX process ceiling. A dedicated rootless byte-client binary will use RCS1 and its own ingress only. Implementation, strict validation and the real four-client VM witness remain open.

The independent release ELF check found descriptor-page overlap. The signed linker correction and fresh native debug/release builds now place one complete descriptor on exclusively read-only, nonexecutable pages. The original refused artifact remains retained. Original CI27 and CI28 stop before Rust compilation because the pinned helper catalog omits Lib-PosixABI; the helper-selection defect records four complete logs23,718 bytes and passing Markdown jobs. A reviewed exact helper revision will correct the inventory while preserving strict unknown-source rejection. No failed job was retried. Coherent producer adoption and the two-realm/four-client configuration, seal and byte-I/O VM witness remain open. Implementation review stays WIP. No additional checklist or guest-build acceptance is added.

Private client materialization contract — 24 September 2026: the existing materialization-begin frame carries only the supervisor pair. Role recognition alone cannot bind an actual client to its intended mediator before native creation. Use distinct private operations with explicit descriptive correlation, authenticated through the existing Loaderd and Launchd routes; no new capability or ordinary-launch fallback is introduced.

Loader PREPARE_REALM_CLIENT (0x655) is exactly 340 bytes: retain the existing 316-byte exact-executable selection offsets, then realm ID/generation u64 at 316/324 and native mediator process/generation u32 at 332/336. Its distinct 176-byte reply retains the existing 152-byte result/grant/digest fields, then echoes the complete relation at 152/160/168/172 on both success and refusal. Existing failure-zero rules still apply to staged/grant IDs and digest evidence. The old 316/152-byte parsers reject this selector. The exact executable SEND retains COPY semantics and independent source disposal; the staged install grant retains MOVE semantics.

Procd BEGIN_REALM_CLIENT_MATERIALIZATION (0x43C) is exactly 88 bytes: existing 64-byte begin field offsets, then realm ID/generation at 64/72 and native mediator process/generation at 80/84. Require private role 0x449, the original nonzero Launchd pair, and nonzero relation scalars. Generic Begin64 must reject role 0x449; mediator Begin64 remains unchanged. The existing 36-byte noncommit reply recognizes the new selector and echoes request, operation and original transaction, with zero materialization and staged IDs. Encoding preflights the complete request; neither decoding nor scalar correlation authenticates the native origin.

Before client CREATE, Procd authenticates actual Loaderd and the retained running Launchd, resolves the exact original Guarded and unstarted mediator, and checks the same supervisor. Because the final plan digest includes actual client generations, the first admitted client request may bind a previously unbound mediator to that realm pair before creation. Retain this first binding even if client creation later fails. All later client requests and counted Provision must match it. Reject the same realm pair on any other retained mediator belonging to that supervisor, including retirement or uncertain cleanup. Bootstrap-only Provision can still perform the first binding when there are no clients. Preserve the actual parent/mediator/client relationship through active materialization, staged commit, rollback and terminal custody; numeric realm metadata grants no authority.

Client startup, ingress installation, complete configuration, authenticated seal, source disposal and native caller retirement remain separate gates. Clients cannot start until committed seal and its caller retirement are proved. The required two-realm/four-client byte-I/O and cross-realm refusal witness remains open. This is the implementation contract; it adds no native or phase acceptance.

Wire precision for configuration and seal — 24 September 2026:

RCP1 version1.0 uses Pull=1 and Reply=2. Its 96-byte common header
is magic/version at0/4/6, kind u16 at8, zero flags u16 at10, raw result
u32 at12, nonzero request u64 at16, complete realm context at24..64 and
configuration SHA-256 at64..96. Requests require result0 and add ordinal
u64 at96 plus reserved0 u64 at104. Replies echo ordinal at96. The validated
plan counts and ordinal determine the one allowed record kind and exact length;
payload length alone never selects policy or capability count. Preserve declared
client and descriptor record order; require unique public/native client pairs
and unique client/descriptor bindings without imposing numeric identity order.

RCS1 version1.0 has the160-byte header already specified: magic/version
at0/4/6, header size/flags at8/12, total bytes16, realm pair24/32, native
client40/44, mediator48/52, Procd56/60, CSpace count64, ingress slot72,
zero-right placeholder slot76, request/result bytes80/88, workspace
address/length96/104, configuration digest112..144, descriptor count144
and reserved0 u64 at152. It fixes the intended SEND at slot5 and the
zero-right placeholder at4. At least one initial binding is required, matching
the plan's coverage rule. Request/result minima are40/32 bytes, derived from
the actual Read/empty-Write request and QueryAbi/Write/error reply framing.
These minima guarantee framing only. The count and every packet/mapping extent
are checked; the consumer independently verifies actual mapping, rights and
inventory. Descriptor records preserve plan order and contain no duplicate fd.

RSC1 version1.0 shares the96-byte common header offsets above with its own
magic and kinds SealProbe=1, Prepared=2, SealCommit=3, Sealed=4,
ClientTerminal=5 and ClientTerminalAck=6. Request results are zero; replies
retain raw application result words. The first four kinds are exactly96 bytes.
Both terminal request and acknowledgement are exactly112 bytes: original native
client process/generation at96/100, native terminal kind/status at104/108.
Only the existing Exited/Killed terminal kinds are valid; all32 status bits are
preserved. Acknowledgements echo the entire terminal description even on refusal.
All replies correlate exact kind, request, context, digest and optional terminal
description. Descriptive decoding does not authenticate Procd or prove cleanup.

Private Procd PrepareSeal and CommitSeal use operation selectors0x439/0x43A
with the existing64/72-byte action framing. Their digest is the canonical
configuration digest, with all bit patterns valid; there is no unknown-digest
sentinel for these operations. Successful dispositions Prepared=4/Sealed=5 are
operation-specific; every refusal uses Unconfirmed=0. Start and Retire retain
their existing startup-digest semantics. REALM_CLIENT is the distinct0x449
process class and cannot enter ordinary launch/start/restart policy.

Canonical record indices need not equal physical runtime row positions. Before
serving, Posixd may move whole owned client rows while retaining each canonical
client index, check public/native pair uniqueness by sorting, then use native-pair
order for lookup. Each move retains all receiver custody. Descriptor references
use canonical indices; result regions are assigned after the final order and
before any delivery or I/O effect. No sorting is permitted during serving.
This avoids new arena allocation and repeated quadratic validation in the I/O
path. Configuration must still prove all uniqueness, binding and channel-coverage
invariants before admission. No runtime acceptance is asserted by these codecs.

Counted client configuration continuation — 24 September 2026:

Proposed coordinated continuation: configure each private Posixd instance with two actual staged clients and mediator-owned bounded byte channels. Preserve the existing startup/control handshake and native identity checks. Configuration is canonical, counted and digest-bound; labels select already held owners and never confer authority. This is a first nonblocking byte-I/O slice. Full filesystem/TTY configuration, complete POSIX semantics, libc, all resource-retirement criteria, rebuilding Rust/LLVM inside EriX and both complete EriX guest builds remain required later work.

Partition only the producer-supplied RW/NX arena into checked client/descriptor/channel rows, canonical-plan storage, explicit ring bytes, per-client retained results and one immediate packet workspace. The target layout must be authenticated and shared with the producer; no guessed host layout, global allocator or fixed deployment array may choose capacity. Pull the canonical configuration only after retiring Ready, retain every possible received endpoint before COLLECT, and register only validated RECV-only client ingress endpoints. The complete plan digest and real inventory must match before Prepared.

Use two-stage seal. After the final pull, retire its caller and drop/query configuration SEND; then answer Prepared while ordinary I/O remains refused. Admit I/O only after authenticated CommitSeal. Route by retained receiver plus actual client process/generation, then owned descriptor binding. Fairly rotate control and client delivery owners; a pending result cannot block another client. Each delivery mutates queues at most once and retains its exact result through COMPLETE or acknowledged draining/relinquishment. Authenticated exact client-terminal control closes its bindings once and retires remaining receiver/delivery custody. Wrong origins, stale generations, surplus receipts and partial configuration fail closed.

Authenticate target geometry through the existing selected-image path. Posixd exports one immutable 96-byte target-generated descriptor in read-only file-backed ELF load storage: magic16 ERIXPXSCAPLAY001, then ten little-endian u64 words for version1, total size96, ELF machine, pointer bits, and client/descriptor/channel row size/alignment pairs. Sizes are nonzero and alignments powers of two; target fields match the selected executable. Loaderd extracts exactly one complete descriptor from its already authenticated root ELF bytes, refusing missing, duplicate, malformed or writable records. No host-derived type size or reopened pathname supplies geometry.

An exact 144-byte BindRealmLayout request uses the existing authenticated LoaderMaterialization route: request/op u32, original active transaction u64, root ELF SHA-25632 and descriptor96. Its response uses the existing 36-byte materialization shape with zero noncommit materialization/staged fields. Procd accepts it only from actual Loaderd for that original active mediator transaction, retains the description through staged commit/rollback, and requires it before mediator commit. The startup carries the descriptor SHA-256, which Posixd compares against its own compiled descriptor before any typed arena borrow. Canonical checked sizing partitions client rows, descriptor rows, channel rows, plan bytes, ring bytes, retained per-client results and immediate packet storage; every multiplication, alignment, address and page round must fit. This grants no additional endpoint or allocation authority.

Ordinary endpoint transfer copies authority. Every source and possible receive destination remains owned across submission, collection and native retirement, including ambiguous results. Reserve each prospective receive slot before COLLECT; validate its normalized receipt and actual Generic kind/rights, then independently reconcile its disposal before reuse. Unique InstallGrant and RevocationGrant transfers keep MOVE semantics. Do not infer source deletion from successful copy or use deletion to manufacture successful unique-grant movement.

Track this continuation with Posixd realm lifecycle, POSIX ABI and Phase 6 completion. This is a proposed contract; no runtime or implementation acceptance is claimed.

The maintained appliance-disk-image-realm-startup-positive scenario passes unchanged: both actual Posixd processes reach authenticated PrivateReady; A retires while B stays ready; B then retires; both stale handles are rejected; the initial shell exits successfully. The original required, unique, ordered and forbidden markers, expected guest exit 0x10, 120-second guest hard limit and 45-second serial-progress limit all pass.

This exercises counted minimum startup, actual capability census, setup-grant consumption and copied SEND disposal before Start, followed by native child registration, exact-origin readiness and the controller challenge. The packaged Posixd alias selects the same authenticated executable; no ordinary sidecar, extra child endpoint or fallback is introduced. Source-bound exercised gates are the evidence; no separate global inventory dump is claimed. Posixd's Ready caller remains its separately owned obligation until retirement. The successful explicit-retirement path does not exercise Launchd's spontaneous WAIT decoder, final CPU/profiler handoff, repeated row reuse, loss paths or capacity exhaustion.

Launchd's six strict local configurations pass 329 library and 69 runtime tests each; all 48 required commands are warning-free. The corrected native-faithful 14-test group includes COPY source retention, post-Provision caller retirement, separate source disposal/absence verification and failure preservation. Original Launchd CI155/156 also passes: four complete logs, 148,673 bytes, zero warning/failure candidates. Original Integration CI1791/1792 remains queued; earlier failures and regression reports remain preserved. The copied-SEND defect and its native startup regression are resolved at this scoped boundary. Relevant implementation reviews remain Launchd PR2, Procd PR2, Posixd PR5 and Integration PR12.

Configuration/seal/publication, four real clients and mediated byte I/O, complete running retirement and profiler disposition, rebuilding the external Rust/LLVM toolchain inside EriX and both complete EriX guest builds remain required and unproved. The WIP reviews remain unfinished.

Each of the four default/all-feature development/release selections passes 14 tests, with development/release native executable builds also accepted. Formatting, strict host/native Clippy, warning-denied builds, private rustdoc, Markdown and exact original dependency checks pass with zero warnings.

Actual running mediator readiness/retirement, complete service-image acceptance, configuration/seal, client I/O and both required guest rebuilds remain open.

Tracking: owning issue, WIP PR and Phase 6 acceptance.

All four default/all-feature development/release selections pass 14 unit tests each. Formatting, strict host/native Clippy, doctests, private rustdoc, Markdown and original single-revision dependency checks pass. Warning-denied development/release freestanding ELF builds contain the entry and final RW/NX stack.

Coordinated producer provisioning, operation 58 supervisor-lifetime-binding adoption, actual Posixd start and native readiness/retirement VM acceptance remain pending. These source and host/build results do not establish a running realm or a full guest build.

Detailed scope and contracts

Validated mediator constructor adoption — 15 September 2026

A refusal never falls back to operation 32.

Exact requests, omitted receipt/drop, materialization, refusal without fallback and unchanged ordinary behavior are covered.

Runtime-image adoption, authenticated grant return, guarded bootstrap routes, private execution, receiver readiness, configuration/seal, client I/O, fair retirement and both full guest build generations remain open.

Construction without child root capabilities — 15 September 2026

Native prerequisite implemented at Kernel 6d2ca19c48d3663db4b3a1eba4e9b7588b351f6f with shared IPC 7c7712057cc5d16ab16a677a886caeac54814a16. Kernel operation 54 admits only actual Process endpoint holders and constructs a Created child with exactly one primary endpoint and no root capabilities. The native TCB retains address-space backing independently. The caller receives a unique install grant, an endpoint master and only an explicitly requested MAP-only VSpace receipt. The checked request distinguishes absence from a genuine slot-zero receipt. Former-root slots are usable; actual caller windows, native capacity, occupancy and child window scope remain enforced. Rollback disposes only successful new receipts and the partial child while preserving pre-existing bindings. Ordinary operation 32 remains unchanged. Initial inventory is not a seal or a permanent ban on later explicit installation. Both isolated native VMs pass; no runnable mediator follows from this prerequisite.

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. Ordinary mediator start gates remain closed. Whole-codebase semantic authority and private-item documentation audits remain incomplete.

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.

Procd uses the actual returned grant to attenuate the initial endpoint to RECV before execution, removes bypass sources, and retains nested custody beneath Kernel lifetime custody. A later mediator disposal report cannot prove absence of bypass senders.

Native upstream Rust/LLVM rebuilding and both complete EriX builds remain required.

Launchd uses its existing endpoint factory and retains the private configuration RECV/GRANT alias; the child receives only its existing control RECV and a guarded configuration SEND. Counted startup records and actual receipts must agree, with all temporary setup/grant disposal acknowledged before the separate private start gate.

Readiness requires actual CLAIM caller identity plus an acknowledged challenge through the retained control endpoint. Child-read-only startup mappings do not revoke Procd's trusted memory-write authority, and ordinary writable LCS1 startup mappings cannot silently stand in for this new contract. The current staged-only retirement path must gain exact running-child cleanup. A surviving child-termination owner after Procd loss remains a prerequisite: SEND lifetime revocation alone does not destroy that child, and Rootd exits after bootstrap.

Existing native guarded-preparation acceptance remains separate; full runtime lifecycle, configuration/seal, real client I/O, full frame proof, native upstream toolchain rebuilding and both full EriX build generations remain open. No whole acceptance item is added.

An install grant alone must not confer child termination authority.

Related records and contracts
Repository Links
integration issue 1
kernel issue 11, issue 19
lib-capabi issue 3
posixd issue 6, client-disposal.md, minimum-bootstrap.md
## Problem and motivation Compatibility programs need process-local filesystem, execution and stream routes without receiving global service authority. They also need bounded exceptional operations and reliable teardown across launch, approval, crash and cancellation. ## Proposed behavior and scope UID zero has no bypass, matched classes cannot fall through, duplicate qualifiers are refused and a combined group request must be covered by one matching entry. Native admission and exact original client/provider provenance remain mandatory. Unknown ACL support cannot become absence. Trusted per-client credential intake, coherent provider snapshots and actual native operation gates are still unfinished implementation. The helper must not be indiscriminately inserted before reads/writes of already opened descriptors. [The feature issue](https://git.erikinkinen.fi/erix/posixd/issues/10) remains open with enhancement, security and phase-6 metadata. Twelve original controls are authored but unrun, covering direct permission outcomes, masks and combined requests, UID zero, special bits, full-width IDs, malformed metadata and large caller-owned storage. Rust formatting was applied. Tests, builds, lint checks, rustdoc, manual builds, profiler runs and CI observation remain deferred; no pass or warning-free result is claimed. The metadata substep is implemented, while the complete permission-enforcement item remains open. Both EriX guest-build generations and the guest Rust/LLVM rebuild remain unproved. [Permission contract](https://git.erikinkinen.fi/erix/lib-posixabi/src/commit/0a27be14820446f6a29ba2ffe656a2df8a95782b/docs/permissions.md), [runtime design](https://git.erikinkinen.fi/erix/posixd/issues/10), [Phase 6 completion](https://git.erikinkinen.fi/erix/integration/issues/65). Completion is **16.07%** weighted, **20/460** parents and **428/888** sub-items across **158** decomposed parents. Reviews: [library](https://git.erikinkinen.fi/erix/lib-posixabi/pulls/3), [mediator](https://git.erikinkinen.fi/erix/posixd/pulls/5), [catalogs](https://git.erikinkinen.fi/erix/integration/pulls/12), [manual](https://git.erikinkinen.fi/erix/docs/pulls/4). Complete client entry census and independent zero-right placeholder disposal leave only the guarded SEND ingress. The mediator closes configuration acquisition, scans the complete local capability window one query per turn, then verifies each distinct original control, client receiver and selected source owner. No new alias can be acquired during this interval. Equal cardinality plus each exact owner proves no surplus alias remains; unknown queries, malformed absence and changed kinds/rights refuse preparation. This keeps control progress bounded, retains original custody and uses linear queries with constant additional stack storage and unchanged arena geometry. The audit fixed [external-descriptor start/seal refusal](https://git.erikinkinen.fi/erix/procd/issues/10) and [empty-table receiver-source disposal](https://git.erikinkinen.fi/erix/procd/issues/11), both recorded with the bug-report template. Procd admits D..=D+A while Launchd derives the exact stream subset from its frozen plan; directory bindings add no descriptors. An empty Commit performs the same original DROP/absence barrier following Begin caller retirement, without requiring a dummy descriptor or grant. Five new Posixd controls and three Procd controls are authored but unrun. Existing materialization, client census, seal, disposal and bounded VM controls remain; no new VM selector or relaxed acceptance gate is needed. Component architecture, applicable README, roadmaps, focused [realm contract](https://git.erikinkinen.fi/erix/posixd/src/commit/5874f330293af475bf4c40c69ef4b94c4a4c4733/docs/realm-ownership.md) and technical manual are updated. Rust formatting was applied. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred; no execution or warnings-free result is claimed. The fresh-process launch checklist item is complete under the testing override. Deny-only compatibility credentials/mode/ACL checks follow. Completion is **15.99%**, with **20/460** parents and **427/884** sub-items. Both complete EriX guest-build generations and rebuilding Rust/LLVM inside EriX remain unproved. Reviews: [Posixd](https://git.erikinkinen.fi/erix/posixd/pulls/5), [Procd](https://git.erikinkinen.fi/erix/procd/pulls/2), [Integration](https://git.erikinkinen.fi/erix/integration/pulls/12), [manual](https://git.erikinkinen.fi/erix/docs/pulls/4). Design ownership remains in [Launchd](https://git.erikinkinen.fi/erix/launchd/issues/1), [Procd](https://git.erikinkinen.fi/erix/procd/issues/1) and [Posixd](https://git.erikinkinen.fi/erix/posixd/issues/1). The separate rootless client requires two reciprocal descriptors plus one exact external Write descriptor at i32::MAX. It retains ingress-only native census, immutable startup/workspace ownership and cleanup. Shared lifecycle code requires six actual successful exits, retirement before START, absent stale clients, record reuse and a surviving peer. The final marker uses the original stdout lender after view retirement. Integration budgets 32 sources and 2640 canonical plan bytes, preserving ordinary exit and deadline gates. Eleven new test functions and six inherited packaging controls are authored but unrun. Existing attenuation and source controls cover read-only mutation, redelegation, parent/symlink escape, replay, receipts and cleanup. Component documentation and the manual describe the [bounded scenario](https://git.erikinkinen.fi/erix/integration/src/commit/7f1e4956ed21dbaec68593989e7a129fa0af62be/docs/realm-binding-witness.md). Formatting was applied. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred; no execution or warnings-free result is claimed. The witness covers binding metadata and disposal; it does not establish external backend byte I/O or complete caller-loss coverage. The binding checklist item is complete under the testing override. Fresh compatibility-process launch and final inventory acceptance are next. Completion is **15.78%**, with **19/460** parents and **425/884** sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. Reviews: [Posixd](https://git.erikinkinen.fi/erix/posixd/pulls/5), [Exsh](https://git.erikinkinen.fi/erix/exsh/pulls/3), [Integration](https://git.erikinkinen.fi/erix/integration/pulls/12), [manual](https://git.erikinkinen.fi/erix/docs/pulls/4). Design ownership: [Launchd](https://git.erikinkinen.fi/erix/launchd/issues/1), [Procd](https://git.erikinkinen.fi/erix/procd/issues/1), [Posixd](https://git.erikinkinen.fi/erix/posixd/issues/1). The graph uses one original signed commit per shared dependency. The separately committed [orchestration helper](https://git.erikinkinen.fi/erix/integration/commit/5df1fc01732b7eaf1e5b4768c653b38f2f6e0523) precedes its Rootd consumer and final catalog selection. All three catalogs retain immutable hashes without source replacement or branch fallback. Source inventory records 263 exact manifest edges. Two new source-budget controls and extended wire, alignment, layout and owner-loss controls are authored but unrun. The contracts and [technical manual](https://git.erikinkinen.fi/erix/docs/commit/36aa70041066cee8478488463e4872d50c8fe5cf) are updated. Counted configuration and deployment storage are complete under the testing override. Complete bounded native binding scenario authoring remains open, so the containing binding item stays open. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred; no execution result is claimed. Completion is **15.72%**, with **18/460** parents and **424/884** sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. Relevant reviews: [Rootd](https://git.erikinkinen.fi/erix/rootd/pulls/2), [Loaderd](https://git.erikinkinen.fi/erix/loaderd/pulls/2), [Exsh](https://git.erikinkinen.fi/erix/exsh/pulls/3), [Integration](https://git.erikinkinen.fi/erix/integration/pulls/12), [manual](https://git.erikinkinen.fi/erix/docs/pulls/4); design ownership remains with [Launchd](https://git.erikinkinen.fi/erix/launchd/issues/1), [Procd](https://git.erikinkinen.fi/erix/procd/issues/1) and [Posixd](https://git.erikinkinen.fi/erix/posixd/issues/1). Directory authorities contribute no descriptor and old startup minors reject without fallback. [launchd `99b2fc19`](https://git.erikinkinen.fi/erix/launchd/commit/99b2fc19ad1e4d970a5b9d5adc819bcd2247b650) counts and emits the same allocation-free frozen-plan record selection and requires cursor exhaustion before committing the original startup hash. [procd `5586e0f5`](https://git.erikinkinen.fi/erix/procd/commit/5586e0f51a19dc4a8b1782669051cec13e937ee8) admits the exact requested count within the original mediator's checked D+A storage ceiling, retaining all native relation, receipt and lifecycle gates. It also adopts the authority-aware target layout and C+A+6 native capability extent, and removes an unused direct time-library dependency. [posixd `7e4450c2`](https://git.erikinkinen.fi/erix/posixd/commit/7e4450c284693f351bd7180a997b5ee1cda9d8a8) adopts the new scalar startup format while preserving the full rootless client census. No provider SEND is installed into the client; its guarded mediator ingress remains the only operation route. [docs `eea18ab3`](https://git.erikinkinen.fi/erix/docs/commit/eea18ab386578481bf243218ab1c088da1bba575) updates the manual. Seven new controls are authored but unrun: one codec/version test, three descriptor-selection tests, two provisioning/count tests and one client-inventory test. Existing literal/malformed controls and target-layout bounds are updated; the public stream handoff/seal control now inspects actual external-only startup records. Formatting was applied. Tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction; no execution result is claimed. Coordinated Rootd/Integration/Loaderd/Exsh adoption and complete bounded native binding scenario authoring remain open. This finishes external-descriptor accounting but adds no checkbox credit for a still-open deployment step. Completion remains **15.65%**, **18/460** parents and **423/884** sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [startup provisioning](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/realm-client-provisioning.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [shared API review](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2), [Bootstrap review](https://git.erikinkinen.fi/erix/lib-bootstrap/pulls/2), [compatibility ABI review](https://git.erikinkinen.fi/erix/lib-posixabi/pulls/3), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [Procd review](https://git.erikinkinen.fi/erix/procd/pulls/2), [Posixd review](https://git.erikinkinen.fi/erix/posixd/pulls/5), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). [launchd `88eb2573`](https://git.erikinkinen.fi/erix/launchd/commit/88eb25732f637f8432f959e62ce8a1151f34c8ca) authenticates the original Running supervisor and guarded client, admits an actual caller-held SEND receipt, and creates the dedicated view from an explicitly budgeted provider pair. Complete generations survive success and refusal. The serial intake shares original receipt and reply-loss machinery with directory preparation. Lost admitted replies cancel the original cohort; stale or foreign requests exhaust their actual receipts without acquiring cancellation authority. A fresh native caller proof precedes successful publication. Provider cleanup preserves the lender. [docs `cf566ff1`](https://git.erikinkinen.fi/erix/docs/commit/cf566ff11eb24da25eecc52aeaf5001896302d58) documents the public wire contract and ownership ordering. Four wire and six public runtime controls are authored but unrun, covering exact framing, atomic refusal, access/descriptor bounds, complete generations, actual view identity, replay, surplus or contradictory receipts, reply loss and caller replacement. The existing native delivery/seal control now obtains its views through public requests. Formatting was applied; tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction. No executed test or image result is claimed. The filesystem/stream producer and frozen-plan receipt-binding substeps are implemented, including the published [Posixd consumer](https://git.erikinkinen.fi/erix/posixd/commit/442a805cbb4ec00c8f8e86f16e16545ad37d8837). Their checkboxes now reflect implementation completion under the testing override. External-descriptor accounting, coordinated deployment/image adoption and the complete bounded native scenario authoring remain unfinished, so the enclosing binding item stays open. Recalculated completion is **15.65%**, **18/460** parents and **423/884** sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [stream ownership](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/recipient-stream-views.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [shared API review](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2), [Bootstrap review](https://git.erikinkinen.fi/erix/lib-bootstrap/pulls/2), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Counted realm stream source ownership — 29 September 2026: signed [launchd `892f8fc0`](https://git.erikinkinen.fi/erix/launchd/commit/892f8fc0ec901d56a091491503194274e13089b5) adds a semantic producer authenticated against the original Running supervisor, guarded client and actual SEND receipt. Explicitly budgeted provider pairs and the existing serialized movement column produce separate SEND-only recipient views. Disposed providers remain reserved until their exact source owner accepts reply completion. Realm retirement rotates provider/source cleanup, lender cleanup waits for the original borrowing realms, and occupied realm/client receiver identity prevents self CALLs. Zero provider capacity disables creation without fallback. First uncertainty survives later absence while other owners retire. Disposal before seal cancels the immutable cohort; later disposal can remain client-local. [docs `908209cf`](https://git.erikinkinen.fi/erix/docs/commit/908209cf5d7f27a1db489c3e23fc091ca47aa88a) updates the manual. Eight new controls are authored but unrun, covering actual object identity, native handoff/seal, descriptor bounds, disposed reservations, partial effects, caller loss, peer cleanup and local receiver identity. Formatting was applied; tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction. No executed test or image result is claimed. Public stream request codecs and authenticated dispatch/reply ownership, external-descriptor accounting and coherent image adoption remain unfinished. Completion stays **15.53%**, **18/460** parents and **421/884** sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [recipient stream ownership](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/recipient-stream-views.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). BOTH/CANCELLED disposes only its retained backend SEND and independently proves absence before acknowledgment, without data-access/offset restrictions or a lender status/CLOSE call. Source audit also fixed [Launchd issue 11](https://git.erikinkinen.fi/erix/launchd/issues/11): repeating generic delivery completion could drop an installed proxy backend from the former factory-source column. The state guard now refuses that phase before effects. Nine controls are authored but unrun, including actual sibling/lender preservation, stale generations, malformed requests, reply capacity, inventory contradiction and partial cleanup. [docs `5b43c817`](https://git.erikinkinen.fi/erix/docs/commit/5b43c817e4be1bcc333900260683cbc1cf2c85d2) updates the manual. Formatting was applied; tests, builds, lint checks, manual builds, profiler runs and CI observation remain deferred by user instruction. No executed reproduction, public runtime trigger or test pass is claimed. Public realm stream reservation, original caller/held-I/O admission, arbitrary descriptor binding, endpoint-pool realm ownership, counted stream source handoff and coordinated image adoption remain unfinished; the public realm path does not yet select this disposal mode. Completion stays **15.53%**, **18/460** parents and **421/884** sub-items. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [recipient-view contract](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/recipient-stream-views.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Native completion advances delivery; mediator Prepared and caller RELEASE precede disposal of original client RECV and directory SEND aliases. [lib-bootstrap `12b11fac`](https://git.erikinkinen.fi/erix/lib-bootstrap/commit/12b11fac4ae8118180ad173e3ad0ba58ee313128) aligns the immutable IPC dependency; [docs `7e9491ca`](https://git.erikinkinen.fi/erix/docs/commit/7e9491ca091cf5fef1451f7b9640702606445d0d) updates the manual. Two wire and six runtime controls are authored but unrun, covering malformed/stale/duplicate appends, reversed physical source order, exact native delivery, seal ordering and cleanup failures. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by user instruction, with no pass claimed. Dedicated recipient stream views and coordinated image adoption remain unfinished. Completion stays **15.53%**, **18/460** parents and **421/884** sub-items; no additional acceptance credit is assigned to this partial checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [directory ownership](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/realm-directory-roots.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [shared IPC review](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). [launchd `0caeb423`](https://git.erikinkinen.fi/erix/launchd/commit/0caeb42357ecfa78e6d0ee3b0b0c5a7b2d00b80f) authenticates the original Running supervisor and guarded client, admits actual SEND scope receipts and prepares original roots into counted custody. Lost admitted reservation/preparation replies cancel the original fixed realm cohort; malformed, stale, foreign, surplus and oversized requests dispose refused receipts without fallback or unearned cancellation ownership. [lib-bootstrap `76882bd3`](https://git.erikinkinen.fi/erix/lib-bootstrap/commit/76882bd3636c714f48cf6f7949399376e4937295) aligns the immutable IPC dependency; [docs `c146117f`](https://git.erikinkinen.fi/erix/docs/commit/c146117f2eb4a15b0c91cbb56feef32f8b240476) updates the manual. Five wire and six public-runtime controls are authored but unrun, alongside the previously published nine ownership controls. Source review corrected the earlier owner fixture's provider source identity and kept new fixture destinations within native CSpace bounds. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by user instruction, with no pass claimed. Canonical source append/native delivery, seal handoff, dedicated recipient stream views and coordinated image adoption remain unfinished. Completion stays **15.53%**, **18/460** parents and **421/884** sub-items; no additional acceptance credit is assigned to this partial checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [directory ownership](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/realm-directory-roots.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [shared IPC review](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Actual SEND receipts require matching native QUERY. [docs `37ddc4ad`](https://git.erikinkinen.fi/erix/docs/commit/37ddc4ad9d0dd2e4e8f5131713fc3584d77b8f40) updates the manual and corrects the configuration reservation width. Nine new admission, receipt movement, partial-effect, loss and cleanup regressions are authored but unrun. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by the user, with no pass claimed. Public source request decoding and authenticated dispatch, canonical source append/native delivery, seal handoff, dedicated recipient stream views and coordinated image adoption remain unfinished. Completion stays **15.53%**, **18/460** parents and **421/884** sub-items; no additional acceptance credit is assigned to this partial checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [directory ownership](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/realm-directory-roots.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [manual review](https://git.erikinkinen.fi/erix/docs/pulls/4) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Directory cleanup after handoff — 29 September 2026: signed [lib-ipc `b0b42939`](https://git.erikinkinen.fi/erix/lib-ipc/commit/b0b42939f7b3093a9096b7ef0a676cd332f9019e), [vfsd `8f34a3e2`](https://git.erikinkinen.fi/erix/vfsd/commit/8f34a3e29639a0abf153082d2ed161156831fcf7) and [launchd `79bcc9d4`](https://git.erikinkinen.fi/erix/launchd/commit/79bcc9d4ca533eb4f085ec96eb82b23fae972b8a) add cap-free retirement through Launchd's held private resolver after the operation SEND alias is discarded. The digest includes a non-reused object identity; plain cwd and inherited descendants are ineligible, and stale requests cannot select reused records. Launchd requires exact reply identity, matching header/body status and provider OK or NOT_FOUND. Transport absence does not prove provider disposal. Every injected receipt is retired independently. [lib-bootstrap `b00c8732`](https://git.erikinkinen.fi/erix/lib-bootstrap/commit/b00c8732f37ef44871273f5edb2ba503f73a3594) and [lib-time `49b5e713`](https://git.erikinkinen.fi/erix/lib-time/commit/49b5e713d615019bc18e16634554ab54433e56a3) align immutable dependencies; [docs `1c13c2e8`](https://git.erikinkinen.fi/erix/docs/commit/1c13c2e86160a020f4b0d0d31b43a1ecf0b3dd2e) updates the manual. Fourteen codec, provider and transport regressions are authored but unrun. Formatting was applied; tests, builds, lint checks, manual builds and CI observation remain deferred by the user, with no pass claimed. This completes a cleanup prerequisite. Authenticated public source preparation, counted original-source custody, seal handoff, dedicated recipient stream views and coordinated image adoption remain unfinished. The published Posixd consumer and Vfsd close barrier remain part of the binding contract. Completion stays **15.53%**, **18/460** parents and **421/884** sub-items; no additional acceptance credit is assigned to this checkpoint. Both full EriX build generations and rebuilding Rust/LLVM inside EriX remain unproved. See [directory ownership](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/realm-directory-roots.md), [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [Vfsd review](https://git.erikinkinen.fi/erix/vfsd/pulls/3) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Counted authority consumer — 29 September 2026: signed [Posixd `799cc1e0`](https://git.erikinkinen.fi/erix/posixd/commit/799cc1e01a8c253c845916d5fb3e185c152ed9ff), [compatibility dependency `17b8346c`](https://git.erikinkinen.fi/erix/lib-posixabi/commit/17b8346ca3d1d5729c9b2d17f1e80c589d1ebe0e) and [manual `a9906120`](https://git.erikinkinen.fi/erix/docs/commit/a9906120f0f949d7af7765bb2ba0a25b07520b35) publish actual noncopyable SEND owners, counted framing and target-generated authority-row geometry. Indexed admission matches the frozen plan and rejects native-slot, complete binding-key and internal/stream descriptor collisions without an additional count ceiling. Preparation rechecks actual senders; typed lookup requires an exact live native client after seal. Client disposal now waits for each provider result, acknowledged original caller retirement and local SEND DROP/independent absence before its receiver or control acknowledgment. Nonzero SUBMIT owners survive refusal; missing callers before acknowledged draining release are not cleanup evidence. Cleanup uses a retained client range and alternates with ordinary client turns. Sixteen new owner/table/service tests and the preceding receipt regressions are authored but unrun, covering all roles, malformed results, digest-correct duplicate bindings, caller loss, cleanup failures, exact original-route selection and peer isolation. Signed [final source review `442a805c`](https://git.erikinkinen.fi/erix/posixd/commit/442a805cbb4ec00c8f8e86f16e16545ad37d8837) removes an unconditional lender-live fixture assertion and adds contradictory NOT_FOUND metadata after DROP: the first failure retains the destination even after later absence. Lender preservation requires coverage in the unfinished stream-view producer. All changed code files remain below 1,000 lines. Formatting was applied; tests, builds, lint checks, VM runs, manual builds and CI observation remain deferred by the user, with no pass claimed. The [ownership contract](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/authority-bindings.md) requires Vfsd's published provider-before-reply directory barrier. Stream teardown requires a dedicated recipient view that accepts BOTH/CANCELLED independently of byte offsets and access, disposes its own provider custody before acknowledgment and preserves its lender. Existing ordinary Launchd proxies do not satisfy that full contract. Authenticated original-source preparation, dedicated stream-view production, source-owner handoff and coordinated Rootd/Integration/Procd/Loaderd/Exsh adoption remain unfinished. The image catalog still selects its earlier graph; fixture behavior does not establish production stream cleanup. Complete binding acceptance remains open. Recalculated accounting stays **15.53%**, **18/460** parents and **421/884** sub-items complete. Both full EriX build generations and the external-toolchain rebuild inside EriX remain unproved. See [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Posixd review](https://git.erikinkinen.fi/erix/posixd/pulls/5), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Eight regression tests are authored but unrun, including real directory pins, parent preservation, either provider-close failure, terminal-caller loss and receiver-disposal failure. The exact runtime is extracted into a focused module; changed code files remain below 1,000 lines. Formatting was applied. Tests, builds, lint checks, VM runs, manual builds and CI observation remain deferred by the user. [The source-confirmed close-ordering defect](https://git.erikinkinen.fi/erix/vfsd/issues/4) uses the bug-report template and is implementation-closed under that testing waiver, with no runtime pass claimed. Actual Launchd source preparation and delivery, Posixd retained provider callers and local alias disposal, Rootd/Integration publication and coordinated dependency selection remain unfinished. The image catalog still selects its earlier graph. Full binding acceptance remains open; recalculated accounting stays **15.53%**, **18/460** parents and **421/884** sub-items complete. Both full EriX build generations and the external-toolchain rebuild inside EriX remain unproved. See [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Vfsd review](https://git.erikinkinen.fi/erix/vfsd/pulls/3), [Posixd review](https://git.erikinkinen.fi/erix/posixd/pulls/5) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Unused source columns still require independent retirement; unexpected occupants quarantine the original realm without adoption or deletion, and generations survive reuse. Launchd also adopts the counted shared framing, allocation-free authority-key/collision validation with exact byte restoration, and record-specific capability rights through QUERY and native COMPLETE. Regression tests are authored but unrun; formatting was applied. Tests, builds, lint checks, manual builds and CI observation remain deferred by the user, with no pass claimed. Authenticated directory/stream source preparation and delivery, complete Posixd provider retirement, Rootd/Integration publication and coordinated dependency selection remain unfinished. The image catalog still selects its earlier committed graph. Storage admission alone cannot freeze or publish source authority. Binding acceptance stays open; accounting remains **15.53%**, **18/460** parents and **421/884** sub-items complete. Both full EriX build generations and the external-toolchain rebuild inside EriX remain unproved. See [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [Posixd review](https://git.erikinkinen.fi/erix/posixd/pulls/5) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Older schemas reject without fallback. Complete scalar admission rejects duplicate bindings and stream descriptors colliding with internal channels; clients may have no internal channels or initial descriptors. Independent wire, overflow, aligned-storage, collision, receipt-count and empty-client regressions are authored but unrun. Formatting was applied. Tests, builds, lint checks, manual builds and CI observation remain deferred by the user; no pass is claimed. This supersedes the preceding scalar-only codec scope. Runtime consumer adoption, explicit Launchd deployment storage, original source preparation and complete Posixd receipt/provider retirement remain unfinished. Integration still selects its earlier coherent dependency graph. The binding item and its four remaining substeps stay open; weighted completion remains **15.53%** with **18/460** parents and **421/884** sub-items complete. Full EriX and external-toolchain builds inside EriX remain unproved. See [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [Posixd review](https://git.erikinkinen.fi/erix/posixd/pulls/5) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). It encodes no capability slot and grants no native authority. The codec is not yet admitted by the counted configuration stream. Explicit authority counts, target owner-row layout, coordinated startup/provisioning framing, original Launchd custody and actual Posixd delivery remain implementation work. The existing five-step binding plan now has an explicit public sub-checklist: directory attenuation is complete, while the other four steps and the whole binding item remain open. Recalculated weighted progress is **15.53%**, with **18/460** parents and **421/884** sub-items complete. Existing section/parent weights are unchanged; this exposes completed prerequisite work and does not claim complete realm binding, a validation pass or either full guest build. See [binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Vfsd review](https://git.erikinkinen.fi/erix/vfsd/pulls/3), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2) and [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Counted authority-record extension — 29 September 2026 (design before implementation): append an explicitly counted authority section after clients, internal descriptors and channels. Each 64-byte record describes a canonical client index (u64), role selector (u64), typed role (u32), maximum operation access (u32), original-source identity digest (32 bytes) and reserved-zero tail (8 bytes). Roles distinguish source, toolchain, output, temporary, executable, root, cwd and inherited stream. Root/cwd use selector zero because each process has one of each; other directory roles allow full-width selectors. A stream selector is a nonnegative compatibility descriptor and must not collide with internal-channel descriptors. Source/toolchain/executable records require read-only policy. Other directory records select read-only or inherited read/write ceiling, never write-only directory authority; streams allow read, write or both. Access is a maximum bound, not evidence that the original native object grants those operations. The source digest is descriptive provenance from the original Vfsd object or stream lender, never a native object-identity substitute. Configuration admission must reject duplicate client/role/selector keys and stream-fd collisions before freezing. A client with no byte channels is valid, including a completely authority-free initial context. Every declared channel still needs an actual descriptor binding and its counted payload budget. Add a separate authority count and target-compiled owner-row layout; update exact startup/provisioning widths and versions together so older peers reject unsupported extensions. Authority pulls require one actual SEND receipt, while existing client pulls require one RECV receipt. Reserve recipient custody before COLLECT and preserve the original source until two-sided seal retirement. Public configuration must derive authority records from authenticated owner-specific preparation; it may not accept a caller-invented digest or arbitrary local slot as proof. Native lifetime, cancellation and cleanup remain implementation requirements, including distinct provider-object release and local alias deletion. Reply correlation, actual endpoint/SEND receipt and local QUERY must agree. Refusal never retries with weaker flags; original alias release and uncertain cleanup remain separate ownership obligations. Root evidence alone carries no authority. Ten new policy, identity, receipt, loss and cleanup tests are authored but unrun. Documentation describes the native custody contract. Counted root/stream records, retained configuration owners and actual delivery to Posixd remain implementation work. Integration has not adopted this prerequisite into its image graph. No binding-item completion credit, validation pass or full guest build is claimed. Tests and CI observation remain deferred. Tracking: [realm binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [Launchd review](https://git.erikinkinen.fi/erix/launchd/pulls/2), [completion](https://git.erikinkinen.fi/erix/integration/issues/65). Vfsd retains the effective policy behind the exact endpoint through cwd changes, redirection and redelegation; clearing request flags cannot recover access. The wire codec rejects operation-inappropriate flags, and older receivers reject unknown bits. Codec, confinement, write-denial, receipt-destination and cleanup tests are authored but unrun. Component documentation and the filesystem-service manual describe the contract. The Vfsd dependency closure is pinned coherently; Integration still selects its earlier coherent graph. Counted root/stream configuration, Launchd custody, actual Posixd receipt binding and the native binding scenario remain implementation work. This prerequisite does not complete filesystem/stream binding or add checklist credit. Testing and CI observation remain deferred; no validation pass or full guest build is claimed. Tracking: [filesystem design](https://git.erikinkinen.fi/erix/vfsd/issues/1), [realm binding design](https://git.erikinkinen.fi/erix/posixd/issues/1), [master completion](https://git.erikinkinen.fi/erix/integration/issues/65). Receipt-bound filesystem and stream configuration design — 29 September 2026 (implementation in progress): complete the binding of read-only source/toolchain directories, writable output/tmp directories, executable directories, root/cwd selectors and inherited streams to actual native receipts. The existing counted configuration only binds internal byte channels. Role names, path strings and a Generic SEND receipt do not themselves establish a directory's read/write or navigation ceiling. First extend Vfsd's existing scoped launch-directory request with two directory-only flags: `DIRECTORY_ROOT` (bit 1) pins the selected directory as the new navigation ceiling; `DIRECTORY_READ_ONLY` (bit 2, valid only together with `DIRECTORY_ROOT`) removes write authority. Existing zero-flag cwd derivation keeps its original ceiling; executable and manifest requests reject these directory flags. Unknown bits remain errors, so an old receiver cannot silently accept weaker semantics. Store the effective write ceiling behind the exact endpoint and carry it through cwd changes, nested directory resolution and redirection. Intersect it with the original namespace session; clearing request flags must never restore write authority. Anchor the new root to the selected provider object, retain original-object identity checks, and retire all independent pins on failure and close. Source and toolchain roots request both restrictions; output/tmp roots request a fresh ceiling without increasing their parent's access. Existing endpoint generation, release and uncertain-cleanup rules remain mandatory. Then extend the canonical configuration and explicit arena/deployment counts with typed root and stream records. Launchd resolves roots through its authenticated Vfsd route under the original owner's held directory capabilities and selects inherited streams from the same caller's live I/O owners. It retains original receipts and transfer ownership until exact source retirement. Posixd reserves custody before collecting each receipt, checks exact native QUERY/type/rights/slot evidence against the frozen realm/owner/role record, and seals only after transport ownership is fully retired. Numeric selectors never create routes. Teardown drops actual aliases and confirms absence before reuse, including cancellation and partial delivery. Storage remains explicitly counted without a fixed number of roots, directories or streams. Author focused codec, confinement, stale/replayed receipt, two-realm and cleanup regressions and a bounded native binding scenario; keep test execution and CI observation deferred under the user's current instruction. Publish coordinated producer/consumer revisions and update the manual and [master completion issue](https://git.erikinkinen.fi/erix/integration/issues/65). This design does not claim completed root/stream binding or either full guest build. Private provisioning transport refinement — 24 September 2026 (implementation pending): the guarded preparation request remains non-starting. Add separate typed Procd operations for Provision (`0x433`), private Start (`0x434`) and exact Retire (`0x435`), all admitted only from the original Launchd generation on its held private receiver. Provision carries a 48-byte request with exact child and realm identity plus explicit request/result byte budgets, and exactly one moved Generic SEND configuration receipt. Procd derives the actual child capability extent from its retained creation geometry, installs configuration at child slot 5, and computes page-rounded startup/workspace mappings beyond the recorded executable extent. Its successful 224-byte response returns the canonical 208-byte startup record after a 16-byte correlation/result/state prefix; failure carries no startup bytes. Start and Retire each carry 64 bytes with the original child/realm and canonical startup digest, preventing cross-stage substitution. These bytes constrain actual held routes and never confer authority. Procd has no existing own-process identity in its startup payload. Reuse native caller attribution through a separate 64-byte configuration ContextProbe/Ack before RBS1 construction. The probe carries correlation, realm/child and original Launchd identity, with zero controller fields; Launchd obtains the Procd pair from actual CLAIM, retains that original pair and echoes it in the correlated acknowledgment. Procd retains the accepted invocation through retirement before committing the resulting context. This adds no kernel identity query, process endpoint or permission to trust an arbitrary first challenge. Posixd still requires its supplied controller to match the challenge's actual native caller. Launchd explicitly reserves four capability columns per admitted realm in its authenticated deployment geometry. It creates the configuration receiver before exporting SEND, binds an ancestor revoker to its own native lifetime, keeps a separate nested revoker for early retirement, and removes all bypass source aliases. Original executable-scope storage may be reused for temporary construction only after its absence is acknowledged. Procd retains the received configuration sender in an already empty role-owned scratch column, accounts for every mapped frame and setup alias, consumes the actual GRANT through operation 58 only after provisioning, and records uncertain start disposition before the native start effect. No grant-derived MINT capability or ordinary-start fallback is added. Private Start completes only after native start and the independent control challenge have completed their owned caller cleanup; readiness uses Launchd's separate actual-child CLAIM and full startup digest. Invocation handles and application owners remain retained on cancellation, malformed response, lost reply, supervisor loss and partial disposal. Retire selects running termination after any possibly committed start and waits for exact terminal observation/destruction before acknowledging final retirement. Frame allocation and each handshake must preserve explicit ownership and bounded progress; ordinary staging and all existing refusal/cleanup witnesses remain required. Provision, Start, readiness, seal, publication and client I/O remain distinct acceptance steps. 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. <details> <summary>Detailed scope and contracts</summary> ### 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. ### Staged mediator handoff contract — 15 September 2026 Reserve Loaderd operation `0x654` (PREPARE_REALM) using the existing exact-executable preparation request/response layout. The operation selects the new Procd lifecycle class `0x448` (REALM_MEDIATOR); role values describe lifecycle policy and confer no capability authority. Launchd explicitly selects this operation after authenticating its executable object. The ordinary operation `0x652` keeps its existing behavior. Responses must echo the selected operation; no fallback is permitted. Loaderd validates the same sole exact-executable SEND receipt, authenticates the complete image graph, and uses the existing semantic materialization pipeline. The mediator's temporary initial endpoint occupies child-local slot 4, after native root slots 1–3. This slot is an ABI destination, not a realm-count or resource-budget restriction. The child remains staged. Procd retains the actual endpoint master in the existing managed scratch endpoint column; it never exports that master to Loaderd or Launchd. Only the actual move-only install grant travels Procd → Loaderd → Launchd. The derived ordinary stream installer is absent for this class. Reply loss aborts the exact stage and accounts for the retained endpoint, grant and VSpace; cleanup uncertainty remains fail-stop. Launchd may inspect, abort and stop only its owned lifecycle classes. Root, driver and powerbox routes cannot use the mediator class; generic staged-start, ordinary startup/stream installation and automatic restart reject it. The future separate bootstrap transaction must receive the actual grant back, authenticate the live caller, install a typed receiver/rendezvous inventory using exact process-bound installation, dispose temporary aliases and configure the startup bytes before private execution. No existing start path may bypass that gate. This staged handoff is the first implementation increment of typed realm bootstrap. Acceptance for this increment requires malformed/foreign operation rejection, exact executable and grant receipts, unstarted materialization, private master retention, no derived stream grant, and rollback coverage across the actual producer paths. It does not establish mediator execution, seal, publication, client I/O, retirement fairness or either complete guest build generation. Those remain required under the existing acceptance criteria. Native VM coverage of the coordinated producer graph is required before claiming runtime acceptance. Implement realm create/configure/seal/start/abort/retire states, namespace ceilings, deny-only compatibility credentials, resource accounting and ext4-based service startup. Integrate authenticated exceptional grants to exact live processes, including trusted consent and noninteractive build denial. The updated ownership design is published in [WIP PR #5](https://git.erikinkinen.fi/erix/posixd/pulls/5) at signed `4f1a964cd32e0b46ccf73f87a3be2efbb5f128ec`. Its [focused contract](https://git.erikinkinen.fi/erix/posixd/src/commit/4f1a964cd32e0b46ccf73f87a3be2efbb5f128ec/docs/realm-ownership.md) requires guarded SEND-branch custody before export, final-process receiver readiness before releasing the producer's sender, and private configuration pulls with capability-bearing owner replies. Ordinary control and client senders do not gain GRANT. Typed provisioning must consume the actual moved process-bound install grant; staged-process records and the retained SEND-only derived installer do not replace it. Procd is the proposed route-guard owner for mediator/Launchd loss. Procd loss needs a distinct ancestor guard, a surviving native holder and an independent trigger. Product Rootd exits after bootstrap. Quarantine, alias absence, process destruction and operation/provider completion remain separate facts. No upstream holder, wire field or runtime behavior is assigned by this documentation change. All 10 Markdown files, 19 local links, canonical sections, six governance files, original source correlation and whitespace checks pass for the three-file correction. Both current component [push CI 3](https://git.erikinkinen.fi/erix/posixd/actions/runs/3) and [PR CI 4](https://git.erikinkinen.fi/erix/posixd/actions/runs/4) pass, checking all 10 Markdown files with zero lint errors. Both complete logs total 7,232 bytes and are bound to the signed source. This is documentation validation, with no runtime acceptance. Matching Docs `928ff81a1d6dea09145f49fd4fbe07ab84525000` in [Docs PR #4](https://git.erikinkinen.fi/erix/docs/pulls/4) is signed and published. Its nineteen API routes select original seventeen-function library 4207509, and the realm narrative matches the guarded custody design. All 44 documentation tests, selected API consistency and 55 Markdown files pass. The complete 2,331-page manual has zero final warnings and all 423,064 word boxes fit; nine selected pages pass visual review. An initial page-selection bound failure and a finalization-prefix collision remain retained and are corrected without render, extraction, API or runtime replay. Matching Docs [push CI 833](https://git.erikinkinen.fi/erix/docs/actions/runs/833) and [PR CI 834](https://git.erikinkinen.fi/erix/docs/actions/runs/834) both pass for signed928ff81a, ending at 04:51:47 UTC on September 13. Each manual job passes 44 tests and produces 2,331 pages with zero final-pass warnings; each Markdown job checks 55 files with zero errors. All four complete logs are retained (750,388 bytes). Thirty first-pass and one second-pass convergence warnings per manual resolve before the final pass. The logged final PDF size is 4,090,720 bytes; CI artifact bytes and geometry were not independently inspected. Prior Docs b11a745 and CI831/832 validate only the preceding fourteen-function manual. Prior source `91b18c9199ff8c9219a5e47718d951266722761c` passed CI1/2 and its preceding manual passed Docs CI821/822; those results remain specific to the prior design. The initial prior Markdown failure remains retained. The repository has no implementation crate. Native acceptance must include two actual mediator processes, two clients per realm, real mediated byte I/O, authenticated denial and complete owned retirement. Rust/VM checks are inapplicable to this documentation-only change; no runtime acceptance or completion credit is claimed. This issue records planned work; its unchecked criteria are not implementation proof. The normative basis is [Phase 6 and AC1–AC24](https://git.erikinkinen.fi/erix/docs/src/branch/main/phases/6.md). 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. </details> ## Authority, security and reliability <details> <summary>Detailed scope and contracts</summary> ### Failure-only lifecycle cleanup After a sealed service records its first error, ordinary advancement, member admission and signaling remain frozen. Bootstrap retains its original watched control receiver and authenticates the controller CLAIM, exact context/digest and distinct terminal/disposal kind. A cleanup-only control entry accepts those original lifecycle requests, closes only the named original client, and retains the complete request beside its retirement owner. Cleanup advancement selects only that client's generation-checked retained invocation rows. It cancels original external, readiness and publication work, then retires the original callers, semantic provider owners, factories and receiver without ordinary CLAIM, COMPLETE replay or new operation submission. Every source still requires its independent acknowledgment and absence proof; uncertainty preserves the first diagnostic and all remaining owners. The native loop must reach this path after a service error, retaining unrelated peer/lender state until independently authenticated closure. Bootstrap/control uncertainty still terminates the process. Positive, malformed-input, foreign/stale controller, refused cleanup, once-only completion and unaffected-peer controls must prove the boundary; ordinary advancement continues returning the original failure. This extends cleanup reachability without clearing uncertainty or narrowing full POSIX/native/guest requirements. Ordinary byte-I/O uses one retained serving delivery and one complete result region per configured client, with fair turns for other clients and private control. Authenticate the actual registered receiver and native CLAIM origin before descriptor lookup or effect. Prepare the exact result before queue or binding mutation; each accepted delivery commits at most once and retains those bytes through native completion or acknowledged invalidation/retirement. Read and Write validate access even when their count is zero, permit short progress, and preserve the specified EBADF/EAGAIN/EPIPE/EOF and close-once semantics. The configured result-storage ceiling is distinct from the native result budget chosen for a particular invocation. The existing CLAIM receipt does not expose that budget. A caller that supplies too little native result capacity can cause COMPLETE to refuse a result after the mediator has committed an effect. The mediator must preserve the exact result and original delivery, never re-execute or roll back that effect, and continue unrelated clients and control. Only actual caller invalidation or exact client termination followed by acknowledged native retirement permits reusing the retained row. A still-serving owner that refuses RELINQUISH remains pending; absence without prior retirement evidence is not cleanup. No additional Kernel authority or budget-query API is introduced. An unauthorized, unsealed or malformed claimed delivery performs no descriptor or channel operation. Its refusal may complete the native delivery with an empty capability-free payload; that payload deliberately is not a valid compatibility result and conveys no other client's metadata or asserted correlation. The caller must reject it and retire its invocation. Failed refusal completion retains the original serving owner under the same bounded cleanup rules. The immutable target layout descriptor derives from the actual compiled client, descriptor and channel runtime types used by the native mediator. It is not a host estimate or a placeholder record size. Checked, disjoint arena slices hold those rows, canonical plan bytes, ring storage, per-client exact results and reused packet scratch. This contract requires focused fault-injection tests and an actual native client witness; it does not claim complete POSIX semantics, libc or a self-hosted EriX/toolchain build. Bind capabilities and revocable aliases to process/job/realm generations, resolved objects, permitted operations and finite lifetimes. Numeric realms, uid 0, PATH and labels cannot mint access. Keep native private receive routes internal, and retire all descendants and partial transfers when the realm ends. Apply the priority order: security, reliability, then performance. Keep suspected vulnerabilities in the repository’s restricted SECURITY.md reporting channel. </details> ## Acceptance criteria <details> <summary>Checklist</summary> - [ ] Specify per-realm/per-process ownership and isolation inside `posixd`; separate private native service routes from each client's narrow authenticated ingress and reject numeric-realm impersonation. - [ ] Implement create/configure/seal/start/abort/retire realm states with generation-bound identities, validated resource ceilings and exact rollback. - [ ] Bind read-only source/toolchain roots, output/tmp roots, executable directories, cwd/root selectors and inherited streams from actual receipts. - [ ] Implement launch integration that creates a fresh compatibility process context, supplies only its selected routes, and never grants global `named`, provider, device, raw-block or kernel process-control endpoints. - [ ] Implement deny-only uid/gid/group/mode/ACL checks after native capability admission; test uid 0, chmod/chown-like metadata and executable permission changes cannot manufacture access or bypass a capability ceiling. - [ ] Implement explicit root/cwd/PATH resolution confined to delegated namespace/executable roots; environment text, absolute paths and `..` cannot escape the realm or select an undelegated service. - [ ] Implement resource accounting for process/thread/fd/memory/temp and in-flight work, with deterministic exhaustion and no fixed accidental table cap. - [ ] Implement noninteractive build policy: out-of-envelope operations fail promptly with documented errors, without hanging for a hidden prompt. - [ ] Implement realm teardown on normal exit, crash, denied transfer, launch abort, timeout and supervisor failure; retire all descendants/aliases and prove process/realm generation reuse cannot recover prior authority. - [ ] Add two-realm isolation VMs for filesystem, process, credentials, descriptors, service routes and teardown; include malicious message replay. - [ ] Package/start `posixd` from ext4 after the required native services; keep compatibility orchestration out of rootd and preserve READY/shell ordering. - [ ] Implement runtime exceptional-authority requests from running compatibility processes through their authenticated launch/realm route; resolve only within the caller's existing delegated selector ceiling. - [ ] Bind every grant to exact process/job/realm generations, resolved object identity, permitted operation and explicit one-shot/invocation/transaction lifetime. Never turn approval into a broad directory or reusable admin grant. - [ ] Extend trusted prompt descriptions for compatibility programs to show executable provenance, operation, object and lifetime; escape untrusted labels and keep labels/argv/paths non-authoritative. - [ ] Preserve automatic same-session secure attention, trusted y/n plus Enter decisions, renderer acknowledgement and fresh-input fences on serial and framebuffer TTYs. Untrusted PTY output cannot approve or spoof a prompt. - [ ] Deliver approved grants to the exact still-running process using explicit caller-local slots and tracked revocable aliases; reject stale, replaced, cancelled or already-exited recipients and clean partial delivery. - [ ] Implement operation-completion/denial/timeout/cancellation/revoke cleanup, including process death during approval and errors after one-shot consumption. No grant remains reusable by a later process or shell command. - [ ] Support exact-entry unlink/rename/truncate and reviewed recursive transaction envelopes; require a fresh explicit policy for any traversal scope, and prove rollback/partial-progress rules without ambient parent-directory write. - [ ] Add interactive VMs for approve, deny, revoke, malformed grant, object replacement, process exit, wrong TTY, replay and two-realm isolation; add a noninteractive build VM proving no prompt or silent escalation occurs. 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. </details> ## Alternatives and tradeoffs A global POSIX namespace or broad approval grant would exceed native capability ceilings. Mediate each client through its own authenticated route and keep compatibility orchestration out of rootd. Validation checkpoint — 14 September 2026: Signed Posixd `52ef820d33399490c121aad3af1409139e4a8f44` selects the proposed realm custody owner: Procd deposits an ancestor SEND-lineage revoker into its exact native generation before export and retains a nested guard for earlier realm retirement. Exported aliases descend from the nested guard; ancestor-only bypass and setup aliases must be removed before publication. Runtime producer adoption, realm byte I/O and both complete guest build generations remain open. Owned invocation wire and native acceptance — 15 September 2026: Signed Posixd `3118b9008a85977b48babc342ba0587ddc99dd57` corrects stale upstream status and records producer adoption prerequisites. Merely adding a realm table cannot establish bounded cleanup progress: the implementation must separately own and schedule native terminal intake, SEND-branch retirement and provider completion, retain actual moved install/guard custody, authenticate exact generation-bound readiness/configuration, dispose setup authority and only then seal. Two realms with two clients each performing mediated byte I/O, broader failure/reuse evidence, full audits and both complete EriX-in-EriX build generations remain open. Typed realm bootstrap installation design — 15 September 2026: The next bootstrap producer step requires validating the actual moved install grant against the intended child before any installation. Add Kernel-control operation 52, INSTALL_WITH_GRANT_FOR_PROCESS, using the existing fixed request/reply envelope: flags and arg3 are zero; arg0 packs grant slot in bits 0..31 and source slot in bits 32..63; arg1 packs child destination slot and exact requested rights; arg2 packs nonzero process ID and nonzero staged generation. Both response values remain zero. The operation is admitted only where grant installation is already allowed (process-control and child-population endpoints, with existing bootstrap control policy preserved). The held unique grant remains the authority; the supplied process/generation pair is an additional equality constraint, never a target-selection grant. Revalidate exact native grant binding, GRANT possession, child/staged identity and current staged liveness, slot and type/rights ceilings, actual source binding and empty destination before transfer. Unlike legacy zero-means-inherit installation, this operation always uses the exact supplied rights, including zero. Reject nonzero reserved input and zero identities deterministically; mismatched target identity must produce no installed alias or new revocation lineage. Keep old producer semantics unchanged until explicitly migrated. Share the native installation implementation and split the existing near-1000-line control dispatcher by responsibility. Tests must use actual moved install grants for distinct staged children, wrong/stale generations, occupied destinations, explicit zero rights, invalid fields, denied endpoint policy, preserved source/grant custody and native lifetime/revocation behavior. Connect the new checked operation to typed Procd bootstrap provisioning; a standalone scalar codec or host-only table is not realm runtime acceptance. Complete receiver readiness, setup-authority disposal, fair terminal/provider scheduling, two-realm byte I/O and both full guest builds remain required. Process-bound native acceptance — 15 September 2026: Signed Kernel `60da5858d7198185efd103f0e91e5ac2e0b63e67` implements control operation 52, checking the actual moved install grant against expected process/generation with exact rights, including zero, under existing endpoint policies. Signed Procd `f1105706cc19ed024a6cca79a29abc57c90c6661` uses 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. The mediator class cannot use ordinary start, immediate commit, TTY provisioning, powerbox installation or automatic restart. Procd has forty native binary builds and six new mediator refusal/cleanup regressions. No Posixd executable or coordinated realm VM acceptance is claimed. Actual grant-return provisioning, authenticated caller ownership, typed startup memory/inventory, readiness, configuration/seal, client I/O, fair retirement, complete consumer image adoption and both full guest build generations remain open. <details> <summary>Detailed scope and contracts</summary> ### Native bootstrap destination correction — 15 September 2026 The temporary endpoint destination is now child-local slot 4, after the mandatory CSpace, VSpace and TCB roots in slots 1–3. This proves the constructor boundary; coordinated mediator startup, seal, client I/O, retirement and full guest builds 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. Typed mediator bootstrap, ordinary service-image adoption and both complete EriX builds inside EriX remain open. The existing held Process or Root route remains required; descriptive identities do not grant authority. An absent or different generation acknowledges absence of only the requested instance, with zero response values; it cannot mutate a replacement. 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. Ordinary mediator start, whole-image admission and both complete builds inside EriX remain separate open gates. Generation-bound cleanup consumer acceptance — 18 September 2026: Signed revision `2aefcaa7b2d847a6982d5d24fefac89a536e6bf8` is pushed. Runnable mediator bootstrap, fair retirement and both complete builds inside EriX remain open. The native pending caller must match a retained running Launchd generation. The actual sole receipt must be INSTALL_GRANT with exactly GRANT|MINT. Previously guarded, started, stale, ordinary-role and malformed stages refuse before new effects. Use the real returned grant and native operation 53 to narrow the Created child's primary endpoint to RECV. Establish an ancestor SEND branch under Kernel lifetime custody and a distinct nested explicit revoker before any export. Lost reply, rollback, abort, supervisor loss and terminal cleanup must account for every reused scratch column, actual guard and exact child identity. Counted final receivers/configuration, owned fair intake/provider/retirement progress, private execution, authenticated readiness, initial receiver disposal, seal/publication, real two-realm client I/O and both complete builds inside EriX remain required. Host models or this guarded stage acknowledgment cannot substitute for those acceptance gates. </details> ## Tracking and rollout Native configured-client acceptance — 25 September 2026: the exact signed [Integration 7a42fa26](https://git.erikinkinen.fi/erix/integration/commit/7a42fa2663bda878edcf59de01d972dd20c58ec7) graph passes the configured-client, preparation and startup VMs with all original markers, deadlines and cleanup gates. The configured witness seals two isolated realms, observes six successful byte-client exits across three realm instances, checks independent retirement, rejects stale client selectors and reuses a Launchd realm record with a new generation. This proves the native configure/seal/publish/mediated-I/O criterion; full Procd managed-row/final CPU reclamation, supervisor loss and resource ceilings remain separate requirements. [Launchd 372ab70e](https://git.erikinkinen.fi/erix/launchd/commit/372ab70ea2ea1133a9bc3edb2cb621f9679b075d) retains only the required result-carrier GRANT and preserves RECV-only client copies plus complete setup retirement. All six strict 497-test configurations and original CI179/180 pass. [Loaderd 5bcf522c](https://git.erikinkinen.fi/erix/loaderd/commit/5bcf522cfec873fa29ffe1b91bde1bf67e9f5ba2) retains the counted grant destination; four strict 145-test configurations and original CI107/108 pass. The original red tests, failed native runs and admitted host TCG diagnostic remain preserved. [Docs 6a1a9686](https://git.erikinkinen.fi/erix/docs/commit/6a1a96869736030727d0366c3e7622993dded7ff) passes the full 2,655-page manual and 45 tests locally and in original CI1085/1086; four complete CI logs total 824,660 bytes and final warnings are zero. The [configuration carrier defect](https://git.erikinkinen.fi/erix/launchd/issues/10), [counted grant defect](https://git.erikinkinen.fi/erix/loaderd/issues/5) and [configured-client stall](https://git.erikinkinen.fi/erix/integration/issues/92) are resolved by this component and native evidence. The [Exsh fixture report](https://git.erikinkinen.fi/erix/exsh/issues/10) retains its pending release compiler/frame validation despite the three native passes. Complete Integration CI1801/1802 is still queued. Whole-fleet authority/source/effect/frame acceptance, final accounting/profiler observation, rebuilding the external Rust/LLVM/runtime toolchain inside EriX and both full EriX guest-build generations remain open. Original prerequisite Integration CI1793/1794 each passes 490/491 scenarios; Rust and Markdown pass, and six complete logs total 27,432,406 bytes with zero warnings. CI1794 retains the [ext4 quota timeout](https://git.erikinkinen.fi/erix/integration/issues/18). CI1793 instead exposes a distinct [one-shot replay QMP connection loss](https://git.erikinkinen.fi/erix/integration/issues/93), recorded using the canonical bug template and phase label. No original workflow was rerun, and no deadline or authority check was relaxed. Only the existing native-witness sub-item gains credit: **15.42% weighted progress**, 413/873 sub-items. Whole acceptance remains **3.86%, 17/460 parents**. Disposal consumer CI and component acceptance — 25 September 2026: original [Posixd CI33](https://git.erikinkinen.fi/erix/posixd/actions/runs/33) and [CI34](https://git.erikinkinen.fi/erix/posixd/actions/runs/34) pass at signed [3541ce5d](https://git.erikinkinen.fi/erix/posixd/commit/3541ce5d621bfbf32e89df1882c3b15cb5ecd707). The completion checklist now exposes this implemented consumer disposal component; [PR5](https://git.erikinkinen.fi/erix/posixd/pulls/5) remains unfinished for coordinated execution. Full configure/seal/client I/O, supervisor/lost-reply recovery, native failure/reuse and both guest rebuilds remain required. Wrong origin/digest/kind, stale clients and changed pending requests are refused; uncertain receiver cleanup and failed COMPLETE preserve custody without replay. [PR5](https://git.erikinkinen.fi/erix/posixd/pulls/5) remains unfinished: Launchd runtime orchestration, coherent four-client configuration/seal/I/O, full loss/reuse and both guest rebuilds remain required. It validates complete RCS1 startup and the actual capability inventory, disposes the zero-right placeholder, and uses only the supplied SEND ingress for cap-free QueryABI/Read/Write/Close calls. Each original invocation remains retained through correlated collection and acknowledged retirement; uncertain results cannot cause replay or reuse. Its reciprocal workload checks realm-bound bytes, short progress, descriptor-rights refusal, close-once behavior and EOF without shell, filesystem, clock, logger or process-control authority. All four local feature/profile configurations pass 58 tests. Strict host/native Clippy, private rustdoc, formatting and warning-denied builds pass. Independent review verifies 39 terminal checks, both executables' debug/release entry and stack geometry, and the mediator's unchanged read-only/nonexecutable layout descriptor. Every Rust file is below 1,000 lines. Original [CI31](https://git.erikinkinen.fi/erix/posixd/actions/runs/31) and [CI32](https://git.erikinkinen.fi/erix/posixd/actions/runs/32) now pass at this exact head: four complete logs, 123,933 bytes, zero warnings/errors and 58 tests in each of four configurations per Rust job. No failed input was retried. Coherent native producer adoption and the two-realm/four-client configuration, seal and byte-I/O VM witness remain open in the [implementation PR](https://git.erikinkinen.fi/erix/posixd/pulls/5). This checkpoint adds no native execution or guest-build acceptance. The phase checklist now exposes the completed native consumer implementation and component-validation sub-item. Weighted progress is15.37%, with400/861 sub-items; whole acceptance remains3.86%,17/460 parents. Original parent scope and section weights are unchanged. Coordinated producer adoption, configuration/seal/client-I/O VM evidence and complete loss/reuse/accounting cleanup remain open. The new RCS1 byte-client executable is separate development work and receives no acceptance credit from these earlier runs. Complete client admission/lifecycle design — 25 September 2026: the [shared codec design](https://git.erikinkinen.fi/erix/lib-ipc/issues/1) now defines public Launchd operations6D5–6DD using only original owned realm/client handles; private Procd provisioning43D–441; distinct authenticated never-started client disposal messages; and LCH1v4 counted client-row/plan-byte storage. No public caller nominates a native process or capability identity. Freeze verifies the complete canonical plan before effects; private provisioning preserves grant MOVE, receiver COPY and independent source/caller retirement. Client Start follows the two-sided seal, and exact terminal outcomes remain in counted storage until realm retirement. The first immutable byte cohort is explicitly scoped; it is no permanent POSIX process ceiling. A dedicated rootless byte-client binary will use RCS1 and its own ingress only. Implementation, strict validation and the real four-client VM witness remain open. The independent release ELF check found [descriptor-page overlap](https://git.erikinkinen.fi/erix/posixd/issues/8). The signed linker correction and fresh native debug/release builds now place one complete descriptor on exclusively read-only, nonexecutable pages. The original refused artifact remains retained. Original [CI27](https://git.erikinkinen.fi/erix/posixd/actions/runs/27) and [CI28](https://git.erikinkinen.fi/erix/posixd/actions/runs/28) stop before Rust compilation because the pinned helper catalog omits Lib-PosixABI; [the helper-selection defect](https://git.erikinkinen.fi/erix/posixd/issues/9) records four complete logs23,718 bytes and passing Markdown jobs. A reviewed exact helper revision will correct the inventory while preserving strict unknown-source rejection. No failed job was retried. Coherent producer adoption and the two-realm/four-client configuration, seal and byte-I/O VM witness remain open. [Implementation review](https://git.erikinkinen.fi/erix/posixd/pulls/5) stays WIP. No additional checklist or guest-build acceptance is added. Private client materialization contract — 24 September 2026: the existing materialization-begin frame carries only the supervisor pair. Role recognition alone cannot bind an actual client to its intended mediator before native creation. Use distinct private operations with explicit descriptive correlation, authenticated through the existing Loaderd and Launchd routes; no new capability or ordinary-launch fallback is introduced. Loader `PREPARE_REALM_CLIENT` (`0x655`) is exactly 340 bytes: retain the existing 316-byte exact-executable selection offsets, then realm ID/generation u64 at 316/324 and native mediator process/generation u32 at 332/336. Its distinct 176-byte reply retains the existing 152-byte result/grant/digest fields, then echoes the complete relation at 152/160/168/172 on both success and refusal. Existing failure-zero rules still apply to staged/grant IDs and digest evidence. The old 316/152-byte parsers reject this selector. The exact executable SEND retains COPY semantics and independent source disposal; the staged install grant retains MOVE semantics. Procd `BEGIN_REALM_CLIENT_MATERIALIZATION` (`0x43C`) is exactly 88 bytes: existing 64-byte begin field offsets, then realm ID/generation at 64/72 and native mediator process/generation at 80/84. Require private role `0x449`, the original nonzero Launchd pair, and nonzero relation scalars. Generic Begin64 must reject role `0x449`; mediator Begin64 remains unchanged. The existing 36-byte noncommit reply recognizes the new selector and echoes request, operation and original transaction, with zero materialization and staged IDs. Encoding preflights the complete request; neither decoding nor scalar correlation authenticates the native origin. Before client CREATE, Procd authenticates actual Loaderd and the retained running Launchd, resolves the exact original Guarded and unstarted mediator, and checks the same supervisor. Because the final plan digest includes actual client generations, the first admitted client request may bind a previously unbound mediator to that realm pair before creation. Retain this first binding even if client creation later fails. All later client requests and counted Provision must match it. Reject the same realm pair on any other retained mediator belonging to that supervisor, including retirement or uncertain cleanup. Bootstrap-only Provision can still perform the first binding when there are no clients. Preserve the actual parent/mediator/client relationship through active materialization, staged commit, rollback and terminal custody; numeric realm metadata grants no authority. Client startup, ingress installation, complete configuration, authenticated seal, source disposal and native caller retirement remain separate gates. Clients cannot start until committed seal and its caller retirement are proved. The required two-realm/four-client byte-I/O and cross-realm refusal witness remains open. This is the implementation contract; it adds no native or phase acceptance. Wire precision for configuration and seal — 24 September 2026: `RCP1` version1.0 uses Pull=1 and Reply=2. Its 96-byte common header is magic/version at0/4/6, kind u16 at8, zero flags u16 at10, raw result u32 at12, nonzero request u64 at16, complete realm context at24..64 and configuration SHA-256 at64..96. Requests require result0 and add ordinal u64 at96 plus reserved0 u64 at104. Replies echo ordinal at96. The validated plan counts and ordinal determine the one allowed record kind and exact length; payload length alone never selects policy or capability count. Preserve declared client and descriptor record order; require unique public/native client pairs and unique client/descriptor bindings without imposing numeric identity order. `RCS1` version1.0 has the160-byte header already specified: magic/version at0/4/6, header size/flags at8/12, total bytes16, realm pair24/32, native client40/44, mediator48/52, Procd56/60, CSpace count64, ingress slot72, zero-right placeholder slot76, request/result bytes80/88, workspace address/length96/104, configuration digest112..144, descriptor count144 and reserved0 u64 at152. It fixes the intended SEND at slot5 and the zero-right placeholder at4. At least one initial binding is required, matching the plan's coverage rule. Request/result minima are40/32 bytes, derived from the actual Read/empty-Write request and QueryAbi/Write/error reply framing. These minima guarantee framing only. The count and every packet/mapping extent are checked; the consumer independently verifies actual mapping, rights and inventory. Descriptor records preserve plan order and contain no duplicate fd. `RSC1` version1.0 shares the96-byte common header offsets above with its own magic and kinds SealProbe=1, Prepared=2, SealCommit=3, Sealed=4, ClientTerminal=5 and ClientTerminalAck=6. Request results are zero; replies retain raw application result words. The first four kinds are exactly96 bytes. Both terminal request and acknowledgement are exactly112 bytes: original native client process/generation at96/100, native terminal kind/status at104/108. Only the existing Exited/Killed terminal kinds are valid; all32 status bits are preserved. Acknowledgements echo the entire terminal description even on refusal. All replies correlate exact kind, request, context, digest and optional terminal description. Descriptive decoding does not authenticate Procd or prove cleanup. Private Procd PrepareSeal and CommitSeal use operation selectors0x439/0x43A with the existing64/72-byte action framing. Their digest is the canonical configuration digest, with all bit patterns valid; there is no unknown-digest sentinel for these operations. Successful dispositions Prepared=4/Sealed=5 are operation-specific; every refusal uses Unconfirmed=0. Start and Retire retain their existing startup-digest semantics. REALM_CLIENT is the distinct0x449 process class and cannot enter ordinary launch/start/restart policy. Canonical record indices need not equal physical runtime row positions. Before serving, Posixd may move whole owned client rows while retaining each canonical client index, check public/native pair uniqueness by sorting, then use native-pair order for lookup. Each move retains all receiver custody. Descriptor references use canonical indices; result regions are assigned after the final order and before any delivery or I/O effect. No sorting is permitted during serving. This avoids new arena allocation and repeated quadratic validation in the I/O path. Configuration must still prove all uniqueness, binding and channel-coverage invariants before admission. No runtime acceptance is asserted by these codecs. Counted client configuration continuation — 24 September 2026: Proposed coordinated continuation: configure each private Posixd instance with two actual staged clients and mediator-owned bounded byte channels. Preserve the existing startup/control handshake and native identity checks. Configuration is canonical, counted and digest-bound; labels select already held owners and never confer authority. This is a first nonblocking byte-I/O slice. Full filesystem/TTY configuration, complete POSIX semantics, libc, all resource-retirement criteria, rebuilding Rust/LLVM inside EriX and both complete EriX guest builds remain required later work. Partition only the producer-supplied RW/NX arena into checked client/descriptor/channel rows, canonical-plan storage, explicit ring bytes, per-client retained results and one immediate packet workspace. The target layout must be authenticated and shared with the producer; no guessed host layout, global allocator or fixed deployment array may choose capacity. Pull the canonical configuration only after retiring Ready, retain every possible received endpoint before COLLECT, and register only validated RECV-only client ingress endpoints. The complete plan digest and real inventory must match before Prepared. Use two-stage seal. After the final pull, retire its caller and drop/query configuration SEND; then answer Prepared while ordinary I/O remains refused. Admit I/O only after authenticated CommitSeal. Route by retained receiver plus actual client process/generation, then owned descriptor binding. Fairly rotate control and client delivery owners; a pending result cannot block another client. Each delivery mutates queues at most once and retains its exact result through COMPLETE or acknowledged draining/relinquishment. Authenticated exact client-terminal control closes its bindings once and retires remaining receiver/delivery custody. Wrong origins, stale generations, surplus receipts and partial configuration fail closed. Authenticate target geometry through the existing selected-image path. Posixd exports one immutable 96-byte target-generated descriptor in read-only file-backed ELF load storage: magic16 `ERIXPXSCAPLAY001`, then ten little-endian u64 words for version1, total size96, ELF machine, pointer bits, and client/descriptor/channel row size/alignment pairs. Sizes are nonzero and alignments powers of two; target fields match the selected executable. Loaderd extracts exactly one complete descriptor from its already authenticated root ELF bytes, refusing missing, duplicate, malformed or writable records. No host-derived type size or reopened pathname supplies geometry. An exact 144-byte BindRealmLayout request uses the existing authenticated LoaderMaterialization route: request/op u32, original active transaction u64, root ELF SHA-25632 and descriptor96. Its response uses the existing 36-byte materialization shape with zero noncommit materialization/staged fields. Procd accepts it only from actual Loaderd for that original active mediator transaction, retains the description through staged commit/rollback, and requires it before mediator commit. The startup carries the descriptor SHA-256, which Posixd compares against its own compiled descriptor before any typed arena borrow. Canonical checked sizing partitions client rows, descriptor rows, channel rows, plan bytes, ring bytes, retained per-client results and immediate packet storage; every multiplication, alignment, address and page round must fit. This grants no additional endpoint or allocation authority. Ordinary endpoint transfer copies authority. Every source and possible receive destination remains owned across submission, collection and native retirement, including ambiguous results. Reserve each prospective receive slot before COLLECT; validate its normalized receipt and actual Generic kind/rights, then independently reconcile its disposal before reuse. Unique InstallGrant and RevocationGrant transfers keep MOVE semantics. Do not infer source deletion from successful copy or use deletion to manufacture successful unique-grant movement. Track this continuation with [Posixd realm lifecycle](https://git.erikinkinen.fi/erix/posixd/issues/1), [POSIX ABI](https://git.erikinkinen.fi/erix/lib-posixabi/issues/1) and [Phase 6 completion](https://git.erikinkinen.fi/erix/integration/issues/65). This is a proposed contract; no runtime or implementation acceptance is claimed. The maintained `appliance-disk-image-realm-startup-positive` scenario passes unchanged: both actual Posixd processes reach authenticated PrivateReady; A retires while B stays ready; B then retires; both stale handles are rejected; the initial shell exits successfully. The original required, unique, ordered and forbidden markers, expected guest exit `0x10`, 120-second guest hard limit and 45-second serial-progress limit all pass. This exercises counted minimum startup, actual capability census, setup-grant consumption and copied SEND disposal before Start, followed by native child registration, exact-origin readiness and the controller challenge. The packaged Posixd alias selects the same authenticated executable; no ordinary sidecar, extra child endpoint or fallback is introduced. Source-bound exercised gates are the evidence; no separate global inventory dump is claimed. Posixd's Ready caller remains its separately owned obligation until retirement. The successful explicit-retirement path does not exercise Launchd's spontaneous WAIT decoder, final CPU/profiler handoff, repeated row reuse, loss paths or capacity exhaustion. Launchd's six strict local configurations pass 329 library and 69 runtime tests each; all 48 required commands are warning-free. The corrected native-faithful 14-test group includes COPY source retention, post-Provision caller retirement, separate source disposal/absence verification and failure preservation. Original Launchd CI155/156 also passes: four complete logs, 148,673 bytes, zero warning/failure candidates. Original Integration CI1791/1792 remains queued; earlier failures and regression reports remain preserved. [The copied-SEND defect](https://git.erikinkinen.fi/erix/launchd/issues/7) and [its native startup regression](https://git.erikinkinen.fi/erix/integration/issues/89) are resolved at this scoped boundary. Relevant implementation reviews remain [Launchd PR2](https://git.erikinkinen.fi/erix/launchd/pulls/2), [Procd PR2](https://git.erikinkinen.fi/erix/procd/pulls/2), [Posixd PR5](https://git.erikinkinen.fi/erix/posixd/pulls/5) and [Integration PR12](https://git.erikinkinen.fi/erix/integration/pulls/12). Configuration/seal/publication, four real clients and mediated byte I/O, complete running retirement and profiler disposition, rebuilding the external Rust/LLVM toolchain inside EriX and both complete EriX guest builds remain required and unproved. The WIP reviews remain unfinished. Each of the four default/all-feature development/release selections passes 14 tests, with development/release native executable builds also accepted. Formatting, strict host/native Clippy, warning-denied builds, private rustdoc, Markdown and exact original dependency checks pass with zero warnings. Actual running mediator readiness/retirement, complete service-image acceptance, configuration/seal, client I/O and both required guest rebuilds remain open. Tracking: [owning issue](https://git.erikinkinen.fi/erix/posixd/issues/1), [WIP PR](https://git.erikinkinen.fi/erix/posixd/pulls/5) and [Phase 6 acceptance](https://git.erikinkinen.fi/erix/integration/issues/65). All four default/all-feature development/release selections pass 14 unit tests each. Formatting, strict host/native Clippy, doctests, private rustdoc, Markdown and original single-revision dependency checks pass. Warning-denied development/release freestanding ELF builds contain the entry and final RW/NX stack. Coordinated producer provisioning, operation 58 supervisor-lifetime-binding adoption, actual Posixd start and native readiness/retirement VM acceptance remain pending. These source and host/build results do not establish a running realm or a full guest build. <details> <summary>Detailed scope and contracts</summary> ### Validated mediator constructor adoption — 15 September 2026 A refusal never falls back to operation 32. Exact requests, omitted receipt/drop, materialization, refusal without fallback and unchanged ordinary behavior are covered. Runtime-image adoption, authenticated grant return, guarded bootstrap routes, private execution, receiver readiness, configuration/seal, client I/O, fair retirement and both full guest build generations remain open. ### Construction without child root capabilities — 15 September 2026 Native prerequisite implemented at Kernel `6d2ca19c48d3663db4b3a1eba4e9b7588b351f6f` with shared IPC `7c7712057cc5d16ab16a677a886caeac54814a16`. Kernel operation 54 admits only actual Process endpoint holders and constructs a Created child with exactly one primary endpoint and no root capabilities. The native TCB retains address-space backing independently. The caller receives a unique install grant, an endpoint master and only an explicitly requested MAP-only VSpace receipt. The checked request distinguishes absence from a genuine slot-zero receipt. Former-root slots are usable; actual caller windows, native capacity, occupancy and child window scope remain enforced. Rollback disposes only successful new receipts and the partial child while preserving pre-existing bindings. Ordinary operation 32 remains unchanged. Initial inventory is not a seal or a permanent ban on later explicit installation. Both isolated native VMs pass; no runnable mediator follows from this prerequisite. 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. Ordinary mediator start gates remain closed. Whole-codebase semantic authority and private-item documentation audits remain incomplete. ### 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. Procd uses the actual returned grant to attenuate the initial endpoint to RECV before execution, removes bypass sources, and retains nested custody beneath Kernel lifetime custody. A later mediator disposal report cannot prove absence of bypass senders. Native upstream Rust/LLVM rebuilding and both complete EriX builds remain required. Launchd uses its existing endpoint factory and retains the private configuration RECV/GRANT alias; the child receives only its existing control RECV and a guarded configuration SEND. Counted startup records and actual receipts must agree, with all temporary setup/grant disposal acknowledged before the separate private start gate. Readiness requires actual CLAIM caller identity plus an acknowledged challenge through the retained control endpoint. Child-read-only startup mappings do not revoke Procd's trusted memory-write authority, and ordinary writable LCS1 startup mappings cannot silently stand in for this new contract. The current staged-only retirement path must gain exact running-child cleanup. A surviving child-termination owner after Procd loss remains a prerequisite: SEND lifetime revocation alone does not destroy that child, and Rootd exits after bootstrap. Existing native guarded-preparation acceptance remains separate; full runtime lifecycle, configuration/seal, real client I/O, full frame proof, native upstream toolchain rebuilding and both full EriX build generations remain open. No whole acceptance item is added. An install grant alone must not confer child termination authority. </details> <details> <summary>Related records and contracts</summary> | Repository | Links | | --- | --- | | integration | [issue 1](https://git.erikinkinen.fi/erix/integration/issues/1) | | kernel | [issue 11](https://git.erikinkinen.fi/erix/kernel/issues/11), [issue 19](https://git.erikinkinen.fi/erix/kernel/issues/19) | | lib-capabi | [issue 3](https://git.erikinkinen.fi/erix/lib-capabi/issues/3) | | posixd | [issue 6](https://git.erikinkinen.fi/erix/posixd/issues/6), [client-disposal.md](https://git.erikinkinen.fi/erix/posixd/src/commit/3541ce5d621bfbf32e89df1882c3b15cb5ecd707/docs/client-disposal.md), [minimum-bootstrap.md](https://git.erikinkinen.fi/erix/posixd/src/commit/3e6292bd3e5c6a3e59dbae54124f8eea52141957/docs/minimum-bootstrap.md) | </details>
erikinkinen changed title from [FEATURE] [P06] Implement isolated compatibility realms and exact grant lifecycles to [FEATURE] Implement isolated compatibility realms and exact grant lifecycles 2026-09-12 08:02:03 +02:00
erikinkinen added this to the Alpha 1 milestone 2026-10-30 09:35:04 +01:00
Sign in to join this conversation.
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
erix/posixd#1
No description provided.