[FEATURE] Acquire dynamic realm files through open and openat #17

Closed
opened 2026-09-29 18:32:02 +02:00 by erikinkinen · 0 comments
Owner

Problem and motivation

Mutable descriptor ownership is implemented, but the realm still cannot acquire a new file through open/openat. Current fixed metadata, resize and inherited-stream grants do not authorize arbitrary file acquisition. Build tools need files and directories opened relative to explicit realm roots or live directory descriptors, with original lifetime and permission evidence preserved throughout lookup, creation and close.

Proposed behavior and scope

Implement dynamic open/openat as a complete native producer/provider/consumer path. Reserve process-local fd and shared-description capacity before any acquisition or namespace effect. Add exact compatibility framing and checked access, creation, truncation, append, directory, no-follow and inheritance modes. Resolve current/root and live-directory-fd bases only from authenticated realm state; path bytes, mode bits and numeric selectors supply no native authority.

Introduce an explicit native acquisition grant and coordinated preparation. Do not widen existing READ_METADATA or RESIZE_FILE operations. Walk from original retained directory objects, checking search permission for every traversed directory and final access or parent creation permission using complete native metadata/ACL evidence. Permission comparison and the dependent lookup/create/truncate operation must concern the same original objects and revisions. Native ceilings and read-only mounts remain authoritative. Keep provider-owned staged objects inaccessible as application fds until admission and custody are complete.

Preserve original prospective/actual provider, receiver, local alias and caller owners through every result, cancellation and partial failure. Any descriptive child handle is usable only through its original held native route and checked owner/generation. Publish one lowest-free fd only after successful acquisition; share the original cursor/status through dup, close the last source exactly once, and retire uninstalled acquisitions before receiver disposal. Directory fds retain their original authority and support later relative opens. Implement creation ownership/mode under actual effective credentials and umask, exclusive create, required append/truncation semantics and coherent error behavior without silent fallback.

Authority, security and reliability

No ambient filesystem session, process authority, path reopening of a supposedly retained object, foreign descriptor table or metadata-only permission bypass is acceptable. Stage output/result and counted storage before effects. Do not replay uncertain opens or namespace mutations. Distinguish definite refusal, stale evidence, partial effects and unknown cleanup; uncertain native state retains original custody and fails stopped. Cancellation, process/realm death, malformed receipts, refused completion, fd exhaustion and generation exhaustion preserve the same obligations. No arbitrary static path/depth/table budget may replace explicitly counted resources and actual provider limits.

Acceptance criteria

Checklist
  • Define documented exact compatibility/native acquisition framing, checked modes, original authority boundaries and counted runtime/prospective storage; author literal, malformed, overflow and atomic-refusal controls.
  • Implement reserved fd/shared-description admission before native effects, exact publication/rollback ordering, generation correlation and terminal ownership of in-flight acquisitions.
  • Connect explicit native preparation and provider-relative traversal, trusted permission/ACL evidence and conditional lookup/create/truncate effects with exact original object lifetime and complete failure cleanup.
  • Connect actual sealed-client open/openat dispatch, directory-relative bases, file/directory descriptions, shared byte/append behavior and final-close/terminal cleanup; do not accept metadata-only substitutes.
  • Author host and native workload controls for reads/writes after opening, exclusive create, modes/umask, truncation, append, directory fds, denial, traversal/symlink boundaries, races, cancellation, exhaustion and refused completion. Preserve existing scenarios. Execution is waived by user.
  • Update component contracts and maintained manual/API descriptions, remove superseded code, publish a coherent signed immutable dependency graph and synchronize owning reviews and phase tracking. Keep complete EriX/toolchain guest rebuilds unfinished until demonstrated.

Alternatives and tradeoffs

A pathname-only wrapper around existing privileged namespace operations would skip both native admission and per-component permission checks. Adding another pre-bound file operation would still leave build tools unable to acquire files. Reopening retained paths after a permission check would introduce object substitution. Acquisition must instead retain its original source and staging ownership until a descriptor is published or all cleanup is positively known.

Behavioral reference: the Open Group open/openat contract. EriX code and fixtures remain original; compatibility values are assigned explicitly rather than imported from another runtime.

Tracking and rollout

Complete native Open/openat implementation is signed and published: lib-ipc 6b96c569, e2fsd aedb65bb, ramfsd dc1de465, fatd 0e209121, vfsd a368b741, posixd 85efb7f9, exsh 3ee15a96, docs c8565b7b, integration 9fb56e3d. Dynamic acquisition is accepted under the testing waiver, completing the Open/Close/duplication checklist item. Other filesystem mediation, libc/process integration and self-hosting remain unfinished.

Conditional creation uses distinct exact native/private families under the existing acquisition scope and original provider root. Posixd captures the authenticated current process mask and derives owner/group policy from fresh complete parent write/search evidence only after final-name absence. Parent setgid and selected-group membership constrain group/special bits; UID zero adds no privilege. VFS requires a writable scope and actual mount even for a Read descriptor and retains original candidate/provider/result cleanup before effects. Ext captures committed inode identity inside the full regular-file transaction, including complete default ACL inheritance and independent child storage; RAM reserves node/handle capacity under proven ACL absence. FAT/exFAT explicitly refuses unknown POSIX metadata.

Created access is frozen independently of the resulting mode, so mode-000 creating descriptors remain usable. Only original successful COMPLETE publishes the fd. A definite nonexclusive conflict retires the failed key before fresh search; stale evidence, malformed results and uncertain effects never replay creation. Cancellation and failed publication retire pins/callers without unlinking committed names. Shared parent/fence helpers and result framing remove duplication; ext publication adds no later fallible media read. No measured speedup is claimed.

Nineteen new unit controls are authored and unrun: four wire, two ext-media, two RAM, one FAT, three VFS and seven sealed-client controls. They cover full IDs/framing, policy and capacity refusals, mode-zero access, current masks, inherited groups, complete multipage ACLs, dangling links and directory suffixes, conflict/stale evidence, lost/malformed replies and refused publication. The native binding workload now checks mode-zero writes, exclusive conflicts, later DAC refusal, post-close persistent bytes, append at real EOF, conditional Open truncation, changed current-mask removal of owner-read permission and restoration, and denied creation by its Read-only peer. It reuses the existing correlated mask-exchange helper. Only its first explicit peer receives inherited acquisition access; realm/generation-separated names prevent fixture collisions. Existing literal producer controls and scenario exit/deadline requirements are preserved.

Current phase progress: 17.04% weighted, 5.61% whole-item acceptance; 22/460 parents and 442/902 sub-items. Both full EriX guest-build generations and rebuilding external Rust/LLVM inside EriX remain required and unperformed. Test-only execution is waived, never reported as a pass.

Detailed scope and contracts

Conditional native regular-file creation and full Open integration

Add distinct native and private conditional creation operations, under the existing original acquisition scope and provider root. The native request carries a pre-submission candidate key, actual root/cwd/held-parent target, fresh parent permission revision, raw final name, requested access and explicit creation mode/UID/GID/mask. The private request substitutes only original provider handles and includes optional VFS-selected trusted time. Exact framing, checked modes/masks, known access, nonzero identities and complete final-component syntax precede every effect. Dot/dot-dot are not creation names. Creation responses remain disjoint from ordinary pin/admission responses and expose no private provider handle to compatibility callers.

Search and existing-object access remain separate from creation admission. Open first searches normally. Only a known missing final component with CREATE, without required-directory semantics, enters fresh parent write/search evidence and complete ACL mediation. Capture the authenticated process's current mask with its original accepted call, not from its immutable initial configuration. Select the authenticated effective UID; inherit the freshly observed parent group when its set-group-ID policy requires it, otherwise select the effective GID. Requested set-group-ID is cleared when the authenticated process lacks that group membership; no UID-zero or implicit native privilege bypass. The complete parent revision binds this selection before provider effects.

Reserve every fd, candidate row, original acquisition key, provider handle and result/cleanup correlation before persistent effects. VFS intersects the original scope write ceiling and actual mount policy even for a requested read-only descriptor. Creation uses the actual selected parent branch and never follows a replacement mount/path. Providers compare original permission evidence and ancestry before a typed absence check and their exclusive create transaction. E2fsd uses its complete independent default-inheritance core; Ramfsd supplies real explicit metadata and proven ACL absence. FAT's unknown POSIX permission evidence remains a refusal, not invented metadata.

A successful creation also admits the requested candidate access. Its mode may be000: do not reapply existing-file access checks to invalidate an already authorized creation. VFS freezes access under the same original acquisition owner, and Posixd publishes the reserved descriptor only after positive original COMPLETE. Lost/malformed replies retain original-key cleanup custody. Cleanup retires pins and callers, not the newly created directory entry; it must never undo a committed creation or replay it. Uncertain ext mutation completion keeps provider fail-stop semantics. Failed final publication leaves no usable descriptor while the committed namespace effect remains.

Retire the unsuccessful search candidate before a new creation key is reserved. An exclusive conflict returns EEXIST. A nonexclusive, definitely no-effect conflict retires that failed creation candidate and resumes fresh search under a new key, permitting the concurrent existing object to receive ordinary final access/truncation checks. Stale or ambiguous effects are not retried. Preserve existing symlink, mount, root/cwd, expansion, cancellation, result and descriptor cleanup semantics, including CREATE through a dangling link and exclusive final-link refusal.

Author exact wire/correlation controls; provider stale/wrong-root/no-space/conflict/metadata/default/cleanup controls; VFS original-route/mount/capacity/uncertain-custody controls; and actual Posixd/native positive, malformed, permission, race, umask, set-group-ID, mode000 and failed-completion coverage. Update contracts and technical manual, coordinate immutable source pins bottom-up, and maintain owning PRs and phase tracking. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Full Open acceptance and both EriX guest generations plus external Rust/LLVM rebuilding remain the unchanged objective.

Regular-file default ACL inheritance and explicit creation metadata are implemented and published: e2fsd ac8aa517, docs 50185374, integration 2ef59f4a, rootd d6055e7f. The full conditional Open/openat work remains open.

The original ext regular-file transaction now requires explicit requested mode, full owner/group IDs, mask and times. Existing administrative path, exact and touch callers explicitly retain0644/UID0/GID0/mask0. Complete access/default decoding shares structural and streamed integrity checks while keeping their mode rules distinct. Valid empty defaults mean absence; malformed or duplicate defaults refuse before allocation. Present defaults attenuate only owner/group-class/other permissions by requested mode without reapplying the mask. Named entries remain exact. Without defaults, the explicit mask restricts requested mode.

Every child receives independent inode-body, external or streamed immutable ACL storage. Parent descriptors, shared tables and value references are preserved. Child ownership/mode/ACL, inline file data, full allocation charges, namespace insertion, selected times and quotas retain the original transaction. Rollback, complete source-digest binding and uncertain-write fail-stop remain. No native route, grant, ambient process metadata or effect replay is introduced. Local payload retention and allocator/journal fixtures are shared; the common builder performs the complete digest check without duplicate hashing in its callers. No measured speedup is claimed.

Fourteen new controls are authored and unrun: eleven actual-media controls, one orchestration control and two host-oracle controls. Coverage includes empty/malformed/duplicate defaults, high identities, shared tables, inline files, all administrative creation paths, over64KiB/9004-entry values, source/charge preservation, independent deletion, quota rollback, uncertain writes and changed source bytes. The existing native ACL scenario now has39 requests with local/streamed child creation, original-handle closure and deletion; post-VM decoding checks complete defaults/access ACLs and independent lifetimes. Existing scripted workload coverage is extended too.

Conditional compatibility creation still needs authenticated current process policy, fresh held-parent write/search and revision comparison, original acquisition/result/cleanup ownership and descriptor installation. Directory creation inheritance remains separate work. This provider implementation does not close full Open or add full-item acceptance credit: 16.91% weighted and 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred by user instruction. No executed pass or warning-free build is claimed.

Earlier evidence follows; the implementation scope above is current.

Ext default inheritance and explicit creation metadata

Refine conditional creation around the provider's original exclusive mutation. Compatibility admission must authenticate current process policy and acquire fresh parent write/search evidence under the original native scope. The provider compares the original parent revision, then validates and uses the actual parent default ACL in the same serialized creation transaction. A separate transported default-ACL snapshot is unnecessary when the provider performs the complete inheritance itself; access-evidence freshness and native scope ceilings still precede creation. Unknown or malformed defaults refuse rather than becoming empty policy.

Share complete access/default ACL decoding, distinguishing their namespaces and mode rules. Access ACLs must agree with current owner permission bits; defaults describe future children and need not match the parent's access mode. Preserve complete structural validation, both attribute stores, value integrity, full-width qualifiers and bounded streaming without an entry-count ceiling. A fully validated empty default denotes absence. Inherit defaults as child access ACLs, attenuating mode-corresponding classes by requested permissions while leaving named entries unchanged. Apply the creation mask only when no default is present.

The shared regular-file core will take explicit requested mode, UID, GID, mask and time fields. Existing native administrative callers explicitly retain their established regular mode0644, UID/GID0 and mask0 policy while gaining default inheritance; these values must never be inferred for compatibility processes. Future conditional callers must provide the authenticated process policy and resolved ownership under the freshly checked parent. Preserve all permission/special bits admitted by the explicit policy; IDs describe metadata and grant no native authority.

Validate defaults before allocation. Copy inherited bytes into child-owned inline or external storage, or stream a new immutable value inode when required. Never rewrite or retire the parent's descriptor, shared table or value reference. Account the child's full attribute charges, preserve inline file data, and commit child mode/ownership/ACL, namespace insertion, timestamps and quotas together. Original transaction rollback and uncertain-effect fail-stop remain. No added block/key/clock capability, fallback route or mutation replay is permitted.

Derive behavior from ACL semantics and the ext attribute format; author implementation and fixtures independently. Add complete-media inheritance, absence/mask, malformed/duplicate storage, shared parent, large value, ownership, rollback and cleanup controls. Tests/builds/lint/docs generation/VM/profiler execution and CI observation remain deferred. Full conditional acquisition, authenticated caller wiring, complete Open and required EriX/external-toolchain guest rebuilding remain in scope.

The ext destination-lookup defect is implemented and published: e2fsd bddfed39, docs ea2f3f25, integration 8fa3c0b8. It is closed under the testing waiver. The full conditional Open/openat work remains open.

Completed child absence now has a distinct internal result. Block/key/format failures, including dependency NOT_FOUND, propagate through regular-file creation, mkdir, links, rename destinations, exact-entry resolution/revalidation and indexed journal recovery. Provider rename preflight retains the distinction across the full pathname and preserves its existing held-destination exclusion on both wire versions. Short unparsed directory suffixes refuse as malformed media. Original mounts, block/key routes, parent identities and native operation ceilings remain unchanged.

Path, exact and touch regular-file creation share one transaction core. Preflight precedes allocation; inode and optional inline payload initialization, checksums, entry insertion, timestamps, quotas and result metadata remain under the original transaction owner. Explicit touch fields override automatic times. Unselected touch fields no longer cause a redundant touch read/write. Journal rollback and uncertain-effect fail-stop behavior remain; no measured performance result is claimed.

Ten regression controls are authored and unrun: linear/indexed namespace failures including missing-device codes, malformed records/suffixes, exact absence resolution/revalidation, successful mutations, intervening conflicts, persisted modes/inline data/timestamps, held-destination provider preflight and indexed recovery with unchanged home media. Rustfmt was applied to19 changed Rust inputs. The source inventory covers 3573 code files across 76 repositories, all below1000 lines; largest changed source 988 lines. Contracts, component documentation and maintained filesystem manual TeX are updated. Three signed commits are published with three catalog selections; the independent Rootd helper remains 17acba24ba2136d453fa84326574b7470b161741.

This completes the reported mutation defect and consolidation. Full conditional compatibility creation still needs authenticated requested mode/effective IDs/current mask, original held-parent evidence, default ACL inheritance and original acquisition/result/cleanup custody. No full Open acceptance credit is added: 16.91% weighted and 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest generations and rebuilding the external Rust/LLVM toolchain inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No executed pass, warning-free build or benchmark result is claimed.

Earlier source evidence follows; the correction above is current.

Authenticated process creation-mask configuration and exchange are implemented and published within full Open/openat: lib-ipc ec802763, lib-posixabi c81f92e5, launchd 1e3ebccd, posixd 6ca3e122, exsh 06056100, docs 468095f5, integration d8413bf1. Full conditional creation remains open; the complete ownership and inheritance design is recorded before ABI implementation.

Canonical configuration/pulls require minor four. Each original client explicitly carries a checked nine-bit initial mask in its unchanged 72-byte record. Owner appends have a distinct 60-byte client record; old frames are rejected. No host, environment, UID-zero exception or omitted-field default supplies policy. Launchd preserves the mask through reversible sorting by using only the remaining reserved u32 for temporary ordinals. Posixd reserves policy with the original counted receiver and verifies it against the frozen digest-covered plan before serving.

Compatibility 1.7 adds Umask operation11. Actual sealed CLAIM admission selects the exact native process generation. A complete previous-mask reply is prepared before one process-local exchange; only low permission bits of the argument are retained. Failed or ambiguous COMPLETE preserves the result and effect under its original serving owner without replay or rollback. Terminal retirement disables selection. No descriptor, filesystem handle, provider call, native endpoint or capability grant is added. The live credential view reports current policy rather than the initial frozen value.

Twelve new unit controls are authored and unrun, alongside migrated independent wire/C constants, original producer fixtures and existing sorting/credential controls. The native two-client workload configures masks027 and077, changes them independently before reciprocal channel traffic, then checks and restores them after peer participation. The LibIPC fixture defect and Launchd fixture defect are corrected and closed under the testing waiver. Reproductions remain explicitly source-derived: missing count, obsolete frame/storage sizes and addressability assumptions were corrected, and the canonical digest fixture was authored independently without executing EriX code.

Conditional creation must still consume current process policy, fresh held-parent evidence and complete default ACLs under original acquisition custody. Persistent inheritance, complete provider policy, libc/shell process integration and fork/exec inheritance remain unfinished. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No executed pass, warning-free build or measured performance result is claimed.

Earlier evidence follows; the process-mask implementation above is current.

Conditional creation and process mask design

Continue full Open/openat acceptance with atomic final-component creation under the original held parent and acquisition scope. A confirmed missing final component may enter creation only after fresh parent write/search and default-ACL evidence. Intermediate absence, unknown replies and malformed evidence must not become permission to create. Reserve descriptor, candidate identity, response storage and cleanup correlations before effects. Providers must correlate the original parent identity and evidence, serialize existence check with creation, and retain the original acquisition key through uncertain replies. Cleanup retires private pins; it must not unlink a possibly committed file or replay creation.

First establish process creation policy through the existing original-client configuration and serving lifetime. Add an explicit checked nine-bit initial file creation mask to each owner append record and digest-covered canonical client record. Grow the append record so old framing is rejected; bump the canonical configuration/pull version before consuming reserved bytes. The runtime's counted noncopyable client row carries the initial mask through reordering, verifies it against the sealed plan, and owns the mutable value for that exact native process generation. There is no host/environment/default mask and no implicit UID-zero exception.

Add a distinct compatibility Umask operation: authenticate the actual CLAIM and sealed receiver, prepare the old-mask reply before replacing the process mask, ignore argument bits outside the permission bits, and retain the fixed reply with the original serving owner. Repeated caller correlations are not replay keys. A refused or ambiguous COMPLETE must not execute the exchange twice or roll it back; terminal retirement disables further selection. Querying live credentials exposes only the authenticated process's current creation policy. No descriptor, native endpoint, filesystem handle or new capability grant is involved. Author framing, legacy rejection, exact-generation isolation, response-capacity, repeated correlation and failed-completion controls, plus a native multi-client witness.

Creation metadata uses effective IDs selected from the original client. Without a parent default ACL, attenuate requested permission bits by the process mask. With a validated complete default ACL, inherit it as the child's access ACL and attenuate the mode-corresponding owner, group-class and other entries by the requested mode; do not apply the process mask a second time. Named qualifiers remain unchanged. Ext default ACLs must remain distinct from access ACLs, and persistent inheritance must commit with creation. Unknown provider metadata remains denial, never an invented empty ACL. Full native creation, persistent inheritance, provider policy, failure cleanup and native workloads remain in this issue's acceptance scope.

Derive semantics from the POSIX open specification and the Linux ACL manual, without importing implementation code: https://pubs.opengroup.org/onlinepubs/9799919799/functions/open.html and https://man7.org/linux/man-pages/man5/acl.5.html. Coordinate producers, consumers, documentation and immutable dependency revisions. Tests, builds and CI execution remain deferred by user instruction; author appropriate controls and distinguish them from executed evidence. Both full EriX guest build generations and rebuilding the external Rust/LLVM toolchain in EriX remain required.

Original mount creation custody and retained administrative installation are implemented and published within full Open/openat: lib-ipc 08c3a9d0, ramfsd 84d60c9c, e2fsd 136c1272, fatd 13738d5e, vfsd c2fcb803, posixd 6cbcfe53, docs 962857ba, integration 450c6f2a. The lost mount reply defect is fixed and closed under the testing waiver. Its reproduction remains explicitly source-derived; no executed compiler, VM or fault-injection result is claimed.

