[FEATURE] Publish original native member capabilities and initialized Start #47

Open
opened 2026-10-04 17:11:07 +02:00 by erikinkinen · 0 comments
Owner

Problem and motivation

Original prepared native members share actual process objects and retained Kernel custody, but userspace cannot obtain a native factory/member carrier, initialize an original context or commit genuine enrolled Start. Real shared-thread execution is required for compatibility consumers and complete EriX plus external Rust/LLVM rebuilding inside EriX.

Proposed behavior and scope

Implement the complete original native factory/member capability and initialized Start transaction. Define typed native carrier IDs and exact narrowed rights, strict versioned codecs, native controls and userspace adapters. Factory creation requires actual supervisor Process authority and exact stage evidence. Delegation carries only the original process-bound factory and explicit total budget; ordinary clients acquire no supervisor Process, root, mapping, receiver or provider authority.

Native preparation derives the process from its actual held factory and captures the actual successful creator CLAIM and original counted mediator row. Retain one original native continuation through uncertain preparation/publication, with exact replay and no duplicate construction. Retain and initialize the actual original code/stack/guard/TLS mapping occupations, backing and complete architecture context. Positive original mediator enrollment precedes runnable publication. Start revalidates the same context and commits that same member once.

Extend capability intake, unique carrier movement, rollback, cleanup, group terminality and original member-only retirement coherently. Integrate supervisor/loader/mediator provisioning and actual creator enrollment. Preserve authentic OIR2 process/thread attribution. Author independent actual-object and real CPL3 workload controls for distinct genuine executions sharing one actual group, initialized state, refusal, reuse and cleanup. Keep the complete thread lifecycle, departed-leader survival, join/detach and compatibility consumer requirements explicit throughout implementation.

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

Numerical keys, addresses, labels and parsed metadata never mint authority. Current context identifies the actual caller's held grants but does not replace them. Factory scope and rights are never broadened. Native carriers have actual unique binding custody; copied metadata cannot create a carrier. Transfer reserves original storage and preserves the exact source through rejected publication and pre-delivery rollback. Destruction and carrier loss retain unresolved original native ownership until positive cleanup.

Mapping context observations must name the same original mapping occupations and current permissions, with real retained backing. Unmap/remap at the same virtual or physical address cannot validate an old preparation. Withdrawing or attenuating a mapping never restores old permissions from a context snapshot. Normal authorized unmapping remains possible while detached backing is retained until original context references settle. Code is executable and nonwritable; stack/TLS are writable and nonexecutable; guard and occupation geometry are checked without new hidden limits. No borrowed or uninitialized architectural context is exposed, and one member's TLS/FP/vector state cannot leak into another execution.

Missing enrollment, stale/foreign carriers, deficient permission/backing, overlap, malformed framing, explicit zero/exhausted budget, allocation/generation exhaustion and group freeze refuse before runnable publication. Group exit/kill and supervisor loss stop all original members before shared inventory disposal, preserving one process event and original backing through failure. Start, terminality, native caller/provider cleanup and final context/storage release remain separate positive boundaries.

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
  • Define and adopt exact native capability rights, strict factory/member/context codecs, operation IDs and original native/user adapters without widening existing authority.
  • Implement actual original carrier binding custody, unique transfer/reservation/rollback and positive removal/revocation with original cleanup retained through failure.
  • Bind preparation to actual held factory and successful creator CLAIM/enrollment intent; retain original continuation, exact replay and quota through uncertain publication and refusal.
  • Retain actual original mapping occupations/backing and initialized code/stack/guard/TLS/architecture context; reject replaced mappings and permission contradictions without restoring old grants or imposing hidden unmap limits.
  • Implement positive original mediator enrollment and revalidated once-only Start; additional members execute only through this complete initialized transaction.
  • Stop/drain every original member/context before shared group disposal and retain group identity, accounting/custody and backing through failure without per-member process purge/events.
  • Adopt actual supervisor/loader/mediator provisioning and author independent native-object, codec, authority-negative, allocation/refusal/replay and real CPL3 shared-execution workload controls.
  • Maintain useful rustdoc/missing-docs gates, code below 1,000 lines, component/manual contracts, signed immutable producer/consumer graphs, owning reviews and phase completion tracking; preserve full lifecycle and guest rebuilding requirements.

Alternatives and tradeoffs

Unstarted Kernel records alone cannot establish shared-thread execution. Native carriers require original capability lifecycle and execution context custody together. Detached mapping backing can remain retained without preserving a withdrawn mapping grant or preventing ordinary authorized unmapping. Indexed original occupations and explicit deployment-counted storage avoid global peer searches or private thread limits while retaining exact generations and positive cleanup.

Tracking and rollout

Ownership specification, prepared custody, native implementation, socket/thread consumers, libc, compatibility ELF/TLS, phase completion. Implement original context/backing custody, exact carriers/native controls, enrollment/Start and coordinated real provisioning/workloads, then reconcile the complete source transaction. Tests, builds, lint, rendering, VM/profiler execution and CI observation remain deferred; no executed native or guest-build result is claimed.

Detailed scope and contracts

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 mediator execution storage contract

Complete the existing native transaction with explicitly supplied thread capacity, separately owned execution rows and target-generated type geometry. The immutable arena descriptor advances to version six with actual ThreadSlot size/alignment; startup advances to RBS1 minor six (header272, image352), canonical configuration to minor eight (header144), Begin configuration120 and provisioning160. Tail positions continue deriving from complete declared extents. Reject old/trailing/partial versions without aliases or fallback; migrate every actual producer, consumer, digest/geometry calculation and maintained fixture together.

The counted arena consumes disjoint storage and initializes authority-empty noncopy thread rows. Require capacity for the originally configured initial executions before service admission. Frozen process metadata reserves expected initial rows; only the actual retained successful native CLAIM confirms the original initial execution. Unknown, stale or forged additional executions remain refused. Keep process receiver/shared policy separate from execution ownership and preserve row identity/generation through retirement. Explicit spare capacity does not enroll a member, provide native factory authority or authorize Start.

Reserve one real original counted row/generation before native preparation and retain the actual original member/intent through uncertain replies. Positive native enrollment must follow actual service ownership and complete original context; copying row labels never substitutes. Complete the original supervisor/loader/mediator deployment, code/module/stack/guard/TLS/architecture, once-only Start and running-group drain within the same full design. All eight full acceptance criteria remain pending; this storage contract does not narrow them. Author independent positive/negative/refusal/capacity and native VM sources; testing, builds, lint/rendering, VM/profiling and CI observation remain deferred.

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 code/stack/guard/TLS memory context contract — 11 October 2026

The original admitted noncopy member will retain a complete memory-context recipe: executable/nonwritable code containing entry, writable/nonexecutable stack containing the entire red zone and synthetic return slot, writable/nonexecutable TLS containing the original thread pointer, explicitly supplied module observations, and independently counted unmapped guard ranges with a guard immediately below the stack. Guard page geometry follows actual hardware mapping granularity; stack/TLS byte ranges and module count have no private deployment ceiling.

Capture preflights all descriptive geometry, current original mapping occupations/backing/permissions, guard absence, exclusive stack/TLS overlap with existing original member memory recipes and storage before publishing any reference. Native VSpace custody copies the original conditions; caller-slice mutation or dropped views cannot forget them. Guard admission does not reserve mapping authority or prohibit ordinary authorized mapping: later mapping invalidates current context admission. Current mapping permissions and exact original occupations are revalidated beside current guard absence; unmap/remap cannot select replacement backing or restore withdrawn rights. Positive release retains original progress through failure and removes exclusive memory conditions only with the same native reference. Module observations grant no loader/mapping/provider capability.

Memory-context retention remains a prerequisite inside the complete transaction. It must not publish initialized architectural state, positive mediator enrollment or runnable Start by itself. Full native context/TLS/FP/vector isolation, once-only Start, all-running-member drain and real supervisor/loader/mediator adoption remain required, with all eight complete criteria pending. Controls will be authored and unrun; tests/builds/lint/rendering/VM/profiling/CI observation remain deferred. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain mandatory.

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.

Private original architectural state contract — 11 October 2026

Initialize and retain actual private per-execution general-register, FS/GS selector/base and enabled extended-state storage. Processor-discovered format, enabled XCR0/IA32_XSS masks and CPUID component geometry govern complete save-area sizing/alignment, including variable future component sizes, without a private512-byte or small feature-count ceiling. Use legacy FXSAVE only when it represents the current enabled state; standard XSAVE or compacted XSAVES/XRSTORS preserve their exact processor format. Sealed native CPU observations remain independent of request data; a copied layout never authorizes hardware save/restore or native context publication.

Fresh state uses deterministic initialized registers/TLS and architectural defaults, without copying another execution or boot FP/vector contents. Saved images remain private Kernel-owned noncopy buffers with original native identity and lifecycle custody. Capture before privileged dispatch and restore only the selected original live execution across syscall, fault, interrupt and scheduler returns; Kernel entry uses its independent baseline. Restore selectors before original FS/GS bases. Preserve feature-disable state where required, reject a changed/incompatible processor layout before use, and retain original storage through uncertain cleanup. No borrowed user pointer can supply saved state. Positive original memory, creator CLAIM, mediator enrollment and once-only Start remain separate mandatory prerequisites.

The existing target compiler contract uses freestanding nonvector/nonfloating-point Kernel code by default; this must remain true at entry and return boundaries. Source algorithms are authored independently from processor specifications, without third-party implementation code. Primary references: Intel architecture manual, current Intel manuals catalog, and Rust target contract. Complete native architecture isolation, user context/replay adapters, actual enrollment/Start/deployment and all-running-member drain remain required; all eight full criteria stay pending. Controls will be authored/unrun, with testing/builds/lint/rendering/VM/profiler/CI observation deferred. Full EriX and external Rust/LLVM guest rebuilds remain mandatory.

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 context and bounded partial initialization

Bind a private complete general-register image, the original native FP/vector/FS owner and a copied opaque TLS initialization recipe to the same actual prepared member and retained native memory reference. Trusted Kernel callers must hold the genuine noncopy member and same original memory view; the eventual user adapter independently requires current held member WRITE and the original actual creator CLAIM/intent. An address, a TCB snapshot or a copied reference key supplies none of this authority. TLS layout and ELF/template policy remain loader/libc obligations; the Kernel copies explicitly supplied data only into the original retained TLS interval and zeroes its remainder, without inventing a fixed TCB layout.

Every geometry, same-original identity/current mapping condition, serial and storage allocation preflights before initialization publishes native custody or changes bytes. Own the copied TLS recipe and complete initialized GPR array in indexed native storage before any stack/TLS effect. A page-bounded copy retains exact original completed-prefix progress under the same VSpace reference/occupation lock. Initialize only the admitted synthetic stack return word and TLS bytes. Refusal retains the same pending context, immutable input intent and private machine image; changed arguments/TLS/geometry cannot reconcile it or acquire another occupation. Completed TLS initialization and original state validation precede the ready-context marker. No partial or ready context supplies mediator enrollment or runnable Start.

Dropped views retain the original pending/ready record and allocation. Ordinary memory-reference release refuses while original initialized context depends on it; positive context withdrawal remains possible through frozen cleanup. Member abort and whole-group drain settle same-original mapping, context/GPR/TLS-recipe and machine custody before ID reuse. A retired context key cannot erase a replacement context, even on the same unstarted execution; serials never wrap or reset into aliases. Ordinary initial-process mutation remains distinct from later genuine execution-specific Start/frame/accounting operations.

Author actual-object controls for allocation refusal before effects, initialized bytes and register defaults, changed/stale/cross-member inputs, exact zero-allocation replay, detached/replaced TLS with unchanged new bytes, pending copy retry, dropped views, dependent-memory refusal and positive original cleanup/reuse. Add guest controls when the strict native user adapter exists. These sources are authored independently without third-party code. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred. All eight original full criteria stay OPEN, including actual creator/enrollment/Start/deployment/running-group drain. Full EriX and external Rust/LLVM guest rebuilding remain mandatory.

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.

Independent user protection-key register state

Actual processor observation must distinguish the user protection-key instruction interface from XSAVE component management. Retain the original PKRU value in private native auxiliary custody whenever actual OSPKE/CR4.PKE enablement permits it, including legacy format or a current XCR0 mask without component 9. Kernel entry installs its independent initialized baseline and return restores the selected original value; current interface changes invalidate profile admission. No user payload enables hardware, supplies register state or changes native mapping permissions. This preserves complete state without a private feature-size restriction or silently omitting independently enabled state.

Add a separately selected isolated native diagnostic that enables actual supported PKE before any native execution owner and deliberately leaves PKRU outside XCR0 management. Three original CPL3 participants require initialized zero, distinct original register values across ordinary syscall/handoff/blocking/deadline returns, and independently observed zero in privileged dispatch. Unsupported hardware must fail the positive diagnostic; a skipped operation or host model is not positive evidence. Preserve every existing complete invocation/machine oracle, hard/stall deadlines and ordinary-image behavior. Add exact scenario/direct-builder selection controls and source documentation. Tests/builds/lint/rendering/VM/profiling/CI execution stay deferred, and all eight full native member criteria remain OPEN.

Complete independently usable legacy state

SSE instruction availability is also independent of XCR0 component1 management. Preserve the complete legacy register region with FXSAVE/FXRSTOR when an extended profile omits that component, while retaining the exact enabled extended format/header and every managed component. Do not enable ordinary-image hardware or invent a feature-size restriction to make an incomplete image appear complete.

The isolated independent-state diagnostic additionally enables actual supported XSAVE with XCR0 selecting x87 alone before any native owner. Existing complete x87/all-XMM/control/user-return checks then exercise unmanaged SSE alongside independently enabled PKRU. Require actual support, exact managed-mask observations and independent zero/default baselines, preserving every original native oracle and deferred execution status. This updates the diagnostic's deliberate boot policy; ordinary images and actual mapping authority remain unchanged. All eight complete member criteria stay OPEN.

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.

