CE2 candidate: concrete original owner realm and catalogue acquisition

Status: proposed narrow amendment to CE1, not selected architecture, source authority, native qualification, provisioning, execution admission, or product completion. The exact CE1 review remains immutable and valid for its original proposal. No CE2 positive trust code has been implemented. A different whole architecture reviewer must assess this complete proposal and its original inputs after the Architect-Conductor selects the route.

Decision and exact counterevidence

CE1 required an independently admitted original owner/input action and conjunctive authentication of its original native producer AND every offered packet. That was a source implementation obligation, not just a missing runtime credential. At the original CE2 counterevidence checkpoint native-application.hpp declared configured/connect/originalAdmissionOwner without State or implementations. The subsequent independent transport continuation now defines a private already-owned channel/clock/end/owner State, connection carrier constructor, immutable getters, one-work bookkeeping and authenticated23 exchange. It still has no configured/connect/originalAdmissionOwner acquisition producer or importer; the carrier constructor cannot authenticate owner approval or provision a realm. original-input-lease.hpp reads a transferred original object and checks size/raw SHA/current identity/EOF; it does not authenticate approval. original-input-codec.hpp supplies G/C data readers. No current native source implements retainOriginalCoreOwnerInputs, acquireOriginalCoreAdmissionInputs, an authenticated owner realm, or an original catalogue acquisition type. Core-image registers the linked binding, but registration is not enrollment. The nineteen-command gap before operation19 implementation and the remaining eighteen after it do not provide an administrative action. Ordinary Core HTTP/MCP service:configure, trusted loopback gateway, filesystem ownership, native process image, provider MAC and initialized Journal cannot become source/qualification approval.

BLUEPRINT21 selects the provisioned native provider, 31 separates owner initialization from operations1..23, 41 requires actual original absent objects and initialized generation, 99 defines the existing thirteen-key initialization receipt, and 103 requires original independently admitted capability evidence. They specify the original owner action but contain no implemented identity/producer/control route. Existing scripts/verify-core-release-authority.mjs reads GitHub repository/develop/review/release-environment settings; it is a diagnostic, not native owner enrollment. ServiceProducerReleaseResolver uses a fixed GitHub publication realm and explicit owner catalogue pins; it does not authenticate Core native ROOT admissions. scripts/runtime-owner.mjs manages workspace runtime ownership and is not this source owner. None may be executed or silently promoted to the missing producer.

Read-only original gh API stdout is retained privately under _audit/core1643-continuation-oct05-01/private/ce2-github-original-read. Actual repository is public service-lasso/service-lasso, repository ID1201306193, node ID R_kgDOR5p6UQ, organization service-lasso ID273574457. Existing authenticated account wildone has user ID170312/node ID MDQ6VXNlcjE3MDMxMg== and actual admin role on this repository. These original reads identify an available EXISTING control-plane owner; they approve no ROOT, source/image, qualification, profile or runtime action. No credential bytes were extracted or retained. The projected terminal display mistakenly selected dictionary properties and showed nulls; the actual retained three complete bodies and MANIFEST have valid lengths/hashes and remain the evidence.

Repository body7444/SHA499ba3ac10242d2b4e005aeff828be885489aea399cb5467d1f206b48b6e7858; account body1294/SHA7aa1a39b7f29dfa490edc2b8a4feca91f7c2eb2e4ae608043972b8f66e3469d0; permission body1070/SHAcee333d988de080dd3356d68b0746dad95c8ff81bd472ca46a7dd2167588a53c. They are original gh output, not a qualified production native HTTPS capture.

Concrete proposed issuer and control route

Use the EXISTING repository source owner wildone/170312 in the EXISTING public GitHub control plane, not another actor, credential issuer, signer, key service or broker. The immutable source policy proposed for the original companion baseline identifies repository1201306193, owner170312, api.github.com, and issue1643. Selecting that policy requires the owner/conductor decision and different entire review; the metadata read alone does not select it.

The owner publishes an explicit closed admission decision as the original body of an issue comment in that repository/issue. It is not inferred from account membership, current admin role, a commit, PR approval, a label, green CI, a release, an arbitrary comment, or a source hash. A source review/approval and an original native evidence/assembly approval are separate decisions. Production importer code can READ decisions but has no HTTP write method and cannot issue its own approval. This author has not created any decision, changed repository settings, enrolled an actor, obtained/extracted a token, or activated a native resource.

Public decisions are retrieved anonymously from exactly GET https://api.github.com/repos/service-lasso/service-lasso/issues/comments/<positive decimal comment id>, with fixed source-owned media/API-version/user-agent headers, no Authorization/cookie/browser credential, no proxy/env-selected authority, no redirects, and no alternate host. The source-native HTTPS implementation must use a source-qualified TLS implementation and immutable source-selected CA trust bundle in the independently admitted baseline closure. It verifies the original live TLS server name/certificate chain and original response framing/EOF. A server response/body hash, OS mutable trust store, caller URL, cached JSON, transcript presented by a caller, or a previously successful gh invocation cannot replace that live original transport. No CA certificate/version/source pin is fabricated here. Exact original TLS/dependency source bytes and native qualification must be supplied before a positive baseline entry can exist. No production credential extraction is required.

The API envelope is GitHub's response, not one of the closed public proof schemas. Native code strictly parses bounded UTF8/duplicate-free JSON and verifies the exact comment id, selected issue_url/repository, immutable user.id170312/user.type User and original body/created_at/updated_at identity. Display login/author_association are not authority. Security-bearing envelope fields and exact original approval body must match the second live read after the complete offered objects are verified; edits, deletion, cross-repository response, redirect, issuer mismatch, failed original EOF or unresolved TLS lifetime invalidate acquisition. Unknown unrelated GitHub metadata may not acquire semantics. There is no offline/cached approval fallback. Approval is an original one-time acquisition fact; continuous global revocation after successful acquisition is not claimed or introduced. Loss/restart cannot renew that acquisition by replaying an old native handle.

Proposed approval body is exactly one closed canonical UTF8 JSON object plus LF, with keys schema,repositoryId,sourceOwnerId,decision,scope,packetSha256,packetBytes,producerSourceCommit,producerImageSha256,consumerSourceCommit,consumerImageSha256,baselineDecisionRef. Schema service-lasso.core-original-input-owner-decision.v1; repository/sourceOwner/comment references are canonical positive decimal strings, hashes lowercase64, commits lowercase40. decision approved/revoked. scope baseline_source/core_source/qualification/input_assembly. Source-only decisions require image fields null rather than inventing future image values; qualification/assembly decisions require actual image associations. baselineDecisionRef is null for the independent original baseline source decision; later records identify the genuine existing original baseline decision. No actual body/ref is supplied. The exact body parser uses the existing64KiB JSON body bound, depth16, token128, strings4096 and rejects unknown/duplicate/trailing input. This is a NEW PRIVATE realm codec subject to whole amendment review; it changes no profile, public API, operation1..23, shared proof or cryptographic preimage.

Each packet ROOT is a detached object: its authenticated decision is NOT a member whose bytes feed its own packetSha256. Later review custody may include both the ROOT and detached decision; that later review ROOT is not the subject of the earlier approval. This prevents source/comment/self-ROOT cycles. A SOURCE-only decision cannot approve native evidence, activate profiles, initialize storage, or grant lifecycle/release authority.

Independent baseline B and original producer

B is the SAME already-selected companion actor/image, with its existing separate original owner administrative mode implemented in source; it is not an additional launcher or broker. Its source and exact dependency/HTTPS/CA/original-object code are independently reviewed and admitted first under the existing owner. B code contains the proposed fixed owner-realm policy but embeds no own image digest, future Core A digest, completed P/G/C/Q/S/I, own qualification ROOT or own approval body. Actual B native/image/dependency qualification and detached owner decision are external original objects produced AFTER B source/build. They are not supplied in this context.

Only AFTER those genuine original B associations exist can a subsequent Core A source build include an immutable source-approved baseline entry identifying the actual B image/native dependency/source/owner closure and exact original baseline decision. Current entries remain EMPTY; no invented digest or guessed native qualification populates them. This is an explicit baseline dependency, not a mutable pin or an own-image/own-ROOT cycle. Core A source, provider source and final images then become independently source/native admitted; B accepts their external approval/qualification objects without recompiling future A/P hashes into B.

The eligible producer is original B's owner-input administrative action retainOriginalCoreOwnerInputs, running in its original held process/task/image/lifetime, after it has authenticated the original detached owner decisions and independently checked the complete original offered packet. Native UID/SID/process image/DACL prove original object/caller correspondence; they do not approve any packet. The eligible consumer is Core A's native acquireOriginalCoreAdmissionInputs exactly ONCE at bootstrap, before any positive admission constructor, reservation, native store/stage effect or profile use. Generic Core APIs stay available when no eligible baseline/input acquisition exists. HTTP/MCP/context/connect cannot enroll B, choose another issuer, provision a missing baseline, renew an acquisition, or import an approval callback.

The two independent conjuncts are mandatory: (1) Core A authenticates original B peer, native birth/owner/image/current executable mapping/dependency/lifetime against the independently admitted baseline, and B authenticates the actual Core A consumer against the owner-approved offered image/source association; (2) the original live GitHub owner decision approves EACH exact source/native qualification/publication/assembly ROOT offered by B, with complete transitive actual byte/source/commit/native-original references. Matching P/G/C labels, a parsed CatalogEntry, sourceSha, signed initialized Journal, provider HMAC or transport nonce prove neither conjunct. Native current mapped-image correctness remains the complete original selected custody predicate, not MEM_IMAGE/path or held file hash alone.

Private transfer and native constructors