Private 0x6FD creation and 0x6FE retirement carry caller-known monotonic keys, complete original correlations, canonical success/refusal shapes and known dispositions. The superseded unowned mount family and consumer adapter are removed. RAM/ext/FAT reserve original IDs and counted mount storage before initialization or media inspection/recovery. Retirement waits for dependent handles, fences stale replay and clears only the original instance. Committed ext journal recovery is not rolled back when private state retires.

Vfsd reserves the namespace record, original route and both correlations before submitting through its counted noncopyable owner. Unknown replies preserve that owner even without a returned mount ID. Administrative installation follows retained raw parent links and earlier actual mount edges, checks actual alias conflicts and covered target type, then publishes in place without losing entering-parent custody. Every failure disables installation before cleanup; refused cleanup retains its original counted row. Independent serving-loop retirement needs neither the initiating client nor fresh correlations. Existing mounts remain available while a failed pending installation drains.

FAT/exFAT supplies original mounted-root/component custody and counted retained ancestry. Retired intermediate caller records become inaccessible to ordinary operations; descendants can retain their entering edges until iterative final release. Dot-dot follows actual held parents and clamps at the original root, including exFAT. Existing identity-replacement exclusion remains effective. Fresh one-use descriptive revisions are consumed before same-turn lookup. POSIX mode/UID/GID/ACL evidence remains unknown; namespace administration does not invent compatibility access policy or acquire additional client authority. Actual compiled arena layouts include the enlarged owner records.

Twenty-one new unit controls are authored and unrun, with three existing actual mount-dispatch controls extended. They cover literal codecs, known refusal and unknown replies, original route/key/correlation cleanup after exhaustion, replay and row reuse, dependent handles, capacity before media work, actual FAT/exFAT ancestry, stale revisions, configured relative/absolute links, aliases, provider crossings, occupied namespace storage and post-creation cleanup refusal. The native realm-binding scenario installs a read-only RAM overlay through an ext symlink parent, opens it through configured and actual namespace spellings, then ascends from a live directory fd. Its explicit budget counts additional namespace and simultaneous client branch pins. No new unit control or VM workload has been executed.

Full Open remains open for conditional creation, authenticated process umask/default ACL inheritance and complete provider policy. No full Open checklist credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No test pass, warning-free build or measured performance improvement is claimed.

Earlier evidence follows; the original mount custody and retained installation above are current.

FAT-family namespace parent custody

The new installation path must preserve mounting beneath FAT/exFAT directories. Extend the existing mounted-root, conditional-component, original retirement and descriptive snapshot families on the private FAT route. Retain ancestry in deployment-counted handle records, including intermediate directories whose caller ownership has retired while descendants still need their original entering edge. Such rows remain inaccessible by ordinary handle operations and drain iteratively when the final dependent child retires. Literal dot-dot follows retained ancestry and clamps at the actual mount root, including exFAT, without trusting on-media parent names, reopening a configured path or adding a fixed traversal-depth bound. Live pins continue to prevent directory identity replacement.

Original mount and component keys remain monotonic and fenced. Root retirement disables access immediately and waits for descendants; independent child retirement remains possible. Snapshot revisions are distinct and consumed before dependent lookup, with the actual retained directory refreshed in the same provider turn. FAT does not supply POSIX ownership or ACL evidence: these fields remain explicitly unknown, rather than inventing user/group IDs or treating an unsupported ACL as absent. Namespace administration already holds its explicit provider authority; this descriptive snapshot does not authorize compatibility-process file access. Full realm Open still needs its complete permission policy and provider coverage. Author FAT and exFAT positive, capacity, stale-evidence, ancestry-retirement and lost-reply controls; execution remains deferred.

Retained mount installation design

Before installing configured parents through the retained namespace walker, repair original provider mount creation custody. The lost mount reply defect records the source-derived failure. Add distinct private mount creation and retirement families with a caller-known nonzero monotonic owner key, complete original-key echoes, known dispositions and canonical success/refusal shapes. Reserve original route plus acquisition and cleanup correlations before submission. A missing or malformed reply stays owned; a correlated definite refusal proves no retained mount allocation. Original-key cleanup fences replay and remains possible without receiving a mount ID or allocating another correlation.

Providers keep the owner key in counted mount storage, admit keys monotonically per original provider endpoint lifetime and preflight mount storage before media validation or allocation. Retirement finds the original creation key, refuses reuse while dependent handles remain and releases only the original mount state; absent-key retirement fences stale replay. Returned mount IDs remain descriptive selections within the existing provider authority. No public client capability or new discovery route is introduced. Coordinate RAM, ext and FAT producers with the Vfsd consumer, and remove the superseded wire path once the consumers and coverage are migrated.

Reserve the namespace installation record before retained parent traversal. Preserve root-first ordering, actual target type checks under the held parent, alias-edge conflict checks and the original administrator's mount flags. Successful publication must preserve the prepared entering-parent owner, not overwrite it with an empty record. Failed walks and failed/uncertain mount creation retain their counted records through independent cleanup. Connect the public administration route and author a native configured-link mount scenario. Audit unsupported provider traversal explicitly; do not introduce a silent fallback that turns denial into path authority. Full Open still requires conditional creation with trusted process umask and default ACL inheritance. Tests, builds and CI execution remain deferred.

The retained namespace-parent binding engine is implemented and published as continued full Open/openat work: vfsd e08309b1, docs b9365cb1, integration cbca80fc. The ownership contract distinguishes implemented traversal from the remaining administrative installation connection.

Namespace walks now retain noncopyable symlink and temporary parent owners in deployment-counted handle rows, keyed by the original walk generation and full outer-frame generation. Every allocation family excludes these rows while owned. Raw pages retain original object, offset and total correlation; a bounded cache preserves unread bytes across components, including the first observed byte. Target length is independent of the configured-path buffer and packet width. No fixed follow count or whole-target array is introduced. Relative targets keep actual parents; absolute targets use only the original namespace root. Actual active object/parent/mount contexts detect recursion while allowing completed revisits and distinct-parent hard-link aliases.

Literal dot/dot-dot traversal uses fresh conditional pins. Mounted descent and ascent retain a conditional departing guard and independently pin the destination. Earlier installed binding dependencies suspend in counted mount records and resume through an iterative driver, without recursive call-stack growth. Actual bound parent objects now select native edges and initial cwd ancestry instead of lexical ancestor-provider prefilters. Client scope ceilings and provider ancestry proofs remain separate. Namespace administration owns these pins; no client grant, public endpoint, clock or metadata write is introduced.

Failures drain current/prospective pins, guards, active expansion chains and suspended dependencies independently of client liveness. Lost replies, malformed later pages, exhausted fresh correlations and refused cleanup preserve the original provider keys and counted rows until positive retirement. Successful namespace roots and entering directories keep their installation lifetime.

Nine new controls are authored and unrun: relative/absolute raw and all-slash targets, a 703-byte target and page caching, 45 completed expansions, direct/mutual/growing recursion, distinct-parent aliases of one link inode, cross-provider mount edges and initial ancestry, mounted ascent, malformed pages with refused cleanup, actual owner exhaustion and suspended dependency cleanup. Rustfmt was applied to 15 inputs with actual crate editions and repository settings. The page-cache control counts fixture provider calls; no measured runtime speedup is claimed. Contracts, README navigation, architecture/roadmaps and manual TeX are updated. Three signed commits are pushed, with three catalog revisions selected and the existing independent Rootd Rust helper preserved. Source inventory covers 3541 code files in 76 repositories, all below 1000 lines; the largest changed Rust file has 946 lines.

Source inspection found that administrative mount installation still uses legacy path-stat preflight. Ext lookup does not follow parent links, so that route must be connected to the new retained engine with pre-effect reservation and complete cleanup before configured symlink mounts can be accepted. Its native VM scenario remains to be authored with that connection. Conditional Open creation with authenticated process umask and default ACL inheritance also remains unfinished. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed.

Earlier evidence follows; the namespace engine and remaining installation connection above are current.

Configured mount-parent traversal design

Resolve each configured entering directory from the independently held namespace root using conditional no-follow component pins and raw retained-link pages. Relative targets retain the actual containing directory; absolute targets use the namespace root. Preserve literal dot/dot-dot traversal across actual mounted roots. Namespace administration supplies this authority; it neither borrows a client scope nor grants a compatibility permission verdict.

Use deployment-counted handle rows for noncopyable active link expansions. Each row owns its original symlink and any temporary containing-directory pin, the exact namespace walk generation, an outer-frame key, and a raw target cursor. Stream components from correlated pages rather than imposing a whole-target array or fixed link-follow count. Compare actual still-held link/parent contexts on their installed mount routes to detect recursive expansion. Completed frames retire positively before reuse; failures drain all original owners independently of the initiating client. Temporary directory and mount-transition pins stay in the counted mount walk before submission. Unknown replies and refused retirement never free their records.

Bind a mount against earlier installed mounts, preserving installation ancestry rather than allowing later aliases to retroactively move its entering edge. Existing mount storage has no removal/reuse operation. Drive dependencies iteratively through counted mount records, with strictly earlier installed dependencies and no recursive call-stack growth. Native edge selection compares actual bound parent objects; initial cwd ancestry follows those same bindings instead of configured lexical prefixes. Conflicting bindings to one actual edge refuse deterministically. Existing administrative path representation remains the input contract; raw target lengths are independent of it.

Author controls for relative/absolute links, long paged targets, cross-mount traversal and ascent, repeated finite links, recursive contexts, identity aliases, frame exhaustion, malformed pages and retained cleanup. Update contracts and the manual, then publish signed dependency/catalog selections. Tests, builds and CI execution remain deferred. Full Open continues to require conditional creation, authenticated process umask and default ACL inheritance; this design does not narrow its acceptance.

Retained symlink following, active-context loop detection and original expansion cleanup are implemented and published as continued full Open/openat work: lib-ipc d1cc4cad, posixd 7d6a76fe, vfsd 10fb2e5c, docs 44bfa626, integration f69e2243.

Posixd assembles every raw page into its original counted request region before following any target byte. Original key, offset and unchanged total extent remain correlated. Relative targets retain their containing directory; absolute targets select only the original scope root. Raw unresolved suffixes, trailing-directory requirements and fresh component/dot/dot-dot search mediation survive substitution. Final exclusive creation refuses an existing link with EEXIST, and final NOFOLLOW refuses with ELOOP before reading target text; directory-prefix links still follow.

Noncopyable active expansion frames retain original symlink and temporary containing-directory pins in the existing counted shared-description arena. Their generational chain and suffix boundaries are internal ownership, never published fds. Complete frames retire both original pins before row reuse. Cancellation drains the complete original chain before cancelling the reserved fd; uncertain replies preserve native caller and original-key custody. The target-derived arena descriptor counts the actual enlarged owner types. Actual byte/owner exhaustion reports ENAMETOOLONG/ENFILE without a fixed follow count.

Cap-free native operation 0x6FC has exact 56-byte requests and 64-byte replies, echoing both complete link/parent contexts and canonical equality. VFS selects only original live pins and compares actual link/directory objects, provider/mount routes and complete retained mount ancestry. Fresh candidate or branch allocation numbers do not determine equality. Comparison calls no provider, obtains no clock and creates no pin. Earlier objects remain pinned throughout active comparison, preventing identity reuse. Returning to an active context reports ELOOP; completed expansions can recur sequentially. Full final permissions and original cleanup remain separate obligations.

The runtime owner observation defect is fixed and closed under the testing override. A const pending-operation observer called a non-const Open method. Removing the unnecessary const qualifier preserves runtime custody observation and includes active frame cleanup callers. The bug report records exact source-derived reproduction and explicitly states that no compiler or runtime reproduction was performed.

Eighteen new tests are authored and unrun: two wire, three raw-assembly, eight sealed-service, three native VFS and two ext-image packaging controls. Coverage includes non-UTF-8 bytes, a 700-byte assembled target, original parents and scope roots, nested and repeated links, more than forty sequential revisits, same-link aliases in distinct directories, direct/mutual/growing recursion, malformed later pages, storage exhaustion, final flags, scope isolation, mounted re-entry and cancellation with refused cleanup. The existing native binding workload now follows independently packaged literal ext links into mounted tmp, observes actual target data, and exercises recursive, NOFOLLOW and trailing-separator cases. The fixture is included only when the original native byte client is selected. No new test or VM workload has been executed.

Configured namespace-parent symlinks and conditional creation with authenticated process umask/default ACLs remain unfinished within full Open. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed.

Earlier evidence follows; retained client following and active-context comparison above are current.

Connect raw retained-link pages to Open without discarding the containing directory. Relative targets restart at that original directory; absolute targets select only the original scope root. Assemble the complete, correlated raw target in the client's counted request storage before following any bytes. Preserve the unresolved suffix, trailing directory requirement and literal dot/dot-dot permission checks. Final exclusive creation refuses an existing link with EEXIST; final NOFOLLOW refuses with ELOOP, while intermediate links still follow.

Retain active expansion frames in the already counted shared-description arena. A frame owns the original symlink candidate and any temporary containing-directory candidate, plus a generational previous-frame key and unresolved suffix boundary. These are internal owners, never published fds. Pop only after the target expansion resolves, and positively retire both original pins before releasing the frame. Cancellation drains the complete original frame chain before cancelling the fd reservation. Exhaustion reports real counted storage exhaustion, not a fixed link-follow limit.

Add a cap-free native comparison family (0x6FC) for two retained link/parent contexts under one actual live scope. Requests echo both link keys and complete parent selectors; responses echo all fields and a canonical boolean. VFS compares actual pinned link and parent identities, provider/mount routes and complete retained mount ancestry. Fresh candidate/branch numbers are not object identity. This observation acquires no provider pin, clock, path or capability. Active owners keep compared objects alive; copied descriptive identities cannot manufacture cleanup custody. Compare only active expansions so legal repeated links after a completed expansion remain valid. A detected recursive context reports ELOOP before another expansion.

Author raw-byte, multi-page, relative/absolute, nested/sequential, growing-loop, final-flag, storage, cancellation and refused-cleanup controls. Extend native workloads where the deployed fixture can provide actual symlinks. Tests, builds and CI remain deferred. Full Open still includes configured namespace-parent links and conditional creation with authenticated umask/default ACLs; this design does not reduce that acceptance scope.

Specification basis: https://pubs.opengroup.org/onlinepubs/9799919799/functions/open.html and https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap04.html#tag_04_16. Independent implementation; no external implementation code is imported.

Raw retained-link pages and original-root retirement enforcement are implemented and published as continued full Open/openat work: lib-ipc 9119a684, ramfsd 4e992840, e2fsd e233edea, vfsd 72564e18, docs 4668d855, integration 07490592.

Distinct native-scope operation 0x6FA and private-provider operation 0x6FB share checked 32-byte requests and 48-byte response prefixes. Original object/key, offset, total target length, positive capacity and initialized bytes are fully correlated. Raw NUL-free targets have no UTF-8 gate or whole-target transport array; page storage does not restrict total target length. Refusals carry no target bytes, offset or total, and do not acknowledge pin retirement.

Ramfsd reads the actual retained node and checks only returned bytes, avoiding a repeated scan of the whole target on every page. Its existing node storage geometry still applies. E2fsd shares one fast/block-backed inode byte reader with legacy whole-target access while retaining that caller's text representation and capacity refusal before data I/O. The VFS gate admits only actual live symlink candidates in the original scope. Complete private response validation precedes in-place rewriting of descriptive correlation/key words. Failed or malformed replies scrub staging. These observational calls create no handles, reopen no path, query no clock and preserve independently reserved original cleanup after correlation exhaustion.

The RAM retained-link retirement defect and ext retained-link retirement defect are implemented and closed under the testing override. Their bug reports record source-derived reproduction and execution limits. The old whole-target readers checked the child handle without checking its acquisition root. Both old and paged readers now reject once that original root enters retirement, while child cleanup remains available. The native VFS scope gate independently rejects revoked scope use; no external runtime bypass is claimed.

Fourteen controls are authored and unrun: three wire, three RAM provider, four ext media/provider, two transport-fault and two actual native-scope controls. They include non-UTF-8 bytes, a 700-byte block-backed target larger than the legacy buffer, page geometry, original echoes, malformed and lost responses, capacity refusal, wrong scopes/types, revocation, original anchor retirement and cleanup after exhausted correlations. Rustfmt was applied to 27 Rust inputs using actual crate editions and repository settings. Contracts, evergreen navigation, architecture/roadmaps and technical manual TeX are updated. No measured performance result is claimed.

Complete consumer assembly/following, loop handling, configured-parent symlinks and conditional creation with authenticated process umask/default ACLs remain unfinished within full Open. Native directory mount traversal remains connected. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed.

Earlier evidence follows; the raw-page implementation and root-retirement correction above are current.

Retained symlink reading design: add distinct private-provider and acquisition-scope page operations, with exact original object/key, offset, requested capacity, total target length and actual initialized bytes. Targets are raw NUL-free pathname bytes; UTF-8 conversion and fixed whole-target transport buffers must not restrict native Open. Pages are observational, do not create handles or query a clock, and never reopen a pathname. Provider and scope families remain disjoint; a native scope can select only its own live original symlink candidate. Refused, malformed or overlong replies expose no staged target bytes and preserve original-key retirement.

Ramfsd reads the actual retained node; E2fsd reads fast or block-backed link slices from the actual retained inode. E2fsd will share the underlying byte reader with legacy whole-target access while preserving the legacy caller's stricter representation separately. Reply storage determines page length, not total link length. Native VFS rewrites private handle identity to the original candidate key after complete correlation. Consumer assembly must compare total extent across every page and retain the containing directory and symlink pin until the full target is available; relative targets continue from that directory and absolute targets restart only at the original root. Final no-follow and exclusive-create semantics, bounded cancellation, loop handling, configured-parent symlinks and conditional creation remain in full Open scope. No new fixed symlink-follow limit is accepted as a substitute for that implementation.

References: POSIX pathname resolution and Open semantics. Tests and execution remain deferred; appropriate raw-byte, multi-page, identity, cleanup and malformed-response controls will be authored.

Native directory mount descent/ascent and initial cwd ancestry are implemented and published: docs a5d8bde4, vfsd 137189c8, posixd 0f12172a, integration b01ed6f5.

VFS retains a counted noncopyable branch with independent entering-directory and mounted-root pins, original scope identity and a generational outer-branch dependency. Descent preflights branch/result storage and conditions the already-mediated search revision before acquiring the mounted root. Actual held identity selects the configured edge; no underlying covered child is forwarded. Nested branches and descendants survive closure of their initiating public directory. Selected mount restrictions still intersect the original scope ceiling.

Ascent conditions search at the actual departing root and retains its temporary guard together with the prospective outer result under the original client cleanup key before effects. The result selects the independently held entering directory beneath the original outer ceiling. Only positive guard retirement permits ordinary use; unknown replies, identity mismatch or refused retirement retain cleanup-only custody. Initial cwd and derived scopes clone each entering parent under its actual outer ceiling, proving provider ancestry before acquiring the next root. Final cwd cloning binds to its mounted root. Scope publication preserves the monotonic key sequence consumed during preparation; no fixed mount-depth limit is added.

Candidates and initial cwd drain before their branch dependencies. Unreferenced branches retire from leaves outward, retaining both original pins and their outer dependency through uncertainty. Original cleanup works after source closure and correlation exhaustion. Zero branch count skips arena scans during ordinary same-mount cleanup; no measured speedup is claimed.

Eleven new VFS controls are authored and unrun for separate providers, nested mounts, independent descendants, stale revisions, lost replies, busy cleanup, exhausted correlations, storage preflight, selected read-only policy, initial subdirectory ceilings and derived/unpublished cwd lifetime. Existing edge fixtures now expect actual mount entry. The native binding workload adds absolute and directory-fd ascent out of /tmp and re-entry, repeated ascent and base-fd closure. Rustfmt was applied to 19 Rust inputs using each crate's actual edition and repository settings. Contracts, architecture/roadmaps and technical manual TeX are updated, with superseded status paragraphs consolidated.

Four signed commits are pushed on feature/posix-compat, with remote head equality recorded. Integration adopts five catalog entries and retains independent Rust helper cafa58e132fe45defcea4df0e8d92cf65fdb209b. No Cargo source identities change. Read-only inventory covers 3515 code files in 76 repositories, all below 1000 lines; the largest changed source is 793 lines.

Full native Open/openat remains open for client symlink following, configured-parent symlinks and conditional creation with authenticated process umask. These implemented directory transitions add no full Open acceptance credit. Recalculated progress is 16.91% weighted, 5.21% whole-item acceptance: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass or warning-free build is claimed.

Earlier evidence follows; current directory mount traversal supersedes earlier statements that mount branches were unfinished.

Mount traversal implementation design: store each scope-owned mounted-root and independent entering-directory obligation in a deployment-counted branch row. Its generational outer-branch link retains the original scope ceiling; candidates reference that row without turning returned handles into authority. Conditional descent first pins the actual entering directory using the already-mediated parent revision, then acquires the original mounted root and an independent result candidate. At a mounted root, parent traversal conditions the original search revision before pinning the actual independently held outer parent. Both sides remain owned under the original client cleanup key across lost replies and busy retirement. Retire unreferenced branches after candidates, preserve inner-to-outer dependencies, and retain unknown preparations until positive original-key cleanup.

