feat: Provide scoped local stream sockets for guest build tooling #34

Open
opened 2026-10-02 19:23:36 +02:00 by erikinkinen · 1 comment
Owner

Problem and motivation

The maintained Integration unit workloads use anonymous socket pairs and pathname-based local stream listeners/clients. Full guest validation requires these operations to execute over EriX ownership; substituting host sockets or treating a copied pathname as communication authority would not satisfy that requirement. At the start of this work, byte channels provided one-way FIFO descriptions without connected duplex socket objects, half-close or scoped local listener admission. The current implementation status is recorded below; the whole required scope remains open.

Original consumers at Integration revision 2002ef2aca1ca38ed36ad66d5d5783deae2dc5f9 include tests/fixture_socket_io_test.py, tests/fixture_startup_test.py and tests/interactive_shell_transport_test.py, selected by the maintained CI commands. Their concrete requirements include socketpair, local bind/listen/connect/accept, nonblocking I/O, select, original timeouts, SO_SNDBUF, shutdown of one direction, peer EOF and exact cleanup. Host VM transport scripts are separate consumers; their presence does not authorize guest access to host QMP or COM1 endpoints. The external toolchain API/version matrix still needs completion and must not be inferred from these owned tests.

Proposed behavior and scope

Implement manifest-required local stream socket semantics through the client's original Posixd ingress and explicitly counted realm storage. Define connected duplex descriptions and independent read/write lifetime, atomic pair creation, required socket options and directional shutdown. Compose ordinary byte/vector I/O, original descriptor aliases, event-driven readiness and actual clock deadlines with those same descriptions.

Implement required pathname local listener and connection semantics only through explicitly admitted directory scope and exact original socket/listener identity. A registry spelling, process ID, peer description or socket filename alone must not confer authority. Preserve original bind/listen/connect/accept reservations, backlog and accepted endpoint custody through publication, cancellation, loss and teardown. Specify required permissions and unlink/replacement behavior before native effects.

Freeze a machine-readable source-backed workload matrix and distinguish required guest unit workloads, host VM transport helpers, optional upstream interfaces and unresolved imported-tool closure. Unsupported families, protocols, message modes, ancillary rights or options must return defined refusal without acquiring authority. No networking is introduced by local socket support.

Ordinary native thread creation

The ordinary Posixd receiver will drive the existing prepare, context, enrollment and Start operations for a client's thread. The request describes its already mapped code, stack and TLS, counted modules and guards, and TLS image. It carries no factory, member, receiver, process or thread selector. The full request must fit the admitted storage before reserving a row or destination.

The successful native CLAIM identifies the admitted client and creator. Their counted thread row retains the invocation generation, delivery owner, caller, inherited signal mask, request bytes, factory slot and serial, and prospective member destination before effects. The held factory authorizes MINT only within its original process. The mediator uses the resulting member's READ, WRITE and EXECUTE rights for setup, then reduces the held member to READ before completing the request; it grants none of these capabilities to the client. Kernel independently checks and retains the original mappings and backing generations through context creation and Start.

Progress takes one native operation per fair turn: check the destination is empty, prepare the member, check its metadata and READ observation, initialize context, enroll, then Start once. Destination selection uses the inventoried capability window, excluding roots, bootstrap endpoints and all retained members and reservations. An occupied slot is neither adopted nor overwritten. Plan and storage capacities determine the limits.

A packed context bridge will validate the complete canonical context packet in caller-supplied scratch. It uses the existing syscall ABI, checks unchanged request bytes and the full correlated reply, and avoids unsafe slice casts or temporary tables. Native selectors come from the held member and current CLAIM, not the client's description. No saved user pointer is dereferenced on a later turn.

Successful Start returns descriptive thread identity. The member remains owned by its thread row after the creator finishes; a refused completion never retries Start or discards the member. Malformed input, disabled factories and insufficient capacity fail before effects. Uncertain effects retain the same request and destination, stop ordinary work, and await authenticated lifecycle cleanup.

Cleanup checks only the retained member destination after process retirement, drops it only if it still holds that member, and independently confirms absence. A different occupant cannot satisfy cleanup. Members settle before the factory and receiver, while the creator's serving invocation and first failure remain separate obligations.

This step includes the production request path, native adapters, counted ownership, fair progress, correlated result and cleanup. Regression coverage includes successful birth, overlapping creators, disabled and exhausted capacity, malformed requests, changed native replies, completion refusal, and uncertainty during preparation or Start. Libc stack/TLS allocation, dynamic ELF TLS, return/join/detach, row reuse, deployment consumers and hardware VM coverage remain required in these open issues.

Authority, security and reliability

Socketpair uses only original realm fd/description/ring storage; it acquires no provider, network, namespace, process-control or global discovery capability. A connection through a name requires the original admitted scope and original listener object, with full realm, client, fd and description generations retained. A cross-realm operation requires explicit delegation; copied names and IDs never widen it.

Validate all request/result/storage requirements before reservations or effects. Publish both pair descriptors together only after the original native result is accepted. Retain unpublished owners after ambiguous completion. Independent aliases preserve their original shared state; shutdown never disposes unrelated capability owners. Preserve buffered bytes and half-close/EOF/error ordering. Final teardown acknowledges every native owner, removes only original bindings and scrubs ring contents before reuse. Security, reliability and performance remain the priority order.

Remove spent native member rights

The ordinary birth path initially retains READ, WRITE and EXECUTE after
positive Start. Native immutable context and once-only Start
prevent another context or successor, but the unused WRITE and EXECUTE masks are
still unwanted explicit authority. Existing local relocation preserves rights;
requesting GRANT to attenuate through a transfer would add unwanted authority.

Native operation

Add one caller-local same-slot native member attenuation operation. The caller
must actually own the current move-only NativeMember binding in its Running
process's existing CSpace window. Expected nonzero serial narrows that binding;
it never authenticates a copied descriptor, selects another process, or follows
an old slot occupant. Factory carriers and ordinary capabilities are outside this
operation. No Process, stage, root, GRANT or target-process selector is accepted.

The requested rights must be a subset of the independently current rights. Zero
remains valid zero. The operation changes only that unique existing member's
capability and indexed native binding metadata; it creates no alias, destination,
TCB, context, process or mapping, and restores no permission. It cannot unfreeze
a cleanup-only member or make a retired carrier operational. Actual cleanup-only
state can be retained while rights monotonically decrease. A carrier lease or
current CSpace inconsistency refuses before either metadata copy changes.

All native transition checks and any required storage admission finish before
the rights change. Under the existing lifecycle exclusion, update the current
CSpace capability and its original directory metadata together; no fallible step
may follow the first change before both copies agree. The actual member/context/
process and memory owners remain in place. No lifetime obligation is discharged.

Framing and compatibility

Use a new strict NTA1 request, 32 bytes:

Offset Meaning
0 NTA1 magic
4 Four zero reserved bytes
8 Current local member slot, u32
12 Requested exact subset, u32
16 Expected original serial, u64
24 Eight zero reserved bytes

Append a 24-byte zero reply reservation. Positive NAR1 output contains its magic,
four reserved zero bytes, the same serial at offset 8, the exact resulting rights
at offset 16 and four final reserved zero bytes. There is deliberately no process
or thread observation: an owner with zero rights can reduce zero to zero without
obtaining READ-only native identity information. The caller already supplied every
returned scalar. Existing member/factory/context/enrollment/Start wire remains
unchanged. Reserve the next unassigned native syscall number only after checking
the complete dispatch registry; rdi/rsi name the exclusive exact 56-byte packet,
all other argument registers must be zero, and success returns extent 24.

Shared IPC exports a canonical request/reply codec and immediate bridge. It
checks complete framing before transport, unchanged original request bytes,
exact success extent, same serial and exact requested resulting mask. Hosted
targets refuse locally. Invalid input never issues a native effect; failed or
inconsistent output retains the original request and native custody.

Replay and errors

With the same current binding/serial and already equal rights, exact continuation
returns the same descriptive success without another native effect. If another
operation has reduced the mask further, the old larger request refuses rather
than restoring it. Missing or changed binding/serial, wrong object kind, broader
requested rights and dirty framing cannot alter either original or new object.
Do not infer absence, successful reduction, removal or permission restoration
from any failure. A moved or positively dropped original carrier is not recreated.

Ordinary birth integration

After correlating the one positive Start, Posixd retains the complete same-slot
serial and READ-only target before requesting attenuation. It advances through
attenuation, exact current metadata and native READ in separate fair turns. Only
then may it prepare NBR1. No WRITE/EXECUTE/GRANT goes to the client. The original
positive Start and member owner survive COMPLETE refusal and creator retirement.

If attenuation or verification becomes uncertain, ordinary service freezes and
retains the original Start, attenuation intent and binding. It does not retry
Start, create a replacement, clear the first error or adopt another slot. During
authenticated terminal cleanup, independently observe the same original serial
and accept only the recorded possible current masks (pre-reduction R/W/X or
post-reduction READ). This is an explicit uncertain original transition, not a
permission allowance for another carrier. Drop only the proved original and
separately establish absence; native group disposal may already have removed it.

Required controls

Cover exact subset and zero reduction, same-slot repeat, changed serial/window/
process/type, missing and historical bindings, cleanup-only preservation,
forbidden restoration, no GRANT requirement, metadata/native-rights coherence and
unchanged original member/context/backing ownership. Bridge controls cover every
reserved field, wrong extent, request mutation, exact result correlation and
hosted refusal. Extend ordinary receiver tests for positive READ-only census,
uncertain attenuation and changed actual current rights/serial, while retaining
all original creator, context, enrollment, Start and cleanup controls. A native
VM control must exercise the immediate operation with real current binding and
malformed register/packet/span refusals. This does not accept allocation, TLS,
thread join/detach or full self-hosting requirements.

Proposed source ownership

  • LibIPC: a thematic native-member attenuation codec module and syscall bridge,
    registered from the existing native_member modules and independent tests.
  • Kernel: native_thread/attenuation.rs, a narrow CSpace metadata reduction helper,
    existing native-thread packet registry/adapter and independent object/wire
    controls. No scheduling, context or Start behavior changes.
  • Posixd: retained attenuation phase/intent and READ-only member inventory and
    cleanup in the existing birth owner, native transport adapter and controls.

Exercise ordinary thread creation with producer-provisioned memory

This extends ordinary creation in Kernel #47 and Posixd #34. The workload uses the
existing factory diagnostic: two realms, two clients per realm, T4/C2 storage,
1024-byte request/result budgets, canonical plan order, 38-process live envelope
and 120-second VM deadline. A factory's capacity 2 includes the initial execution,
so each client creates exactly one additional member. There is no new mapper,
process, logging or factory grant in the client or Posixd.

Select a separate executable without changing the supervisor

Add a separate realm-thread-client Cargo root in Posixd and a separate linker.
Integration selects its source and linker explicitly and packages that graph root
under the existing private /bin/realm-byte-client fixture alias. Exsh retains
its current factory diagnostic, canonical plan and all startup, signal, peer,
exhaustion, six-native-exit and replacement-retirement witnesses. Ordinary byte,
binding and pipe fixtures keep their existing source/linker selection. A new
scenario field enables this client only with the existing factory diagnostic;
invalid combinations refuse before artifact construction.

The new root shares native startup, original-caller transport and the complete
reciprocal byte workload. A thematic callback module runs the thread workload
after the complete existing byte workload and before process exit. Existing clients
use one shared empty callback; they gain no unused member memory or syscall path.
No Exsh source change or frame-proof bypass is part of this extension.

Provision real distinct ELF mappings

Use explicit PHDRs for RX code, R read-only data, ordinary RW data, member TLS,
member stack and the final original creator stack. All writable headers are NX.
Reserve TLS and stack in separate original LOAD extents with page-aligned bounds.
Leave one complete native page outside every LOAD immediately below the member
stack. A linker symbol or padding inside a writable LOAD is insufficient.
Keep the creator stack as the final writable root extent, preserving Loaderd's
current root-stack selection. Initial member TLS is ordinary explicit RW data,
not an ELF PT_TLS segment or a dynamic TLS allocator.

Actual authenticated Loaderd/Procd materialization maps and zeroes these LOADs
before the original process Start. Posixd receives neither VSpace nor mapping
capabilities. Before packaging the selected native artifact, inspect its real
program headers: code RX, ordinary data/TLS/stacks RW/NX, complete stack guard
outside all mapped page extents, creator/member stacks and TLS disjoint, and the
final writable extent equal to the creator stack. The checker also rejects
reserved/unknown permissions, wrapping or incomplete extents, merged guard pages
and substituted fixture source/linker selection. Zero-file-size LOADs must follow
the existing authenticated materialization contract rather than a fabricated
host allocation. An actual producer refusal becomes a prerequisite to repair.

Preserve original caller and memory lifetimes

The creator sends ByteCall::new_thread through its admitted ingress with the
linked executable range, member stack/TLS bounds, guard and immutable initial TLS
bytes. A fixed native entry wrapper and opaque callback arguments describe this
same process's original memory; they carry no native factory/member selector.
The creator's packet is its original exclusive startup workspace. The member's
packet lives in its separately provisioned stack and cannot alias that workspace.
Fixture packet extents must cover the existing 1024-byte budgets explicitly;
these sizes add no general codec, module or thread limit.

Posixd retains the original request, native CLAIM, READ/MINT factory, counted row,
context/enrollment/Start and member destination. Kernel admits actual mappings
and retains their original backing occupations and guard absence. After Start,
Posixd removes WRITE/EXECUTE from its held carrier, independently verifies READ
and returns descriptive NBR1. The creator keeps its original ByteCall through
caller retirement and retains every uncertain owner until genuine process exit.

The native member uses its fresh FS to check the immutable TLS word, executes its
own ordinary QueryAbi through the same process ingress, and retires that separate
native caller. Its actual returned callback value is published through a release
atomic in original shared RW data. The creator checks it with acquire ordering
while its startup object and original stack remain alive. No borrowed startup
pointer is used after publication. The entry wrapper then invokes current-thread
self-exit with that original result. Any unexpected return or uncertainty closes
the actual process through its existing terminal path; no operation is retried.

The returned word proves the callback returned after its own ordinary call; it
is not an exclusive join, stack-reuse or independently observed departed-member
receipt. Those remain separate requirements. Kernel's existing actual self-exit
controls cover the native primitive independently.

Preserve terminal ownership and actual evidence

Each creator completes every existing reciprocal, blocking, signal, Close and
EOF witness before the thread workload. It then requires the returned callback
value and retired original birth caller before process exit. This keeps the old
signal workload's original task set intact; it does not claim new per-thread
signal delivery or departed-member signal eligibility.
Exsh still requires its six genuine successful native exits and full original
realm/client retirement, including the never-started replacement and live peer.
Member cleanup uses the original READ carrier, exact serial, native DROP and a
separate absence observation before factory/receiver retirement. The new scenario
keeps every existing marker and timeout; its required native exits now also depend
on the selected client's birth, TLS, member-call and returned-value checks.

Run that bounded VM only with the actual signed graph, matching artifact/source
receipts and required Exsh frame gate. A compiled client, host model, linked ELF
or unchanged marker name is not a deployed pass. This slice does not complete
ordinary libc stack allocation, dynamic ELF TLS, join/detach or guest self-hosting.

Source ownership

Posixd owns the new client root, thematic workload/default callback modules,
separate linker, shared native callback dispatch, native CI coverage and component
documentation. Integration owns private client artifact selection, the narrow
scenario field/policy, ELF geometry checker and focused independent controls,
and the separate finite scenario. Root coordinates exact signed dependency heads,
public design, commits and the existing Exsh proof owner. No producer authority
protocol or shared libc codec migration is changed without another reviewed design.

Acceptance criteria

Checklist
  • Record exact required source/workload operations and resolve their interface ownership; retain explicit gaps for the imported-tool manifest and never claim whole coverage from a source-string inventory.
  • Specify and implement the complete counted local-stream ABI, atomic pair/result admission and defined unsupported-operation errors without changing native authority ceilings.
  • Implement original duplex byte/vector I/O, aliases, nonblocking/backpressure semantics, required buffer options, directional shutdown, peer closure and exact final retirement.
  • Implement required scoped pathname bind/listen/connect/accept, original listener/backlog/connection lifetime and unlink/replacement behavior without ambient name lookup.
  • Integrate original event-driven readiness, actual delegated deadlines, cancellation and signal interruption for pending socket operations.
  • Author independent positive, malformed, exhaustion, half-close, replacement, cross-client/realm denial, caller-loss and ambiguous-publication controls, plus actual native multi-client socket workloads.
  • Update component/manual contracts and inline rustdoc, retain missing-docs enforcement and code below 1,000 lines, remove superseded one-way assumptions, and preserve duplicate same-repository PR guards.
  • Publish coherent signed immutable dependencies, document source/performance evidence and update owning reviews and phase tracking before acceptance. Test execution remains waived; no execution or measured performance result may be invented.

Alternatives and tradeoffs

A socketpair-only implementation cannot cover the maintained pathname listener tests. Two uncoordinated pipe creations cannot provide atomic duplex publication, shared socket state or directional shutdown. A process-global name registry, implicit host socket adapter or hidden network endpoint would create authority outside the original realm. Use actual admitted storage and explicit capacity refusal instead of a new hard-coded pair/listener count. Additional datagram, credential or descriptor-transfer interfaces require a demonstrated workload and reviewed ownership contract.

The design derives from the POSIX socketpair contract and the Python socket interface, together with original EriX workload sources. No third-party implementation code is copied.

Tracking and rollout

Coordinate filesystem/descriptor services, completed descriptor readiness, Posixd review, Integration review and phase completion. Record the workload matrix first; implement duplex publication and lifecycle, scoped listeners, waits and native consumers coherently. General libc wrappers, imported-tool porting and both guest EriX/toolchain rebuild demonstrations remain separate required integration work.

Detailed scope and contracts

Fair original native intake and Close reply custody — 4 October 2026

Retiring scopes and removed metadata stop intake; no separate parallelism cap, heap allocator, per-thread scope grant or packet thread-ID authority is added.

One-shot receivers remain exclusive through refused completion and original retirement. Final ordinary settlement yields the existing preferred legacy RECV turn. Refused COMPLETE remains attempted; draining and receiver-disposal refusal retain original custody. Caller retirement cannot prove semantic cleanup; private revocation may suppress Close's reply while cleanup still finishes. Final scope clearing requires every original call and positive receiver absence. The association is descriptive and adds no capability; actual updated type size/alignment drive exported target layout and runtime storage without a wire or authority ABI change.

They cover real peer-blocked Wait with provider work/query, multiple original waits and process cleanup, Close after older Wait drain, refused Close/draining/delayed disposal, private revocation/provider refusal, counted saturation/recovery, one-shot exclusivity, final-settlement legacy opportunity, valid/contradictory Close associations, original child disposal through provider refusal/caller loss/private abandonment, and receiver-generation refusal before provider retry. Full Posixd uncertain process-close coordination and overlapping intake, per-call masks/TLS, complete libc/imported consumers, same-process native overlap workload sources remain required. Native caller retirement cannot prove semantic cleanup or permit old cleanup to release newer process locks. The whole socket feature remains open.

Completed source criteria are marked despite deferred execution; missing implementation remains open. Both complete EriX guest generations and external Rust/LLVM guest rebuilds remain mandatory and unperformed.

Independent native custody and fair blocked-Wait intake are source-complete; native serving has five completed source criteria and three open criteria: fd/process-lifetime coordination, the retained Posixd close coordinator, and complete same-process native VM workload sources. Recalculated phase progress is 21.11% weighted; 9.61% whole acceptance; 32/460 parents and 495/965 children across 167 decomposed parents.

Original first-submission key order — 4 October 2026

Fair Vfsd intake must dispatch each newly claimed request before yielding so later claims cannot overtake the monotonic admission fence. The existing candidate and Wait replay/absence fences remain intact; this adds no scope mutex, grant, tombstone ledger, allocator or independent waiter cap. Commit/Cancel and uncertain submission keep the original key and normalized intent; original native retirement precedes idempotent cleanup and cannot itself prove semantic rollback.

Six controls are authored and unrun: delayed EOF with reordered Wait admission; a newer actual first submission while another Wait stays pending; pre-submission cancellation without consuming a key; actual packet and EOF-coordinate refusal before issuance; uncertain original submission and cleanup after a newer key; and full-width final-key exhaustion.

Fair overlap, one-shot/legacy lifetimes, full terminal drain integration and uncertain process-close coordination remain unfinished in independent native invocations and local stream sockets. Both features remain open with all eight whole criteria unchecked. Per-call masks/TLS, complete libc frontends and imported-tool closure remain required in the same whole socket scope.

Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Deferred execution does not prevent marking completed implementation; unfinished whole serving and guest-build requirements remain open.

Original advisory provider-pin custody — 4 October 2026

Provider disposal refuses active uses before effects. This creates no additional provider acquisition, native grant, RPC, allocator or per-process concurrency cap.

Original generations, both reservation links and captured intent must agree. Stale saved success and foreign terminal correlation refuse; attempted COMPLETE history remains unchanged without replay.

Eight controls are authored and unrun: immediate publication and uncertain completion; readiness/Commit transfer; prepared cancellation and stale-result refusal; original pin disposal preserving another pin's newer locks; quarantine preserving published before-images; quarantine of an immediate acquisition; no-row cleanup ticket order; and contradictory scope generation before effects. Existing retirement controls now require independent positive cancellation instead of stale success.

Public pre-submission key ordering, independent intake, one-shot/legacy fairness and uncertain process-close coordination remain unfinished in independent native invocations and local stream sockets. Both owning features remain open with all eight whole criteria unchecked. Complete libc frontends, per-call masks/TLS and imported-tool closure remain required in the same whole socket scope.