Candidate original-object transfer uses a separately typed one-use CE2 bootstrap transaction on the EXISTING fixed companion endpoint, not an added endpoint/profile actor or an ordinary operation1..23. It has a distinct closed discriminator/version and no fallthrough to the command receiver. Existing companion D1 command greeting remains exactly80; key-provider greeting remains64; five provider preimages and23 commands remain unchanged. The exact bootstrap BEGIN/object/END/response grammar, original message/EOF separation, native peer-before-transfer and final closure require the whole CE2 source interface review before implementation. An END discriminator alone is never OS EOF. Windows original request-message boundary and final channel closure are distinct; Linux original socket write EOF is retained separately.

Linux source-native transfer carries only original read-only held FDs via the authenticated original channel using SCM_RIGHTS/MSG_CMSG_CLOEXEC, exact ancillary count/type and actual original received-object identity; no pathname imports authority. Windows source-native transfer uses actual original HANDLE duplication into the retained actual consumer process and original source/target handle correspondence; the exact PROCESS_DUP_HANDLE right needed by the selected transfer is explicit for review, not silently inferred from the existing QUERY/VM_READ/SYNCHRONIZE peer handle. No new host privilege/credential/system setting is requested. Raw duplication/control observations and original source/target process lifetimes are retained. Failure denies positive acquisition and retains actual outstanding IO/object custody.

P exact10/images5/provider5/11 capabilities, G exact6, C exact9, Q/S original Core21/sharedCLI18/10/11/13/primitive11, and I exact13 stay unchanged. OriginalInputObjectRead remains IO-only. The importer verifies every received original object's true raw count/SHA/EOF/stable held native identity/parent and exact source repository/full commit/Git framing/raw digest association, then the original owner/source/qualification/publication approval relations. No source directory name or generic source manifest can be converted into approval by hashing it. Whole original private proof reference/nested codecs remain required, not assertions in an opaque wrapper.

NativeOriginalInputImporter privately constructs NativeAdmittedCatalogLease only after BOTH conjuncts and complete current catalogue/publication/source/native associations pass. Proposed accessors catalogEntry() immutable decoded row; asset(Archive|Descriptor|Policy|Sums) const borrowed OriginalInputObjectRead; originalSourceAssociation(); originalQualificationAssociation(); originalPublicationAssociation(); referenceRuntime(); originalAllocationOwner(); checkOriginalCustody(). The retained lease owns OriginalOwnerDecisionLease, OriginalBaselinePeerLease, OriginalSourcePacketLease, OriginalQualificationLease, OriginalPublicationLease and four original asset leases. None is constructible from a JS value, decoded row, digest, pathname, callback or requested boolean. Names specify concrete source responsibilities, not implemented authority. NQ1's parser factory remains a data-level consumer pending this entire boundary decision.

NativeReferenceRuntimeLease identifies the exact original Node-carried V8/ICU source/build/dependency and original Unicode data association required by the >=22 semantic reference. It is within the existing source/image dependency closure, not another public image or profile key. Version text alone, std::regex, a substituted Unicode table, sorted JSON or source-only helper fixtures cannot establish the association. The separately owned NQ1 amendment must specify the full source-pinned port/compiler/Unicode/finite allocator implementation and private source codec before a positive parser route. This candidate supplies its original owner-held association/lifetime boundary, not missing V8/ICU implementation.

The original provider constructor independently receives its existing owner-authorized P/G/I/key-service lineage through the SAME original owner action and held object associations; it does not obtain source authority from its key. NativeProviderWorkspaceScope is privately constructed from original profile/workspace/provider/keySet/current-retained/init associations and retained native objects. It binds the original provider instance and original admitted companion/Core peer to exactly one selected workspace/provider realm. Endpoint names and RESOLVE_KEY matching strings are correlations only. Foreign workspace/provider/version deny before signing. Operation19 sends only the original S(actor)+S(raw key) body; provider workspace scope is constructor/native peer authority, never appended to the fixed SLTP-IDEMPOTENCY-1 preimage or hidden new request field. Current provider constructor/scope is missing source and remains required; the new real resolver implementation does not fill it by assertion.

Ordering, ownership, loss and rollback

Order: independently approved B source -> B actual source/native/HTTPS/dependency qualification -> detached original B approval -> Core/provider source importing genuine B baseline -> actual final A/provider images -> original native qualification and C/Q/S -> completed external P with independently resolvable actual qualification references -> explicit original owner provider/storage initialization I -> G/external input assembly -> detached original EACH packet approval -> original native B transfer -> Core importer -> original native constructors/command effects. Source-only input/candidate ROOTs and the original Template2b9aa7cd policy/inventory are not qualification. There is no current baseline, eligible approval, qualified four-asset native Template tuple or initialized resource.

No completed P/Q self-content hash cycle may be disguised by naming a ref. A qualification reference must refer to an actual original native observation/run/object whose authentic independently approved association is verified; the complete external proof bytes and owner ROOT approval are detached. A prospective ID, padded buffer or future receipt is not positive qualification. All source/build publication dependencies must be genuine original raw associations. No build/import/test/probe/provisioning is permitted merely because this order is described.

All HTTPS request/response/framing/parser/TLS/control metadata, ROOT/source streaming, transferred handles, original read/EOF buffers, bootstrap/command frames, outstanding borrowers and failed IO must be prospectively charged to the SAME independently qualified original owner. The source128MiB ceiling is preserved. No second128MiB allowance, uncharged fixed history, Node/V8 soft limit, GC/finalizer or logical descriptor close can report physical retirement. The full64MiB valid original capsule route and Windows one-message envelope must fit without duplicated67MiB allocations. Existing native Budget is bookkeeping; the complete physical owner/early native Node allocator and original bootstrap lifetime are unfinished. CLI N1 is not automatically Core authority. CE2 does not approve an unreviewed Core allocator/startup extension.

Original owner administrative acquisition needs a source-defined original native absolute-end producer and original domain/thread/lifetime before untrusted control/ROOT/network input. It cannot reuse a later HTTP token or mint now+40s after expiry. D1 exact originalHTTP authority remains unchanged. The exact administrative bootstrap time origin/source cap and physical preentry owner are explicit integration obligations in this whole decision; positive code cannot assume them from a Deadline value. The stopped original-clock-domain supplement lacks qualified DomainCustody and full64MiB history, and is not an eligible producer.

Loss, negative TLS/API decision, partial/extra/duplicate object/frame, native peer/image replacement, mismatch, disappeared ROOT/member, calibration/reference-runtime/source drift, expiry or failed final original IO closure invalidates semantic use. Actual original held objects, buffers, raw failure evidence and capacity remain retained through ended IO and last actual borrower; no reconnect/retry creates authority. Borrowed catalogue/parser references cannot outlive retained source/assets/runtime/owner. CLOSE never manufactures an independent receipt or FREE. Unavailable authority leaves the actual catalogue empty/native admission unavailable and ordinary Core intact; it does not excuse missing generic engine/store/recovery/materializer/observer implementations.

Rollback is source-level rejection of CE2: preserve exact CE1/current incomplete source and all failed/private custody; add no positive baseline entry or approval. If selected/implemented later, original acquisition failure performs no ordinary23 effect, no initialization, rotation, resource activation, target deletion or lifecycle. A later approved image/baseline change requires exact new source/native association and whole governing gates; mutable replacement is not permitted.

Required whole decision/review evidence

The conductor must decide the exact GitHub-owner policy, detached approval codec, independent SAME-companion baseline order, native HTTPS trust/dependency source, private transfer discriminator/framing/rights/caller and original ROOT/proof/source codec, bootstrap time/physical owner boundary and NQ runtime association. DIFFERENT whole architecture review must inspect ALL original25411, CE1/D1 decisions/reviews/current complete actual source, new original GitHub bodies, clock/NQ counterevidence and actual Node/V8/ICU/TLS dependency source used by this candidate. It must check spoofed repo/user/role/comment/body/commit-only/edited approval, missing original native Q, detached self-hash cycles, baseline dependency cycles, no native-memory identity substitution, source object replacement, failed handoff/EOF/closure, provider foreign scope,4 handles/64 versions and no secret raw-key capture, full64MiB/128MiB physical ownership, and unchanged public/shared/23/five-preimage contracts.

This decision deliberately records the remaining concrete interfaces whose whole specification must be reconciled before positive trust code; none is an opaque implementation callback or supplied runtime approval. It is a candidate for selection and further whole review, not a claim that the realm producer/bootstrap/packet codec/physical owner is implemented or that the entire product is review-ready. Independent owning command/effect source work continues under existing decisions.

Primary API references: https://docs.github.com/en/rest/issues/comments?apiVersion=2022-11-28 and https://docs.github.com/en/rest/collaborators/collaborators?apiVersion=2022-11-28 describe original comment/user/issue fields and repository permission reads. These support the transport/control-plane source design only; they do not approve this packet. Existing source publication and release authority are .governance/rules/gov-09-release-authority.mdc, scripts/verify-core-release-authority.mjs and src/runtime/release/service-producer-release-resolver.ts. No source/GA/native approval is inferred from them.

CE2 concrete reference-source and ownership reconciliation supplement

The conductor selected the detached existing GitHub owner route and independent SAME-companion B-before-A ordering as a candidate route on 2026-10-05. This selection is not CE2 architecture GO and supplies no authentic approval, image, provider, realm or native resource. CE1 and D1 frozen inputs/reviews stay unchanged. This supplement replaces a floating >=22 reference association with the following exact proposed reference source; it does not qualify a build or permit material trust implementation.

The reference is original Node22.23.2 commit aa4c77582be995286fc6e00aaf530dc7ade102a9 and root tree cee5f56eb6b8b6b8e300419196dc90e8c7abd64b. Complete original custody is D:/projects/service-lasso/_audit/cli39-node-startup-allocator-architecture-precode-oct05-01/original-node-source.git, FULL-ORIGINAL-GIT-TREE-ASSOCIATIONS.json, and original-raw-objects/<first2>/<GitID>.raw. The latter contains original raw object bodies, not only an extracted source subset. The immutable N1 candidate INPUT-MANIFEST.json has 75,551 associations; previous full byte verification is retained but is not represented as a fresh verification of every row in this supplement. Original extracted-source directory presence is not complete dependency custody.

