[FEATURE] Audit authority, code quality and documentation in launchd #1
Labels
No labels
alpha-1
bug
ci
docs
duplicate
enhancement
help wanted
invalid
performance
phase-6
question
refactor
security
wontfix
No project
No assignees
1 participant
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
erix/launchd#1
Loading…
Reference in a new issue
No description provided.
Delete branch "%!s()"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Problem and motivation
Audit
launchdthroughout Phase 6. Mediate native launch transactions, authenticated capability receipts, running-job loans and cleanup using caller-supplied state arenas.Review each changed boundary at the final published revision. Prioritize security, reliability, then performance.
Proposed behavior and scope
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
99b2fc19counts and emits the same allocation-free frozen-plan record selection and requires cursor exhaustion before committing the original startup hash. procd5586e0f5admits 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. posixd7e4450c2adopts 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
eea18ab3updates 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
88eb2573authenticates 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
cf566ff1documents 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
892f8fc0adds 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
908209cfupdates 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
5b43c817updates 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
12b11facaligns the immutable IPC dependency; docs7e9491caupdates 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
0caeb423authenticates 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
76882bd3aligns the immutable IPC dependency; docsc146117fupdates 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
37ddc4adupdates 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, vfsd8f34a3e2and launchd79bcc9d4add 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
b00c8732and lib-time49b5e713align immutable dependencies; docs1c13c2e8updates 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 dependency17b8346cand manuala9906120publish 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
442a805cremoves 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.
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.
Final mediator CPU custody design — proposed, not yet implemented or accepted:
Use two capability-free owned operations on the existing private Launchd–Procd route:
READ_REALM_FINAL_ACCOUNTING(0x437) andACK_REALM_FINAL_ACCOUNTING(0x438). Selector0x436belongs to the separately proposed Provision successor. No additional endpoint, identity query, capability transfer or authority is introduced.All fields are little-endian, with exact framing:
Every request correlation and identity word is nonzero; only the two assigned operations are admitted in their corresponding message types. Dispositions are
Unconfirmed=0,Measured=1, andNeverExecuted=2. Successful responses and ACK requests require Measured or NeverExecuted and a complete nonzero supervisor pair; NeverExecuted requires both counters zero. Measured permits zero counters: only an actual terminal measurement establishes this disposition. Failure responses preserve the valid request/op/child/realm selector, require Unconfirmed, and zero the supervisor pair and counters. They never invent caller identity. No all-zero digest sentinel is introduced: accounting binds the original native child, original realm and actual caller, and does not restate startup authentication.READ obtains the supervisor identity from actual native CLAIM, which Procd checks against the retained original supervisor. This also works before ContextProbe has supplied Launchd's descriptive identity. A successful READ returns that authenticated pair. Launchd additionally compares it to its retained bootstrap context when one exists. ACK must match actual CLAIM and every retained snapshot field. Parsing bytes proves no native effect or authority. Codecs reject short, surplus, malformed, reserved or mismatched fields; encoding preflights the complete value and output length before any write.
Lost-provision-reply retirement refinement — 24 September 2026 (implementation pending): RETIRE alone permits an all-zero startup digest to explicitly describe an unknown startup after a lost or malformed Provision response. The actual original Launchd caller, complete original child/generation and retained realm binding remain mandatory; the zero sentinel omits only digest correlation and never selects a replacement or confers authority. A supplied nonzero digest must still match exactly. START never permits this sentinel. Known pre-provision staged custody keeps its existing authenticated staged-abort route. Final retirement acknowledgment still requires actual exact-instance disposal and all locally owned transport/authority obligations, rather than native absence alone.
Private start admission refinement — 24 September 2026 (implementation pending): add Launchd START_REALM operation
0x6D4with an exact 40-byte authority-free request: request/op at offsets 0/4, original realm/generation at 8/16, and explicit request/result byte budgets at 24/32. The actual pending native caller must still own that retained realm. Validate packet arithmetic and both minimum 96-byte budgets before effects. Preserve all existing BEGIN/PREPARE/READ/ABORT selectors and the ordinary process-start gate.Extend descriptive realm state with Starting (6) and PrivateReady (7), retaining values 0–5. Reuse the existing 40-byte admission response; a successful START acknowledgment requires PrivateReady. The service retains the original response obligation while its immediate private caller and configuration-server owners progress. READ may describe Starting; a lost public response or cancellation retains exact cleanup. PrivateReady proves the observed native-child Ready and confirmed independent controller challenge plus retirement of Launchd-owned transport handles. It does not claim that server COMPLETE observes Posixd's later caller RELEASE, nor does it seal, publish or grant client access.
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 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 class0x448(REALM_MEDIATOR); role values describe lifecycle policy and confer no capability authority. Launchd explicitly selects this operation after authenticating its executable object. The ordinary operation0x652keeps 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.
Current inventory: 2 Cargo targets (1 bin, 1 lib); manifests:
Cargo.toml. Include explicit and automatically discovered targets, supported features and target-specific configurations.Inventory every startup/runtime grant and authenticated peer, then success, denial, cancellation, failed transfer, restart and teardown. Trace callers and downstream providers so names, numeric identities and retained aliases never become implicit authority.
Authority, security and reliability
The final READ does not consume a row. Running terminal observation retains its existing measured user/system counters, original supervisor and exact child/realm after native destruction and capability cleanup. Explicit RETIRE retains its separate exact terminal-event disposition. Ordinary QUERY_PROCESS_TIMES must become non-consuming for mediator rows so it cannot bypass the new ACK; ordinary-process behavior is a separate tracked concern.
NeverExecuted must be an explicit retained outcome of successful exact AbortStaged before any native START attempt. A private Provision or Retire that owns rollback binds its realm correlation and engages this scalar obligation before its first possible cleanup effect. Preserve an active scalar-only row after its successful unstarted abort, using an explicit disposed-unstarted state rather than fabricating a terminal event, EXITED state or CPU measurement. Bind an otherwise unbound realm only from that authenticated exact owner's Retire request. The ordinary guarded PREPARE/ABORT path, which never enters running-bootstrap ownership, keeps its existing disposition. An uncertain START can never become NeverExecuted. An absent row or kernel NOT_FOUND is not an accounting outcome.
The managed-row allocator and exact cleanup predicate must recognize both measured-terminal and proved-unstarted dispositions, require empty native/capability custody, no pending scalar obligation and no retained original invocation reservation, and preserve every other existing gate. Repeated cleanup of an already disposed scalar row must not issue AbortStaged or native destruction again. Original supervisor death disables the accounting obligation before its cleanup loop, so successful unstarted cleanup cannot recreate a pending consumer after that death.
Launchd retains one final snapshot in the original RetainedRealmStart. Its retirement phases become: exact child/local/caller/event cleanup, READ and retirement of that original caller, atomic local profiler commit, ACK and retirement of that original caller, fully Retired. Independent local and serving cleanup continues during these phases. Malformed results, uncertainty and unknown owners retain the original record and cannot report successful ABORT or permit release_retired.
Use a production scalar sink in RealmTable, initialized with its pristine storage and lasting for the current Launchd generation. Keep separate measured-retirement and never-executed counts plus checked cumulative mediator user/system nanoseconds, separate from POSIX self/waited-child/job totals. Preflight every aggregate addition, then commit all totals and the original owner's recorded flag together without fallible I/O between them. Arithmetic refusal retains the unchanged totals and the owned snapshot; repeated progress never charges twice. The bounded aggregate does not retain an unbounded history; the original exact snapshot remains in its realm record until ACK and retirement. A Rust-only read accessor supports the existing diagnostic output route; no public cross-client metrics endpoint is added.
ACK carries that already committed snapshot. Procd reserves its exact row, checks its immutable pending snapshot and original native caller, encodes the correlated reply, and clears cpu_time_observation_pending only after canonical native COMPLETE success, before releasing that same reservation. Failed or noncanonical COMPLETE leaves the obligation pending; no incoming accounting request can trigger cleanup of an unrelated or unvalidated child. Native COMPLETE is not caller RELEASE. It copies the result into the original invocation's owned result storage, independently of the managed row. Launchd already owns the snapshot before sending ACK, and retains the original ACK invocation through COLLECT and acknowledged RELEASE. Thus managed-row reuse after successful ACK COMPLETE cannot erase the original result or local accounting evidence. Launchd's realm record still cannot be reused until its own ACK caller and all other owners retire. Route failure may prevent successful retirement, but cannot justify replay, inferred acknowledgement or a second charge.
Client death still follows this accounting path while Launchd lives. Exact Launchd-generation death discharges only its own remaining scalar obligation, as the existing process-lifetime sink ends with that generation. No durable cross-restart profiling history or inherited supervisor authority is claimed.
Record each finding's affected revision, invariant, reproduction, owner, regression coverage and resolution. Report suspected vulnerabilities through SECURITY.md and keep sensitive details private. Record a result and rationale for each audit criterion, including caller responsibilities when this component has no process or Rust target.
Acceptance criteria
Checklist
Independent literal codec fixtures, all offsets, exact sizes, malformed/surplus/zero identities, unknown operations/dispositions, reserved words, canonical failure zeroing, cross-child/realm/supervisor/operation correlation and unchanged output on failed encoding.
Non-consuming READ and ordinary mediator CPU query; real terminal consumer plus real managed allocator retains the row until exact ACK commit. Failed ACK COMPLETE, draining owner, malformed success and nonzero error owners preserve evidence and reservations.
Wrong actual CLAIM, stale original generations, changed disposition/counters and a replacement row cannot consume the original or replacement snapshot. Repeated reads remain identical. Measured zero is distinct from proved NeverExecuted.
Successful original staged abort preserves NeverExecuted only where final accounting is engaged; pre-Provision failure, lost Provision result and cancellation retain the original proof. Unknown native START never becomes unstarted. No duplicate native cleanup or invented terminal event occurs.
Launchd charges its separate production sink once, before ACK; overflow leaves both aggregate and pending snapshot unchanged. Malformed READ never charges. Lost READ/ACK/public-ABORT replies, client loss and repeated cancellation keep original owners. Exact supervisor loss does not resurrect pending accounting or alter another generation.
Native owned-result control: commit the exact ACK, reuse the Procd managed slot for another generation before the caller collects, then collect the original ACK bytes and retire that original invocation. The replacement stays unchanged; stale requests reject. Failed COMPLETE must prevent this reuse. Use the real retained result implementation, not a fixture that assumes its behavior.
Explicit RETIRE and spontaneous terminal observation converge; already consumed and unrelated queued terminal events keep their existing ownership, ordering and counter evidence.
Extend a maintained actual-service witness with an explicit capacity-derived number of create/start/retire cycles greater than the initially available mediator rows, while one other realm stays live. Verify full generations, stable reusable capacity, exactly-once final profiler contributions, nonzero measured CPU for an executed workload, final retirement and stale refusals. Read the actual production totals through an already supplied diagnostic output route; add no cross-client query authority. Preserve the original guest limits and required markers; report capacity/deadline constraints rather than hiding a leak by raising them.
Publish shared ABI first; use original coherent dependency pins, full supported strict host/native matrices, missing_docs/private rustdoc and thematic files under 1,000 lines. Update component architecture/roadmap and technical manual, then preserve complete original CI and native evidence. Existing two-mediator startup acceptance remains separate from final accounting acceptance.
Record origin, recipient, object, operations, delegation ceiling, lifetime and aliases for each relevant capability or caller-supplied authority-bearing value.
Audit ambient discovery/selectors, cwd/PATH/environment, numeric identities, inherited routes and host fallbacks; require explicit authorized intake.
Account for residual authority after success, error, cancellation, timeout, restart, failed transfer and teardown, including fork/exec where implemented.
Remove unnecessary endpoints, broad rights, duplicate aliases, provider/admin grants and debug routes.
Exercise stale generations, replay, pending replies, forged descriptive identity and object/path resolution races at the owned boundary.
Prove independent cleanup attempts and caller-specific error precedence; quarantine or terminate when retained authority cannot be accounted for.
Review unsafe/FFI/parser/arithmetic/lifetime/lock/publication invariants and add adversarial coverage where practical.
Inventory obsolete APIs, wrappers, fallback/dead paths and duplicate validators with their maintained callers.
Migrate callers and delete deprecated contracts/shims in a coherent signed revision graph; reject retired input versions where relevant.
Classify each size/count/depth/time bound as ABI, hardware, explicit resource policy or accidental limitation.
Test beyond removed boundaries and at allocation/ABI limits while preserving exhaustion errors, denial-of-service controls and bounded waits.
Keep every tracked authored code/test/script/workflow file below 1000 physical lines through thematic refactoring.
Run the deterministic tracked-source size gate, covering executable fixtures/generators and excluding only genuine non-code data or external payloads.
Audit production/test feature and symbol separation, including this repository's effect on rootd test orchestration.
Supply changes affecting rootd semantic surface to the maintained same-toolchain baseline; record a justified component-specific applicability result.
Check bootstrap ownership and development/release authority parity at this repository's producer/consumer boundary.
Use maintained integration#3 profiler evidence before optimizing; preserve live access checks, ownership and success criteria.
Audit build/CI inputs, secret handling, private outputs, symlink containment, deletion, subprocess bounds, warnings and host dependencies.
meaningful public/private inline documentation, crate/target
missing_docsenforcement without blanket allowances or hidden-API escapes, warning-denied private-item rustdoc and an undocumented-public-API negative gate.Validation: Run
cargo fmt --all -- --check, strict Clippy, unit/doctests and warning-denied builds/rustdoc for every owned crate/target under default and all valid feature, freestanding/host, SMP and profile combinations; test mutually exclusive combinations separately. Add focused VM regressions for runtime behavior and observe the older catalog and unit tests at the exact published heads.Documentation: update applicable README/ARCHITECTURE/ROADMAP in meta's canonical format and affected technical-manual TeX/API references; keep README evergreen and shared governance byte-identical to meta.
Evidence: record exact source/dependency revisions, commands, configurations, real exit status, CI run URLs and results; repeat the audit on final heads and obtain independent review of security closures. No skipped/pending/predecessor result counts as a pass.
Alternatives and tradeoffs
Refactor within the component unless shared semantics justify extracting common code. Preserve regression coverage before deleting superseded paths. Profile before optimizing, and document ABI limits, hardware limits and explicit quotas. Preserve security and reliability requirements.
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.
Select mediator preparation through the transfer-aware loader client and reject substituted operations or incorrect live grant receipts. 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.
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.
It requires exact correlated acknowledgment and independent source absence before any disposal; deleting a residual source cannot create success evidence. Matching consumer VM execution, runnable mediator bootstrap, fair retirement and both complete builds inside EriX remain separate open acceptance requirements.
No grant is constructed, copied, attenuated or retargeted. Malformed register shape rejects before context lookup; caller/window checks precede source lookup, then type/binding checks precede empty-destination admission. Ordinary validation refusal leaves inventory unchanged. Literal register, foreign/terminal caller, missing/fake binding, occupied destination, exact-rights/scope and actual CPL3 controls are required, followed by coordinated producer/consumer adoption and the remaining realm VM gates.
Owned receiver request-budget contract — 18 September 2026: Extend register-only REGISTER (0x4C) to take the actual local RECV slot, maximum request payload bytes and maximum request capability count in arguments 0–2; arguments 3–5 remain zero and successful RDX is zero. The byte/slot/receipt receive layout must be addressable and capability capacity must fit native private CSpace storage. The actual Running generation and held generic RECV endpoint remain the registration authority. SUBMIT compares actual payload length and capability count against that exact registration before request allocation, private-space reservation, native transfer or invocation serial acceptance. These budgets describe service-owned receiving storage; they add no global CALL-size ceiling, user-pointer retention, foreign selector or capability grant. Literal malformed/zero/exact registration controls, rejected-inventory checks, actual CPL3 calls and existing VM oracles are required. Actual consumer VMs, complete fair realm progress and both full guest builds remain open acceptance requirements.
Existing launch-description staging may be reused only with explicit exclusive ownership and proved completion of its former cleanup; add no broad Process authority or per-realm scratch column. Numeric identity or receipt metadata never replaces actual possession or scope validation.
The running service loop must give native retirement a turn before owned bootstrap and ordinary intake. Complete every independent local and child retirement action before relinquishing bookkeeping; uncertain cleanup cannot return a service to ordinary work.
Success requires a canonical correlated result, actual source-grant absence and complete invocation retirement. Preserve ordinary start refusal until realm configuration, readiness and sealing are complete.
Acceptance requires adversarial ownership/cancellation/partial-cleanup host controls, strict coordinated builds and real producer/consumer VM execution.
Both are nonzero only for the realm mediator role; both must be zero for every other role. Reject the obsolete 56-byte shape.
The pair describes delegated lifecycle responsibility; numbers alone never confer creation, installation or rollback authority. Guard admission must match the original supervisor, never replace it with a later claimant.
Caller RELEASE initiates cancellation and must precede any ordinary abort request that could wait behind Procd delivery retirement.
Actual Launchd runtime preparation and scheduler adoption, deployment-sized ownership storage, adversarial host controls and real producer/consumer VM execution remain required.
Require canonical cap-free collection, actual source absence and full invocation retirement. Actual caller-bound runtime admission, deployment-sized owner storage, scheduler integration and real consumer VM execution remain open; this binding alone does not establish runnable realm acceptance.
Original retained caller CI acceptance — 18 September 2026: Signed Launchd
a084e1167221bacc5dd1b60fec2ae4f05fa39c12passes CI 135 and CI 136. Actual runtime admission, scheduler adoption and coordinated consumer VM proof remain required; no complete realm or guest-build acceptance is claimed.Client numeric identities or a bearer sender cannot select ownership.
The request carries exactly one actual SEND-only directory endpoint to
the reserved receipt slot. Verify the original caller/job/session/authority realm
again and retire every unretained received capability on refusal. Never imply a Posixd pathname,
Named route, root, cwd, TTY stream, ordinary job or public PreparedProcess input.
They require the same original
Running native owner. READ observes retained state only; ABORT must complete
independent source, invocation and exact-child retirement before its successful
acknowledgment.
Success at BEGIN
requires Reserved, a nonzero complete handle and receipt slot. PREPARE success
requires Guarded; ABORT success requires Retired. READ returns an authenticated
nonzero state.
Require an
explicit deployment value: zero disables new realm reservations, and nonzero
values allocate that many retained records and disjoint receipt slots. Coordinate shared startup codecs, Rootd payloads, Launchd arena and
Integration policy/packaging; old version/width must reject.
Actual scheduler progress must exclude ordinary and indirect blocking
peer calls while any native invocation needs progress. A permanently discharged
source slot is never revisited after reuse. Guarded staging remains private
and unstarted, without exported SEND or a Running job.
Coordinated host negatives, strict source-bound build matrices and real consumer
VM execution are required. Two mediator processes, two clients per realm with
actual mediated I/O, complete fair progress, source/effect/frame admission and
both full builds inside EriX remain separate open acceptance requirements.
Generation never wraps. Independent scope deletion and absence proof retain full signed first errors, and stale cleanup cannot touch a reused slot. Actual public dispatch, VFS/Loaderd preparation, native progress scheduling, Rootd/Integration startup adoption and consumer VM proof remain required; storage semantics do not establish a runnable realm.
Public dispatcher, held replies, global scheduling, coordinated startup consumers and source-bound native VM acceptance remain required; host transport controls do not establish a runnable mediator or guest build.
Original exact preparation CI acceptance — 18 September 2026: Signed Launchd
5c58f9e702be3e130b7040be2a042b1a41a5aea8passes CI 139 and CI 140. Actual runtime admission, scheduler adoption and coordinated consumer VM proof remain required; no complete realm or guest-build acceptance is claimed.Public BEGIN, PREPARE, ABORT and READ now dispatch canonical frames and actual receipts through original native caller proof. Creation/abort reply loss requests cleanup; read or refused-request loss preserves earlier realm ownership. Coordinated startup/image consumers and actual consumer VMs remain required, as do configuration, readiness, seal, mediated I/O and both complete builds inside EriX.
Original public realm dispatch CI acceptance — 18 September 2026: Signed Launchd
5837873167c5e6ed99045af7052004affb5c28ffpasses CI 141 and CI 142. Actual runtime consumer adoption and coordinated consumer VM proof remain required; no complete realm or guest-build acceptance is claimed.Coherent startup consumer acceptance — 18 September 2026: Signed Integration
8b1c037aed2503e1f2a4b17c8a8be0666d62a305adopts exact 72-byte LCH1 version 3, explicit realm capacity and version-6 compiler-derived arena geometry across runtime profiles, wire/configuration boundaries and image packaging. Full source/effect/frame admission, complete realm operation and both full builds inside EriX remain required.Tracking and rollout
Counted pipes and original-controller default SIGPIPE are implemented and signed/published: lib-ipc
fdbe4e08, lib-posixabi980a332e, posixd645be685, launchddfcb4d7d, procdf198cbf5, exsh165f2613, integrationc51e2f93, docs47a75253. The separate Integration helper60a44c20precedes final catalogs. The coherent closure contains 56 signed commits across 55 repositories, 206 Cargo selectors and 111 catalog selectors, with exact remote branch equality.RCF1/RCP1 version1.5 admits explicit unused rings of at least512 bytes, including pool-only plans without inherited descriptors. Compatibility1.11 adds Pipe opcode21 and matching Rust/C constants. Two lowest-free fd numbers, independent descriptions and one generation-bound counted ring remain unpublished until accepted native COMPLETE. Refusal cancels both ends; native invocation custody remains independently retained. FIFO scalar/vector writes of at most512 bytes are atomic, larger writes may be short, and blocking calls retain the original description and required free-space condition. Final aliases drive EOF/EPIPE; both-end retirement scrubs the whole ring before reuse. Unrelated closure cannot satisfy a wait.
Ignored, blocked and caught SIGPIPE preserve their distinct EPIPE/pending/handoff behavior. Default unblocked SIGPIPE freezes the original client. Posixd authenticates the original controller CLAIM and complete native context/digest before a one-shot policy decision. Procd polls through its existing mediator SEND, reserves both original rows through actual caller retirement, revalidates the original live relationship and issues at most one generation-checked kill. Native terminal observation, accounting, destruction and notification remain independently owned. A retiring original client discharges a drained poll without another kill; uncertain native custody stays fail-stop. Posixd receives no process-control capability, outbound route, ambient discovery or hidden capacity.
Ordinary byte/binding native clients exercise successful pipes, atomic writes, wraparound, alias closure, reuse and nondefault SIGPIPE. The separate realm-pipes scenario selects realm-pipe-client and requires real Killed(SIGPIPE), retained through retirement and reuse; an EPIPE return or normal exit fails that diagnostic. Explicit1024-byte packets and H=4/Q=1038 pool geometry are configured, with872-byte or3432-byte plan arenas. Existing native authority, lender and120-second deadline gates remain. Unit, transcript, selector and packaging controls are authored and unrun. The Exsh transcript ordering defect is repaired and published.
The pipe feature is accepted under that waiver. Event-driven poll/select, complete libc wrappers, asynchronous handlers and other native signal defaults remain separate work. Both full EriX guest-build generations and rebuilding external Rust/LLVM inside EriX remain required and unperformed.
Current progress is 17.84% weighted and 6.41% whole acceptance: 24/460 parents and 454/914 sub-items under 161 decomposed parents. One complete pipe parent and its seven explicit sub-items are accepted; original parent weights are unchanged.
Pipe contract, descriptor/namespace work, Phase6 master. Reviews: lib-ipc, lib-posixabi, posixd, launchd, procd, exsh, integration, docs.
Exact Launchd 2-realm/4-client/576-byte, Procd 38-record and Pagerd 102-binding budgets require reclamation. All six actual successful client exits, realm/client/plan refusals and original capability routes remain intact.
The client VM and older preparation/startup VMs pass every original marker, exit and 120/45-second gate. Retained client evidence binds 109 artifacts, 57,045 serial bytes, empty QEMU stderr and zero warnings. This accepts the native disposal/reuse sub-item. Separate positive NeverExecuted CPU accounting remains required: the first capture was rejected before boot because the host GDB package changed; after RPM identity/API verification and fresh two-positive/twenty-negative verifier controls, a separate capture reached the original 120-second limit after five Measured commits, before either NeverExecuted snapshot. Its failed result and cleanup are retained. No deadline, guest byte, authority or oracle was weakened; no numeric completion or speedup is claimed.
All fourteen Exsh development/release selections pass 988 tests each, strict host/native builds, Clippy, rustdoc and 355 checker controls pass without warnings, while native frame proof issue 4 stays open. Docs CI1099/1100 passes 45 document controls and the complete 2,657-page manual with zero final warnings. Integration passes its 187 host commands. Original CI1824 passes all 492 scenarios and subsequent image/input gates. CI1823 instead stops in the known physical utility host fixture, before catalog VMs. The companion pass does not resolve that intermittent failure.
All 22 original Integration runs 1803–1824 now have complete reviewed logs: 66 logs, 264,989,379 bytes, zero warning candidates. The smoke-policy defect is closed on its source correction and matching full-CI evidence. Remaining observations are retained under pipeline, ext4 quota, physical consent, interrupt reuse, canonical release, and the new canonical-template reports for release COM1 editor and canonical development. Their causes are not inferred from wrapper failures, and no unchanged CI job was rerun.
The phase checklist now records 419/879 completed sub-items, 17/460 accepted parents, and 15.45% weighted progress. Numerical NeverExecuted accounting, remaining authority/lifecycle cleanup, complete CI/frame acceptance, external Rust/LLVM/toolchain rebuilding and both complete EriX builds inside EriX remain required and unproved.
Valid counts independently exhaust each free pool, require exact RESOURCE_EXHAUSTED and unchanged Guarded/Sealed peers, then allow normal configuration.
The client VM and older preparation/startup VMs pass with every original marker, native exit and 120/45-second gate. Retained client evidence contains 109 artifacts and 57,045 serial bytes, with empty QEMU stderr and zero image warnings. Independent BootConfig decoding verifies 2 realm records, 4 client records and 576 plan bytes; packaged Procd/Pagerd layouts retain 38 records and 102 bindings. Requests add no capability or guest inspection route.
The phase checklist now has 417/877 completed sub-items, 17/460 accepted parents and 15.43% weighted progress after exact recalculation. This accepts the two configuration-storage ceilings. Existing compiler/frame gates, supervisor loss, partial cleanup, NeverExecuted accounting, complete CI review, external Rust/LLVM/toolchain rebuilding and both full EriX builds inside EriX remain required. All earlier failures are retained, and no unchanged CI job was rerun.
Original CI1799 and CI1800 are fully reviewed: 372/492 and 371/492 scenarios pass, with six complete logs and zero warning candidates. Both retain 119 obsolete policy refusals and the known configuration-carrier stall on their older graph. The pipeline descriptor scenario passes in 1799 and fails in 1800 on the same source graph, reproducing open Integration issue 91. Its cause remains unproved; a companion pass does not resolve it.
Native full-table realm refusal accepted — 25 September 2026: signed Integration bdd04a62 runs the new Exsh bc5cc8ac probe. The added requests transfer no capability and use the original authenticated Launchd route.
All original client markers, native exit and 120/45-second limits pass. The 109 retained artifacts include 57,045 serial bytes and empty QEMU stderr, with zero image warnings. Independent BootConfig decoding follows the actual Launchd filesystem role to its 2-realm/4-client/576-plan-byte policy; packaged Procd and Pagerd layouts retain 38 records and 102 bindings. The original preparation-only and startup VMs also pass, with 108 retained artifacts each, 56,131/56,165 serial bytes and zero warnings. No guest inspection endpoint, grant or deadline change is introduced.
All 187 Integration host commands, seven 987-test Exsh development selections, fourteen strict host/native build/Clippy/rustdoc configurations and 355 checker controls pass. Docs CI1091/1092 passes the complete manual and 45 tests without final warnings. Exsh CI283/284 passes 987 unit tests and 355 checker controls, then fails the existing native frame proof: runtime 256 reached/101 unresolved and all-feature 286/68 in both profiles. All four complete logs contain zero warning candidates. Seven local release unit compilations and the native frame gaps remain open under compiler issue 9 and frame issue 4.
Documentation status is signed and pushed as Exsh 232e6849, Docs e2131e57, Integration c5958f12. Only ROADMAP changes in those follow-ups; code, catalog, helper and manual inputs retain their original validation identity. The phase tracker now records 416/876 completed sub-items, 17/460 whole parents, and 15.43% weighted progress after recalculation. This accepts the realm-record ceiling only. Client/plan exhaustion, supervisor loss, partial cleanup, NeverExecuted accounting, complete original CI review, external toolchain rebuilding and both full EriX builds inside EriX remain required.
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.
Signed configuration carrier correction — 25 September 2026: Launchd 372ab70e retains exactly RECV | GRANT only for counted-client result delivery. Readiness-only RECV, mediator SEND-only routes, RECV-only client copies, original authentication and complete setup disposal before seal/retirement remain required.
Docs 6a1a9686 documents the carrier/source distinction and its temporary setup lifetime. All 45 document tests, Markdown, template, link and unchanged-reference checks pass. The complete 2,655-page manual builds without final warnings, all 491,315 word bounds pass and three affected/adjacent pages are visually reviewed. Original CI1085/1086 is under observation.
Integration 7a42fa26 selects the two signed image sources. Both catalog policies, all 76 original signatures and complete dynamic closure pass. Helper, Rust, profiler and CI inputs remain byte-identical to their recorded validation; fresh formatting, source policy and Markdown pass. The corrected client VM is running from a fresh source-bound runner, followed by the older preparation/startup regressions. Original CI1801/1802 is queued. Launchd issue 10 and Integration issue 92 remain open pending native closure. Earlier failures and host counter evidence are preserved. No deadline or authority gate was relaxed, and these repairs add no canonical checklist credit.
The configured-client VM stalls after the same three inherited markers and a private process exit with status 5. Its original failure retains 109 artifacts and 56,130 serial bytes, zero image-warning candidates and no process-owner cleanup failure. Integration issue 92 preserves that observation. An admitted host TCG counter run against the identical guest disk reproduces the stall under the original 120/45-second bounds. Its complete capture contains 100,639 translations and 74,009 code groups. The top 100 groups cover 85.32% of the 65,912,963,324 translated-instruction upper bound; uniquely matching Kernel mapping-batch code accounts for 38.67% of that total. This is a performance investigation candidate, without a measured speedup, timing attribution or accepted native result. Shared code, addresses and process identity remain separate evidence questions.
Exact retained executable-region comparison with original symbol-bearing artifacts narrows the failure to Posixd configuration progress and its native exit; the exit block uniquely matches Posixd across all 68 packaged executables/shared objects. The source mismatch is confirmed independently: Launchd retains only RECV on its configuration receiver, while native COMPLETE requires carrier GRANT for capability-bearing client replies. Enforcing that actual gate in the maintained complete-record pull fixture fails the original implementation. Launchd issue 10 tracks the correction and original red control. The local correction retains exactly RECV | GRANT only for counted-client replies, preserves readiness-only RECV, mediator SEND-only routes and RECV-only client copies, and retains complete receiver disposal before seal/cancellation. Full component validation is running; corrected native client execution remains required.
Both original Docs CI1083/1084 pass, with 45 document tests and the 2,653-page manual. All four complete logs total 824,211 bytes; normal early-pass references converge to zero final warnings. Original Integration runs remain running or queued, without unchanged reruns. No canonical checklist credit is added: configured native clients, managed-row reuse, complete authority/frame closure, profiling improvements and both full guest-build requirements remain open.
Client and mediator lifetime totals share one checked implementation in separate sinks; no public inspection authority or wire change is added.
Procd's explicit mediator Retire consumes that exact queued terminal event. Launchd neither demands a duplicate WAIT nor invents one from CPU or an action result. A spontaneous authenticated WAIT retains its original identity, kind and full status before joining retirement. Known Start/Ready or terminal evidence contradicts NeverExecuted; only positive native pre-start disposal establishes it.
The new regression fails on the preceding production source because retirement issued neither final Read nor ACK. The corrected component passes all 44 final checks: 335 library plus 161 runtime tests, 496 in each of six maintained configurations, strict host/native Clippy, private rustdoc, formatting, Markdown, dependency checks and warning-denied native builds. All six ELF files pass entry/permissions and complete version-7 layout checks (2,640-byte realm and 2,184-byte client rows). Nine added controls cover exact identities, recording before ACK, full-width refusal, altered ACK, native loss/unknown custody, overflow, spontaneous/duplicate events, public reply loss and local reuse. Eight older completed-retirement operation sequences now require final Read/ACK. Original CI177 and CI178 pass; all four complete logs are independently verified (179,140 bytes, zero warnings). No unchanged workflow was rerun.
README, ARCHITECTURE, ROADMAP and the mediator accounting contract are updated. Existing technical manual contracts already require these ownership and recording guarantees. The fresh structural audit covers 76 repositories, 3,189 authored code files below 1,000 lines, 264 full Git pins and 98 original crate documentation gates. This does not establish whole-fleet semantic authority acceptance.
Completion is 15.41% weighted checklist progress, 412/873 sub-items and 17/460 whole items. Launchd PR2 remains unfinished. Procd issue 5 stays open until a coherent native witness proves repeated managed-row reuse and Integration profiler observation. The full configure/seal/four-client I/O/failure/isolation witness, the complete EriX build inside EriX and external Rust/LLVM/toolchain rebuild inside EriX remain required. Original Integration CI1791/1792 remains green on its older source graph; that does not validate this new component graph.
Final snapshots now require that supervisor; startup still validates the controller. Negative controls reject both controller substitution and stale supervisor generations without recording or ACK.
All 44 final checks pass: 487 tests in each of six maintained configurations, strict host/native Clippy, private rustdoc, formatting, Markdown, dependency checks and warning-denied native builds. All six ELF files pass entry/permissions and complete version-7 layout inspection, including the retained supervisor pair (2,544-byte realm and 2,184-byte client rows). The fresh structural fleet audit again checks 76 repositories, 3,186 code files below 1,000 lines, 264 full pins and 98 original crate documentation gates. These are scoped component and structural results. Original CI175 and CI176 pass for the correction. All four complete logs are independently verified (176,394 bytes, 487 tests per Rust job and zero warnings); no unchanged workflow was rerun. This accepts the corrected client-execution component and resolves issue 9 using changed production source and producer-consistent red/green controls. Completion is 15.41%, 411/872 sub-items and 17/460 whole items, with all original section weights preserved. Mediator accounting, Integration profiler observation, coherent native four-client I/O/failure/reuse and both complete guest builds remain open.
Authenticated Procd WAIT now preserves its role through private dispatch before ordinary job lookup. Unknown private identities and role substitutions fail closed. Full original Exited/Killed kind and status survive individual retirement. Private disposal, actual WAIT and immutable final Read remain independent; an action or CPU counter cannot invent an event. Positive NeverExecuted comes only from Procd's actual pre-start disposal evidence, never local Start failure or absence. That revision incorrectly checked final snapshots against the Procd controller; the correction above requires the original Launchd supervisor. The original fixture duplicated the mistake.
Before ACK, a bounded Launchd-lifetime sink atomically records checked private-client counts and user/system CPU nanoseconds once. Overflow keeps the original snapshot unacknowledged; lost ACK cannot charge twice. Totals survive realm reuse, remain separate from POSIX/ordinary job accounting and add no inspection route. Unknown native custody and cleanup failure stay quarantined while known peers retire. Idle clients awaiting only WAIT and already retired mediators now yield: two focused controls exposed 16/16 spurious busy turns before the fix and require 0/16 afterward. This is a deterministic scheduler control, not a guest timing claim.
All 44 final checks pass: 335 library plus 152 runtime tests, 487 in each of six maintained feature/profile selections; strict host/native Clippy, private rustdoc, formatting, Markdown, dependency checks and warning-denied native builds. All six native executables pass RX-entry, no-W+X-page and complete RO/NX version-7 layout inspection. Fifteen added controls cover admission, substituted/refused/lost Start, unknown owners, full-width outcomes, both event/accounting orders, every public loss boundary, supervisor loss, once-only recording before ACK, ACK loss, overflow and idle progress. README, ARCHITECTURE, ROADMAP and the execution contract are updated. Existing technical manual contracts already require these ordering and outcome guarantees.
The fresh structural audit covers 76 repositories, 3,186 authored code files below 1,000 lines, 264 full Git pins and 98 original crate roots with missing-docs gates; it is not whole-fleet semantic authority acceptance. Original CI173/174 passed all of their original tests, with four complete logs reviewed (176,408 bytes and zero warnings). Their shared fixture mistake means that source does not establish execution acceptance. At that checkpoint: completion remains 15.41%, 410/871 sub-items and 17/460 whole items. Launchd PR2 remains unfinished. Mediator final accounting (Procd issue 5), Integration profiler observation, the coherent native configure/seal/four-client I/O and failure/reuse witness, the complete EriX build inside EriX and external Rust/LLVM/toolchain rebuild inside EriX all remain required.
Every original client RECV and configuration setup column then needs DROP and an independent absence query before the single CommitSeal.
The same immediate column cleanup helper now serves seal and cancellation, preserving permanent absence and independent peer cleanup. Unknown callers, source/query failures and unproved retirement remain quarantined. README, ARCHITECTURE, ROADMAP and the seal contract are updated, including correction of the obsolete architecture reference to the implemented Provision selector.
All 44 final checks pass: 335 library plus 137 runtime tests, 472 in each of six maintained feature/profile selections; strict host/native Clippy, private rustdoc, formatting, Markdown, dependency checks and warning-denied native builds. All six executables pass RX-entry, no-W+X-page and complete RO/NX version-7 layout inspection. Eleven new controls exercise early seal, every correlation field, remote preparation proof, transport/application/RELEASE errors, source cleanup, unknown ownership, premature Prepared, permanent absence and lost public replies at every scheduler boundary. Original CI171 and CI172 pass with four complete independently verified logs (171,034 bytes, 472 tests per Rust job, zero warnings). No unchanged workflow was rerun.
Docs PR4 remains unfinished for the remaining phase requirements.
The seal component is now exposed as an accepted substep. Completion is 15.41% weighted checklist progress, 410 of 871 sub-items complete across 156 decomposed parents. Whole acceptance remains 3.86%, 17 of 460 parents, with all 22 original section weights unchanged. The fresh structural audit checks 76 repositories, 3,181 authored code files under the expanded suffix scope below 1,000 lines, 264 unchanged full Git pins and 98 original crate roots with missing-docs gates. This is not whole-fleet semantic authority acceptance.
Launchd PR2 remains unfinished. Next work must retain actual client Start and terminal outcomes, route authenticated client events before ordinary job lookup, consume final CPU once, and prove coherent native configuration/seal/byte I/O plus failure/reuse. The complete EriX build inside EriX and external Rust/LLVM/toolchain rebuild inside EriX remain unproved. Original Integration CI1792 also passes all 491 VM scenarios and interactive dev/release gates, with all three complete logs reviewed (13,516,777 bytes, zero warnings). This validates its older source graph only; Launchd issue 8 preserves CI164's original failure and inaccessible diagnostics.
A client record resolves its original committed row and rechecks the actual RECV-only source immediately before native COPY. Scalar replies carry no authority.
All 44 final checks pass: 335 library plus 126 runtime tests, 461 in each of six maintained feature/profile selections; strict host/native Clippy, private rustdoc, formatting, Markdown, dependency checks and warning-denied native builds. All six executables pass RX-entry, no-W+X-page and complete RO/NX version-7 layout inspection. Ten new runtime controls cover exact complete plan bytes/hash and source order, context substitutions, replay/exhaustion, changed inventory, native failure/draining, unknown custody, failed relinquishment, separate client retirement and parent loss at all nineteen delivery boundaries. Original CI169 and CI170 pass, with all four complete logs independently verified (167,380 bytes, 461 tests per Rust job, zero warnings). No unchanged workflow was rerun.
README, ARCHITECTURE, ROADMAP and the focused configuration delivery contract are updated. The existing technical manual already specifies this unchanged pull/Prepared custody contract. A fresh structural fleet check covers 76 repositories, 3,167 files in the prior code scope below 1,000 lines, 264 full-revision Git pins and 98 original crate roots with missing-docs gates. It is not whole-fleet semantic authority acceptance.
Original older Launchd CI166 and Integration CI1791 also pass: 491/491 VM scenarios plus interactive development/release and disk image checks for Integration's original 66ddc78 graph. Five complete logs independently verify 13,603,813 bytes with zero warnings; eleven deliberate negative-fixture diagnostics were reviewed in context. Integration CI1792 remains running. This older graph does not validate the new configured-client path. Launchd issue 8 continues to preserve CI164's failed result and unavailable diagnostics.
One component substep now exposes the validated configuration-delivery implementation. Completion is 15.40% weighted checklist progress, 409 of 870 sub-items complete across 156 decomposed parents. Whole acceptance remains 3.86%, 17 of 460 parents; the 22 original section weights are unchanged. Launchd PR2 remains unfinished. Public two-sided seal must prove all remote pull callers retired and the mediator's configuration sender absent before Launchd disposes original sources and commits seal. Client execution, coherent native failure/reuse, final CPU accounting, the complete EriX build inside EriX and the external Rust/LLVM/toolchain rebuild inside EriX remain unproved.
Current-source component acceptance — 25 September 2026: original CI167 and CI168 pass at signed Launchd 21635dba.
Three component substeps now expose the validated guarded-client preparation, canonical plan append/freeze and stopped-client provisioning through public Start. The earlier CI164 diagnostics failure stays recorded: current-source success does not change that original failed result or explain its inaccessible logs. No unchanged workflow was rerun.
Completion is 15.40% weighted checklist progress, with 408 of 869 sub-items complete across 156 decomposed parents. Whole acceptance remains 3.86%, 17 of 460 parents; all 22 original section weights are unchanged. PR2 remains unfinished. Configuration pull serving and receive-source disposal, two-sided seal, actual client execution, coordinated native failure/reuse and final CPU accounting remain open. Neither the complete EriX build inside EriX nor the required external Rust/LLVM/toolchain rebuild inside EriX has been demonstrated.
Each dependent step requires original native caller RELEASE; only then can mediator Start reach its independent PrivateReady gate.
Client Begin retains the original GRANT MOVE and RECV destination independently of scalar reply validity. It checks complete context, the controller proved by native ContextProbe, explicit budgets, descriptor count, immutable plan digest, exact receipt and actual receive inventory. Grant absence is independently proved. Incremental SHA-256 covers the complete acknowledged RCS1 startup, separately from the RCF1 configuration hash. Cancellation drains an unfinished original caller before private Retire/Read/Ack; partial startup uses the existing unknown-digest sentinel, while a known complete digest survives Commit reply loss. Unknown invocation creation and cleanup uncertainty remain quarantined while independent peers retire. A failure reply does not claim cleanup completion.
All 44 final checks pass: 335 library plus 116 runtime tests, 451 total in each of six maintained development/release and default/all-feature/production configurations; strict host/native Clippy, private rustdoc, formatting, Markdown, dependency checks and warning-denied native builds. All six exact executables pass RX-entry, no-W+X-page and complete RO/NX version-7 layout-table inspection. Controls include reversed client order, nine clients and full descriptor width, stale caller/member and changed budgets, eleven malformed or refused Begin cases, substituted Append/Commit replies, each failed RELEASE, unknown invocation ownership, full-width inventory errors and public caller loss at every scheduler boundary. The largest Launchd Rust file remains 982 lines.
The stopped provisioning contract, README, ARCHITECTURE and ROADMAP are updated. The existing technical manual already specifies this unchanged wire and custody contract. The read-only fleet audit covers 76 repositories, 3,163 tracked code files below 1,000 lines, 264 full-commit Git dependency pins and 98 conventional/manifest crate roots with missing-docs gates; this structural check is not whole-fleet semantic authority acceptance.
Original CI167 and CI168 now pass with complete verified logs. The earlier CI164 now fails both Rust and Markdown, with both original job logs returning HTTP 500. The canonical unavailable CI diagnostics report records the evidence and unknown cause. No unchanged job was rerun, and succeeding checks do not override that original failure.
Launchd PR2 remains unfinished. Next work must serve the authenticated configuration pulls, transfer and retire each original client RECV source, complete two-sided seal and actual client execution, and prove coordinated native failure/reuse and final CPU accounting. The coherent four-client VM witness, a complete EriX build inside EriX and the external Rust/LLVM/toolchain rebuild inside EriX remain unproved. Three component substeps are now accepted on this exact current source and its passing original CI; full native acceptance remains open.
Component checklist acceptance remains unchanged while those jobs are monitored. Configured client provisioning, two-sided seal, actual client execution, coordinated failure/reuse and both required rebuilds inside EriX remain open. The required provisioning order is stopped counted mediator Provision, every original client Begin/descriptor stream/Commit, then mediator Start; each original native caller must retire before the dependent step. Launchd PR2 remains unfinished.
Freeze requires complete membership, unique public/native identities and descriptor bindings, client/channel coverage and exact ring capacity, then rechecks original Guarded membership and retains SHA-256 over the exact bytes. No native selector, slot or capability is accepted in records. Accepted lost replies retire the enclosing original realm; refusals cannot consume ordinals or cancel prior custody.
All 44 final checks pass: 335 library plus 107 runtime tests, 442 total in each of six maintained feature/profile selections, strict host/native Clippy, warning-denied native builds, private rustdoc, formatting, dependency and Markdown checks. Six native executables pass RX-entry, no-W+X-page and complete RO/NX layout-table inspection. Tests include literal canonical digest/order, foreign/stale members, malformed/surplus input, duplicate/missing coverage, immutable freeze, lost replies, full pool reuse and a nine-client cohort.
Profiling identified quadratic global validation. The replacement sorts within the existing plan bytes and restores every original field and record order before success or refusal, without hidden allocation, new admitted-client limits or authority effects. Complete checks now take O(C log C + D log D + H) comparisons. Reference-parity tests include all 2,944 single-bit mutations of a full fixture and exact byte restoration through global refusals. Matched shuffled host workloads use eight descriptors per client, three samples and 2,000 checks per sample with identical fixture hashes and semantic checks. At 8/32/128 clients, median complete scalar validation changes from 8.27/123.30/1,526.60 microseconds to 2.35/11.68/50.81 microseconds, about 3.5/10.6/30 times faster. These shared-host measurements establish neither whole-admission nor guest execution speed.
The canonical plan and authority contract, README, ARCHITECTURE and ROADMAP are updated. The existing technical manual already specifies this unchanged append/freeze contract. Original CI165 now passes with complete verified Rust/Markdown logs; CI166 remains waiting. PR2 remains unfinished: configured mediator/client provisioning, two-sided seal, actual client execution, unknown-creation recovery, the coherent four-client VM witness and both required rebuilds inside EriX remain open.
Original CI monitoring: earlier Launchd CI164 still reports running. One bounded live-log diagnostic returned HTTP 500 for both jobs and downloaded no log bytes; this proves neither failure nor termination. It was not cancelled or rerun. Component acceptance credit remains unchanged pending sufficient original CI evidence. The complete goal scope and weighted checklist arithmetic remain unchanged.
Private Retire, final accounting Read and exact Ack require original native RELEASE between stages. PR2 remains unfinished for plan streaming/freeze, client provisioning, seal, actual execution, unknown-creation recovery and coherent VM acceptance.
It adds no native materialization, provisioning, seal, four-client execution or guest-build acceptance. The next preparation work must retain each original client grant and use the private client retirement/accounting protocol, with no ordinary-process rollback fallback. Public checklist acceptance and full goal scope remain unchanged.
The distinct64-byte reply carries no authority; reserved-client retirement retains a never-started outcome and cannot replace the member. Every counted row, including unissued members, must retire both columns before enclosing pool reuse. PR2 remains unfinished: native client materialization, complete plan streaming/provision/seal/start/accounting, coherent four-client VM execution and full guest rebuilds remain required. No additional checklist item or native acceptance is claimed by this component checkpoint.
This verifies the preceding 408-test component checkpoint for PR2; public client materialization, plan streaming/freeze, seal/start/accounting, coherent four-client execution and both guest rebuilds remain open.
Its Configuring reply is capability-free; all carried authority is refused and independently retired. Rejected or duplicate calls preserve previous custody, and Configuring cannot enter the earlier bootstrap-only START path. Actual public-frame controls exercise exact abort/pool reuse, wrong caller/generation, resource refusal, accepted/rejected reply loss and independent receipt disposal. PR2 remains unfinished: public client reservation/materialization, plan append/freeze, streamed provisioning, seal/start/accounting and the coherent four-client VM witness remain required.
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.
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 role0x449, the original nonzero Launchd pair, and nonzero relation scalars. Generic Begin64 must reject role0x449; 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:
RCP1version1.0 uses Pull=1 and Reply=2. Its 96-byte common headeris 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.
RCS1version1.0 has the160-byte header already specified: magic/versionat0/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.
RSC1version1.0 shares the96-byte common header offsets above with its ownmagic 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.
Launchd retains and records each original mediator snapshot, then owns the ACK through native caller retirement. Coordinate the shared ABI and producer with Procd realm work and final scalar retention. This extends Phase 6 completion; it adds no client-visible cross-realm metrics authority and does not replace ordinary job accounting.
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.
Stage clients only from the actual requesting parent's supplied directory SEND and selector, returning nonwrapping realm-local handles. Public policy may refer to those held handles; native process/generation and foreign slot addresses are filled internally from authenticated preparation. Freeze the canonical plan only after staging all clients, then provision/start the exact mediator and provision the client startup records. Preserve the explicit configuration-source retirement corrected in Launchd 7.
Serve ordered configuration pulls only to the actual retained mediator. The temporary configuration receiver needs RECV|GRANT to return exactly one RECV copy for each client record; the child configuration route stays SEND only. Retain original receiver sources and each delivery separately. After Procd returns Prepared, retire the PrepareSeal caller and every copied source/configuration delivery, then independently dispose configuration receiver, sender and revoker obligations. Only afterward send the separate CommitSeal action. Public Sealed and client Start require both correlated proof and native caller retirement. Lost replies or uncertain disposal keep the exact realm/client owners reserved and trigger owned cleanup.
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-positivescenario 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 exit0x10, 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.
The same checkpoint fixes the independently reproduced WAIT decoder defect by accepting exactly ordinary-child and realm-mediator terminal roles before matching the retained process generation. Invalid identity, framing, state and authority remain rejected. All six default/all-feature/production development/release configurations pass 329 library and 66 runtime tests each, strict host/native Clippy, native builds, private rustdoc, formatting and documentation checks, with zero warnings. Authored Rust files remain below 1,000 lines. Final documentation corrections preserve the tested Rust behavior.
The original failed VM remains retained. A newly selected image must pass the unchanged actual startup/readiness/retirement scenario before native acceptance; configuration/seal, four clients, byte I/O and guest toolchain/EriX builds remain open. Private preparation issue 4 and independent event issue 3 remain distinct. WIP PR 2 and Phase 6 completion track the remaining acceptance.
All six default/all-feature/production development and release configurations pass 327 library and 66 runtime tests each. Strict host/native Clippy, warning-denied native builds, private rustdoc, formatting, Markdown and dependency checks pass with zero warnings. Hosted controls include two simultaneous realms, malformed actual native metadata, retained error handles, pending-Ready parent loss and unknown-owner quarantine.
Matching-image native Posixd startup, two-realm independence and retirement acceptance remain pending. These local checks do not establish sealing, client I/O, a complete EriX guest build or the external toolchain rebuild. Publication CI is tracked separately from local validation.
Detailed scope and contracts
Runtime consumer dependency alignment — 15 September 2026
The product catalog, product VM acceptance and guest build remain pending.
No unchanged retry or successful runtime acceptance is claimed.
A matching fixed-server VM is required to establish the correction.
A matching fixed-server VM is still required; Integration issue 66 remains open with both failed predecessor observations.
The actual VM passes all eleven admission calls over the shell's existing private script route: reservation, reads, full-width stale-generation rejection, missing-scope refusal, acknowledged retirement, record reuse and stale-abort rejection.
Successful preparation, mediator configuration/readiness/sealing, client byte I/O, complete source/effect/frame proof, native Rust/LLVM rebuilding and both full EriX builds remain required. This partial lifecycle acceptance adds no whole checklist item.
The new diagnostic will reserve a record, transfer exactly one SEND-only copy of its explicitly supplied startup cwd to the BEGIN-reserved receipt slot, select
bin/truewithin that initial root scope, require PREPARE/Guarded and READ/Guarded, then require ABORT/Retired and a stale READ/NOT_FOUND.No ordinary start, new endpoint, root capability or implicit namespace is introduced. Launchd must retire its received directory copy after exact resolution; Loaderd must return the original staged child and grant, and Procd must retain the actual returned grant and guarded sender branch before acknowledging Guarded. Abort must retire that exact stage and retained custody. Error telemetry must preserve application refusal codes and stop ordinary output after uncertain receipt disposal. The new actual VM retains the 120-second hard and 45-second progress limits and requires its own unique marker before ordinary shell exit. Full source/effect/frame proof, configured/sealed mediator execution, real client byte I/O, native Rust/LLVM rebuilding and both full EriX builds remain required.
The separately retained corrected caller VM passes; full original CI acceptance remains open.
The actual VM passes the eleven existing admission calls followed by BEGIN/Reserved, PREPARE/Guarded, READ/Guarded, ABORT/Retired and stale READ/NOT_FOUND. It transfers exactly one SEND-only copy of the explicitly supplied initial cwd to the authenticated reservation and selects
bin/trueinside that scope. The existing private Launchd route is reused; no new endpoint, root grant or implicit namespace is introduced.Eight actual frame observations retain complete workspace mapping but incomplete 97/63/100/100 runtime/all/admission/preparation proof in both policies; the full frame gate remains required.
Complete typed mediator bootstrap, readiness/configuration/sealing, real client byte I/O, complete source/effect/frame proof, native upstream Rust/LLVM rebuilding and both full EriX build generations 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.
Signed commit be2e28730f714b35e356e925cee8061c67e0799d requires exact GRANT-only final installer receipts and selects the original shared dependency graph.
Lifetime now exercises 27 ordinary CPL3 grant-right controls and requires INSTALL_GRANT_RIGHTS_OK before its existing cleanup assertions. These minimal native scenarios establish neither full service-image acceptance nor a guest build.
Full coordinated consumer acceptance remains open under Kernel design 19 and phase completion.
Full service CPU/profiler VM acceptance and guest builds remain open in Phase 6 completion.
Dynamic pipe status and explicit clock custody — 30 September 2026
Cap-free public operations cannot choose a slot or transfer a caller-selected source. Launchd retains prospective counted custody before copying its startup-admitted SEND query endpoint; configuration and inventory admission preserve original receipts. The shared clock has no per-client provider object or Close; recipient alias disposal follows caller retirement and requires DROP plus independent absence QUERY.
No compatibility client receives a native clock capability.
The full status/directory feature remains open: initial configured channels, inherited stream metadata, full FAT identity/owner/mode/time policy and whole-feature integration remain implementation work. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.
Initial configured FIFO status and atomic writes — 30 September 2026
Bound FIFOs require a valid canonical creator; unbound pools require the all-ones no-creator encoding. Launchd restores original ordering and all creator/credential bytes on acceptance and refusal.
Release precedes original metadata publication and Prepared; native client-disposal acknowledgment cannot overtake query retirement or drop the original clock alias early.
No compatibility client receives a clock capability.
Two ordinary plans require 936 bytes; explicit binding plans require 3752 bytes and 44 authority rows.
The full status/directory feature remains open: inherited stream metadata, complete FAT identity/owner/mode/time policy and whole-feature integration remain implementation work. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.
Original inherited stream metadata — 30 September 2026
Canonical refusals carry no observations. An explicitly unavailable native source cannot become a successful POSIX status.
Shared observers preserve original inode/node/media evidence; Vfsd shares mounted-filesystem qualification with candidate metadata and never replaces object serials with temporary handles or queue offsets.
Missing required fields return ENOTSUP without changing offsets or descriptor lifetime. No new capability, clock, content grant, heap pool or descriptor ceiling is introduced.
12 new Rust controls are authored and unrun: independent family literals, correlation and capacity rejection; ordinary/acquired handle separation; write-only alias identity; unavailable metadata with continued byte I/O; malformed-response custody; cancellation; original lender forwarding; and PTY/local-buffer observations.
The full status/directory feature remains open: native-buffer/PTY original identity, creator and time policy, complete FAT metadata and whole-feature integration remain implementation work. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.
Original native stream identities — 30 September 2026
Ordinary namespace and executable routes cannot allocate one.
Original event times remain Unknown; this scalar metadata cannot turn an incomplete observation into successful compatibility status.
They cover literal wire rejection, atomic encoding, administrator isolation, lost-delivery allocation, binding refusal, exhaustion, directional lifetime, teardown/reuse, original ownership, malformed observations and receipt cleanup.
The full status/directory feature remains open for original native event-time capture, complete FAT metadata and whole-feature integration. Both full EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.
Original native stream event times — 30 September 2026
Alias creation, metadata queries, empty or refused operations and terminal device progress do not query a historical clock.
Ttyd receives an exact authenticated SEND-only Timed endpoint for this source purpose; Launchd uses its already admitted endpoint. Clean refusal remains Unknown.
The seeded boundary control retains the whole original object and proves the intended no-clock refusal contract when executed; no runtime reproduction or practical path to 2^64 bytes is claimed.
They cover source-event independence, unknown evidence, full-range dates, malformed replies, receipt cleanup, exact SEND-only admission, alias/retirement/reuse and overflow refusal. The existing realm workload now requires successful inherited fstat and original PTY clock evidence with stable birth before and after realm retirement; its independent transcript remains 385 calls.
The full status/directory feature remains open for complete FAT metadata and whole-feature integration. Both full EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.
Held directory and resize acquisition without display-path admission
The source audit finds that Launchd never uses directory/root/resize response paths in production. These roles carry no command-entry or manifest binding requirement. Separate them from executable/sidecar resolution with receipt-only V2 directory (0x716) and resize-file (0x717) operations. The 88-byte request preserves full original transaction/session/realm, scope/destination slots, operation-specific attenuation flags, full-width selector length and digest. Raw selectors have no extra inline width; actual transport provides the bound. The exact 128-byte response preserves original correlation, result/failure, mode/size and selected-object digest, with no pathname field or fallback.
Both runtime sides must authenticate the original SEND transfer, exact destination, queried receipt and native source equality. Directory-root attenuation, resize-only purpose, job lifetime, independently retained provider owners, original-key retirement and uncertain-cleanup precedence remain unchanged. Vfsd must admit the complete response before receiver creation. Detached or unrepresentable descriptions cannot prevent relative held-directory, narrowed-root or resize acquisition. Launchd's retained descriptions must drop their unused path arrays and accessors. Retire the old directory/resize opcodes and codec acceptance after all owning consumers and authored controls migrate; no V1 downgrade retry.
Executable/sidecar resolution, authenticated command-entry identity, Loaderd graph selection and retained program display form a separate coordinated boundary. Their current binding checks remain required; this change must not replace them with caller selectors, optional display labels or unproven hashes. Continue that migration and provider/name retirement before the complete feature is accepted. Author raw/long selectors, detached source inheritance, unknown root labels, purpose/attenuation refusal, malformed/replayed receipts, retired frames and cleanup controls without executing tests or CI under the current waiver.
Native SEND and entry-digest
validation return a borrowed complete raw label; ordinary preparation copies it
before transport reuse and admits the sidecar in the remaining exact scratch. Labels create no capability or replacement authority.
Seven new controls cover long raw preparation, reused caller scratch, original
job ownership, capacity/identity refusal, compaction, stale generations, successor
transfer, literal startup geometry and missing/unaddressable budgets.
The containing native migration remains open for remaining provider/name adapters,
complete cross-provider lifetime/refusal controls and coherent runtime catalog
adoption. Existing broad acceptance remains unchanged. Full EriX guest build
generations, external Rust/LLVM rebuilding inside EriX and profiler evidence remain
required and unperformed.
Digest-selected exact executable preparation
Retire the fixed-path private Loaderd preparation family after migrating Launchd and all native consumers. Add V2 operations 0x718 (ordinary executable), 0x719 (realm mediator) and 0x71A (realm client). Their 104-byte base request retains request/opcode, transaction, install destination, actual executable SEND source/staging, mode, size and original object identity. Replace pathname fields with the nonzero command-entry digest already defined as SHA-256(domain V1 || u64 little-endian raw entry length || exact authenticated entry bytes). Realm clients append the unchanged 24-byte original relation, for 128 bytes total. The 184-byte base response preserves original preparation measurements and appends that command-entry correlation; clients append the relation for 208 bytes. Refusal echoes the original entry and relation while withholding success evidence. Old operations and codecs are removed without a fallback.
Launchd derives the digest only from existing Vfsd-authenticated executable evidence, never argv[0], a caller selector or optional display labels. Loaderd compares that digest against entries of the complete runtime graph after authenticating its configured digest. Require exactly one matching executable root, then materialize the actual received executable endpoint with existing exact size, manifest and content measurement checks. The selector digest is data and cannot acquire a filesystem object, bypass runtime-graph integrity, select a service role or start a process.
Separate graph-root selection explicitly: authenticated bootstrap/service pathname selection remains on its own native lifecycle; exact executable/realm/client preparation accepts only the digest selector with actual executable SEND custody. Do not copy a graph source path into another fixed buffer, synthesize a pathname or reopen the selected executable. Preserve graph closure/cycle checks, native caller/realm relation, unique install-grant MOVE, uncertain cleanup and original rollback obligations. Both success and refusal must correlate the requested command entry before Launchd accepts returned evidence.
This completes Loaderd selection within the ongoing native launch migration. Vfsd executable/sidecar framing, counted authenticated entry evidence, retained program display, provider adapter retirement and coherent runtime adoption remain required. Author literal wire, wrong/zero digest, same-content distinct entries, long names, retired frames, native authority and cleanup controls; keep tests/builds/checks/CI deferred under the current waiver. Publish immutable dependencies bottom-up and update the manual and affected tracking records.
Counted authenticated launch-entry evidence
Replace private Vfsd launch-artifact operation 0x613 and its V1 codecs with operation 0x71B and V2 framing. The request retains the original 88-byte correlation/selector prefix and appends u64 maximum exported entry bytes at offset 88, then raw selector bytes at 96. Zero export capacity requests authenticated digest evidence without a display copy. Positive capacity requires the complete available entry, never truncation. Preserve the explicit sidecar flag, source/destination and all transaction/session/realm bindings.
The 184-byte response prefix retains request/op/result/failure at 0/4/8/12, transaction/session/realm at 16/24/32, scope/source/result slots at 40/44/48, mode at 52, size at 56, exported entry length at 64, selector digest at 72 and original object digest at 104. Add authenticated artifact-entry digest at 136, echoed export capacity at 168, echoed flags at 176 and zero reserved at 180; optional complete raw entry bytes follow at 184. Success requires a nonzero entry digest and original object evidence. Refusal preserves original request correlations while zeroing all new object, entry and measurement evidence. Both codecs reject the retired operation with no downgrade.
Vfsd derives entry identity only from complete original-generation evidence retained by the actual native resolution, never from an unchecked caller selector. Hash the existing command-entry domain, u64 little-endian complete byte length and canonical raw entry bytes in place across counted description fragments. For sidecars preserve the explicit derived .lmf requirement; the artifact hash describes the full sidecar entry, while its authenticated manifest contents remain bound to the executable command-entry digest. Missing required binding evidence refuses normally with original cleanup. Display absence cannot manufacture entry identity.
Resolve the executable selector as borrowed bytes. Derive the sidecar by streaming the original selector and literal suffix into the same counted scope traversal, without a 240-byte whole-selector buffer. Preserve known-root interpretation, actual provider authority, active symlink context, source generation and original retirement. Admit caller/transport reply extent and encode complete typed evidence before creating a receiver. Failed publication retires only new custody; uncertain cleanup stops ordinary work.
Launchd validates all original correlations, flags and capacity before accepting evidence. When entry bytes are exported, independently hash their complete bytes and require digest equality. Store the authenticated executable digest independently of its display; Loaderd and manifest binding consume that digest. Manifest evidence needs no retained path cache. Realm/client preparation requests digest-only evidence, removing the display-width obstacle on those paths. Ordinary prompted launches initially advertise their actual existing display storage capacity; continue replacing that retained storage and the coordinated Powerbox/TTY display contract in the same migration. This intermediate capacity is not full counted program-display acceptance.
Author literal wire, atomic capacity, long/raw selector, original-source closure, sidecar derivation, changed entry, retired-operation and cleanup controls. Retain existing content, relation, native receipt and rollback controls. Keep testing, builds and CI observation deferred. Complete retained display, remaining provider/name adapters and coherent deployment adoption before closing the containing native migration or claiming guest self-hosting.
Counted raw program context — producer/consumer design, 1 October 2026
The ordinary prompt boundary must preserve the complete authenticated program entry
without a 240-byte or UTF-8 adapter. This is descriptive data only: Launchd's
entry digest, manifest admission, native scope and object custody remain independent.
Launchd's remaining per-job retained display storage will migrate after this boundary.
Replace the contextual V1 types with PowerboxBeginContextRequestV2 and
TtyPowerboxPromptContextRequestV2 across LibIPC, Launchd, Powerboxd and Ttyd.
The fixed authority-free BEGIN (80 bytes) and prompt (128 bytes), private routes
and answer correlation remain unchanged. V2 context appends job generation u32,
a reserved zero u32 and program length u64; the prompt additionally appends selector
length u64. Prefixes are exactly 96 and 152 bytes. Raw program and then selector
bytes follow. Exact fixed shapes select their fixed codecs; every other shape
selects only V2, without retrying the fixed parser after a contextual failure.
The nonzero legacy contextual length occupies V2's reserved word, so retired V1
contexts reject rather than silently changing interpretation.
Programs use complete absolute normalized raw bytes; generation is nonzero.
Selectors remain complete nonempty NUL-free raw bytes. Counts must fit target
width and exact body extent before borrowing, retaining or encoding. Overflow,
unknown padding, short/long bodies and insufficient output leave storage unchanged.
No opcode, label, generation or byte count creates a capability or changes policy.
Powerbox retains the full original program and selector together in its existing
caller-sized arena, preserves both through compaction and clears retired ranges.
Prompt transport admits the complete body before calling Ttyd. Ttyd escapes each
non-ASCII/control byte, admits the whole rendered review, and retains existing
rollback and visibility-gated secure-input behavior. No truncated prompt or digest
shortcut may authorize consent. Surplus capability receipts retain their existing
independent disposal rules.
Migrate current controls and add raw/long geometry, retired-context refusal,
capacity atomicity, retained arena ownership/compaction and trusted rendering
controls. Document the coordinated immutable revision graph and remaining ordinary
Launchd storage work. Author controls without running tests, builds, checks,
generated documents or CI observation under the current request.
Counted retained program display — ownership and deployment design, 1 October 2026
Remove Launchd's fixed program display array while retaining independently
Vfsd-authenticated entry identity and native executable/manifest custody. No
selector, argv label, digest rendering or later pathname reopening may substitute
for the original complete program bytes.
Executable reply validation borrows the complete raw entry from the authenticated
reply after checking the native SEND receipt and entry digest. Ordinary preparation
copies it into the front of its existing caller-owned authentication scratch before
reusing transport storage; the remaining exact scratch range receives the manifest.
Private realm/client preparation continues to request digest-only evidence. No
file SEND is retained merely to keep display bytes alive.
A separate caller-supplied job-program byte arena owns display after authentication.
Each occupied generational job stores a checked offset/length, without a per-job
partition or pathname limit. Policy binding checks shape, original entry digest
and full remaining capacity before publishing either policy or display. Compaction
updates live offsets and clears released tail bytes. Stale handles cannot read or
retire a replacement. Successor adoption transfers the candidate range to the stable
job, retires the predecessor range exactly once and clears the candidate owner.
Terminal release retires bytes after the original native cleanup checks. Delayed
and runtime prompts borrow only the original job's range and retain existing
process, transaction, session and generation binding.
Deployment explicitly budgets job_program_bytes independently of transaction,
manifest and job-record counts. LCH1 V6 appends a positive u64 byte capacity at
offset 96 and has exact size 104; obsolete V5 is rejected without a default. The
Launchd target capacity descriptor advances to version 9, retaining its existing
type-layout words and adding this byte region in the same allocation order used
by Integration. LibBootstrap, Rootd, Launchd and Integration producers/consumers,
profiles, command-line forwarding and authored fixtures migrate together. Existing
capability-slot policy and authority ceilings do not change. The separately pinned
Rootd compiled helper remains unchanged.
Author long/raw entry, exact capacity, scratch reuse, compaction, stale generation,
successor transfer, delayed prompt and cleanup controls, plus literal startup and
image geometry cases. Keep original failure precedence and uncertain cleanup.
Update component contracts and manual TeX. Tests, builds, checks, generated manuals,
VM/profiler execution and CI observation remain deferred by request. The containing
native migration and full guest/toolchain builds remain open until actually handled.
Related records and contracts
[FEATURE] [P02.R27] Audit authority, code quality and documentation in launchdto [FEATURE] Audit authority, code quality and documentation in launchderikinkinen referenced this issue2026-09-15 10:56:18 +02:00
erikinkinen referenced this issue from erix/vfsd2026-10-01 19:57:22 +02:00
erikinkinen referenced this issue from erix/vfsd2026-10-01 19:57:26 +02:00
erikinkinen referenced this issue from erix/docs2026-10-01 19:57:26 +02:00
erikinkinen referenced this issue from erix/integration2026-10-01 19:57:27 +02:00
erikinkinen referenced this issue from erix/posixd2026-10-01 19:57:28 +02:00
erikinkinen referenced this issue from erix/lib-ipc2026-10-01 19:57:28 +02:00
erikinkinen referenced this issue from erix/ramfsd2026-10-01 19:57:29 +02:00
erikinkinen referenced this issue from erix/e2fsd2026-10-01 19:57:29 +02:00
erikinkinen referenced this issue from erix/fatd2026-10-01 19:57:30 +02:00
erikinkinen referenced this issue from erix/exsh2026-10-01 19:57:30 +02:00
erikinkinen referenced this issue from erix/coreutils2026-10-01 19:57:31 +02:00
erikinkinen referenced this issue from erix/loaderd2026-10-01 20:20:29 +02:00
erikinkinen referenced this issue from erix/lib-ipc2026-10-01 20:55:41 +02:00
erikinkinen referenced this issue from erix/ttyd2026-10-01 21:15:32 +02:00
erikinkinen referenced this issue from erix/rootd2026-10-01 21:46:30 +02:00