Initial cwd is included in this design: build the actual configured mount ancestry and independently bind each entering parent under the held outer ceiling using the provider's existing conditional ancestry check. Bind the original cwd under its actual mounted-root branch before publishing the scope. Namespace paths identify configured topology only; held objects and provider ancestry authorize the resulting pins. Scope derivation repeats original ownership without depending on the source after publication. Keep the original subdirectory ceiling, nested mounts, selected-mount restrictions and complete scope revocation. Full Open still includes symlinks and conditional creation with process umask/default ACLs. Tests will be authored; execution and CI observation remain deferred.

The covered-directory selection defect is corrected and published: docs a62f871a, vfsd 1872afc5, integration 6c080259.

Native component dispatch compares configured raw basenames with actual held parent identities on their original provider/mount routes before forwarding a lookup. Equal names under different actual parents remain ordinary lookups; aliased parents identify the same edge, and conflicting configured aliases refuse. A matched edge refuses before selecting an underlying child while full scope-owned crossing is completed.

Deployment-counted mount records retain noncopyable namespace root and entering-parent owners. Mounted-root transport reserves its original mount/key and both correlations before submission, and remains distinct from conditional cloning. Parent walks retain at most two original component owners through advancement and cleanup. Successful pins last for the installed namespace mount; they are not client grants. Unknown replies and refused cleanup remain counted and drain from the serving loop independently of client liveness or new correlation allocation. A pending flag avoids idle cleanup scans.

Mount insertion now consumes an exclusive borrowed empty-record reservation. Another insertion cannot overwrite original native custody, and publishing a successful provider mount needs no further fallible storage step. Table reborrowing preserves initialized owners. The obsolete component-only backend retirement method is replaced by one original-acquisition method shared by the distinct private families.

Ten new controls are authored and unrun: three original transport controls and seven actual native-dispatch controls, covering aliases, ambiguous edges, different parents, malformed/lost replies, two-pin cleanup and correlation exhaustion. Rustfmt was applied to 22 Rust inputs using the crate's actual edition and repository settings; an existing include fragment keeps its surrounding format with only its noncopyable array initializer changed. Contracts, architecture/roadmaps and technical manual TeX are updated.

Three signed commits are pushed on feature/posix-compat, with remote head equality recorded. Integration adopts three catalog entries and retains independent Rust helper cafa58e132fe45defcea4df0e8d92cf65fdb209b. No Cargo source identities change. A read-only inventory covers 3509 code files in 76 repositories, all below 1000 lines; the largest changed source is 944 lines.

Full native Open/openat remains open. Scope-owned mount descent/ascent, initially mounted cwd and original subdirectory ceilings, symlink following and conditional creation with process umask remain implementation requirements. This correction adds no full Open acceptance credit. Recalculated progress is 16.91% weighted, 5.21% whole-item acceptance: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass, warning-free build or measured speedup is claimed.

Earlier evidence follows; the current correction above supersedes the earlier covered-directory behavior.

Continued mount-transition design: retain noncopyable mounted-root and entering-parent acquisition owners in the deployment-counted namespace mount records. All provider keys come from the existing monotonic VFS identity sequence and cleanup correlations are reserved before submission. Resolve configured parent edges from actual retained namespace roots, using counted temporary component owners and actual returned identities; retain those parents against object reuse. Client selection compares the actual held parent, original mount route and raw basename, never a pathname or handle number alone. Unknown binding replies retain cleanup owners and independent serving-loop cleanup must drain them even when the initiating client disappears. This closes covered-directory selection while scope-owned branches are wired for full descent/ascent; the full Open requirement remains unchanged.

Actual held-object identity is implemented and published as continued full Open/openat work: lib-ipc 69e15a49, ramfsd d490fac0, e2fsd c30ef621, vfsd 5fee4fdb, docs 32e94c9f, integration 41f65446.

Private component 0x6CA and conditional-anchor 0x6CC replies are exactly 72 bytes, carrying 32 stable identity bytes after their original 40-byte disposition. The earlier 40-byte responses reject. Success requires nonzero identity; refusals carry neither a handle nor identity. Mounted-root 0x6F9 keeps its existing 72-byte wire layout and distinct operation, sharing the complete anchor representation and eliminating duplicate identity framing/validation. All original requests and retirement framing remain unchanged. The coordinated immutable graph selects both producers and consumers.

Ramfsd constructs identity from the actual node during the serialized pinning turn. E2fsd uses the actual inode, generation and mount identity; conditional cloning reuses its already-refreshed permission metadata without another inode read. Both agree with independently held cwd/root aliases, retain original replay fences and preserve original-key cleanup. Identity bytes alone grant no authority.

VFS retains provider identity alongside the handle inside the original noncopyable acquisition state. Prepared, unknown and retiring owners expose no identity. Missing or malformed successful identity keeps the original cleanup obligation and never permits resubmission. Scope preparation installs actual cloned root/cwd identities and uses them in the published endpoint digest, replacing copied source endpoint digests as object identity.

Five new controls are authored and unrun: one literal codec, one Ramfsd alias/lifetime, one E2fsd alias/read-count and two VFS original-owner/derived-scope controls. Existing codec, provider dispatch and transport fixtures cover complete framing, short-output preflight, missing identity and lost replies. Rustfmt was applied to 34 changed inputs using actual Cargo editions and repository settings. Contracts, architecture/roadmaps and filesystem manual TeX are updated. No extra clone inode read is introduced; no speedup was measured.

Counted VFS mount branches, independently held entering directories and object-bound ascent/descent remain unfinished, along with symlink following and conditional creation with process umask. This identity layer does not complete native cross-mount Open or its workload. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed.

Earlier evidence follows; the held-identity implementation above is the current checkpoint.

Continued implementation design: carry stable held-object identity in existing private component and conditional-anchor acquisition replies. Both exact replies become 72 bytes, with 32 identity bytes after the existing 40-byte disposition. Successful pins require nonzero identity; refusals require zero identity and no handle. Mounted-root replies keep their current 72-byte wire layout and distinct operation, sharing the complete anchor representation without duplicate fields. Original request and retirement framing remains unchanged.

Providers compute identity in the same serialized pinning turn from the actual selected node/inode, using the existing cwd identity representation. Ext conditional cloning should reuse the generation from already-refreshed permission metadata rather than issue another inode read. VFS retains identity inside its original noncopyable acquisition owner and installs provider-confirmed root/cwd identities during scope preparation, replacing descriptive endpoint digests as object comparisons. Unknown or malformed identity responses keep original-key cleanup custody. No public handle, selector or endpoint is added. Mount transitions still require counted branch and entering-parent ownership; identity alone grants no authority. Publish all consumers together with the immutable dependency closure, author codec/provider/transport regressions, and retain the current execution waiver. Full Open and guest builds remain unfinished.

Mounted-root provider custody is implemented and published as continued full Open/openat work: lib-ipc 2b65a08b, ramfsd 76271d74, e2fsd 0fbb6964, docs ad7fb2e4, integration 76ace98c.

Private operation 0x6F9 accepts an exact 24-byte original mount/key request and returns an exact 72-byte root/held-identity response. It selects an already-retained private provider mount, adds no public selector or endpoint, and never reopens a source path. Root replies share internal anchor-envelope code while their public parsers strictly distinguish operation families. Refusals carry no handle or object identity; framing and output preflight preserve rejected destinations.

Ramfsd and E2fsd share mounted-root and conditional-clone keys under the original monotonic mount fence. Counted handle/identity capacity precedes publication; E2fsd reserves it before reading root metadata. Existing anchor retirement cleans by the original mount/key without a handle reply, fences absent keys and retains roots through dependent child cleanup. E2fsd retirement performs no media/key I/O. Mounted-root and cwd pins use the same held object identity. E2fsd selects the actual root inode without directory scans, name keys or writes, and dot lookup now reuses the already-read parent inode.

Ten new controls are authored and unrun: three literal codec, three Ramfsd state/dispatch and four E2fsd real-media/dispatch controls. They cover lost replies, shared replay fences, other mounts and successors, full-width identities, short output, exhausted identities, dependent cleanup and non-directory root media. An authored read-count control covers the removed duplicate dot read; no speedup was measured. Two older provider fixtures now allocate the current 48-byte conditional-clone request, and its short-request codec coverage includes the complete extent. Rustfmt was applied to 19 inputs using repository settings and Cargo editions. Contracts, evergreen navigation links, architecture/roadmaps and filesystem manual TeX are updated.

VFS still needs counted mount-branch ownership, independently held entering directories and object-bound edge selection for ascent/descent under the original ceiling. Those transitions, symlink following and conditional creation with process umask remain unfinished. This provider operation does not complete native cross-mount Open or its workload. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed.

Earlier evidence follows; the mounted-root provider layer above is the current checkpoint.

Mount-transition design: the private provider root-acquisition request will carry the already-selected mounted provider and a fresh mount-local anchor key before submission. The existing anchor retirement operation will own cleanup and fence replay, even when the root-handle reply is lost. Root replies carry held object identity; response capacity and provider row/identity reservation precede pin publication. Conditional anchor clones and mounted-root acquisition share one monotonic key namespace. No public pathname or provider selector is added.

The VFS transition will retain the actual entering directory independently, with counted branch ownership and original provider routes through descendant cleanup. Ascent must use that actual retained parent and stop at the original native ceiling. Mount edge selection must compare held objects; a pathname spelling or coincident numeric handle cannot reconstruct authority. Selected mount policy continues to intersect the original scope ceiling. The provider operation is only the next implementation layer; complete mount dispatch and full Open acceptance remain open.

The native candidate mount-policy defect is corrected and published: docs c6fe35cf, vfsd 4658bef7, integration ba59428d.

Candidate write evidence, final write admission, truncation and each positioned/append write intersect the original scope ceiling with the selected held object's mount policy before provider work. Bound-directory write-access evidence applies the same restriction. Empty writes still require native write authority. Local mount refusal preserves an admitted read alias and the original cleanup key; pending retirement still retains the actual provider pin.

Read-only candidate reads omit clock queries and access-time updates. VFS selects timestamps according to mount policy and operation intent, and provider adapters only forward that value. Writable nonempty read requests, nonempty writes and truncation retain trusted time. Empty requests omit it. Clock or provider failures after entering the original operation boundary retain cleanup-only custody without replay.

Four new focused regressions and an extended bound-directory control are authored and unrun. The fixture observes actual timestamped and ordinary provider wire calls, original bytes, denial without clock/provider effects and independently retained cleanup pins. Rustfmt was applied to 13 Rust inputs using repository settings. Component architecture/roadmaps, the custody contract and technical manual TeX are updated.

Three signed commits in Vfsd, Docs and Integration are pushed on feature/posix-compat, with remote head equality recorded. Integration adopts three catalog entries and retains independent Rust helper 0483017f598290a81af9f57dc3f937f390b1ec83. No Cargo source identities change. A read-only inventory covers 3499 code files in 76 repositories, all below 1000 lines; the largest changed source is 889 lines.

Full native Open/openat remains open. Cross-mount transitions, symlink following and conditional creation with process umask remain unfinished. This correction adds no full Open acceptance credit. Recalculated progress is 16.91% weighted, 5.21% whole-item acceptance: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass, warning-free build or measured speedup is claimed.

Earlier evidence follows; the current correction above supersedes the earlier mount-policy behavior.

Original-ceiling parent traversal is implemented for same-provider scopes and published as continued Open work: lib-ipc 9597b508, ramfsd 91992025, e2fsd ede2bbcb, vfsd 374065f3, posixd 1d53add3, integration 50666ac4, docs ea904a19.

VFS binds an independently cloned cwd to the original held root before submitting the cwd clone. The private anchor request is now exactly 48 bytes, with the full original ceiling handle at offset 40; zero requests an independent root and the earlier body extent rejects. Same-provider root and cwd keep distinct actual handles while candidates retain their original scope generation and common navigation ceiling. Ordinary same-inode aliases do not imply this relationship.

Ramfsd proves ancestry through actual node links. E2fsd shares checksummed dot-entry or inline-parent reading with rename admission. Constant-space cycle detection adds no fixed depth limit and neither cursor reads above the supplied ceiling. Fresh search evidence, ancestry, conditional lookup and pin publication stay in one provider turn. Moved-out parents and cycles refuse before creating a candidate. Dot-dot clamps at the original ceiling. Posixd applies complete fresh search checks to the directory being left and never lexically removes a parent component.

Bound cwd anchors and acquired candidates independently retain their original ceiling. Starting ceiling retirement disables bound-anchor use while original-key cleanup remains available. Root disposal waits for all dependent custody. Cross-mount ascent remains unfinished and refuses before provider submission; no pathname reopening or coincident handle number bridges routes.

Twelve new controls are authored and unrun: two codec, three Ramfsd, three E2fsd, two VFS and two sealed-service tests. Existing literal, original-route and transport fixtures are extended. The native binding workload now requires absolute and directory-fd root-parent clamping before its existing file acquisition checks. Rustfmt was applied to 39 inputs using repository settings; component contracts, architecture/roadmaps and technical manual TeX are updated. No execution pass is claimed.

Full realm Open/openat remains open in the same implementation pass. Cross-mount transitions, symlink following and conditional creation with process umask remain unfinished. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. No full-item acceptance is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No warning-free build or measured speedup is claimed.

Earlier evidence (historical; superseded where the current checkpoint above advances it):

The file-delivery cancellation defect is corrected and published: docs 8a2ea35b, posixd 17e151a3, integration 70d1079b.

After an original native Read/Write reply is completely validated, cancellation during ordinary or acknowledged draining caller release preserves the committed shared cursor and admitted candidate for surviving aliases. It abandons only the delivery and never replays the effect. An uncollected effect remains cleanup-only, and uncertain submission retains original custody under the existing service failure latch. Final Close still retires the one shared pin.

Four sealed-service regressions are authored and unrun: collected Read and Write each cover cancellation before and during draining release; negative controls cover uncollected cancellation and uncertain submission without ordinary-use recovery or discarded custody. Rustfmt was applied with the repository configuration. Component contracts, architecture/roadmap and the technical manual are updated. The implementation closes the defect under the current testing waiver; no test pass is claimed.

Three signed commits are pushed on feature/posix-compat in Posixd, Docs and Integration. Integration adopts three catalog entries and preserves the independent Rust helper e755cf71c9365577882183d16e7d7e4442fa49cd. No Cargo dependency changes are needed. A read-only inventory covers 3493 code files in 76 repositories, all below 1000 lines; the largest changed source is 475 lines.

Full native Open/openat remains unfinished for parent/symlink/mount traversal and conditional creation with process umask. The source audit confirms root/cwd are independent provider anchors; accepting parent components alone cannot implement ceiling-preserving traversal across them. This correction adds no full Open acceptance credit. Recalculated completion remains 16.91% weighted: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred.

Earlier evidence follows; the correction above supersedes the original cancellation behavior.

Retained Open and dynamic file serving are implemented for existing downward paths and published as unfinished acquisition work: lib-ipc caac62ca, lib-posixabi be194572, posixd 6674637c, loaderd 83651288, launchd 0315555d, procd 26dce660, integration e1dcb8ff, docs 7c7f7440.

The sealed native client selects its actual original root, cwd or live directory fd. Each component retains its own pre-submission cleanup key and uses fresh complete permission evidence, immutable effective credentials and fully folded ACL pages. Final admission and optional truncation use the original held candidate. The fd and description remain reserved until native COMPLETE succeeds; refused completion drains the candidate and reservation without replaying truncation. Positive COMPLETE is recorded before local publication so terminal handling cannot repeat it.

Dynamic aliases share one counted candidate and cursor. Exact native request/key/progress checks precede cursor changes. Read-only files reject empty writes, directory I/O reports EISDIR, and append delegates EOF selection to the provider's exclusive write turn. Empty writes preserve position. Last Close and dup2 replacement retain original candidate custody through provider and caller cleanup. Terminal handling retires all candidates before their acquisition scope and receiver.

Arena version four adds independent retained request bytes per client and counts complete Open/candidate owners in authenticated target geometry. Older layouts reject. Variable native payloads are framed in place; request, result and packet regions remain distinct. Compatibility 1.6 appends EISDIR, ENOTDIR, ELOOP and ENAMETOOLONG as values 21 through 24 without renumbering existing errors. Original ACL folding and packet framing are shared between consumers.

Nine sealed-service tests and two packet tests are authored and unrun, covering original bases, full ACL collection, UID-zero denials, shared cursors, independent append pins, empty writes, cleanup BUSY, cancellation, refused completion, terminal ordering and malformed pin echoes. Existing arena and compatibility/C fixtures are extended. The native binding workload additionally requires Open/openat, directory-base closure, shared-cursor aliases, EOF and write refusals. Rustfmt was applied; maintained contracts and technical manual TeX are updated.

Full realm open/openat remains open in the same implementation pass. Parent traversal, symlink following, mount transitions and conditional creation with process umask remain unfinished. The authored native workload includes the remaining mount-transition requirement and has not run. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. No full-item acceptance is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass, warning-free build or measured speedup is claimed.

Earlier evidence (historical; superseded where the current checkpoint above advances it):

Native final-candidate admission and file I/O are implemented and published: lib-ipc fec141eb, ramfsd 67bcad59, e2fsd a3b6777c, vfsd 944e4a06, integration 9f00c9f7, docs c9672b76.

The original acquired component grants no ordinary file I/O until the trusted mediator applies complete final permissions and native admission succeeds. VFS enforces the scope write ceiling, records the attempt before the provider gate and freezes read/write access once. Ramfsd compares the current permission revision; E2fsd consumes and refreshes the original complete fingerprint. Optional truncation affects that same retained object in the exclusive comparison turn, without pathname reopening or another handle.

Actual acquisition endpoints now serve reads and positioned or atomic append writes through the retained owner. Borrowed codecs preserve exact initialized bytes and full original correlation; actual transport capacity determines short progress. Both providers select append EOF and write in one exclusive turn, including across independent pins of the same file. Empty writes cannot extend a file or change timestamps. E2fsd reuses its encryption and journal write engine. Native time comes only from the existing trusted route.

A failed or uncertain provider result disables further ordinary use while preserving original-key cleanup and its separately reserved correlation. No confirmed progress is not a rollback assertion after reply loss. Native delivery holds the prepared result; refused COMPLETE cannot repeat provider writes. Whole-scope revocation drains the same original owners and preserves the already implemented delivery/receiver lifetime correction.

Eighteen controls are authored and unrun: four shared-wire, four Ramfsd, four E2fsd and six VFS. They cover framing, immutable access, stale final permissions, independent append pins, empty writes, reply capacity, lost/malformed replies, correlation exhaustion, original cleanup and native completion refusal. Rustfmt was applied to forty changed Rust files. Component contracts, README/ARCHITECTURE/ROADMAP and manual TeX are updated.

Full realm open/openat remains open. Posixd still needs retained path walking, parent/symlink/mount transitions, sealed credential mediation, conditional creation, final descriptor publication and ordinary fd serving through these native operations. Native open/openat workloads and both full EriX guest-build generations plus the Rust/LLVM guest rebuild remain unfinished. This checkpoint adds no full-item acceptance: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or measured speedup is claimed.

Earlier evidence (historical; superseded where the current checkpoint above advances it):

The scope Close lifetime defect is corrected and closed: vfsd e10522c0, launchd 2690e09e, integration 4f2aff8e, docs d963ebc5.

VFS retains the original private cleanup key after provider Close and descriptive metadata removal. The counted owner prevents row reuse through delayed delivery retirement and failed receiver disposal. Ordinary owned Close attempts its original completion at most once and keeps the key until native custody and receiver disposal settle. Legacy Close preserves its reply and disposal boundary as well.

Private revocation can supersede a pending Close reply. It suppresses that reply, invalidates the receiver and returns fully correlated BUSY while original delivery remains counted; subsequent exact turns relinquish that original owner. Launchd retains its cleanup obligation and retries on later scheduler turns. BUSY no longer poisons retirement, while wrong keys, generations, request correlations and contradictory result layers remain errors. No provider effect or native completion is replayed.

Five VFS and three Launchd regression controls are authored and unrun. They cover delayed native drain, positive completion followed by failed receiver disposal, private revocation during Close or an ordinary pending reply, stale cleanup after row reuse, and complete pending-result correlation. Existing native controls share the same independent fixture. Rustfmt was applied; component contracts and maintained manual TeX are updated.

Full realm open/openat, complete path/permission mediation, parent/symlink/mount transitions, conditional creation/append, descriptor publication/serving and native workloads remain unfinished. Both EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. No runtime checklist acceptance is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass is claimed.

Earlier evidence (historical; superseded where the current checkpoint above advances it):

Native scoped component dispatch is implemented and published: lib-ipc c0d3bec1, vfsd 764a6a76, integration 590c5e77, docs df1fb3c2.

Actual acquisition endpoints now select original root, cwd or counted candidates for permission evidence, complete ACL pages, conditional no-follow pinning and original-key retirement. Root and cwd descendants retain distinct original provider branches; no request supplies provider handles, mounts or replacement routes. The consumer retains its candidate key before submission. VFS counts the original owner and reserves both provider correlations before effects, fences replay across the complete nonzero key domain and preserves unknown outcomes for cleanup.