The concrete proposed private HTTPS implementation source is the SAME Node-carried OpenSSL3.5.7 closure statically linked into the independent baseline B. VERSION.dat original blob a297eee91e1715c45386d63377541af4b0dfa86a is 99 bytes, raw SHA256 29fa590c7c24685a90d0f72401c8d65a23877a9e5986494d58eccd32c33d67ca. It actually names MAJOR3/MINOR5/PATCH7 and release 9 Jun2026; no guessed OpenSSL version is accepted. The immutable CA source is that exact Node source's src/node_root_certs.h, blob e3c77a175f9ccfa63fcb61ebed6d22f5b2d78364, 235,162 raw bytes, SHA256 b8381bf64c65982dc9e93e87489e98f25cc660cfe46bd0f53ffaf99154ac6aac. These three raw bodies including ssl.h.in were freshly read/hashed through original custody. Hashing the complete CA file does not constitute a full semantic review of every certificate; original PEM parsing/build-root lineage, complete cryptographic/source/dependency/mapped-image and native TLS qualification remain required.

ssl.h.in original blob e684f7c429750198bcdaae6f67a964b56efa8407 is 114,954 bytes, raw SHA256 ed4fb5f8bc85ca9450aa7ec9ac2a88cbf7dd9094d923ae24e09a604cf8649813. Original source declarations include SSL_CTX_set_cert_store, SSL_CTX_set_verify, SSL_set1_host and SSL_get_verify_result. The proposed TLS connection uses the exact embedded-root X509 store, peer verification with no permissive verifier callback, fixed api.github.com hostname and SNI, original complete chain verification result, actual native socket read/write/closure and complete original HTTP framing. It may not use mutable host CA stores, environment CA/proxy overrides, redirects, browser cookies, GitHub bearer tokens, another host, a verifier callback assertion, or the earlier gh transport as native TLS qualification. Exact native DNS/address, certificate UTC/time and earliest OpenSSL allocation/IO ownership still need complete source implementation and independent qualification. No native TLS call is executed here.

NativeReferenceRuntimeLease is a retained immutable SOURCE/BUILD association, not a live Node process by definition. It borrows exact original Node-carried V8/ICU/Unicode/build objects and exact generated-table lineage; arbitrary large source closures are not copied into an allocator arena. The NQ port's earlier23,918,937-byte bitmap representation is retained counterevidence; its newer compact original ICU topology/alias/generated-case route is still incomplete and unselected. Any eventual genuine generated backing, transient full/simple closure work and fixed table/control views remain actual resident owners with exact source-derived bounds; the immutable ICU source closure must not be mislabeled an additional runtime backing. Conversely, actual resident Core Node/embedder/ICU/TLS or live independent B objects, mappings, stacks, metadata and pending borrowers cannot be declared free because another type is named a source lease. If those owners occupy the SAME128MiB domain concurrently, every actual resident byte and rounding/control owner is included. CE2 currently has no proved source/lifetime basis excluding or sharing them.

NQ R2's latest known representation subtotal is 127,762,281 bytes, leaving 6,455,447 before the complete Core control/native-code/allocator rounding/lifetime calculation. This is arithmetic, not a new quota or a physical fit result. If a concurrently owned full ICU runtime backing of 33,107,424 bytes is required in that SAME domain, the sum is160,869,705 before further controls and cannot satisfy134,217,728. This is conditional concrete layout counterevidence, not a universal Node/RSS or OS impossibility claim. The later NQ optimization/stack-equivalence counterevidence also means its R2 subtotal cannot by itself qualify original successful RegExp semantics.

The data-level borrower ABI must preserve accepted metadata independently of quota: catalogue ownerApproval.repository and catalogSource.repository have no generic accepted byte limit; descriptorKind is not generically capped by the current runtime catalogue validator; configPaths is not assigned a new count/duplicate limit. A proposed source span therefore identifies an original held object slot/generation, original encoded offset/count, original decoded UTF16 count and encoding discriminator, all checked against that original object's exact length. The decoded catalogue can expose bounded scalar/path fields directly only where the original selected validator actually imposes their bound; unconstrained strings/arrays require original source-offset views and bounded IO/UTF16 iteration. No std::string copy, truncation, invented 128-item configPaths bound, normalizing replacement, or independently requested span can become source approval. The importer alone binds a span to an approved original packet and retained object; the namespace parser receives borrowed data and never an approval constructor.

No concrete physical control occupancy is asserted from sizeof a prospective span. Current ObjectIdentity contains a dynamic owner string, OriginalInputObjectRead contains actual native handles/metadata and EOF borrower, NativeJournal payload construction owns dynamic Json/map/string allocations, and TLS/runtime/control acquisition has unresolved original allocation hooks. The actual original allocation backend, page/stack rounding, object count, peak overlap, failure retention, outstanding OVERLAPPED/native reads, and final actual borrower retirement must precede a whole fit claim. The current logical Budget is not that backend. No fixed residual allowance, owner exemption or fabricated FREE is introduced by this supplement.

A semantics-preserving bounded IO alternative may move expanded file bytes to the existing engine-owned reserved native scratch/capsule storage and borrow held read windows rather than own a second64MiB resident expansion. Such a change requires exact original reservation/quota, scratch native object, true raw read/EOF/flush/readback, source equality, immutable association, match backtracking/read semantics and failure lifetime mappings before implementation. It is not permission for a new disk allowance, a replacement regex stack model, a narrowed original64MiB route, a second full envelope, or END-as-EOF. Current one-message Windows provider request geometry stays unchanged until a concrete whole private-geometry amendment is selected/reviewed.

The administrative original clock/time-origin, exact bootstrap BEGIN/object/END/native EOF grammar, original process duplication rights, source-qualified physical preentry owner, native immutable packet codec and complete whole128MiB fit remain visibly unresolved material CE2 choices. This supplement records selected concrete dependency candidates and original counterevidence, not a review-ready whole proposal or positive trust code. Independent actual command/store/native work continues; missing runtime grants are not represented as a source-completion exemption.

Exact domain clarification after source counterevidence

The conductor clarified the literal landed bound: source-safe-template-admission.md line438 reserves parser/stream copy allowance<=134217728 perCoreinstance and BLUEPRINT line37 repeats that instance parser/stream bound, not a universal entire Core Node image/RSS128MiB cap. This is preserved exactly; no second parser pool is created. Exact accepted CE1 line55 also requires the SAME original admission owner before C parsing and charges all current held leases/parser/copy/capture/runtime/IO/metadata. Both clauses must be satisfied by actual source-origin allocation classification and lifetime, not by naming ordinary runtime bytes unowned or silently revising CE1. Ordinary original runtime/image ownership must be independently finite-accounted with actual source-derived objects/allocations/limits and qualified capture; unspecified ordinary runtime implementation is distinct from a new normative parser limit.

Thus the33,107,424 ICU arithmetic above is conditional on a SAME parser-owner concurrent allocation, not a claim that any resident global Node image necessarily consumes that parser copy allowance. A nonresident immutable reference-source lease neither introduces that allocation nor proves a live runtime allocation absent. The current core-image.cpp actually creates a four-thread MultiIsolatePlatform and CommonEnvironmentSetup before native admission binding; native source/bootstrap allocations and compiled source/image ownership are not yet instrumented. No qualified binary/tool/runtime/profile supplies their original occupancy. The original generic Core behavior remains required; CLI's later8MiB runtime amendment does not alter this Core domain or license feature removal.

The owning stage upload, semantic validation, journal transition and provider phases need an exact real overlap model. Existing Core controller currently retains full raw stage/expanded entry Buffers and public-plan data, while the native namespace proposal has its own real parser/table/program/stack controls. A future native semantic consumer cannot silently overlap both full representations or claim a logical method return frees them. Actual original same-image borrower release, asynchronous worker/outstanding I/O, immutable catalogue/source leases, journal/provider signing storage and failed attempts must be represented prospectively. Source object spans are not a solution to the resident parser peak by themselves. No complete phase model, owner calibration or fit is asserted here.

Exact proposed jitless RegExp reference association

Core's existing selected static embedder jitless setting is retained. Original proposed Node22.23.2 flag-definitions.h Gitblob feb025c1d2061e19eeb4d1cf87ed97165faa1d51 (139725 rawbytes SHA256 d9d7be396dd2855dc8f55db9fafe895fb75329f872d072c6ae91b3597efd399c) line728 explicitly implies regexp_interpret_all from jitless; line2433 retains regexp_optimization default true. Original regexp.cc Gitblob482959a4e680cacda8449c250aac22fa175f94c2 (55397 rawbytes SHA256 2b0ceff003730878ba39405eb1c976fe8a212010d6625ab609f3a2c3145b81b2) line110 permits bytecode with interpret_all or tier_up. Actual original raw bodies were reread from retained whole Node custody, without executing Node/compiler/V8. Thus the proposed NQ reference association is the exact interpreter backend with its original optimization/bytecode/stack/error behavior, not an silently substituted native backend or unoptimized generic lowering. Build flags, source closure, generated Unicode bytes, runtime image and actual native eligibility still require independent original approval/qualification; source implication alone grants none. This adds no Core JIT/runtime amendment and imports no CLI human runtime change.

Fixed realm repository identity validation supplement