Both complete EriX guest generations and external Rust/LLVM rebuilds inside EriX remain mandatory and unperformed.

Implementation completion is not gated on those deferred executions; incomplete serving and guest-build requirements remain open.

Whole-receiver native reply abandonment — 4 October 2026

Actual reference count, links, tail, progress cursor and original non-reused generations must agree.

Later progress cannot dispatch the abandoned request, reconstruct a result, attach a new reservation or resume provider arbitration. An earlier accepted or refused COMPLETE keeps its original decision and is never replayed. Provider and receiver refusal retain their own original cleanup barriers.

The cached lock-success defect, Vfsd#28, is closed as source-complete using bug_report with bug/phase-6 metadata and all four criteria checked under the user testing waiver. The original serial serving path could roll back an advisory lock, refuse provider retirement and leave its cached Complete result eligible for native delivery.

Seven new controls are authored and unrun: full roster abandonment preserving an independent receiver and an unclaimed association; malformed roster refusal before any saved result changes; permanent abandonment across movement/live probes; accepted/refused native completion history; multiple-call native/receiver drain; private scope cleanup through provider/receiver refusal; and the minimal serial cached-success regression.

Suspended-operation pins, public pre-submission key ordering, independent intake and one-shot/legacy fairness remain unfinished in Vfsd#27. All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added.

Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Native mutation admission — 4 October 2026

Disjoint requests inside one original before-image still depend on that journal so rollback cannot overwrite newer state. Capacity refusal and duplicate original change admission preserve all rows before any effect.

Public continuation token zero cannot select these native queues.

Cancellation rolls back effects while retaining the original typed result through actual completion or positive retirement; it never redirects cleanup into a newer provider pin or repeats attempted COMPLETE.

Nine new controls are authored and unrun: independent objects/owners and separately settled intervals; shared before-images and merge neighbors; atomic capacity refusal; original Unlock delivery; process-close publication; ordered native cleanup calls; original pin retirement preserving newer locks; and counted queue exhaustion preserving the original caller and effect.

Suspended-operation pins, public pre-submission key ordering, independent native intake, generalized all-call terminal drain and one-shot/legacy fairness remain unfinished in Vfsd#27. All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added.

Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Independent advisory reservation custody — 4 October 2026

Exhaustion refuses before consuming the client's continuation key or installing a call link.

Ordinary progress follows the actual link; copied snapshots cannot replace custody. Commit and Cancel select only the original scope's continuation key and require fully correlated intent. Contradictory generations propagate refusal before arbitration or cleanup. Exact Commit requires this positive readiness boundary and attaches its own original delivery; early or repeated Commit preserves the reservation.

An unsubmitted readiness or Commit result becomes a correlated refusal; an attempted COMPLETE is never replayed. A terminal reservation cannot resume provider arbitration after pin retirement. Scope reuse and call clearing refuse retained reservation custody.

Admission based on actual conflicting mutations remains required. Production intake still progresses an existing call before claiming another; interleaved native intake, suspended-operation pins, generalized all-call terminal drain and one-shot/legacy fairness remain unfinished in Vfsd#27. All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added.

Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Original native request dispatch — 3 October 2026

Dispatch copies the retained packet into scratch; scratch contents cannot substitute another request. Unclaimed allocation, malformed native intake, endpoint substitution, replay and abandoned or settled delivery cannot supply dispatch proof. Malformed application framing consumes readiness before refusal.

Legacy advisory mutations, including Commit, Cancel and process-close cleanup, refuse even while another native call is pending on the scope. Queued waits retain their original call identity; readiness and native settlement cannot borrow another delivery.

Six new controls are authored and unrun: unusable intake and abandonment; one-use dispatch across movement/refusal; legacy mutations during an unrelated native query; accepted/refused Try and Commit from spare call rows; spare-call readiness followed by Commit; and unclaimed/malformed request replay.

Independent multi-waiter custody, exact reservation lookup, cancellation drain, conflict-journal admission, suspended-operation pins and fair all-call terminal drain remain unfinished in Vfsd#27. All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added.

Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Counted native call allocation — 3 October 2026

No separate per-process call cap, new buffer, allocator or native grant is introduced.

Scope clearing refuses retained receiver associations. Stale call keys, replacement generations and contradictory neighbors refuse before native progress or unlinking. Native submission also refuses a substituted endpoint index or generation before CLAIM.

Four controls are authored and unrun: counted exhaustion and roster unlinking with receiver retention after metadata removal; stale call keys and replacement receiver generations; idle CLAIM cleanup through the real serving path; and rejection of substituted endpoint coordinates before native submission.

Explicit invocation-versus-scope dispatch identity, independent reservation ownership after readiness, exact Commit/Cancel lookup, conflict-journal admission, suspended-operation pins and all-call terminal drain remain unfinished in Vfsd#27. All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added.

Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Native call custody — 3 October 2026

COMPLETE and provider/receiver cleanup use that retained endpoint independently of the call's current storage location; replacement generations refuse before native progress or cleanup. Copied endpoint coordinates confer no authority without the retained native owner.

Moving a call preserves its prepared bytes, completion-attempt history, native acceptance/retirement and original advisory settlement. A refused COMPLETE cannot be retried after movement. Clearing now refuses until positive native settlement and consumption of the original journal decision; refusal preserves both custody and bytes. No extra buffer, allocator, wire operation or grant is introduced.

The other moves a refused delivery and requires positive original cancellation retirement plus journal consumption before clearing, without a repeated COMPLETE.

Independent allocation, original receiver/scope holds, multi-waiter reservation lookup and cancellation, conflicting-journal admission, fair progress and all-call terminal drain remain unfinished in Vfsd#27. The process's single admitted acquisition-scope route can still be occupied by a blocked native Wait; a mediator-only fence cannot make Close progress there. All eight native-serving criteria and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added.

The completed candidate-retirement repair remains selected: delayed native pin disposal stays narrow and cannot restore retired custody from rollback records. Complete native thread/TLS semantics, libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Candidate lock retirement — 3 October 2026

While a native Wait owns that row, the scope cannot claim Close or an independent operation. A mediator-only lock fence cannot resolve this limitation. Native receiver/scope custody must be separated from counted per-call serving owners, with original pin holds, reservation/journal settlement, fair progress and all-call terminal drain. Its eight whole criteria remain unchecked; no additional completion credit is claimed.

No new native grant, provider route, allocation, wire operation or unsafe code is introduced.

This repair does not complete mediator admission coordination: uncertain explicit Close retries must not erase newly acquired process locks, and a blocking Wait must not hold a fence that deadlocks Close. Queued mutation admission, path-anchor/socket-path lifetime audit, invocation-owned masks, fair all-call intake/drain, native thread/TLS semantics, complete libc frontends and imported consumers remain unfinished. All eight whole socket criteria remain unchecked. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Prospective alias holds and cleanup activity — 3 October 2026

Source fd close/reuse cannot redirect the eventual alias. Commit transfers its original hold into the destination fd even when no source fd remains; effect-free undo returns an ordinary cleanup hold to the same native delivery. Final source disposal remains explicit and never repeats any-close process-lock policy.

Generic source release cannot discard an uncommitted alias intent.

Repeated settled cleanup produces no new local effect.

Seven controls are authored and unrun: original-source publication after close/reuse; final-source cleanup returned by undo; independent alias cancellation; exact target conflict boundaries; listener survival through publication; listener cancellation retaining its pin; and same-epoch peer HANGUP before a refused native call retires.

Four constructor calls now supply explicit subscription storage; a restored-target assertion requires the advanced occupation generation while comparing all other original fields.

Queued mutation admission and any-close lock-policy coordination must precede overlap; a blocking lock must not retain a fence that deadlocks Close, and an uncertain old Close must not release newly acquired process locks. Path-anchor/socket-path reservation lifetimes, invocation-owned masks and fair all-call intake/terminal drain remain unfinished. Complete native thread/TLS semantics, libc frontends and imported consumers remain required. All eight whole socket criteria stay unchecked. Both complete EriX guest generations and the external Rust/LLVM guest rebuild remain mandatory and unperformed.

Original candidate cursor arbitration — 3 October 2026

An alias, copied key or reused fd cannot release another call's barrier.

Fixed results and completion refusal cannot replay the operation.

The candidate fixture exercises actual file admission and local Seek effects while refusing native provider execution.

Exact descriptor target/replacement-source conflicts, any-close lock-policy coordination, per-call masks and fair overlapping intake remain unfinished. Path-anchor and socket-path reservations require continued lifetime audit. All eight whole socket criteria remain unchecked; both complete EriX guest generations and the external Rust/LLVM guest rebuild remain mandatory and unperformed.

Ordinary call source holds — 3 October 2026

A resumed call with a missing or mismatched token rejects instead of looking up a reused fd. Call and readiness holds share checked accounting and final candidate/stream/socket/queue disposal; final hold release never repeats any-close process-lock policy.

Refusal, cancellation and authenticated termination preserve that original token. Target-generated invocation geometry includes the actual hold; no new grant, hidden fd or implicit allocation is introduced.

Shared-cursor arbitration, exact descriptor target/replacement-source conflicts, any-close lock-policy coordination, per-call masks and fair overlapping intake remain unfinished. Path-anchor and socket-path reservations require continued lifetime audit. All eight whole socket criteria remain unchecked; both complete EriX guest generations and the external Rust/LLVM guest rebuild remain mandatory and unperformed.

Original readiness holds — 3 October 2026

No additional native grant, implicit allocation or payload identity is introduced.

It never repeats any-close process-lock release.

Per-description cursor arbitration, call-owned masks, fair overlapping intake, complete libc frontends, native thread/TLS semantics and imported consumers remain unfinished. The whole socket issue retains all eight unchecked acceptance criteria. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Counted invocation storage — 3 October 2026

Retained request/result regions scale with explicit invocation capacity, and enabled header replies require 240 bytes.

Stale generations, cross-client selection and reuse with outstanding native custody remain refused.

Safe overlapping intake remains unfinished: original description holds must survive fd close/reuse; final disposal must wait for all holders; shared cursor operations need description-level arbitration; temporary masks and handoffs must remain call-owned. Complete libc frontends, native thread/TLS semantics and imported consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding within EriX remain required and unperformed. No whole socket acceptance credit is added.

Named stream implementation — 2 October 2026

No pathname, fd number or copied identity supplies authority.

Refused client or accept completion disposes only its original
endpoint.

The native binding workload adds scoped named connections, empty accept,
duplex traffic, listener close, EOF, explicit unlink and read-only-scope denial.

Concurrent calls per process, complete libc frontends and imported-tool closure
remain unfinished. The complete socket issue remains open; no artificial checklist
credit is added. Both full EriX guest generations and external Rust/LLVM rebuilding
inside EriX remain required and unperformed.

Original socket admission implementation — 2 October 2026

Both require the actual native write ceiling.

FAT refuses because the selected catalog cannot represent socket objects. The exact descriptive identity is usable only beside independently admitted
original pins in the same realm; it is never a route selector or capability.

Nine new independent controls cover wire framing/atomic refusal, native purpose
and ceiling enforcement, read-only-media communication, stale/uncertain replies,
original cleanup and no-mutation provider behavior.

Scoped compatibility bind/listen/connect/accept, counted backlog and concurrent
calls, libc frontends and imported-tool closure remain unfinished. The complete
socket issue stays open; no checklist acceptance credit is added. Both full EriX
guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory
and unperformed.

Counted socket lifecycle implementation — 2 October 2026

Native COMPLETE acceptance controls publication. Refusal cancels only the
original reservation while the enclosing serving owner remains retained.

No endpoint, native grant, route,
uncounted allocation or unsafe code is added.

Six new runtime controls are authored and unrun: original unconnected publication
with occupied transport, no-peer I/O/shutdown refusal, alias/shared option lifetime,
refused native publication with another client, terminal alias cleanup beside
another client's live pair, and stale connected queue generation refusal.

The whole socket requirement stays open: scoped bind/listen/connect/accept,
original listener identity and permission admission, counted backlog and concurrent
calls, full libc frontends and imported-tool closure remain unfinished. Both full EriX guest generations and external
Rust/LLVM rebuilding inside EriX remain required and unperformed.

No executed pass, warning-free build,
full-socket acceptance or measured performance improvement is claimed.

Atomic socket namespace implementation — 2 October 2026

Explicit socket intent is separate from regular-file
access; successful replies must match the original key and requested kind. FAT refuses
socket intent before effects under its current catalog representation.

The same whole socket requirement remains open: Posixd bind/listen/connect/accept,
independently admitted listener identity, counted backlog and concurrent calls,
full libc frontends and imported-tool closure still require implementation. Both full EriX guest generations
and rebuilding external Rust/LLVM inside EriX remain required and unperformed.

Anonymous duplex socket implementation — 2 October 2026

Two fd/description reservations and two queues publish atomically only after native completion acceptance.

The implementation retains original pair custody through refusal, cancellation and terminal loss, scrubs both queues before reuse, reports actual Socket metadata without invented creator/time observations, and refuses unbudgeted send-buffer growth. No provider, networking, discovery or host-control authority is added.

The new realm-sockets group selects those existing VM scenarios without changing grants, queue backing, process budgets or exit criteria.

Scoped pathname bind/listen/connect/accept remains required by the original workload matrix. Named listener/connection lifetime, complete socket adapters and imported-tool interface closure remain open. The owning feature stays open with all eight full-scope criteria unchecked; anonymous pairs alone do not satisfy it.

Overall progress remains 21.04% weighted, 9.61% whole-item acceptance, 32/460 parents and 493/953 sub-items across 166 decomposed parents. No artificial substep or acceptance credit was added. Both full EriX guest generations and rebuilding external Rust/LLVM inside EriX remain required and unperformed.

Required local stream socket scope — 2 October 2026

The local stream socket requirement now has a concrete feature design and source-bound workload matrix. Six original source identities at Integration revision 2002ef2aca1ca38ed36ad66d5d5783deae2dc5f9 identify three maintained unit commands and their required operations. Both anonymous pairs and scoped pathname listeners are needed; socketpair alone would not cover those consumers.

The owned requirements include nonblocking send/receive, backpressure/select, actual timeouts, send-buffer capacity, directional shutdown, peer EOF and original cleanup. The contract distinguishes synthetic local unit peers from host QMP/COM1 endpoints. Neither a source file, socket name nor copied peer identity grants a guest authority. Complete upstream tool versions, recipe options and transitive interface requirements remain explicit gaps.

The documented implementation order is coordinated duplex descriptions and pair publication; directional I/O, options, shutdown and alias retirement; scoped bind/listen/connect/accept with original object and backlog custody; readiness/deadline/interruption; independent and native controls; then coherent ABI adoption. Socket implementation remains open with all eight feature criteria unchecked. No new partial checklist item or acceptance credit is added.

Five signed commits across four repositories publish the requirements, component contracts and manual while preserving the coherent immutable source graph. The checkpoint changes fourteen paths and no executable code. All 269 compiled edges and 162 catalog selectors remain coherent, with Rootd's independent Integration helper preserved. All 153 same-repository PR guards in 76 workflows remain intact. All feature trees are clean except the preserved unrelated Meta cache.

Overall progress remains 21.04% weighted, 9.61% whole-item acceptance, 32/460 parents and 493/953 sub-items.

Atomic filesystem ownership for pathname sockets — 2 October 2026

The pathname implementation will extend the existing conditional creation request
with explicit FsCreationIntentV1: regular-file access keeps wire values 1–3;
value 4 creates a socket binding without file-content access. Prefix sizes and
operation IDs stay unchanged. Older decoders reject the new intent. Success must
match the requested kind, empty size and original correlation/key; no ordinary
pin reply or regular-file result can satisfy a socket creation request.

Vfsd retains the original provider acquisition before submission and records a
socket binding separately from file admission. RAM and Ext creation reserve the
original pin before namespace effects and return the committed socket identity
inside the same operation. Neither a second path lookup nor a copied object ID
can substitute for that owner. Existing metadata, mask/default ACL, parent
freshness, namespace replay fencing and uncertain-effect custody still apply.
FAT's regular-file creation path must explicitly refuse the socket intent before
namespace effects until its persistent metadata format supports socket objects.
No provider may create a regular file and report it as a socket.

Unlink detaches the original name while a live pin keeps the original socket
object distinct from a replacement. Retirement releases that pin, not the
namespace entry. A later Posixd binding will retain this owner for its lifetime;
connect still needs independently scoped original-object permission admission,
listener identity, counted backlog and pending-connection custody. Native
creation alone does not complete bind/listen/connect/accept or threaded consumers.
Independent wire, provider and VFS controls will cover kind substitution,
capacity/permission refusal, unlink/replacement, reply loss and exact retirement.
Tests, builds and CI observation remain deferred; none is claimed to have passed.

Counted socket descriptor lifecycle — 2 October 2026

Listening
and pending-connection ownership must remain counted independently of published
accepted descriptors.

Creation uses the original
fd/description and configured byte-storage budgets; native COMPLETE acceptance
controls publication. Unconnected read/write/shutdown returns ENOTCONN and cannot
invent EOF or peer authority.

Scoped connection must admit its independently selected original object
and permission revision. Final close and terminal retirement must settle both
native binding custody and local queue/backlog owners before reuse. The full
socket feature remains open; tests and CI observation remain deferred.

Creation-response regression repair — 2 October 2026

Socket intent cannot become regular-file access.

Component status documents record
the repair; unchanged runtime/API behavior requires no new manual contract.

Whole socket completion remains open: scoped named
connections, original admission, counted backlog and concurrent calls still need
implementation. Full EriX and external Rust/LLVM guest rebuilding remain required
and unperformed. No checklist acceptance credit is added for this repair.

Original socket identity admission — 2 October 2026

Add a distinct scoped native socket admission operation. It selects only the
original acquisition candidate beneath the actual retained scope; it accepts no
path, provider route, object identity or substitute root. Binding identity can be
published only from a socket pin created by that original scope. Connect admission
requires a fresh acquired socket, the original scope's native write ceiling and
complete current permission evidence. Existing metadata/ACL queries supply facts;
the mediator must evaluate socket write permission before final admission. The
provider compares the same retained candidate's fresh revision without file I/O,
truncation, timestamp mutation or a writable-media requirement. Binding creation
continues to require original writable parent and mount admission.

Use VFS operation 0x71f with a 32-byte request (correlation, original candidate,
permission revision, Binding/Connect purpose, reserved zero) and a 56-byte result
(correlation, original candidate, known result, provider kind, 32-byte original
object identity). Binding uses revision zero and only the originally created
SocketBinding state; Connect uses a positive fresh revision and only Fresh state.
Advance original admission before any provider call. An uncertain/refused call
cannot publish identity, gain file content rights, or replay under another key.
Successful binding and connect states remain separate from Live file access and
retain original-key cleanup. The private provider operation 0x720 has a 24-byte
request with correlation, retained handle and positive revision; its result uses
the existing exact status framing with original operation/correlation checks.

Returned identity is descriptive association, not a capability. Posixd may compare
it only while it retains both independently admitted original pins in the same
realm. No global pathname registry or copied credential grants communication.
Provider identity must remain stable while that actual pin lives; unlink and
replacement cannot retarget it. RAM and Ext compare original root/lifetime/kind
and fresh permission revision. FAT cannot represent socket objects and refuses
this admission without filesystem effects. Old peers refuse the new operation.

Continue the full named socket implementation after this boundary: bind custody,
listen/backlog, original connect and accepted endpoints, concurrent calls and
required workloads. Full socket acceptance and guest rebuild requirements remain
open. Source controls will cover wrong purpose/kind/key, stale permissions, native
ceilings, read-only media, lost/malformed results, cleanup and identity reuse.
Tests, builds, lint and CI observation remain deferred.

Named socket custody and compatibility operations — 2 October 2026

Implement scoped bind/listen/connect/accept over the original socket description,
without allocating a hidden application descriptor for an incoming connection.
Compatibility 1.25 assigns Bind=44, Listen=45, Connect=46 and Accept=47. Bind and
Connect carry one existing socket fd, an explicit relative directory base and
counted raw pathname. Listen carries the existing fd and full-width requested
backlog. Accept carries the existing listener fd plus explicit new descriptor
and nonblocking flags; success returns one newly reserved fd. Binding and
connection require the original scoped native operations already implemented.
Names and copied object identities cannot supply authority or choose a route.

The existing counted socket description owns every native binding/peer pin and
local queue reference. Bind reserves its original local fd occupation before
native traversal; the namespace object is created under fresh parent write/search
policy and the process mask, then admitted as Binding using the original native
candidate. The original caller and every temporary walk pin retire independently.
Only accepted serving completion moves the binding into the socket description.
Refused publication retires that original native pin before releasing the local
reservation; it never unlinks a committed name or removes a replacement.

Connect applies full original pathname search and final socket-write DAC, then
uses fresh native Connect admission. Listener association requires independently
admitted live original pins in this same admitted realm. The connection owns
original counted queue generations. Incoming backlog ownership consumes counted
storage, never an accepted application fd; actual Accept allocates and publishes
that fd. Requested capacity is bounded only by actual admitted storage, with
correlated exhaustion instead of hidden fixed limits. Closing a listener drains
its original pending connections independently from accepted endpoints.

Native pin and local queue disposal compose for final close, descriptor replacement
and terminal cleanup. A nonfinal alias cannot dispose either resource. Uncertain
native cleanup keeps the same original description, queue and serving owner;
positive pin retirement precedes final local disposal and row reuse. Retained
operation reservations cannot acquire authority through recycled fd numbers.