Native write ceilings precede permission observation. Every ACL page retains full target/object/revision/ordinal correlation and forwards its entries in place. Cleanup uses the original pre-reserved correlation without needing a returned handle. Private whole-scope revocation disables new use and attempts every child before disposing either anchor, so consumer loss cannot strand independently owned candidates. Public Close refuses live children; native delivery and receiver custody still settle independently.

Five shared-wire and seven actual VFS dispatch/state controls are authored and unrun. They cover literal framing, raw names, scope/branch isolation, lost replies, uncertain cleanup, exhaustion, ACL pages and whole-scope revocation. Existing custody regressions remain; fixture-only acquisition helpers are removed from production builds. Refused owner insertion leaves incoming custody with its original caller. Native adapter code is split by responsibility. Rustfmt was applied and component contracts/manual TeX are updated.

A further source audit identified premature scope-cleanup acknowledgment during native Close. The original delivery remains counted, but its scope cleanup key is cleared before receiver disposal finishes. This non-security lifecycle report is open for implementation; no observed runtime failure or access bypass is claimed. Fixing that ordering is the next priority.

Full realm open/openat remains open. Posixd still needs complete retained path walking, parent/symlink/mount transitions, sealed credential mediation, conditional creation/append, final descriptor publication and ordinary fd serving. Native open/openat workloads and both full EriX guest-build generations plus the Rust/LLVM guest rebuild remain unfinished. This checkpoint adds no full-item acceptance: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or measured speedup is claimed.

Earlier evidence (historical; superseded where the current checkpoint above advances it):

Native acquisition-scope preparation is implemented and published: lib-ipc ab4e18f6, vfsd acc9a53a, launchd 53ff53ca, posixd 45976b69, exsh 5308ec15, integration 42f7d97b, docs fe1cd7d7.

A distinct counted authority role connects public Launchd preparation, strict native scope transfer, VFS independent root/cwd ownership and sealed-client authority retirement. Root/cwd come from one actual held directory or live acquisition scope; preparation reopens no pathname and cannot widen its write ceiling. Every observation, acquisition and cleanup correlation is reserved before provider effects. Original source row, full generation, session and realm remain retained across lost replies, partial COPY and receiver disposal. Retirement disables new use before live children can delay disposal, while original child cleanup remains available. The generic broker mask and existing metadata/resize operations remain unchanged.

The native binding workload now prepares one read-only acquisition scope per client, with twenty authority rows and a 1684-byte plan per realm. Original provider and capability storage are explicitly budgeted. Twenty new controls are authored and unrun: four shared-wire, eleven VFS ownership/intake and five Launchd source/public-lifecycle cases. Existing Posixd authority, Exsh transcript and Integration geometry controls are extended. Provider correlation/cleanup and descriptor-aware source fixtures are resolved by implementation; no executed test failure or pass is claimed.

Full realm open/openat remains unfinished: native component dispatch, per-component/final permission mediation, raw path traversal, creation/append and Posixd descriptor serving still require implementation. Completion remains 16.91% weighted, 21/460 parents and 441/902 sub-items; this prerequisite adds no full-item acceptance. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred by instruction. Both full EriX guest-build generations and the Rust/LLVM guest rebuild remain unfinished.

Earlier evidence (historical; superseded where the current checkpoint above advances it):

Independent acquisition-root checkpoint: lib-ipc 4fefcc1f, ramfsd d9880325, e2fsd d2943a01, vfsd 8c8b98d5, docs 55c7e640, integration a9c3b6b1, rootd 72a63e1e.

Private anchor cloning now reserves a mount-scoped original identity before submission and pins the actual held source directory without reopening a pathname. Ramfsd checks the source revision in one exclusive turn; E2fsd reserves counted handle capacity before media I/O, consumes original permission evidence and refreshes the complete live inode/ACL fingerprint. The resulting root has an independent lifetime, so source closure and a lost handle reply cannot erase its preknown cleanup identity. Mount fences prevent delayed replay, including after retirement of a key whose response was lost.

Starting anchor retirement disables ordinary root use and new component acquisition. Existing child cleanup remains available; live children return BUSY before root disposal, and final original mount/key cleanup confirms absence idempotently without media or key I/O. VFS shares its noncopyable original-route owner and state machine across component and anchor calls while preserving separate operation families and root/component versus mount/anchor identity. Both call and cleanup correlations are reserved before submission; every original echo is checked, and uncertainty retains custody.

Eighteen new controls are authored and unrun: four exact wire codecs, five Ramfsd state/dispatch cases, five ext media/dispatch cases and four VFS retained-owner cases. They cover source-independent lifetime, lost replies, cross-mount and cross-family refusal, stale evidence, replay/full-domain exhaustion, retiring-root denial and short outputs. Rustfmt was applied. Component contracts and maintained manual/API-reference source are updated. Published 56 signed commits across 55 repositories, selecting 206 Cargo and 111 catalog revisions. Rootd and both helper catalogs select the independent Rust helper 35f0b37ea8bb55f26fd52e0ae4fdee1449add810. Read-only inventory covers 3432 code files in 76 repositories, all below one thousand lines; the largest changed source is 932 lines.

Full native realm open/openat remains open. Explicit native acquisition grant admission, counted source publication, VFS request dispatch, per-component/final permission mediation, creation/append effects, Posixd descriptor serving and complete native workloads remain unfinished. Original correlation/cleanup follow-up stays open until that native preparation path uses the retained owner. Existing metadata/resize grants gain no new operation authority. No new acceptance credit is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Both EriX guest-build generations and the external Rust/LLVM guest rebuild remain unfinished.

Original VFS acquisition custody checkpoint: vfsd 3ac14044, docs ac19ea76, integration a31127bb.

The internal acquisition owner now retains its original provider route and reserves separate call and cleanup correlations before submission. Counted noncopyable candidates bind the original VFS root row/generation, mount and provider root. All allocation families preserve their custody independently of metadata copies and native delivery clearing. Same-root directory selection, independent descendant pins and stale-selector refusal keep candidates tied to their originals. Public Close, direct record removal and private Launchd retirement refuse before provider or receiver disposal while a candidate retains the root.

Unknown or malformed responses preserve the cleanup obligation. Retirement disables ordinary use immediately and uses its original root/key and pre-reserved correlation, without another allocation or the lost handle reply. The complete nonzero provider u32 domain is issued once. Checked pre-effect acquisition reservation is separate from the legacy terminal fallback, which remains necessary when earlier effects may have occurred without independent cleanup custody. Correlation-exhaustion follow-up remains open until native acquisition grant integration and root preparation cleanup are connected.

Fourteen new transport, counted-table and actual root-close controls are authored and unrun; two counter controls are migrated. Rustfmt was applied. Component contracts and maintained manual TeX are updated. Three signed commits and three catalog selectors are published; Cargo pins and the independent Rust helper 6315e904c9d8769829928bb35108090f38c6a059 remain unchanged. Read-only inventory covers 3420 code files across 76 repositories, all below one thousand lines; the largest changed source is 959 lines.

This is internal ownership infrastructure. Complete realm open/openat remains open: explicit native acquisition grants, per-component and final permission mediation, VFS dispatch, creation/append effects, Posixd descriptor publication/serving and complete native workloads are unfinished. Metadata and resize endpoints acquire no new operation authority. No new acceptance credit is added; weighted completion remains 16.91%, with 21/460 parents and 441/902 sub-items accepted. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Both EriX guest-build generations and the external Rust/LLVM guest rebuild are unfinished.

Ext provider acquisition checkpoint: e2fsd 7daf33ca, docs f77a2a5c, integration a975a3e9.

E2fsd now implements the private original-root acquisition and retirement family. It reserves counted handle capacity before media lookup, consumes the exact parent permission observation and checks its epoch and full live permission/ACL fingerprint before no-follow child publication. Conditional truncation shares that gate; cwd and acquisition share inode selection while preserving distinct name/result domains. Raw ext names retain actual format and configured casefold/encryption rules. Pre-submission cleanup identities, monotonic replay fences and independent descendant lifetime make cleanup possible without the original handle reply and prevent early root closure.

Six new controls use original ext inode/directory bytes and actual dispatch, covering raw names, symlinks, independent descendants, wrong-root cleanup, alias refusal, stale revisions/epochs/fingerprints, exhaustion, short output, lost replies and consumed evidence after a missing child. Existing handle fixtures are migrated. All are authored and unrun. Rustfmt was applied; component contracts and maintained manual TeX are updated. Three signed commits and three catalog selectors are published, while the independent Rust helper remains 6315e904c9d8769829928bb35108090f38c6a059. Read-only inventory covers 3416 code files across 76 repositories, all below one thousand lines; the largest changed source is 922 lines.

Complete realm open/openat remains open. Native source preparation, VFS candidate ownership, Posixd serving, creation/append effects and native workloads remain unfinished. No acceptance credit is added; weighted completion remains 16.91%, with 21/460 parents and 441/902 sub-items accepted. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Both EriX guest-build generations and the external Rust/LLVM guest rebuild are unfinished.

Conditional provider acquisition checkpoint: lib-ipc bb5df3d2, lib-posixabi cdc6eb9e, ramfsd ba8ea6da, docs d470ea50, integration b9acf76b, rootd 27835abd.

Compatibility 1.5 now describes Open/openat with raw borrowed pathname bytes and checked independent base, access, lookup, shared-status, inheritance and creation-mode domains. Private provider acquisition/retirement framing retains an original root and acquisition identity before submission. Ramfsd compares actual parent permission evidence and pins no-follow files, directories or symlinks in one exclusive turn. Cleanup does not require the original handle reply; retirement fences delayed replay without tombstone storage. Intermediate directory closure preserves independent children, and the original root cannot close while its pins remain.

Eighteen new controls are authored and unrun: five compatibility codecs, five private-provider codecs and eight actual Ramfsd state/dispatch cases. Ramfsd's live-handle helper types and stale compatibility-minor fixture expectations are corrected from source observations. No compiler or test failure is claimed. Component contracts and maintained manual/API-reference source are updated, and Rustfmt was applied.

Full native open/openat remains open: native source preparation, VFS candidate ownership, other providers, Posixd serving, creation/append effects and native workloads are unfinished. No acquisition acceptance credit is added. Weighted completion remains 16.91%, with 21/460 parents and 441/902 sub-items complete. Both EriX guest-build generations and the external Rust/LLVM guest rebuild remain unfinished.

Dynamic acquisition reservation checkpoint — 29 September 2026: posixd 947d9852, docs e9cd7b00, integration 730f6f1a.

Local fd and shared-description capacity is now reserved together before external acquisition. Pending numbers cannot perform I/O, and the empty source row retains its reserving process. Publication/cancellation correlates both complete generations; peer index changes and stale tokens cannot select a successor. Configured initial source installation uses the same implementation. The cross-client terminal compaction defect is fixed by interpreting descriptions only for the terminal client, preserving another client's pending new duplicate and original source hold.

Five new reservation controls and one cross-client regression control are authored and unrun. Component architecture/roadmaps, the descriptor contract and maintained manual TeX are updated. Three signed commits and three catalog selectors are published; the independent Rust-helper identity is unchanged. Rustfmt was applied. Tests, builds, lint checks, manual/Rustdoc generation, VM/profiler execution and CI observation remain deferred by user instruction.

The complete open/openat acquisition issue remains open. Native source preparation, conditional provider traversal/effects, actual sealed-client dispatch and the complete native workload are still implementation work. This checkpoint adds no checklist completion credit: weighted progress remains 16.91%, with 21/460 parent items and 441/902 sub-items accepted. No execution pass or dynamic open success is claimed.

Predecessor: #15. Related filesystem mediation: #10. Owning review: #5. Native wire: erix/lib-ipc#2. Compatibility wire: erix/lib-posixabi#3. Phase tracking: erix/integration#65.