The comment API envelope's issue_url identifies a repository NAME/issue number, not by itself the selected immutable repositoryId1201306193. Consequently the proposed producer additionally reads the FIXED anonymous GET https://api.github.com/repos/service-lasso/service-lasso from the SAME source-selected GitHub/TLS/CA realm and strictly verifies its actual numeric id1201306193 plus original full_name service-lasso/service-lasso before treating a comment as this repository's decision. It repeats that original repository check alongside the second comment read after offered-object verification. The selected sourceOwnerId170312 is the explicit original decision issuer; it is NOT inferred from the repository owner's organisation id or current membership. Name reuse/recreation/redirect/id mismatch invalidates acquisition. This is an explicit additional PRIVATE fixed read route in the CE2 WHOLE candidate, superseding the earlier comment-only GET statement; it selects no actual approval, write/credential/new actor or endpoint resource. It must be included in whole source-interface/realm review before implementation.

The same genuine original native UTC observation dependency must supply source-owned certificate verification time to the selected OpenSSL chain verifier, with no supplied Date header/clock/locale or anonymous callback approval. Original system UTC, source image/task/domain, raw native return/FILETIME/timespec and monotonic correlation are retained privately; this does not prove external NTP accuracy. Native UTC capture remains a whole source/clock/API candidate to be reviewed, distinct from any Audit persistence amendment. Merely using SSL_set1_host/SSL_get_verify_result while silently trusting an unobserved mutable time source would leave a real native verifier producer gap. Exact source-carried X509 time API and dependency association must be read before implementing this interface; no guessed function declaration is admitted here.

Exact proposed native realm HTTP transport choices

The candidate request fixes Accept: application/vnd.github+json, User-Agent: service-lasso-core and X-GitHub-Api-Version:2022-11-28, matching the existing source release resolver's Accept/User-Agent and making its existing default API version explicit. Original GitHub documentation https://docs.github.com/en/rest/about-the-rest-api/api-versions currently lists2022-11-28 supported until10 March2028 and explains unsupported versions return410. The native producer must deny410/anynon200 and never silently select a successor version, alternate host or cached approval. This is a source-only proposed fixed policy, not an executed API compatibility/native TLS qualification.

The proposed source-owned OpenSSL transport requests HTTP/1.1 (no HTTP/2 parser/ALPN upgrade), Host: api.github.com, Accept-Encoding: identity and Connection: close, with no credentials or proxy environment. Complete original response framing accepts exactly one Content-Length OR one valid chunked transfer coding, never both, with actual original TLS/native read closure after the exact decoded body. Malformed/duplicate framing, nonidentity Content-Encoding, unsolicited protocol switch, redirect, truncated body, trailing application bytes and unavailable final IO/peer closure invalidate acquisition. Chunk terminator is not OS EOF. The body parser retains exact original API/decision bytes and all decoded chunk/native boundaries needed for genuine custody; TLS record bytes are not relabelled HTTP payload raw equality. Fixed bounded header/decoded body/control window geometry must be part of the same physical decision, with early denial before growth and truthful retained failure; current transport is not implemented by this text.

Original TLS certificate clock API association

Fresh FULL raw read/hash plus Git blob <length> NUL SHA1 equality binds original Node22.23.2 deps/openssl/openssl/include/openssl/x509_vfy.h.in Gitblobce9d7bb9b1ded81986c9a707cba234fb2f957748,34375bytes SHA2564525271ca522cda3eb5119f10f0daa7adeb4d5528176b1de42b5a49887349b86; original crypto/x509/x509_vpm.c Gitblobca66f78d2e4e0eb4b5be86f004f29d794a78f064,17880bytes SHA2560d2330f8f84e86a44009e5eeab68f78615af9673d89d1fe90314125fd245b59f. These complete original bodies are retained in the existing original Node raw custody, not refetched or executed. ssl.h.in's original SSL_get0_param declaration is also present in the earlier retained full source association.

Select candidate per-connection SSL_get0_param plus original X509_VERIFY_PARAM_set_time using the genuine native UTC observation converted with checked actual time_t ABI/range. Exact x509_vpm.c sets check_time and X509_V_FLAG_USE_CHECK_TIME; the header's NO_CHECK_TIME is explicitly forbidden. This bypasses no chain/hostname checks and provides no caller-supplied clock callback. The native TLS source keeps its unique verifier/context private, verifies the resulting parameter time/flags and admits only the actual qualified source/build/ABI, no truncated scalar or missing-clock fallback. Both setter and GetSystemTimePreciseAsFileTime are VOID: their actual source-native attempts retain raw output/definedness, not invented success return values. This is one concrete source API choice for the pending whole CE2 verifier, not a claim of authentic UTC/CA/source qualification or implemented positive TLS. Original TLS/output/control/crypto allocations and baseline mapped-image custody remain separate mandatory source obligations.

Selected internal uncompressed raw-Git archive candidate

The conductor selected ONE uncompressed raw-Git-object archive as an INTERNAL source-association carrier candidate, preserving all47300 original Node tree associations plus the actual original commit/root-tree/tag closure. This is not a fifth Template public asset, source approval, stronger hash-as-immutability claim, new actor or activation grant. The archive is built BEFORE its detached original ROOT/owner approval and excludes both, so later approval can bind its actual complete raw bytes without a self-ROOT cycle. Existing source-owner/publisher permission and source-qualified original build invocation must independently authorize the producer and output object; current eligible source producer/resources remain ABSENT. Ordinary Core HTTP/MCP cannot invoke construction.

Choose closed private SOURCE-01 codec for whole review. Header is112 bytes: ASCII16 SLCORE-SOURCE-01, U32BE version1, U64BE primary association count, U64BE additional original Git closure count, U64BE sum of raw Git body bytes, four zero reserved bytes, source tree-association manifest rawSHA25632 and additional-closure manifest rawSHA25632. Manifest objects are independently original held read-only source inputs authenticated by the detached source ROOT; archive embeds neither ROOT nor owner approval. Count/length/hash claims are checked against actual original files and source associations, never authority by header alone. No universal47300 cap is introduced: that is the actual selected source closure's count. Another eligible source tuple must have its actual finite count/representation qualified before construction/acquisition.

Records occur in EXACT original primary manifest order, then exact original additional-closure manifest order, without collapsing duplicate logical associations. Record prefix84: U64BE original section ordinal, U8 mode length, six original ASCII mode bytes padded with zeros, U8 closed Git object type, Git object identity20 raw bytes, raw bodySHA25632, U64BE raw body length, U64BE original UTF8 association path byte length. Then exact original path bytes followed immediately by exact ORIGINAL raw Git body. Closed object type maps tree/blob/commit/tag, with no executable filename or supplied native path interpretation. Primary mode/path/type/object matches the entire original tree manifest; additional records have their exact separately authenticated source identities and absent path/mode where applicable. Empty original blobs preserve actual zero body bytes/hash and require genuine final native EOF separately. The Git hash recomputes the original ASCII type + SP + canonical decimal body length + NUL + EXACTbody; no pretty serialization or text decoding of binary tree bodies.

Additional closure manifest candidate is closed UTF8 JSON: repository,commit,tree,tag,objects; objects are closed type,object,rawSha256,rawBytes in original declared order. Repository retains original nonempty source string as a streamed held span; commits/tree/tag/object retain their original40hex identities, tag nullable only where the actual source association has no tag, SHA256 lowercase64 and rawBytes canonical unsigned decimal string. This manifest records actual original bodies; it grants no source authority. Complete native reader validates duplicate identities/contradictions, original commit/tree/tag graph linkage, all tree modes/paths/object references, raw hashes/whole archive length, all original47300 associations and every offered original dependency/source origin. Unknown/trailing records, count overflow, malformed mode/type/path, changed object, unobserved/early EOF or failed closure retain denial and genuine originals. A source parser cannot accept a caller decoded manifest as independent owner approval.

Producer streams original source files/objects through pre-enrolled native read windows and one original output writer, checks original identities/bytes before/after, writes+flushes+same-handle full readback and final readonly immutable-object acquisition under its actual source-publisher scope. Publication/approval happens only after actual output/native source construction association exists. The source-qualified producer's output reservation, original input/archive overlap, failed/pending IO/rawhistory/metadata/closure and all physical retirement must be in the whole source/build execution input ROOT; no archive producer is executed here. A source-only approval is not execution permission or a generic catalogRoot write grant.

Consumer holds the one ORIGINAL readonly archive and both manifests with native write/delete exclusion/immutable byte/lifetime proof, performs full original SHA/count/EOF/source graph validation, and exposes borrowed member windows by original ordinal. It may keep a96-byte SourceMemberIndex record: five U64 ordinal/headerOffset/pathOffset/bodyOffset/bodyLength=40; rawSHA32=72; Git object20=92; U8 type/U8 modeLength/reserved2=96. Actual47300 primary records require4540800 raw index bytes before real rounding/control; actual three commit/root-tree/tag records add288 where that is the authenticated current closure. This is a representation subtotal, not a fixed allowance or count grant. Lookup may stream original manifest/path windows and retains its original offsets/leases; it cannot expand every repository/path string into unowned metadata or open47300 independent file handles as a hidden optimization. All resulting member borrowers retain original archive/object/source/clock/owner/IO association through use. Native readonly access plus matching digest alone does not prove lifetime immutability; missing actual source-owned exclusion/observations leaves acquisition unavailable.

Repeated Git object identities across distinct original logical paths/sections are permitted only with the EXACT same original type/raw length/rawSHA/body identity; the archive must preserve every logical association and its order. Contradictory repeated identities are denied. Native validation compares the original manifest mode string unchanged while separately interpreting actual raw tree mode bytes for graph linkage (for example original raw tree40000 vs manifest040000); it never rewrites the original Git body or hashes a normalized tree. Source paths remain association strings, not native filesystem-open authorization or symlink traversal. The selected actual source's additional commit/root-tree/tag objects remain original raw bodies under independent source authority; absent source submodule/external closure cannot be replaced with a marker.