Preserve readiness, shutdown, signals, deadlines and cancellation. Concurrent
calls require counted original invocation state; the current one-delivery client
row is a remaining part of this whole feature. Add independent wire, serving,
provider-lifetime and native workload controls. Tests, builds, lint and CI
observation remain deferred. Full socket acceptance, imported-tool closure and
both EriX and external Rust/LLVM guest rebuilding remain open.

Concurrent invocation and readiness ownership — 2 October 2026

Complete same-process concurrency under the existing whole local-stream requirement.
A process receiver and its immutable native origin remain one original authority;
multiple independently owned serving invocations must have separate counted rows,
request/result bytes, wait state and publication/cleanup state. No caller-provided
thread label or copied process number will authenticate an invocation or grant a
new endpoint. The actual CLAIM origin and original nonzero serving owner remain
the admission boundary.

Add explicit invocation and readiness-subscription capacities to the immutable
realm counts. The target-generated arena descriptor gains actual InvocationSlot
and ReadinessSlot size/alignment pairs; loader authentication, exact layout digest
and target/runtime equality precede typed borrowing. Introduce layout version 5,
160 bytes; remove the superseded version-4 API. Configuration RCF1 and pull RCP1 minor
7 has a 136-byte header with invocation capacity at 120 and readiness capacity at
128. Startup RBS1 minor 5 has a 264-byte header with capacities at 248 and 256.
The corresponding counted provisioning and layout-binding frames expand exactly;
old frames fail closed. Retained request/result regions scale with invocation
capacity, independently of process count. Propagate these counts through actual
Launchd/Procd provisioning, image and client configuration without implicit defaults
inside the consumer or uncounted fallback allocation.

Reserve storage before every CLAIM. Each configured process has one guaranteed
base invocation row, with additional explicitly admitted rows shared by fair
intake. No caller can consume another process's base reservation. A full budget
applies native backpressure without claiming an owner that cannot be retained.
Original receiver registration/watch remains process-owned. Schedule original
active calls independently; a sleeping read, connect, accept or poll cannot prevent
another admitted call from the same process making progress. Nonwrapping call-row
generations bind internal associations; request IDs remain descriptive correlation.

Move readiness subscriptions out of descriptor bindings into separately counted
original-call rows. Different calls watching the same fd must never merge their
native query owners, linked lists, temporary masks or output positions. Within one
call, duplicate poll positions may share one original subscription. Subscription
and byte-operation lifetime holds retain the original shared description through
fd close/reuse. Close removes only its fd occupation; final backend disposal waits
for every original alias, call hold and native cleanup owner. Shared file cursor
effects need original description arbitration; positioned I/O must not silently
change the shared cursor. Any-close process-lock semantics remain intact.

Replace process-wide descriptor-mutation exclusion with conflict handling for the
actual original occupation/description. Waiting calls cannot select a recycled fd
or freeze unrelated descriptors. Cancellation, ambiguous results, deadline/mask
restoration, accepted publication and authenticated process teardown all keep
separate original owners until independently confirmed disposal. Process teardown
stops intake first, drains every invocation/subscription/publication, and only then
retires descriptors, scope pins, receiver watches and receiver authority.

Keep process policy separate from invocation state. Readiness temporary masks and
selected handoff belong to their original call; they cannot overwrite another
call's state. Full native thread lifecycle, per-thread signal/TLS semantics and libc
integration remain explicit requirements alongside concurrent invocation serving.
Author native same-process overlapping-call workloads and independent capacity,
fd-reuse, cancellation, cursor, signal and teardown controls. Tests, builds, lint,
VM/profiler execution and CI observation remain deferred; no execution result is
claimed. Whole socket acceptance and full EriX/external Rust/LLVM guest rebuilds
remain open.

Signed current revision: 9ae22041.

Original process-close continuation contract — 4 October 2026

Before overlapping mediator intake, replace blind uncertain process release with one original keyed native cleanup intent. Reuse the existing fixed-width candidate-lock request and existing scope-local monotonic continuation domain. Nonzero-key ReleaseProcess prepares whole-object process cleanup with kind absent and report PID zero; Ready leaves published intervals unchanged. Exact Commit publishes once. Retain a counted, grant-free committed receipt through caller loss and repeated exact requests; Cancel with that cleanup shape acknowledges the receipt without releasing locks. Ordinary acquisition Cancel retains its rollback meaning. Original scope/candidate/key and full request echo must correlate every stage.

Pending cleanup retains the original noncopy provider-pin use and actual object/process-owner dependency. It fences only related mutations, not queries, reads, independent objects or description owners. Close cancels older acquisition waits before queueing its original cleanup; it must not wait behind an external lock holder. Refused readiness or Commit retains the original intent for exact continuation; it cannot create a fresh release. Pin disposal preserves historical identity and cannot rebind cleanup to a newer object. Whole-scope teardown disposes its own retained histories. Admission failure and fenced absence must have explicit effect-free outcomes, distinct from semantic completion. Posixd issues the key in its first actual submission turn, retains original caller/descriptor-change custody through ambiguity and application cancellation, and retires the final candidate only after positive semantic confirmation and receipt acknowledgment.

Implement producer, consumer, actual storage/layout, independent failure controls and documentation together, with coherent signed immutable adoption. Do not add an object-identity metadata RPC, per-process activity exclusion, copied grant, payload thread authority, allocator or arbitrary capacity. Same-process mediator overlap, per-call native origin/masks/TLS, complete socket consumers and native workloads remain required. Tests and CI observation remain deferred; this section records the implementation contract, not completion or execution evidence.

Earlier keyed process-close source checkpoint — 4 October 2026

Fixed request/response widths and native authority ceilings remain intact; older peers reject the extended cleanup shapes, so producers and consumers adopt coherently.

Refused readiness or Commit rolls back the original journal and moves the same noncopy provider-pin use out of its retired native call, preserving the original key/object/process owner/ticket. Actual storage refusal precedes effects, pin retention and key burn.

Repeated exact cleanup or Commit cannot release newer locks. No copied grant, object-identity metadata RPC, payload thread authority, allocator or arbitrary coordinator cap is introduced.

They cover refused Ready/Commit and rollback, narrow owner dependencies, old Wait cancellation, newer locks preserved across historical retries, premature/mismatched acknowledgment, original pin/scope history disposal, actual counted admission refusal, malformed Commit lookup, malformed acknowledgment and application abandonment.

Same-process mediator overlap, authenticated native per-call origin/source holds, per-call masks/TLS, full socket/native workload and libc/imported consumer closure remain unfinished. Native caller retirement cannot prove semantic cleanup. The whole socket requirement remains open; both complete EriX guest generations and external Rust/LLVM guest rebuilding remain mandatory and unperformed.

Completed implementation source is marked under the waiver; missing implementation remains open.

Native-serving acceptance remains five of eight: its coordinator criterion also requires real Close intake behind blocking Wait, which remains unfinished; fd/process coordination and complete same-process VM workload sources also remain open. No full-feature acceptance is inferred from authored controls or waived execution.

Counted mediator intake and original-call progress

Reserve an actual invocation row, its nonwrapping generation and its original receiver/client association before every native CLAIM. Retain a returned owner before interpreting status. Empty native intake releases only the uncommitted reservation; actual capacity refusal performs no CLAIM. The shared counted pool admits independent calls from the same authenticated native TCB/generation without duplicating receiver grants or process policy.

An intrusive original-call roster gives every retained owner a fair progress turn, independently of receiver intake. Every association and roster link includes the original row generation. Request/result regions and wake stamps belong to individual calls; receiver parking cannot consume their wake observations. Receiver/watch, descriptor, provider-pin and scope disposal wait for every original call, including refused completion and source cleanup. Result inspection names the original owner explicitly rather than guessing one call for a process.

Each readiness call retains its own noncopy temporary-mask observation. Installing or discarding it must not overwrite another call's mask or a later permanent mask change. A selected caught occurrence is consumed once and remains reserved for SignalTake; it cannot interrupt another call or be overwritten by another selection. Cancellation and uncertain handoff preserve the original native owners and terminal policy. These changes do not authenticate payload thread identifiers. Native shared-process thread membership, distinct per-thread masks/TLS and complete consumer adoption remain required; asynchronous calls from the current one-TCB execution identity do not satisfy that boundary.

Author independent native-owner controls for overlapping waits/intake, capacity refusal, origin mismatch, original result isolation, cancellation, receiver lifetime and signal selection. Testing and CI execution remain deferred under the active instruction; source implementation does not claim runtime validation.

Original mediator calls and source acceptance — 4 October 2026

Terminal retirement drains every call, including refused completion and source cleanup, before descriptor, provider, scope, watch or receiver disposal.

Their original target occupation and sole prospective duplicate source survive fd reuse; stale targets refuse without changing a new binding. Original receipt retries cannot release newer locks.

Cancellation cannot overwrite another call or a later permanent mask. Signal selection consumes one actual occurrence and reserves it exclusively for Take; another call cannot reuse it.

These sources introduce no additional endpoint, grant or hidden fd.

Authentic native shared-process thread membership, shared process actions with distinct per-thread masks/TLS, libc/imported consumer closure and profiling measurements remain open. Payload thread identifiers and duplicated client rows cannot satisfy that boundary. Full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.

Source acceptance follows the active waiver; missing implementation remains open.

Native-serving source acceptance is complete with all eight design criteria. Duplex semantics, scoped named lifecycle, independent controls/native workload sources and maintained socket documentation are source-accepted in the broader socket design; its complete ABI/consumer matrix, complete signal/runtime integration and whole source/performance closure remain open. The phase socket checklist has fourteen children, seven checked, while its parent remains open.

Native process/thread ownership specification — 4 October 2026

The complete ownership specification defines one original process with shared CSpace/VSpace, capability/fd/action/cwd/creation-mask policy and distinct authenticated native execution occupations. An explicitly sealed original-process factory and retained thread handles authorize Prepare/Start and cleanup; clients gain no global Process route, root or MAP grant. The actual original creator and counted enrollment precede Start. Native membership and caller origin never come from payload labels or copied ClientSlot policy.

The contract separates thread-only exit from process exit. Initial-thread departure preserves peers and shared resources. Last-thread preparation serializes creation/Start, settles potentially startable original members and retains the final context for process finalization. Whole-group retirement drains every original member/provider before shared authority reclamation and emits one process event. Join/detach arbitrate one original target, preserve joinability on cancelled uncommitted joins and reconcile committed disposition through reply loss without affecting a replacement generation.

Stack/guard, caller-owned storage, TLS/errno/module/destructor and complete architecture state have explicit original lifetime and reclamation boundaries. Current OIR1's 64-byte header uses bytes 56–63 for terminal status; the proposed versioned OIR2 extent is 72 bytes, adding thread identity/generation at 64–71. No runtime ABI/codec is changed by this specification. Mediator process policy remains shared while real enrolled threads own distinct masks/handlers. Fork/exec, native provisioning, target geometry, memory/loader/linker/libc and real workload adoption are coordinated requirements.

Integration's native lifecycle contract records independent actual membership, blocked-peer progress, initial/last exit, TLS/context, guards, join/detach, failure/reuse, group loss, profiling and tool-consumer evidence. The imported-tool source/version/options and transitive interface matrix remains unresolved. Current one-TCB asynchronous calls do not implement native shared-process threads.

Specification acceptance completes the ownership specification only. Native process/member/factory/origin mechanisms, thread-only exit, join/detach, per-thread TLS, libc/imported consumers and real profiling remain open. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.

Three signed commits across Kernel, Docs and Integration publish 17 paths: 14 maintained documentation sources and three catalog files containing four selector updates. No runtime or Cargo source changes; no Rustfmt inputs. Read-only source/Git inventory records all 269 compiled edges and 162 catalog selections coherent, 4,346 code files below 1,000 lines, retained missing-docs gates, and 153 guards across 76 workflows. All 76 feature trees are clean except preserved Meta cache. Rootd and helper catalog entries retain independent compiled helper cc878220040dfa741491249434d6b8f8fe2252f7.

Signed documentation/adoption: docs af376f65, integration 5daf30c3, kernel 9660dacf.

Tracking: ownership specification, native implementation, socket consumers, libc, compatibility ELF/TLS, phase completion.

The complete ownership specification is source-accepted. Every native runtime, thread/TLS, imported consumer, profiling and guest-build implementation/evidence requirement retains its existing open scope.

Original process lifetime storage — 4 October 2026

Process-window observations consult the current owner; copied metadata cannot enroll another member or acquire authority.

Admission requires a reserved native identity and actual objects, reserves both publication directories before retaining backing, and publishes no half-owner on refusal.

Seven new controls are authored and unrun: sole window sealing/current observation, contradictory association refusal before hardware effects, copied-peer refusal without an extra backing reference, actual storage failure at both admission allocations, constructor cap-collision rollback, failed final release and generation reuse, and captured origin through actual cleanup/reuse. Invalid VSpaces now refuse at admission; initial-stack failure uses an unregistered high range in the real original VSpace.

Genuine member factories/enrollment, versioned thread origins, thread-only exit, departed-leader survival, join/detach, TLS and complete libc/upstream consumers remain required and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Rootless construction observes the sole actual ceiling, and malformed-window controls verify refusal without altering copied metadata.

Authenticated process and execution origins — 4 October 2026

CLAIM requires both complete keys; COLLECT requires neither. Old/partial/mixed origins refuse before native transfer/output effects.

Copied metadata and parsed bytes grant no authority, liveness or native attestation.

Posixd preserves full successful CLAIM origin in its original counted call record before interpretation and refuses unknown execution IDs or stale thread generations before request effects. Additional native members still require the open factory/enrollment implementation. Independent modeled controls preserve the denied original owner, empty refusal, unrelated pending peer and lease generation; only an enrolled writer can unblock that peer.

Genuine shared-process membership/factories, departed-leader survival, thread-only exit, join/detach, per-thread masks/TLS and full libc/imported-tool consumers remain required and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Original prepared native member custody — 4 October 2026

A noncopy process-bound Kernel factory requires actual held Process SEND of native Process kind in the Running caller's window plus an actual exact-stage GRANT install grant naming a Created initial process. The grant supplies target evidence, never Process authority; scope and rights remain unchanged. An explicit u64 total occupation budget includes the initial execution, and zero/exhausted capacity refuses.

Stale or exhausted factory admission refuses before prospective ID/global execution generation allocation. Native keys and factory serials never wrap. Parsed metadata, copied snapshots, ordinary endpoints, inert rights, foreign/stale targets and outside-window grants cannot authorize creation.

Factory release refuses until preparations withdraw, preserving the original view and quota. Old member/factory observations cannot dispose replacement occupations. Group terminal/cleanup freezes admission and preflights/drains original preparations before shared inventory effects; a refused final backing release retains the original process owner/reference and cleanup-only initial record for retry. Additional preparations cannot enter legacy initial Start/current-context/window/receiver/child/process mapping/write, install/revocation target, dynamic-link cleanup, CPU-time or process termination/destruction paths. Created native activity notifications have no effects.

Nine independent actual-object controls are authored and unrun: shared objects/window and total capacity; native authority negatives; legacy initial-path/copied-peer refusal; member/factory reuse; actual TCB/member allocation failure; dropped member views and final release failure; group terminality and one event; dropped factory retention; nonpristine refusal and exact cleanup retry.

No userspace factory capability/wire carrier or runnable member is published. Genuine Start/context, original stack/TLS, mediator enrollment, running-peer scheduling, thread-only exit, departed-leader survival, join/detach, whole-group CPU aggregation, per-thread masks and libc/imported consumers remain mandatory and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.

Checklist acceptance records source implementation under the testing waiver.

Retained original member mapping backing — 4 October 2026

Checked byte ranges carry access observations, no process selector or grant. The actual VSpace retains noncopy original reference records; a dropped view leaves native custody and cannot duplicate the same member continuation.

Unmap/remap of the same virtual or physical address cannot validate an old context. Old detached release has no hardware effect on a replacement VA. Live validation requires the same original occupation and current required/forbidden permissions; stored access never restores a withdrawn grant.

Positive release records each completed page and retains the same cleanup-only continuation through later managed-frame refusal. Last process backing release and final VSpace teardown refuse before effects while context/detached custody remains. Production initialization cannot erase retained contexts, process references or active roots.

Eight actual-object controls are authored and unrun: retained old backing and untouched remapped bytes; overlapping observations/multiple members/dropped views; malformed, borrowed and contradictory ranges; actual capture/detachment storage failures; permission attenuation and last managed backing release; completed-prefix refusal followed by native abort retry; dropped group context and refused last process reference; and mapping/context serial exhaustion.

The full native carrier/context/enrollment/Start issue stays OPEN with all eight complete-transaction criteria pending. Complete capability transfer/rollback/removal, original creator continuation, code/stack/guard/TLS/architecture, positive mediator enrollment, genuine once-only Start, all-running-member group stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Full thread lifecycle, departed-leader survival, thread-only exit, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Source completion of this prerequisite does not accept the unfinished initialized-running-member criterion.

Original native member carrier custody — 11 October 2026

Factory READ/MINT/MANAGE/GRANT and member READ/WRITE/EXECUTE/MANAGE/GRANT have separate observation, construction/context/Start, retirement and unique delegation meanings.

Publishers require the actual original source and Running custodian/window, reserve real metadata/native storage before consumption, and preserve the same noncopy source on refusal. Fabricated metadata, numerical targets, copied observations and old serials cannot construct or select native custody. One native stack lease preserves original storage through callbacks outside directory locks; busy owners cannot be erased or reused.

Unique delegation requires actual GRANT, active original scope and exact subset rights. Owned invocation intake authenticates source GRANT; private custody retains only the requested recipient mask plus the original GRANT needed for handoff. Final recipient masks/receipts remain exact, including zero; repeated collection cannot recreate a native object.

Factory admission freezes before refusal while members remain; metadata restoration cannot resume ordinary authority. Busy/refused cleanup retains the same original group, quota and remaining owners. Production reset refuses actual custody; host quiescent reset preserves carrier serials.

Fourteen independent actual-object controls are authored and unrun: fabricated metadata; actual publication/window/mask refusal; serial/slot reuse; unique attenuation and original rollback; READ-only local relocation; failed factory removal with actual admission frozen; remote group abort; busy original group refusal/retry; occupied/widened/inert moves; real destination allocation failure; allocation-free prepared transport commit/rollback; private owned request handoff versus final rights; returned unique collection/descriptive replay; and exact zero owned recipient rights.

The complete native capability/context/enrollment/Start design stays OPEN with all eight complete-transaction criteria pending. Full operation framing/native/user adapters, actual creator CLAIM and original counted enrollment intent/replay, original code/module/stack/guard/TLS/complete architecture, positive mediator enrollment, once-only genuine Start, all-running-member stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Thread-only exit, departed-leader survival, join/detach and complete compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Original claimed native preparation — 11 October 2026

Original claimed native preparation now requires actual held factory MINT and actual original successful Serving CLAIM under the same live registered receiver. Parsed origins, numerical identities and labels cannot construct the borrowed proof. The captured caller's process must equal the actual factory scope. Completion, replaced/removed RECV registration, original caller retirement, route loss or group freeze refuses before construction.

Changed intent refuses. Histories retain data only, with no extra backing/cap alias/process event; group disposal withdraws original remote custody before native identity/shared disposal.

They cover one genuine member/full-quota same-member and retired replay, changed intent/destination/rights/epoch, actual queued/completed/removed RECV refusal, foreign genuine creator, moved historical replay, actual continuation allocation refusal/retry, replaced receiver registration, foreign MINT plus equal RECV possession, fresh quota refusal before allocation, claimed member/group cleanup with one event, literal byte positions, every reserved byte and obsolete/partial/trailing/missing-selector frames.

The complete native control design stays OPEN with all eight full-transaction criteria pending. Full factory/member operation/native-user adapters, actual counted creator/enrollment intent, original code/module/stack/guard/TLS/complete architecture, positive enrollment, once-only genuine Start, all-running-member stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Complete thread lifecycle, departed-leader survival, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Immediate native preparation packet boundary — 11 October 2026

Already serialized admission avoids recursive lifecycle locking; hosted numeric addresses are never dereferenced.

Actual held factory MINT, original carrier scope/serial and live registered RECV for the same genuine outstanding Serving CLAIM remain mandatory. Creator/process attribution comes from the actual Kernel invocation owner, never payload labels. Every error preserves original intent and earlier custody; uncertainty cannot justify changed selectors or a successor.

Fourteen additional independent controls are authored and unrun: four literal/framing/identity/intent codec controls, four local-refusal/status/uncertainty bridge controls and six genuine native-packet/register/mapping controls. They cover replay across retired/replaced destinations, refusal before constructor/quota effects, absent genuine CLAIM, changed serial/wrong rights, exact zero rights, destination conflict, reserved registers and complete current writable mapping admission including gaps, revocation, stale VSpace and invalid addresses. Actual installed user instructions must check refusal and unchanged bytes before the original complete scenario oracle can pass.

Factory construction/provisioning, the complete operation surface, actual counted mediator row adoption and positive enrollment, original code/module/stack/guard/TLS/complete architecture, once-only Start, all-running-member stop/drain and real supervisor/loader/mediator provisioning remain required by the full native control design. All eight complete-transaction criteria stay OPEN. No whole running-thread acceptance is inferred from an unstarted packet boundary.

Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 sub-items under 167 decomposed parents. Full source acceptance remains independent of deferred execution.

Original native factory provisioning and READ — 11 October 2026

Original native factory control now exposes actual user factory creation/reconciliation at 0x5D and exact READ observations at 0x5E beside claimed preparation at 0x5C. Fresh creation independently needs actual held Process SEND and exact GRANT evidence for the original Created initial target. Carrier/CSpace/history storage reserve before publication; wrong own rights and zero/exhausted budget refuse before history allocation.