Strict original member context operation and packet

Use a new immediate native member context operation 0x5F with one complete current readable/writable caller packet and zero unused registers. NCI1 request header is 192 bytes: original current member/receiver slots, member serial, actual delivery selector, original row/generation intent, entry/stack/thread pointers, explicit code/stack/TLS ranges, three initial arguments, counted modules/guards/TLS-prefix bytes and exact request extent. Modules use 24-byte base/length/role/reserved records, guards use 16-byte base/length records, then inline opaque TLS bytes and one zero-reserved 64-byte NCR1 reply. Checked count products/sums, exact complete framing, reserved words, role tags, zero structural selectors and ordinary range geometry refuse; there is no private input/module/TLS count limit or old-frame fallback.

Actual current member WRITE and expected original native carrier serial, live native member scope and the same original successful outstanding creator CLAIM/row intent precede any target observation or effect. No caller-origin, target PID/thread ID, saved register image or CPU-control bitmap occurs in the request. Slot/receiver selectors narrow actual held current authority; the captured native creator/intent determines the original process and member. Same creator/intent input preserves original memory/context custody through allocation/write/reply refusal. Changed geometry, arguments, module/guard order/roles or TLS bytes cannot reconcile a retained attempt or create a successor. Input snapshots and retained intent are Kernel-owned and erased on original disposal.

Copy caller input before target effects and release the user borrow, including when process-owned target backing could alias caller packet memory. Retain original memory references and immutable request continuation before initialization can become uncertain. Extract serialized trusted member/memory/context cores without recursively acquiring lifecycle exclusion. Exact replay uses original references/context rather than recapturing them. Encode a complete local reply, then revalidate original current caller identity and whole packet span before publishing only the reply. NCR1 reports current original member/context serials, genuine process/thread observations and original entry/thread/stack addresses; parsing supplies no held authority, enrollment or Start.

Add checked user bridge handling with exact output extent, original-request reconciliation and retained/uncertain original custody, plus independent malformed/range/count/allocation/claim/rights/stale/cleanup controls and real CPL3 context-operation sources. Preserve every full existing VM oracle and original allocation/partial-prefix cleanup. This completes the context operation without accepting the still-required positive mediator enrollment, once-only Start, running-group drain or real deployment/consumer requirements. All eight original full criteria stay OPEN. Tests/builds/lint/rendering/VM/profiling/CI execution remains deferred; full EriX and external Rust/LLVM guest rebuilding remain mandatory.

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 member enrollment

Add immediate operation 0x60 with exact NEN1 request64 plus zero NER1 reply64. Request fields are current member/receiver slots, original member/context serials, actual outstanding delivery and original row/generation; all unused registers and reserved fields are zero. No request supplies process/thread attribution. Actual member WRITE, active original scope, initialized same-original context and the identical successful still-Serving creator CLAIM and row intent independently precede enrollment.

Native context custody retains the original positive enrollment, captured creator identity, intended row and a distinct nonwrapping enrollment serial. Allocate/reserve every fallible prerequisite before positive publication. Same intent reconciles the same original enrollment; changed creator/context/row refuses. Duplicate live row intent in the same original process refuses. Ordinary context withdrawal cannot discard positive enrollment; original unstarted member/group disposal settles it positively with existing memory/machine custody. Ready/enrolled context still supplies no Start.

The real mediator owns separately counted noncopy thread rows. Reserve a pristine spare row against its actual retained successful creator delivery and original configured process before invoking native enrollment; ordinary payload labels and parsed descriptors cannot admit a thread. Retain original reservation/intent through native status or inconsistent positive output, and reconcile only the same original continuation. Commit enrolled origin only from exact positive native member/context/enrollment output matching the actual configured original process. Intake may admit that distinct execution only against this positive original row and genuine CLAIM metadata. Process retirement closes all its original rows.

Author independent literal/bridge, actual native authority/refusal/replay/cleanup and real CPL3 enrollment sources; keep every full existing oracle and add a positive enrollment marker. Maintain component/manual contracts and coherent signed graph. Positive once-only Start, complete running-group drain, actual deployed provisioning/ELF/TLS/consumers and full guest/toolchain rebuilding remain mandatory. The complete design stays open; no label-only registration or host model substitutes for native proof. Tests/builds/lint/rendering/VM/profiling/CI execution remains deferred.

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.

Once-only original member Start and complete running-group drain

Add operation0x61 with exact NTS1 request64 plus zero NSR1 reply64. The request contains only actual current member slot, original member/context/enrollment serials and original row/generation, with reserved zero fields and unused registers. It supplies no target process/thread attribution or register/frame pointer. Actual current member EXECUTE, original active native scope, completed original context and positive same-original enrollment precede Start. Positive enrollment is retained independently of creator call completion; Starting requires no reacquisition of Process/root/setup grants or old CLAIM.

Revalidate current original mapping/guard/permission and actual CPU policy plus independent current processor baseline before runnable publication. Reserve actual private resume-frame destination before consuming the original initialized complete GPR allocation. Transfer that same noncopy stable frame into scheduling custody, publish original started membership and TCB resume/run state only after every fallible prerequisite, and preserve initial argument/default state including RDX across first selection. Exact replay observes the same original started execution without new allocation, another frame or resetting registers/TLS; changed intent or retired/replaced original refuses. Erase private register storage before every disposal path. Original carrier disposal after Start may detach its view only after actual started custody is independently retained by the native process/context; it cannot implicitly stop a peer or forget its charge/backing.

Separate genuine started execution admission from initial-process policy/setup APIs. Saved-frame, current execution, accounting, block/wake, activity, pager/fault and interrupt adapters must validate initial or positively started original membership without admitting pristine preparations. Initial Start/window/setup/process-memory authority stays narrow. Per-thread accounting belongs to actual original executions and process observations retain complete group totals before and after member drain. Process exit/fatal current-member policy resolves its genuine original group, not a payload-selected peer. Ordinary terminal wake/block operations cannot revive stopped execution.

Freeze new admission and stop every actual original Running/blocked/fault member before receiver/invocation retirement or shared disposal. Preserve whole-group identity/backing/private frame/machine custody and exact positive cleanup progress through refusal. Preflight all original memberships, private owners and active return/accounting intervals before remote carrier removal and any shared purge. Drain all additional contexts/frames/charges before native ID reuse and preserve one process event, descendants and process-wide authority semantics; no per-member CSpace/VSpace purge or invented process event.

Adopt counted mediator once-only Start continuation from its same positive original row and explicit member EXECUTE. Add a separately selected real-CPL3 additional-member workload with actual returned member/context/enrollment keys, initial arguments/TLS/machine checks, real shared-process execution and original running-group stop/drain. Keep every existing complete oracle and authored independent native-object/codec/authority/refusal/replay/teardown controls. Maintain bounded explicit diagnostic selection and source contracts, signed immutable graph, component/manual documentation and phase tracking. Ordinary deployed creation/ELF/TLS/per-thread masks/lifecycle/required consumers and both full EriX guest generations plus external Rust/LLVM guest rebuilding stay mandatory. All eight complete design criteria stay open until their full scope is implemented. Tests/builds/lint/rendering/VM/profiling/CI execution remains deferred; source controls are not runtime proof.

Original member Start and group retirement — 11 October 2026

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

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

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

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

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

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

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

Original per-thread signal ownership — 11 October 2026

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

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

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

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

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

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

Original ELF TLS image and linking source — 11 October 2026

Static native TLS refusal remains intact.

Complete caller-image preflight precedes every byte effect; refusal and spare bytes remain unchanged. Scalar addresses, IDs and generations grant no native authority.

Ordinary graph planning refuses TLS, and the distinct patch type cannot enter existing eight-byte-only handoff consumers. Descriptor resolver addresses remain descriptive; actual register-preserving code and its native mapping must be authenticated separately. Missing weak TLS providers, static-linker annotations and complete actual imported-artifact coverage remain unfinished.

No allocation, ambient lookup, numeric address dereference, capability minting, FS setter or runtime policy widening is introduced. Twenty-one independent template/image/expression/graph controls cover malformed/overflow/alignment/refusal, independent images, provider identity, full descriptor targets and late-refusal/retry output custody.

Actual Loaderd/Dynlinkd/Procd/Kernel initial and additional TLS image production, LibCstd errno/TLS/descriptor accessors, ordinary creation/deployment, inherited FP state, member exit/join/detach, module mutation/unload/destructors and all required native/imported consumers remain unfinished. Existing executable/artifact TLS refusal stays until every thread is initialized. Both complete EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Canonical completion is 21.88% weighted and 10.11% whole acceptance: 33/460 accepted parents, 505/978 completed sub-items under 168 decomposed parents. Two explicit template/image source sub-items are credited; complete TLS and native thread lifecycle requirements remain open.

Tracking: complete TLS, native thread acceptance, linker runtime, libc, thread consumers, phase completion.

Original initial-process TLS native custody — 12 October 2026

Original initial-process TLS now has a distinct native operation 0x62 with ITI1/ITR1, independently requiring the actual Running caller's Process SEND endpoint and exact Created initial-process stage GRANT. Scalar labels, copied receipts and current execution alone cannot construct it. Caller-counted module/guard/template framing validates every field/extent/count/reserved byte without private count/size limits, preauthorizes before copied-input allocation and preserves refusal/spare bytes.

Machine or byte refusal retains pending original custody; changed input/creator/occupation/mapping cannot adopt it. Actual complete caller READ/WRITE span preflights before copy/effects, and the same original caller/span revalidates before complete reply publication.

Initial Start refuses pending state, changed entry/top, invalidated original mappings/guards or machine policy before runnable publication.

They cover complete framing/overflow/refusal/correlation, actual Process/grant/initial role, prefix/zero/stack/startup preservation, same-original ready replay, peer/changed-input refusal, guard and remap conditions, allocation cut points, unauthorized allocation refusal and positive abort/reuse. No hook supplies effects.

Actual Loaderd/Dynlinkd/Procd ELF image/patch producers, LibCstd errno/TLS/descriptor accessors, ordinary native creation/deployment, inherited FP state, exit/join/detach/module/unload/destructors and all required consumers remain unfinished. Existing executable/artifact TLS refusal stays until every initial and additional producer is migrated. Both complete EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. No narrower native or parser endpoint replaces complete acceptance.

Full native/TLS/runtime/lifecycle/consumer acceptance remains open.

Tracking: complete TLS, full native thread acceptance, libc, thread consumers, phase completion.

Initial TLS materialization storage and native readiness — 12 October 2026

Old 64/88-byte bodies reject. Procd inserts independently retained actual Process SEND route, exact stage grant, native created identity and original intent; the payload cannot select them. Identical repeats retain progress; changed descriptions refuse. Stale, empty, reordered, overflowing and overlong input refuses before mutation; fragments cannot overwrite the private native header or reply reservation.

Both ordinary and staged commit require complete mappings/patches/canonical TLS input and actual native operation 0x62 while the original stage grant remains held, before grant disposal, transfer or Start. The allocation-free client hashes complete original input across transport and requires exact positive extent and complete identity/intent/TP correlation. Only the complete original native result publishes readiness; repeat gating cannot reset live bytes. Loaderd's noncopy materialization owner retains acknowledged-abort responsibility after a lost streaming reply and refuses incomplete commit or input replacement.

Eighteen new unit controls and an independent capacity/descriptor/refusal suite are authored and unrun. Coverage includes complete original correlation, capacity refusal before creation/cleanup, input order/header/reply/spare protection, malformed/incomplete input before native effects, once-only readiness, uncertain native/abort outcomes, refusal of original owner replacement, positive cleanup erasure and lost streaming replies.

Actual authenticated ELF template/immutable registry/image production, dedicated stack/guard/TLS/registry geometry, Dynlinkd original module correlation/exact-width patch streaming, libc errno/TLS/descriptor accessors, ordinary additional thread birth/deployment/creator FP inheritance, exit/join/detach/module/unload/destructors and required imported/native consumers remain unfinished. Existing artifact/production ELF TLS refusal stays until these paths migrate. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Complete native and TLS acceptance remains open; this materialization source is a prerequisite, not a replacement for full acceptance.

Exact-width materialization and complete raw-record refusal — 12 October 2026

Old scalar-only record/body widths reject and retired value fields are removed without aliases.

Complete-batch validation now decodes every raw record and propagates each refusal before exposing an accepted immutable iterator.

Fifteen new unit controls are authored and unrun: five literal codec/full-record controls, five mixed-width/span/boundary/failure/producer-state controls, three client correlation/refusal/uncertainty controls and two original graph producer/short-output controls. They include malformed-first/middle/last validation, no early output/native/progress/cleanup effect, exact bytes and untouched spare capacity, complete overflow refusal and original abort custody.

Actual TLS graph/module/template/immutable registry/image production, dedicated mapping geometry, libc resolvers, normal additional thread birth/FP inheritance, complete lifecycle and required imported/native consumers remain unfinished. Existing ELF/artifact TLS refusal stays. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Full native and TLS acceptance stays open; this exact-width stream is a prerequisite, not a substitute for complete producer adoption.

Immutable original TLS registry and initial ELF production — 12 October 2026

The encoder/parser preserve refusal and spare bytes without private module/image ceilings. Fresh image initialization derives from the retained immutable registry, never another thread's writable bytes. Digests, IDs and pointer words remain descriptive and grant no native authority.

Required descriptors derive the exact original ABI export within original executable nonwritable code; a scalar address is only an assertion, and actual libc resolver implementation remains pending.

Cross-prefix and original zero-suffix effects refuse rather than disappearing; relocated zero-suffix support remains required. A complete second read supplies original process-memory patches; SHA-256 of all ordered canonical records and the exact full count must agree before linker retirement and child commit.