SOURCE-01 immutable original archive: concrete Linux mechanism alternative, not a selected grant

The readonly-FD plus original full hash proposal still needs genuine lifetime immutability. Original advisory locks, chmod and stable fstat fields alone do not establish absence of writable mappings or later owner mutation. A concrete additional Linux candidate is producer-owned fs-verity on its genuine build output, before detached approval: enable through an O_RDONLY descriptor with actual inode write permission and no writable descriptors/mappings; then measure through the same retained original object and fully read/hash SOURCE-01 separately. The fs-verity digest is NOT the archive SHA256 and does not replace detached source approval. Later corruption may produce original read failure, never fabricated immutable bytes.

Official kernel source-contract documentation states that enable rejects writers including writable mappings, makes the file readonly and verifies subsequent reads; unsupported kernel/filesystem fails. Primary reference: https://www.kernel.org/doc/html/latest/filesystems/fsverity.html . This is read-only research, not executed enabling, filesystem configuration, new source authority or native qualification. Exact admitted kernel/filesystem/API/source/native stack/control/Merkle storage/build-output association and physical occupancy must be included before this can become a positive producer or consumer. The original current profile does not silently acquire a new capability or observer primitive because the API exists. Whole CE2 must explicitly compare this prospective mechanism with the original supported Linux resources, and retain incompatibility if it needs an unselected capability. No IMA/keyring/signature authority or external issuer is proposed.

SOURCE-01 actual original logical-entry geometry (data-only measurement; no archive produced)

Fresh size enumeration of every original47300 association against its original raw-object file found zero missing bodies. Original FULL-ORIGINAL-GIT-TREE-ASSOCIATIONS.json is8538357 bytes SHA2560e34b3a211537f7f1da81e8b95acbbede186e3d902329e4cc15be30431b9bd10. Repeated identities are preserved as separate logical records: total raw bodies629285786, exact original path UTF8 bytes2389354, record prefixes47300*84=3973200. With the112-byte header the primary section is635648452 bytes. This fresh enumeration checks sizes/presence and hashes the manifest, NOT a new SHA verification of all47300 bodies or an archive execution/acceptance.

The existing additional raw commit/root-tree/tag bodies are respectively2310/1916/1207 bytes, freshly hashed as987c2e150a94aff16e2c1ec110453d9ae3284c92973a8598ef84da0163132bbe /4982e1875ade00ba98a7217d31fe540440193a63a74ab014e745f196b17f832d /d4fa2ff25147a00d9526b007989ffe37cfa11f2ff076c9db5669a7c72eb6977a. Additional closure records have genuine empty path because their original additional manifest contains object associations, not invented filesystem paths. Their body bytes5433 plus three84-byte prefixes252 add5685, giving proposed exact archive635654137 bytes and aggregate raw body629291219. Header counts47300/3 correspond only to this actual proposed source closure, not a general accepted limit or granted resource.

This635654137-byte backing is greater than both the parser134217728 resident ceiling and stage-declared compressed reservation167772160 ceiling (not an observer/source archive cap). It must not be silently placed under either, or use capsule1073741824 as a general source-storage permission. Source-native archive output/input storage, kernel page-cache/Merkle backing, build write/readback/retained IO, failure overlap and all original readonly borrowers need their actual genuine producer-owned source/build object association and finite complete-owner classification. A nonresident file/window/index representation does not erase those real backing/kernel owners. SourceMemberIndex4541088 and one bounded read window are resident subtotals only; they do not prove the whole source object fits, native page cache is absent, or existing resources permit creation. No output archive, fs-verity enable, source producer, execution ROOT or calibrated physical grant exists here.

Conductor selection recorded: Linux fs-verity is now the INTERNAL SOURCE-01 archive immutability PRECODE candidate, contingent on exact original eligible task-owned filesystem/kernel/source-profile and native enable/measure/read APIs. The preceding alternative status is superseded only for candidate selection, not approval or implementation. Enable is restricted to a NEW task-owned archive produced by the genuinely eligible original source/build actor BEFORE detached approval; retained/frozen original source objects are never modified. Consumer retains the same original O_RDONLY object, direct native identity, actual verity measurement, full ordinary raw SHA/read membership and separate original source approval. Unsupported/mismatched resources deny without substitution. No ioctl, trust code, build/archive producer or filesystem mutation is executed. Exact native attempt histories, SDK/stack/control/Merkle/backing occupancy, construction overlap, caller/time origin and final borrower retirement remain required in ONE complete CE2 candidate before different whole review.

For a prospective sequential read of this635654137-byte archive with actual65536-byte full-progress reads, the data-read count is9700 plus one real nonzero-capacity zero-byte EOF read. Attempt144 subtotal is9701144=1396944; ArchiveIndex64 subtotal is970164=620864. These are ONLY those9701 data/EOF attempts, not all identity/verity/manifest/graph/window/member/TLS/native SDK/control/flush/close/archive attempts or archive generation witnesses. Original maximum primary path UTF8 length measured136 bytes; this can bound this independently approved exact source association's path input, never impose a generic catalogue repository/path cap.

The actual source reader must reserve/commit each original entered attempt and its SDK output/history borrowers before it occurs. A short native read is still real progress, with its own record; these full-progress arithmetic counts cannot become an assumed kernel guarantee, retry count, fixed history-dropping ring or acceptance grant. A resource-exhausted path must deny before the next effect and retain prior original custody. Construction of the separate new archive also has genuine input reads, output writes/flush/readback/EOF and verity effects; the9701 figure does not count or authorize those. Later original member-window access may add reads after the full archive pass, and its actual source graph/semantic operation count and archive/borrower/termination scope belong to the complete owner phase equation.

CE2 closed one-way native bootstrap transaction candidate

Conductor-selected administrative origin: the SAME B owner-input administrative source entry captures original native task/domain tick at its FIRST entry, before args/ROOT/HTTPS. Checked40s absolute end covers every subsequent queue/auth/import/expiry phase and cannot renew; this is a NEW private source implementation duration, not an existing normative administrative cap, a D1 HTTP fallback or a source-build duration. Source-build/archive construction uses a separate genuine governed build invocation/end. Actual native task/domain/sampler/physical-root source custody precedes the first sample, using the shared clock-owner join; unobserved JSON/end values cannot construct it. Windows checked QPC/frequency floor+one-tick semantics and Linux original CLOCK_MONOTONIC domain/lifecycle invariants are D1-compatible native APIs; no new public primitive or greeting tid is added.

The proposed bootstrap is one-way B→A, on the EXISTING companion endpoint. A connects to the original independently admitted B endpoint/peer; in the bootstrap branch B is the protocol initiator and A receiver. Endpoint client/server placement does not change this source-owned framing role. This is distinct from ordinary command mode, where A initiates existing23 commands. Private mode is selected by the owning bootstrap entry before ordinary NativeCommandSequence enrollment, never by a caller-controlled Operation or fallback after an unknown command. B first verifies actual original A peer/image/process/lifetime against the detached offered-packet/Core approval, without compiling future A hashes into B. A verifies B against the independently admitted actual baseline; current baseline registry remains EMPTY. Both retain actual original peer/source/clock/lifetime objects, not a supplied pid/image digest.

Bootstrap uses the existing companion80 greeting exactly: nonce32/capability32/original end8/frequency8. It does not change provider64. The greeting capability is source-private noncapturable; it authenticates framing, not source approval or a profile. A receives the original end only through original peer-domain/sampler/lifecycle adoption; no receive-time duration is minted. B's first administrative tick and immutable end remain owning clock observations. Expiry before source/API/packet validation consumes the attempt and cannot open a replacement bootstrap transaction.

Each bootstrap frame uses the existing companion length/body/MAC framing and SLCORE-ADMISSION-1 preimage unchanged, with sequence strictly0..count+1 and direction0 for B's one-way bodies. Its disjoint private body codes are0xf0 BEGIN,0xf1 OBJECT,0xf2 END, never values1..23 or their response codes. Separate bootstrap decoder validates only these exact shapes and cannot call decodeOriginalCommand. No provider-domain/version/preimage, public request/profile field, native operation enum, ACK or new endpoint is added. A generic ordinary channel cannot reinterpret those private codes as a bootstrap authority.

BEGIN body is exactly: codeU8=0xf0, sequenceU32BE=0, privateVersionU32BE=1, objectCountU32BE, originalInputRootOrdinalU32BE=0, originalManifestOrdinalU32BE=1, originalInputRootBytesU64BE, originalInputRootRawSHA32, originalManifestBytesU64BE, originalManifestRawSHA32. Zero/overflow count, absent ordinals0/1, contradictory source tuple or unexpected body length deny. Counts are exact original approved packet associations, not resource grants. Current native resource/cell/window reservations must admit those actual objects before any receive/duplication; the count field cannot grow a vector or set another quota.

OBJECT body is exactly: codeU8=0xf1, sequenceU32BE, ordinalU32BE, originalManifestEntryOrdinalU32BE, platformU8(linux1/win322), originalRawBytesU64BE, originalRawSHA32, originalProducerObjectObservationSHA32, nativeTransferredValueU64BE. Ordinals follow the original manifest order exactly, no missing/repeated/reordered object; identity/name/digest claims remain correlations until original native received-object validation and complete source approval. Linux nativeTransferredValue is exactly0 and exactly ONE SCM_RIGHTS FD accompanies this frame, received with MSG_CMSG_CLOEXEC; reject extra/unknown/duplicate ancillary data or truncation. Windows carries the actual duplicated target-process HANDLE value; no caller-selected pid/process/path opens an object. Full current native FILE_ID_INFO/held-object metadata and source-side duplication/target-side query observations are privately retained and correlated; objectObservationSHA alone is not that observation.