## Problem and motivation Mutable descriptor ownership is implemented, but the realm still cannot acquire a new file through open/openat. Current fixed metadata, resize and inherited-stream grants do not authorize arbitrary file acquisition. Build tools need files and directories opened relative to explicit realm roots or live directory descriptors, with original lifetime and permission evidence preserved throughout lookup, creation and close. ## Proposed behavior and scope Implement dynamic open/openat as a complete native producer/provider/consumer path. Reserve process-local fd and shared-description capacity before any acquisition or namespace effect. Add exact compatibility framing and checked access, creation, truncation, append, directory, no-follow and inheritance modes. Resolve current/root and live-directory-fd bases only from authenticated realm state; path bytes, mode bits and numeric selectors supply no native authority. Introduce an explicit native acquisition grant and coordinated preparation. Do not widen existing READ_METADATA or RESIZE_FILE operations. Walk from original retained directory objects, checking search permission for every traversed directory and final access or parent creation permission using complete native metadata/ACL evidence. Permission comparison and the dependent lookup/create/truncate operation must concern the same original objects and revisions. Native ceilings and read-only mounts remain authoritative. Keep provider-owned staged objects inaccessible as application fds until admission and custody are complete. Preserve original prospective/actual provider, receiver, local alias and caller owners through every result, cancellation and partial failure. Any descriptive child handle is usable only through its original held native route and checked owner/generation. Publish one lowest-free fd only after successful acquisition; share the original cursor/status through dup, close the last source exactly once, and retire uninstalled acquisitions before receiver disposal. Directory fds retain their original authority and support later relative opens. Implement creation ownership/mode under actual effective credentials and umask, exclusive create, required append/truncation semantics and coherent error behavior without silent fallback. ## Authority, security and reliability No ambient filesystem session, process authority, path reopening of a supposedly retained object, foreign descriptor table or metadata-only permission bypass is acceptable. Stage output/result and counted storage before effects. Do not replay uncertain opens or namespace mutations. Distinguish definite refusal, stale evidence, partial effects and unknown cleanup; uncertain native state retains original custody and fails stopped. Cancellation, process/realm death, malformed receipts, refused completion, fd exhaustion and generation exhaustion preserve the same obligations. No arbitrary static path/depth/table budget may replace explicitly counted resources and actual provider limits. ## Acceptance criteria <details> <summary>Checklist</summary> - [x] Define documented exact compatibility/native acquisition framing, checked modes, original authority boundaries and counted runtime/prospective storage; author literal, malformed, overflow and atomic-refusal controls. - [x] Implement reserved fd/shared-description admission before native effects, exact publication/rollback ordering, generation correlation and terminal ownership of in-flight acquisitions. - [x] Connect explicit native preparation and provider-relative traversal, trusted permission/ACL evidence and conditional lookup/create/truncate effects with exact original object lifetime and complete failure cleanup. - [x] Connect actual sealed-client open/openat dispatch, directory-relative bases, file/directory descriptions, shared byte/append behavior and final-close/terminal cleanup; do not accept metadata-only substitutes. - [x] Author host and native workload controls for reads/writes after opening, exclusive create, modes/umask, truncation, append, directory fds, denial, traversal/symlink boundaries, races, cancellation, exhaustion and refused completion. Preserve existing scenarios. Execution is waived by user. - [x] Update component contracts and maintained manual/API descriptions, remove superseded code, publish a coherent signed immutable dependency graph and synchronize owning reviews and phase tracking. Keep complete EriX/toolchain guest rebuilds unfinished until demonstrated. </details> ## Alternatives and tradeoffs A pathname-only wrapper around existing privileged namespace operations would skip both native admission and per-component permission checks. Adding another pre-bound file operation would still leave build tools unable to acquire files. Reopening retained paths after a permission check would introduce object substitution. Acquisition must instead retain its original source and staging ownership until a descriptor is published or all cleanup is positively known. Behavioral reference: the Open Group [open/openat contract](https://pubs.opengroup.org/onlinepubs/9799919799/functions/open.html). EriX code and fixtures remain original; compatibility values are assigned explicitly rather than imported from another runtime. ## Tracking and rollout Complete native Open/openat implementation is signed and published: [lib-ipc `6b96c569`](https://git.erikinkinen.fi/erix/lib-ipc/commit/6b96c5698a736000e314a4c3abbcfa76132c492c), [e2fsd `aedb65bb`](https://git.erikinkinen.fi/erix/e2fsd/commit/aedb65bb5d41613adb00625124422af490dec6d0), [ramfsd `dc1de465`](https://git.erikinkinen.fi/erix/ramfsd/commit/dc1de465be087e6c8f22523c665d2aad1464644f), [fatd `0e209121`](https://git.erikinkinen.fi/erix/fatd/commit/0e209121d7b1e802809e99910c14cf5c4acf42ed), [vfsd `a368b741`](https://git.erikinkinen.fi/erix/vfsd/commit/a368b741c87c0b5f0cf947dc4e03f8a0d036d11e), [posixd `85efb7f9`](https://git.erikinkinen.fi/erix/posixd/commit/85efb7f985c04a737b147689bd7a6126b94a1817), [exsh `3ee15a96`](https://git.erikinkinen.fi/erix/exsh/commit/3ee15a96f2b4def52860fcd423615f3d3367f667), [docs `c8565b7b`](https://git.erikinkinen.fi/erix/docs/commit/c8565b7b3a5c77f1e3d5a9e3b3a06994bfde505b), [integration `9fb56e3d`](https://git.erikinkinen.fi/erix/integration/commit/9fb56e3d618588969bdc9a01b507ab094f92a4e1). [Dynamic acquisition](https://git.erikinkinen.fi/erix/posixd/issues/17) is accepted under the testing waiver, completing the Open/Close/duplication checklist item. Other filesystem mediation, libc/process integration and self-hosting remain unfinished. Conditional creation uses distinct exact native/private families under the existing acquisition scope and original provider root. Posixd captures the authenticated current process mask and derives owner/group policy from fresh complete parent write/search evidence only after final-name absence. Parent setgid and selected-group membership constrain group/special bits; UID zero adds no privilege. VFS requires a writable scope and actual mount even for a Read descriptor and retains original candidate/provider/result cleanup before effects. Ext captures committed inode identity inside the full regular-file transaction, including complete default ACL inheritance and independent child storage; RAM reserves node/handle capacity under proven ACL absence. FAT/exFAT explicitly refuses unknown POSIX metadata. Created access is frozen independently of the resulting mode, so mode-000 creating descriptors remain usable. Only original successful COMPLETE publishes the fd. A definite nonexclusive conflict retires the failed key before fresh search; stale evidence, malformed results and uncertain effects never replay creation. Cancellation and failed publication retire pins/callers without unlinking committed names. Shared parent/fence helpers and result framing remove duplication; ext publication adds no later fallible media read. No measured speedup is claimed. Nineteen new unit controls are authored and unrun: four wire, two ext-media, two RAM, one FAT, three VFS and seven sealed-client controls. They cover full IDs/framing, policy and capacity refusals, mode-zero access, current masks, inherited groups, complete multipage ACLs, dangling links and directory suffixes, conflict/stale evidence, lost/malformed replies and refused publication. The native binding workload now checks mode-zero writes, exclusive conflicts, later DAC refusal, post-close persistent bytes, append at real EOF, conditional Open truncation, changed current-mask removal of owner-read permission and restoration, and denied creation by its Read-only peer. It reuses the existing correlated mask-exchange helper. Only its first explicit peer receives inherited acquisition access; realm/generation-separated names prevent fixture collisions. Existing literal producer controls and scenario exit/deadline requirements are preserved. Current phase progress: 17.04% weighted, 5.61% whole-item acceptance; 22/460 parents and 442/902 sub-items. Both full EriX guest-build generations and rebuilding external Rust/LLVM inside EriX remain required and unperformed. Test-only execution is waived, never reported as a pass. <details> <summary>Detailed scope and contracts</summary> ### Conditional native regular-file creation and full Open integration Add distinct native and private conditional creation operations, under the existing original acquisition scope and provider root. The native request carries a pre-submission candidate key, actual root/cwd/held-parent target, fresh parent permission revision, raw final name, requested access and explicit creation mode/UID/GID/mask. The private request substitutes only original provider handles and includes optional VFS-selected trusted time. Exact framing, checked modes/masks, known access, nonzero identities and complete final-component syntax precede every effect. Dot/dot-dot are not creation names. Creation responses remain disjoint from ordinary pin/admission responses and expose no private provider handle to compatibility callers. Search and existing-object access remain separate from creation admission. Open first searches normally. Only a known missing final component with CREATE, without required-directory semantics, enters fresh parent write/search evidence and complete ACL mediation. Capture the authenticated process's current mask with its original accepted call, not from its immutable initial configuration. Select the authenticated effective UID; inherit the freshly observed parent group when its set-group-ID policy requires it, otherwise select the effective GID. Requested set-group-ID is cleared when the authenticated process lacks that group membership; no UID-zero or implicit native privilege bypass. The complete parent revision binds this selection before provider effects. Reserve every fd, candidate row, original acquisition key, provider handle and result/cleanup correlation before persistent effects. VFS intersects the original scope write ceiling and actual mount policy even for a requested read-only descriptor. Creation uses the actual selected parent branch and never follows a replacement mount/path. Providers compare original permission evidence and ancestry before a typed absence check and their exclusive create transaction. E2fsd uses its complete independent default-inheritance core; Ramfsd supplies real explicit metadata and proven ACL absence. FAT's unknown POSIX permission evidence remains a refusal, not invented metadata. A successful creation also admits the requested candidate access. Its mode may be000: do not reapply existing-file access checks to invalidate an already authorized creation. VFS freezes access under the same original acquisition owner, and Posixd publishes the reserved descriptor only after positive original COMPLETE. Lost/malformed replies retain original-key cleanup custody. Cleanup retires pins and callers, not the newly created directory entry; it must never undo a committed creation or replay it. Uncertain ext mutation completion keeps provider fail-stop semantics. Failed final publication leaves no usable descriptor while the committed namespace effect remains. Retire the unsuccessful search candidate before a new creation key is reserved. An exclusive conflict returns EEXIST. A nonexclusive, definitely no-effect conflict retires that failed creation candidate and resumes fresh search under a new key, permitting the concurrent existing object to receive ordinary final access/truncation checks. Stale or ambiguous effects are not retried. Preserve existing symlink, mount, root/cwd, expansion, cancellation, result and descriptor cleanup semantics, including CREATE through a dangling link and exclusive final-link refusal. Author exact wire/correlation controls; provider stale/wrong-root/no-space/conflict/metadata/default/cleanup controls; VFS original-route/mount/capacity/uncertain-custody controls; and actual Posixd/native positive, malformed, permission, race, umask, set-group-ID, mode000 and failed-completion coverage. Update contracts and technical manual, coordinate immutable source pins bottom-up, and maintain owning PRs and phase tracking. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Full Open acceptance and both EriX guest generations plus external Rust/LLVM rebuilding remain the unchanged objective. Regular-file default ACL inheritance and explicit creation metadata are implemented and published: [e2fsd `ac8aa517`](https://git.erikinkinen.fi/erix/e2fsd/commit/ac8aa517c5c900a8d0f8a51763af02e3e9e93636), [docs `50185374`](https://git.erikinkinen.fi/erix/docs/commit/501853745487b0592b675a175cc6ea78eeb06ca5), [integration `2ef59f4a`](https://git.erikinkinen.fi/erix/integration/commit/2ef59f4a7105b2a99fb4c195579775e108c0c0fd), [rootd `d6055e7f`](https://git.erikinkinen.fi/erix/rootd/commit/d6055e7fe0004a207477bc232e09feca378eca5d). The [full conditional Open/openat work](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. The original ext regular-file transaction now requires explicit requested mode, full owner/group IDs, mask and times. Existing administrative path, exact and touch callers explicitly retain0644/UID0/GID0/mask0. Complete access/default decoding shares structural and streamed integrity checks while keeping their mode rules distinct. Valid empty defaults mean absence; malformed or duplicate defaults refuse before allocation. Present defaults attenuate only owner/group-class/other permissions by requested mode without reapplying the mask. Named entries remain exact. Without defaults, the explicit mask restricts requested mode. Every child receives independent inode-body, external or streamed immutable ACL storage. Parent descriptors, shared tables and value references are preserved. Child ownership/mode/ACL, inline file data, full allocation charges, namespace insertion, selected times and quotas retain the original transaction. Rollback, complete source-digest binding and uncertain-write fail-stop remain. No native route, grant, ambient process metadata or effect replay is introduced. Local payload retention and allocator/journal fixtures are shared; the common builder performs the complete digest check without duplicate hashing in its callers. No measured speedup is claimed. Fourteen new controls are authored and unrun: eleven actual-media controls, one orchestration control and two host-oracle controls. Coverage includes empty/malformed/duplicate defaults, high identities, shared tables, inline files, all administrative creation paths, over64KiB/9004-entry values, source/charge preservation, independent deletion, quota rollback, uncertain writes and changed source bytes. The existing native ACL scenario now has39 requests with local/streamed child creation, original-handle closure and deletion; post-VM decoding checks complete defaults/access ACLs and independent lifetimes. Existing scripted workload coverage is extended too. Conditional compatibility creation still needs authenticated current process policy, fresh held-parent write/search and revision comparison, original acquisition/result/cleanup ownership and descriptor installation. Directory creation inheritance remains separate work. This provider implementation does not close full Open or add full-item acceptance credit: 16.91% weighted and 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred by user instruction. No executed pass or warning-free build is claimed. Earlier evidence follows; the implementation scope above is current. ### Ext default inheritance and explicit creation metadata Refine conditional creation around the provider's original exclusive mutation. Compatibility admission must authenticate current process policy and acquire fresh parent write/search evidence under the original native scope. The provider compares the original parent revision, then validates and uses the actual parent default ACL in the same serialized creation transaction. A separate transported default-ACL snapshot is unnecessary when the provider performs the complete inheritance itself; access-evidence freshness and native scope ceilings still precede creation. Unknown or malformed defaults refuse rather than becoming empty policy. Share complete access/default ACL decoding, distinguishing their namespaces and mode rules. Access ACLs must agree with current owner permission bits; defaults describe future children and need not match the parent's access mode. Preserve complete structural validation, both attribute stores, value integrity, full-width qualifiers and bounded streaming without an entry-count ceiling. A fully validated empty default denotes absence. Inherit defaults as child access ACLs, attenuating mode-corresponding classes by requested permissions while leaving named entries unchanged. Apply the creation mask only when no default is present. The shared regular-file core will take explicit requested mode, UID, GID, mask and time fields. Existing native administrative callers explicitly retain their established regular mode0644, UID/GID0 and mask0 policy while gaining default inheritance; these values must never be inferred for compatibility processes. Future conditional callers must provide the authenticated process policy and resolved ownership under the freshly checked parent. Preserve all permission/special bits admitted by the explicit policy; IDs describe metadata and grant no native authority. Validate defaults before allocation. Copy inherited bytes into child-owned inline or external storage, or stream a new immutable value inode when required. Never rewrite or retire the parent's descriptor, shared table or value reference. Account the child's full attribute charges, preserve inline file data, and commit child mode/ownership/ACL, namespace insertion, timestamps and quotas together. Original transaction rollback and uncertain-effect fail-stop remain. No added block/key/clock capability, fallback route or mutation replay is permitted. Derive behavior from [ACL semantics](https://man7.org/linux/man-pages/man5/acl.5.html) and the [ext attribute format](https://docs.kernel.org/filesystems/ext4/attributes.html); author implementation and fixtures independently. Add complete-media inheritance, absence/mask, malformed/duplicate storage, shared parent, large value, ownership, rollback and cleanup controls. Tests/builds/lint/docs generation/VM/profiler execution and CI observation remain deferred. Full conditional acquisition, authenticated caller wiring, complete Open and required EriX/external-toolchain guest rebuilding remain in scope. The [ext destination-lookup defect](https://git.erikinkinen.fi/erix/e2fsd/issues/13) is implemented and published: [e2fsd `bddfed39`](https://git.erikinkinen.fi/erix/e2fsd/commit/bddfed39353239417f0543852d46fbe859c2963b), [docs `ea2f3f25`](https://git.erikinkinen.fi/erix/docs/commit/ea2f3f2591e87e867692c180b38c364a1116e24d), [integration `8fa3c0b8`](https://git.erikinkinen.fi/erix/integration/commit/8fa3c0b8f987b1407ceb8b5ca248075b0e519dd7). It is closed under the testing waiver. The [full conditional Open/openat work](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Completed child absence now has a distinct internal result. Block/key/format failures, including dependency NOT_FOUND, propagate through regular-file creation, mkdir, links, rename destinations, exact-entry resolution/revalidation and indexed journal recovery. Provider rename preflight retains the distinction across the full pathname and preserves its existing held-destination exclusion on both wire versions. Short unparsed directory suffixes refuse as malformed media. Original mounts, block/key routes, parent identities and native operation ceilings remain unchanged. Path, exact and touch regular-file creation share one transaction core. Preflight precedes allocation; inode and optional inline payload initialization, checksums, entry insertion, timestamps, quotas and result metadata remain under the original transaction owner. Explicit touch fields override automatic times. Unselected touch fields no longer cause a redundant touch read/write. Journal rollback and uncertain-effect fail-stop behavior remain; no measured performance result is claimed. Ten regression controls are authored and unrun: linear/indexed namespace failures including missing-device codes, malformed records/suffixes, exact absence resolution/revalidation, successful mutations, intervening conflicts, persisted modes/inline data/timestamps, held-destination provider preflight and indexed recovery with unchanged home media. Rustfmt was applied to19 changed Rust inputs. The source inventory covers 3573 code files across 76 repositories, all below1000 lines; largest changed source 988 lines. Contracts, component documentation and maintained filesystem manual TeX are updated. Three signed commits are published with three catalog selections; the independent Rootd helper remains `17acba24ba2136d453fa84326574b7470b161741`. This completes the reported mutation defect and consolidation. Full conditional compatibility creation still needs authenticated requested mode/effective IDs/current mask, original held-parent evidence, default ACL inheritance and original acquisition/result/cleanup custody. No full Open acceptance credit is added: 16.91% weighted and 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest generations and rebuilding the external Rust/LLVM toolchain inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No executed pass, warning-free build or benchmark result is claimed. Earlier source evidence follows; the correction above is current. Authenticated process creation-mask configuration and exchange are implemented and published within [full Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17): [lib-ipc `ec802763`](https://git.erikinkinen.fi/erix/lib-ipc/commit/ec8027630ac2433851a02a681f3921eb235f3877), [lib-posixabi `c81f92e5`](https://git.erikinkinen.fi/erix/lib-posixabi/commit/c81f92e537066f9596d53d42a9a9d214c2be11a3), [launchd `1e3ebccd`](https://git.erikinkinen.fi/erix/launchd/commit/1e3ebccd1fe2e005c2c6d3af4419886d38237d91), [posixd `6ca3e122`](https://git.erikinkinen.fi/erix/posixd/commit/6ca3e122835c83c74ee153785d67c97cea32d353), [exsh `06056100`](https://git.erikinkinen.fi/erix/exsh/commit/060561008337aa4d95761ef2747b184fe9a9d72e), [docs `468095f5`](https://git.erikinkinen.fi/erix/docs/commit/468095f5465b07eab28915822805b1d5730db383), [integration `d8413bf1`](https://git.erikinkinen.fi/erix/integration/commit/d8413bf1bb92414b6b84ffec9e3839695b1439dc). Full conditional creation remains open; the complete ownership and inheritance design is recorded before ABI implementation. Canonical configuration/pulls require minor four. Each original client explicitly carries a checked nine-bit initial mask in its unchanged 72-byte record. Owner appends have a distinct 60-byte client record; old frames are rejected. No host, environment, UID-zero exception or omitted-field default supplies policy. Launchd preserves the mask through reversible sorting by using only the remaining reserved u32 for temporary ordinals. Posixd reserves policy with the original counted receiver and verifies it against the frozen digest-covered plan before serving. Compatibility 1.7 adds Umask operation11. Actual sealed CLAIM admission selects the exact native process generation. A complete previous-mask reply is prepared before one process-local exchange; only low permission bits of the argument are retained. Failed or ambiguous COMPLETE preserves the result and effect under its original serving owner without replay or rollback. Terminal retirement disables selection. No descriptor, filesystem handle, provider call, native endpoint or capability grant is added. The live credential view reports current policy rather than the initial frozen value. Twelve new unit controls are authored and unrun, alongside migrated independent wire/C constants, original producer fixtures and existing sorting/credential controls. The native two-client workload configures masks027 and077, changes them independently before reciprocal channel traffic, then checks and restores them after peer participation. The [LibIPC fixture defect](https://git.erikinkinen.fi/erix/lib-ipc/issues/4) and [Launchd fixture defect](https://git.erikinkinen.fi/erix/launchd/issues/14) are corrected and closed under the testing waiver. Reproductions remain explicitly source-derived: missing count, obsolete frame/storage sizes and addressability assumptions were corrected, and the canonical digest fixture was authored independently without executing EriX code. Conditional creation must still consume current process policy, fresh held-parent evidence and complete default ACLs under original acquisition custody. Persistent inheritance, complete provider policy, libc/shell process integration and fork/exec inheritance remain unfinished. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest build generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No executed pass, warning-free build or measured performance result is claimed. Earlier evidence follows; the process-mask implementation above is current. ### Conditional creation and process mask design Continue full Open/openat acceptance with atomic final-component creation under the original held parent and acquisition scope. A confirmed missing final component may enter creation only after fresh parent write/search and default-ACL evidence. Intermediate absence, unknown replies and malformed evidence must not become permission to create. Reserve descriptor, candidate identity, response storage and cleanup correlations before effects. Providers must correlate the original parent identity and evidence, serialize existence check with creation, and retain the original acquisition key through uncertain replies. Cleanup retires private pins; it must not unlink a possibly committed file or replay creation. First establish process creation policy through the existing original-client configuration and serving lifetime. Add an explicit checked nine-bit initial file creation mask to each owner append record and digest-covered canonical client record. Grow the append record so old framing is rejected; bump the canonical configuration/pull version before consuming reserved bytes. The runtime's counted noncopyable client row carries the initial mask through reordering, verifies it against the sealed plan, and owns the mutable value for that exact native process generation. There is no host/environment/default mask and no implicit UID-zero exception. Add a distinct compatibility Umask operation: authenticate the actual CLAIM and sealed receiver, prepare the old-mask reply before replacing the process mask, ignore argument bits outside the permission bits, and retain the fixed reply with the original serving owner. Repeated caller correlations are not replay keys. A refused or ambiguous COMPLETE must not execute the exchange twice or roll it back; terminal retirement disables further selection. Querying live credentials exposes only the authenticated process's current creation policy. No descriptor, native endpoint, filesystem handle or new capability grant is involved. Author framing, legacy rejection, exact-generation isolation, response-capacity, repeated correlation and failed-completion controls, plus a native multi-client witness. Creation metadata uses effective IDs selected from the original client. Without a parent default ACL, attenuate requested permission bits by the process mask. With a validated complete default ACL, inherit it as the child's access ACL and attenuate the mode-corresponding owner, group-class and other entries by the requested mode; do not apply the process mask a second time. Named qualifiers remain unchanged. Ext default ACLs must remain distinct from access ACLs, and persistent inheritance must commit with creation. Unknown provider metadata remains denial, never an invented empty ACL. Full native creation, persistent inheritance, provider policy, failure cleanup and native workloads remain in this issue's acceptance scope. Derive semantics from the POSIX open specification and the Linux ACL manual, without importing implementation code: https://pubs.opengroup.org/onlinepubs/9799919799/functions/open.html and https://man7.org/linux/man-pages/man5/acl.5.html. Coordinate producers, consumers, documentation and immutable dependency revisions. Tests, builds and CI execution remain deferred by user instruction; author appropriate controls and distinguish them from executed evidence. Both full EriX guest build generations and rebuilding the external Rust/LLVM toolchain in EriX remain required. Original mount creation custody and retained administrative installation are implemented and published within [full Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17): [lib-ipc `08c3a9d0`](https://git.erikinkinen.fi/erix/lib-ipc/commit/08c3a9d05ef10b8f1eca48a03bfbb5f4a8abd520), [ramfsd `84d60c9c`](https://git.erikinkinen.fi/erix/ramfsd/commit/84d60c9cac073e6585d057fcd8da89e3d7c21ac0), [e2fsd `136c1272`](https://git.erikinkinen.fi/erix/e2fsd/commit/136c1272d78ea8e0d19bd9e6fa5cd29738ac3927), [fatd `13738d5e`](https://git.erikinkinen.fi/erix/fatd/commit/13738d5e851fe861d8f1ea0aec1f67142a89cf01), [vfsd `c2fcb803`](https://git.erikinkinen.fi/erix/vfsd/commit/c2fcb8036d1656b73fa1e1fdfed55934f618896a), [posixd `6cbcfe53`](https://git.erikinkinen.fi/erix/posixd/commit/6cbcfe537c2bc093823c95a9713cff43e6ac7ad4), [docs `962857ba`](https://git.erikinkinen.fi/erix/docs/commit/962857ba3cb4405dc89b5900b2f38796f555c1bc), [integration `450c6f2a`](https://git.erikinkinen.fi/erix/integration/commit/450c6f2a0c4866ed476375239847c7667395d585). The [lost mount reply defect](https://git.erikinkinen.fi/erix/vfsd/issues/13) is fixed and closed under the testing waiver. Its reproduction remains explicitly source-derived; no executed compiler, VM or fault-injection result is claimed. Private 0x6FD creation and 0x6FE retirement carry caller-known monotonic keys, complete original correlations, canonical success/refusal shapes and known dispositions. The superseded unowned mount family and consumer adapter are removed. RAM/ext/FAT reserve original IDs and counted mount storage before initialization or media inspection/recovery. Retirement waits for dependent handles, fences stale replay and clears only the original instance. Committed ext journal recovery is not rolled back when private state retires. Vfsd reserves the namespace record, original route and both correlations before submitting through its counted noncopyable owner. Unknown replies preserve that owner even without a returned mount ID. Administrative installation follows retained raw parent links and earlier actual mount edges, checks actual alias conflicts and covered target type, then publishes in place without losing entering-parent custody. Every failure disables installation before cleanup; refused cleanup retains its original counted row. Independent serving-loop retirement needs neither the initiating client nor fresh correlations. Existing mounts remain available while a failed pending installation drains. FAT/exFAT supplies original mounted-root/component custody and counted retained ancestry. Retired intermediate caller records become inaccessible to ordinary operations; descendants can retain their entering edges until iterative final release. Dot-dot follows actual held parents and clamps at the original root, including exFAT. Existing identity-replacement exclusion remains effective. Fresh one-use descriptive revisions are consumed before same-turn lookup. POSIX mode/UID/GID/ACL evidence remains unknown; namespace administration does not invent compatibility access policy or acquire additional client authority. Actual compiled arena layouts include the enlarged owner records. Twenty-one new unit controls are authored and unrun, with three existing actual mount-dispatch controls extended. They cover literal codecs, known refusal and unknown replies, original route/key/correlation cleanup after exhaustion, replay and row reuse, dependent handles, capacity before media work, actual FAT/exFAT ancestry, stale revisions, configured relative/absolute links, aliases, provider crossings, occupied namespace storage and post-creation cleanup refusal. The native realm-binding scenario installs a read-only RAM overlay through an ext symlink parent, opens it through configured and actual namespace spellings, then ascends from a live directory fd. Its explicit budget counts additional namespace and simultaneous client branch pins. No new unit control or VM workload has been executed. Full Open remains open for conditional creation, authenticated process umask/default ACL inheritance and complete provider policy. No full Open checklist credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest generations and external Rust/LLVM rebuilding inside EriX remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No test pass, warning-free build or measured performance improvement is claimed. Earlier evidence follows; the original mount custody and retained installation above are current. ### FAT-family namespace parent custody The new installation path must preserve mounting beneath FAT/exFAT directories. Extend the existing mounted-root, conditional-component, original retirement and descriptive snapshot families on the private FAT route. Retain ancestry in deployment-counted handle records, including intermediate directories whose caller ownership has retired while descendants still need their original entering edge. Such rows remain inaccessible by ordinary handle operations and drain iteratively when the final dependent child retires. Literal dot-dot follows retained ancestry and clamps at the actual mount root, including exFAT, without trusting on-media parent names, reopening a configured path or adding a fixed traversal-depth bound. Live pins continue to prevent directory identity replacement. Original mount and component keys remain monotonic and fenced. Root retirement disables access immediately and waits for descendants; independent child retirement remains possible. Snapshot revisions are distinct and consumed before dependent lookup, with the actual retained directory refreshed in the same provider turn. FAT does not supply POSIX ownership or ACL evidence: these fields remain explicitly unknown, rather than inventing user/group IDs or treating an unsupported ACL as absent. Namespace administration already holds its explicit provider authority; this descriptive snapshot does not authorize compatibility-process file access. Full realm Open still needs its complete permission policy and provider coverage. Author FAT and exFAT positive, capacity, stale-evidence, ancestry-retirement and lost-reply controls; execution remains deferred. ### Retained mount installation design Before installing configured parents through the retained namespace walker, repair original provider mount creation custody. The [lost mount reply defect](https://git.erikinkinen.fi/erix/vfsd/issues/13) records the source-derived failure. Add distinct private mount creation and retirement families with a caller-known nonzero monotonic owner key, complete original-key echoes, known dispositions and canonical success/refusal shapes. Reserve original route plus acquisition and cleanup correlations before submission. A missing or malformed reply stays owned; a correlated definite refusal proves no retained mount allocation. Original-key cleanup fences replay and remains possible without receiving a mount ID or allocating another correlation. Providers keep the owner key in counted mount storage, admit keys monotonically per original provider endpoint lifetime and preflight mount storage before media validation or allocation. Retirement finds the original creation key, refuses reuse while dependent handles remain and releases only the original mount state; absent-key retirement fences stale replay. Returned mount IDs remain descriptive selections within the existing provider authority. No public client capability or new discovery route is introduced. Coordinate RAM, ext and FAT producers with the Vfsd consumer, and remove the superseded wire path once the consumers and coverage are migrated. Reserve the namespace installation record before retained parent traversal. Preserve root-first ordering, actual target type checks under the held parent, alias-edge conflict checks and the original administrator's mount flags. Successful publication must preserve the prepared entering-parent owner, not overwrite it with an empty record. Failed walks and failed/uncertain mount creation retain their counted records through independent cleanup. Connect the public administration route and author a native configured-link mount scenario. Audit unsupported provider traversal explicitly; do not introduce a silent fallback that turns denial into path authority. Full Open still requires conditional creation with trusted process umask and default ACL inheritance. Tests, builds and CI execution remain deferred. The retained namespace-parent binding engine is implemented and published as continued [full Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) work: [vfsd `e08309b1`](https://git.erikinkinen.fi/erix/vfsd/commit/e08309b1552141a2387390936967ccfb149c9aa7), [docs `b9365cb1`](https://git.erikinkinen.fi/erix/docs/commit/b9365cb13be79479277935a23b71c54f4beaaf4b), [integration `cbca80fc`](https://git.erikinkinen.fi/erix/integration/commit/cbca80fc5fb7eb00c783d7e4ff3af1cd9f471890). The [ownership contract](https://git.erikinkinen.fi/erix/vfsd/src/branch/feature/posix-compat/docs/namespace-parent-traversal.md) distinguishes implemented traversal from the remaining administrative installation connection. Namespace walks now retain noncopyable symlink and temporary parent owners in deployment-counted handle rows, keyed by the original walk generation and full outer-frame generation. Every allocation family excludes these rows while owned. Raw pages retain original object, offset and total correlation; a bounded cache preserves unread bytes across components, including the first observed byte. Target length is independent of the configured-path buffer and packet width. No fixed follow count or whole-target array is introduced. Relative targets keep actual parents; absolute targets use only the original namespace root. Actual active object/parent/mount contexts detect recursion while allowing completed revisits and distinct-parent hard-link aliases. Literal dot/dot-dot traversal uses fresh conditional pins. Mounted descent and ascent retain a conditional departing guard and independently pin the destination. Earlier installed binding dependencies suspend in counted mount records and resume through an iterative driver, without recursive call-stack growth. Actual bound parent objects now select native edges and initial cwd ancestry instead of lexical ancestor-provider prefilters. Client scope ceilings and provider ancestry proofs remain separate. Namespace administration owns these pins; no client grant, public endpoint, clock or metadata write is introduced. Failures drain current/prospective pins, guards, active expansion chains and suspended dependencies independently of client liveness. Lost replies, malformed later pages, exhausted fresh correlations and refused cleanup preserve the original provider keys and counted rows until positive retirement. Successful namespace roots and entering directories keep their installation lifetime. Nine new controls are authored and unrun: relative/absolute raw and all-slash targets, a 703-byte target and page caching, 45 completed expansions, direct/mutual/growing recursion, distinct-parent aliases of one link inode, cross-provider mount edges and initial ancestry, mounted ascent, malformed pages with refused cleanup, actual owner exhaustion and suspended dependency cleanup. Rustfmt was applied to 15 inputs with actual crate editions and repository settings. The page-cache control counts fixture provider calls; no measured runtime speedup is claimed. Contracts, README navigation, architecture/roadmaps and manual TeX are updated. Three signed commits are pushed, with three catalog revisions selected and the existing independent Rootd Rust helper preserved. Source inventory covers 3541 code files in 76 repositories, all below 1000 lines; the largest changed Rust file has 946 lines. Source inspection found that administrative mount installation still uses legacy path-stat preflight. Ext lookup does not follow parent links, so that route must be connected to the new retained engine with pre-effect reservation and complete cleanup before configured symlink mounts can be accepted. Its native VM scenario remains to be authored with that connection. Conditional Open creation with authenticated process umask and default ACL inheritance also remains unfinished. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed. Earlier evidence follows; the namespace engine and remaining installation connection above are current. ### Configured mount-parent traversal design Resolve each configured entering directory from the independently held namespace root using conditional no-follow component pins and raw retained-link pages. Relative targets retain the actual containing directory; absolute targets use the namespace root. Preserve literal dot/dot-dot traversal across actual mounted roots. Namespace administration supplies this authority; it neither borrows a client scope nor grants a compatibility permission verdict. Use deployment-counted handle rows for noncopyable active link expansions. Each row owns its original symlink and any temporary containing-directory pin, the exact namespace walk generation, an outer-frame key, and a raw target cursor. Stream components from correlated pages rather than imposing a whole-target array or fixed link-follow count. Compare actual still-held link/parent contexts on their installed mount routes to detect recursive expansion. Completed frames retire positively before reuse; failures drain all original owners independently of the initiating client. Temporary directory and mount-transition pins stay in the counted mount walk before submission. Unknown replies and refused retirement never free their records. Bind a mount against earlier installed mounts, preserving installation ancestry rather than allowing later aliases to retroactively move its entering edge. Existing mount storage has no removal/reuse operation. Drive dependencies iteratively through counted mount records, with strictly earlier installed dependencies and no recursive call-stack growth. Native edge selection compares actual bound parent objects; initial cwd ancestry follows those same bindings instead of configured lexical prefixes. Conflicting bindings to one actual edge refuse deterministically. Existing administrative path representation remains the input contract; raw target lengths are independent of it. Author controls for relative/absolute links, long paged targets, cross-mount traversal and ascent, repeated finite links, recursive contexts, identity aliases, frame exhaustion, malformed pages and retained cleanup. Update contracts and the manual, then publish signed dependency/catalog selections. Tests, builds and CI execution remain deferred. Full Open continues to require conditional creation, authenticated process umask and default ACL inheritance; this design does not narrow its acceptance. Retained symlink following, active-context loop detection and original expansion cleanup are implemented and published as continued [full Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) work: [lib-ipc `d1cc4cad`](https://git.erikinkinen.fi/erix/lib-ipc/commit/d1cc4cadbb64a3fea7ce9cad081d97608fbe8c25), [posixd `7d6a76fe`](https://git.erikinkinen.fi/erix/posixd/commit/7d6a76feba3e0df346f5be8769df202276ba3d3d), [vfsd `10fb2e5c`](https://git.erikinkinen.fi/erix/vfsd/commit/10fb2e5c140e666a99b34d8c8b4258d7362ee9bf), [docs `44bfa626`](https://git.erikinkinen.fi/erix/docs/commit/44bfa62635acabd2502764cde1d3f3f45beaaee2), [integration `f69e2243`](https://git.erikinkinen.fi/erix/integration/commit/f69e22437e75ea161532f7f85ec0f47a7203d2a4). Posixd assembles every raw page into its original counted request region before following any target byte. Original key, offset and unchanged total extent remain correlated. Relative targets retain their containing directory; absolute targets select only the original scope root. Raw unresolved suffixes, trailing-directory requirements and fresh component/dot/dot-dot search mediation survive substitution. Final exclusive creation refuses an existing link with EEXIST, and final NOFOLLOW refuses with ELOOP before reading target text; directory-prefix links still follow. Noncopyable active expansion frames retain original symlink and temporary containing-directory pins in the existing counted shared-description arena. Their generational chain and suffix boundaries are internal ownership, never published fds. Complete frames retire both original pins before row reuse. Cancellation drains the complete original chain before cancelling the reserved fd; uncertain replies preserve native caller and original-key custody. The target-derived arena descriptor counts the actual enlarged owner types. Actual byte/owner exhaustion reports ENAMETOOLONG/ENFILE without a fixed follow count. Cap-free native operation 0x6FC has exact 56-byte requests and 64-byte replies, echoing both complete link/parent contexts and canonical equality. VFS selects only original live pins and compares actual link/directory objects, provider/mount routes and complete retained mount ancestry. Fresh candidate or branch allocation numbers do not determine equality. Comparison calls no provider, obtains no clock and creates no pin. Earlier objects remain pinned throughout active comparison, preventing identity reuse. Returning to an active context reports ELOOP; completed expansions can recur sequentially. Full final permissions and original cleanup remain separate obligations. The [runtime owner observation defect](https://git.erikinkinen.fi/erix/posixd/issues/20) is fixed and closed under the testing override. A const pending-operation observer called a non-const Open method. Removing the unnecessary const qualifier preserves runtime custody observation and includes active frame cleanup callers. The bug report records exact source-derived reproduction and explicitly states that no compiler or runtime reproduction was performed. Eighteen new tests are authored and unrun: two wire, three raw-assembly, eight sealed-service, three native VFS and two ext-image packaging controls. Coverage includes non-UTF-8 bytes, a 700-byte assembled target, original parents and scope roots, nested and repeated links, more than forty sequential revisits, same-link aliases in distinct directories, direct/mutual/growing recursion, malformed later pages, storage exhaustion, final flags, scope isolation, mounted re-entry and cancellation with refused cleanup. The existing native binding workload now follows independently packaged literal ext links into mounted tmp, observes actual target data, and exercises recursive, NOFOLLOW and trailing-separator cases. The fixture is included only when the original native byte client is selected. No new test or VM workload has been executed. Configured namespace-parent symlinks and conditional creation with authenticated process umask/default ACLs remain unfinished within full Open. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed. Earlier evidence follows; retained client following and active-context comparison above are current. ### Active retained-link expansion design Connect raw retained-link pages to Open without discarding the containing directory. Relative targets restart at that original directory; absolute targets select only the original scope root. Assemble the complete, correlated raw target in the client's counted request storage before following any bytes. Preserve the unresolved suffix, trailing directory requirement and literal dot/dot-dot permission checks. Final exclusive creation refuses an existing link with EEXIST; final NOFOLLOW refuses with ELOOP, while intermediate links still follow. Retain active expansion frames in the already counted shared-description arena. A frame owns the original symlink candidate and any temporary containing-directory candidate, plus a generational previous-frame key and unresolved suffix boundary. These are internal owners, never published fds. Pop only after the target expansion resolves, and positively retire both original pins before releasing the frame. Cancellation drains the complete original frame chain before cancelling the fd reservation. Exhaustion reports real counted storage exhaustion, not a fixed link-follow limit. Add a cap-free native comparison family (0x6FC) for two retained link/parent contexts under one actual live scope. Requests echo both link keys and complete parent selectors; responses echo all fields and a canonical boolean. VFS compares actual pinned link and parent identities, provider/mount routes and complete retained mount ancestry. Fresh candidate/branch numbers are not object identity. This observation acquires no provider pin, clock, path or capability. Active owners keep compared objects alive; copied descriptive identities cannot manufacture cleanup custody. Compare only active expansions so legal repeated links after a completed expansion remain valid. A detected recursive context reports ELOOP before another expansion. Author raw-byte, multi-page, relative/absolute, nested/sequential, growing-loop, final-flag, storage, cancellation and refused-cleanup controls. Extend native workloads where the deployed fixture can provide actual symlinks. Tests, builds and CI remain deferred. Full Open still includes configured namespace-parent links and conditional creation with authenticated umask/default ACLs; this design does not reduce that acceptance scope. Specification basis: https://pubs.opengroup.org/onlinepubs/9799919799/functions/open.html and https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap04.html#tag_04_16. Independent implementation; no external implementation code is imported. Raw retained-link pages and original-root retirement enforcement are implemented and published as continued [full Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) work: [lib-ipc `9119a684`](https://git.erikinkinen.fi/erix/lib-ipc/commit/9119a684dbf9f3342ac83971b2742f3dd7207cb0), [ramfsd `4e992840`](https://git.erikinkinen.fi/erix/ramfsd/commit/4e992840f7990a222f36e65c8f598d2d9d49b27c), [e2fsd `e233edea`](https://git.erikinkinen.fi/erix/e2fsd/commit/e233edea9bfbdf525b1f02b6d8a5c81215a9a852), [vfsd `72564e18`](https://git.erikinkinen.fi/erix/vfsd/commit/72564e1870970e942a783281df4ebd74aabb7045), [docs `4668d855`](https://git.erikinkinen.fi/erix/docs/commit/4668d8555db16a4cf9d094585cfa3057addf71b9), [integration `07490592`](https://git.erikinkinen.fi/erix/integration/commit/07490592437dc4e52ab97b1746685e78c6594835). Distinct native-scope operation 0x6FA and private-provider operation 0x6FB share checked 32-byte requests and 48-byte response prefixes. Original object/key, offset, total target length, positive capacity and initialized bytes are fully correlated. Raw NUL-free targets have no UTF-8 gate or whole-target transport array; page storage does not restrict total target length. Refusals carry no target bytes, offset or total, and do not acknowledge pin retirement. Ramfsd reads the actual retained node and checks only returned bytes, avoiding a repeated scan of the whole target on every page. Its existing node storage geometry still applies. E2fsd shares one fast/block-backed inode byte reader with legacy whole-target access while retaining that caller's text representation and capacity refusal before data I/O. The VFS gate admits only actual live symlink candidates in the original scope. Complete private response validation precedes in-place rewriting of descriptive correlation/key words. Failed or malformed replies scrub staging. These observational calls create no handles, reopen no path, query no clock and preserve independently reserved original cleanup after correlation exhaustion. The [RAM retained-link retirement defect](https://git.erikinkinen.fi/erix/ramfsd/issues/4) and [ext retained-link retirement defect](https://git.erikinkinen.fi/erix/e2fsd/issues/12) are implemented and closed under the testing override. Their bug reports record source-derived reproduction and execution limits. The old whole-target readers checked the child handle without checking its acquisition root. Both old and paged readers now reject once that original root enters retirement, while child cleanup remains available. The native VFS scope gate independently rejects revoked scope use; no external runtime bypass is claimed. Fourteen controls are authored and unrun: three wire, three RAM provider, four ext media/provider, two transport-fault and two actual native-scope controls. They include non-UTF-8 bytes, a 700-byte block-backed target larger than the legacy buffer, page geometry, original echoes, malformed and lost responses, capacity refusal, wrong scopes/types, revocation, original anchor retirement and cleanup after exhausted correlations. Rustfmt was applied to 27 Rust inputs using actual crate editions and repository settings. Contracts, evergreen navigation, architecture/roadmaps and technical manual TeX are updated. No measured performance result is claimed. Complete consumer assembly/following, loop handling, configured-parent symlinks and conditional creation with authenticated process umask/default ACLs remain unfinished within full Open. Native directory mount traversal remains connected. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed. Earlier evidence follows; the raw-page implementation and root-retirement correction above are current. Retained symlink reading design: add distinct private-provider and acquisition-scope page operations, with exact original object/key, offset, requested capacity, total target length and actual initialized bytes. Targets are raw NUL-free pathname bytes; UTF-8 conversion and fixed whole-target transport buffers must not restrict native Open. Pages are observational, do not create handles or query a clock, and never reopen a pathname. Provider and scope families remain disjoint; a native scope can select only its own live original symlink candidate. Refused, malformed or overlong replies expose no staged target bytes and preserve original-key retirement. Ramfsd reads the actual retained node; E2fsd reads fast or block-backed link slices from the actual retained inode. E2fsd will share the underlying byte reader with legacy whole-target access while preserving the legacy caller's stricter representation separately. Reply storage determines page length, not total link length. Native VFS rewrites private handle identity to the original candidate key after complete correlation. Consumer assembly must compare total extent across every page and retain the containing directory and symlink pin until the full target is available; relative targets continue from that directory and absolute targets restart only at the original root. Final no-follow and exclusive-create semantics, bounded cancellation, loop handling, configured-parent symlinks and conditional creation remain in full Open scope. No new fixed symlink-follow limit is accepted as a substitute for that implementation. References: [POSIX pathname resolution](https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap04.html#tag_04_16) and [Open semantics](https://pubs.opengroup.org/onlinepubs/9799919799/functions/open.html). Tests and execution remain deferred; appropriate raw-byte, multi-page, identity, cleanup and malformed-response controls will be authored. Native directory mount descent/ascent and initial cwd ancestry are implemented and published: [docs `a5d8bde4`](https://git.erikinkinen.fi/erix/docs/commit/a5d8bde4eddc04109e6a81af4b5da1652a1e274a), [vfsd `137189c8`](https://git.erikinkinen.fi/erix/vfsd/commit/137189c8135dad5bf45b88c765cea1d66cf76be1), [posixd `0f12172a`](https://git.erikinkinen.fi/erix/posixd/commit/0f12172a60c2eb515f522f466871d4342188d349), [integration `b01ed6f5`](https://git.erikinkinen.fi/erix/integration/commit/b01ed6f546853957feb270c5561b53c41d7ac4b6). VFS retains a counted noncopyable branch with independent entering-directory and mounted-root pins, original scope identity and a generational outer-branch dependency. Descent preflights branch/result storage and conditions the already-mediated search revision before acquiring the mounted root. Actual held identity selects the configured edge; no underlying covered child is forwarded. Nested branches and descendants survive closure of their initiating public directory. Selected mount restrictions still intersect the original scope ceiling. Ascent conditions search at the actual departing root and retains its temporary guard together with the prospective outer result under the original client cleanup key before effects. The result selects the independently held entering directory beneath the original outer ceiling. Only positive guard retirement permits ordinary use; unknown replies, identity mismatch or refused retirement retain cleanup-only custody. Initial cwd and derived scopes clone each entering parent under its actual outer ceiling, proving provider ancestry before acquiring the next root. Final cwd cloning binds to its mounted root. Scope publication preserves the monotonic key sequence consumed during preparation; no fixed mount-depth limit is added. Candidates and initial cwd drain before their branch dependencies. Unreferenced branches retire from leaves outward, retaining both original pins and their outer dependency through uncertainty. Original cleanup works after source closure and correlation exhaustion. Zero branch count skips arena scans during ordinary same-mount cleanup; no measured speedup is claimed. Eleven new VFS controls are authored and unrun for separate providers, nested mounts, independent descendants, stale revisions, lost replies, busy cleanup, exhausted correlations, storage preflight, selected read-only policy, initial subdirectory ceilings and derived/unpublished cwd lifetime. Existing edge fixtures now expect actual mount entry. The native binding workload adds absolute and directory-fd ascent out of `/tmp` and re-entry, repeated ascent and base-fd closure. Rustfmt was applied to 19 Rust inputs using each crate's actual edition and repository settings. Contracts, architecture/roadmaps and technical manual TeX are updated, with superseded status paragraphs consolidated. Four signed commits are pushed on feature/posix-compat, with remote head equality recorded. Integration adopts five catalog entries and retains independent Rust helper `cafa58e132fe45defcea4df0e8d92cf65fdb209b`. No Cargo source identities change. Read-only inventory covers 3515 code files in 76 repositories, all below 1000 lines; the largest changed source is 793 lines. [Full native Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open for client symlink following, configured-parent symlinks and conditional creation with authenticated process umask. These implemented directory transitions add no full Open acceptance credit. Recalculated progress is 16.91% weighted, 5.21% whole-item acceptance: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass or warning-free build is claimed. Earlier evidence follows; current directory mount traversal supersedes earlier statements that mount branches were unfinished. Mount traversal implementation design: store each scope-owned mounted-root and independent entering-directory obligation in a deployment-counted branch row. Its generational outer-branch link retains the original scope ceiling; candidates reference that row without turning returned handles into authority. Conditional descent first pins the actual entering directory using the already-mediated parent revision, then acquires the original mounted root and an independent result candidate. At a mounted root, parent traversal conditions the original search revision before pinning the actual independently held outer parent. Both sides remain owned under the original client cleanup key across lost replies and busy retirement. Retire unreferenced branches after candidates, preserve inner-to-outer dependencies, and retain unknown preparations until positive original-key cleanup. Initial cwd is included in this design: build the actual configured mount ancestry and independently bind each entering parent under the held outer ceiling using the provider's existing conditional ancestry check. Bind the original cwd under its actual mounted-root branch before publishing the scope. Namespace paths identify configured topology only; held objects and provider ancestry authorize the resulting pins. Scope derivation repeats original ownership without depending on the source after publication. Keep the original subdirectory ceiling, nested mounts, selected-mount restrictions and complete scope revocation. Full Open still includes symlinks and conditional creation with process umask/default ACLs. Tests will be authored; execution and CI observation remain deferred. The [covered-directory selection defect](https://git.erikinkinen.fi/erix/vfsd/issues/12) is corrected and published: [docs `a62f871a`](https://git.erikinkinen.fi/erix/docs/commit/a62f871a8d476ab1185ba11dbf0f1fdf5767b027), [vfsd `1872afc5`](https://git.erikinkinen.fi/erix/vfsd/commit/1872afc572ddeb3b12bf1482af8773cc13020698), [integration `6c080259`](https://git.erikinkinen.fi/erix/integration/commit/6c0802594660957c6716ae77e2d52f70dadc7017). Native component dispatch compares configured raw basenames with actual held parent identities on their original provider/mount routes before forwarding a lookup. Equal names under different actual parents remain ordinary lookups; aliased parents identify the same edge, and conflicting configured aliases refuse. A matched edge refuses before selecting an underlying child while full scope-owned crossing is completed. Deployment-counted mount records retain noncopyable namespace root and entering-parent owners. Mounted-root transport reserves its original mount/key and both correlations before submission, and remains distinct from conditional cloning. Parent walks retain at most two original component owners through advancement and cleanup. Successful pins last for the installed namespace mount; they are not client grants. Unknown replies and refused cleanup remain counted and drain from the serving loop independently of client liveness or new correlation allocation. A pending flag avoids idle cleanup scans. Mount insertion now consumes an exclusive borrowed empty-record reservation. Another insertion cannot overwrite original native custody, and publishing a successful provider mount needs no further fallible storage step. Table reborrowing preserves initialized owners. The obsolete component-only backend retirement method is replaced by one original-acquisition method shared by the distinct private families. Ten new controls are authored and unrun: three original transport controls and seven actual native-dispatch controls, covering aliases, ambiguous edges, different parents, malformed/lost replies, two-pin cleanup and correlation exhaustion. Rustfmt was applied to 22 Rust inputs using the crate's actual edition and repository settings; an existing include fragment keeps its surrounding format with only its noncopyable array initializer changed. Contracts, architecture/roadmaps and technical manual TeX are updated. Three signed commits are pushed on feature/posix-compat, with remote head equality recorded. Integration adopts three catalog entries and retains independent Rust helper `cafa58e132fe45defcea4df0e8d92cf65fdb209b`. No Cargo source identities change. A read-only inventory covers 3509 code files in 76 repositories, all below 1000 lines; the largest changed source is 944 lines. [Full native Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Scope-owned mount descent/ascent, initially mounted cwd and original subdirectory ceilings, symlink following and conditional creation with process umask remain implementation requirements. This correction adds no full Open acceptance credit. Recalculated progress is 16.91% weighted, 5.21% whole-item acceptance: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass, warning-free build or measured speedup is claimed. Earlier evidence follows; the current correction above supersedes the earlier covered-directory behavior. Continued mount-transition design: retain noncopyable mounted-root and entering-parent acquisition owners in the deployment-counted namespace mount records. All provider keys come from the existing monotonic VFS identity sequence and cleanup correlations are reserved before submission. Resolve configured parent edges from actual retained namespace roots, using counted temporary component owners and actual returned identities; retain those parents against object reuse. Client selection compares the actual held parent, original mount route and raw basename, never a pathname or handle number alone. Unknown binding replies retain cleanup owners and independent serving-loop cleanup must drain them even when the initiating client disappears. This closes covered-directory selection while scope-owned branches are wired for full descent/ascent; the full Open requirement remains unchanged. Actual held-object identity is implemented and published as continued [full Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) work: [lib-ipc `69e15a49`](https://git.erikinkinen.fi/erix/lib-ipc/commit/69e15a49767c9b3b93653e968ebc1faa24c60c63), [ramfsd `d490fac0`](https://git.erikinkinen.fi/erix/ramfsd/commit/d490fac06a76e14a5227ab34fb2ed286d48c111d), [e2fsd `c30ef621`](https://git.erikinkinen.fi/erix/e2fsd/commit/c30ef62150ffcd8d32ed291dfdc0071543b6265f), [vfsd `5fee4fdb`](https://git.erikinkinen.fi/erix/vfsd/commit/5fee4fdb0eb5d4ec96d84030b5253b3d2116014e), [docs `32e94c9f`](https://git.erikinkinen.fi/erix/docs/commit/32e94c9ff5020071585e01286a73dc9490ebd32b), [integration `41f65446`](https://git.erikinkinen.fi/erix/integration/commit/41f654464b801d8aa72d4ad3e2d24df63eff422b). Private component 0x6CA and conditional-anchor 0x6CC replies are exactly 72 bytes, carrying 32 stable identity bytes after their original 40-byte disposition. The earlier 40-byte responses reject. Success requires nonzero identity; refusals carry neither a handle nor identity. Mounted-root 0x6F9 keeps its existing 72-byte wire layout and distinct operation, sharing the complete anchor representation and eliminating duplicate identity framing/validation. All original requests and retirement framing remain unchanged. The coordinated immutable graph selects both producers and consumers. Ramfsd constructs identity from the actual node during the serialized pinning turn. E2fsd uses the actual inode, generation and mount identity; conditional cloning reuses its already-refreshed permission metadata without another inode read. Both agree with independently held cwd/root aliases, retain original replay fences and preserve original-key cleanup. Identity bytes alone grant no authority. VFS retains provider identity alongside the handle inside the original noncopyable acquisition state. Prepared, unknown and retiring owners expose no identity. Missing or malformed successful identity keeps the original cleanup obligation and never permits resubmission. Scope preparation installs actual cloned root/cwd identities and uses them in the published endpoint digest, replacing copied source endpoint digests as object identity. Five new controls are authored and unrun: one literal codec, one Ramfsd alias/lifetime, one E2fsd alias/read-count and two VFS original-owner/derived-scope controls. Existing codec, provider dispatch and transport fixtures cover complete framing, short-output preflight, missing identity and lost replies. Rustfmt was applied to 34 changed inputs using actual Cargo editions and repository settings. Contracts, architecture/roadmaps and filesystem manual TeX are updated. No extra clone inode read is introduced; no speedup was measured. Counted VFS mount branches, independently held entering directories and object-bound ascent/descent remain unfinished, along with symlink following and conditional creation with process umask. This identity layer does not complete native cross-mount Open or its workload. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed. Earlier evidence follows; the held-identity implementation above is the current checkpoint. Continued implementation design: carry stable held-object identity in existing private component and conditional-anchor acquisition replies. Both exact replies become 72 bytes, with 32 identity bytes after the existing 40-byte disposition. Successful pins require nonzero identity; refusals require zero identity and no handle. Mounted-root replies keep their current 72-byte wire layout and distinct operation, sharing the complete anchor representation without duplicate fields. Original request and retirement framing remains unchanged. Providers compute identity in the same serialized pinning turn from the actual selected node/inode, using the existing cwd identity representation. Ext conditional cloning should reuse the generation from already-refreshed permission metadata rather than issue another inode read. VFS retains identity inside its original noncopyable acquisition owner and installs provider-confirmed root/cwd identities during scope preparation, replacing descriptive endpoint digests as object comparisons. Unknown or malformed identity responses keep original-key cleanup custody. No public handle, selector or endpoint is added. Mount transitions still require counted branch and entering-parent ownership; identity alone grants no authority. Publish all consumers together with the immutable dependency closure, author codec/provider/transport regressions, and retain the current execution waiver. Full Open and guest builds remain unfinished. Mounted-root provider custody is implemented and published as continued [full Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) work: [lib-ipc `2b65a08b`](https://git.erikinkinen.fi/erix/lib-ipc/commit/2b65a08bb3b3190c305d223b94bf45518370b2db), [ramfsd `76271d74`](https://git.erikinkinen.fi/erix/ramfsd/commit/76271d74fb3624db77b30e0bab2b2c50623e6373), [e2fsd `0fbb6964`](https://git.erikinkinen.fi/erix/e2fsd/commit/0fbb6964946f84be308acd71f0bc37dfabd5fd61), [docs `ad7fb2e4`](https://git.erikinkinen.fi/erix/docs/commit/ad7fb2e4180320182054baf6a15999f1358b79c5), [integration `76ace98c`](https://git.erikinkinen.fi/erix/integration/commit/76ace98c081679d68b03b1c3802ea4e4b2437bb9). Private operation 0x6F9 accepts an exact 24-byte original mount/key request and returns an exact 72-byte root/held-identity response. It selects an already-retained private provider mount, adds no public selector or endpoint, and never reopens a source path. Root replies share internal anchor-envelope code while their public parsers strictly distinguish operation families. Refusals carry no handle or object identity; framing and output preflight preserve rejected destinations. Ramfsd and E2fsd share mounted-root and conditional-clone keys under the original monotonic mount fence. Counted handle/identity capacity precedes publication; E2fsd reserves it before reading root metadata. Existing anchor retirement cleans by the original mount/key without a handle reply, fences absent keys and retains roots through dependent child cleanup. E2fsd retirement performs no media/key I/O. Mounted-root and cwd pins use the same held object identity. E2fsd selects the actual root inode without directory scans, name keys or writes, and dot lookup now reuses the already-read parent inode. Ten new controls are authored and unrun: three literal codec, three Ramfsd state/dispatch and four E2fsd real-media/dispatch controls. They cover lost replies, shared replay fences, other mounts and successors, full-width identities, short output, exhausted identities, dependent cleanup and non-directory root media. An authored read-count control covers the removed duplicate dot read; no speedup was measured. Two older provider fixtures now allocate the current 48-byte conditional-clone request, and its short-request codec coverage includes the complete extent. Rustfmt was applied to 19 inputs using repository settings and Cargo editions. Contracts, evergreen navigation links, architecture/roadmaps and filesystem manual TeX are updated. VFS still needs counted mount-branch ownership, independently held entering directories and object-bound edge selection for ascent/descent under the original ceiling. Those transitions, symlink following and conditional creation with process umask remain unfinished. This provider operation does not complete native cross-mount Open or its workload. No full Open acceptance credit is added: 16.91% weighted, 5.21% whole acceptance; 21/460 parents and 441/902 sub-items. Both full EriX guest-build generations and external Rust/LLVM guest rebuilding remain required and unperformed. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or warning-free build is claimed. Earlier evidence follows; the mounted-root provider layer above is the current checkpoint. Mount-transition design: the private provider root-acquisition request will carry the already-selected mounted provider and a fresh mount-local anchor key before submission. The existing anchor retirement operation will own cleanup and fence replay, even when the root-handle reply is lost. Root replies carry held object identity; response capacity and provider row/identity reservation precede pin publication. Conditional anchor clones and mounted-root acquisition share one monotonic key namespace. No public pathname or provider selector is added. The VFS transition will retain the actual entering directory independently, with counted branch ownership and original provider routes through descendant cleanup. Ascent must use that actual retained parent and stop at the original native ceiling. Mount edge selection must compare held objects; a pathname spelling or coincident numeric handle cannot reconstruct authority. Selected mount policy continues to intersect the original scope ceiling. The provider operation is only the next implementation layer; complete mount dispatch and full Open acceptance remain open. The [native candidate mount-policy defect](https://git.erikinkinen.fi/erix/vfsd/issues/11) is corrected and published: [docs `c6fe35cf`](https://git.erikinkinen.fi/erix/docs/commit/c6fe35cf519b3f43c05187bab849eff663bf5c11), [vfsd `4658bef7`](https://git.erikinkinen.fi/erix/vfsd/commit/4658bef704c6c26cfadf43034e4b8d9fc0fdcc44), [integration `ba59428d`](https://git.erikinkinen.fi/erix/integration/commit/ba59428dec40731c1d2b426befaa31fc32fd8006). Candidate write evidence, final write admission, truncation and each positioned/append write intersect the original scope ceiling with the selected held object's mount policy before provider work. Bound-directory write-access evidence applies the same restriction. Empty writes still require native write authority. Local mount refusal preserves an admitted read alias and the original cleanup key; pending retirement still retains the actual provider pin. Read-only candidate reads omit clock queries and access-time updates. VFS selects timestamps according to mount policy and operation intent, and provider adapters only forward that value. Writable nonempty read requests, nonempty writes and truncation retain trusted time. Empty requests omit it. Clock or provider failures after entering the original operation boundary retain cleanup-only custody without replay. Four new focused regressions and an extended bound-directory control are authored and unrun. The fixture observes actual timestamped and ordinary provider wire calls, original bytes, denial without clock/provider effects and independently retained cleanup pins. Rustfmt was applied to 13 Rust inputs using repository settings. Component architecture/roadmaps, the custody contract and technical manual TeX are updated. Three signed commits in Vfsd, Docs and Integration are pushed on feature/posix-compat, with remote head equality recorded. Integration adopts three catalog entries and retains independent Rust helper `0483017f598290a81af9f57dc3f937f390b1ec83`. No Cargo source identities change. A read-only inventory covers 3499 code files in 76 repositories, all below 1000 lines; the largest changed source is 889 lines. [Full native Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Cross-mount transitions, symlink following and conditional creation with process umask remain unfinished. This correction adds no full Open acceptance credit. Recalculated progress is 16.91% weighted, 5.21% whole-item acceptance: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass, warning-free build or measured speedup is claimed. Earlier evidence follows; the current correction above supersedes the earlier mount-policy behavior. Original-ceiling parent traversal is implemented for same-provider scopes and published as continued Open work: [lib-ipc `9597b508`](https://git.erikinkinen.fi/erix/lib-ipc/commit/9597b508e9478b826e41aeeaab52d1cf09edd160), [ramfsd `91992025`](https://git.erikinkinen.fi/erix/ramfsd/commit/91992025215275341271bc2adbd06efeefab4c49), [e2fsd `ede2bbcb`](https://git.erikinkinen.fi/erix/e2fsd/commit/ede2bbcb9ee5a591fb1e59247a3175dc1705eeff), [vfsd `374065f3`](https://git.erikinkinen.fi/erix/vfsd/commit/374065f38ddb5ad82e3ca6f3c76580a946431829), [posixd `1d53add3`](https://git.erikinkinen.fi/erix/posixd/commit/1d53add3e66068f0d7926edb48aa2e1fd0219202), [integration `50666ac4`](https://git.erikinkinen.fi/erix/integration/commit/50666ac469d9e342c567b066fa3b5d667f1f2da1), [docs `ea904a19`](https://git.erikinkinen.fi/erix/docs/commit/ea904a19ad94ae71160a20434d71379889660b8d). VFS binds an independently cloned cwd to the original held root before submitting the cwd clone. The private anchor request is now exactly 48 bytes, with the full original ceiling handle at offset 40; zero requests an independent root and the earlier body extent rejects. Same-provider root and cwd keep distinct actual handles while candidates retain their original scope generation and common navigation ceiling. Ordinary same-inode aliases do not imply this relationship. Ramfsd proves ancestry through actual node links. E2fsd shares checksummed dot-entry or inline-parent reading with rename admission. Constant-space cycle detection adds no fixed depth limit and neither cursor reads above the supplied ceiling. Fresh search evidence, ancestry, conditional lookup and pin publication stay in one provider turn. Moved-out parents and cycles refuse before creating a candidate. Dot-dot clamps at the original ceiling. Posixd applies complete fresh search checks to the directory being left and never lexically removes a parent component. Bound cwd anchors and acquired candidates independently retain their original ceiling. Starting ceiling retirement disables bound-anchor use while original-key cleanup remains available. Root disposal waits for all dependent custody. Cross-mount ascent remains unfinished and refuses before provider submission; no pathname reopening or coincident handle number bridges routes. Twelve new controls are authored and unrun: two codec, three Ramfsd, three E2fsd, two VFS and two sealed-service tests. Existing literal, original-route and transport fixtures are extended. The native binding workload now requires absolute and directory-fd root-parent clamping before its existing file acquisition checks. Rustfmt was applied to 39 inputs using repository settings; component contracts, architecture/roadmaps and technical manual TeX are updated. No execution pass is claimed. [Full realm Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open in the same implementation pass. Cross-mount transitions, symlink following and conditional creation with process umask remain unfinished. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. No full-item acceptance is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No warning-free build or measured speedup is claimed. Earlier evidence (historical; superseded where the current checkpoint above advances it): The [file-delivery cancellation defect](https://git.erikinkinen.fi/erix/posixd/issues/19) is corrected and published: [docs `8a2ea35b`](https://git.erikinkinen.fi/erix/docs/commit/8a2ea35bb0509e7b19b649062756e1259ee4cda1), [posixd `17e151a3`](https://git.erikinkinen.fi/erix/posixd/commit/17e151a37674d470496dbcc019789e802bdb1125), [integration `70d1079b`](https://git.erikinkinen.fi/erix/integration/commit/70d1079b107ca74bf63ef13e5523754b1649fc3f). After an original native Read/Write reply is completely validated, cancellation during ordinary or acknowledged draining caller release preserves the committed shared cursor and admitted candidate for surviving aliases. It abandons only the delivery and never replays the effect. An uncollected effect remains cleanup-only, and uncertain submission retains original custody under the existing service failure latch. Final Close still retires the one shared pin. Four sealed-service regressions are authored and unrun: collected Read and Write each cover cancellation before and during draining release; negative controls cover uncollected cancellation and uncertain submission without ordinary-use recovery or discarded custody. Rustfmt was applied with the repository configuration. Component contracts, architecture/roadmap and the technical manual are updated. The implementation closes the defect under the current testing waiver; no test pass is claimed. Three signed commits are pushed on feature/posix-compat in Posixd, Docs and Integration. Integration adopts three catalog entries and preserves the independent Rust helper `e755cf71c9365577882183d16e7d7e4442fa49cd`. No Cargo dependency changes are needed. A read-only inventory covers 3493 code files in 76 repositories, all below 1000 lines; the largest changed source is 475 lines. [Full native Open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains unfinished for parent/symlink/mount traversal and conditional creation with process umask. The source audit confirms root/cwd are independent provider anchors; accepting parent components alone cannot implement ceiling-preserving traversal across them. This correction adds no full Open acceptance credit. Recalculated completion remains 16.91% weighted: 21/460 parents and 441/902 sub-items. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Earlier evidence follows; the correction above supersedes the original cancellation behavior. Retained Open and dynamic file serving are implemented for existing downward paths and published as unfinished acquisition work: [lib-ipc `caac62ca`](https://git.erikinkinen.fi/erix/lib-ipc/commit/caac62ca4aa6c9091a8099fd498596187b7b7dc9), [lib-posixabi `be194572`](https://git.erikinkinen.fi/erix/lib-posixabi/commit/be1945725c1b6f0d337eb94bd0e9a2091ffbe3dd), [posixd `6674637c`](https://git.erikinkinen.fi/erix/posixd/commit/6674637c7a10420dac23a9622e0c27a7e37e7492), [loaderd `83651288`](https://git.erikinkinen.fi/erix/loaderd/commit/83651288c2336de7fcde19e1c68a43f0b9d9fc26), [launchd `0315555d`](https://git.erikinkinen.fi/erix/launchd/commit/0315555d0cc631910d5fd0c5f7941900fb2a04f6), [procd `26dce660`](https://git.erikinkinen.fi/erix/procd/commit/26dce66075cb588573a609c728f7a414125ef85c), [integration `e1dcb8ff`](https://git.erikinkinen.fi/erix/integration/commit/e1dcb8ff2acfb8d45d98093f43ee7f17e1ffdf47), [docs `7c7f7440`](https://git.erikinkinen.fi/erix/docs/commit/7c7f74409afc28d4cfa847e7e46a59468880718e). The sealed native client selects its actual original root, cwd or live directory fd. Each component retains its own pre-submission cleanup key and uses fresh complete permission evidence, immutable effective credentials and fully folded ACL pages. Final admission and optional truncation use the original held candidate. The fd and description remain reserved until native COMPLETE succeeds; refused completion drains the candidate and reservation without replaying truncation. Positive COMPLETE is recorded before local publication so terminal handling cannot repeat it. Dynamic aliases share one counted candidate and cursor. Exact native request/key/progress checks precede cursor changes. Read-only files reject empty writes, directory I/O reports EISDIR, and append delegates EOF selection to the provider's exclusive write turn. Empty writes preserve position. Last Close and dup2 replacement retain original candidate custody through provider and caller cleanup. Terminal handling retires all candidates before their acquisition scope and receiver. Arena version four adds independent retained request bytes per client and counts complete Open/candidate owners in authenticated target geometry. Older layouts reject. Variable native payloads are framed in place; request, result and packet regions remain distinct. Compatibility 1.6 appends EISDIR, ENOTDIR, ELOOP and ENAMETOOLONG as values 21 through 24 without renumbering existing errors. Original ACL folding and packet framing are shared between consumers. Nine sealed-service tests and two packet tests are authored and unrun, covering original bases, full ACL collection, UID-zero denials, shared cursors, independent append pins, empty writes, cleanup BUSY, cancellation, refused completion, terminal ordering and malformed pin echoes. Existing arena and compatibility/C fixtures are extended. The native binding workload additionally requires Open/openat, directory-base closure, shared-cursor aliases, EOF and write refusals. Rustfmt was applied; maintained contracts and technical manual TeX are updated. [Full realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open in the same implementation pass. Parent traversal, symlink following, mount transitions and conditional creation with process umask remain unfinished. The authored native workload includes the remaining mount-transition requirement and has not run. Both complete EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. No full-item acceptance is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. No execution pass, warning-free build or measured speedup is claimed. Earlier evidence (historical; superseded where the current checkpoint above advances it): Native final-candidate admission and file I/O are implemented and published: [lib-ipc `fec141eb`](https://git.erikinkinen.fi/erix/lib-ipc/commit/fec141eb95ee984e58e198c65ada67294ff2c231), [ramfsd `67bcad59`](https://git.erikinkinen.fi/erix/ramfsd/commit/67bcad59433d9ef1e66c6d492cbdd70dc7f89378), [e2fsd `a3b6777c`](https://git.erikinkinen.fi/erix/e2fsd/commit/a3b6777cfd58f26f8d8c0d362688e4dac5f074e9), [vfsd `944e4a06`](https://git.erikinkinen.fi/erix/vfsd/commit/944e4a06f7160bd1b5e2545128ca59d278f6d486), [integration `9f00c9f7`](https://git.erikinkinen.fi/erix/integration/commit/9f00c9f784809cff4c78bea63bf9f6c398fa43c4), [docs `c9672b76`](https://git.erikinkinen.fi/erix/docs/commit/c9672b761a863e077ee18fd93ebb7a247d141e56). The original acquired component grants no ordinary file I/O until the trusted mediator applies complete final permissions and native admission succeeds. VFS enforces the scope write ceiling, records the attempt before the provider gate and freezes read/write access once. Ramfsd compares the current permission revision; E2fsd consumes and refreshes the original complete fingerprint. Optional truncation affects that same retained object in the exclusive comparison turn, without pathname reopening or another handle. Actual acquisition endpoints now serve reads and positioned or atomic append writes through the retained owner. Borrowed codecs preserve exact initialized bytes and full original correlation; actual transport capacity determines short progress. Both providers select append EOF and write in one exclusive turn, including across independent pins of the same file. Empty writes cannot extend a file or change timestamps. E2fsd reuses its encryption and journal write engine. Native time comes only from the existing trusted route. A failed or uncertain provider result disables further ordinary use while preserving original-key cleanup and its separately reserved correlation. No confirmed progress is not a rollback assertion after reply loss. Native delivery holds the prepared result; refused COMPLETE cannot repeat provider writes. Whole-scope revocation drains the same original owners and preserves the already implemented delivery/receiver lifetime correction. Eighteen controls are authored and unrun: four shared-wire, four Ramfsd, four E2fsd and six VFS. They cover framing, immutable access, stale final permissions, independent append pins, empty writes, reply capacity, lost/malformed replies, correlation exhaustion, original cleanup and native completion refusal. Rustfmt was applied to forty changed Rust files. Component contracts, README/ARCHITECTURE/ROADMAP and manual TeX are updated. [Full realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Posixd still needs retained path walking, parent/symlink/mount transitions, sealed credential mediation, conditional creation, final descriptor publication and ordinary fd serving through these native operations. Native open/openat workloads and both full EriX guest-build generations plus the Rust/LLVM guest rebuild remain unfinished. This checkpoint adds no full-item acceptance: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or measured speedup is claimed. Earlier evidence (historical; superseded where the current checkpoint above advances it): [The scope Close lifetime defect](https://git.erikinkinen.fi/erix/vfsd/issues/10) is corrected and closed: [vfsd `e10522c0`](https://git.erikinkinen.fi/erix/vfsd/commit/e10522c024a7e4afc5766524a2c24ab67f8d635c), [launchd `2690e09e`](https://git.erikinkinen.fi/erix/launchd/commit/2690e09e84d3a57d9efe1a5c132d53da9cd0f4a0), [integration `4f2aff8e`](https://git.erikinkinen.fi/erix/integration/commit/4f2aff8eca29314a6ad5db1d4502e8218ef061a5), [docs `d963ebc5`](https://git.erikinkinen.fi/erix/docs/commit/d963ebc500e0380953eb792a1e1f2d5c00f678f1). VFS retains the original private cleanup key after provider Close and descriptive metadata removal. The counted owner prevents row reuse through delayed delivery retirement and failed receiver disposal. Ordinary owned Close attempts its original completion at most once and keeps the key until native custody and receiver disposal settle. Legacy Close preserves its reply and disposal boundary as well. Private revocation can supersede a pending Close reply. It suppresses that reply, invalidates the receiver and returns fully correlated BUSY while original delivery remains counted; subsequent exact turns relinquish that original owner. Launchd retains its cleanup obligation and retries on later scheduler turns. BUSY no longer poisons retirement, while wrong keys, generations, request correlations and contradictory result layers remain errors. No provider effect or native completion is replayed. Five VFS and three Launchd regression controls are authored and unrun. They cover delayed native drain, positive completion followed by failed receiver disposal, private revocation during Close or an ordinary pending reply, stale cleanup after row reuse, and complete pending-result correlation. Existing native controls share the same independent fixture. Rustfmt was applied; component contracts and maintained manual TeX are updated. Full [realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17), complete path/permission mediation, parent/symlink/mount transitions, conditional creation/append, descriptor publication/serving and native workloads remain unfinished. Both EriX guest-build generations and the external Rust/LLVM guest rebuild remain required. No runtime checklist acceptance is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass is claimed. Earlier evidence (historical; superseded where the current checkpoint above advances it): Native scoped component dispatch is implemented and published: [lib-ipc `c0d3bec1`](https://git.erikinkinen.fi/erix/lib-ipc/commit/c0d3bec14920b4a20693daa159041c0a6e7a3b20), [vfsd `764a6a76`](https://git.erikinkinen.fi/erix/vfsd/commit/764a6a762465caf3d8e5abce24402720e2192ae4), [integration `590c5e77`](https://git.erikinkinen.fi/erix/integration/commit/590c5e77587765af76f1e7c9fd039330a3dcb9ec), [docs `df1fb3c2`](https://git.erikinkinen.fi/erix/docs/commit/df1fb3c2981015c6a6d849639deda4bd779127a2). Actual acquisition endpoints now select original root, cwd or counted candidates for permission evidence, complete ACL pages, conditional no-follow pinning and original-key retirement. Root and cwd descendants retain distinct original provider branches; no request supplies provider handles, mounts or replacement routes. The consumer retains its candidate key before submission. VFS counts the original owner and reserves both provider correlations before effects, fences replay across the complete nonzero key domain and preserves unknown outcomes for cleanup. Native write ceilings precede permission observation. Every ACL page retains full target/object/revision/ordinal correlation and forwards its entries in place. Cleanup uses the original pre-reserved correlation without needing a returned handle. Private whole-scope revocation disables new use and attempts every child before disposing either anchor, so consumer loss cannot strand independently owned candidates. Public Close refuses live children; native delivery and receiver custody still settle independently. Five shared-wire and seven actual VFS dispatch/state controls are authored and unrun. They cover literal framing, raw names, scope/branch isolation, lost replies, uncertain cleanup, exhaustion, ACL pages and whole-scope revocation. Existing custody regressions remain; fixture-only acquisition helpers are removed from production builds. Refused owner insertion leaves incoming custody with its original caller. Native adapter code is split by responsibility. Rustfmt was applied and component contracts/manual TeX are updated. A further source audit identified [premature scope-cleanup acknowledgment during native Close](https://git.erikinkinen.fi/erix/vfsd/issues/10). The original delivery remains counted, but its scope cleanup key is cleared before receiver disposal finishes. This non-security lifecycle report is open for implementation; no observed runtime failure or access bypass is claimed. Fixing that ordering is the next priority. [Full realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Posixd still needs complete retained path walking, parent/symlink/mount transitions, sealed credential mediation, conditional creation/append, final descriptor publication and ordinary fd serving. Native open/openat workloads and both full EriX guest-build generations plus the Rust/LLVM guest rebuild remain unfinished. This checkpoint adds no full-item acceptance: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred; no execution pass or measured speedup is claimed. Earlier evidence (historical; superseded where the current checkpoint above advances it): Native acquisition-scope preparation is implemented and published: [lib-ipc `ab4e18f6`](https://git.erikinkinen.fi/erix/lib-ipc/commit/ab4e18f6837bde4f3d7dcb0b7b5b532633ff403b), [vfsd `acc9a53a`](https://git.erikinkinen.fi/erix/vfsd/commit/acc9a53ae3f044b1c272d1010e04d84b0cc2b3d7), [launchd `53ff53ca`](https://git.erikinkinen.fi/erix/launchd/commit/53ff53ca206f15fdba52bee013647e56dc57dbce), [posixd `45976b69`](https://git.erikinkinen.fi/erix/posixd/commit/45976b69ba032fbbc73fdf1ffbeb1a0aae893a02), [exsh `5308ec15`](https://git.erikinkinen.fi/erix/exsh/commit/5308ec152020c8d087aaac3e16a77342c4d454c3), [integration `42f7d97b`](https://git.erikinkinen.fi/erix/integration/commit/42f7d97b649294881e16614e13186c40f3e1c04d), [docs `fe1cd7d7`](https://git.erikinkinen.fi/erix/docs/commit/fe1cd7d7805499162311c084d589771293a1d813). A distinct counted authority role connects public Launchd preparation, strict native scope transfer, VFS independent root/cwd ownership and sealed-client authority retirement. Root/cwd come from one actual held directory or live acquisition scope; preparation reopens no pathname and cannot widen its write ceiling. Every observation, acquisition and cleanup correlation is reserved before provider effects. Original source row, full generation, session and realm remain retained across lost replies, partial COPY and receiver disposal. Retirement disables new use before live children can delay disposal, while original child cleanup remains available. The generic broker mask and existing metadata/resize operations remain unchanged. The native binding workload now prepares one read-only acquisition scope per client, with twenty authority rows and a 1684-byte plan per realm. Original provider and capability storage are explicitly budgeted. Twenty new controls are authored and unrun: four shared-wire, eleven VFS ownership/intake and five Launchd source/public-lifecycle cases. Existing Posixd authority, Exsh transcript and Integration geometry controls are extended. [Provider correlation/cleanup](https://git.erikinkinen.fi/erix/vfsd/issues/8) and [descriptor-aware source fixtures](https://git.erikinkinen.fi/erix/launchd/issues/13) are resolved by implementation; no executed test failure or pass is claimed. [Full realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains unfinished: native component dispatch, per-component/final permission mediation, raw path traversal, creation/append and Posixd descriptor serving still require implementation. Completion remains 16.91% weighted, 21/460 parents and 441/902 sub-items; this prerequisite adds no full-item acceptance. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred by instruction. Both full EriX guest-build generations and the Rust/LLVM guest rebuild remain unfinished. Earlier evidence (historical; superseded where the current checkpoint above advances it): Independent acquisition-root checkpoint: [lib-ipc `4fefcc1f`](https://git.erikinkinen.fi/erix/lib-ipc/commit/4fefcc1fd32b5714212b50f6d4f4e817619314aa), [ramfsd `d9880325`](https://git.erikinkinen.fi/erix/ramfsd/commit/d9880325f564f8cf66ac0c861251624d1b7d8fd1), [e2fsd `d2943a01`](https://git.erikinkinen.fi/erix/e2fsd/commit/d2943a01417089c4e72d760c7a3079b9af3019e8), [vfsd `8c8b98d5`](https://git.erikinkinen.fi/erix/vfsd/commit/8c8b98d51a829af78c6b448c75de3a070f58eba5), [docs `55c7e640`](https://git.erikinkinen.fi/erix/docs/commit/55c7e640368869c8bf162e1ca51f0a301ca55b89), [integration `a9c3b6b1`](https://git.erikinkinen.fi/erix/integration/commit/a9c3b6b17c373796a2402af397504796ba120a0e), [rootd `72a63e1e`](https://git.erikinkinen.fi/erix/rootd/commit/72a63e1e11a7142ba2134a5ee92fb5a53010ac36). Private anchor cloning now reserves a mount-scoped original identity before submission and pins the actual held source directory without reopening a pathname. Ramfsd checks the source revision in one exclusive turn; E2fsd reserves counted handle capacity before media I/O, consumes original permission evidence and refreshes the complete live inode/ACL fingerprint. The resulting root has an independent lifetime, so source closure and a lost handle reply cannot erase its preknown cleanup identity. Mount fences prevent delayed replay, including after retirement of a key whose response was lost. Starting anchor retirement disables ordinary root use and new component acquisition. Existing child cleanup remains available; live children return BUSY before root disposal, and final original mount/key cleanup confirms absence idempotently without media or key I/O. VFS shares its noncopyable original-route owner and state machine across component and anchor calls while preserving separate operation families and root/component versus mount/anchor identity. Both call and cleanup correlations are reserved before submission; every original echo is checked, and uncertainty retains custody. Eighteen new controls are authored and unrun: four exact wire codecs, five Ramfsd state/dispatch cases, five ext media/dispatch cases and four VFS retained-owner cases. They cover source-independent lifetime, lost replies, cross-mount and cross-family refusal, stale evidence, replay/full-domain exhaustion, retiring-root denial and short outputs. Rustfmt was applied. Component contracts and maintained manual/API-reference source are updated. Published 56 signed commits across 55 repositories, selecting 206 Cargo and 111 catalog revisions. Rootd and both helper catalogs select the independent Rust helper `35f0b37ea8bb55f26fd52e0ae4fdee1449add810`. Read-only inventory covers 3432 code files in 76 repositories, all below one thousand lines; the largest changed source is 932 lines. [Full native realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Explicit native acquisition grant admission, counted source publication, VFS request dispatch, per-component/final permission mediation, creation/append effects, Posixd descriptor serving and complete native workloads remain unfinished. [Original correlation/cleanup follow-up](https://git.erikinkinen.fi/erix/vfsd/issues/8) stays open until that native preparation path uses the retained owner. Existing metadata/resize grants gain no new operation authority. No new acceptance credit is added: 16.91% weighted, 21/460 parents and 441/902 sub-items. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Both EriX guest-build generations and the external Rust/LLVM guest rebuild remain unfinished. Original VFS acquisition custody checkpoint: [vfsd `3ac14044`](https://git.erikinkinen.fi/erix/vfsd/commit/3ac14044390abe26dbe021815b6cb691e78a3592), [docs `ac19ea76`](https://git.erikinkinen.fi/erix/docs/commit/ac19ea76855e62c601cfb3054c12a723e0195b66), [integration `a31127bb`](https://git.erikinkinen.fi/erix/integration/commit/a31127bb457019796c389cd6b0e38e8282bd9c68). The internal acquisition owner now retains its original provider route and reserves separate call and cleanup correlations before submission. Counted noncopyable candidates bind the original VFS root row/generation, mount and provider root. All allocation families preserve their custody independently of metadata copies and native delivery clearing. Same-root directory selection, independent descendant pins and stale-selector refusal keep candidates tied to their originals. Public Close, direct record removal and private Launchd retirement refuse before provider or receiver disposal while a candidate retains the root. Unknown or malformed responses preserve the cleanup obligation. Retirement disables ordinary use immediately and uses its original root/key and pre-reserved correlation, without another allocation or the lost handle reply. The complete nonzero provider u32 domain is issued once. Checked pre-effect acquisition reservation is separate from the legacy terminal fallback, which remains necessary when earlier effects may have occurred without independent cleanup custody. [Correlation-exhaustion follow-up](https://git.erikinkinen.fi/erix/vfsd/issues/8) remains open until native acquisition grant integration and root preparation cleanup are connected. Fourteen new transport, counted-table and actual root-close controls are authored and unrun; two counter controls are migrated. Rustfmt was applied. Component contracts and maintained manual TeX are updated. Three signed commits and three catalog selectors are published; Cargo pins and the independent Rust helper `6315e904c9d8769829928bb35108090f38c6a059` remain unchanged. Read-only inventory covers 3420 code files across 76 repositories, all below one thousand lines; the largest changed source is 959 lines. This is internal ownership infrastructure. [Complete realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open: explicit native acquisition grants, per-component and final permission mediation, VFS dispatch, creation/append effects, Posixd descriptor publication/serving and complete native workloads are unfinished. Metadata and resize endpoints acquire no new operation authority. No new acceptance credit is added; weighted completion remains 16.91%, with 21/460 parents and 441/902 sub-items accepted. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Both EriX guest-build generations and the external Rust/LLVM guest rebuild are unfinished. Ext provider acquisition checkpoint: [e2fsd `7daf33ca`](https://git.erikinkinen.fi/erix/e2fsd/commit/7daf33ca06c509a955b64979feb88b9580862919), [docs `f77a2a5c`](https://git.erikinkinen.fi/erix/docs/commit/f77a2a5caf5c3657a6f397c0ce10b1772834f87b), [integration `a975a3e9`](https://git.erikinkinen.fi/erix/integration/commit/a975a3e96acdd2d30dfc766d9699e883f2cecde4). E2fsd now implements the private original-root acquisition and retirement family. It reserves counted handle capacity before media lookup, consumes the exact parent permission observation and checks its epoch and full live permission/ACL fingerprint before no-follow child publication. Conditional truncation shares that gate; cwd and acquisition share inode selection while preserving distinct name/result domains. Raw ext names retain actual format and configured casefold/encryption rules. Pre-submission cleanup identities, monotonic replay fences and independent descendant lifetime make cleanup possible without the original handle reply and prevent early root closure. Six new controls use original ext inode/directory bytes and actual dispatch, covering raw names, symlinks, independent descendants, wrong-root cleanup, alias refusal, stale revisions/epochs/fingerprints, exhaustion, short output, lost replies and consumed evidence after a missing child. Existing handle fixtures are migrated. All are authored and unrun. Rustfmt was applied; component contracts and maintained manual TeX are updated. Three signed commits and three catalog selectors are published, while the independent Rust helper remains `6315e904c9d8769829928bb35108090f38c6a059`. Read-only inventory covers 3416 code files across 76 repositories, all below one thousand lines; the largest changed source is 922 lines. [Complete realm open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Native source preparation, VFS candidate ownership, Posixd serving, creation/append effects and native workloads remain unfinished. No acceptance credit is added; weighted completion remains 16.91%, with 21/460 parents and 441/902 sub-items accepted. Tests, builds, lint checks, documentation generation, VM/profiler execution and CI observation remain deferred. Both EriX guest-build generations and the external Rust/LLVM guest rebuild are unfinished. Conditional provider acquisition checkpoint: [lib-ipc `bb5df3d2`](https://git.erikinkinen.fi/erix/lib-ipc/commit/bb5df3d21da19e585b5e0d4128cc84e103b43398), [lib-posixabi `cdc6eb9e`](https://git.erikinkinen.fi/erix/lib-posixabi/commit/cdc6eb9ebac4f8dace25fa3e2e5c78a42b450e3d), [ramfsd `ba8ea6da`](https://git.erikinkinen.fi/erix/ramfsd/commit/ba8ea6daaa1d0c6caa1baafff266c20c29fce8ed), [docs `d470ea50`](https://git.erikinkinen.fi/erix/docs/commit/d470ea50be9cf5b70491c99140ba4aa0e71bd60f), [integration `b9acf76b`](https://git.erikinkinen.fi/erix/integration/commit/b9acf76bba4967a139eaf16d666c8d05eb261482), [rootd `27835abd`](https://git.erikinkinen.fi/erix/rootd/commit/27835abda0a1356824ea462269fce68f0c048cdc). Compatibility 1.5 now describes Open/openat with raw borrowed pathname bytes and checked independent base, access, lookup, shared-status, inheritance and creation-mode domains. Private provider acquisition/retirement framing retains an original root and acquisition identity before submission. Ramfsd compares actual parent permission evidence and pins no-follow files, directories or symlinks in one exclusive turn. Cleanup does not require the original handle reply; retirement fences delayed replay without tombstone storage. Intermediate directory closure preserves independent children, and the original root cannot close while its pins remain. Eighteen new controls are authored and unrun: five compatibility codecs, five private-provider codecs and eight actual Ramfsd state/dispatch cases. [Ramfsd's live-handle helper types](https://git.erikinkinen.fi/erix/ramfsd/issues/3) and [stale compatibility-minor fixture expectations](https://git.erikinkinen.fi/erix/lib-posixabi/issues/4) are corrected from source observations. No compiler or test failure is claimed. Component contracts and maintained manual/API-reference source are updated, and Rustfmt was applied. [Full native open/openat](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open: native source preparation, VFS candidate ownership, other providers, Posixd serving, creation/append effects and native workloads are unfinished. No acquisition acceptance credit is added. Weighted completion remains 16.91%, with 21/460 parents and 441/902 sub-items complete. Both EriX guest-build generations and the external Rust/LLVM guest rebuild remain unfinished. Dynamic acquisition reservation checkpoint — 29 September 2026: [posixd `947d9852`](https://git.erikinkinen.fi/erix/posixd/commit/947d9852bc49ebda37ac71e6700786ef339425cf), [docs `e9cd7b00`](https://git.erikinkinen.fi/erix/docs/commit/e9cd7b00834b85ed22985bfa7b9389c18ac81577), [integration `730f6f1a`](https://git.erikinkinen.fi/erix/integration/commit/730f6f1a297d88f7a762217db2f88876d3794f29). Local fd and shared-description capacity is now reserved together before external acquisition. Pending numbers cannot perform I/O, and the empty source row retains its reserving process. Publication/cancellation correlates both complete generations; peer index changes and stale tokens cannot select a successor. Configured initial source installation uses the same implementation. [The cross-client terminal compaction defect](https://git.erikinkinen.fi/erix/posixd/issues/18) is fixed by interpreting descriptions only for the terminal client, preserving another client's pending new duplicate and original source hold. Five new reservation controls and one cross-client regression control are authored and unrun. Component architecture/roadmaps, the descriptor contract and maintained manual TeX are updated. Three signed commits and three catalog selectors are published; the independent Rust-helper identity is unchanged. Rustfmt was applied. Tests, builds, lint checks, manual/Rustdoc generation, VM/profiler execution and CI observation remain deferred by user instruction. [The complete open/openat acquisition issue](https://git.erikinkinen.fi/erix/posixd/issues/17) remains open. Native source preparation, conditional provider traversal/effects, actual sealed-client dispatch and the complete native workload are still implementation work. This checkpoint adds no checklist completion credit: weighted progress remains 16.91%, with 21/460 parent items and 441/902 sub-items accepted. No execution pass or dynamic open success is claimed. Predecessor: https://git.erikinkinen.fi/erix/posixd/issues/15. Related filesystem mediation: https://git.erikinkinen.fi/erix/posixd/issues/10. Owning review: https://git.erikinkinen.fi/erix/posixd/pulls/5. Native wire: https://git.erikinkinen.fi/erix/lib-ipc/pulls/2. Compatibility wire: https://git.erikinkinen.fi/erix/lib-posixabi/pulls/3. Phase tracking: https://git.erikinkinen.fi/erix/integration/issues/65. </details>
erikinkinen added this to the Alpha 1 milestone 2026-10-30 09:35:05 +01:00
Sign in to join this conversation.
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
erix/posixd#17
No description provided.