Old descriptors refuse. The versioned standard and smoke profiles explicitly select adjustable 65536-byte stack policy; malformed/unpatched stack values refuse.

They include literal sparse/empty/duplicate/malformed registry geometry, independent fresh images, exact fragments/tail/refusal/spare bytes, original transaction association and retirement, actual committed mixed-width TLS plans, selected descriptor provider/code-span refusal, disjoint workspace, complete plan/count correlation, late cross-prefix/zero-suffix refusal and actual original PT_TLS Loaderd handoff.

Full TLS/native acceptance remains open. Actual libc errno/TLS/descriptor resolution, early FS0 migration, ordinary additional birth, FP/mask inheritance, join/detach/exit, synchronized module lifetime/unload/destructors, required weak-null/static-flag/zero-suffix forms and complete native/imported consumers still need implementation. Existing native VM sources and all earlier integration oracles remain; complete ELF multi-thread VM adoption remains required. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. These completed source prerequisites do not substitute for complete production/runtime/lifecycle acceptance.

Four fully completed source prerequisites are exposed under the original full TLS item; its additional-thread/libc/lifetime/consumer scope remains open.

Explicit original per-thread C runtime primitives — 12 October 2026

TLS lookup preflights original nonzero ID, complete count/slot/module arithmetic, immutable registry-generation correlation, present pointer and offset within its complete original extent; a one-past result supplies no dereference authority.

Accepted bytes cannot authenticate a current native thread, module lifetime or mapped registry.

Integration replaces the old memory-only selection type with RuntimeSelection and requires exact explicit component schemas/roles. Standalone CLI component selection is explicit; existing kernel/shared builders retain memory-only selection and the shared builder refuses substitution. Thread provenance cannot satisfy old memory support, and public thread provider policy does not expand the old hidden-only memory provenance contract.

Literal oracles cover signed isolated errno, sparse missing IDs, full-width offsets, one-past results, zero-sized present modules, complete malformed first/last slots, original generation/identity and extent overflow refusal without byte changes.

Complete libc/TLS/native acceptance stays open. Actual native consumer packaging, early FS0 migration, normal additional birth, creator FP/mask inheritance, TLS keys/destructor ordering, synchronized module admission/unload, exit/join/detach, required imported forms and real native ELF multi-thread VM controls remain mandatory. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. These implemented primitives and explicit producer/provenance paths are source prerequisites, not complete runtime or self-host acceptance.

Bounded original thread controls and compatibility packaging — 12 October 2026

Expected SIGILL requires the original raw negative child signal status, matching shell status and clean owned cleanup. Numeric exits, another signal, timeout, warnings or uncertain cleanup cannot satisfy it. Complete actual command and source/tool/owner/receipt identity remains before acceptance; already owned original probes are reused without repeating compilation.

Compatibility packaging preserves the original thread instructions and all four standalone memory/string instruction sections; the driver requires byte identity rather than matching names alone.

Compatibility support cannot impersonate memory-only or thread-only provenance. Existing kernel/shared bootstrap continues memory-only selection and refuses substitution; full artifact TLS admission is unchanged.

Complete libc/TLS/native acceptance remains open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. The complete original criteria are retained; this source packaging and authored host driver cannot substitute for actual native or guest evidence.

Original creator floating-point environment inheritance — 12 October 2026

Complete actual creator floating-point environment inheritance for additional native members. Preserve every full native-thread criterion, ordinary birth/lifecycle/libc/imported consumer requirement and both EriX plus Rust/LLVM guest generations. This is a required original state boundary, not a substitute for complete native threads.

An invocation can remain queued/Serving while its asynchronous caller resumes and changes FP state. Capture the environment from the actual submitting execution's private saved machine image at original ingress after native endpoint admission and before request authority transfer; never read the service receiver's live CPU state or a later caller image. Retain that immutable source beside the actual original invocation owner and expose it only through its sealed outstanding successful creator CLAIM. Payload origins, saved bytes and raw IDs cannot select a source. The corresponding original factory/member scope and creator identity remain independently required; no additional process, mapping, execution or receive authority is introduced.

Inherit original FP control/rounding/exception environment only, with independently initialized target register data. Preserve x87 control and applicable exception status plus SSE MXCSR environment. Normalize architectural init state according to actual saved format/component semantics before interpreting fields. Do not copy x87/MMX/XMM/vector data, stack tags/TOP, instruction/data pointers, TLS/segment bases, feature-disable/protection state or another execution's Kernel baseline. Fresh private target image and its actual current processor profile remain required. Extended restore headers must describe the inherited environment so the hardware restore does not silently replace it with defaults. Keep independently enabled SSE behavior correct even when its state is outside extended management.

Bind the source once to the original claimed member and pending/ready context. Allocation/profile/memory/identity refusal must precede native publication; partial byte effects retain original input/progress and positive cleanup obligations. Same-original retries and Start validate immutable inheritance without rereading or resetting creator state. A changed source or original identity refuses rather than recapturing or selecting a replacement. Original invocation/context/machine lifecycle retires all private environment storage before native reuse. Unclaimed trusted initial contexts retain their independent defaults. Hosted fixture observations remain model-only and cannot establish native hardware capture or inheritance evidence.

Author independent layout/bitmap/default/environment-only/overflow/refusal controls, actual original asynchronous ingress/claim association, changed later creator state, allocation/replay/cleanup and native CPL3 inheritance canaries. Keep every existing native integration oracle and budget. Maintain rustdoc/component/manual contracts, source files below one thousand lines, strict missing-docs gates, signed coherent helper/component/catalog graph and public tracking. Execution/builds/lint/rendering/VM/profiling and CI observation remain deferred; no passing or measured result is claimed.

Primary inputs: POSIX thread creation and Intel processor state specification. All implementation derives independently from those specifications and original EriX custody, without third-party implementation. Related complete work: ELF/TLS, libc, phase completion.

Original creator environment implementation — 12 October 2026

Native admission requires an actual captured original image; the immutable snapshot is retained beside the original invocation and lent only through the sealed outstanding successful creator CLAIM. Later asynchronous caller changes, receiver CPU state and payload data cannot replace that source.

Exact replay compares it; Start uses retained intent and never recaptures or resets registers. Current original authority, independent Kernel baseline, TLS memory, enrollment/EXECUTE and positive cleanup stay required.

Eight independent unit controls cover init/format/fresh-byte/reserved bits, allocation/replay/retirement, asynchronous source changes and actual actor refusal. The existing actual CPL3 member stream now requires original creator rounding and masked SSE precision status, fresh TOP/tags and all sixteen fresh XMM registers before installing its distinct canary. Full ordinary birth/lifecycle/libc/imported consumers, complete ELF TLS/masks/module lifetime and native multi-thread evidence remain open. Both EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Two complete creator-environment implementation/control-source prerequisites are exposed without narrowing full native/ELF/TLS/libc/consumer/guest acceptance.

Original thread self-exit and last-thread finalization — 12 October 2026

Implement the missing actual-current thread-only exit boundary required before ordinary thread entry wrappers can return. Preserve all original full native/thread/libc/ELF acceptance criteria and both EriX plus Rust/LLVM guest generations. Native self-exit accepts only a result value; no peer/process selector, authority or user saved context is supplied. Retain exact original execution/process/result intent before effects and never return to a committed terminal user stack.

Separate execution terminality from whole-process terminality explicitly. An initial execution may depart while its original process anchor, peers, shared CSpace/VSpace/window/pager/fd/policy/children and CPU accounting survive. Thread-only exit retires only that original execution's native receiver/call/wait/observer custody, emits no process event, revokes no process lifetime grant and retains exact result/context/machine/mapping storage until positive native cleanup. Generation reuse cannot adopt an old result. Whole-group kill/exit and cleanup still settle the original process and exactly one event. Remove ambiguous internal terminal predicates and retain every existing denial/error-precedence rule.

Serialize last-thread arbitration with actual native membership and Start under lifecycle exclusion. Count genuinely started live/blocked peers rather than copied counters. If peers survive, commit self terminality only. Otherwise freeze further preparation/Start, positively establish that retained unstarted or uncertain members cannot execute, and retain the original running execution as exclusive finalizer. Return only that finalization decision to the same original user runtime so process atexit/finalization can execute before existing whole-group exit zero. Exact result replay retains the same intent; changed input refuses. No observation alone can grant finalizer, process or mapping authority.

Author literal codec/bridge and genuine native-object controls for initial/noninitial exit, departed-leader survival, peer/blocked-peer preservation, exact result/identity replay, allocation/refusal before effects, last-thread/Start arbitration, process events/grants/shared inventory, accounting and cleanup/reuse. Extend actual CPL3 member coverage while preserving every older oracle and budget. Maintain rustdoc/component/manual contracts, files below one thousand lines and coherent signed immutable graphs/reviews/master tracking. Testing/builds/lint/rendering/VM/profiling/CI observation remain deferred; no executed or measured result is claimed. Ordinary creation, full exit/join/detach/libc/imported consumers and native ELF multi-thread and guest acceptance remain open.

Native thread self-exit and finalization implementation — 12 October 2026

Scalar opcode 0x63 accepts a complete opaque result word with all other arguments reserved zero; no peer, process, capability or pointer selector is supplied. The bridge admits only the exact same-caller finalization return and rejects departed/unknown/auxiliary success. Hosted transport refuses locally without instructions or pointer access.

Thread-only exit retires only its original receiver/caller/wait/observer custody, emits no process event and retires no process lifetime grant. The assembly-owned return guard never resumes the committed terminal stack.

With no surviving started peer, lifecycle exclusion closes preparation and initial/member Start, retains unstarted/uncertain charged backing that cannot execute and keeps the same running execution for runtime finalizers followed by existing whole-process exit zero. Exact result replay never selects another intent; changed result/generation/process/state refuses. Positive departed-member observation/disposal requires a genuine original noncopy view; current attribution, native charges and refused backing preserve original custody.

A separate actual CPL3 self-exit scenario requires full retained result and original initial/shared-process survival before complete original group drain. Complete ordinary creation, full exit/join/detach/libc/ELF/imported consumers and both EriX plus external Rust/LLVM guest build generations remain open and mandatory.

Native runtime consumer selection implementation — 12 October 2026

The shared builder refuses wrong component, policy or target before source/tool access. Both registry readers require exact integer version four; prebuilt header refusal occurs before artifact-row access. Old memory-only registries, public compatibility, missing/mixed thread roles and stale ABI cannot satisfy shared admission.

Four independent authored controls cover actual-consumer component/policy/target refusal before effects, normal/prebuilt version refusal, memory/thread/public substitution and complete thread role/ABI identity.

Resolver code availability does not initialize FS/TLS or provide native execution authority; existing artifact TLS refusal remains. Complete libc/startup/sysroot, ordinary native creation, full thread/module lifetime, keys/destructors, join/detach, imported consumers and both EriX plus external Rust/LLVM guest build generations remain required and unperformed.

Native runtime consumer documentation correction — 12 October 2026

Full ordinary creation, libc/sysroot, lifecycle, native ELF/TLS and both EriX plus external Rust/LLVM guest build generations remain open and required.

Held-member exit-result observation — 12 October 2026

Ordinary thread creation must retain a usable join/cleanup boundary. Add an immediate read-only member exit-result operation (x86_64 opcode 0x64) through the original current caller-local native member READ capability and exact nonzero carrier serial. Reuse the complete 24-byte NTO1 selection and 72-byte exclusive packet; the separate 48-byte NXR1 reply carries original serial/process/thread, an exact result-presence flag and the complete opaque result word. All unused registers, reserved bytes and absent-result storage are zero. No process/thread ID, peer lookup, pointer-valued selector or metadata snapshot supplies authority. Factory, fabricated/replaced slot, withdrawn READ, stale native association and group removal refuse before reply publication.

The original noncopy member view and lifecycle exclusion validate current native scope and retained execution; split the existing result observation into locked public and already-serialized private entry points. Active or cleanup-only retained member custody may observe its original result while native identity remains backed; observation creates no join reservation, Start/stop/disposal authority, releases no backing and changes no shared process inventory. Only actual thread-only departure yields a result, including zero/full-width words; running/unstarted/finalizing execution yields no result, and an error is never absence or cleanup proof. Exact repeats are read-only and require current READ/serial again.

The bridge preserves status precedence and rejects changed input, incomplete/unknown flags, wrong serial/extent and malformed positive output; hosted targets refuse locally without instruction or pointed-to access. Author independent literal codec/bridge controls, genuine native object/rights/serial/state/refusal/replay controls and actual CPL3 query coverage within the separately routed thread self-exit stream while retaining every earlier scenario, oracle and finite budget. Maintain component/manual contracts and coherent signed immutable adoption.

This closes a necessary native observation boundary, while original ordinary factory provisioning/request dispatch, full join/detach exclusive policy, libc consumers, native ELF/TLS lifetime and both full EriX plus external Rust/LLVM guest build generations remain open and required. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred; source controls are authored without execution.

Held-member native exit-result observation implementation — 12 October 2026

Native opcode 0x64 requires actual current-local native member READ and exact original serial, reusing the complete NTO1 selection and a distinct NXR1 output. Factory, counterfeit/replaced binding, missing READ, stale serial/native association and group removal refuse. The bridge preserves status precedence and correlates original input, serial, flags and extent; hosted targets refuse locally without instructions or pointed-to access.

Retained cleanup-only members may observe their original result through real native charge/backing refusal; last-thread finalization yields no departed result. Each repeat requires current READ and restores unchanged original custody. Observation grants no lookup, exclusive join, Start/stop/disposal authority and changes no shared inventory, mapping, result, charge or backing. An error or absent result never proves cleanup.