The referenced closed original transfer manifest determines role and exact raw association of each object; no OBJECT role byte can approve a row or choose an issuer. Its original root and every P/G/allC/Q/S/I/catalog/reference-runtime/baseline/source/member reference are resolved only by their exact source-owned closed readers and authentic source producer/owner relations, including the full original qualification/native SDK/proof graph. Missing referred object, unknown schema, duplicate/extra reference, unresolved source permission or failed native proof denies. SOURCE-01 is a held source association object, not inline635MiB bootstrap payload and not a newly granted native capsule/archive object. Object borrowing/mapping/control/kernel backing remains charged; one HANDLE/FD is not free memory.

END body is exactly: codeU8=0xf2, sequenceU32BE=objectCount+1, objectCountU32BE, originalInputRootRawSHA32, originalManifestRawSHA32. END completes only the exact ordered authenticated frame set. There is NO bootstrap response or ACK. After sending END, B ends its original bootstrap channel and IO once; A observes genuine final native channel EOF/closure before admitting the acquired object set. Linux retains real write-side EOF and final channel close separately; Windows must observe original ERROR_BROKEN_PIPE on a nonzero-capacity ReadFile after the final message. END, ERROR_MORE_DATA message termination, zero available bytes, queue-empty, cancellation or timeout are never EOF. Any subsequent data/frame, missing final EOF, failed native close, expired end, partial duplication or failed archive/effect handoff invalidates positive acquisition and retains actual original failures/IO/transferred objects. B's service process/lifetime remains the retained original peer after its bootstrap channel closes; process exit/replacement is not disguised by the channel EOF.

Windows transfer requires actual source-owned target OriginalPeer process HANDLE with PROCESS_DUP_HANDLE in addition to the separately retained QUERY/VM_READ/SYNCHRONIZE observations. The rights addition is explicit private CE2 source transfer dependency, not a granted privilege or a substituted caller handle. B uses DuplicateHandle from its actual held readonly source object into that exact retained A process, without DUPLICATE_CLOSE_SOURCE and without granting write/delete/execute access. A obtains its actual original target handle and verifies object type/rights/native identity/byte membership/source tuple before exposure. Source and target handle-cell lifetimes are separate, both pre-enrolled and retained through actual duplication result, archive correlation and once-close; duplication failure cannot drop an unknown partial acquisition. Linux sendmsg/recvmsg native FD transfer similarly preserves actual source/received open-file identity, flags, count and original ancillary raw result. All native stack/SDK argument/output/error bodies and pendingIO borrower slots are part of the SAME owner geometry.

This defines a concrete prospective private transaction, not an implemented initial authority or codec. OriginalManifest/native qualification nested readers, actual physical bootstrap reservation/source caller and complete SDK/role/lifetime layouts must be present in the ONE whole candidate. Authentic actual B baseline/P/G/C/Q/S/I/source/API/TLS/resources are still absent. No native connect/sendmsg/recvmsg/DuplicateHandle/ReadFile/build/enable is run; no private trust hook is added before different whole review. A failed or absent one-way acquisition leaves the ordinary Core API available and source admission genuinely unavailable, not a positive empty catalog or permanent final product stub.

Acyclic original transfer-manifest association candidate

The following closes the private carrier association, not the independent source-owner approval or native qualification readers. Object ordinal0 is the original input ROOT; ordinal1 is its original transfer manifest. Their OBJECT originalManifestEntryOrdinal is exactly0xffffffff, a reserved sentinel, and those two associations are taken exclusively from BEGIN and the detached owner decision. For each object ordinal n>=2, originalManifestEntryOrdinal is exactly n-2 and indexes its sole corresponding manifest row. No ordinary row may use the sentinel. objectCount is exactly2 plus manifest row count, with checked U32 arithmetic and an original pre-reserved object-cell admission before any duplication/receive. The sentinel is private codec structure and grants no object authority.

The proposed manifest is one closed canonical UTF8 JSON object plus LF with exactly schema,repositoryId,sourceOwnerId,producerSourceCommit,consumerSourceCommit,objects. schema is service-lasso.core-original-transfer-manifest.v1; repositoryId and sourceOwnerId are the fixed canonical decimal strings1201306193 and170312; the two source commits are lowercase40 actual source associations. Each objects row is closed with exactly ordinal,role,rawBytes,rawSha256. ordinal is canonical decimal string n>=2 in contiguous original order; rawBytes is canonical unsigned decimal string; rawSha256 is lowercase64. No row refers to ordinal0, ordinal1, a current approval body/comment, the manifest itself or an enclosing ROOT. No filename/path, supplied object handle, arbitrary decoded repository, extension field or JSON duplicate establishes approval. The raw manifest is borrowed from its original immutable received object; unconstrained metadata is not silently copied or truncated into a fixed string arena. Strict streaming closed parsing and checked counts precede role-specific native acquisition.

Closed role vocabulary for this candidate is profile,grant,calibration,qualification,sourceAssociation,inputAssembly,catalog,templateArchive,templateDescriptor,templatePolicy,templateSums,referenceSourceArchive,referenceSourceManifest,referenceBuildAssociation,baselineAssociation. These are locator discriminators, not new actors or replacements for original P/G/C/Q/S/I fields. Exactly one profile/grant/qualification/sourceAssociation/inputAssembly/catalog/four-template/reference trio/baseline row is required; calibration retains the complete original independently associated calibration set, not an invented one-row shortcut. Any further genuine original proof object is reached only through the original selected closed reference grammar and must be represented by a specifically reviewed role amendment; an unknown generic proof/extension row is rejected. This makes the proposed current coverage explicit rather than giving a generic JSON object implicit approval power. Exact native qualification subgraphs and SDK/clock/allocation measurement readers remain separate mandatory whole-candidate obligations.

The original input ROOT uses the EXISTING original ROOT association shape and hashes, with an additional proposed private transferManifest association (rawBytes/rawSha256) carried outside its original public/shared codec in the native importer envelope. The exact amendment is therefore an importer envelope, not a mutation of the original ROOT grammar: its closed keys are schema,originalRootRawBytes,originalRootRawSha256,transferManifestRawBytes,transferManifestRawSha256. schema is service-lasso.core-original-import-envelope.v1; counts are canonical unsigned decimal strings, hashes lowercase64. The envelope is bound by the detached input_assembly approval's packetSha256/packetBytes together with the original ROOT and manifest association; it cannot approve itself. BEGIN still names the original ROOT and manifest, not an envelope masquerading as an original ROOT. The approved packet carrier must supply its actual acyclic original ordered association of envelope+ROOT+manifest and objects before any positive importer; no concatenation/hash convention is inferred merely by naming this envelope.

This section deliberately records the remaining packet-carrier framing choice: a detached approval cannot simultaneously refer only to ROOT rawSHA while privately assuming it also approved a manifest not covered by that ROOT. The eventual exact packet framing must bind both objects and preserve original ROOT bytes without a self-reference. Until that exact source packet association is selected and independently reviewed, NativeOriginalInputImporter has no positive authority constructor. This is a source architecture obligation, not a request for credentials or permission to accept current metadata. No bootstrap trust implementation is introduced by these candidate schemas.

Exact detached packet association superseding the envelope alternative

Select a concrete source-private PACKET-01 association record instead of the preceding JSON importer-envelope alternative. The original ROOT grammar and bytes are unchanged. The actual detached input_assembly owner decision binds packetBytes and packetSha256 to the exact PACKET-01 bytes, NOT to ROOT alone, a decoded JSON digest, a compiled image, a comment envelope or the transport capability. This selection is prospective whole CE2 architecture only; there is no actual decision or approved packet.

PACKET-01 has exactly one CURRENT binary dispatch: ASCII16 service-lasso followed by three NUL bytes; U32BE version1; U32BE objectCount; U64BE originalRootBytes; rawSHA32 originalRoot; U64BE originalManifestBytes; rawSHA32 originalManifest; then the regular/directory kind rows specified below. The fixed prefix is104 bytes. The ASCII16 prefix is fixed bytes 73 65 72 76 69 63 65 2d 6c 61 73 73 6f 00 00 00 (thirteen printable bytes and three NULs). Root/manifest ordinals0/1 are represented only in that prefix; every ordinal>=2 has exactly one row in original manifest order. The current total is104+45regularManifestCount+9directoryManifestCount, checked before allocation. No names, handles, runtime outputs, current approval reference, PACKET digest or parent ROOT digest is inserted into a row. The earlier uniform44-byte row is preserved only in immutable historical inputs; no current decoder accepts it. Thus the record binds immutable object associations without its own digest or detached approval and has no self-cycle.

The B source producer constructs PACKET-01 from its actual immutable held ROOT/manifest/object raw count/hash observations and strict manifest role order, after validating the original approval/source/native conjunctions required for the offered objects. The owner explicitly approves those exact record bytes through the existing detached decision realm; an account, commit, repository role or producer digest alone never supplies that decision. Before bootstrap B reads the original owner decision twice under its original40s end and validates the same complete packet association. A independently reconstructs the exact record from BEGIN, the original received manifest and each actually validated received object; verifies the detached approval from the existing original realm and the independently qualified B producer; and compares exact packetBytes/rawSHA. The reconstructable current kind-row bytes are actual pre-reserved owner storage or checked bounded source windows, not a fresh authority object. The record itself need not be a duplicated object and introduces no OBJECT role/ACK/endpoint.

This supersedes the prior transferManifest importer-envelope alternative and the statement that packet-carrier framing remains unspecified. The original ROOT bytes, exact detached approval schema, BEGIN/OBJECT/END grammar, sentinel rule, native real EOF, P/G/allC/Q/S/I readers and original source/qualification/native proof obligations remain unchanged. Hash equality only establishes that the current original associations equal the specifically approved packet record; original held-native immutability, eligibility, actor/source approval and borrower lifetimes remain distinct necessary predicates. Positive trust code still awaits complete whole source decision and different entire review.