Indexed histories use Kernel-captured original current process/execution and the same operation key, never a payload actor. Complete original route/stage/destination/rights/budget intent reconciles the same factory after uncertain reply, setup-grant withdrawal, initial target Start, transfer, removal refusal or retirement. Changed parameters refuse. Held observations read current rights; transferred/retired descriptors are cleanup-only data and cannot recreate a cap, factory, identity or quota. A legitimate fresh key still requires independently held setup authority and an eligible Created target. Production reset refuses both live owners and retained histories.

TFC1 request64/TFR1 reply48 use one 112-byte creation packet; NTO1 request24/NTD1 reply48 use one 72-byte READ packet. Actual READ, current window, original serial and actual native indexed owner must agree; fake cap metadata or old serial cannot follow replacements.

Seventeen additional controls are authored and unrun: ten genuine native-object creation/READ/uncertainty/refusal controls, four independent literal codec controls and three checked bridge controls. They cover no-allocation same-original replay, changed parameters, grant withdrawal/initial Start, transfer/retirement/reuse, ordinary/weak/fabricated authority, actual allocation failure and occupied destinations, wrong rights/zero quota before storage, exact zero rights/full-width budgets, foreign actual execution, genuine factory/member/cleanup READ, reserved/partial/trailing frames, type-specific identity, original key/scope/budget/rights correlation, native status, uncertain output and local hosted refusal.

The maintained owned-invocation VM source adds 18 positive CPL3 calls for user creation/reconciliation, checked initial client Start after stage-grant disposal, genuine successful original CLAIM preparation/full-quota replay, actual factory/member READ, retired history, positive disposal and setup/carrier absence. Temporary Process SEND is removed before ordinary service work; only factory READ/MINT and member READ are retained for required operations. Hooks only observe original instructions/results, never perform effects or replace output. The new factory/preparation marker and original complete oracle require every new witness/user check.

The complete native control design stays OPEN with all eight full-transaction criteria pending. Real supervisor/loader/mediator deployment, target-generated counted thread storage/adoption, original code/module/stack/guard/TLS/complete architecture, positive original enrollment, once-only member Start and all-running-member stop/drain remain required. Full thread-only exit, departed-leader survival, join/detach and compatibility consumers remain open.

Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress stays 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 sub-items under 167 decomposed parents. Full source acceptance remains independent of deferred execution.

Counted startup tail repair — 11 October 2026

No old/trailing/partial/overwritten-tail fallback or new authority is added.

A disabled literal image requires zero count words and rejects obsolete overwritten-tail bytes. The maintained realm-startup VM source preserves its full oracle for two actual private mediators, authenticated readiness, peer-independent retirement/stale-handle refusal and ordinary successful shell exit. Its description now names the same canonical framing; no acceptance or marker is relaxed.

Bug source acceptance closes after complete repair, authored controls, documentation and coherent signed adoption, independently of deferred testing. The full native control design stays OPEN with all eight complete-transaction criteria pending. Actual counted thread storage/adoption, complete code/module/stack/guard/TLS/architecture, positive original enrollment, once-only member Start, all-running-member drain and real supervisor/loader/mediator deployment remain required. Full thread exit, departed-leader survival, join/detach and compatibility consumers remain open.

Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred execution.

Counted original execution storage — 11 October 2026

Older schemas/widths reject without aliases, inferred counts or fallback.

Public payload IDs, matching process labels or spare capacity cannot enroll another execution. Unknown/stale/unsealed/failed/native-draining delivery retains its ordinary native custody and refusal obligations. This introduces no extra receiver, process capability, member enrollment or runnable context.

Eleven additional execution/arena controls are authored and unrun: empty-capacity refusal, all-original-key admission, retirement/reconstruction prevention, incomplete identity atomicity, missing/previously occupied engine capacity, canonical row association, successful CLAIM/completion/retirement, errored CLAIM custody, spare-row unknown/stale refusal, real target ThreadSlot geometry/disjoint extents and independent grown geometry.

Two spare execution rows remain inert while the full existing oracle still requires two actual private mediators, authenticated readiness, independent peer retirement, stale-handle refusal and ordinary successful shell exit.

The full native member control and Start design remains OPEN with all eight original complete-transaction criteria pending. Additional prepared members, current original code/module/stack/guard/TLS and complete architecture state, positive original enrollment, once-only Start and all-running-member stop/drain remain required. Per-thread masks/TLS, thread exit, departed-leader survival, join/detach and all required compatibility consumers remain open.

Read-only source inventories record all 4,387 code files below1,000 lines, missing_docs denial at all 98 Cargo crate roots, and153 duplicate PR guards across76 workflows.

Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred execution.

Original complete member memory custody — 11 October 2026

Stack/TLS/code geometry and module/guard contradictions refuse before native reference publication.

Caller-slice mutation or dropped views cannot forget these conditions. Another original complete memory recipe cannot alias retained stack/TLS bytes until positive same-reference release.

Positive original release retains completed prefixes and refused native cleanup.

Nine independent actual-object controls are authored/unrun: complete original recipe and dropped-view custody, current guard mapping/copied condition ownership, malformed/overlapping/missing geometry, distinct-member exclusive stack/TLS, all capture allocation refusals, original TLS replacement/new-byte preservation, every user-visible guard inventory, current role/module contradictions, and frozen-scope positive cleanup. Existing native VM oracles retain their complete acceptance; this trusted Kernel API introduces no guest context operation or runnable member.

The full native member context/enrollment/Start design stays OPEN with all eight original complete criteria pending. Strict native context/user adapters and replay, real supervisor/loader/mediator adoption, all-running-member stop/drain, thread exit, departed-leader survival, join/detach and required compatibility consumers remain mandatory. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.

Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction is still unimplemented.

Original native machine custody and entry ABI — 11 October 2026

Private noncopy aligned images follow genuine execution and process generations through allocation refusal, dropped views, positive cleanup and ID reuse.

Hosted model images never provide privileged transfer or native execution proof.

Thirteen independent unit controls are authored/unrun: eight geometry/storage/default/refusal controls and five actual-object allocation/replay/TLS-change/identity-reuse/drop/host-transfer controls. The additional NATIVE_MACHINE_STATE_OK marker requires every existing full native oracle and user check.

The full native member context/enrollment/Start design stays OPEN with all eight original complete criteria pending. Full running-member drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread exit, departed-leader survival, join/detach and required compatibility consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.

Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.

Original native state reconciliation preflight — 11 October 2026

Existing private storage cannot bypass this admission. An additional original-object control covers missing-baseline allocation refusal, unchanged Created identity/image, same-original Start retry and allocation-free unchanged fully prepared replay; it is authored and unrun. Private noncopy aligned images follow genuine execution and process generations through allocation refusal, dropped views, positive cleanup and ID reuse.

Hosted model images never provide privileged transfer or native execution proof.

Fourteen independent unit controls are authored/unrun: eight geometry/storage/default/refusal controls and six actual-object allocation/replay/TLS-change/identity-reuse/drop/host-transfer controls. The additional NATIVE_MACHINE_STATE_OK marker requires every existing full native oracle and user check.

The full native member context/enrollment/Start design stays OPEN with all eight original complete criteria pending. Full running-member drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread exit, departed-leader survival, join/detach and required compatibility consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.

Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.

Retained initialized native context — 11 October 2026

Actual current CPU policy, private initialized FS/FP/vector state and independent processor baseline remain mandatory.

Remapping cannot substitute backing between validation and effects. Write refusal retains the native pending record, original machine/reference custody and immutable input/completed-prefix progress. Same input retries without another context occupation or allocation; changed arguments/TLS/geometry refuses.

Ordinary original memory-reference release refuses while that context depends on it. A retired serial cannot erase a later context on the same unstarted member.

Eleven actual-object controls are authored/unrun: exact initialized bytes/private GPR defaults, full-quota allocation-free replay and changed input, allocation refusal before effects with exact retry, input extent/initial-stack ABI refusal, cross-member memory denial, dependent release/stale same-member refusal, dropped views/member cleanup, frozen cleanup, original TLS replacement with untouched new bytes, whole-group disposal and actual page-write refusal with immutable pending input/completed-prefix retry.

The full native member context/enrollment/Start design remains OPEN with all eight original complete criteria pending. Positive mediator enrollment, once-only Start, running-group drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread lifecycle and required consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.

Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.

Original independently usable native state — 11 October 2026

Original PKRU is retained with the same noncopy FS/GS/feature-disable owner, initialized Kernel zero precedes scoped dispatch and selected-original return restores exact state with the required register inputs and compiler memory boundary. Actual instruction availability cannot silently narrow the preserved state. Current profile changes refuse old-image admission. Ordinary images enable no hardware, allocate no protection keys and change no native mapped authority through this boundary.

The separately selected native diagnostic requires actual PKU/XSAVE support and owns isolated BSP CPU configuration before any original native execution. Three original CPL3 participants require initialized zero and distinct PKRU values across every native return, handoff, blocking and hardware deadline wake. Privileged dispatch independently observes actual zero and unmanaged components1/9; hooks supply no register effects.

Native deadlines/stall/exit and ordered/unique marker acceptance stay intact. One independent descriptor/default/host-refusal control, strict scenario/direct-builder selection controls and the actual native diagnostic are authored and unrun.

The full native member context/enrollment/Start design remains OPEN with all eight complete criteria pending. Strict actual member-WRITE user context/creator/intent/caller-copy controls, positive mediator enrollment, once-only Start, running-group drain and real supervisor/loader/mediator deployment remain mandatory. Required thread lifecycle/consumers and both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.

Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.

Original counted member context — 11 October 2026

Unknown roles, malformed input and dirty reply reservations refuse.

A noncopy member continuation retains immutable original input and genuine memory/context views through refusal. Exact replay uses the same original occupation; changed intent, a withdrawn ready view or replaced backing cannot recreate a context.

A separate packet page preserves original unmapped-gap refusals. Both maintained positive scenarios keep every complete factory/machine/invocation/protection-key oracle and additionally require NATIVE_MEMBER_CONTEXT_OK. Hooks supply no context effect.

The full native context/enrollment/Start design remains OPEN with all eight complete criteria pending. Positive original mediator enrollment, revalidated once-only member Start, running-group drain and actual supervisor/loader/mediator deployment remain mandatory. Required thread lifecycle/consumers, both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.

Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.

Positive original native enrollment — 11 October 2026

Actual current member WRITE, expected member/context serials, ready original context, active native scope and identical successful still-Serving creator CLAIM/row captured during preparation are independently required. Sealed noncopy admission borrows genuine member/context/native claim; scalar labels and descriptive receipts cannot construct it.

Changed context/creator/row, stale current authority or closed/replaced claim refuses. Ordinary context withdrawal cannot erase positive enrollment.

It binds immutable member/context input before native enrollment, and requires exact output matching the earlier initialized process/thread observation before committing distinct-member intake.

Both complete CPL3 scenarios additionally require NATIVE_MEMBER_ENROLLMENT_OK: actual user instructions use returned member/context keys and successful CLAIM, check inaccessible spans/reserved fields/row refusal and exact replay, then positively dispose the same unstarted member. Hooks perform no effect; every original context/machine/protection/invocation oracle remains.

The full native context/enrollment/Start design stays OPEN with all eight complete criteria pending. Revalidated once-only Start, all-running-member drain, actual ordinary thread-creation/deployed supervisor/loader/mediator provisioning and required per-thread lifecycle/masks/ELF/TLS/consumers remain mandatory. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed.

Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished.

Original member Start and group retirement — 11 October 2026

Current actual member EXECUTE, original positive context/enrollment and counted row are independently required. Sealed noncopy admission borrows genuine native objects; process/thread IDs, creator delivery, saved pointers and copied receipts supply no authority.

Pager, child supervision and final CPU totals belong to the shared process; a running member may bind a child while its initial peer blocks through actual held GRANT.

Destruction refuses original active user/kernel intervals and runnable/blocked members before cleanup custody or remote/shared effects. Positive drain settles mappings, erases private context/machine/register storage and folds member CPU totals before identity reuse; refusal retains original custody and positive release progress.

Local acknowledged replay is a descriptive observation and performs no new native effect.

The separate kernel-running-members-positive scenario requires both original invocation and protection-key fixtures and preserves every existing factory/context/enrollment/machine/protection/invocation/activity/watch/deadline/terminal oracle, additionally requiring NATIVE_RUNNING_MEMBERS_OK.

The complete native context/enrollment/Start design remains OPEN with its original eight full criteria pending. Ordinary production creation/deployment, loader ELF/TLS construction, per-thread masks, join/detach, lifecycle and required consumers remain unfinished. Both full EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Complete native creation/deployment and required consumers remain unfinished.

Authenticated per-thread signal state design — 11 October 2026

Complete the native-member signal boundary alongside ordinary thread creation and deployed consumers. Shared process actions and controller-generated process pending state remain with the original configured process. Each counted original ThreadSlot retains its own effective mask, self-directed pending bits, selected caught occurrence and uncertain-handoff freeze. New members copy only the genuine creator thread mask at actual reservation, with empty task pending/selected state; exact reservation/enrollment/Start replay never resets it. No payload PID/thread label or copied native receipt selects signal authority.

Capture the admitted original counted row/generation and complete native CLAIM origin in each serving owner before interpreting compatibility operations. All later byte/provider/readiness interruption and temporary-mask selection/settlement use that same original task, refusing stale/replaced occupations. Thread-directed self generation never interrupts a peer; process-directed occurrences remain shared until one eligible original task selects them. Selection consumes exactly one occurrence; later generation and peer pending bits survive. Shared reset-hand actions commit once; Ignore discards unselected pending conditions across the original group. Temporary-mask tokens bind original task occupation and cannot settle through another member.

A failed/uncertain native caught handoff freezes only its original task while preserving native owner/result and shared process policy. Controller-default process termination and terminal retirement retain whole-process gates. Shared receiver/descriptor/clock/provider authority and counted storage remain unchanged; authenticated target-generated arena geometry includes actual row sizes. No fixed private thread/pending-count limit or new lookup/control capability is introduced.

Author multi-member mask/action/self-versus-process pending, creator inheritance, wait/selection/replay, short-result/uncertain publication and terminal retirement controls. Maintain existing complete VM oracles. Ordinary creation/deployment, ELF/TLS, join/detach, lifecycle, required consumers and full EriX/external Rust/LLVM guest rebuilding remain required. Tests/builds/lint/rendering/VM/profiler execution and CI observation remain deferred; this design does not claim runtime implementation or completion.

Specification references: POSIX thread creation and POSIX signal generation and delivery.

Original per-thread signal ownership — 11 October 2026

Payload IDs, handler labels and copied receipts supply no peer authority.

Shared actions remain one process policy: unavailable defaults preflight all task/process pending state, Ignore discards unselected group conditions, and reset-hand selection cannot overwrite a later shared action change.

Wrong-task or other settlement refusal preserves the original token; successful matching cancellation/selection is once-only. Selected occurrence stays with its task while another member's self signal cannot interrupt a peer wait. Refused/uncertain caught publication retains original native owner/result and freezes only its original task; eligible default termination and authentic terminal retirement retain whole-process duties.

Seven additional counted mediator/policy controls are authored and unrun for creator mask inheritance, shared actions, separate process/self consumption, peer-pending refusal and Ignore, task-only uncertain handoff, default eligibility, retained member readiness and wrong-task token refusal/retry/once-only settlement.

The complete native context/enrollment/Start design remains OPEN with its original eight full criteria pending. Normal production creation/deployment, ELF/TLS, join/detach, lifecycle and complete libc/native consumers remain unfinished. Both full EriX guest build generations and rebuilding external Rust/LLVM inside EriX remain mandatory and unperformed.

Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Complete native creation/deployment and required consumers remain unfinished.