The isolated actual CPL3 self-exit stream checks pending READ before Start, malformed register/output/span refusal and two full-width departed-result queries through the production path. Four separately supplied directed SEND/RECV rendezvous endpoints order custodian readiness, member notification/self-exit, result queries and creator/observer acknowledgements before process drain. The creator stays blocked/alive until actual result acknowledgement; each actor positively disposes its last-used rendezvous grants and final native oracles require absence. Hooks compare actual results/state and supply no runtime effect.

Full ordinary factory provisioning/request dispatch, exclusive join/detach, libc/startup/sysroot, native ELF/TLS/module lifetime and imported consumers remain open and mandatory. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.

Authenticated staged client factory producer — 12 October 2026

Add an explicit owned Procd operation for native client factory provisioning before client startup/provision/Start. Authenticate the retained Launchd supervisor from successful native CLAIM and require its exact original staged client/realm/mediator relationship plus one actual INSTALL_GRANT receipt. A capability-free 48-byte descriptive request selects only the already owned client and explicit total occupation capacity; these labels confer no authority. The actual Process SEND route and supplied exact Created-stage GRANT independently authorize native creation. No default factory or thread authority is added to existing client provisioning.

Use the existing independently empty pre-provision working scratch column, without increasing a hidden resource pool. Retain immutable same-process native creation intent before effects; preserve original row, delivery, prospective destination and result custody through errors. Native opcode 0x5D creates the genuine original factory with exact READ/MINT/GRANT needed for subsequent scoped delivery. MANAGE is omitted because uniquely held carrier disposal does not require it. Require complete original scope/capacity/intent/rights/current Held observation and actual local metadata before result publication. A 104-byte correlated response returns the factory descriptor as data; successful owned COMPLETE transfers the same original stage GRANT and actual native factory in two explicitly selected result roles. No factory lookup from IDs or metadata, scope widening, fabricated positive descriptor or alternate process route is permitted.

A new request cannot reconstruct or duplicate an already transferred factory. Existing original owned-caller continuation handles uncertain publication; failure cleanup retains all native sources and the exact staged child until independent native retirement. Source absence is checked after complete acknowledgement before ordinary producer intake; original stage grant/factory data cannot be forgotten or substituted by successor row/slot occupations. Full mediator configuration delivery, ordinary thread preparation/context/enrollment/Start dispatch, exclusive join/detach and libc/native ELF/TLS consumers remain open and required.

Author independent request/reply/cap-role controls and producer admission/original scope/changed intent/refusal/partial failure/transfer/cleanup controls; use the real native bridge in production. Maintain rustdoc/component/manual contracts and coherent signed immutable adoption. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred; no runtime pass or guest evidence is claimed. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Authenticated staged client factory producer implementation — 12 October 2026

Explicit private operation 0x445 takes exact 48-byte descriptive framing plus one independently received original stage GRANT. The existing independently empty pre-provision working column receives the native factory; no default thread grant or hidden scratch pool is added.

Complete current Held descriptor correlation, actual local metadata and native READ/serial/scope/kind/minimal rights precede every publication. Rights are exactly READ/MINT/GRANT; no unused MANAGE is granted. The exact 104-byte response echoes original input and native descriptor data; failure has a zero tail and no grants. Parsed bytes and metadata authenticate no capability or cleanup.

Positive owned COMPLETE uniquely returns the same stage GRANT then genuine factory. Transferred state rejects source access before slot queries, so replacement occupations cannot supply old authority. A new request cannot duplicate a transferred factory. Changed row/scope, uncertainty, failed READ or partial publication retains exact original child/delivery/prospective source/native intent through independent retirement.

Full mediator configuration delivery, ordinary preparation/context/enrollment/Start dispatch, exclusive join/detach, libc/startup/sysroot, native ELF/TLS/module lifetime and imported consumers remain open and required. Full producer/consumer VM coverage remains required as that path is wired. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed.

Counted Launchd factory caller and original custody — 12 October 2026

Wire the actual authenticated factory producer into Launchd stopped-client provisioning before native client Begin and before mediator/client Start. Extend the canonical client record from 72 to 80 bytes with explicit total native factory capacity; zero requests no factory/authority. Bind capacity in the frozen digest and check the sum of requested extra occupations against caller-supplied thread storage. Reject old/mixed client framing and migrate every maintained producer/consumer/fixture.

Launchd client storage has three explicitly counted roles: original stage GRANT, ingress RECV and prospective native factory. Version the startup/pool contract and all actual Rust/Python capacity/image consumers; remove superseded startup/client-pool APIs without aliases. Preserve caller/deployment resource counts, complete target-derived record sizing and all existing budget refusals. No slot may be acquired by discovery or extra uncounted storage.

The original owned caller supports exact semantic zero, one or paired result roles. For factory provisioning, submit the same stage GRANT once, retain nonzero/uncertain owners, prove the source empty before COLLECT may reuse its original destination, and reserve both original result destinations before effects. Decode exact framing/status/role/serial/process/capacity/intent, inspect actual local metadata and native factory READ, and independently retire the original caller before later client Begin. Failure, cancellation, malformed/surplus receipts and partial transfer retain original row/caller/grant/factory custody until positive retirement. A copy of result bytes cannot authenticate a source or restore a replaced slot.

Positive factory intake retains only original descriptive factory identity/capacity beside its actual noncopy counted column. Old stage-call selectors and ownership do not survive acknowledged transfer/retirement; uncertain cases remain charged. Default capacity zero preserves original Begin/descriptor/Commit flow. Complete Posixd factory configuration delivery and ordinary creation/context/enrollment/Start, exclusive join/detach, libc/native ELF/TLS/module lifetime and guest acceptance remain open and mandatory.

Author independent literal/version/geometry/capacity/paired-role/caller/provision/refusal/replay/cleanup controls and maintain all earlier VM scenarios/oracles/budgets. Update rustdoc/component/manual and coherent signed immutable graph/reviews/phase tracking. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred; no executed control or guest demonstration is claimed. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed.

Counted Launchd client factory custody implementation — 12 October 2026

Superseded startup symbols/versions are removed without aliases; capacity and hashes confer no authority.

Accepted/nonzero/unknown callers and prospective row columns remain retained; exact caller RELEASE/drain retirement precedes result acceptance. Complete original request,scope,capacity,intent,current Held descriptor and exact stage GRANT plus factory READ/MINT/GRANT roles must match. Actual inventory and native READ/serial/process/kind/rights/cleanup evidence precede Begin. Sticky cleanup refusal retains row quarantine even after the native caller drains.

Sixteen controls are authored/unrun: literal capacity/budget/old-width, paired caller source/result/cancel/retirement, one/multiple-client provisioning/refusal/quarantine, default seal-to-Start and receiver-only unsupported admission.

Posixd current receiver-only intake refuses positive factory descriptions while retaining prospective caller/source custody. Complete mediator factory delivery and ordinary preparation/context/enrollment/Start, exclusive join/detach, libc/startup/sysroot, native ELF/TLS/module lifetime and imported consumers remain open. Full producer/consumer VM coverage remains required as that path is wired. Both complete EriX guest generations and rebuilding external Rust/LLVM inside EriX remain mandatory and unperformed.

Genuine counted mediator factory delivery design — 12 October 2026

The original frozen RCF1 minor-nine client capacity stays descriptive and in its canonical digest. RCP1 minor ten adds explicit Record and ClientFactory pull operations. Record requests/replies retain kinds1/2; factory requests/replies use kinds3/4, the same112-byte request, original context/digest/client ordinal and an exact48-byte current TFR1 descriptor outside canonical plan bytes. Refusals have the same104-byte authority-empty prefix. Only an original positive-capacity canonical client may request its factory after its receiver pull and original caller retirement; defaults acquire no factory. The existing248-byte result floor and single-receipt geometry remain sufficient. Old RCP1 minors refuse; RCF1 framing remains unchanged. Complete scope/capacity/intent and operation correlation remain independent of actual native custody.

Launchd retains original immutable row/process/realm/capacity and genuine factory evidence. It serves the original receiver first and then uniquely moves that same client's native factory into the mediator, narrowing READ/MINT/GRANT to READ/MINT. No factory GRANT or MANAGE reaches the recipient. Actual source inventory and native READ precede publication. The serving publication intent precedes COMPLETE; its exact original delivery and prospective native source remain retained through partial failure or uncertainty. Positive COMPLETE plus independent original source absence precedes advancing to another canonical record, erasing the obsolete local selector and marking the descriptor historical. Native copies, source deletion and scalar acknowledgments cannot substitute for successful unique transfer. Receiver copies still retire only after the original two-sided seal evidence; factory source absence remains a separate obligation. Foreign origins, wrong operation/ordinal, replay, bad masks or altered scope/capacity/intent refuse before authority selection.

Posixd requests one explicit factory destination only after learning the original positive client capacity and retiring the receiver pull caller. Its inventoried startup window owns that prospective slot before COLLECT. Complete client/realm/context/digest/operation/ordinal/capacity/intent and exact native receipt role precede actual local metadata and native READ/serial/process/kind/rights/cleanup validation. Original caller retirement precedes operational factory admission. Noncopyable factory custody travels with the original counted client row through sorting, configuration integrity, receiver registration and seal; metadata or a digest cannot create or reacquire it. The actual target layout follows changed row size with authenticated descriptor identity, without a hidden factory pool or private count ceiling.

Factory READ/MINT is wanted runtime authority for future ordinary thread preparation and survives seal. Exact terminal/disposal intake closes access before cleanup; outstanding original thread/member/delivery/accounting owners remain separate. DROP acknowledgment and a separate actual absence query retire the original local factory. Errors retain its exact source, original client and first uncertainty; successor occupations cannot stand in for original identity or inherit forgotten authority. Receiver/watch/factory/member and native process retirement remain separately proved. No new native controller, broad resolver, root capability or endpoint discovery is introduced.

Author independent literal/correlation/old-minor, rights/role, source/move/refusal/replay/selector-erasure, actual consumer/READ/caller/registration/seal/disposal and zero-policy controls. Add bounded genuine native transfer and actual producer/consumer VM sources as the coordinated path allows, preserving older oracles and finite budgets. Source-audit code size, documentation, original authority and immutable source graph continuously. Tests, Cargo/builds, lint checks, rendering, VM/profiler execution and CI observation stay deferred; authored controls supply no execution claim.

This completes genuine factory delivery and operational custody, while original ordinary preparation/context/enrollment/Start, exclusive join/detach, full libc/TLS/module lifetime, imported native toolchain integration and complete consumer VM acceptance remain required. Both whole EriX guest generations and rebuilding external Rust/LLVM inside EriX remain mandatory and unperformed. All eight original whole-feature criteria stay open. See counted caller custody and phase completion.

Validation resumed in parallel — 12 October 2026

The user lifted restrictions on testing and CI monitoring and requires all repositories to pass CI. Test or CI failures must never block unrelated implementation progress. Existing waived source checkpoints remain historical source acceptance, not retrospective test proof; earlier “remain deferred” wording is superseded for ongoing work.

Full native factory delivery, ordinary thread lifecycle/libc/TLS integration, both whole EriX guest generations and rebuilding external Rust/LLVM inside EriX remain required and unfinished.