Original held directory transfer: explicit object-kind amendment candidate

The regular-object format above does not cover authentic workspace/services/storage/catalog root directory custody. OriginalInputObjectRead is a regular raw-byte IO adapter; directories must not acquire fabricated SHA256(empty), byteCount0 or authority from G route strings. Select a private OBJECT kind variant for whole review. This supersedes the uniform OBJECT body and fixed44-byte PACKET row for object ordinals>=2 only; BEGIN, END, companion80/provider64, existing MAC preimage, source actors and endpoint remain unchanged.

OBJECT common prefix is codeU8,sequenceU32BE,ordinalU32BE,manifestEntryOrdinalU32BE,platformU8,objectKindU8,producerObjectObservationSHA32,nativeTransferredValueU64BE. objectKind1=immutableRegular and2=heldDirectory. Kind1 suffix is rawBytesU64BE,rawSHA32. Kind2 suffix is directoryBindingObjectOrdinalU32BE. No raw-byte count/digest exists in kind2. The binding ordinal refers to a DIFFERENT kind1 original native directory-binding observation object whose approved raw association appears earlier in the manifest; unknown kind, later/self reference, contradictory role or reuse of a regular byte reader on a directory denies. Root0/manifest1 remain kind1 with the sentinel; each object still has exactly one original native FD/HANDLE transfer and genuine final channel EOF. The actual directory object is validated through original native object type/identity/source/parent/rights/lock/read-only discovery and original binding association, not by reading the binding file as its directory contents.

Manifest regular rows are now closed ordinal,role,objectKind,rawBytes,rawSha256 with objectKind immutableRegular. Directory rows are closed ordinal,role,objectKind,directoryBindingObjectOrdinal with objectKind heldDirectory. Extra directory roles are heldWorkspaceRoot,heldServicesRoot,heldStorageRoot,heldCatalogRoot; exactly one of each accompanies the selected G root associations. Their regular observation roles are workspaceRootBinding,servicesRootBinding,storageRootBinding,catalogRootBinding respectively, with original source/native proof readers and no parser-level approval constructor. A G pathname is only a required correlation, not a substitute for the original directory object. All declared bindings are checked against actual acquired root/native observation, authentic source grant, original ownership/exclusion and current unchanged root state before constructors can use them.

PACKET-01 retains its exact104-byte fixed prefix; each manifest regular row is encoded kindU8=1,ordinalU32BE,rawBytesU64BE,rawSHA32 (45 bytes), and each directory row is kindU8=2,ordinalU32BE,bindingObjectOrdinalU32BE (9 bytes). Exact packetBytes=104+45regularManifestCount+9directoryManifestCount, checked before growth. The earlier104+44N record is superseded by this explicit object-kind amendment; root/manifest raw associations are still fixed-prefix only. Directory binding raw observations are kind1 associations included in the specifically approved packet. Thus source approval names original directory-binding evidence while actual native transfer independently proves the held object matches it; neither conjunct is derived from the other. Future changing root/native binding cannot silently reuse a stale approval or mutate this original packet.

On Linux the actual transferred directory FD must retain the original source-selected O_DIRECTORY/O_RDONLY/CLOEXEC object, original device/inode/type/owner/mode and parent/name/namespace association, plus existing genuine exclusion/held lock custody required by the operation. On Windows the actual duplicated directory HANDLE preserves the source-selected access needed by the existing operation and original FILE_ID_INFO24/type/nonreparse/owner/parent/exclusion custody. The source producer cannot grant write/create/delete/rename authority by labeling a handle readonly; any required original write-side lock/effect handle remains separately authenticated under the genuine existing storage/service grant and source-native ownership. PROCESS_DUP_HANDLE adds only the previously explicit private transfer dependency. No caller-chosen process/path/access-mask, new profile right, directory write, grant provisioning or stronger immutability is inferred. Unknown or unavailable existing required root/exclusion resource denies construction while the full generic owning source remains required.

All regular binding bodies must use the reviewed O2 original object/performer/source/clock/SDK/borrower/namespace/exclusion codecs; an arbitrary JSON identity row cannot substitute them. Their exact actual source-owned native records and transferable lock lifetime are explicit constructor dependencies, to be supplied in the ONE whole proposal rather than a callback returning approved. This is a material prospective private codec/type amendment, no source/native implementation or authority. Root cells, transferred directory cells, genuine source-side lock holders and their failure/closure/kernel histories are additional actual owner extents in the complete geometry, never free because no directory byte payload exists.

Directory/exclusion and Windows source archive source choices

Current platform.hpp StorageLock explicitly rejects identity.directory and uses LockFileEx/flock on a held REGULAR admitted storage object. It is not a directory lock, whole namespace writer-exclusion proof, immutable-source permission or transfer-safe destructor. Its destructor retries release and its actual attempts are not joined to the proposed pre-enrolled owner/archive; those are source gaps, not evidence of authentic original closure. The candidate keeps directory roots, source-native namespace/exclusion observation and existing regular storage transactional lock as distinct owning objects. A transferred readonly directory FD/HANDLE cannot silently replace the original write-side transaction resource or assert that unrelated writers are excluded. Exact O2 namespace/exclusion association and source-qualified original access/grant predicates must resolve independently for each root before a positive constructor. No use of flock on a directory or LockFileEx on a directory is proposed as an unnoticed compatibility substitute.

Select a concrete Windows NEW-source-archive immutability candidate for whole assessment. The original source-build producer creates the new original regular output with its genuinely authorized write/read rights and FILE_SHARE_READ only, retaining actual original handle/FILE_ID_INFO/source/parent/birth and complete IO history. After exact write/flush/full readback/real EOF, it creates an actual read-only duplicate HANDLE to that SAME original file object with explicitly reduced rights; source-native duplication results/access/type/identity are observed, and every original write-capable handle and pending write/OVERLAPPED borrower ends once with actual closure before offering the readonly archive. The live original share mode continues to deny later write/delete opens while any retained reader remains; no path reopen gap, pathname hash or merely readonly attribute is used. The genuine qualified source/image/lifetime must exclude another unrecorded duplicate or write mapping, and actual original native rights must prevent write through every offered reader. Source/consumer handles and last-borrower/failure histories remain retained. Existing mutable frozen source files are not changed.

This is a selected private candidate algorithm, not proof Windows resources support it: exact DuplicateHandle reduced-right semantics, retained FILE_OBJECT share lifetime, security/token/source actor, no preexisting writable mapping, readonly handle granted-access observation, complete original closure and all physical/SDK/kernel effects require whole source/interface review and later native qualification. Linux fs-verity is a distinct selected native algorithm, not equated to share mode or advisory lock. Unknown semantics/resources deny rather than accept mere MEM_IMAGE/file identity or a new privilege. No native output creation, sharing/duplication/lock/ACL/verity effect executes before reviewed whole source and complete original execution admission. Primary API references for this candidate: Microsoft DuplicateHandle documentation https://learn.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-duplicatehandle describes source/target PROCESS_DUP_HANDLE, actual target-valid handle, explicit desired access unless SAME_ACCESS, same original object association and CLOSE_SOURCE even on error. The candidate forbids SAME_ACCESS/CLOSE_SOURCE for readonly source transfer, uses actual explicit rights and bInheritHandle FALSE. Microsoft CreateFileW https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew documents compatible sharing for each open handle until closure and write/delete conflict rejection. These primary descriptions support API selection, not a complete proof of the candidate FILE_OBJECT/share/mapping interval or a native granted-access qualification; that exact source/lifetime predicate still requires whole review and native originals. Both references were read-only; no DuplicateHandle/CreateFile/native effect ran.

Catalogue cardinality and per-entry asset association correction

The earlier wording requiring exactly one four-Template asset set is not the complete generic catalogue contract. Correct the candidate: profile/grant/Core qualification/source association/input assembly/catalogue/reference trio/baseline/root bindings retain their specifically selected source associations; Template asset rows occur as FOUR original regular associations for EACH independently qualified original catalogue entry. Empty actual catalogue is permitted and has zero Template asset rows; it means no-qualified-tuple, not fabricated approval or missing native authority converted to success. Multiple qualified entries remain supported without a new arbitrary catalogue count cap or default template. Runtime READ_ASSETS selects only a genuinely qualified original entry and its exact four held original assets/publication/source/native tuple, never another entry's row because a role name matches.

Template rows add exactly catalogEntryOrdinal to the closed regular manifest row shape; other regular roles forbid that key. The ordinal is a canonical decimal string indexing the ORIGINAL approved catalogue row order; role must be templateArchive/templateDescriptor/templatePolicy/templateSums. Each tuple has exactly one of each, raw associations equal its original source-pinned asset fields and complete qualifying native/publication approval. A decoded catalogue row/ordinal is only a locator until original importer conjunctions pass. Unknown/duplicate/cross-entry assets, reference to an unqualified row or contradictory native source/publication tuple deny. This adds a private source locator field, no public Template asset or profile/shared proof field.

PACKET-01 binds the exact raw manifest SHA/length, so the per-entry locator is authenticated by that specifically approved manifest without another directory hash or self-reference. Regular packet rows45 and directory rows9 remain unchanged; objectCount and checked exact packet length are actual approved association counts, not capacity grants or a one-entry native quota. Actual source-native pre-reserved object cells/view indices/source windows/control/failure/history and large catalogue metadata borrowers must admit the offered association set before effects; unconstrained original repository strings and catalogue count cannot grow default vectors or be silently truncated. The source-owned importer privately constructs NativeAdmittedCatalogLease with entry(ordinal)/assets(ordinal)/referenceRuntime/current immutable original tuple/custody views after all actual relations, rather than a constructible parser-approved single-entry wrapper. Catalogue and eligible tuples stay genuinely EMPTY in this delivery context because no authentic resources/approvals are supplied.