Related records and contracts
Repository Links
blockd PR 2
coreutils PR 2
crashd PR 2
deviced PR 3
docs PR 4
drv-acpi PR 2
drv-i8042 PR 2
drv-ps2-keyboard PR 2
drv-ps2-mouse PR 2
drv-rtc-cmos PR 2
drv-serial PR 2
drv-virtio-block PR 2
dynlinkd PR 3
e2fsd PR 3
exsh PR 3
extop PR 2
fatd PR 3
fbcond PR 2
hotplugd PR 2
inputd PR 2
irqd PR 2
kernel issue 45, issue 46, PR 3, independent-machine-state.md, initialized-native-context.md, native-context-memory.md, native-machine-state.md, native-member-carriers.md, prepared-native-members.md, process-lifetime-storage.md, retained-member-mappings.md
keyd PR 2
launchd PR 2
lib-block PR 2
lib-bootstrap PR 2
lib-capabi PR 2
lib-driver PR 2
lib-input PR 2
lib-interrupt PR 2
lib-ipc issue 5, issue 6, PR 2, native-context-abi.md, native-enrollment-abi.md, native-preparation-abi.md, native-start-abi.md, owned-invocation-abi.md, socket-admission.md
lib-log PR 2
lib-posixabi PR 3, local-stream-sockets.md
lib-service PR 2
lib-stdio PR 2
lib-time PR 2
lib-tty PR 2
lib-vfs PR 2
loaderd PR 2
logd PR 4
memd PR 2
named PR 2
pagerd PR 2
posixd issue 35, issue 36, issue 37, issue 38, issue 39, local-stream-sockets.md, thread-signals.md, thread-storage.md
powerboxd PR 2
probed PR 2
procd PR 2
ramfsd PR 2
rootd PR 2
seriald PR 2
timed PR 2
ttyd PR 3
vfsd issue 29, PR 3
vspaced PR 2
## Problem and motivation The maintained Integration unit workloads use anonymous socket pairs and pathname-based local stream listeners/clients. Full guest validation requires these operations to execute over EriX ownership; substituting host sockets or treating a copied pathname as communication authority would not satisfy that requirement. At the start of this work, byte channels provided one-way FIFO descriptions without connected duplex socket objects, half-close or scoped local listener admission. The current implementation status is recorded below; the whole required scope remains open. Original consumers at Integration revision `2002ef2aca1ca38ed36ad66d5d5783deae2dc5f9` include `tests/fixture_socket_io_test.py`, `tests/fixture_startup_test.py` and `tests/interactive_shell_transport_test.py`, selected by the maintained CI commands. Their concrete requirements include socketpair, local bind/listen/connect/accept, nonblocking I/O, select, original timeouts, SO_SNDBUF, shutdown of one direction, peer EOF and exact cleanup. Host VM transport scripts are separate consumers; their presence does not authorize guest access to host QMP or COM1 endpoints. The external toolchain API/version matrix still needs completion and must not be inferred from these owned tests. ## Proposed behavior and scope Implement manifest-required local stream socket semantics through the client's original Posixd ingress and explicitly counted realm storage. Define connected duplex descriptions and independent read/write lifetime, atomic pair creation, required socket options and directional shutdown. Compose ordinary byte/vector I/O, original descriptor aliases, event-driven readiness and actual clock deadlines with those same descriptions. Implement required pathname local listener and connection semantics only through explicitly admitted directory scope and exact original socket/listener identity. A registry spelling, process ID, peer description or socket filename alone must not confer authority. Preserve original bind/listen/connect/accept reservations, backlog and accepted endpoint custody through publication, cancellation, loss and teardown. Specify required permissions and unlink/replacement behavior before native effects. Freeze a machine-readable source-backed workload matrix and distinguish required guest unit workloads, host VM transport helpers, optional upstream interfaces and unresolved imported-tool closure. Unsupported families, protocols, message modes, ancillary rights or options must return defined refusal without acquiring authority. No networking is introduced by local socket support. <details> <summary>Ordinary native thread creation</summary> The ordinary Posixd receiver will drive the existing prepare, context, enrollment and Start operations for a client's thread. The request describes its already mapped code, stack and TLS, counted modules and guards, and TLS image. It carries no factory, member, receiver, process or thread selector. The full request must fit the admitted storage before reserving a row or destination. The successful native CLAIM identifies the admitted client and creator. Their counted thread row retains the invocation generation, delivery owner, caller, inherited signal mask, request bytes, factory slot and serial, and prospective member destination before effects. The held factory authorizes MINT only within its original process. The mediator uses the resulting member's READ, WRITE and EXECUTE rights for setup, then reduces the held member to READ before completing the request; it grants none of these capabilities to the client. Kernel independently checks and retains the original mappings and backing generations through context creation and Start. Progress takes one native operation per fair turn: check the destination is empty, prepare the member, check its metadata and READ observation, initialize context, enroll, then Start once. Destination selection uses the inventoried capability window, excluding roots, bootstrap endpoints and all retained members and reservations. An occupied slot is neither adopted nor overwritten. Plan and storage capacities determine the limits. A packed context bridge will validate the complete canonical context packet in caller-supplied scratch. It uses the existing syscall ABI, checks unchanged request bytes and the full correlated reply, and avoids unsafe slice casts or temporary tables. Native selectors come from the held member and current CLAIM, not the client's description. No saved user pointer is dereferenced on a later turn. Successful Start returns descriptive thread identity. The member remains owned by its thread row after the creator finishes; a refused completion never retries Start or discards the member. Malformed input, disabled factories and insufficient capacity fail before effects. Uncertain effects retain the same request and destination, stop ordinary work, and await authenticated lifecycle cleanup. Cleanup checks only the retained member destination after process retirement, drops it only if it still holds that member, and independently confirms absence. A different occupant cannot satisfy cleanup. Members settle before the factory and receiver, while the creator's serving invocation and first failure remain separate obligations. This step includes the production request path, native adapters, counted ownership, fair progress, correlated result and cleanup. Regression coverage includes successful birth, overlapping creators, disabled and exhausted capacity, malformed requests, changed native replies, completion refusal, and uncertainty during preparation or Start. Libc stack/TLS allocation, dynamic ELF TLS, return/join/detach, row reuse, deployment consumers and hardware VM coverage remain required in these open issues. </details> ## Authority, security and reliability Socketpair uses only original realm fd/description/ring storage; it acquires no provider, network, namespace, process-control or global discovery capability. A connection through a name requires the original admitted scope and original listener object, with full realm, client, fd and description generations retained. A cross-realm operation requires explicit delegation; copied names and IDs never widen it. Validate all request/result/storage requirements before reservations or effects. Publish both pair descriptors together only after the original native result is accepted. Retain unpublished owners after ambiguous completion. Independent aliases preserve their original shared state; shutdown never disposes unrelated capability owners. Preserve buffered bytes and half-close/EOF/error ordering. Final teardown acknowledges every native owner, removes only original bindings and scrubs ring contents before reuse. Security, reliability and performance remain the priority order. <details> <summary>Remove spent native member rights</summary> The ordinary birth path initially retains READ, WRITE and EXECUTE after positive Start. Native immutable context and once-only Start prevent another context or successor, but the unused WRITE and EXECUTE masks are still unwanted explicit authority. Existing local relocation preserves rights; requesting GRANT to attenuate through a transfer would add unwanted authority. ### Native operation Add one caller-local same-slot native member attenuation operation. The caller must actually own the current move-only NativeMember binding in its Running process's existing CSpace window. Expected nonzero serial narrows that binding; it never authenticates a copied descriptor, selects another process, or follows an old slot occupant. Factory carriers and ordinary capabilities are outside this operation. No Process, stage, root, GRANT or target-process selector is accepted. The requested rights must be a subset of the independently current rights. Zero remains valid zero. The operation changes only that unique existing member's capability and indexed native binding metadata; it creates no alias, destination, TCB, context, process or mapping, and restores no permission. It cannot unfreeze a cleanup-only member or make a retired carrier operational. Actual cleanup-only state can be retained while rights monotonically decrease. A carrier lease or current CSpace inconsistency refuses before either metadata copy changes. All native transition checks and any required storage admission finish before the rights change. Under the existing lifecycle exclusion, update the current CSpace capability and its original directory metadata together; no fallible step may follow the first change before both copies agree. The actual member/context/ process and memory owners remain in place. No lifetime obligation is discharged. ### Framing and compatibility Use a new strict NTA1 request, 32 bytes: | Offset | Meaning | | --- | --- | | 0 | NTA1 magic | | 4 | Four zero reserved bytes | | 8 | Current local member slot, u32 | | 12 | Requested exact subset, u32 | | 16 | Expected original serial, u64 | | 24 | Eight zero reserved bytes | Append a 24-byte zero reply reservation. Positive NAR1 output contains its magic, four reserved zero bytes, the same serial at offset 8, the exact resulting rights at offset 16 and four final reserved zero bytes. There is deliberately no process or thread observation: an owner with zero rights can reduce zero to zero without obtaining READ-only native identity information. The caller already supplied every returned scalar. Existing member/factory/context/enrollment/Start wire remains unchanged. Reserve the next unassigned native syscall number only after checking the complete dispatch registry; rdi/rsi name the exclusive exact 56-byte packet, all other argument registers must be zero, and success returns extent 24. Shared IPC exports a canonical request/reply codec and immediate bridge. It checks complete framing before transport, unchanged original request bytes, exact success extent, same serial and exact requested resulting mask. Hosted targets refuse locally. Invalid input never issues a native effect; failed or inconsistent output retains the original request and native custody. ### Replay and errors With the same current binding/serial and already equal rights, exact continuation returns the same descriptive success without another native effect. If another operation has reduced the mask further, the old larger request refuses rather than restoring it. Missing or changed binding/serial, wrong object kind, broader requested rights and dirty framing cannot alter either original or new object. Do not infer absence, successful reduction, removal or permission restoration from any failure. A moved or positively dropped original carrier is not recreated. ### Ordinary birth integration After correlating the one positive Start, Posixd retains the complete same-slot serial and READ-only target before requesting attenuation. It advances through attenuation, exact current metadata and native READ in separate fair turns. Only then may it prepare NBR1. No WRITE/EXECUTE/GRANT goes to the client. The original positive Start and member owner survive COMPLETE refusal and creator retirement. If attenuation or verification becomes uncertain, ordinary service freezes and retains the original Start, attenuation intent and binding. It does not retry Start, create a replacement, clear the first error or adopt another slot. During authenticated terminal cleanup, independently observe the same original serial and accept only the recorded possible current masks (pre-reduction R/W/X or post-reduction READ). This is an explicit uncertain original transition, not a permission allowance for another carrier. Drop only the proved original and separately establish absence; native group disposal may already have removed it. ### Required controls Cover exact subset and zero reduction, same-slot repeat, changed serial/window/ process/type, missing and historical bindings, cleanup-only preservation, forbidden restoration, no GRANT requirement, metadata/native-rights coherence and unchanged original member/context/backing ownership. Bridge controls cover every reserved field, wrong extent, request mutation, exact result correlation and hosted refusal. Extend ordinary receiver tests for positive READ-only census, uncertain attenuation and changed actual current rights/serial, while retaining all original creator, context, enrollment, Start and cleanup controls. A native VM control must exercise the immediate operation with real current binding and malformed register/packet/span refusals. This does not accept allocation, TLS, thread join/detach or full self-hosting requirements. ### Proposed source ownership - LibIPC: a thematic native-member attenuation codec module and syscall bridge, registered from the existing native_member modules and independent tests. - Kernel: native_thread/attenuation.rs, a narrow CSpace metadata reduction helper, existing native-thread packet registry/adapter and independent object/wire controls. No scheduling, context or Start behavior changes. - Posixd: retained attenuation phase/intent and READ-only member inventory and cleanup in the existing birth owner, native transport adapter and controls. </details> ### Exercise ordinary thread creation with producer-provisioned memory This extends ordinary creation in [Kernel #47](https://git.erikinkinen.fi/erix/kernel/issues/47) and [Posixd #34](https://git.erikinkinen.fi/erix/posixd/issues/34). The workload uses the existing factory diagnostic: two realms, two clients per realm, T4/C2 storage, 1024-byte request/result budgets, canonical plan order, 38-process live envelope and 120-second VM deadline. A factory's capacity 2 includes the initial execution, so each client creates exactly one additional member. There is no new mapper, process, logging or factory grant in the client or Posixd. #### Select a separate executable without changing the supervisor Add a separate `realm-thread-client` Cargo root in Posixd and a separate linker. Integration selects its source and linker explicitly and packages that graph root under the existing private `/bin/realm-byte-client` fixture alias. Exsh retains its current factory diagnostic, canonical plan and all startup, signal, peer, exhaustion, six-native-exit and replacement-retirement witnesses. Ordinary byte, binding and pipe fixtures keep their existing source/linker selection. A new scenario field enables this client only with the existing factory diagnostic; invalid combinations refuse before artifact construction. The new root shares native startup, original-caller transport and the complete reciprocal byte workload. A thematic callback module runs the thread workload after the complete existing byte workload and before process exit. Existing clients use one shared empty callback; they gain no unused member memory or syscall path. No Exsh source change or frame-proof bypass is part of this extension. #### Provision real distinct ELF mappings Use explicit PHDRs for RX code, R read-only data, ordinary RW data, member TLS, member stack and the final original creator stack. All writable headers are NX. Reserve TLS and stack in separate original LOAD extents with page-aligned bounds. Leave one complete native page outside every LOAD immediately below the member stack. A linker symbol or padding inside a writable LOAD is insufficient. Keep the creator stack as the final writable root extent, preserving Loaderd's current root-stack selection. Initial member TLS is ordinary explicit RW data, not an ELF PT_TLS segment or a dynamic TLS allocator. Actual authenticated Loaderd/Procd materialization maps and zeroes these LOADs before the original process Start. Posixd receives neither VSpace nor mapping capabilities. Before packaging the selected native artifact, inspect its real program headers: code RX, ordinary data/TLS/stacks RW/NX, complete stack guard outside all mapped page extents, creator/member stacks and TLS disjoint, and the final writable extent equal to the creator stack. The checker also rejects reserved/unknown permissions, wrapping or incomplete extents, merged guard pages and substituted fixture source/linker selection. Zero-file-size LOADs must follow the existing authenticated materialization contract rather than a fabricated host allocation. An actual producer refusal becomes a prerequisite to repair. #### Preserve original caller and memory lifetimes The creator sends ByteCall::new_thread through its admitted ingress with the linked executable range, member stack/TLS bounds, guard and immutable initial TLS bytes. A fixed native entry wrapper and opaque callback arguments describe this same process's original memory; they carry no native factory/member selector. The creator's packet is its original exclusive startup workspace. The member's packet lives in its separately provisioned stack and cannot alias that workspace. Fixture packet extents must cover the existing 1024-byte budgets explicitly; these sizes add no general codec, module or thread limit. Posixd retains the original request, native CLAIM, READ/MINT factory, counted row, context/enrollment/Start and member destination. Kernel admits actual mappings and retains their original backing occupations and guard absence. After Start, Posixd removes WRITE/EXECUTE from its held carrier, independently verifies READ and returns descriptive NBR1. The creator keeps its original ByteCall through caller retirement and retains every uncertain owner until genuine process exit. The native member uses its fresh FS to check the immutable TLS word, executes its own ordinary QueryAbi through the same process ingress, and retires that separate native caller. Its actual returned callback value is published through a release atomic in original shared RW data. The creator checks it with acquire ordering while its startup object and original stack remain alive. No borrowed startup pointer is used after publication. The entry wrapper then invokes current-thread self-exit with that original result. Any unexpected return or uncertainty closes the actual process through its existing terminal path; no operation is retried. The returned word proves the callback returned after its own ordinary call; it is not an exclusive join, stack-reuse or independently observed departed-member receipt. Those remain separate requirements. Kernel's existing actual self-exit controls cover the native primitive independently. #### Preserve terminal ownership and actual evidence Each creator completes every existing reciprocal, blocking, signal, Close and EOF witness before the thread workload. It then requires the returned callback value and retired original birth caller before process exit. This keeps the old signal workload's original task set intact; it does not claim new per-thread signal delivery or departed-member signal eligibility. Exsh still requires its six genuine successful native exits and full original realm/client retirement, including the never-started replacement and live peer. Member cleanup uses the original READ carrier, exact serial, native DROP and a separate absence observation before factory/receiver retirement. The new scenario keeps every existing marker and timeout; its required native exits now also depend on the selected client's birth, TLS, member-call and returned-value checks. Run that bounded VM only with the actual signed graph, matching artifact/source receipts and required Exsh frame gate. A compiled client, host model, linked ELF or unchanged marker name is not a deployed pass. This slice does not complete ordinary libc stack allocation, dynamic ELF TLS, join/detach or guest self-hosting. #### Source ownership Posixd owns the new client root, thematic workload/default callback modules, separate linker, shared native callback dispatch, native CI coverage and component documentation. Integration owns private client artifact selection, the narrow scenario field/policy, ELF geometry checker and focused independent controls, and the separate finite scenario. Root coordinates exact signed dependency heads, public design, commits and the existing Exsh proof owner. No producer authority protocol or shared libc codec migration is changed without another reviewed design. ## Acceptance criteria <details> <summary>Checklist</summary> - [ ] Record exact required source/workload operations and resolve their interface ownership; retain explicit gaps for the imported-tool manifest and never claim whole coverage from a source-string inventory. - [ ] Specify and implement the complete counted local-stream ABI, atomic pair/result admission and defined unsupported-operation errors without changing native authority ceilings. - [x] Implement original duplex byte/vector I/O, aliases, nonblocking/backpressure semantics, required buffer options, directional shutdown, peer closure and exact final retirement. - [x] Implement required scoped pathname bind/listen/connect/accept, original listener/backlog/connection lifetime and unlink/replacement behavior without ambient name lookup. - [ ] Integrate original event-driven readiness, actual delegated deadlines, cancellation and signal interruption for pending socket operations. - [x] Author independent positive, malformed, exhaustion, half-close, replacement, cross-client/realm denial, caller-loss and ambiguous-publication controls, plus actual native multi-client socket workloads. - [x] Update component/manual contracts and inline rustdoc, retain missing-docs enforcement and code below 1,000 lines, remove superseded one-way assumptions, and preserve duplicate same-repository PR guards. - [ ] Publish coherent signed immutable dependencies, document source/performance evidence and update owning reviews and phase tracking before acceptance. Test execution remains waived; no execution or measured performance result may be invented. </details> ## Alternatives and tradeoffs A socketpair-only implementation cannot cover the maintained pathname listener tests. Two uncoordinated pipe creations cannot provide atomic duplex publication, shared socket state or directional shutdown. A process-global name registry, implicit host socket adapter or hidden network endpoint would create authority outside the original realm. Use actual admitted storage and explicit capacity refusal instead of a new hard-coded pair/listener count. Additional datagram, credential or descriptor-transfer interfaces require a demonstrated workload and reviewed ownership contract. The design derives from the [POSIX socketpair contract](https://pubs.opengroup.org/onlinepubs/9799919799/functions/socketpair.html) and the [Python socket interface](https://docs.python.org/3/library/socket.html), together with original EriX workload sources. No third-party implementation code is copied. ## Tracking and rollout Coordinate [filesystem/descriptor services](https://git.erikinkinen.fi/erix/posixd/issues/2), [completed descriptor readiness](https://git.erikinkinen.fi/erix/posixd/issues/33), [Posixd review](https://git.erikinkinen.fi/erix/posixd/pulls/5), [Integration review](https://git.erikinkinen.fi/erix/integration/pulls/12) and [phase completion](https://git.erikinkinen.fi/erix/integration/issues/65). Record the workload matrix first; implement duplex publication and lifecycle, scoped listeners, waits and native consumers coherently. General libc wrappers, imported-tool porting and both guest EriX/toolchain rebuild demonstrations remain separate required integration work. <details> <summary>Detailed scope and contracts</summary> ### Fair original native intake and Close reply custody — 4 October 2026 Retiring scopes and removed metadata stop intake; no separate parallelism cap, heap allocator, per-thread scope grant or packet thread-ID authority is added. One-shot receivers remain exclusive through refused completion and original retirement. Final ordinary settlement yields the existing preferred legacy RECV turn. Refused COMPLETE remains attempted; draining and receiver-disposal refusal retain original custody. Caller retirement cannot prove semantic cleanup; private revocation may suppress Close's reply while cleanup still finishes. Final scope clearing requires every original call and positive receiver absence. The association is descriptive and adds no capability; actual updated type size/alignment drive exported target layout and runtime storage without a wire or authority ABI change. They cover real peer-blocked Wait with provider work/query, multiple original waits and process cleanup, Close after older Wait drain, refused Close/draining/delayed disposal, private revocation/provider refusal, counted saturation/recovery, one-shot exclusivity, final-settlement legacy opportunity, valid/contradictory Close associations, original child disposal through provider refusal/caller loss/private abandonment, and receiver-generation refusal before provider retry. Full Posixd uncertain process-close coordination and overlapping intake, per-call masks/TLS, complete libc/imported consumers, same-process native overlap workload sources remain required. Native caller retirement cannot prove semantic cleanup or permit old cleanup to release newer process locks. The whole socket feature remains open. Completed source criteria are marked despite deferred execution; missing implementation remains open. Both complete EriX guest generations and external Rust/LLVM guest rebuilds remain mandatory and unperformed. Independent native custody and fair blocked-Wait intake are source-complete; native serving has five completed source criteria and three open criteria: fd/process-lifetime coordination, the retained Posixd close coordinator, and complete same-process native VM workload sources. Recalculated phase progress is 21.11% weighted; 9.61% whole acceptance; 32/460 parents and 495/965 children across 167 decomposed parents. ### Original first-submission key order — 4 October 2026 Fair Vfsd intake must dispatch each newly claimed request before yielding so later claims cannot overtake the monotonic admission fence. The existing candidate and Wait replay/absence fences remain intact; this adds no scope mutex, grant, tombstone ledger, allocator or independent waiter cap. Commit/Cancel and uncertain submission keep the original key and normalized intent; original native retirement precedes idempotent cleanup and cannot itself prove semantic rollback. Six controls are authored and unrun: delayed EOF with reordered Wait admission; a newer actual first submission while another Wait stays pending; pre-submission cancellation without consuming a key; actual packet and EOF-coordinate refusal before issuance; uncertain original submission and cleanup after a newer key; and full-width final-key exhaustion. Fair overlap, one-shot/legacy lifetimes, full terminal drain integration and uncertain process-close coordination remain unfinished in [independent native invocations](https://git.erikinkinen.fi/erix/vfsd/issues/27) and [local stream sockets](https://git.erikinkinen.fi/erix/posixd/issues/34). Both features remain open with all eight whole criteria unchecked. Per-call masks/TLS, complete libc frontends and imported-tool closure remain required in the same whole socket scope. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Deferred execution does not prevent marking completed implementation; unfinished whole serving and guest-build requirements remain open. ### Original advisory provider-pin custody — 4 October 2026 Provider disposal refuses active uses before effects. This creates no additional provider acquisition, native grant, RPC, allocator or per-process concurrency cap. Original generations, both reservation links and captured intent must agree. Stale saved success and foreign terminal correlation refuse; attempted COMPLETE history remains unchanged without replay. Eight controls are authored and unrun: immediate publication and uncertain completion; readiness/Commit transfer; prepared cancellation and stale-result refusal; original pin disposal preserving another pin's newer locks; quarantine preserving published before-images; quarantine of an immediate acquisition; no-row cleanup ticket order; and contradictory scope generation before effects. Existing retirement controls now require independent positive cancellation instead of stale success. Public pre-submission key ordering, independent intake, one-shot/legacy fairness and uncertain process-close coordination remain unfinished in [independent native invocations](https://git.erikinkinen.fi/erix/vfsd/issues/27) and [local stream sockets](https://git.erikinkinen.fi/erix/posixd/issues/34). Both owning features remain open with all eight whole criteria unchecked. Complete libc frontends, per-call masks/TLS and imported-tool closure remain required in the same whole socket scope. Both complete EriX guest generations and external Rust/LLVM rebuilds inside EriX remain mandatory and unperformed. Implementation completion is not gated on those deferred executions; incomplete serving and guest-build requirements remain open. ### Whole-receiver native reply abandonment — 4 October 2026 Actual reference count, links, tail, progress cursor and original non-reused generations must agree. Later progress cannot dispatch the abandoned request, reconstruct a result, attach a new reservation or resume provider arbitration. An earlier accepted or refused COMPLETE keeps its original decision and is never replayed. Provider and receiver refusal retain their own original cleanup barriers. [The cached lock-success defect, Vfsd#28](https://git.erikinkinen.fi/erix/vfsd/issues/28), is closed as source-complete using bug_report with bug/phase-6 metadata and all four criteria checked under the user testing waiver. The original serial serving path could roll back an advisory lock, refuse provider retirement and leave its cached Complete result eligible for native delivery. Seven new controls are authored and unrun: full roster abandonment preserving an independent receiver and an unclaimed association; malformed roster refusal before any saved result changes; permanent abandonment across movement/live probes; accepted/refused native completion history; multiple-call native/receiver drain; private scope cleanup through provider/receiver refusal; and the minimal serial cached-success regression. Suspended-operation pins, public pre-submission key ordering, independent intake and one-shot/legacy fairness remain unfinished in [Vfsd#27](https://git.erikinkinen.fi/erix/vfsd/issues/27). All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added. Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Native mutation admission — 4 October 2026 Disjoint requests inside one original before-image still depend on that journal so rollback cannot overwrite newer state. Capacity refusal and duplicate original change admission preserve all rows before any effect. Public continuation token zero cannot select these native queues. Cancellation rolls back effects while retaining the original typed result through actual completion or positive retirement; it never redirects cleanup into a newer provider pin or repeats attempted COMPLETE. Nine new controls are authored and unrun: independent objects/owners and separately settled intervals; shared before-images and merge neighbors; atomic capacity refusal; original Unlock delivery; process-close publication; ordered native cleanup calls; original pin retirement preserving newer locks; and counted queue exhaustion preserving the original caller and effect. Suspended-operation pins, public pre-submission key ordering, independent native intake, generalized all-call terminal drain and one-shot/legacy fairness remain unfinished in [Vfsd#27](https://git.erikinkinen.fi/erix/vfsd/issues/27). All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added. Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Independent advisory reservation custody — 4 October 2026 Exhaustion refuses before consuming the client's continuation key or installing a call link. Ordinary progress follows the actual link; copied snapshots cannot replace custody. Commit and Cancel select only the original scope's continuation key and require fully correlated intent. Contradictory generations propagate refusal before arbitration or cleanup. Exact Commit requires this positive readiness boundary and attaches its own original delivery; early or repeated Commit preserves the reservation. An unsubmitted readiness or Commit result becomes a correlated refusal; an attempted COMPLETE is never replayed. A terminal reservation cannot resume provider arbitration after pin retirement. Scope reuse and call clearing refuse retained reservation custody. Admission based on actual conflicting mutations remains required. Production intake still progresses an existing call before claiming another; interleaved native intake, suspended-operation pins, generalized all-call terminal drain and one-shot/legacy fairness remain unfinished in [Vfsd#27](https://git.erikinkinen.fi/erix/vfsd/issues/27). All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added. Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Original native request dispatch — 3 October 2026 Dispatch copies the retained packet into scratch; scratch contents cannot substitute another request. Unclaimed allocation, malformed native intake, endpoint substitution, replay and abandoned or settled delivery cannot supply dispatch proof. Malformed application framing consumes readiness before refusal. Legacy advisory mutations, including Commit, Cancel and process-close cleanup, refuse even while another native call is pending on the scope. Queued waits retain their original call identity; readiness and native settlement cannot borrow another delivery. Six new controls are authored and unrun: unusable intake and abandonment; one-use dispatch across movement/refusal; legacy mutations during an unrelated native query; accepted/refused Try and Commit from spare call rows; spare-call readiness followed by Commit; and unclaimed/malformed request replay. Independent multi-waiter custody, exact reservation lookup, cancellation drain, conflict-journal admission, suspended-operation pins and fair all-call terminal drain remain unfinished in [Vfsd#27](https://git.erikinkinen.fi/erix/vfsd/issues/27). All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added. Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Counted native call allocation — 3 October 2026 No separate per-process call cap, new buffer, allocator or native grant is introduced. Scope clearing refuses retained receiver associations. Stale call keys, replacement generations and contradictory neighbors refuse before native progress or unlinking. Native submission also refuses a substituted endpoint index or generation before CLAIM. Four controls are authored and unrun: counted exhaustion and roster unlinking with receiver retention after metadata removal; stale call keys and replacement receiver generations; idle CLAIM cleanup through the real serving path; and rejection of substituted endpoint coordinates before native submission. Explicit invocation-versus-scope dispatch identity, independent reservation ownership after readiness, exact Commit/Cancel lookup, conflict-journal admission, suspended-operation pins and all-call terminal drain remain unfinished in [Vfsd#27](https://git.erikinkinen.fi/erix/vfsd/issues/27). All eight native-serving and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added. Native threads/TLS, complete libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Native call custody — 3 October 2026 COMPLETE and provider/receiver cleanup use that retained endpoint independently of the call's current storage location; replacement generations refuse before native progress or cleanup. Copied endpoint coordinates confer no authority without the retained native owner. Moving a call preserves its prepared bytes, completion-attempt history, native acceptance/retirement and original advisory settlement. A refused COMPLETE cannot be retried after movement. Clearing now refuses until positive native settlement and consumption of the original journal decision; refusal preserves both custody and bytes. No extra buffer, allocator, wire operation or grant is introduced. The other moves a refused delivery and requires positive original cancellation retirement plus journal consumption before clearing, without a repeated COMPLETE. Independent allocation, original receiver/scope holds, multi-waiter reservation lookup and cancellation, conflicting-journal admission, fair progress and all-call terminal drain remain unfinished in [Vfsd#27](https://git.erikinkinen.fi/erix/vfsd/issues/27). The process's single admitted acquisition-scope route can still be occupied by a blocked native Wait; a mediator-only fence cannot make Close progress there. All eight native-serving criteria and all eight whole socket criteria remain unchecked; no artificial acceptance credit is added. The completed [candidate-retirement repair](https://git.erikinkinen.fi/erix/vfsd/issues/26) remains selected: delayed native pin disposal stays narrow and cannot restore retired custody from rollback records. Complete native thread/TLS semantics, libc frontends and imported consumers remain required. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Candidate lock retirement — 3 October 2026 While a native Wait owns that row, the scope cannot claim Close or an independent operation. A mediator-only lock fence cannot resolve this limitation. Native receiver/scope custody must be separated from counted per-call serving owners, with original pin holds, reservation/journal settlement, fair progress and all-call terminal drain. Its eight whole criteria remain unchecked; no additional completion credit is claimed. No new native grant, provider route, allocation, wire operation or unsafe code is introduced. This repair does not complete mediator admission coordination: uncertain explicit Close retries must not erase newly acquired process locks, and a blocking Wait must not hold a fence that deadlocks Close. Queued mutation admission, path-anchor/socket-path lifetime audit, invocation-owned masks, fair all-call intake/drain, native thread/TLS semantics, complete libc frontends and imported consumers remain unfinished. All eight whole socket criteria remain unchecked. Both full EriX guest generations AND external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Prospective alias holds and cleanup activity — 3 October 2026 Source fd close/reuse cannot redirect the eventual alias. Commit transfers its original hold into the destination fd even when no source fd remains; effect-free undo returns an ordinary cleanup hold to the same native delivery. Final source disposal remains explicit and never repeats any-close process-lock policy. Generic source release cannot discard an uncommitted alias intent. Repeated settled cleanup produces no new local effect. Seven controls are authored and unrun: original-source publication after close/reuse; final-source cleanup returned by undo; independent alias cancellation; exact target conflict boundaries; listener survival through publication; listener cancellation retaining its pin; and same-epoch peer HANGUP before a refused native call retires. Four constructor calls now supply explicit subscription storage; a restored-target assertion requires the advanced occupation generation while comparing all other original fields. Queued mutation admission and any-close lock-policy coordination must precede overlap; a blocking lock must not retain a fence that deadlocks Close, and an uncertain old Close must not release newly acquired process locks. Path-anchor/socket-path reservation lifetimes, invocation-owned masks and fair all-call intake/terminal drain remain unfinished. Complete native thread/TLS semantics, libc frontends and imported consumers remain required. All eight whole socket criteria stay unchecked. Both complete EriX guest generations and the external Rust/LLVM guest rebuild remain mandatory and unperformed. ### Original candidate cursor arbitration — 3 October 2026 An alias, copied key or reused fd cannot release another call's barrier. Fixed results and completion refusal cannot replay the operation. The candidate fixture exercises actual file admission and local Seek effects while refusing native provider execution. Exact descriptor target/replacement-source conflicts, any-close lock-policy coordination, per-call masks and fair overlapping intake remain unfinished. Path-anchor and socket-path reservations require continued lifetime audit. All eight whole socket criteria remain unchecked; both complete EriX guest generations and the external Rust/LLVM guest rebuild remain mandatory and unperformed. ### Ordinary call source holds — 3 October 2026 A resumed call with a missing or mismatched token rejects instead of looking up a reused fd. Call and readiness holds share checked accounting and final candidate/stream/socket/queue disposal; final hold release never repeats any-close process-lock policy. Refusal, cancellation and authenticated termination preserve that original token. Target-generated invocation geometry includes the actual hold; no new grant, hidden fd or implicit allocation is introduced. Shared-cursor arbitration, exact descriptor target/replacement-source conflicts, any-close lock-policy coordination, per-call masks and fair overlapping intake remain unfinished. Path-anchor and socket-path reservations require continued lifetime audit. All eight whole socket criteria remain unchecked; both complete EriX guest generations and the external Rust/LLVM guest rebuild remain mandatory and unperformed. ### Original readiness holds — 3 October 2026 No additional native grant, implicit allocation or payload identity is introduced. It never repeats any-close process-lock release. Per-description cursor arbitration, call-owned masks, fair overlapping intake, complete libc frontends, native thread/TLS semantics and imported consumers remain unfinished. The whole socket issue retains all eight unchecked acceptance criteria. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Counted invocation storage — 3 October 2026 Retained request/result regions scale with explicit invocation capacity, and enabled header replies require 240 bytes. Stale generations, cross-client selection and reuse with outstanding native custody remain refused. Safe overlapping intake remains unfinished: original description holds must survive fd close/reuse; final disposal must wait for all holders; shared cursor operations need description-level arbitration; temporary masks and handoffs must remain call-owned. Complete libc frontends, native thread/TLS semantics and imported consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding within EriX remain required and unperformed. No whole socket acceptance credit is added. ### Named stream implementation — 2 October 2026 No pathname, fd number or copied identity supplies authority. Refused client or accept completion disposes only its original endpoint. The native binding workload adds scoped named connections, empty accept, duplex traffic, listener close, EOF, explicit unlink and read-only-scope denial. Concurrent calls per process, complete libc frontends and imported-tool closure remain unfinished. The complete socket issue remains open; no artificial checklist credit is added. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. ### Original socket admission implementation — 2 October 2026 Both require the actual native write ceiling. FAT refuses because the selected catalog cannot represent socket objects. The exact descriptive identity is usable only beside independently admitted original pins in the same realm; it is never a route selector or capability. Nine new independent controls cover wire framing/atomic refusal, native purpose and ceiling enforcement, read-only-media communication, stale/uncertain replies, original cleanup and no-mutation provider behavior. Scoped compatibility bind/listen/connect/accept, counted backlog and concurrent calls, libc frontends and imported-tool closure remain unfinished. The complete socket issue stays open; no checklist acceptance credit is added. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Counted socket lifecycle implementation — 2 October 2026 Native COMPLETE acceptance controls publication. Refusal cancels only the original reservation while the enclosing serving owner remains retained. No endpoint, native grant, route, uncounted allocation or unsafe code is added. Six new runtime controls are authored and unrun: original unconnected publication with occupied transport, no-peer I/O/shutdown refusal, alias/shared option lifetime, refused native publication with another client, terminal alias cleanup beside another client's live pair, and stale connected queue generation refusal. The whole socket requirement stays open: scoped bind/listen/connect/accept, original listener identity and permission admission, counted backlog and concurrent calls, full libc frontends and imported-tool closure remain unfinished. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. No executed pass, warning-free build, full-socket acceptance or measured performance improvement is claimed. ### Atomic socket namespace implementation — 2 October 2026 Explicit socket intent is separate from regular-file access; successful replies must match the original key and requested kind. FAT refuses socket intent before effects under its current catalog representation. The same whole socket requirement remains open: Posixd bind/listen/connect/accept, independently admitted listener identity, counted backlog and concurrent calls, full libc frontends and imported-tool closure still require implementation. Both full EriX guest generations and rebuilding external Rust/LLVM inside EriX remain required and unperformed. ### Anonymous duplex socket implementation — 2 October 2026 Two fd/description reservations and two queues publish atomically only after native completion acceptance. The implementation retains original pair custody through refusal, cancellation and terminal loss, scrubs both queues before reuse, reports actual Socket metadata without invented creator/time observations, and refuses unbudgeted send-buffer growth. No provider, networking, discovery or host-control authority is added. The new `realm-sockets` group selects those existing VM scenarios without changing grants, queue backing, process budgets or exit criteria. Scoped pathname bind/listen/connect/accept remains required by the [original workload matrix](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/local-ipc-requirements.toml). Named listener/connection lifetime, complete socket adapters and imported-tool interface closure remain open. The [owning feature](https://git.erikinkinen.fi/erix/posixd/issues/34) stays open with all eight full-scope criteria unchecked; anonymous pairs alone do not satisfy it. Overall progress remains 21.04% weighted, 9.61% whole-item acceptance, 32/460 parents and 493/953 sub-items across 166 decomposed parents. No artificial substep or acceptance credit was added. Both full EriX guest generations and rebuilding external Rust/LLVM inside EriX remain required and unperformed. ### Required local stream socket scope — 2 October 2026 The local stream socket requirement now has a concrete [feature design](https://git.erikinkinen.fi/erix/posixd/issues/34) and [source-bound workload matrix](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/local-ipc-requirements.toml). Six original source identities at Integration revision `2002ef2aca1ca38ed36ad66d5d5783deae2dc5f9` identify three maintained unit commands and their required operations. Both anonymous pairs and scoped pathname listeners are needed; socketpair alone would not cover those consumers. The owned requirements include nonblocking send/receive, backpressure/select, actual timeouts, send-buffer capacity, directional shutdown, peer EOF and original cleanup. The contract distinguishes synthetic local unit peers from host QMP/COM1 endpoints. Neither a source file, socket name nor copied peer identity grants a guest authority. Complete upstream tool versions, recipe options and transitive interface requirements remain explicit gaps. The documented implementation order is coordinated duplex descriptions and pair publication; directional I/O, options, shutdown and alias retirement; scoped bind/listen/connect/accept with original object and backlog custody; readiness/deadline/interruption; independent and native controls; then coherent ABI adoption. Socket implementation remains open with all eight feature criteria unchecked. No new partial checklist item or acceptance credit is added. Five signed commits across four repositories publish the requirements, component contracts and manual while preserving the coherent immutable source graph. The checkpoint changes fourteen paths and no executable code. All 269 compiled edges and 162 catalog selectors remain coherent, with Rootd's independent Integration helper preserved. All 153 same-repository PR guards in 76 workflows remain intact. All feature trees are clean except the preserved unrelated Meta cache. Overall progress remains 21.04% weighted, 9.61% whole-item acceptance, 32/460 parents and 493/953 sub-items. ### Atomic filesystem ownership for pathname sockets — 2 October 2026 The pathname implementation will extend the existing conditional creation request with explicit `FsCreationIntentV1`: regular-file access keeps wire values 1–3; value 4 creates a socket binding without file-content access. Prefix sizes and operation IDs stay unchanged. Older decoders reject the new intent. Success must match the requested kind, empty size and original correlation/key; no ordinary pin reply or regular-file result can satisfy a socket creation request. Vfsd retains the original provider acquisition before submission and records a socket binding separately from file admission. RAM and Ext creation reserve the original pin before namespace effects and return the committed socket identity inside the same operation. Neither a second path lookup nor a copied object ID can substitute for that owner. Existing metadata, mask/default ACL, parent freshness, namespace replay fencing and uncertain-effect custody still apply. FAT's regular-file creation path must explicitly refuse the socket intent before namespace effects until its persistent metadata format supports socket objects. No provider may create a regular file and report it as a socket. Unlink detaches the original name while a live pin keeps the original socket object distinct from a replacement. Retirement releases that pin, not the namespace entry. A later Posixd binding will retain this owner for its lifetime; connect still needs independently scoped original-object permission admission, listener identity, counted backlog and pending-connection custody. Native creation alone does not complete bind/listen/connect/accept or threaded consumers. Independent wire, provider and VFS controls will cover kind substitution, capacity/permission refusal, unlink/replacement, reply loss and exact retirement. Tests, builds and CI observation remain deferred; none is claimed to have passed. ### Counted socket descriptor lifecycle — 2 October 2026 Listening and pending-connection ownership must remain counted independently of published accepted descriptors. Creation uses the original fd/description and configured byte-storage budgets; native COMPLETE acceptance controls publication. Unconnected read/write/shutdown returns ENOTCONN and cannot invent EOF or peer authority. Scoped connection must admit its independently selected original object and permission revision. Final close and terminal retirement must settle both native binding custody and local queue/backlog owners before reuse. The full socket feature remains open; tests and CI observation remain deferred. ### Creation-response regression repair — 2 October 2026 Socket intent cannot become regular-file access. Component status documents record the repair; unchanged runtime/API behavior requires no new manual contract. Whole socket completion remains open: scoped named connections, original admission, counted backlog and concurrent calls still need implementation. Full EriX and external Rust/LLVM guest rebuilding remain required and unperformed. No checklist acceptance credit is added for this repair. ### Original socket identity admission — 2 October 2026 Add a distinct scoped native socket admission operation. It selects only the original acquisition candidate beneath the actual retained scope; it accepts no path, provider route, object identity or substitute root. Binding identity can be published only from a socket pin created by that original scope. Connect admission requires a fresh acquired socket, the original scope's native write ceiling and complete current permission evidence. Existing metadata/ACL queries supply facts; the mediator must evaluate socket write permission before final admission. The provider compares the same retained candidate's fresh revision without file I/O, truncation, timestamp mutation or a writable-media requirement. Binding creation continues to require original writable parent and mount admission. Use VFS operation 0x71f with a 32-byte request (correlation, original candidate, permission revision, Binding/Connect purpose, reserved zero) and a 56-byte result (correlation, original candidate, known result, provider kind, 32-byte original object identity). Binding uses revision zero and only the originally created SocketBinding state; Connect uses a positive fresh revision and only Fresh state. Advance original admission before any provider call. An uncertain/refused call cannot publish identity, gain file content rights, or replay under another key. Successful binding and connect states remain separate from Live file access and retain original-key cleanup. The private provider operation 0x720 has a 24-byte request with correlation, retained handle and positive revision; its result uses the existing exact status framing with original operation/correlation checks. Returned identity is descriptive association, not a capability. Posixd may compare it only while it retains both independently admitted original pins in the same realm. No global pathname registry or copied credential grants communication. Provider identity must remain stable while that actual pin lives; unlink and replacement cannot retarget it. RAM and Ext compare original root/lifetime/kind and fresh permission revision. FAT cannot represent socket objects and refuses this admission without filesystem effects. Old peers refuse the new operation. Continue the full named socket implementation after this boundary: bind custody, listen/backlog, original connect and accepted endpoints, concurrent calls and required workloads. Full socket acceptance and guest rebuild requirements remain open. Source controls will cover wrong purpose/kind/key, stale permissions, native ceilings, read-only media, lost/malformed results, cleanup and identity reuse. Tests, builds, lint and CI observation remain deferred. ### Named socket custody and compatibility operations — 2 October 2026 Implement scoped bind/listen/connect/accept over the original socket description, without allocating a hidden application descriptor for an incoming connection. Compatibility 1.25 assigns Bind=44, Listen=45, Connect=46 and Accept=47. Bind and Connect carry one existing socket fd, an explicit relative directory base and counted raw pathname. Listen carries the existing fd and full-width requested backlog. Accept carries the existing listener fd plus explicit new descriptor and nonblocking flags; success returns one newly reserved fd. Binding and connection require the original scoped native operations already implemented. Names and copied object identities cannot supply authority or choose a route. The existing counted socket description owns every native binding/peer pin and local queue reference. Bind reserves its original local fd occupation before native traversal; the namespace object is created under fresh parent write/search policy and the process mask, then admitted as Binding using the original native candidate. The original caller and every temporary walk pin retire independently. Only accepted serving completion moves the binding into the socket description. Refused publication retires that original native pin before releasing the local reservation; it never unlinks a committed name or removes a replacement. Connect applies full original pathname search and final socket-write DAC, then uses fresh native Connect admission. Listener association requires independently admitted live original pins in this same admitted realm. The connection owns original counted queue generations. Incoming backlog ownership consumes counted storage, never an accepted application fd; actual Accept allocates and publishes that fd. Requested capacity is bounded only by actual admitted storage, with correlated exhaustion instead of hidden fixed limits. Closing a listener drains its original pending connections independently from accepted endpoints. Native pin and local queue disposal compose for final close, descriptor replacement and terminal cleanup. A nonfinal alias cannot dispose either resource. Uncertain native cleanup keeps the same original description, queue and serving owner; positive pin retirement precedes final local disposal and row reuse. Retained operation reservations cannot acquire authority through recycled fd numbers. Preserve readiness, shutdown, signals, deadlines and cancellation. Concurrent calls require counted original invocation state; the current one-delivery client row is a remaining part of this whole feature. Add independent wire, serving, provider-lifetime and native workload controls. Tests, builds, lint and CI observation remain deferred. Full socket acceptance, imported-tool closure and both EriX and external Rust/LLVM guest rebuilding remain open. ### Concurrent invocation and readiness ownership — 2 October 2026 Complete same-process concurrency under the existing whole local-stream requirement. A process receiver and its immutable native origin remain one original authority; multiple independently owned serving invocations must have separate counted rows, request/result bytes, wait state and publication/cleanup state. No caller-provided thread label or copied process number will authenticate an invocation or grant a new endpoint. The actual CLAIM origin and original nonzero serving owner remain the admission boundary. Add explicit invocation and readiness-subscription capacities to the immutable realm counts. The target-generated arena descriptor gains actual InvocationSlot and ReadinessSlot size/alignment pairs; loader authentication, exact layout digest and target/runtime equality precede typed borrowing. Introduce layout version 5, 160 bytes; remove the superseded version-4 API. Configuration RCF1 and pull RCP1 minor 7 has a 136-byte header with invocation capacity at 120 and readiness capacity at 128. Startup RBS1 minor 5 has a 264-byte header with capacities at 248 and 256. The corresponding counted provisioning and layout-binding frames expand exactly; old frames fail closed. Retained request/result regions scale with invocation capacity, independently of process count. Propagate these counts through actual Launchd/Procd provisioning, image and client configuration without implicit defaults inside the consumer or uncounted fallback allocation. Reserve storage before every CLAIM. Each configured process has one guaranteed base invocation row, with additional explicitly admitted rows shared by fair intake. No caller can consume another process's base reservation. A full budget applies native backpressure without claiming an owner that cannot be retained. Original receiver registration/watch remains process-owned. Schedule original active calls independently; a sleeping read, connect, accept or poll cannot prevent another admitted call from the same process making progress. Nonwrapping call-row generations bind internal associations; request IDs remain descriptive correlation. Move readiness subscriptions out of descriptor bindings into separately counted original-call rows. Different calls watching the same fd must never merge their native query owners, linked lists, temporary masks or output positions. Within one call, duplicate poll positions may share one original subscription. Subscription and byte-operation lifetime holds retain the original shared description through fd close/reuse. Close removes only its fd occupation; final backend disposal waits for every original alias, call hold and native cleanup owner. Shared file cursor effects need original description arbitration; positioned I/O must not silently change the shared cursor. Any-close process-lock semantics remain intact. Replace process-wide descriptor-mutation exclusion with conflict handling for the actual original occupation/description. Waiting calls cannot select a recycled fd or freeze unrelated descriptors. Cancellation, ambiguous results, deadline/mask restoration, accepted publication and authenticated process teardown all keep separate original owners until independently confirmed disposal. Process teardown stops intake first, drains every invocation/subscription/publication, and only then retires descriptors, scope pins, receiver watches and receiver authority. Keep process policy separate from invocation state. Readiness temporary masks and selected handoff belong to their original call; they cannot overwrite another call's state. Full native thread lifecycle, per-thread signal/TLS semantics and libc integration remain explicit requirements alongside concurrent invocation serving. Author native same-process overlapping-call workloads and independent capacity, fd-reuse, cancellation, cursor, signal and teardown controls. Tests, builds, lint, VM/profiler execution and CI observation remain deferred; no execution result is claimed. Whole socket acceptance and full EriX/external Rust/LLVM guest rebuilds remain open. Signed current revision: [9ae22041](https://git.erikinkinen.fi/erix/posixd/commit/9ae220411648da646e84c5814019019719d1066a). ### Original process-close continuation contract — 4 October 2026 Before overlapping mediator intake, replace blind uncertain process release with one original keyed native cleanup intent. Reuse the existing fixed-width candidate-lock request and existing scope-local monotonic continuation domain. Nonzero-key ReleaseProcess prepares whole-object process cleanup with kind absent and report PID zero; Ready leaves published intervals unchanged. Exact Commit publishes once. Retain a counted, grant-free committed receipt through caller loss and repeated exact requests; Cancel with that cleanup shape acknowledges the receipt without releasing locks. Ordinary acquisition Cancel retains its rollback meaning. Original scope/candidate/key and full request echo must correlate every stage. Pending cleanup retains the original noncopy provider-pin use and actual object/process-owner dependency. It fences only related mutations, not queries, reads, independent objects or description owners. Close cancels older acquisition waits before queueing its original cleanup; it must not wait behind an external lock holder. Refused readiness or Commit retains the original intent for exact continuation; it cannot create a fresh release. Pin disposal preserves historical identity and cannot rebind cleanup to a newer object. Whole-scope teardown disposes its own retained histories. Admission failure and fenced absence must have explicit effect-free outcomes, distinct from semantic completion. Posixd issues the key in its first actual submission turn, retains original caller/descriptor-change custody through ambiguity and application cancellation, and retires the final candidate only after positive semantic confirmation and receipt acknowledgment. Implement producer, consumer, actual storage/layout, independent failure controls and documentation together, with coherent signed immutable adoption. Do not add an object-identity metadata RPC, per-process activity exclusion, copied grant, payload thread authority, allocator or arbitrary capacity. Same-process mediator overlap, per-call native origin/masks/TLS, complete socket consumers and native workloads remain required. Tests and CI observation remain deferred; this section records the implementation contract, not completion or execution evidence. ### Earlier keyed process-close source checkpoint — 4 October 2026 Fixed request/response widths and native authority ceilings remain intact; older peers reject the extended cleanup shapes, so producers and consumers adopt coherently. Refused readiness or Commit rolls back the original journal and moves the same noncopy provider-pin use out of its retired native call, preserving the original key/object/process owner/ticket. Actual storage refusal precedes effects, pin retention and key burn. Repeated exact cleanup or Commit cannot release newer locks. No copied grant, object-identity metadata RPC, payload thread authority, allocator or arbitrary coordinator cap is introduced. They cover refused Ready/Commit and rollback, narrow owner dependencies, old Wait cancellation, newer locks preserved across historical retries, premature/mismatched acknowledgment, original pin/scope history disposal, actual counted admission refusal, malformed Commit lookup, malformed acknowledgment and application abandonment. Same-process mediator overlap, authenticated native per-call origin/source holds, per-call masks/TLS, full socket/native workload and libc/imported consumer closure remain unfinished. Native caller retirement cannot prove semantic cleanup. The whole socket requirement remains open; both complete EriX guest generations and external Rust/LLVM guest rebuilding remain mandatory and unperformed. Completed implementation source is marked under the waiver; missing implementation remains open. Native-serving acceptance remains five of eight: its coordinator criterion also requires real Close intake behind blocking Wait, which remains unfinished; fd/process coordination and complete same-process VM workload sources also remain open. No full-feature acceptance is inferred from authored controls or waived execution. ### Counted mediator intake and original-call progress Reserve an actual invocation row, its nonwrapping generation and its original receiver/client association before every native CLAIM. Retain a returned owner before interpreting status. Empty native intake releases only the uncommitted reservation; actual capacity refusal performs no CLAIM. The shared counted pool admits independent calls from the same authenticated native TCB/generation without duplicating receiver grants or process policy. An intrusive original-call roster gives every retained owner a fair progress turn, independently of receiver intake. Every association and roster link includes the original row generation. Request/result regions and wake stamps belong to individual calls; receiver parking cannot consume their wake observations. Receiver/watch, descriptor, provider-pin and scope disposal wait for every original call, including refused completion and source cleanup. Result inspection names the original owner explicitly rather than guessing one call for a process. Each readiness call retains its own noncopy temporary-mask observation. Installing or discarding it must not overwrite another call's mask or a later permanent mask change. A selected caught occurrence is consumed once and remains reserved for SignalTake; it cannot interrupt another call or be overwritten by another selection. Cancellation and uncertain handoff preserve the original native owners and terminal policy. These changes do not authenticate payload thread identifiers. Native shared-process thread membership, distinct per-thread masks/TLS and complete consumer adoption remain required; asynchronous calls from the current one-TCB execution identity do not satisfy that boundary. Author independent native-owner controls for overlapping waits/intake, capacity refusal, origin mismatch, original result isolation, cancellation, receiver lifetime and signal selection. Testing and CI execution remain deferred under the active instruction; source implementation does not claim runtime validation. ### Original mediator calls and source acceptance — 4 October 2026 Terminal retirement drains every call, including refused completion and source cleanup, before descriptor, provider, scope, watch or receiver disposal. Their original target occupation and sole prospective duplicate source survive fd reuse; stale targets refuse without changing a new binding. Original receipt retries cannot release newer locks. Cancellation cannot overwrite another call or a later permanent mask. Signal selection consumes one actual occurrence and reserves it exclusively for Take; another call cannot reuse it. These sources introduce no additional endpoint, grant or hidden fd. Authentic native shared-process thread membership, shared process actions with distinct per-thread masks/TLS, libc/imported consumer closure and profiling measurements remain open. Payload thread identifiers and duplicated client rows cannot satisfy that boundary. Full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Source acceptance follows the active waiver; missing implementation remains open. Native-serving source acceptance is complete with all eight design criteria. Duplex semantics, scoped named lifecycle, independent controls/native workload sources and maintained socket documentation are source-accepted in the broader socket design; its complete ABI/consumer matrix, complete signal/runtime integration and whole source/performance closure remain open. The phase socket checklist has fourteen children, seven checked, while its parent remains open. ### Native process/thread ownership specification — 4 October 2026 [The complete ownership specification](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/process-thread-ownership.md) defines one original process with shared CSpace/VSpace, capability/fd/action/cwd/creation-mask policy and distinct authenticated native execution occupations. An explicitly sealed original-process factory and retained thread handles authorize Prepare/Start and cleanup; clients gain no global Process route, root or MAP grant. The actual original creator and counted enrollment precede Start. Native membership and caller origin never come from payload labels or copied ClientSlot policy. The contract separates thread-only exit from process exit. Initial-thread departure preserves peers and shared resources. Last-thread preparation serializes creation/Start, settles potentially startable original members and retains the final context for process finalization. Whole-group retirement drains every original member/provider before shared authority reclamation and emits one process event. Join/detach arbitrate one original target, preserve joinability on cancelled uncommitted joins and reconcile committed disposition through reply loss without affecting a replacement generation. Stack/guard, caller-owned storage, TLS/errno/module/destructor and complete architecture state have explicit original lifetime and reclamation boundaries. Current OIR1's 64-byte header uses bytes 56–63 for terminal status; the proposed versioned OIR2 extent is 72 bytes, adding thread identity/generation at 64–71. No runtime ABI/codec is changed by this specification. Mediator process policy remains shared while real enrolled threads own distinct masks/handlers. Fork/exec, native provisioning, target geometry, memory/loader/linker/libc and real workload adoption are coordinated requirements. [Integration's native lifecycle contract](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/native-thread-lifecycle.md) records independent actual membership, blocked-peer progress, initial/last exit, TLS/context, guards, join/detach, failure/reuse, group loss, profiling and tool-consumer evidence. The imported-tool source/version/options and transitive interface matrix remains unresolved. Current one-TCB asynchronous calls do not implement native shared-process threads. Specification acceptance completes the ownership specification only. Native process/member/factory/origin mechanisms, thread-only exit, join/detach, per-thread TLS, libc/imported consumers and real profiling remain open. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Three signed commits across Kernel, Docs and Integration publish 17 paths: 14 maintained documentation sources and three catalog files containing four selector updates. No runtime or Cargo source changes; no Rustfmt inputs. Read-only source/Git inventory records all 269 compiled edges and 162 catalog selections coherent, 4,346 code files below 1,000 lines, retained missing-docs gates, and 153 guards across 76 workflows. All 76 feature trees are clean except preserved Meta cache. Rootd and helper catalog entries retain independent compiled helper `cc878220040dfa741491249434d6b8f8fe2252f7`. Signed documentation/adoption: [docs af376f65](https://git.erikinkinen.fi/erix/docs/commit/af376f658022125af232de67c22427cd7554c202), [integration 5daf30c3](https://git.erikinkinen.fi/erix/integration/commit/5daf30c307a59d2df10a8c694f89d283b10deaf0), [kernel 9660dacf](https://git.erikinkinen.fi/erix/kernel/commit/9660dacf70b80cfce387046e5df6e54232f8619e). Tracking: [ownership specification](https://git.erikinkinen.fi/erix/kernel/issues/44), [native implementation](https://git.erikinkinen.fi/erix/kernel/issues/1), [socket consumers](https://git.erikinkinen.fi/erix/posixd/issues/34), [libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [compatibility ELF/TLS](https://git.erikinkinen.fi/erix/dynlinkd/issues/1), [phase completion](https://git.erikinkinen.fi/erix/integration/issues/65). The complete ownership specification is source-accepted. Every native runtime, thread/TLS, imported consumer, profiling and guest-build implementation/evidence requirement retains its existing open scope. ### Original process lifetime storage — 4 October 2026 Process-window observations consult the current owner; copied metadata cannot enroll another member or acquire authority. Admission requires a reserved native identity and actual objects, reserves both publication directories before retaining backing, and publishes no half-owner on refusal. Seven new controls are authored and unrun: sole window sealing/current observation, contradictory association refusal before hardware effects, copied-peer refusal without an extra backing reference, actual storage failure at both admission allocations, constructor cap-collision rollback, failed final release and generation reuse, and captured origin through actual cleanup/reuse. Invalid VSpaces now refuse at admission; initial-stack failure uses an unregistered high range in the real original VSpace. Genuine member factories/enrollment, versioned thread origins, thread-only exit, departed-leader survival, join/detach, TLS and complete libc/upstream consumers remain required and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Rootless construction observes the sole actual ceiling, and malformed-window controls verify refusal without altering copied metadata. ### Authenticated process and execution origins — 4 October 2026 CLAIM requires both complete keys; COLLECT requires neither. Old/partial/mixed origins refuse before native transfer/output effects. Copied metadata and parsed bytes grant no authority, liveness or native attestation. Posixd preserves full successful CLAIM origin in its original counted call record before interpretation and refuses unknown execution IDs or stale thread generations before request effects. Additional native members still require the open factory/enrollment implementation. Independent modeled controls preserve the denied original owner, empty refusal, unrelated pending peer and lease generation; only an enrolled writer can unblock that peer. Genuine shared-process membership/factories, departed-leader survival, thread-only exit, join/detach, per-thread masks/TLS and full libc/imported-tool consumers remain required and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Original prepared native member custody — 4 October 2026 A noncopy process-bound Kernel factory requires actual held Process SEND of native Process kind in the Running caller's window plus an actual exact-stage GRANT install grant naming a Created initial process. The grant supplies target evidence, never Process authority; scope and rights remain unchanged. An explicit u64 total occupation budget includes the initial execution, and zero/exhausted capacity refuses. Stale or exhausted factory admission refuses before prospective ID/global execution generation allocation. Native keys and factory serials never wrap. Parsed metadata, copied snapshots, ordinary endpoints, inert rights, foreign/stale targets and outside-window grants cannot authorize creation. Factory release refuses until preparations withdraw, preserving the original view and quota. Old member/factory observations cannot dispose replacement occupations. Group terminal/cleanup freezes admission and preflights/drains original preparations before shared inventory effects; a refused final backing release retains the original process owner/reference and cleanup-only initial record for retry. Additional preparations cannot enter legacy initial Start/current-context/window/receiver/child/process mapping/write, install/revocation target, dynamic-link cleanup, CPU-time or process termination/destruction paths. Created native activity notifications have no effects. Nine independent actual-object controls are authored and unrun: shared objects/window and total capacity; native authority negatives; legacy initial-path/copied-peer refusal; member/factory reuse; actual TCB/member allocation failure; dropped member views and final release failure; group terminality and one event; dropped factory retention; nonpristine refusal and exact cleanup retry. No userspace factory capability/wire carrier or runnable member is published. Genuine Start/context, original stack/TLS, mediator enrollment, running-peer scheduling, thread-only exit, departed-leader survival, join/detach, whole-group CPU aggregation, per-thread masks and libc/imported consumers remain mandatory and open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Checklist acceptance records source implementation under the testing waiver. ### Retained original member mapping backing — 4 October 2026 Checked byte ranges carry access observations, no process selector or grant. The actual VSpace retains noncopy original reference records; a dropped view leaves native custody and cannot duplicate the same member continuation. Unmap/remap of the same virtual or physical address cannot validate an old context. Old detached release has no hardware effect on a replacement VA. Live validation requires the same original occupation and current required/forbidden permissions; stored access never restores a withdrawn grant. Positive release records each completed page and retains the same cleanup-only continuation through later managed-frame refusal. Last process backing release and final VSpace teardown refuse before effects while context/detached custody remains. Production initialization cannot erase retained contexts, process references or active roots. Eight actual-object controls are authored and unrun: retained old backing and untouched remapped bytes; overlapping observations/multiple members/dropped views; malformed, borrowed and contradictory ranges; actual capture/detachment storage failures; permission attenuation and last managed backing release; completed-prefix refusal followed by native abort retry; dropped group context and refused last process reference; and mapping/context serial exhaustion. The full native carrier/context/enrollment/Start issue stays OPEN with all eight complete-transaction criteria pending. Complete capability transfer/rollback/removal, original creator continuation, code/stack/guard/TLS/architecture, positive mediator enrollment, genuine once-only Start, all-running-member group stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Full thread lifecycle, departed-leader survival, thread-only exit, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Source completion of this prerequisite does not accept the unfinished initialized-running-member criterion. ### Original native member carrier custody — 11 October 2026 Factory READ/MINT/MANAGE/GRANT and member READ/WRITE/EXECUTE/MANAGE/GRANT have separate observation, construction/context/Start, retirement and unique delegation meanings. Publishers require the actual original source and Running custodian/window, reserve real metadata/native storage before consumption, and preserve the same noncopy source on refusal. Fabricated metadata, numerical targets, copied observations and old serials cannot construct or select native custody. One native stack lease preserves original storage through callbacks outside directory locks; busy owners cannot be erased or reused. Unique delegation requires actual GRANT, active original scope and exact subset rights. Owned invocation intake authenticates source GRANT; private custody retains only the requested recipient mask plus the original GRANT needed for handoff. Final recipient masks/receipts remain exact, including zero; repeated collection cannot recreate a native object. Factory admission freezes before refusal while members remain; metadata restoration cannot resume ordinary authority. Busy/refused cleanup retains the same original group, quota and remaining owners. Production reset refuses actual custody; host quiescent reset preserves carrier serials. Fourteen independent actual-object controls are authored and unrun: fabricated metadata; actual publication/window/mask refusal; serial/slot reuse; unique attenuation and original rollback; READ-only local relocation; failed factory removal with actual admission frozen; remote group abort; busy original group refusal/retry; occupied/widened/inert moves; real destination allocation failure; allocation-free prepared transport commit/rollback; private owned request handoff versus final rights; returned unique collection/descriptive replay; and exact zero owned recipient rights. The complete [native capability/context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight complete-transaction criteria pending. Full operation framing/native/user adapters, actual creator CLAIM and original counted enrollment intent/replay, original code/module/stack/guard/TLS/complete architecture, positive mediator enrollment, once-only genuine Start, all-running-member stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Thread-only exit, departed-leader survival, join/detach and complete compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Original claimed native preparation — 11 October 2026 [Original claimed native preparation](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/claimed-native-preparation.md) now requires actual held factory MINT and actual original successful Serving CLAIM under the same live registered receiver. Parsed origins, numerical identities and labels cannot construct the borrowed proof. The captured caller's process must equal the actual factory scope. Completion, replaced/removed RECV registration, original caller retirement, route loss or group freeze refuses before construction. Changed intent refuses. Histories retain data only, with no extra backing/cap alias/process event; group disposal withdraws original remote custody before native identity/shared disposal. They cover one genuine member/full-quota same-member and retired replay, changed intent/destination/rights/epoch, actual queued/completed/removed RECV refusal, foreign genuine creator, moved historical replay, actual continuation allocation refusal/retry, replaced receiver registration, foreign MINT plus equal RECV possession, fresh quota refusal before allocation, claimed member/group cleanup with one event, literal byte positions, every reserved byte and obsolete/partial/trailing/missing-selector frames. The complete [native control design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight full-transaction criteria pending. Full factory/member operation/native-user adapters, actual counted creator/enrollment intent, original code/module/stack/guard/TLS/complete architecture, positive enrollment, once-only genuine Start, all-running-member stop/drain, real supervisor/loader/mediator provisioning and CPL3 controls remain required. Complete thread lifecycle, departed-leader survival, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Immediate native preparation packet boundary — 11 October 2026 Already serialized admission avoids recursive lifecycle locking; hosted numeric addresses are never dereferenced. Actual held factory MINT, original carrier scope/serial and live registered RECV for the same genuine outstanding Serving CLAIM remain mandatory. Creator/process attribution comes from the actual Kernel invocation owner, never payload labels. Every error preserves original intent and earlier custody; uncertainty cannot justify changed selectors or a successor. Fourteen additional independent controls are authored and unrun: four literal/framing/identity/intent codec controls, four local-refusal/status/uncertainty bridge controls and six genuine native-packet/register/mapping controls. They cover replay across retired/replaced destinations, refusal before constructor/quota effects, absent genuine CLAIM, changed serial/wrong rights, exact zero rights, destination conflict, reserved registers and complete current writable mapping admission including gaps, revocation, stale VSpace and invalid addresses. Actual installed user instructions must check refusal and unchanged bytes before the original complete scenario oracle can pass. Factory construction/provisioning, the complete operation surface, actual counted mediator row adoption and positive enrollment, original code/module/stack/guard/TLS/complete architecture, once-only Start, all-running-member stop/drain and real supervisor/loader/mediator provisioning remain required by the full [native control design](https://git.erikinkinen.fi/erix/kernel/issues/47). All eight complete-transaction criteria stay OPEN. No whole running-thread acceptance is inferred from an unstarted packet boundary. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 sub-items under 167 decomposed parents. Full source acceptance remains independent of deferred execution. ### Original native factory provisioning and READ — 11 October 2026 [Original native factory control](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-factory-abi.md) now exposes actual user factory creation/reconciliation at 0x5D and exact READ observations at 0x5E beside claimed preparation at 0x5C. Fresh creation independently needs actual held Process SEND and exact GRANT evidence for the original Created initial target. Carrier/CSpace/history storage reserve before publication; wrong own rights and zero/exhausted budget refuse before history allocation. Indexed histories use Kernel-captured original current process/execution and the same operation key, never a payload actor. Complete original route/stage/destination/rights/budget intent reconciles the same factory after uncertain reply, setup-grant withdrawal, initial target Start, transfer, removal refusal or retirement. Changed parameters refuse. Held observations read current rights; transferred/retired descriptors are cleanup-only data and cannot recreate a cap, factory, identity or quota. A legitimate fresh key still requires independently held setup authority and an eligible Created target. Production reset refuses both live owners and retained histories. TFC1 request64/TFR1 reply48 use one 112-byte creation packet; NTO1 request24/NTD1 reply48 use one 72-byte READ packet. Actual READ, current window, original serial and actual native indexed owner must agree; fake cap metadata or old serial cannot follow replacements. Seventeen additional controls are authored and unrun: ten genuine native-object creation/READ/uncertainty/refusal controls, four independent literal codec controls and three checked bridge controls. They cover no-allocation same-original replay, changed parameters, grant withdrawal/initial Start, transfer/retirement/reuse, ordinary/weak/fabricated authority, actual allocation failure and occupied destinations, wrong rights/zero quota before storage, exact zero rights/full-width budgets, foreign actual execution, genuine factory/member/cleanup READ, reserved/partial/trailing frames, type-specific identity, original key/scope/budget/rights correlation, native status, uncertain output and local hosted refusal. The maintained owned-invocation VM source adds 18 positive CPL3 calls for user creation/reconciliation, checked initial client Start after stage-grant disposal, genuine successful original CLAIM preparation/full-quota replay, actual factory/member READ, retired history, positive disposal and setup/carrier absence. Temporary Process SEND is removed before ordinary service work; only factory READ/MINT and member READ are retained for required operations. Hooks only observe original instructions/results, never perform effects or replace output. The new factory/preparation marker and original complete oracle require every new witness/user check. The complete [native control design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight full-transaction criteria pending. Real supervisor/loader/mediator deployment, target-generated counted thread storage/adoption, original code/module/stack/guard/TLS/complete architecture, positive original enrollment, once-only member Start and all-running-member stop/drain remain required. Full thread-only exit, departed-leader survival, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress stays 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 sub-items under 167 decomposed parents. Full source acceptance remains independent of deferred execution. ### Counted startup tail repair — 11 October 2026 No old/trailing/partial/overwritten-tail fallback or new authority is added. A disabled literal image requires zero count words and rejects obsolete overwritten-tail bytes. The maintained realm-startup VM source preserves its full oracle for two actual private mediators, authenticated readiness, peer-independent retirement/stale-handle refusal and ordinary successful shell exit. Its description now names the same canonical framing; no acceptance or marker is relaxed. Bug source acceptance closes after complete repair, authored controls, documentation and coherent signed adoption, independently of deferred testing. The full [native control design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight complete-transaction criteria pending. Actual counted thread storage/adoption, complete code/module/stack/guard/TLS/architecture, positive original enrollment, once-only member Start, all-running-member drain and real supervisor/loader/mediator deployment remain required. Full thread exit, departed-leader survival, join/detach and compatibility consumers remain open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred execution. ### Counted original execution storage — 11 October 2026 Older schemas/widths reject without aliases, inferred counts or fallback. Public payload IDs, matching process labels or spare capacity cannot enroll another execution. Unknown/stale/unsealed/failed/native-draining delivery retains its ordinary native custody and refusal obligations. This introduces no extra receiver, process capability, member enrollment or runnable context. Eleven additional execution/arena controls are authored and unrun: empty-capacity refusal, all-original-key admission, retirement/reconstruction prevention, incomplete identity atomicity, missing/previously occupied engine capacity, canonical row association, successful CLAIM/completion/retirement, errored CLAIM custody, spare-row unknown/stale refusal, real target ThreadSlot geometry/disjoint extents and independent grown geometry. Two spare execution rows remain inert while the full existing oracle still requires two actual private mediators, authenticated readiness, independent peer retirement, stale-handle refusal and ordinary successful shell exit. The full [native member control and Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) remains OPEN with all eight original complete-transaction criteria pending. Additional prepared members, current original code/module/stack/guard/TLS and complete architecture state, positive original enrollment, once-only Start and all-running-member stop/drain remain required. Per-thread masks/TLS, thread exit, departed-leader survival, join/detach and all required compatibility consumers remain open. Read-only source inventories record all 4,387 code files below1,000 lines, missing_docs denial at all 98 Cargo crate roots, and153 duplicate PR guards across76 workflows. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical phase progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred execution. ### Original complete member memory custody — 11 October 2026 Stack/TLS/code geometry and module/guard contradictions refuse before native reference publication. Caller-slice mutation or dropped views cannot forget these conditions. Another original complete memory recipe cannot alias retained stack/TLS bytes until positive same-reference release. Positive original release retains completed prefixes and refused native cleanup. Nine independent actual-object controls are authored/unrun: complete original recipe and dropped-view custody, current guard mapping/copied condition ownership, malformed/overlapping/missing geometry, distinct-member exclusive stack/TLS, all capture allocation refusals, original TLS replacement/new-byte preservation, every user-visible guard inventory, current role/module contradictions, and frozen-scope positive cleanup. Existing native VM oracles retain their complete acceptance; this trusted Kernel API introduces no guest context operation or runnable member. The full [native member context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight original complete criteria pending. Strict native context/user adapters and replay, real supervisor/loader/mediator adoption, all-running-member stop/drain, thread exit, departed-leader survival, join/detach and required compatibility consumers remain mandatory. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed. Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction is still unimplemented. ### Original native machine custody and entry ABI — 11 October 2026 Private noncopy aligned images follow genuine execution and process generations through allocation refusal, dropped views, positive cleanup and ID reuse. Hosted model images never provide privileged transfer or native execution proof. Thirteen independent unit controls are authored/unrun: eight geometry/storage/default/refusal controls and five actual-object allocation/replay/TLS-change/identity-reuse/drop/host-transfer controls. The additional NATIVE_MACHINE_STATE_OK marker requires every existing full native oracle and user check. The full [native member context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight original complete criteria pending. Full running-member drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread exit, departed-leader survival, join/detach and required compatibility consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed. Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished. ### Original native state reconciliation preflight — 11 October 2026 Existing private storage cannot bypass this admission. An additional original-object control covers missing-baseline allocation refusal, unchanged Created identity/image, same-original Start retry and allocation-free unchanged fully prepared replay; it is authored and unrun. Private noncopy aligned images follow genuine execution and process generations through allocation refusal, dropped views, positive cleanup and ID reuse. Hosted model images never provide privileged transfer or native execution proof. Fourteen independent unit controls are authored/unrun: eight geometry/storage/default/refusal controls and six actual-object allocation/replay/TLS-change/identity-reuse/drop/host-transfer controls. The additional NATIVE_MACHINE_STATE_OK marker requires every existing full native oracle and user check. The full [native member context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight original complete criteria pending. Full running-member drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread exit, departed-leader survival, join/detach and required compatibility consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed. Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished. ### Retained initialized native context — 11 October 2026 Actual current CPU policy, private initialized FS/FP/vector state and independent processor baseline remain mandatory. Remapping cannot substitute backing between validation and effects. Write refusal retains the native pending record, original machine/reference custody and immutable input/completed-prefix progress. Same input retries without another context occupation or allocation; changed arguments/TLS/geometry refuses. Ordinary original memory-reference release refuses while that context depends on it. A retired serial cannot erase a later context on the same unstarted member. Eleven actual-object controls are authored/unrun: exact initialized bytes/private GPR defaults, full-quota allocation-free replay and changed input, allocation refusal before effects with exact retry, input extent/initial-stack ABI refusal, cross-member memory denial, dependent release/stale same-member refusal, dropped views/member cleanup, frozen cleanup, original TLS replacement with untouched new bytes, whole-group disposal and actual page-write refusal with immutable pending input/completed-prefix retry. The full [native member context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) remains OPEN with all eight original complete criteria pending. Positive mediator enrollment, once-only Start, running-group drain and actual supervisor/loader/mediator deployment remain mandatory, followed by thread lifecycle and required consumers. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed. Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished. ### Original independently usable native state — 11 October 2026 Original PKRU is retained with the same noncopy FS/GS/feature-disable owner, initialized Kernel zero precedes scoped dispatch and selected-original return restores exact state with the required register inputs and compiler memory boundary. Actual instruction availability cannot silently narrow the preserved state. Current profile changes refuse old-image admission. Ordinary images enable no hardware, allocate no protection keys and change no native mapped authority through this boundary. The separately selected native diagnostic requires actual PKU/XSAVE support and owns isolated BSP CPU configuration before any original native execution. Three original CPL3 participants require initialized zero and distinct PKRU values across every native return, handoff, blocking and hardware deadline wake. Privileged dispatch independently observes actual zero and unmanaged components1/9; hooks supply no register effects. Native deadlines/stall/exit and ordered/unique marker acceptance stay intact. One independent descriptor/default/host-refusal control, strict scenario/direct-builder selection controls and the actual native diagnostic are authored and unrun. The full [native member context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) remains OPEN with all eight complete criteria pending. Strict actual member-WRITE user context/creator/intent/caller-copy controls, positive mediator enrollment, once-only Start, running-group drain and real supervisor/loader/mediator deployment remain mandatory. Required thread lifecycle/consumers and both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed. Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished. ### Original counted member context — 11 October 2026 Unknown roles, malformed input and dirty reply reservations refuse. A noncopy member continuation retains immutable original input and genuine memory/context views through refusal. Exact replay uses the same original occupation; changed intent, a withdrawn ready view or replaced backing cannot recreate a context. A separate packet page preserves original unmapped-gap refusals. Both maintained positive scenarios keep every complete factory/machine/invocation/protection-key oracle and additionally require NATIVE_MEMBER_CONTEXT_OK. Hooks supply no context effect. The full [native context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) remains OPEN with all eight complete criteria pending. Positive original mediator enrollment, revalidated once-only member Start, running-group drain and actual supervisor/loader/mediator deployment remain mandatory. Required thread lifecycle/consumers, both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed. Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished. ### Positive original native enrollment — 11 October 2026 Actual current member WRITE, expected member/context serials, ready original context, active native scope and identical successful still-Serving creator CLAIM/row captured during preparation are independently required. Sealed noncopy admission borrows genuine member/context/native claim; scalar labels and descriptive receipts cannot construct it. Changed context/creator/row, stale current authority or closed/replaced claim refuses. Ordinary context withdrawal cannot erase positive enrollment. It binds immutable member/context input before native enrollment, and requires exact output matching the earlier initialized process/thread observation before committing distinct-member intake. Both complete CPL3 scenarios additionally require NATIVE_MEMBER_ENROLLMENT_OK: actual user instructions use returned member/context keys and successful CLAIM, check inaccessible spans/reserved fields/row refusal and exact replay, then positively dispose the same unstarted member. Hooks perform no effect; every original context/machine/protection/invocation oracle remains. The full [native context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) stays OPEN with all eight complete criteria pending. Revalidated once-only Start, all-running-member drain, actual ordinary thread-creation/deployed supervisor/loader/mediator provisioning and required per-thread lifecycle/masks/ELF/TLS/consumers remain mandatory. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain unperformed. Existing missing_docs denial and useful inline ownership/geometry/error documentation remain in source. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Source acceptance remains independent of deferred testing; the complete additional-member transaction remains unfinished. ### Original member Start and group retirement — 11 October 2026 Current actual member EXECUTE, original positive context/enrollment and counted row are independently required. Sealed noncopy admission borrows genuine native objects; process/thread IDs, creator delivery, saved pointers and copied receipts supply no authority. Pager, child supervision and final CPU totals belong to the shared process; a running member may bind a child while its initial peer blocks through actual held GRANT. Destruction refuses original active user/kernel intervals and runnable/blocked members before cleanup custody or remote/shared effects. Positive drain settles mappings, erases private context/machine/register storage and folds member CPU totals before identity reuse; refusal retains original custody and positive release progress. Local acknowledged replay is a descriptive observation and performs no new native effect. The separate kernel-running-members-positive scenario requires both original invocation and protection-key fixtures and preserves every existing factory/context/enrollment/machine/protection/invocation/activity/watch/deadline/terminal oracle, additionally requiring NATIVE_RUNNING_MEMBERS_OK. The complete [native context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) remains OPEN with its original eight full criteria pending. Ordinary production creation/deployment, loader ELF/TLS construction, per-thread masks, join/detach, lifecycle and required consumers remain unfinished. Both full EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Complete native creation/deployment and required consumers remain unfinished. ### Authenticated per-thread signal state design — 11 October 2026 Complete the native-member signal boundary alongside ordinary thread creation and deployed consumers. Shared process actions and controller-generated process pending state remain with the original configured process. Each counted original ThreadSlot retains its own effective mask, self-directed pending bits, selected caught occurrence and uncertain-handoff freeze. New members copy only the genuine creator thread mask at actual reservation, with empty task pending/selected state; exact reservation/enrollment/Start replay never resets it. No payload PID/thread label or copied native receipt selects signal authority. Capture the admitted original counted row/generation and complete native CLAIM origin in each serving owner before interpreting compatibility operations. All later byte/provider/readiness interruption and temporary-mask selection/settlement use that same original task, refusing stale/replaced occupations. Thread-directed self generation never interrupts a peer; process-directed occurrences remain shared until one eligible original task selects them. Selection consumes exactly one occurrence; later generation and peer pending bits survive. Shared reset-hand actions commit once; Ignore discards unselected pending conditions across the original group. Temporary-mask tokens bind original task occupation and cannot settle through another member. A failed/uncertain native caught handoff freezes only its original task while preserving native owner/result and shared process policy. Controller-default process termination and terminal retirement retain whole-process gates. Shared receiver/descriptor/clock/provider authority and counted storage remain unchanged; authenticated target-generated arena geometry includes actual row sizes. No fixed private thread/pending-count limit or new lookup/control capability is introduced. Author multi-member mask/action/self-versus-process pending, creator inheritance, wait/selection/replay, short-result/uncertain publication and terminal retirement controls. Maintain existing complete VM oracles. Ordinary creation/deployment, ELF/TLS, join/detach, lifecycle, required consumers and full EriX/external Rust/LLVM guest rebuilding remain required. Tests/builds/lint/rendering/VM/profiler execution and CI observation remain deferred; this design does not claim runtime implementation or completion. Specification references: [POSIX thread creation](https://pubs.opengroup.org/onlinepubs/9799919799/functions/pthread_create.html) and [POSIX signal generation and delivery](https://pubs.opengroup.org/onlinepubs/9799919799/functions/V2_chap02.html). ### Original per-thread signal ownership — 11 October 2026 Payload IDs, handler labels and copied receipts supply no peer authority. Shared actions remain one process policy: unavailable defaults preflight all task/process pending state, Ignore discards unselected group conditions, and reset-hand selection cannot overwrite a later shared action change. Wrong-task or other settlement refusal preserves the original token; successful matching cancellation/selection is once-only. Selected occurrence stays with its task while another member's self signal cannot interrupt a peer wait. Refused/uncertain caught publication retains original native owner/result and freezes only its original task; eligible default termination and authentic terminal retirement retain whole-process duties. Seven additional counted mediator/policy controls are authored and unrun for creator mask inheritance, shared actions, separate process/self consumption, peer-pending refusal and Ignore, task-only uncertain handoff, default eligibility, retained member readiness and wrong-task token refusal/retry/once-only settlement. The complete [native context/enrollment/Start design](https://git.erikinkinen.fi/erix/kernel/issues/47) remains OPEN with its original eight full criteria pending. Normal production creation/deployment, ELF/TLS, join/detach, lifecycle and complete libc/native consumers remain unfinished. Both full EriX guest build generations and rebuilding external Rust/LLVM inside EriX remain mandatory and unperformed. Canonical progress remains 21.78% weighted and 10.11% whole acceptance: 33/460 parents and 503/970 children under 167 decomposed parents. Complete native creation/deployment and required consumers remain unfinished. </details> <details> <summary>Related records and contracts</summary> | Repository | Links | | --- | --- | | blockd | [PR 2](https://git.erikinkinen.fi/erix/blockd/pulls/2) | | coreutils | [PR 2](https://git.erikinkinen.fi/erix/coreutils/pulls/2) | | crashd | [PR 2](https://git.erikinkinen.fi/erix/crashd/pulls/2) | | deviced | [PR 3](https://git.erikinkinen.fi/erix/deviced/pulls/3) | | docs | [PR 4](https://git.erikinkinen.fi/erix/docs/pulls/4) | | drv-acpi | [PR 2](https://git.erikinkinen.fi/erix/drv-acpi/pulls/2) | | drv-i8042 | [PR 2](https://git.erikinkinen.fi/erix/drv-i8042/pulls/2) | | drv-ps2-keyboard | [PR 2](https://git.erikinkinen.fi/erix/drv-ps2-keyboard/pulls/2) | | drv-ps2-mouse | [PR 2](https://git.erikinkinen.fi/erix/drv-ps2-mouse/pulls/2) | | drv-rtc-cmos | [PR 2](https://git.erikinkinen.fi/erix/drv-rtc-cmos/pulls/2) | | drv-serial | [PR 2](https://git.erikinkinen.fi/erix/drv-serial/pulls/2) | | drv-virtio-block | [PR 2](https://git.erikinkinen.fi/erix/drv-virtio-block/pulls/2) | | dynlinkd | [PR 3](https://git.erikinkinen.fi/erix/dynlinkd/pulls/3) | | e2fsd | [PR 3](https://git.erikinkinen.fi/erix/e2fsd/pulls/3) | | exsh | [PR 3](https://git.erikinkinen.fi/erix/exsh/pulls/3) | | extop | [PR 2](https://git.erikinkinen.fi/erix/extop/pulls/2) | | fatd | [PR 3](https://git.erikinkinen.fi/erix/fatd/pulls/3) | | fbcond | [PR 2](https://git.erikinkinen.fi/erix/fbcond/pulls/2) | | hotplugd | [PR 2](https://git.erikinkinen.fi/erix/hotplugd/pulls/2) | | inputd | [PR 2](https://git.erikinkinen.fi/erix/inputd/pulls/2) | | irqd | [PR 2](https://git.erikinkinen.fi/erix/irqd/pulls/2) | | kernel | [issue 45](https://git.erikinkinen.fi/erix/kernel/issues/45), [issue 46](https://git.erikinkinen.fi/erix/kernel/issues/46), [PR 3](https://git.erikinkinen.fi/erix/kernel/pulls/3), [independent-machine-state.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/independent-machine-state.md), [initialized-native-context.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/initialized-native-context.md), [native-context-memory.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-context-memory.md), [native-machine-state.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-machine-state.md), [native-member-carriers.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-member-carriers.md), [prepared-native-members.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/prepared-native-members.md), [process-lifetime-storage.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/process-lifetime-storage.md), [retained-member-mappings.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/retained-member-mappings.md) | | keyd | [PR 2](https://git.erikinkinen.fi/erix/keyd/pulls/2) | | launchd | [PR 2](https://git.erikinkinen.fi/erix/launchd/pulls/2) | | lib-block | [PR 2](https://git.erikinkinen.fi/erix/lib-block/pulls/2) | | lib-bootstrap | [PR 2](https://git.erikinkinen.fi/erix/lib-bootstrap/pulls/2) | | lib-capabi | [PR 2](https://git.erikinkinen.fi/erix/lib-capabi/pulls/2) | | lib-driver | [PR 2](https://git.erikinkinen.fi/erix/lib-driver/pulls/2) | | lib-input | [PR 2](https://git.erikinkinen.fi/erix/lib-input/pulls/2) | | lib-interrupt | [PR 2](https://git.erikinkinen.fi/erix/lib-interrupt/pulls/2) | | lib-ipc | [issue 5](https://git.erikinkinen.fi/erix/lib-ipc/issues/5), [issue 6](https://git.erikinkinen.fi/erix/lib-ipc/issues/6), [PR 2](https://git.erikinkinen.fi/erix/lib-ipc/pulls/2), [native-context-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-context-abi.md), [native-enrollment-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-enrollment-abi.md), [native-preparation-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-preparation-abi.md), [native-start-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/native-start-abi.md), [owned-invocation-abi.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/owned-invocation-abi.md), [socket-admission.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/socket-admission.md) | | lib-log | [PR 2](https://git.erikinkinen.fi/erix/lib-log/pulls/2) | | lib-posixabi | [PR 3](https://git.erikinkinen.fi/erix/lib-posixabi/pulls/3), [local-stream-sockets.md](https://git.erikinkinen.fi/erix/lib-posixabi/src/branch/feature/posix-compat/docs/local-stream-sockets.md) | | lib-service | [PR 2](https://git.erikinkinen.fi/erix/lib-service/pulls/2) | | lib-stdio | [PR 2](https://git.erikinkinen.fi/erix/lib-stdio/pulls/2) | | lib-time | [PR 2](https://git.erikinkinen.fi/erix/lib-time/pulls/2) | | lib-tty | [PR 2](https://git.erikinkinen.fi/erix/lib-tty/pulls/2) | | lib-vfs | [PR 2](https://git.erikinkinen.fi/erix/lib-vfs/pulls/2) | | loaderd | [PR 2](https://git.erikinkinen.fi/erix/loaderd/pulls/2) | | logd | [PR 4](https://git.erikinkinen.fi/erix/logd/pulls/4) | | memd | [PR 2](https://git.erikinkinen.fi/erix/memd/pulls/2) | | named | [PR 2](https://git.erikinkinen.fi/erix/named/pulls/2) | | pagerd | [PR 2](https://git.erikinkinen.fi/erix/pagerd/pulls/2) | | posixd | [issue 35](https://git.erikinkinen.fi/erix/posixd/issues/35), [issue 36](https://git.erikinkinen.fi/erix/posixd/issues/36), [issue 37](https://git.erikinkinen.fi/erix/posixd/issues/37), [issue 38](https://git.erikinkinen.fi/erix/posixd/issues/38), [issue 39](https://git.erikinkinen.fi/erix/posixd/issues/39), [local-stream-sockets.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/local-stream-sockets.md), [thread-signals.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/thread-signals.md), [thread-storage.md](https://git.erikinkinen.fi/erix/posixd/src/branch/feature/posix-compat/docs/thread-storage.md) | | powerboxd | [PR 2](https://git.erikinkinen.fi/erix/powerboxd/pulls/2) | | probed | [PR 2](https://git.erikinkinen.fi/erix/probed/pulls/2) | | procd | [PR 2](https://git.erikinkinen.fi/erix/procd/pulls/2) | | ramfsd | [PR 2](https://git.erikinkinen.fi/erix/ramfsd/pulls/2) | | rootd | [PR 2](https://git.erikinkinen.fi/erix/rootd/pulls/2) | | seriald | [PR 2](https://git.erikinkinen.fi/erix/seriald/pulls/2) | | timed | [PR 2](https://git.erikinkinen.fi/erix/timed/pulls/2) | | ttyd | [PR 3](https://git.erikinkinen.fi/erix/ttyd/pulls/3) | | vfsd | [issue 29](https://git.erikinkinen.fi/erix/vfsd/issues/29), [PR 3](https://git.erikinkinen.fi/erix/vfsd/pulls/3) | | vspaced | [PR 2](https://git.erikinkinen.fi/erix/vspaced/pulls/2) | </details>
Author
Owner

edeff8c7 adds fresh TLS preparation for additional native threads. It rebuilds self/DTV state and zero errno from the initial immutable registry, then binds the birth request to the planned TLS range and FS base. The separate thread workload now consumes Loaderd’s registry and checks independent errno across join, detach and storage reuse. General stack/TLS allocation and dynamic module lifetime remain open.

[edeff8c7](https://git.erikinkinen.fi/erix/posixd/commit/edeff8c73f56cb79d9f463671b6570040a772602) adds fresh TLS preparation for additional native threads. It rebuilds self/DTV state and zero errno from the initial immutable registry, then binds the birth request to the planned TLS range and FS base. The separate thread workload now consumes Loaderd’s registry and checks independent errno across join, detach and storage reuse. General stack/TLS allocation and dynamic module lifetime remain open.
erikinkinen added this to the Alpha 1 milestone 2026-10-30 09:35:07 +01:00
Sign in to join this conversation.
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
erix/posixd#34
No description provided.