Related records and contracts
Repository Links
blockd PR 2
bootloader PR 3
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 issue 13, PR 3
extop PR 2
fatd PR 3
fbcond PR 2
hotplugd PR 2
inputd PR 2
integration issue 103, PR 12, native-c-runtime-consumers.md
irqd PR 2
kernel PR 3, creator-floating-environment.md, independent-machine-state.md, initialized-native-context.md, native-context-memory.md, native-machine-state.md, native-member-carriers.md, native-member-exit-observation.md, native-thread-exit.md, retained-member-mappings.md
keyd PR 2
launchd PR 2
lib-block PR 2
lib-bootstrap PR 2
lib-capabi PR 2
lib-cstd thread-runtime.md
lib-driver PR 2
lib-dynlink PR 3, tls-registry.md
lib-elf PR 2
lib-input PR 2
lib-interrupt PR 2
lib-ipc issue 6, PR 2, native-context-abi.md, native-enrollment-abi.md, native-preparation-abi.md, native-start-abi.md, relocation-patches.md
lib-log PR 2
lib-posixabi PR 3
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 PR 5, thread-signals.md, thread-storage.md
powerboxd PR 2
probed PR 2
procd PR 2, client-thread-factory.md, initial-tls-materialization.md
ramfsd PR 2
rootd PR 2
seriald PR 2
timed PR 2
ttyd PR 3
vfsd PR 3
vspaced PR 2
## Problem and motivation Original prepared native members share actual process objects and retained Kernel custody, but userspace cannot obtain a native factory/member carrier, initialize an original context or commit genuine enrolled Start. Real shared-thread execution is required for compatibility consumers and complete EriX plus external Rust/LLVM rebuilding inside EriX. ## Proposed behavior and scope Implement the complete original native factory/member capability and initialized Start transaction. Define typed native carrier IDs and exact narrowed rights, strict versioned codecs, native controls and userspace adapters. Factory creation requires actual supervisor Process authority and exact stage evidence. Delegation carries only the original process-bound factory and explicit total budget; ordinary clients acquire no supervisor Process, root, mapping, receiver or provider authority. Native preparation derives the process from its actual held factory and captures the actual successful creator CLAIM and original counted mediator row. Retain one original native continuation through uncertain preparation/publication, with exact replay and no duplicate construction. Retain and initialize the actual original code/stack/guard/TLS mapping occupations, backing and complete architecture context. Positive original mediator enrollment precedes runnable publication. Start revalidates the same context and commits that same member once. Extend capability intake, unique carrier movement, rollback, cleanup, group terminality and original member-only retirement coherently. Integrate supervisor/loader/mediator provisioning and actual creator enrollment. Preserve authentic OIR2 process/thread attribution. Author independent actual-object and real CPL3 workload controls for distinct genuine executions sharing one actual group, initialized state, refusal, reuse and cleanup. Keep the complete thread lifecycle, departed-leader survival, join/detach and compatibility consumer requirements explicit throughout implementation. <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 Numerical keys, addresses, labels and parsed metadata never mint authority. Current context identifies the actual caller's held grants but does not replace them. Factory scope and rights are never broadened. Native carriers have actual unique binding custody; copied metadata cannot create a carrier. Transfer reserves original storage and preserves the exact source through rejected publication and pre-delivery rollback. Destruction and carrier loss retain unresolved original native ownership until positive cleanup. Mapping context observations must name the same original mapping occupations and current permissions, with real retained backing. Unmap/remap at the same virtual or physical address cannot validate an old preparation. Withdrawing or attenuating a mapping never restores old permissions from a context snapshot. Normal authorized unmapping remains possible while detached backing is retained until original context references settle. Code is executable and nonwritable; stack/TLS are writable and nonexecutable; guard and occupation geometry are checked without new hidden limits. No borrowed or uninitialized architectural context is exposed, and one member's TLS/FP/vector state cannot leak into another execution. Missing enrollment, stale/foreign carriers, deficient permission/backing, overlap, malformed framing, explicit zero/exhausted budget, allocation/generation exhaustion and group freeze refuse before runnable publication. Group exit/kill and supervisor loss stop all original members before shared inventory disposal, preserving one process event and original backing through failure. Start, terminality, native caller/provider cleanup and final context/storage release remain separate positive boundaries. <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> - [ ] Define and adopt exact native capability rights, strict factory/member/context codecs, operation IDs and original native/user adapters without widening existing authority. - [ ] Implement actual original carrier binding custody, unique transfer/reservation/rollback and positive removal/revocation with original cleanup retained through failure. - [ ] Bind preparation to actual held factory and successful creator CLAIM/enrollment intent; retain original continuation, exact replay and quota through uncertain publication and refusal. - [ ] Retain actual original mapping occupations/backing and initialized code/stack/guard/TLS/architecture context; reject replaced mappings and permission contradictions without restoring old grants or imposing hidden unmap limits. - [ ] Implement positive original mediator enrollment and revalidated once-only Start; additional members execute only through this complete initialized transaction. - [ ] Stop/drain every original member/context before shared group disposal and retain group identity, accounting/custody and backing through failure without per-member process purge/events. - [ ] Adopt actual supervisor/loader/mediator provisioning and author independent native-object, codec, authority-negative, allocation/refusal/replay and real CPL3 shared-execution workload controls. - [ ] Maintain useful rustdoc/missing-docs gates, code below 1,000 lines, component/manual contracts, signed immutable producer/consumer graphs, owning reviews and phase completion tracking; preserve full lifecycle and guest rebuilding requirements. </details> ## Alternatives and tradeoffs Unstarted Kernel records alone cannot establish shared-thread execution. Native carriers require original capability lifecycle and execution context custody together. Detached mapping backing can remain retained without preserving a withdrawn mapping grant or preventing ordinary authorized unmapping. Indexed original occupations and explicit deployment-counted storage avoid global peer searches or private thread limits while retaining exact generations and positive cleanup. ## Tracking and rollout [Ownership specification](https://git.erikinkinen.fi/erix/kernel/issues/44), [prepared custody](https://git.erikinkinen.fi/erix/kernel/issues/46), [native implementation](https://git.erikinkinen.fi/erix/kernel/issues/1), [socket/thread 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). Implement original context/backing custody, exact carriers/native controls, enrollment/Start and coordinated real provisioning/workloads, then reconcile the complete source transaction. Tests, builds, lint, rendering, VM/profiler execution and CI observation remain deferred; no executed native or guest-build result is claimed. <details> <summary>Detailed scope and contracts</summary> ### 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 mediator execution storage contract Complete the existing native transaction with explicitly supplied thread capacity, separately owned execution rows and target-generated type geometry. The immutable arena descriptor advances to version six with actual ThreadSlot size/alignment; startup advances to RBS1 minor six (header272, image352), canonical configuration to minor eight (header144), Begin configuration120 and provisioning160. Tail positions continue deriving from complete declared extents. Reject old/trailing/partial versions without aliases or fallback; migrate every actual producer, consumer, digest/geometry calculation and maintained fixture together. The counted arena consumes disjoint storage and initializes authority-empty noncopy thread rows. Require capacity for the originally configured initial executions before service admission. Frozen process metadata reserves expected initial rows; only the actual retained successful native CLAIM confirms the original initial execution. Unknown, stale or forged additional executions remain refused. Keep process receiver/shared policy separate from execution ownership and preserve row identity/generation through retirement. Explicit spare capacity does not enroll a member, provide native factory authority or authorize Start. Reserve one real original counted row/generation before native preparation and retain the actual original member/intent through uncertain replies. Positive native enrollment must follow actual service ownership and complete original context; copying row labels never substitutes. Complete the original supervisor/loader/mediator deployment, code/module/stack/guard/TLS/architecture, once-only Start and running-group drain within the same full design. All eight full acceptance criteria remain pending; this storage contract does not narrow them. Author independent positive/negative/refusal/capacity and native VM sources; testing, builds, lint/rendering, VM/profiling and CI observation remain deferred. ### 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 code/stack/guard/TLS memory context contract — 11 October 2026 The original admitted noncopy member will retain a complete memory-context recipe: executable/nonwritable code containing entry, writable/nonexecutable stack containing the entire red zone and synthetic return slot, writable/nonexecutable TLS containing the original thread pointer, explicitly supplied module observations, and independently counted unmapped guard ranges with a guard immediately below the stack. Guard page geometry follows actual hardware mapping granularity; stack/TLS byte ranges and module count have no private deployment ceiling. Capture preflights all descriptive geometry, current original mapping occupations/backing/permissions, guard absence, exclusive stack/TLS overlap with existing original member memory recipes and storage before publishing any reference. Native VSpace custody copies the original conditions; caller-slice mutation or dropped views cannot forget them. Guard admission does not reserve mapping authority or prohibit ordinary authorized mapping: later mapping invalidates current context admission. Current mapping permissions and exact original occupations are revalidated beside current guard absence; unmap/remap cannot select replacement backing or restore withdrawn rights. Positive release retains original progress through failure and removes exclusive memory conditions only with the same native reference. Module observations grant no loader/mapping/provider capability. Memory-context retention remains a prerequisite inside the complete transaction. It must not publish initialized architectural state, positive mediator enrollment or runnable Start by itself. Full native context/TLS/FP/vector isolation, once-only Start, all-running-member drain and real supervisor/loader/mediator adoption remain required, with all eight complete criteria pending. Controls will be authored and unrun; tests/builds/lint/rendering/VM/profiling/CI observation remain deferred. Both full EriX guest generations and external Rust/LLVM guest rebuilding remain mandatory. ### 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. ### Private original architectural state contract — 11 October 2026 Initialize and retain actual private per-execution general-register, FS/GS selector/base and enabled extended-state storage. Processor-discovered format, enabled XCR0/IA32_XSS masks and CPUID component geometry govern complete save-area sizing/alignment, including variable future component sizes, without a private512-byte or small feature-count ceiling. Use legacy FXSAVE only when it represents the current enabled state; standard XSAVE or compacted XSAVES/XRSTORS preserve their exact processor format. Sealed native CPU observations remain independent of request data; a copied layout never authorizes hardware save/restore or native context publication. Fresh state uses deterministic initialized registers/TLS and architectural defaults, without copying another execution or boot FP/vector contents. Saved images remain private Kernel-owned noncopy buffers with original native identity and lifecycle custody. Capture before privileged dispatch and restore only the selected original live execution across syscall, fault, interrupt and scheduler returns; Kernel entry uses its independent baseline. Restore selectors before original FS/GS bases. Preserve feature-disable state where required, reject a changed/incompatible processor layout before use, and retain original storage through uncertain cleanup. No borrowed user pointer can supply saved state. Positive original memory, creator CLAIM, mediator enrollment and once-only Start remain separate mandatory prerequisites. The existing target compiler contract uses freestanding nonvector/nonfloating-point Kernel code by default; this must remain true at entry and return boundaries. Source algorithms are authored independently from processor specifications, without third-party implementation code. Primary references: [Intel architecture manual](https://cdrdv2-public.intel.com/671436/253665-sdm-vol-1.pdf), [current Intel manuals catalog](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html), and [Rust target contract](https://doc.rust-lang.org/rustc/platform-support/x86_64-unknown-none.html). Complete native architecture isolation, user context/replay adapters, actual enrollment/Start/deployment and all-running-member drain remain required; all eight full criteria stay pending. Controls will be authored/unrun, with testing/builds/lint/rendering/VM/profiler/CI observation deferred. Full EriX and external Rust/LLVM guest rebuilds remain mandatory. ### 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 context and bounded partial initialization Bind a private complete general-register image, the original native FP/vector/FS owner and a copied opaque TLS initialization recipe to the same actual prepared member and retained native memory reference. Trusted Kernel callers must hold the genuine noncopy member and same original memory view; the eventual user adapter independently requires current held member WRITE and the original actual creator CLAIM/intent. An address, a TCB snapshot or a copied reference key supplies none of this authority. TLS layout and ELF/template policy remain loader/libc obligations; the Kernel copies explicitly supplied data only into the original retained TLS interval and zeroes its remainder, without inventing a fixed TCB layout. Every geometry, same-original identity/current mapping condition, serial and storage allocation preflights before initialization publishes native custody or changes bytes. Own the copied TLS recipe and complete initialized GPR array in indexed native storage before any stack/TLS effect. A page-bounded copy retains exact original completed-prefix progress under the same VSpace reference/occupation lock. Initialize only the admitted synthetic stack return word and TLS bytes. Refusal retains the same pending context, immutable input intent and private machine image; changed arguments/TLS/geometry cannot reconcile it or acquire another occupation. Completed TLS initialization and original state validation precede the ready-context marker. No partial or ready context supplies mediator enrollment or runnable Start. Dropped views retain the original pending/ready record and allocation. Ordinary memory-reference release refuses while original initialized context depends on it; positive context withdrawal remains possible through frozen cleanup. Member abort and whole-group drain settle same-original mapping, context/GPR/TLS-recipe and machine custody before ID reuse. A retired context key cannot erase a replacement context, even on the same unstarted execution; serials never wrap or reset into aliases. Ordinary initial-process mutation remains distinct from later genuine execution-specific Start/frame/accounting operations. Author actual-object controls for allocation refusal before effects, initialized bytes and register defaults, changed/stale/cross-member inputs, exact zero-allocation replay, detached/replaced TLS with unchanged new bytes, pending copy retry, dropped views, dependent-memory refusal and positive original cleanup/reuse. Add guest controls when the strict native user adapter exists. These sources are authored independently without third-party code. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred. All eight original full criteria stay OPEN, including actual creator/enrollment/Start/deployment/running-group drain. Full EriX and external Rust/LLVM guest rebuilding remain mandatory. ### 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. ### Independent user protection-key register state Actual processor observation must distinguish the user protection-key instruction interface from XSAVE component management. Retain the original PKRU value in private native auxiliary custody whenever actual OSPKE/CR4.PKE enablement permits it, including legacy format or a current XCR0 mask without component 9. Kernel entry installs its independent initialized baseline and return restores the selected original value; current interface changes invalidate profile admission. No user payload enables hardware, supplies register state or changes native mapping permissions. This preserves complete state without a private feature-size restriction or silently omitting independently enabled state. Add a separately selected isolated native diagnostic that enables actual supported PKE before any native execution owner and deliberately leaves PKRU outside XCR0 management. Three original CPL3 participants require initialized zero, distinct original register values across ordinary syscall/handoff/blocking/deadline returns, and independently observed zero in privileged dispatch. Unsupported hardware must fail the positive diagnostic; a skipped operation or host model is not positive evidence. Preserve every existing complete invocation/machine oracle, hard/stall deadlines and ordinary-image behavior. Add exact scenario/direct-builder selection controls and source documentation. Tests/builds/lint/rendering/VM/profiling/CI execution stay deferred, and all eight full native member criteria remain OPEN. ### Complete independently usable legacy state SSE instruction availability is also independent of XCR0 component1 management. Preserve the complete legacy register region with FXSAVE/FXRSTOR when an extended profile omits that component, while retaining the exact enabled extended format/header and every managed component. Do not enable ordinary-image hardware or invent a feature-size restriction to make an incomplete image appear complete. The isolated independent-state diagnostic additionally enables actual supported XSAVE with XCR0 selecting x87 alone before any native owner. Existing complete x87/all-XMM/control/user-return checks then exercise unmanaged SSE alongside independently enabled PKRU. Require actual support, exact managed-mask observations and independent zero/default baselines, preserving every original native oracle and deferred execution status. This updates the diagnostic's deliberate boot policy; ordinary images and actual mapping authority remain unchanged. All eight complete member criteria stay OPEN. ### 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. ### Strict original member context operation and packet Use a new immediate native member context operation 0x5F with one complete current readable/writable caller packet and zero unused registers. NCI1 request header is 192 bytes: original current member/receiver slots, member serial, actual delivery selector, original row/generation intent, entry/stack/thread pointers, explicit code/stack/TLS ranges, three initial arguments, counted modules/guards/TLS-prefix bytes and exact request extent. Modules use 24-byte base/length/role/reserved records, guards use 16-byte base/length records, then inline opaque TLS bytes and one zero-reserved 64-byte NCR1 reply. Checked count products/sums, exact complete framing, reserved words, role tags, zero structural selectors and ordinary range geometry refuse; there is no private input/module/TLS count limit or old-frame fallback. Actual current member WRITE and expected original native carrier serial, live native member scope and the same original successful outstanding creator CLAIM/row intent precede any target observation or effect. No caller-origin, target PID/thread ID, saved register image or CPU-control bitmap occurs in the request. Slot/receiver selectors narrow actual held current authority; the captured native creator/intent determines the original process and member. Same creator/intent input preserves original memory/context custody through allocation/write/reply refusal. Changed geometry, arguments, module/guard order/roles or TLS bytes cannot reconcile a retained attempt or create a successor. Input snapshots and retained intent are Kernel-owned and erased on original disposal. Copy caller input before target effects and release the user borrow, including when process-owned target backing could alias caller packet memory. Retain original memory references and immutable request continuation before initialization can become uncertain. Extract serialized trusted member/memory/context cores without recursively acquiring lifecycle exclusion. Exact replay uses original references/context rather than recapturing them. Encode a complete local reply, then revalidate original current caller identity and whole packet span before publishing only the reply. NCR1 reports current original member/context serials, genuine process/thread observations and original entry/thread/stack addresses; parsing supplies no held authority, enrollment or Start. Add checked user bridge handling with exact output extent, original-request reconciliation and retained/uncertain original custody, plus independent malformed/range/count/allocation/claim/rights/stale/cleanup controls and real CPL3 context-operation sources. Preserve every full existing VM oracle and original allocation/partial-prefix cleanup. This completes the context operation without accepting the still-required positive mediator enrollment, once-only Start, running-group drain or real deployment/consumer requirements. All eight original full criteria stay OPEN. Tests/builds/lint/rendering/VM/profiling/CI execution remains deferred; full EriX and external Rust/LLVM guest rebuilding remain mandatory. ### 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 member enrollment Add immediate operation 0x60 with exact NEN1 request64 plus zero NER1 reply64. Request fields are current member/receiver slots, original member/context serials, actual outstanding delivery and original row/generation; all unused registers and reserved fields are zero. No request supplies process/thread attribution. Actual member WRITE, active original scope, initialized same-original context and the identical successful still-Serving creator CLAIM and row intent independently precede enrollment. Native context custody retains the original positive enrollment, captured creator identity, intended row and a distinct nonwrapping enrollment serial. Allocate/reserve every fallible prerequisite before positive publication. Same intent reconciles the same original enrollment; changed creator/context/row refuses. Duplicate live row intent in the same original process refuses. Ordinary context withdrawal cannot discard positive enrollment; original unstarted member/group disposal settles it positively with existing memory/machine custody. Ready/enrolled context still supplies no Start. The real mediator owns separately counted noncopy thread rows. Reserve a pristine spare row against its actual retained successful creator delivery and original configured process before invoking native enrollment; ordinary payload labels and parsed descriptors cannot admit a thread. Retain original reservation/intent through native status or inconsistent positive output, and reconcile only the same original continuation. Commit enrolled origin only from exact positive native member/context/enrollment output matching the actual configured original process. Intake may admit that distinct execution only against this positive original row and genuine CLAIM metadata. Process retirement closes all its original rows. Author independent literal/bridge, actual native authority/refusal/replay/cleanup and real CPL3 enrollment sources; keep every full existing oracle and add a positive enrollment marker. Maintain component/manual contracts and coherent signed graph. Positive once-only Start, complete running-group drain, actual deployed provisioning/ELF/TLS/consumers and full guest/toolchain rebuilding remain mandatory. The complete design stays open; no label-only registration or host model substitutes for native proof. Tests/builds/lint/rendering/VM/profiling/CI execution remains deferred. ### 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. ### Once-only original member Start and complete running-group drain Add operation0x61 with exact NTS1 request64 plus zero NSR1 reply64. The request contains only actual current member slot, original member/context/enrollment serials and original row/generation, with reserved zero fields and unused registers. It supplies no target process/thread attribution or register/frame pointer. Actual current member EXECUTE, original active native scope, completed original context and positive same-original enrollment precede Start. Positive enrollment is retained independently of creator call completion; Starting requires no reacquisition of Process/root/setup grants or old CLAIM. Revalidate current original mapping/guard/permission and actual CPU policy plus independent current processor baseline before runnable publication. Reserve actual private resume-frame destination before consuming the original initialized complete GPR allocation. Transfer that same noncopy stable frame into scheduling custody, publish original started membership and TCB resume/run state only after every fallible prerequisite, and preserve initial argument/default state including RDX across first selection. Exact replay observes the same original started execution without new allocation, another frame or resetting registers/TLS; changed intent or retired/replaced original refuses. Erase private register storage before every disposal path. Original carrier disposal after Start may detach its view only after actual started custody is independently retained by the native process/context; it cannot implicitly stop a peer or forget its charge/backing. Separate genuine started execution admission from initial-process policy/setup APIs. Saved-frame, current execution, accounting, block/wake, activity, pager/fault and interrupt adapters must validate initial or positively started original membership without admitting pristine preparations. Initial Start/window/setup/process-memory authority stays narrow. Per-thread accounting belongs to actual original executions and process observations retain complete group totals before and after member drain. Process exit/fatal current-member policy resolves its genuine original group, not a payload-selected peer. Ordinary terminal wake/block operations cannot revive stopped execution. Freeze new admission and stop every actual original Running/blocked/fault member before receiver/invocation retirement or shared disposal. Preserve whole-group identity/backing/private frame/machine custody and exact positive cleanup progress through refusal. Preflight all original memberships, private owners and active return/accounting intervals before remote carrier removal and any shared purge. Drain all additional contexts/frames/charges before native ID reuse and preserve one process event, descendants and process-wide authority semantics; no per-member CSpace/VSpace purge or invented process event. Adopt counted mediator once-only Start continuation from its same positive original row and explicit member EXECUTE. Add a separately selected real-CPL3 additional-member workload with actual returned member/context/enrollment keys, initial arguments/TLS/machine checks, real shared-process execution and original running-group stop/drain. Keep every existing complete oracle and authored independent native-object/codec/authority/refusal/replay/teardown controls. Maintain bounded explicit diagnostic selection and source contracts, signed immutable graph, component/manual documentation and phase tracking. Ordinary deployed creation/ELF/TLS/per-thread masks/lifecycle/required consumers and both full EriX guest generations plus external Rust/LLVM guest rebuilding stay mandatory. All eight complete design criteria stay open until their full scope is implemented. Tests/builds/lint/rendering/VM/profiling/CI execution remains deferred; source controls are not runtime proof. ### 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. ### 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. ### Original ELF TLS image and linking source — 11 October 2026 Static native TLS refusal remains intact. Complete caller-image preflight precedes every byte effect; refusal and spare bytes remain unchanged. Scalar addresses, IDs and generations grant no native authority. Ordinary graph planning refuses TLS, and the distinct patch type cannot enter existing eight-byte-only handoff consumers. Descriptor resolver addresses remain descriptive; actual register-preserving code and its native mapping must be authenticated separately. Missing weak TLS providers, static-linker annotations and complete actual imported-artifact coverage remain unfinished. No allocation, ambient lookup, numeric address dereference, capability minting, FS setter or runtime policy widening is introduced. Twenty-one independent template/image/expression/graph controls cover malformed/overflow/alignment/refusal, independent images, provider identity, full descriptor targets and late-refusal/retry output custody. Actual Loaderd/Dynlinkd/Procd/Kernel initial and additional TLS image production, LibCstd errno/TLS/descriptor accessors, ordinary creation/deployment, inherited FP state, member exit/join/detach, module mutation/unload/destructors and all required native/imported consumers remain unfinished. Existing executable/artifact TLS refusal stays until every thread is initialized. Both complete EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Canonical completion is 21.88% weighted and 10.11% whole acceptance: 33/460 accepted parents, 505/978 completed sub-items under 168 decomposed parents. Two explicit template/image source sub-items are credited; complete TLS and native thread lifecycle requirements remain open. Tracking: [complete TLS](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [native thread acceptance](https://git.erikinkinen.fi/erix/kernel/issues/47), [linker runtime](https://git.erikinkinen.fi/erix/dynlinkd/issues/1), [libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [thread consumers](https://git.erikinkinen.fi/erix/posixd/issues/34), [phase completion](https://git.erikinkinen.fi/erix/integration/issues/65). ### Original initial-process TLS native custody — 12 October 2026 Original initial-process TLS now has a distinct native operation 0x62 with ITI1/ITR1, independently requiring the actual Running caller's Process SEND endpoint and exact Created initial-process stage GRANT. Scalar labels, copied receipts and current execution alone cannot construct it. Caller-counted module/guard/template framing validates every field/extent/count/reserved byte without private count/size limits, preauthorizes before copied-input allocation and preserves refusal/spare bytes. Machine or byte refusal retains pending original custody; changed input/creator/occupation/mapping cannot adopt it. Actual complete caller READ/WRITE span preflights before copy/effects, and the same original caller/span revalidates before complete reply publication. Initial Start refuses pending state, changed entry/top, invalidated original mappings/guards or machine policy before runnable publication. They cover complete framing/overflow/refusal/correlation, actual Process/grant/initial role, prefix/zero/stack/startup preservation, same-original ready replay, peer/changed-input refusal, guard and remap conditions, allocation cut points, unauthorized allocation refusal and positive abort/reuse. No hook supplies effects. Actual Loaderd/Dynlinkd/Procd ELF image/patch producers, LibCstd errno/TLS/descriptor accessors, ordinary native creation/deployment, inherited FP state, exit/join/detach/module/unload/destructors and all required consumers remain unfinished. Existing executable/artifact TLS refusal stays until every initial and additional producer is migrated. Both complete EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. No narrower native or parser endpoint replaces complete acceptance. Full native/TLS/runtime/lifecycle/consumer acceptance remains open. Tracking: [complete TLS](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [full native thread acceptance](https://git.erikinkinen.fi/erix/kernel/issues/47), [libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [thread consumers](https://git.erikinkinen.fi/erix/posixd/issues/34), [phase completion](https://git.erikinkinen.fi/erix/integration/issues/65). ### Initial TLS materialization storage and native readiness — 12 October 2026 Old 64/88-byte bodies reject. Procd inserts independently retained actual Process SEND route, exact stage grant, native created identity and original intent; the payload cannot select them. Identical repeats retain progress; changed descriptions refuse. Stale, empty, reordered, overflowing and overlong input refuses before mutation; fragments cannot overwrite the private native header or reply reservation. Both ordinary and staged commit require complete mappings/patches/canonical TLS input and actual native operation 0x62 while the original stage grant remains held, before grant disposal, transfer or Start. The allocation-free client hashes complete original input across transport and requires exact positive extent and complete identity/intent/TP correlation. Only the complete original native result publishes readiness; repeat gating cannot reset live bytes. Loaderd's noncopy materialization owner retains acknowledged-abort responsibility after a lost streaming reply and refuses incomplete commit or input replacement. Eighteen new unit controls and an independent capacity/descriptor/refusal suite are authored and unrun. Coverage includes complete original correlation, capacity refusal before creation/cleanup, input order/header/reply/spare protection, malformed/incomplete input before native effects, once-only readiness, uncertain native/abort outcomes, refusal of original owner replacement, positive cleanup erasure and lost streaming replies. Actual authenticated ELF template/immutable registry/image production, dedicated stack/guard/TLS/registry geometry, Dynlinkd original module correlation/exact-width patch streaming, libc errno/TLS/descriptor accessors, ordinary additional thread birth/deployment/creator FP inheritance, exit/join/detach/module/unload/destructors and required imported/native consumers remain unfinished. Existing artifact/production ELF TLS refusal stays until these paths migrate. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Complete native and TLS acceptance remains open; this materialization source is a prerequisite, not a replacement for full acceptance. ### Exact-width materialization and complete raw-record refusal — 12 October 2026 Old scalar-only record/body widths reject and retired value fields are removed without aliases. Complete-batch validation now decodes every raw record and propagates each refusal before exposing an accepted immutable iterator. Fifteen new unit controls are authored and unrun: five literal codec/full-record controls, five mixed-width/span/boundary/failure/producer-state controls, three client correlation/refusal/uncertainty controls and two original graph producer/short-output controls. They include malformed-first/middle/last validation, no early output/native/progress/cleanup effect, exact bytes and untouched spare capacity, complete overflow refusal and original abort custody. Actual TLS graph/module/template/immutable registry/image production, dedicated mapping geometry, libc resolvers, normal additional thread birth/FP inheritance, complete lifecycle and required imported/native consumers remain unfinished. Existing ELF/artifact TLS refusal stays. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Full native and TLS acceptance stays open; this exact-width stream is a prerequisite, not a substitute for complete producer adoption. ### Immutable original TLS registry and initial ELF production — 12 October 2026 The encoder/parser preserve refusal and spare bytes without private module/image ceilings. Fresh image initialization derives from the retained immutable registry, never another thread's writable bytes. Digests, IDs and pointer words remain descriptive and grant no native authority. Required descriptors derive the exact original ABI export within original executable nonwritable code; a scalar address is only an assertion, and actual libc resolver implementation remains pending. Cross-prefix and original zero-suffix effects refuse rather than disappearing; relocated zero-suffix support remains required. A complete second read supplies original process-memory patches; SHA-256 of all ordered canonical records and the exact full count must agree before linker retirement and child commit. Old descriptors refuse. The versioned standard and smoke profiles explicitly select adjustable 65536-byte stack policy; malformed/unpatched stack values refuse. They include literal sparse/empty/duplicate/malformed registry geometry, independent fresh images, exact fragments/tail/refusal/spare bytes, original transaction association and retirement, actual committed mixed-width TLS plans, selected descriptor provider/code-span refusal, disjoint workspace, complete plan/count correlation, late cross-prefix/zero-suffix refusal and actual original PT_TLS Loaderd handoff. Full TLS/native acceptance remains open. Actual libc errno/TLS/descriptor resolution, early FS0 migration, ordinary additional birth, FP/mask inheritance, join/detach/exit, synchronized module lifetime/unload/destructors, required weak-null/static-flag/zero-suffix forms and complete native/imported consumers still need implementation. Existing native VM sources and all earlier integration oracles remain; complete ELF multi-thread VM adoption remains required. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. These completed source prerequisites do not substitute for complete production/runtime/lifecycle acceptance. Four fully completed source prerequisites are exposed under the original full TLS item; its additional-thread/libc/lifetime/consumer scope remains open. ### Explicit original per-thread C runtime primitives — 12 October 2026 TLS lookup preflights original nonzero ID, complete count/slot/module arithmetic, immutable registry-generation correlation, present pointer and offset within its complete original extent; a one-past result supplies no dereference authority. Accepted bytes cannot authenticate a current native thread, module lifetime or mapped registry. Integration replaces the old memory-only selection type with RuntimeSelection and requires exact explicit component schemas/roles. Standalone CLI component selection is explicit; existing kernel/shared builders retain memory-only selection and the shared builder refuses substitution. Thread provenance cannot satisfy old memory support, and public thread provider policy does not expand the old hidden-only memory provenance contract. Literal oracles cover signed isolated errno, sparse missing IDs, full-width offsets, one-past results, zero-sized present modules, complete malformed first/last slots, original generation/identity and extent overflow refusal without byte changes. Complete libc/TLS/native acceptance stays open. Actual native consumer packaging, early FS0 migration, normal additional birth, creator FP/mask inheritance, TLS keys/destructor ordering, synchronized module admission/unload, exit/join/detach, required imported forms and real native ELF multi-thread VM controls remain mandatory. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. These implemented primitives and explicit producer/provenance paths are source prerequisites, not complete runtime or self-host acceptance. ### Bounded original thread controls and compatibility packaging — 12 October 2026 Expected SIGILL requires the original raw negative child signal status, matching shell status and clean owned cleanup. Numeric exits, another signal, timeout, warnings or uncertain cleanup cannot satisfy it. Complete actual command and source/tool/owner/receipt identity remains before acceptance; already owned original probes are reused without repeating compilation. Compatibility packaging preserves the original thread instructions and all four standalone memory/string instruction sections; the driver requires byte identity rather than matching names alone. Compatibility support cannot impersonate memory-only or thread-only provenance. Existing kernel/shared bootstrap continues memory-only selection and refuses substitution; full artifact TLS admission is unchanged. Complete libc/TLS/native acceptance remains open. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. The complete original criteria are retained; this source packaging and authored host driver cannot substitute for actual native or guest evidence. ### Original creator floating-point environment inheritance — 12 October 2026 Complete actual creator floating-point environment inheritance for additional native members. Preserve every full native-thread criterion, ordinary birth/lifecycle/libc/imported consumer requirement and both EriX plus Rust/LLVM guest generations. This is a required original state boundary, not a substitute for complete native threads. An invocation can remain queued/Serving while its asynchronous caller resumes and changes FP state. Capture the environment from the actual submitting execution's private saved machine image at original ingress after native endpoint admission and before request authority transfer; never read the service receiver's live CPU state or a later caller image. Retain that immutable source beside the actual original invocation owner and expose it only through its sealed outstanding successful creator CLAIM. Payload origins, saved bytes and raw IDs cannot select a source. The corresponding original factory/member scope and creator identity remain independently required; no additional process, mapping, execution or receive authority is introduced. Inherit original FP control/rounding/exception environment only, with independently initialized target register data. Preserve x87 control and applicable exception status plus SSE MXCSR environment. Normalize architectural init state according to actual saved format/component semantics before interpreting fields. Do not copy x87/MMX/XMM/vector data, stack tags/TOP, instruction/data pointers, TLS/segment bases, feature-disable/protection state or another execution's Kernel baseline. Fresh private target image and its actual current processor profile remain required. Extended restore headers must describe the inherited environment so the hardware restore does not silently replace it with defaults. Keep independently enabled SSE behavior correct even when its state is outside extended management. Bind the source once to the original claimed member and pending/ready context. Allocation/profile/memory/identity refusal must precede native publication; partial byte effects retain original input/progress and positive cleanup obligations. Same-original retries and Start validate immutable inheritance without rereading or resetting creator state. A changed source or original identity refuses rather than recapturing or selecting a replacement. Original invocation/context/machine lifecycle retires all private environment storage before native reuse. Unclaimed trusted initial contexts retain their independent defaults. Hosted fixture observations remain model-only and cannot establish native hardware capture or inheritance evidence. Author independent layout/bitmap/default/environment-only/overflow/refusal controls, actual original asynchronous ingress/claim association, changed later creator state, allocation/replay/cleanup and native CPL3 inheritance canaries. Keep every existing native integration oracle and budget. Maintain rustdoc/component/manual contracts, source files below one thousand lines, strict missing-docs gates, signed coherent helper/component/catalog graph and public tracking. Execution/builds/lint/rendering/VM/profiling and CI observation remain deferred; no passing or measured result is claimed. Primary inputs: [POSIX thread creation](https://pubs.opengroup.org/onlinepubs/9799919799/functions/pthread_create.html) and [Intel processor state specification](https://cdrdv2.intel.com/v1/dl/getContent/671200). All implementation derives independently from those specifications and original EriX custody, without third-party implementation. Related complete work: [ELF/TLS](https://git.erikinkinen.fi/erix/lib-dynlink/issues/4), [libc](https://git.erikinkinen.fi/erix/lib-cstd/issues/1), [phase completion](https://git.erikinkinen.fi/erix/integration/issues/65). ### Original creator environment implementation — 12 October 2026 Native admission requires an actual captured original image; the immutable snapshot is retained beside the original invocation and lent only through the sealed outstanding successful creator CLAIM. Later asynchronous caller changes, receiver CPU state and payload data cannot replace that source. Exact replay compares it; Start uses retained intent and never recaptures or resets registers. Current original authority, independent Kernel baseline, TLS memory, enrollment/EXECUTE and positive cleanup stay required. Eight independent unit controls cover init/format/fresh-byte/reserved bits, allocation/replay/retirement, asynchronous source changes and actual actor refusal. The existing actual CPL3 member stream now requires original creator rounding and masked SSE precision status, fresh TOP/tags and all sixteen fresh XMM registers before installing its distinct canary. Full ordinary birth/lifecycle/libc/imported consumers, complete ELF TLS/masks/module lifetime and native multi-thread evidence remain open. Both EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. Two complete creator-environment implementation/control-source prerequisites are exposed without narrowing full native/ELF/TLS/libc/consumer/guest acceptance. ### Original thread self-exit and last-thread finalization — 12 October 2026 Implement the missing actual-current thread-only exit boundary required before ordinary thread entry wrappers can return. Preserve all original full native/thread/libc/ELF acceptance criteria and both EriX plus Rust/LLVM guest generations. Native self-exit accepts only a result value; no peer/process selector, authority or user saved context is supplied. Retain exact original execution/process/result intent before effects and never return to a committed terminal user stack. Separate execution terminality from whole-process terminality explicitly. An initial execution may depart while its original process anchor, peers, shared CSpace/VSpace/window/pager/fd/policy/children and CPU accounting survive. Thread-only exit retires only that original execution's native receiver/call/wait/observer custody, emits no process event, revokes no process lifetime grant and retains exact result/context/machine/mapping storage until positive native cleanup. Generation reuse cannot adopt an old result. Whole-group kill/exit and cleanup still settle the original process and exactly one event. Remove ambiguous internal terminal predicates and retain every existing denial/error-precedence rule. Serialize last-thread arbitration with actual native membership and Start under lifecycle exclusion. Count genuinely started live/blocked peers rather than copied counters. If peers survive, commit self terminality only. Otherwise freeze further preparation/Start, positively establish that retained unstarted or uncertain members cannot execute, and retain the original running execution as exclusive finalizer. Return only that finalization decision to the same original user runtime so process atexit/finalization can execute before existing whole-group exit zero. Exact result replay retains the same intent; changed input refuses. No observation alone can grant finalizer, process or mapping authority. Author literal codec/bridge and genuine native-object controls for initial/noninitial exit, departed-leader survival, peer/blocked-peer preservation, exact result/identity replay, allocation/refusal before effects, last-thread/Start arbitration, process events/grants/shared inventory, accounting and cleanup/reuse. Extend actual CPL3 member coverage while preserving every older oracle and budget. Maintain rustdoc/component/manual contracts, files below one thousand lines and coherent signed immutable graphs/reviews/master tracking. Testing/builds/lint/rendering/VM/profiling/CI observation remain deferred; no executed or measured result is claimed. Ordinary creation, full exit/join/detach/libc/imported consumers and native ELF multi-thread and guest acceptance remain open. ### Native thread self-exit and finalization implementation — 12 October 2026 Scalar opcode 0x63 accepts a complete opaque result word with all other arguments reserved zero; no peer, process, capability or pointer selector is supplied. The bridge admits only the exact same-caller finalization return and rejects departed/unknown/auxiliary success. Hosted transport refuses locally without instructions or pointer access. Thread-only exit retires only its original receiver/caller/wait/observer custody, emits no process event and retires no process lifetime grant. The assembly-owned return guard never resumes the committed terminal stack. With no surviving started peer, lifecycle exclusion closes preparation and initial/member Start, retains unstarted/uncertain charged backing that cannot execute and keeps the same running execution for runtime finalizers followed by existing whole-process exit zero. Exact result replay never selects another intent; changed result/generation/process/state refuses. Positive departed-member observation/disposal requires a genuine original noncopy view; current attribution, native charges and refused backing preserve original custody. A separate actual CPL3 self-exit scenario requires full retained result and original initial/shared-process survival before complete original group drain. Complete ordinary creation, full exit/join/detach/libc/ELF/imported consumers and both EriX plus external Rust/LLVM guest build generations remain open and mandatory. ### Native runtime consumer selection implementation — 12 October 2026 The shared builder refuses wrong component, policy or target before source/tool access. Both registry readers require exact integer version four; prebuilt header refusal occurs before artifact-row access. Old memory-only registries, public compatibility, missing/mixed thread roles and stale ABI cannot satisfy shared admission. Four independent authored controls cover actual-consumer component/policy/target refusal before effects, normal/prebuilt version refusal, memory/thread/public substitution and complete thread role/ABI identity. Resolver code availability does not initialize FS/TLS or provide native execution authority; existing artifact TLS refusal remains. Complete libc/startup/sysroot, ordinary native creation, full thread/module lifetime, keys/destructors, join/detach, imported consumers and both EriX plus external Rust/LLVM guest build generations remain required and unperformed. ### Native runtime consumer documentation correction — 12 October 2026 Full ordinary creation, libc/sysroot, lifecycle, native ELF/TLS and both EriX plus external Rust/LLVM guest build generations remain open and required. ### Held-member exit-result observation — 12 October 2026 Ordinary thread creation must retain a usable join/cleanup boundary. Add an immediate read-only member exit-result operation (x86_64 opcode 0x64) through the original current caller-local native member READ capability and exact nonzero carrier serial. Reuse the complete 24-byte NTO1 selection and 72-byte exclusive packet; the separate 48-byte NXR1 reply carries original serial/process/thread, an exact result-presence flag and the complete opaque result word. All unused registers, reserved bytes and absent-result storage are zero. No process/thread ID, peer lookup, pointer-valued selector or metadata snapshot supplies authority. Factory, fabricated/replaced slot, withdrawn READ, stale native association and group removal refuse before reply publication. The original noncopy member view and lifecycle exclusion validate current native scope and retained execution; split the existing result observation into locked public and already-serialized private entry points. Active or cleanup-only retained member custody may observe its original result while native identity remains backed; observation creates no join reservation, Start/stop/disposal authority, releases no backing and changes no shared process inventory. Only actual thread-only departure yields a result, including zero/full-width words; running/unstarted/finalizing execution yields no result, and an error is never absence or cleanup proof. Exact repeats are read-only and require current READ/serial again. The bridge preserves status precedence and rejects changed input, incomplete/unknown flags, wrong serial/extent and malformed positive output; hosted targets refuse locally without instruction or pointed-to access. Author independent literal codec/bridge controls, genuine native object/rights/serial/state/refusal/replay controls and actual CPL3 query coverage within the separately routed thread self-exit stream while retaining every earlier scenario, oracle and finite budget. Maintain component/manual contracts and coherent signed immutable adoption. This closes a necessary native observation boundary, while original ordinary factory provisioning/request dispatch, full join/detach exclusive policy, libc consumers, native ELF/TLS lifetime and both full EriX plus external Rust/LLVM guest build generations remain open and required. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred; source controls are authored without execution. ### Held-member native exit-result observation implementation — 12 October 2026 Native opcode 0x64 requires actual current-local native member READ and exact original serial, reusing the complete NTO1 selection and a distinct NXR1 output. Factory, counterfeit/replaced binding, missing READ, stale serial/native association and group removal refuse. The bridge preserves status precedence and correlates original input, serial, flags and extent; hosted targets refuse locally without instructions or pointed-to access. Retained cleanup-only members may observe their original result through real native charge/backing refusal; last-thread finalization yields no departed result. Each repeat requires current READ and restores unchanged original custody. Observation grants no lookup, exclusive join, Start/stop/disposal authority and changes no shared inventory, mapping, result, charge or backing. An error or absent result never proves cleanup. The isolated actual CPL3 self-exit stream checks pending READ before Start, malformed register/output/span refusal and two full-width departed-result queries through the production path. Four separately supplied directed SEND/RECV rendezvous endpoints order custodian readiness, member notification/self-exit, result queries and creator/observer acknowledgements before process drain. The creator stays blocked/alive until actual result acknowledgement; each actor positively disposes its last-used rendezvous grants and final native oracles require absence. Hooks compare actual results/state and supply no runtime effect. Full ordinary factory provisioning/request dispatch, exclusive join/detach, libc/startup/sysroot, native ELF/TLS/module lifetime and imported consumers remain open and mandatory. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. ### Authenticated staged client factory producer — 12 October 2026 Add an explicit owned Procd operation for native client factory provisioning before client startup/provision/Start. Authenticate the retained Launchd supervisor from successful native CLAIM and require its exact original staged client/realm/mediator relationship plus one actual INSTALL_GRANT receipt. A capability-free 48-byte descriptive request selects only the already owned client and explicit total occupation capacity; these labels confer no authority. The actual Process SEND route and supplied exact Created-stage GRANT independently authorize native creation. No default factory or thread authority is added to existing client provisioning. Use the existing independently empty pre-provision working scratch column, without increasing a hidden resource pool. Retain immutable same-process native creation intent before effects; preserve original row, delivery, prospective destination and result custody through errors. Native opcode 0x5D creates the genuine original factory with exact READ/MINT/GRANT needed for subsequent scoped delivery. MANAGE is omitted because uniquely held carrier disposal does not require it. Require complete original scope/capacity/intent/rights/current Held observation and actual local metadata before result publication. A 104-byte correlated response returns the factory descriptor as data; successful owned COMPLETE transfers the same original stage GRANT and actual native factory in two explicitly selected result roles. No factory lookup from IDs or metadata, scope widening, fabricated positive descriptor or alternate process route is permitted. A new request cannot reconstruct or duplicate an already transferred factory. Existing original owned-caller continuation handles uncertain publication; failure cleanup retains all native sources and the exact staged child until independent native retirement. Source absence is checked after complete acknowledgement before ordinary producer intake; original stage grant/factory data cannot be forgotten or substituted by successor row/slot occupations. Full mediator configuration delivery, ordinary thread preparation/context/enrollment/Start dispatch, exclusive join/detach and libc/native ELF/TLS consumers remain open and required. Author independent request/reply/cap-role controls and producer admission/original scope/changed intent/refusal/partial failure/transfer/cleanup controls; use the real native bridge in production. Maintain rustdoc/component/manual contracts and coherent signed immutable adoption. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred; no runtime pass or guest evidence is claimed. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Authenticated staged client factory producer implementation — 12 October 2026 Explicit private operation 0x445 takes exact 48-byte descriptive framing plus one independently received original stage GRANT. The existing independently empty pre-provision working column receives the native factory; no default thread grant or hidden scratch pool is added. Complete current Held descriptor correlation, actual local metadata and native READ/serial/scope/kind/minimal rights precede every publication. Rights are exactly READ/MINT/GRANT; no unused MANAGE is granted. The exact 104-byte response echoes original input and native descriptor data; failure has a zero tail and no grants. Parsed bytes and metadata authenticate no capability or cleanup. Positive owned COMPLETE uniquely returns the same stage GRANT then genuine factory. Transferred state rejects source access before slot queries, so replacement occupations cannot supply old authority. A new request cannot duplicate a transferred factory. Changed row/scope, uncertainty, failed READ or partial publication retains exact original child/delivery/prospective source/native intent through independent retirement. Full mediator configuration delivery, ordinary preparation/context/enrollment/Start dispatch, exclusive join/detach, libc/startup/sysroot, native ELF/TLS/module lifetime and imported consumers remain open and required. Full producer/consumer VM coverage remains required as that path is wired. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain mandatory and unperformed. ### Counted Launchd factory caller and original custody — 12 October 2026 Wire the actual authenticated factory producer into Launchd stopped-client provisioning before native client Begin and before mediator/client Start. Extend the canonical client record from 72 to 80 bytes with explicit total native factory capacity; zero requests no factory/authority. Bind capacity in the frozen digest and check the sum of requested extra occupations against caller-supplied thread storage. Reject old/mixed client framing and migrate every maintained producer/consumer/fixture. Launchd client storage has three explicitly counted roles: original stage GRANT, ingress RECV and prospective native factory. Version the startup/pool contract and all actual Rust/Python capacity/image consumers; remove superseded startup/client-pool APIs without aliases. Preserve caller/deployment resource counts, complete target-derived record sizing and all existing budget refusals. No slot may be acquired by discovery or extra uncounted storage. The original owned caller supports exact semantic zero, one or paired result roles. For factory provisioning, submit the same stage GRANT once, retain nonzero/uncertain owners, prove the source empty before COLLECT may reuse its original destination, and reserve both original result destinations before effects. Decode exact framing/status/role/serial/process/capacity/intent, inspect actual local metadata and native factory READ, and independently retire the original caller before later client Begin. Failure, cancellation, malformed/surplus receipts and partial transfer retain original row/caller/grant/factory custody until positive retirement. A copy of result bytes cannot authenticate a source or restore a replaced slot. Positive factory intake retains only original descriptive factory identity/capacity beside its actual noncopy counted column. Old stage-call selectors and ownership do not survive acknowledged transfer/retirement; uncertain cases remain charged. Default capacity zero preserves original Begin/descriptor/Commit flow. Complete Posixd factory configuration delivery and ordinary creation/context/enrollment/Start, exclusive join/detach, libc/native ELF/TLS/module lifetime and guest acceptance remain open and mandatory. Author independent literal/version/geometry/capacity/paired-role/caller/provision/refusal/replay/cleanup controls and maintain all earlier VM scenarios/oracles/budgets. Update rustdoc/component/manual and coherent signed immutable graph/reviews/phase tracking. Tests/builds/lint/rendering/VM/profiling/CI observation remain deferred; no executed control or guest demonstration is claimed. Both complete EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. ### Counted Launchd client factory custody implementation — 12 October 2026 Superseded startup symbols/versions are removed without aliases; capacity and hashes confer no authority. Accepted/nonzero/unknown callers and prospective row columns remain retained; exact caller RELEASE/drain retirement precedes result acceptance. Complete original request,scope,capacity,intent,current Held descriptor and exact stage GRANT plus factory READ/MINT/GRANT roles must match. Actual inventory and native READ/serial/process/kind/rights/cleanup evidence precede Begin. Sticky cleanup refusal retains row quarantine even after the native caller drains. Sixteen controls are authored/unrun: literal capacity/budget/old-width, paired caller source/result/cancel/retirement, one/multiple-client provisioning/refusal/quarantine, default seal-to-Start and receiver-only unsupported admission. Posixd current receiver-only intake refuses positive factory descriptions while retaining prospective caller/source custody. Complete mediator factory delivery and ordinary preparation/context/enrollment/Start, exclusive join/detach, libc/startup/sysroot, native ELF/TLS/module lifetime and imported consumers remain open. Full producer/consumer VM coverage remains required as that path is wired. Both complete EriX guest generations and rebuilding external Rust/LLVM inside EriX remain mandatory and unperformed. ### Genuine counted mediator factory delivery design — 12 October 2026 The original frozen RCF1 minor-nine client capacity stays descriptive and in its canonical digest. RCP1 minor ten adds explicit Record and ClientFactory pull operations. Record requests/replies retain kinds1/2; factory requests/replies use kinds3/4, the same112-byte request, original context/digest/client ordinal and an exact48-byte current TFR1 descriptor outside canonical plan bytes. Refusals have the same104-byte authority-empty prefix. Only an original positive-capacity canonical client may request its factory after its receiver pull and original caller retirement; defaults acquire no factory. The existing248-byte result floor and single-receipt geometry remain sufficient. Old RCP1 minors refuse; RCF1 framing remains unchanged. Complete scope/capacity/intent and operation correlation remain independent of actual native custody. Launchd retains original immutable row/process/realm/capacity and genuine factory evidence. It serves the original receiver first and then uniquely moves that same client's native factory into the mediator, narrowing READ/MINT/GRANT to READ/MINT. No factory GRANT or MANAGE reaches the recipient. Actual source inventory and native READ precede publication. The serving publication intent precedes COMPLETE; its exact original delivery and prospective native source remain retained through partial failure or uncertainty. Positive COMPLETE plus independent original source absence precedes advancing to another canonical record, erasing the obsolete local selector and marking the descriptor historical. Native copies, source deletion and scalar acknowledgments cannot substitute for successful unique transfer. Receiver copies still retire only after the original two-sided seal evidence; factory source absence remains a separate obligation. Foreign origins, wrong operation/ordinal, replay, bad masks or altered scope/capacity/intent refuse before authority selection. Posixd requests one explicit factory destination only after learning the original positive client capacity and retiring the receiver pull caller. Its inventoried startup window owns that prospective slot before COLLECT. Complete client/realm/context/digest/operation/ordinal/capacity/intent and exact native receipt role precede actual local metadata and native READ/serial/process/kind/rights/cleanup validation. Original caller retirement precedes operational factory admission. Noncopyable factory custody travels with the original counted client row through sorting, configuration integrity, receiver registration and seal; metadata or a digest cannot create or reacquire it. The actual target layout follows changed row size with authenticated descriptor identity, without a hidden factory pool or private count ceiling. Factory READ/MINT is wanted runtime authority for future ordinary thread preparation and survives seal. Exact terminal/disposal intake closes access before cleanup; outstanding original thread/member/delivery/accounting owners remain separate. DROP acknowledgment and a separate actual absence query retire the original local factory. Errors retain its exact source, original client and first uncertainty; successor occupations cannot stand in for original identity or inherit forgotten authority. Receiver/watch/factory/member and native process retirement remain separately proved. No new native controller, broad resolver, root capability or endpoint discovery is introduced. Author independent literal/correlation/old-minor, rights/role, source/move/refusal/replay/selector-erasure, actual consumer/READ/caller/registration/seal/disposal and zero-policy controls. Add bounded genuine native transfer and actual producer/consumer VM sources as the coordinated path allows, preserving older oracles and finite budgets. Source-audit code size, documentation, original authority and immutable source graph continuously. Tests, Cargo/builds, lint checks, rendering, VM/profiler execution and CI observation stay deferred; authored controls supply no execution claim. This completes genuine factory delivery and operational custody, while original ordinary preparation/context/enrollment/Start, exclusive join/detach, full libc/TLS/module lifetime, imported native toolchain integration and complete consumer VM acceptance remain required. Both whole EriX guest generations and rebuilding external Rust/LLVM inside EriX remain mandatory and unperformed. All eight original whole-feature criteria stay open. See [counted caller custody](https://git.erikinkinen.fi/erix/launchd/src/branch/feature/posix-compat/docs/client-thread-factory.md) and [phase completion](https://git.erikinkinen.fi/erix/integration/issues/65). ### Validation resumed in parallel — 12 October 2026 The user lifted restrictions on testing and CI monitoring and requires all repositories to pass CI. Test or CI failures must never block unrelated implementation progress. Existing waived source checkpoints remain historical source acceptance, not retrospective test proof; earlier “remain deferred” wording is superseded for ongoing work. Full native factory delivery, ordinary thread lifecycle/libc/TLS integration, both whole EriX guest generations and rebuilding external Rust/LLVM inside EriX remain required and unfinished. </details> <details> <summary>Related records and contracts</summary> | Repository | Links | | --- | --- | | blockd | [PR 2](https://git.erikinkinen.fi/erix/blockd/pulls/2) | | bootloader | [PR 3](https://git.erikinkinen.fi/erix/bootloader/pulls/3) | | 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 | [issue 13](https://git.erikinkinen.fi/erix/exsh/issues/13), [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) | | integration | [issue 103](https://git.erikinkinen.fi/erix/integration/issues/103), [PR 12](https://git.erikinkinen.fi/erix/integration/pulls/12), [native-c-runtime-consumers.md](https://git.erikinkinen.fi/erix/integration/src/branch/feature/posix-compat/docs/native-c-runtime-consumers.md) | | irqd | [PR 2](https://git.erikinkinen.fi/erix/irqd/pulls/2) | | kernel | [PR 3](https://git.erikinkinen.fi/erix/kernel/pulls/3), [creator-floating-environment.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/creator-floating-environment.md), [independent-machine-state.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/independent-machine-state.md), [initialized-native-context.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/initialized-native-context.md), [native-context-memory.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-context-memory.md), [native-machine-state.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-machine-state.md), [native-member-carriers.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-member-carriers.md), [native-member-exit-observation.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-member-exit-observation.md), [native-thread-exit.md](https://git.erikinkinen.fi/erix/kernel/src/branch/feature/posix-compat/docs/native-thread-exit.md), [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-cstd | [thread-runtime.md](https://git.erikinkinen.fi/erix/lib-cstd/src/branch/feature/posix-compat/docs/thread-runtime.md) | | lib-driver | [PR 2](https://git.erikinkinen.fi/erix/lib-driver/pulls/2) | | lib-dynlink | [PR 3](https://git.erikinkinen.fi/erix/lib-dynlink/pulls/3), [tls-registry.md](https://git.erikinkinen.fi/erix/lib-dynlink/src/branch/feature/posix-compat/docs/tls-registry.md) | | lib-elf | [PR 2](https://git.erikinkinen.fi/erix/lib-elf/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 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), [relocation-patches.md](https://git.erikinkinen.fi/erix/lib-ipc/src/branch/feature/posix-compat/docs/relocation-patches.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) | | 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 | [PR 5](https://git.erikinkinen.fi/erix/posixd/pulls/5), [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), [client-thread-factory.md](https://git.erikinkinen.fi/erix/procd/src/branch/feature/posix-compat/docs/client-thread-factory.md), [initial-tls-materialization.md](https://git.erikinkinen.fi/erix/procd/src/branch/feature/posix-compat/docs/initial-tls-materialization.md) | | ramfsd | [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 | [PR 3](https://git.erikinkinen.fi/erix/vfsd/pulls/3) | | vspaced | [PR 2](https://git.erikinkinen.fi/erix/vspaced/pulls/2) | </details>
erikinkinen added this to the Alpha 1 milestone 2026-10-30 09:34:29 +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/kernel#47
No description provided.