Complete original qualification-reference object associations

The earlier rule requiring a fresh role amendment for every additional proof object would leave the required full original Q/native proof graph untransferable. Select explicit private qualificationEvidence regular rows, closed with ordinal,role,objectKind,rawBytes,rawSha256,qualificationOrdinal,originalReference. qualificationOrdinal identifies an EARLIER kind1 qualification object; originalReference is the exact original closed proof/reference value in that original Q graph, preserved without renaming, path authority, a new public field or decoded approval. These rows are not generic extension objects: importer resolves every original required reference through its original closed Core21/sharedCLI18/closure10/launch11/inspection13/primitive11 and reviewed native-private association reader; unknown reference, duplicate/missing body, different qualification owner, inconsistent byte count/hash/native actor/source association or unreachable row denies. A body represented only by a digest/string/qualified label is not evidence. All required actual original raw/reference bodies must be present or remain genuinely unavailable; no unobserved original is fabricated.

The referenced body's exact codec is determined by the ORIGINAL containing proof contract/native API/source association, not an OBJECT role byte or a supplied arbitrary schema. Native raw Windows FILE_ID_INFO24/Node birth40, original Linux waitid/pidfd/task bodies, source/clock/IO/close/collector/readback and raw byte extents preserve their real original format/definedness/outcome/source actors. The native-private O2 nine association codecs and SDK variant readers remain part of the same whole architecture decision and complete source obligations; this role cannot approve an opaque JSON object or fill absent schema definitions by itself. Direct raw keys/keyHMAC/auth/confirmation/capability bytes and forbidden direct digests remain excluded; original111/217 mixed-secret and terminal alternatives are not waived by originalReference lookup.

Exact raw manifest binding covers qualificationOrdinal/originalReference, while PACKET regular rows stay45 bytes because the manifest association is already in the fixed prefix. Every actually offered proof object adds a real pre-enrolled native object cell/frame/index/window/borrower and source/kernel/closure history. Counts come from the exact approved complete graph and physical source admission, not a32-object universal cap, a single evidence body shortcut or a new raw quota. Complete unsupported/missing native evidence denies native qualification while ordinary Core behavior and generic full23 mechanisms remain required. This makes the complete transfer vocabulary represent original transitive proof inputs without elevating references or new markers into source authority.

Exact original-reference repair/build association

The selected segmented interpreter repair must be source-associated explicitly. SOURCE-01 retains all47300 ORIGINAL Node22.23.2 source entries and original commit/tree/tag unchanged. The owner-approved offered packet additionally retains the exact private repair source/build association as original qualificationEvidence members under the independently admitted reference-runtime qualification, with each actual originalReference binding its raw source member/body, source path and original patch/build relation according to the closed qualification reader. This is not an extra public Template asset, caller patch string, supplied runtime flag or digest-as-approval. The future source-qualified build consumes the immutable original source plus exact reviewed repair under its own genuine governed source-build invocation/end; it must identify the actual resulting source/build/image association instead of claiming byte-identical unmodified Node. BaselineB admission and offered-packetA approval conjuncts independently check that association. No patch application/build/tool/native execution or actual qualified reference image is authorized by selecting this prospective source repair. If complete qualification readers cannot encode the original repair/build member relation, their exact closed schema must be completed in this ONE whole proposal before positive importer code; opaque labels or a generic decoded source version cannot fill it.

The prospective source repair/build association reader is a NEW closed private source codec in this whole amendment, schema service-lasso.core-reference-build.v1, with EXACT9 keys schema,originalSourceArchiveRef,originalCommit,originalTree,originalTag,repairSources,buildDependencies,buildResultRef,outcome. Original commit/tree/tag are the exact retained full40 identities, and originalSourceArchiveRef resolves the genuinely held SOURCE-01 original-byte association. repairSources is an ordered source-owned array with exact6-key rows path,originalGitBlob,originalRawRef,repairedSourceRef,purpose,sourceDecisionRef. path is an original source path from the held source index; originalGitBlob and originalRawRef must resolve its exact original raw Git body, not a caller pathname. repairedSourceRef resolves the complete exact immutable reviewed source body (not an arbitrary patch callback or generated hash), purpose is source-fixed segmented-interpreter-stack/admission-allocation-owner, and sourceDecisionRef resolves the independently owner-approved exact whole source decision for that actual repair. BuildDependencies is an ordered array of original held source/tool/build-configuration/platform-SDK/ABI/immutable-CA associations, each exact3-key role,originalReference,qualificationRef; roles are source-fixed original-node-source,compiler,linker,platform-sdk,build-configuration,static-ca-source. Every originalReference resolves its genuine complete held body/byte window and every qualificationRef independently authenticates the exact governed build-source/tool association. No repository version string or guessed tool hash alone supplies qualification. buildResultRef resolves actual original governed build invocation and resulting same-image source/build/native qualification association, or null ONLY when outcome is unavailable; outcome success/unavailable/failure. Success requires all exact actual source decisions, tool/build closure, original native association and both existing approval conjuncts, never a decoded successful row. Currently no such authentic positive record exists. Array counts derive from exact complete source graph and actual pre-reserved source/owner controls, not a new generic repository/string quota. This codec is prospective and requires entire architecture review; it changes no public proof/profile fields, source authority actor or raw/capsule/parser caps. This reference-build repair codec covers original Node source members only. Core static embedder/application source retains its separate complete Core tool/source qualification association under the original profile tools and source-approved offered packet; it cannot be relabelled an original Node source member or assigned a fabricated original Git blob.

CE2 complete private native geometry carrier candidate (not a calibration grant)

C9 measurementRef resolves a proposed immutable held source-private record with EXACT9 keys schema,actor,profileDigest,sourceImageSha256,sourceAssociationRef,nativeBuildRef,sourceProgrammeRef,geometryRef,outcome. schema is service-lasso.core-native-measurement.v1; actor/profileDigest/sourceImageSha256/sourceAssociationRef must equal the SAME independently authenticated original C/P/source associations, not a new issuer. nativeBuildRef resolves the original complete governed native build/SDK/ABI/image association; sourceProgrammeRef resolves the complete reviewed owning source callgraph, entered-call loops, phase counts and original failure/retirement branches. geometryRef resolves the actual original native geometry observations. outcome is success/unavailable/failure; null nativeBuildRef/sourceProgrammeRef/geometryRef is permitted only for unavailable, and success requires all three genuine original associations plus the existing producer AND offered packet approval conjuncts. A successful parsed record is never a constructor grant or fit assertion.

The geometry carrier is EXACT8 keys schema,nativeBuildRef,sourceProgrammeRef,platform,abi,allocationClasses,nativeObjects,sourcePhases; schema service-lasso.core-native-geometry.v1. platform is win32/linux and matches original admitted image/kernel/filesystem proof. abi is EXACT8 keys pointerBytes,sizeTBytes,wcharBytes,ulongBytes,pageBytes,reservationBytes,byteOrder,originalObservationRef; all sizes are positive canonical U64 decimal strings checked against original native target ABI and actual held observations, byteOrder little/big. A single supplied numeric tuple cannot establish that ABI. Source-fixed allocationClasses rows are EXACT7 keys classId,sourceAssociationRef,recordBytes,alignmentBytes,roundedBytes,backingObservationRef,retirementProgrammeRef. classId resolves a reviewed source-owned record/backing class (never arbitrary caller allocation type); the original backing observation and exact physical retirement programme are mandatory for positive rows. Rounded size is checked using authentic ABI/backend geometry and source record extent, not accepted as a credit.

nativeObjects rows are EXACT6 keys sourceApiId,originalObservationRef,maximumOutputBytes,nativeOccupancyBytes,stackAssociationRef,callProgrammeRef. Each sourceApiId resolves the reviewed fixed native callsite/SDK variant; original observations must cover its genuine output/kernel/view/stack/TLS lifetime and source programme, including failed/pending ownership. sourcePhases rows are EXACT5 keys phaseId,sourceProgrammeRef,liveClassCounts,nativeObjectCounts,originalObservationRef. Count rows are EXACT2 keys classId,count or sourceApiId,count respectively, each canonical U64 decimal and source-checked against COMPLETE simultaneously live source phase counts, not runtime-provided allowances. Duplicate IDs, omitted required source phases/classes, unknown native terms, mismatched original build/source refs and arithmetic overflow deny before owner enrollment. Full graph array counts derive from the exact independently reviewed source programme, not an invented universal string/body quota; carrier bytes remain borrowed held immutable original windows and are parsed with physically owned bounded cursors.

This NEW closed private measurement/geometry vocabulary is prospective whole CE2 architecture source, completes formerly opaque measurementRef structure, and must receive different whole review before positive readers/owner constructors. It adds no existing public profile fields, actors or authority; original C9 actor scope/core-admission allocationDomain stays unchanged. Separate publisher source-build qualification uses its existing genuine governed source invocation/resource authority and is NOT fabricated as a new C9 actor or automatically covered by parser128/stage160/capsule storage. No authentic measurements/qualification/positive carrier exist today, and source code definitions of these closed readers remain required after source architecture approval.

Current measurement dispatcher is EXCLUSIVE: service-lasso.core-native-measurement.v1 exact9 then service-lasso.core-native-geometry.v1 exact8/ABI8/classes7/objects6/phases5/counts2 as above. The earlier physical decision sixteen-key service-lasso.core-native-owner-measurement.v1 ABI5/pageGeometry3 qualified/failed/unresolved proposal is historical superseded, never fallback/current nested evidence grammar. Its mandatory full physical/SDK/stack/native allocation/history/23-programme obligations remain; current original sourceProgrammeRef/nativeBuildRef/observation associations must cover them completely or no positive owner constructor exists. No missing width/layout/attempt source is inferred from compact numeric keys.