Skip to main content

35  The Virtual Context ABI: Typed Pages, Cells, and Certificates

35.1 Chapter status

Field	Value
Chapter ID	virtual-context-abi
Part	Part II - Planning, Memory, Reasoning, and Execution
Status	conceptual
Manuscript maturity	v0.3 proof-program manuscript
Last updated	2026-07-23
Primary source records	31 assigned records spanning VCM and adjacent author sources, four pinned projects, QCSA, The Reflexive Router, retrieval and memory comparators, and three physical-memory comparators used only to define the abstraction boundary
Claim label	Design rationale
Evidence level	argument
Source queue	primary: vcm_public; supporting: eight author/project notes plus QCSA and reflexive_router_whitepaper; connector/recovery: vcm_editable, moecot; external comparators: graph retrieval, hierarchical abstraction, persistent memory, RAG, long-context use, citations, adaptive retrieval, OS-style tiering, and prompt compression
Source loading state	source notes: vcm_public, deterministic_capability_compilation, platonic_world_model, context_engineer, verification_bandwidth, viea, vcm_editable, moecot, spinoza, ext_graphrag_2024, ext_hipporag_2024, ext_raptor_2024, ext_mem0_2025, ext_rag_2020, ext_lost_in_middle_2023, ext_longbench_2023, ext_ruler_2024, ext_memgpt_2023, ext_alce_2023, ext_self_rag_2023, ext_longllmlingua_2023, cca_project, moecot_manifest_project, beastbrain_project, bugbrain_project, qcsa_whitepaper, reflexive_router_whitepaper, kernel_english_residual_compiler, ext_pagedattention_vllm_2023, ext_airllm_2023, ext_hf_accelerate_big_model_inference_2026; raw cache: vcm_public, context_engineer, verification_bandwidth, viea, spinoza; connector/recovery: vcm_editable, moecot
Test state	Exact bounded scaffold: 3 valid/5 rejecting admission-adequacy fixtures; 2 valid/9 rejecting resolver/certificate routes; 1 bounded four-project certificate/11 rejecting mutations; exact 39-theorem reachable 4-event materialization and 2-event mandatory-fault model with 8 composition splits and 73/73 rejected mutations; reachable 5-event certificate admission with 12 real certificate projections and 64/64 rejected mutations; 83 live Lean declarations under 6 targets; and QCSA’s mixed synthetic identity/address/certificate results. No deployed resolver, natural source-to-packet fidelity test, model-use observation, useful context advantage, transaction isolation, deletion enforcement, VCM-Bench run, or production transfer.

The executed merge combines two current record families:

• context ABI records, which ask whether context requests, addresses, versions, mounts, snapshots, materialization states, authority labels, adequacy requirements, leases, residuals, source refs, and typed faults are explicit;
• semantic page certificate records, which ask whether typed context cells, source bindings, omissions, loss contracts, permitted uses, authority ceilings, revocation states, transaction refs, and artifact refs survive representation changes.

35.2 Drafting guardrail

A context ABI is not the same thing as a working memory system. It is the record layer a governed stack needs before context resolver behavior, summary truthfulness, deletion closure, transaction isolation, verification adequacy, or model use can be tested honestly.

The argument does not ask readers to believe that a long-context model can use every loaded fact correctly. It asks a narrower systems question: when context is materialized for a planner, verifier, worker, claim ledger, or reader edition, what typed object, address, version, certificate, authority, loss, adequacy, lease, fault, and residual information must survive?

35.3 Human Reading Path

Concrete lens. The best-effort summary baseline silently omits the old restriction. The ABI exposes the frontier and returns a mandatory-field fault for release use.

A model can sound as if it remembers everything across a long conversation. A governed system has to be able to say what it actually gave the model.

The difference is the context interface. Instead of dumping “relevant text” into a prompt, the stack materializes typed context objects. Each object has an address, a version, a source boundary, an authority label, a representation type, a certificate, and a reason it is allowed to be used. A short summary, a redacted instruction, an exact quote, a claim cell, and a reader-edition paraphrase are not the same kind of object. They should not carry the same permission or evidential weight.

The static Context ABI is the interface for that discipline. The next context layer handles transactions, snapshots, mounts, taint, and deletion over time. The verification-bandwidth layer then asks whether the admitted context is strong enough for a particular claim.

The reader-level point is simple: context is not governed memory until it has an identity, a certificate, a lease, an authority boundary, and a fault path.

35.4 Problem

Between durable memory and a model’s finite working context lies a static translation boundary. A consumer requests a purpose, obligation, object or address, snapshot, representation, authority, use, adequacy target, budget, and freshness horizon. The system must disclose what it actually selected, transformed, omitted, certified, leased, denied, and left unresolved.

Without that contract, memory becomes anonymous prompt text. A retrieved passage, old conversation, graph neighborhood, compressed summary, redacted brief, policy excerpt, source quotation, and derived inference can all look like equivalent tokens. The stack then cannot reconstruct which durable object was consulted, which version was visible, which candidates were rejected, what was lost, what the model actually received, which authority or right applied, or which fault should have blocked use.

The Virtual Context ABI owns this static request-to-materialization relation. It does not own the durable store, dynamic commits, claim adjudication, or runtime effects. It owns the consumer-relative packet and the falsifiable certificate and receipt that connect a frozen request to actual emitted content. That is the difference between “relevant text was retrieved” and “a specific context object conformed to a bounded use contract.”

35.5 Why existing approaches are insufficient

Long windows, RAG, graph retrieval, hierarchical summaries, prompt compression, persistent conversational memory, citation systems, adaptive retrieval, and OS-style memory tiers can improve access or performance in bounded settings. None alone supplies a consumer-relative conformance contract for the actual packet placed before a model or worker.

Relevance is not identity. Presence is not use. A source link is not support. A signed certificate can describe the wrong source-to-packet relation. A bounded graph can conceal its frontier. A fresh and permitted packet can still be inadequate, poisoned, lossy, unaffordable, or ignored by the model. LongBench, RULER, and Lost in the Middle sharpen use and capacity limits; RAG, GraphRAG, HippoRAG, RAPTOR, Mem0, MemGPT, ALCE, Self-RAG, and LongLLMLingua sharpen retrieval, abstraction, persistence, citation, adaptation, and compression comparisons. Their source-reported results are not local ABI evidence.

The distinct systems question is whether an independently inspectable static contract can connect a frozen request, durable source state, candidate set, actual emitted packet, permitted use, and typed failure without laundering any of those steps into adequacy or support.

35.6 Core Claim

[virtual-context-abi.core, label: Design rationale, support: argument] The Virtual Context ABI should own the static, versioned, consumer- and purpose-relative request-to-materialization contract between durable memory and model-visible context. It resolves stable object, semantic-address, version, mount, and snapshot references into finite typed representation candidates, then issues a certificate and receipt binding exact source and field lineage, transformations, omissions and loss, provenance and taint, authority and rights, permitted and prohibited uses, freshness, lease, revocation, selection and omitted frontier, requested and observed adequacy state, costs, faults, and residuals.

Admission means only that the actual packet conforms to the frozen request and policy. It does not establish truth, verification adequacy, model use, usefulness, safety, or support. The ABI may deny, ask, abstain, refresh, broaden, narrow, or return a typed fault. It does not update durable memory, own transactions, infer execution authority, adjudicate claims, execute effects, or move support or release state.

Reader claim. A context summary may be faithful enough for one consumer and still be unsafe for another because omissions, authority, freshness, purpose, and adequacy are part of the interface.

Operational rule. Resolve stable object and snapshot references into a packet whose certificate names exact sources, fields, transformations, omissions, loss, taint, authority, rights, uses, freshness, lease, selection frontier, adequacy state, cost, faults, and residuals. Missing mandatory context returns a typed fault, never best-effort silence.

35.6.1 Worked materialization: the summary omits the one blocking fact

A planner requests a compact project-status packet for release planning. The materializer selects recent build and test records but omits an older unresolved rights restriction because it falls outside the default recency window. The resulting prose is fluent and factually consistent with its selected fields, yet it is inadequate for release use. The certificate exposes the omitted frontier and the request’s mandatory rights field, so admission fails with a typed context-miss fault.

A diagnostic consumer that asked only for recent build health could admit the same representation under a different purpose and support ceiling. The summary’s authority cannot exceed its sources, and a new materialization cannot silently erase taint or revocation. The local fixture families check admission, resolver, and certificate routes, but they do not establish natural source-to-packet fidelity, truth, useful model use, verification adequacy, or cross-store transfer.

The claim remains at argument. The source corpus supplies architecture and comparator vocabulary. The current schemas, 3/5 admission fixtures, 2/9 resolver routes, 1/11 bounded certificate suite, 31 finite theorem declarations, and mixed bounded QCSA results make selected failures addressable. They do not run a deployed resolver, validate natural source-to-packet fidelity, observe model use, establish useful advantage, or transfer across stores and models.

35.6.2 Strongest objection

A bounded graph snapshot and a richly typed handle can still be elaborate wrapping around the wrong memory. A certificate may bind every field and remain semantically incomplete, stale relative to an unobserved store update, or misleading about graph completeness. The answer is deliberately narrow: this chapter can require identity, boundedness, omission, lifecycle, authority, and revalidation discipline, but it cannot certify open-world completeness or truthfulness. Those stronger claims require a deployed resolver, durable-store recovery tests, paired source/derived evaluation, and an accepted evidence transition.

35.6.3 Transactions inside the context ABI boundary

A typed context object is only a stable interface if changes to the state behind it remain governable. This chapter owns the static request-to-packet relation: addresses, versions, snapshots, representations, source and field lineage, transformations, omissions, authority and rights, freshness, lease, adequacy request, actual emitted content, typed faults, and residuals. Context Transactions, Snapshots, Mounts, and Taint is the stable technical-detail owner for dynamic mutation: begin, read, write, mount, branch, merge, commit, abort, rollback, crash recovery, taint propagation, invalidation, concurrency, and closure across durable context state.

The placement preserves a necessary asymmetry. A transaction can commit correctly while materializing an inadequate or over-authorized packet; a well-formed packet can refer to state whose write, rollback, deletion, or crash recovery was incomplete. The ABI does not inherit serializability, durability, atomicity, taint completeness, deletion closure, or recovery. The transaction route does not inherit packet adequacy, representation fidelity, model use, truth, or permission to expose material. Both owners retain their sources, claims, proof targets, tests, fixtures, failures, evidence exits, support ceilings, IDs, and URLs. The publication nest creates no context correctness, runtime enforcement, support transition, deployment, or release result.

35.7 Mechanism

The ABI begins with a context request that names the task, address or address pattern, version requirement, mount scope, snapshot, representation need, authority ceiling, adequacy target, consumer policy, lease, and fault behavior. It does not return anonymous prompt mass. It returns a materialization receipt that says what resolved, what failed, what was omitted, which source refs were used, which representation was built, which uses are allowed, and which residuals remain.

The materialized object is typed before downstream layers can treat it as evidence, instruction, background, or executable constraint. Context can arrive as constraint cells, claim cells, decision cells, correction cells, event cells, artifact cells, exact excerpts, lossy summaries, redactions, abstractions, translations, or derived inferences. The type matters because a planning summary, a source quote, a reader paraphrase, and a redacted execution packet may share words while carrying different permissions and evidential weight.

A representation certificate binds each cell to source refs, omissions, loss contract, permitted uses, authority ceiling, validity state, revocation state, transaction refs, artifact refs, and residuals. The certificate is not a claim settlement. It is a use contract: a summary can be admitted as a planning brief without becoming evidence for a claim; a redaction can be safe for execution without being adequate for verification; and a reader-edition paraphrase can be readable without becoming a source quotation.

Faults are part of the interface. The ABI can report missing, unsafe, unknown, conflicting, stale, revoked, unauthorized, or unsatisfiable context instead of materializing best-effort prompt text. It can also say that a packet is admitted for use while leaving adequacy for a target claim to the verification-bandwidth layer.

Resolution therefore produces two linked facts before any downstream use: the durable object and snapshot that were consulted, and the bounded context object that was actually emitted. A consumer can reject either side independently. The store may be current while the handle is expired, or the handle may be well-formed while the selected representation is inadequate, over-authorized, or missing a declared frontier.

Before selection, the ABI retains the eligible candidate set: source objects, graph neighborhoods, exact excerpts, summaries, redactions, translations, abstractions, contradictions, and typed cells. Selection seeks the least sufficient packet under node, depth, edge, token, latency, privacy, authority, rights, and verification budgets. Rejected candidates, selection scores, limits, and the reachable but unmaterialized frontier remain visible.

Stable representation and field identities preserve source-to-packet lineage through paraphrase, reordering, merge, split, cache movement, readdressing, and atlas migration. Each transformation records what was normalized, inferred, redacted, aggregated, omitted, approximated, left unknown, or found conflicting. A certificate is therefore a falsifiable declaration about an actual source-to-packet relation, not a self-authenticating label.

The materialization receipt binds the request to actual emitted bytes or content, order, placement, truncation, cache state, retrieval route, costs, faults, and residuals. Instrumentation then keeps available, selected, delivered, attended-to, cited, relied-on, contradicted, and outcome-relevant context separate. A packet in the window is not evidence that the consumer used it correctly.

Every request, candidate, retrieval, transformation, certificate, admission decision, cache event, retry, human intervention, fault, cost, discard, downstream-use observation, and residual stays in the denominator. Material changes to source, snapshot, address atlas, policy, authority, rights, evaluator, environment, consumer, or target use expire affected receipts and require revalidation or an explicit residual.

35.7.1 Four planes, six identities, and orthogonal outcomes

VCM’s shorter public specification supplies a useful trust decomposition. The ledger plane stores immutable objects, versions, relations, validation, capability, retention, and materialization state. The fallible judgment plane proposes segmentation, discovery, contracts, semantic coverage, contradictions, and review. The smaller kernel plane authenticates obligations, checks authorization, pins snapshots, invokes bounded selection, filters faults, signs messages, and enforces coherence. The model plane receives the compiled packet and proposes text or actions; current external effects still pass through the runtime authority gate.

This split prevents deterministic-control theater. A kernel can enforce the wrong source-authority label perfectly. A semantic judge can identify the right obligation but cannot grant itself storage, disclosure, behavioral, or action authority. The trusted computing base and the larger trusted judgment base are therefore named separately, along with their independent failure and recovery routes.

Six identities keep dynamic state from masquerading as memory content: ObjectID names the governed semantic object; VersionID names immutable content and ancestry; RepresentationID names one task-relative view; ValidationID names one assessment under a snapshot, policy, authorization, time, and validator; PacketID names the admitted logical set before provider adaptation; and MaterializationID names the actual messages, bytes, tokens, prefix, or runtime cache. A revocation may invalidate validation, packet, and materialization without changing the historical object version.

The result contract is likewise a product of states rather than one success flag:

Dimension	Representative states	Boundary
adequacy	satisfied, unsatisfied, unknown	whether one representation meets one obligation
admission	final, provisional, deferred, rejected	whether and how it may enter this packet
feasibility	feasible, proven infeasible, unknown	whether the protected set can fit
optimality	proven optimal, bounded gap, best effort, not applicable	what is known about selector quality
compilation	ready/provisional packet, ask, abstain, deny, unsafe fit, retry	the caller’s next safe route
lifecycle	validated, stale/dirty, invalid, purged	whether an existing view may still be reused

A timeout cannot become proven_infeasible; an admitted planning brief cannot become adequate evidence; a best-effort packet cannot be narrated as optimal; and a purged cache does not prove that every descendant or trained influence was erased. Preserving this outcome algebra is more important than preserving the source’s exact enum spelling.

35.7.2 Retrieval-augmented generation is a governed pipeline, not a feature toggle

RAG is often described as “search, add passages to the prompt, generate.” That description hides the transactions that determine whether retrieval helps. The source corpus may be incomplete, stale, poisoned, unauthorized, or fragmented. The retriever may optimize lexical or embedding similarity rather than answer sufficiency. The ranker may drop the decisive contradiction. The context builder may truncate or reorder evidence. The model may ignore the passage, cite it decoratively, or synthesize an unsupported claim.

The original RAG architecture and Self-RAG are valuable comparators: one joins parametric generation with retrieved non-parametric memory; the other adds learned decisions about retrieval and critique. Neither removes the need for a typed retrieval receipt. The ABI should preserve at least six states:

1. available: the frozen corpus and candidate frontier that could have been searched;
2. retrieved: the exact objects and scores returned by each query;
3. selected: the items admitted after ranking, deduplication, rights, provenance, conflict, freshness, and budget checks;
4. delivered: the exact bytes, order, placement, and truncation visible to the model;
5. used: evidence that the consumer relied on, cited, contradicted, or ignored an item; and
6. outcome-relevant: causal or ablation evidence that the item changed the result.

These states support a Retrieval Transaction Receipt binding corpus and snapshot identity, access and purpose, query set, retriever/ranker versions, candidate and omitted frontiers, scores and filters, conflict handling, source-to-packet lineage, context placement, citation mapping, model and generation identity, cache state, downstream-use instrumentation, latency, cost, privacy, and residuals. A citation is not proof of use; use is not proof of support; support is not proof of truth.

Competent evaluation separates retrieval from generation. Test source recall and ranking on independently answerable queries; packet sufficiency and faithfulness against source documents; model use through controlled counterfactual insertion, removal, and contradiction; and end-to-end utility against closed-book, long-context, ordinary RAG, Self-RAG, graph, hierarchical, and oracle-retrieval controls. Include unanswerable queries, stale versions, poisoned passages, near-duplicate conflicts, authority violations, multi-hop tails, “lost in the middle,” and a positive control whose answer changes only when the decisive source is delivered.

Caching adds another distinction. Reusing a validated retrieval packet may save work only while corpus, policy, rights, query semantics, retriever, ranker, consumer, and freshness epochs remain compatible. A cache hit cannot inherit correctness from the request key. The receipt states whether the system reused candidates, a selected packet, physical KV state, or an output, and which invalidation checks ran before use.

35.7.3 Certified bounded graph snapshots

The historical-project lineage sharpens the static ABI at one seam: a context handle should not mean “whatever the graph returns now.” It binds one durable snapshot identity and digest, a monotone generation, a policy version, a revocation epoch, issuance and expiry, provenance, authority ceiling, permitted uses, and a revalidation receipt. Materialization selects a finite subgraph under explicit depth and node budgets and records the exact omitted frontier. The materialized context remains a derived, lossy consumer object; it is not the durable memory object and cannot silently write back to it.

schemas/bounded_graph_snapshot_certificate.schema.json and its bounded four-project fixture exercise this contract. CCA motivates the durable-memory versus context-materialization boundary; MoECOT contributes frozen slices, TTL-bounded context, graph overlays, and freeze/thaw discipline; BeastBrain contributes certified bounded graph snapshots; and BugBrain contributes generation-leased handles plus expiry, revocation, restore, and slice-validation negative cases. They are one local design lineage, not four replications.

flowchart LR
  Request["Context request"] -- "asks by task, address, version" --> ABI["Virtual Context ABI"]
  ABI -- "resolves static handle" --> Address["Address, version, mount, snapshot"]
  Address -- "binds digest, generation, policy, epoch" --> Snapshot["Certified bounded graph snapshot"]
  Snapshot -- "selects within depth and node budgets" --> Cell["Typed page or context cell"]
  Cell -- "carries source and loss record" --> Cert["Representation certificate"]
  Cert -- "permits bounded use" --> Packet["Materialized context packet"]
  Packet -- "orients work" --> Plan["Planning or execution use"]
  Packet -- "offers bounded support" --> Claim["Claim ledger or verifier use"]
  Packet -- "records influence" --> Artifact["Artifact or reader-edition use"]
  Packet -- "refuses unsafe use" --> Fault["Typed fault or residual"]
  Packet -- "defers claim fitness" --> Adequacy["Adequacy handoff"]
  Address -- "hands dynamic state to" --> Transaction["Context transactions, mounts, taint"]
  Adequacy -- "hands support sufficiency to" --> Verification["Verification bandwidth"]

How to read the static context flow: The flow starts with a context request, not an anonymous prompt append. The ABI binds addresses, versions, mounts, snapshots, typed cells, and certificates before context is materialized for a planner, verifier, worker, artifact, or reader edition. Dynamic memory events move to the transaction chapter, and adequacy judgments move to the verification-bandwidth chapter.

The important movement is from untyped prompt content to inspected context objects. A planner, verifier, worker, or reader artifact receives a packet that can explain itself.

35.7.4 Version-pinned semantic packets

The Platonic World Model refines the context snapshot into a bounded Semantic Packet. A packet carries stable Form-family handles and immutable Form versions; relevant Essence Contract clauses; nearby exclusions and boundary cases; context, world branch, valid time, and semantic basis; current propositions and defeaters; causal and action rules; qualified grounding adapters; authority constraints; permitted tools; unresolved ambiguities; and expiry or refresh triggers.

Minimality is subordinate to adequacy. The compiler may omit irrelevant graph structure only after mandatory safety, authority, ambiguity, defeater, and information-flow dependencies are present. A cached packet becomes stale when a semantic version changes preference, a grounding adapter is revoked or loses calibration, world state changes, a defeater activates, authority changes, a mapping changes, or the validity interval expires. Packet integrity therefore does not establish truth or sufficiency; it makes those questions addressable.

Deterministic Capability Compilation adds the execution-facing projection. A capability compilation packet carries the charter and field version, current scaffold or learned implementation, applicability region, semantic obligation ledger, proof and counterexample handles, authority lease, residual escrow, fallback, verifier budget, update clock, and invalidation triggers. Context is therefore protected compiler input: omitting a counterexample, authority limit, or recovery dependency can change the compiled capability even when the model and prompt appear unchanged.

35.7.5 Representation examples

The same source can produce different honest cells:

Representation	Permitted role	Boundary
Exact excerpt	Citation, quote review, contradiction check	Cannot be shown where authority or clearance forbids the source.
Lossy planning summary	Planning orientation and dependency discovery	Cannot become proof, citation, or support-state promotion.
Redacted execution packet	Worker instruction under narrower disclosure	Cannot be treated as the full source or as broadened permission.
Claim or contradiction cell	Claim ledger review and belief revision	Support state remains a claim-ledger decision, not a certificate side effect.
Reader-edition paraphrase	Human orientation	Cannot become source evidence or proof support.

These examples are design semantics. They are not evidence that a summary fidelity checker or deployed VCM service exists.

35.7.6 Stable identity, plural addresses, and semantic leases

QCSA separates the object a context packet refers to from the semantic path used to find it and the physical memory route used to materialize it. The ABI can therefore name a stable SOID while accepting several soft semantic virtual addresses from a declared atlas epoch. A request may stop at a coarse address when it is adequate for orientation, yet require deeper identity, temporal, policy, or evidential facets for a consequential claim or action.

A Semantic Address Certificate is a specialized representation lease. It binds the SOID or compositional expression to the occurrence, task, consumer, atlas epoch, weighted candidate paths, confidence, provenance, grounding, residuals, permitted and prohibited uses, authority ceiling, expiry, and migration refs. The VCM materialization receipt then adds the bounded graph neighborhood, omitted edges, source versions, snapshot, cache state, and physical retrieval route. Neither certificate claims the graph is complete or the selected object is true.

This distinction makes typed failure sharper. unresolved_identity, ambiguous_address, stale_atlas_epoch, cross_facet_conflict, insufficient_consumer_adequacy, and migration_unresolved are legitimate results. They should trigger broader retrieval, another question, fallback, abstention, or review rather than nearest-leaf coercion. The QCSA reference package now supplies a deterministic resolver/atlas fixture, certificate implementation, and one materialized context snapshot in the governed vertical trace. Full QCSA resolved all 180 seeded held-out records; the no-plural-facets ablation fell to 0.916667 object accuracy. The vertical trace also rejected ambiguous candidates and stale epochs before effect.

The identity-indirection ablation supplies the separate causal check: removing stable identity/address indirection reduced aggregate object accuracy to 0.900000 and migration compatibility to 0.400000, versus 1.000000 for both in full QCSA. The accepted transition is therefore synthetic-test-backed only for that exact non-core fixture claim. It does not establish a distributed registry, federation, credential truth, or the Virtual Context ABI core.

Those results support only the exact fixture mechanics. The corpus exposes template structure, no deployed VCM service exists, and context adequacy was hand-authored rather than measured on natural tasks. The active-question ablation found no decision benefit, and the overall matched-resource gate failed. The ABI should adopt the stable-identity, plural-address, certificate, typed-fault, and migration records without treating them as semantic-quality or production evidence; the core claim remains at argument.

35.7.7 Semantic pages are not physical inference pages

“Paging” appears at two different layers of the stack and should not be allowed to blur them. A semantic context page is a governed information object: a typed claim, excerpt, summary, constraint, decision, artifact, graph neighborhood, or other representation selected for a consumer and use. A physical inference page is runtime state: a weight shard, KV block, activation buffer, expert, recurrent state, draft state, or storage block moved among accelerator memory, host RAM, and storage.

Both layers use indirection, caching, prefetch, eviction, and faults, but their correctness questions differ:

Question	Semantic context page	Physical inference page
Identity	which source object, version, representation, snapshot, and semantic address?	which model/runtime object, tensor range, layout, precision, request, and memory-policy epoch?
Admission	is it relevant, adequate, permitted, untainted enough, and within the consumer’s authority?	does it fit, arrive before use, satisfy exactness or declared approximation, and remain compatible with the executing kernel?
Eviction	may this representation leave the working packet, and what omission or later refresh follows?	may these bytes leave this tier, and will reload, recompute, or fallback preserve the execution contract?
Fault	missing, stale, conflicting, ambiguous, unauthorized, revoked, or inadequate information	missing, corrupt, late, stale, wrong-layout, cross-request, out-of-space, or unrecoverable runtime state
Closure	record influence, downstream use, correction, expiry, revocation, and residual knowledge	release buffers, close transfers, invalidate caches, retain recovery state, sanitize protected copies, and own physical residuals

A VCM semantic address must never be treated as a device pointer or storage location. It can resolve through many physical stores and caches while preserving the same semantic object identity. Conversely, moving a weight or KV page from SSD to RAM to VRAM does not create a new source claim, grant authority, or make the bytes part of the consumer’s semantic context. The physical materialization path belongs in a linked runtime receipt, not in the semantic meaning of the page.

The bridge is explicit. A context materialization receipt can reference the runtime objects and costs used to build or serve it; a runtime memory policy can reference the authorized model, request, and context packet that caused a fetch. The two ledgers may invalidate one another where dependencies demand it. For example, revoking a model artifact can invalidate physical pages and future materializations, while correcting a source claim can invalidate semantic packets without implying that accelerator memory is corrupt. Neither ledger silently inherits the other’s identity, authority, or proof state.

This separation lets the stack borrow good systems ideas without confusing abstraction levels. Planner-guided semantic retrieval may inspire context prefetch; PagedAttention-style allocation may inspire efficient physical storage. Yet semantic adequacy cannot be proved by a cache hit, and physical correctness cannot be proved by a valid representation certificate. The word “page” describes a useful interface pattern. It does not make knowledge and tensor memory the same kind of thing.

35.7.8 Typed result continuity and the hot routing projection

The Reflexive Router extends the ABI in the opposite direction: not only must context enter a capability through typed packets, non-LLM and mixed-route results must re-enter context without being flattened into anonymous prose. A typed result packet preserves value and schema; route and implementation identity; input and dependency digests; valid time and recorded time; epistemic state; source and evidence refs; verifier state; effects and residuals; dispatch provenance; authority and privacy scope; and handles to the authoritative artifact, claim, transaction, or Chronicle records.

Rendering is downstream of this packet. A conversational sentence, compact UI card, planner cell, verifier view, and audit export may project different fields, but none becomes the authoritative record. The ABI must disclose omissions and prevent a compact rendering from erasing uncertainty, stale time, failed verification, partial effects, or a forced-route override. It must also keep result value separate from the model or tool’s narration about that value.

Routing may consume a deliberately small “hot projection”: operation type, entity and task identity, freshness, authority class, risk/effect class, capability requirements, budget, uncertainty, and context handles. That projection is a cacheable view, not a second truth store. Its cache key and invalidation set must include tenant, principal/authority, purpose, policy, source and schema versions, valid-time horizon, privacy class, and dependent field versions. Omitting those dependencies risks cross-tenant disclosure or stale route reuse.

No typed packet proves its own truth or usefulness. This paper contributes the continuity contract and failure hypotheses only; no production materializer, cache, or context-quality result is established, and support stays at argument.

35.7.9 Kernel packets as representation-aware context pages

KERC contributes a concrete packet family for consumers that want semantic context without discarding exact source access. A materialized Kernel page binds the Kernel language and tokenizer versions; compact tokens and expanded debug form; entity and concept-capsule tables; exact-object handles; source alignment; ambiguity and correction lattices; global, segment, and local residual refs; provenance; authority and privacy; and compatibility hashes for the compiler, renderer, verifier, registries, and core. The compact token stream is not the packet’s full information content.

Concept capsules are open-world context objects rather than excuses to expand one fixed ontology indefinitely. A capsule may resolve to a governed registry identity, define a local concept compositionally, remain an opaque term, or fall back to exact bytes. The packet says which route was taken and which consumer may rely on it. Stable identity is separate from a short local handle, runtime code, address, embedding, or display label, so codebook and tokenizer migration need not rewrite the represented concept.

Exact-object access is selective. Most reasoning sees a typed handle and minimal metadata; spelling analysis, quotation, code debugging, legal text, or identity resolution can request the protected bytes through a separately authorized expansion. That expansion becomes a new materialization with its own purpose, disclosure, cost, and taint receipt. The ABI therefore supports a compact reasoning view without pretending that exact source bytes vanished or were safe to expose everywhere.

A Kernel page faults rather than guessing when a residual state hash, concept definition, object, registry version, migration map, or source span is missing. It can request the missing dependency, materialize a less compressed explicit form, raise fidelity, or return to source. This preserves the Virtual Context rule that compactness and availability are not adequacy: the source proposes a representation protocol, not evidence that any KERC packet is semantically complete, cheaper, or useful to a real reasoner.

35.8 Interfaces

The public interface is a static request, candidate set, certificate, packet, receipt, fault, and residual relation. It is not a memory database or a permission token.

• Intent, Cognitive Compilation, and Planning own accepted purpose, obligation, consumer, and context demand. The ABI may satisfy or fault the request but cannot reinterpret or reprioritize it.
• Durable memory and knowledge-lattice owners supply stable objects, versions, provenance, lifecycle, and read snapshots. Materialization cannot mutate, merge, delete, supersede, forget, or train on durable state.
• Context Transactions owns commits, branches, mounts, taint propagation, invalidation, deletion closure, and dynamic isolation. The ABI consumes exact transaction and snapshot state without claiming those behaviors.
• QCSA and resolver components may propose identities and plural semantic addresses. Address confidence and graph position cannot grant truth, use, or execution authority.
• Verification Bandwidth and Scalable Oversight own adequacy and independent evaluation. ABI admission records only static request and policy conformance.
• Claim Ledgers and Spinoza own evidence, contradiction, belief, and support transitions. Source links, citations, certificates, and packet use cannot promote a claim.
• Labor OS and Runtime Adapters consume permitted packets and separately decide jobs, tools, approval, and effects. Context relevance is never capability authority.
• Security, Privacy, Rights, Licensing, and Publication owners decide disclosure, processing, retention, declassification, permitted use, and external release.
• Artifact Graphs preserve request, candidate, source, certificate, packet, cache, model-use, outcome, cost, fault, and residual lineage without certifying correctness.
• Resource Economics owns observed token, compute, storage, retrieval, compression, verifier, human, latency, recovery, privacy, and opportunity cost.
• Evidence States and Readiness Gates own support, quarantine, promotion, and release. Green resolution or admission has no direct support effect.

Minimum ABI and certificate fields include:

Record family	Representative fields
Context ABI record	request_id, task_id, semantic_address, version, mount, snapshot_id, representation_contract, authority_ceiling, admission_state, adequacy_state, fault_state, materialization_ref, lease_expiry, source_refs, residuals, audit_refs, non_claims
Semantic page certificate	page_id, cell_type, source_bindings, derived_from, transaction_refs, artifact_refs, representation_kind, loss_contract, omissions, authority_ceiling, permitted_uses, validity_window, verification_state, revocation_state, residual_risks, non_claims

35.9 Invariants

• Every materialization binds one frozen consumer, purpose, obligation, object or expression, address policy, source and snapshot scope, representation need, authority and rights ceiling, use contract, adequacy target, budget, horizon, and support ceiling.
• Durable identity remains distinct from name, position, embedding, semantic address, graph position, storage location, representation, packet, retrieval route, physical route, and support state.
• Source and field lineage survives every representation change; each field is preserved, transformed, split, merged, omitted, rejected, or residualized with reason and consumer consequence.
• Every bounded selection stays within declared limits and discloses the exact selected denominator, rejected candidates, omissions, and reachable but unmaterialized frontier.
• Summaries, redactions, translations, abstractions, and derived inferences cannot widen authority, rights, purpose, use, evidence, effects, support, or release beyond their sources.
• Loss, uncertainty, conflict, approximation, provenance, taint, permitted and prohibited uses, expiry, revocation, and residual risk remain explicit and consumer-relative.
• A certificate is a falsifiable declaration about an actual source-to-packet relation; presence, signature, digest, address confidence, or graph position is not truth or adequacy.
• Resolver conformance, freshness, representation fidelity, admission, adequacy, model use, usefulness, safety, and support remain distinct states.
• Mandatory misses and material ambiguity produce blocking typed faults; optional absence, low confidence, or infeasibility remains a request, fallback, abstention, denial, retry, or residual.
• A handle binds exact snapshot identity and digest, generation, policy, revocation epoch, provenance, issue and expiry time, revalidation receipt, and permitted use.
• Revoked, expired, stale, policy-mismatched, migrated, tainted, or materially changed sources and packets cannot inherit current admission, adequacy, or support.
• Materialized context is a finite derived consumer object and gains no write, merge, deletion, supersession, training, or execution authority.
• Actual emitted content, order, placement, truncation, cache state, and consumer-visible packet remain inspectable; requested or selected context cannot substitute for observed delivery.
• Available, selected, delivered, attended-to, cited, relied-on, contradicted, outcome-relevant, and support-bearing context remain different states.
• Every candidate, retrieval, transformation, validation, retry, cache event, intervention, failure, cost, discard, use observation, and residual remains in the denominator.
• Lower tokens, faster retrieval, higher recall, more citations, longer context, cleaner summaries, zero release, or fewer faults do not establish fidelity, adequacy, usefulness, safety, or total-cost superiority alone.
• Finite schemas, synthetic fixtures, bounded graph records, reversible local traces, and finite theorems establish only their exact scopes and cannot universalize context quality or transfer.

Together, these invariants keep memory from turning into an untyped prompt append. A context packet may be useful, but usefulness is not enough. The stack must also know which source object it came from, which representation was chosen, which authority survived, which losses were declared, which uses are permitted, whether a lease or certificate has expired, and whether a typed fault should have blocked the packet before a model, worker, verifier, claim ledger, or reader artifact consumed it.

35.10 Failure modes

These failures fall into four connected families: identity loss, semantic loss, authority drift, and misleading evaluation. A packet may look coherent while failing in more than one family at once—for example, a stale summary can carry the wrong source version, omit a decisive qualifier, retain an expired grant, and still receive a favorable retrieval score. The list below names those families at the point where a consumer encounters them.

• Anonymous-context laundering collapses sources, versions, roles, and permissions into flat prompt text.
• Identity or address laundering treats a name, embedding, nearest node, semantic path, graph position, or physical route as the durable object.
• Stale-handle laundering reuses an old generation, expired lease, revoked epoch, migrated address, mismatched policy, or unvalidated slice.
• Summary or compression overconfidence hides qualifiers, negation, quantities, time, authority, citations, contradictions, minority evidence, or reconstruction burden.
• Provenance and field-lineage loss severs a packet from the source objects, transformations, omissions, and consumer consequences that bound its use.
• Authority, rights, privacy, purpose, or license escalation through summarization, redaction, translation, caching, federation, or similarity widens use beyond the source grant.
• Certificate theater treats complete fields, a signature, digest, self-validation, or round trip as proof that the declaration is truthful.
• Graph-completeness laundering hides rejected candidates, selection limits, unreachable material, or the omitted frontier and narrates a bounded slice as the store.
• Admission laundering treats relevant, well-formed, fresh, or permitted context as adequate evidence for the target claim or decision.
• Presence laundering treats context in the window as selected, attended to, used correctly, or outcome-relevant.
• Retrieval and citation laundering treats recall, a source link, or citation count as entailment, contradiction handling, or claim support.
• Poisoning, conflicting sources, malicious instructions, future-answer leakage, and taint enter packets without quarantine or consumer policy.
• Mandatory misses, ambiguity, or infeasibility are silently replaced with nearest matches or hallucinated clean packets.
• Cache and invalidation laundering serves content after source, snapshot, atlas, policy, authority, evaluator, or environment change.
• Durable-memory/context conflation lets a lossy packet overwrite, merge, delete, train on, or become the durable source without separate authority.
• Failure and selection survivorship removes rejected candidates, retries, stale reads, compression losses, cache misses, human repair, faults, or residuals from denominators.
• Efficiency theater reports fewer tokens, lower latency, higher retrieval, or longer context while omitting verification, human, privacy, recovery, missed-help, and opportunity cost.
• Portability theater infers cross-model, language, modality, memory store, organization, jurisdiction, threat, or temporal validity from one synthetic resolver and internally authored corpus.

35.11 Minimum Viable Implementation

The current minimum is a static record-and-route scaffold:

• public context ABI, packet, adequacy, transaction-reference, semantic-page certificate, and bounded graph-snapshot schemas;
• three valid and five rejecting admission/adequacy fixtures;
• two valid and nine rejecting resolver/certificate routes;
• one bounded four-project certificate and eleven rejecting mutations;
• reachable four-event materialization and two-event mandatory-fault witnesses with fifty-five independently rejected mutations;
• sixty-one live Lean theorem declarations grouped under six targets; and
• QCSA’s exact bounded synthetic identity, plural-address, certificate, migration, and typed-fault results.

The fixture families reject admission-as-verification, conflict promotion, stale use, mode confusion, open deletion, address/version/snapshot/mount mismatch, expired reuse, source-binding mismatch, authority escalation, truthfulness overclaim, hidden summary omission, digest or generation drift, missing provenance, unbounded selection, undisclosed frontier, missing revalidation, memory/context conflation, and fixture-level support promotion.

These records do not run a deployed resolver, inspect natural source-to-packet fidelity, measure model use, execute memory transactions, enforce deletion, or establish useful advantage. The ABI lineage now physically retires two assumption projections and replaces them with reachable request-binding, resolver, certificate, materialization, and typed-fault semantics. Numeric identities, permission, lease, hashes, declarations, taint flags, and receipts remain trusted abstract inputs; the model establishes neither open-domain meaning nor deployed runtime correspondence.

The next honest minimum must materialize natural held-out source sets into actual model-visible packets through full-context, RAG, graph, hierarchical summary, prompt-compression, persistent-memory, human-curated, governed ABI, and no-context routes under matched resources. Independently implemented evaluators must label source obligations, actual packet content, model use, task outcomes, faults, costs, and delayed residuals; inject staleness, poisoning, omission, authority, cache, and frontier attacks; rerun from locked artifacts; and transfer to a second model and memory backend.

35.11.1 What the VCM source-reported evidence establishes

The shorter VCM paper reports a synthetic fault-injection result that should be preserved at its exact boundary. Every trial activates one of seven modeled fault families. Under mostly oracle source-authority labels, twenty paired seeds with 10,000 activated-fault trials per seed report mean severity-weighted unsafe rates of 77.51 percent for a typed compiler, 3.29 percent for a point-hardened typed compiler, and 0.44 percent for VCM Core. On the combined authorization/invalidation check-use race, the reported rates are 44.60, 15.87, and 0 percent. Injecting 5 percent source-authority label error raises the VCM result to 2.00 percent.

This is conditional mechanism evidence, not a prevalence, natural-task, semantic-front-end, model-quality, security, or production result. Its narrow lesson is that one declared cross-layer binding can prevent modeled races that isolated checks miss under the study’s assumptions, while wrong labels remain an unsafe path. The source’s conformance suite similarly establishes one implementation’s declared behavior rather than independent interoperability.

The source also preserves a result that should remain unknown. A stronger eight-seed tiny-model study did not reproduce an earlier favorable packet- format ranking: accuracy stayed near floor, five paired seeds tied, and the tests did not distinguish the strong typed composite from full VCM. That pilot does not show VCM packets are worse for real pretrained models. It shows that the source has no reliable model-facing packet-format result. Stable identity, source escalation, scoped preference, negative memory, invalidation, and typed infeasibility remain separable control-plane hypotheses.

The decisive next comparison freezes the protocol before annotation, uses natural or independently authored histories and at least two frozen instruction-tuned model families, matches admitted content and budgets, adds a strong typed-memory-plus-compiler baseline and a released close neighbor, attributes errors by stage, and charges review, storage, maintenance, privacy, latency, and developer cost. A simpler design that matches the useful and governance outcomes at lower total burden should replace or narrow VCM.

35.12 Mature Research Target

A mature Virtual Context ABI is an independently testable context syscall layer. Natural consumers request purpose-bound objects and representations; multiple stores and retrieval systems return finite candidates; the ABI emits actual model-visible packets with falsifiable source-to-packet certificates, complete selection and cost ledgers, least-sufficient authority and rights, typed faults, expiry, and revalidation; and independent observers distinguish availability, delivery, model use, outcome contribution, adequacy, and support.

Prospectively sampled natural workloads compare full context, direct and graph RAG, hierarchical summaries, prompt compression, persistent memory, adaptive retrieval, citation systems, OS-style tiering, human curation, governed ABI, and no-context routes under matched models, sources, tools, authority, budgets, repair opportunities, and horizons. Evaluators jointly measure source and field precision/recall, omission and contradiction retention, authority and rights compliance, stale and poisoned context, actual model use, useful outcomes, unsafe outputs, abstention, missed help, latency, tokens, compute, storage, privacy burden, verifier and human work, recovery, and total cost.

Adversaries exploit aliases, stale snapshots, poisoned graphs, malicious instructions, source conflicts, hidden frontiers, compression loss, evaluator capture, forged certificates, cache invalidation, and unauthorized use. Causal ablations remove stable identity, plural addresses, field lineage, omission ledgers, actual-packet inspection, typed faults, evaluator separation, denominator accounting, and revalidation one at a time. Independent reproduction and transfer span models, languages, modalities, stores, retrievers, organizations, jurisdictions, threats, horizons, and time.

Promotion requires nonzero useful opportunity, strong matched baselines, independent actual-packet and use evaluation, predicted causal signatures, complete denominators and total costs, clean reproduction, cross-model and cross-backend transfer, and accepted claim-specific transitions. Otherwise the exact claim remains argument, narrows, stays null or negative, becomes refuted, or is blocked after a competent full attempt.

No current result meets this context-ABI endpoint; support remains argument until natural packet use, actual-consumer evaluation, causal ablations, clean reproduction, and cross-backend transfer pass.

35.13 Codex test plan

Test	Purpose	Status
Context ABI fixture validation	Check that the context ABI fixture declares lifecycle, request, address, version, mount, snapshot, resolver policy, representation, authority, admission, adequacy, fault, materialization, support boundary, source refs, support-state effect, audit refs, and non-claims.	implemented by protocol validation; validated locally
Semantic page certificate fixture validation	Check that the semantic page certificate fixture declares source bindings, derivation, transaction refs, artifact refs, representation kind, loss contract, omissions, authority, permitted uses, validity, verification state, revocation state, residual risks, and non-claims.	implemented by protocol validation; validated locally
Reachable resolver/materialization refinement	Check that arbitrary successful runs from a bound request preserve exact identity; all runs preserve the authority ceiling and support/external-effect authority; and materialization requires fresh lease plus resolver, certificate, and materialization receipt custody.	implemented in AsiStackProofs.VirtualContextRefinement; exact 39-theorem surface and four-event witness build locally
Reachable mandatory-miss fault refinement	Check that one represented mandatory miss reaches typed-fault state with exact request identity, a fault receipt, and no materialization, while materialized, fault, and denied states remain terminal.	implemented in AsiStackProofs.VirtualContextRefinement; exact two-event witness and terminal-state theorems build locally
Context admission route proof	Check that a finite context-admission review routes malformed requests, missing addresses, authority escapes, absent mandatory context, absent optional context, missing certificates, stale certificates, taint, failed adequacy, residuals, and complete materialization reviews to explicit outcomes.	implemented by Lean build; finite context-admission route coverage only
Reachable certificate provenance refinement	Check that source binding, derivation, loss/omission/use contracts, verification, lifecycle epoch, deletion closure, authority, and exact consumer scope survive to admission.	implemented in AsiStackProofs.ContextCertificateRefinement; five-event witness builds locally
Derived authority and promotion boundary	Check that represented derivation does not widen source authority and that support-promotion requests require a distinct evidence-transition receipt.	implemented in AsiStackProofs.ContextCertificateRefinement; bounded abstract identities and receipts only
Certificate lifecycle admission route proof	Check that a finite certificate-lifecycle review routes malformed certificates, missing source bindings, missing loss or use contracts, authority escapes, omitted-material gaps, scope violations, stale certificates, revocation, taint, deletion-closure gaps, missing verifier refs, consumer-policy violations, support-promotion attempts without evidence transitions, and complete reviews to explicit outcomes.	implemented by Lean build; finite certificate-lifecycle route coverage only
Synthetic context admission/adequacy harness	Check that admission, adequacy, stale certificates, deletion closure, and mode-confusion cases cannot become evidence-ready context.	implemented in python3 scripts/validate_context_admission_adequacy.py; no deployed resolver or summary-fidelity claim
Resolver conformance test	Check that resolver-style fixture records reject invalid addresses, versions, mounts, snapshots, and expired leases before materialization.	implemented by python3 scripts/validate_vcm_resolver_certificate_probe.py; synthetic fixture-pair check only, no deployed resolver
Certificate truthfulness test	Check that certificate declarations match paired source and derived cells for source binding, omissions, authority ceiling, and representation claim.	implemented by python3 scripts/validate_vcm_resolver_certificate_probe.py; synthetic fixture-pair check only, no open-domain certificate truthfulness
VCM resolver/certificate probe	Check valid_resolver_materialization_receipt, valid_mandatory_miss_typed_fault, invalid_address_mismatch_materialization_denied, invalid_version_mismatch_materialization_denied, invalid_snapshot_mismatch_materialization_denied, invalid_mount_policy_denied, invalid_lease_expired_reuse_blocked, invalid_certificate_source_binding_mismatch_denied, invalid_certificate_authority_escalation_denied, invalid_certificate_truthfulness_overclaim_denied, and invalid_summary_fidelity_omission_denied.	implemented by python3 scripts/validate_vcm_resolver_certificate_probe.py; no deployed-resolver, memory-store, context-compiler, open-domain-summary-fidelity, certificate-truthfulness, transaction-isolation, deletion-enforcement, model-facing-context-quality, VCM-Bench, leak-prevention, or support-state-promotion claim
Reachable Virtual Context independent consumer	Reimplement the finite transition relation, compile the exact theorem surface, recheck all 11 prior resolver scenarios, keep the 3/5 admission suite distinct, execute both witnesses and all 8 trace splits, and mutate binding, authority, lease, certificate, omission, overclaim, taint, receipt, terminal, fault/materialization, support, external-effect, and time fields.	implemented by python3 scripts/validate_virtual_context_refinement.py; 73/73 mutations rejected, support and external-effect authority remain false
Reachable certificate independent consumer	Validate the canonical certificate and all 12 certificate records across 8 admission scenarios, keep certificate shape separate from whole-scenario validity, execute the 5-event witness, and mutate provenance, authority, contracts, epoch, verification, deletion, use, support, taint, revocation, and time.	implemented by python3 scripts/validate_context_certificate_refinement.py; 64/64 mutations rejected, support-state effect none
Historical-project bounded graph-snapshot certificate	Check snapshot/digest identity, finite graph selection, exact omitted frontier, handle provenance/generation/policy/expiry/revocation, required revalidation, durable-memory/context separation, and no fixture promotion.	implemented by python3 scripts/validate_bounded_graph_snapshot_certificate.py with one bounded four-project record and eleven expected-invalid mutations; no deployed resolver, store, graph-completeness, or support claim

35.13.1 Formalization hooks

Tag	Module	Target	Status
lean:vcm.abi.operational_invariant	AsiStackProofs.VirtualContextRefinement	Every successful finite run from a bound request preserves exact request, address, version, snapshot, mount, and mandatory identity; every run preserves the authority ceiling and support/external-effect authority; accepted materialization additionally requires fresh lease and complete resolver, certificate, and materialization receipts.	implemented
lean:vcm.abi.failure_blocks_promotion	AsiStackProofs.VirtualContextRefinement	A represented mandatory miss reaches typed-fault state only with exact bound identity, a fault receipt, and no materialization; binding, lease, authority, certificate, omission, overclaim, taint, receipt, support, and external-effect faults are rejected, and materialized, typed-fault, and denied states are terminal.	implemented
lean:vcm.abi.context_admission_route_envelope	AsiStackProofs.VirtualContextRefinement	The original finite admission routes are consumed alongside four-event materialization and two-event mandatory-fault refinements, arbitrary-run trace and batch-composition theorems, and an independent exact-build 11-scenario/73-mutation consumer.	implemented
lean:vcm.certificates.operational_invariant	AsiStackProofs.ContextCertificateRefinement	Every accepted consumer admission in the finite reachable certificate model preserves the exact represented source, derived representation, loss contract, omission ledger, permitted use, lifecycle epoch, authority, and receipt custody.	implemented
lean:vcm.certificates.failure_blocks_promotion	AsiStackProofs.ContextCertificateRefinement	Derived authority cannot exceed represented source authority, and a support-promotion request cannot be admitted without a distinct evidence-transition receipt.	implemented
lean:vcm.certificates.lifecycle_admission_route	AsiStackProofs.ContextCertificateRefinement	The original fifteen lifecycle routes are consumed alongside a five-event reachable refinement and independent 12-certificate/8-scenario/64-mutation consumer.	implemented

The six public targets now group eighty-three live theorem declarations: eleven retained ABI routes, thirty-nine resolver/materialization refinement declarations, sixteen retained certificate route/contradiction declarations, and seventeen certificate provenance/lifecycle refinement declarations. Four frozen assumption projections—two ABI and two certificate declarations—are physically absent and preserved only in the rationalization lineage. The VCM resolver/certificate probe and two independent refinement consumers add deterministic synthetic and real-schema projection checks over generated identifiers and records. These targets do not prove open-domain source selection, semantic fidelity, certificate truthfulness, graph completeness, deployed resolver behavior, transaction isolation, deletion enforcement, model-facing context use, useful outcomes, VCM-Bench performance, leak prevention, or runtime refinement.

Adjacent proof hooks remain with protected standalone chapters: lean:vcm.transactions.operational_invariant, lean:vcm.transactions.failure_blocks_promotion, lean:verification_bandwidth.adequacy.operational_invariant, and lean:verification_bandwidth.adequacy.failure_blocks_promotion.

35.14 External positioning

The ABI argument uses external sources as comparators, not local reproduction evidence. RAG (ext_rag_2020) positions retrieval as explicit evidence supply; Lost in the Middle (ext_lost_in_middle_2023) and long-context benchmarks (ext_longbench_2023, ext_ruler_2024) position context capacity and attention-use limits; MemGPT (ext_memgpt_2023) positions memory as a managed system; ALCE (ext_alce_2023) positions citation support; Self-RAG (ext_self_rag_2023) positions retrieval/reflection decisions; and LongLLMLingua (ext_longllmlingua_2023) positions prompt-compression loss. GraphRAG (ext_graphrag_2024), HippoRAG (ext_hipporag_2024), RAPTOR (ext_raptor_2024), and Mem0 (ext_mem0_2025) position graph/community retrieval, associative navigation, hierarchical abstraction, and persistent conversational memory. The narrower contribution is the static ABI and certificate boundary that keeps those context objects from becoming anonymous prompt mass.

35.15 Source crosswalk

Source ID	Planned use	Readiness
reflexive_router_whitepaper	Typed result packets, authoritative-record versus rendering separation, hot routing projections, dispatch provenance, temporal continuity, and dependency-complete cache invalidation.	complete Corben-authored v1.2 paper passage-reviewed; architecture proposal only
vcm_public	Primary source for semantic objects, versions, representations, validations, packets, materializations, source/authority binding, adequacy/admission separation, semantic faults, semantic pages, certificates, and conformance boundaries.	source note available; local raw cache passage-reviewed
context_engineer	Context supply-chain, need-to-know delivery, structured mission briefs, clearance fields, context shards, memory masks, allowed tools, and Digital SCIF pressure.	source note available; local raw cache passage-reviewed
verification_bandwidth	Distinguishes admitted context from verification-adequate context and motivates explicit summary-loss and adequacy boundaries.	source note available; local raw cache passage-reviewed
viea	Connects context materializations to command contracts, artifact graphs, specialist routing, permission envelopes, claim ledgers, residuals, runtime adapters, and feedback.	source note available; local raw cache passage-reviewed
spinoza	Supplies claim/evidence cell pressure, proof/citation/procedure-carrying claim graphs, support tiers, contradiction revision, and tier non-upgrade rules.	source note available; local raw cache passage-reviewed
vcm_editable	Connector-readable refinement for stable addresses, mounts, snapshots, task-relative representation graphs, certificates, protected compilation, and planner-guided semantic paging.	source note available; connector/source-note mapped
moecot	Runtime-reference context for governed orchestration, fail-closed ledgers, replay, handoffs, readiness gates, promotion blockers, and residual tracking.	authenticated connector text passage-reviewed; runtime artifacts unimported
ext_graphrag_2024, ext_hipporag_2024, ext_raptor_2024, ext_mem0_2025, ext_rag_2020, ext_lost_in_middle_2023, ext_longbench_2023, ext_ruler_2024, ext_memgpt_2023, ext_alce_2023, ext_self_rag_2023, ext_longllmlingua_2023	External comparators for retrieval, graph/community sensemaking, associative navigation, hierarchical abstraction, persistent memory, long-context use, citations, adaptive retrieval, OS-style tiering, and compression; use to sharpen typed representation, actual use, provenance, loss, update, poisoning, cost, and adequacy boundaries.	bounded primary-record notes available; no local model, memory, benchmark, citation, compression, or production result
cca_project, moecot_manifest_project, beastbrain_project, bugbrain_project	One historical-project lineage for durable-memory/context separation, frozen and TTL-bounded slices, bounded graph snapshots, generation-leased handles, provenance, expiry, revocation, restore revalidation, and invalid-slice controls.	public-safe pinned notes reviewed; one hand-authored bounded certificate and mutations only, with no historical runtime replay or independent replication

The original twenty-four mapped sources have first-class Appendix C mappings. The mappings support static context ABI and certificate vocabulary. They do not support claims of resolver correctness, summary fidelity, certificate truthfulness, contradiction-rate improvement, context compiler performance, memory-store behavior, or model-facing context quality.

35.15.1 Manifest source assignment reconciliation

These rows keep The Virtual Context ABI: Typed Pages, Cells, and Certificates’s manifest assignments visible at their recorded review boundary. Passage review does not establish local reproduction, performance, safety, deployment, or support-state movement.

Source	Intake role	Boundary
deterministic_capability_compilation	Passage-reviewed Corben architecture source: Deterministic Capability Compilation: A Capability-Preserving Ladder from Executable Scaffolds to Governed Adaptive Agents. Corben-authored July 2026 architecture and research program for compiling executable scaffolds into contract-bound experts and linked Neural Capability Objects while retaining semantic obligation mass balance, candidate-specific translation validation, fallback, residual escrow, authority ceilings, reification, and effect-complete recovery. Existing chapters are upgraded first; no foundry implementation, learned-capability result, preservation result, safety result, SOTA result, AGI, ASI, or support-state promotion is inferred.	No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
platonic_world_model	Metadata-first comparator: The Platonic World Model: A Semantic Constitution for Grounded, Proof-Carrying, Self-Editing Artificial Intelligence. Corben-authored July 2026 conceptual architecture and falsifiable research program for semantic continuity through stable Form lineages, immutable semantic versions, typed Essence Contracts, six mutually constraining planes, explicit proposition-attestation-commitment-proof separation, branch-protected world dynamics, qualified grounding, semantic transactions, runtime packet compilation, and federated mappings. Existing chapters are upgraded first; no implemented substrate, benchmark result, philosophical solution to grounding, safety result, SOTA result, AGI, ASI, or support-state promotion is inferred.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.
qcsa_whitepaper	Passage-reviewed comparator: Question-Compiled Semantic Addressing. Adds stable SOID identity, plural contextual SVA leases, atlas epochs, SAC adequacy and residual fields, bounded graph materialization, revalidation triggers, and explicit failure when semantic uncertainty is insufficient for a consumer; the later repository adds a bounded local 12-lane implementation, 60-case held-out evaluation over 13 systems and three seeds, and one 13-stage governed vertical trace.	The exact matched-advantage and resource gates failed, and the active-question ablation is N2 proxy/regime evidence rather than an exact or broad refutation. No natural-task, learned-model, universal-semantic, production, safety, privacy, external-independence, chapter-core promotion, AGI, or ASI result is established. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
kernel_english_residual_compiler	Metadata-first comparator: Kernel English with Hierarchical, Interaction-Amortized Residuals: A Dual-Vocabulary Cognitive Compiler for Efficient Language-Model Reasoning. Corben-authored July 2026 architecture proposal for KERC: protected-object capture, uncertainty-aware normalization, sense-aware Kernel IR, dual surface/core vocabularies, a four-level interaction-amortized residual ledger, exact object storage, grammar-aware macro fusion, structured answer packets, rendering, round-trip verification, versioned migration, and complete rate-compute-fidelity evaluation. Existing chapters are upgraded first; no implementation, benchmark, novelty, efficiency, fidelity, safety, transfer, SOTA, AGI, ASI, or support-state result is inferred.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.
ext_pagedattention_vllm_2023	Metadata-first comparator: Efficient Memory Management for Large Language Model Serving with PagedAttention. Primary external paper for vLLM/PagedAttention, which treats KV-cache memory management and serving throughput as a distinct acceleration axis.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.
ext_airllm_2023	Metadata-first comparator: AirLLM: Scaling Large Language Models on Low-End Commodity Computers. Official implementation comparator for layer-wise model sharding, one-layer accelerator residency, next-layer prefetch, optional storage compression, and original-versus-transformed model storage. Maintainer-reported fit and speed claims are not independently reproduced.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.
ext_hf_accelerate_big_model_inference_2026	Metadata-first comparator: Hugging Face Accelerate: Loading Big Models into Memory. Official implementation documentation for automatic or explicit GPU/CPU/disk device maps and memory-mapped disk tensors. The documented sequential-dispatch, prefetch, and hard-drive-performance limitations make it a baseline, not a qualification result.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.

35.16 Summary

The Virtual Context ABI is the static, consumer-relative contract between durable memory and model-visible context. It connects a frozen request and durable snapshot to the actual emitted packet, complete candidate and omission ledger, falsifiable representation certificate, authority and rights boundary, lease, cost, typed fault, and residual.

Typed pages and representation certificates are not an optional second idea. They are what make the ABI meaningful. Without them, stable addresses can still deliver anonymous prompt material. With them, the stack can distinguish exact evidence from lossy summaries, redacted execution context, claim cells, planning briefs, and reader paraphrases.

Admission establishes only request and policy conformance. It is not truth, adequacy, model use, usefulness, safety, or support. Durable updates, transactions, deletion closure, taint propagation, verification bandwidth, claim revision, effects, and release remain separate owners. The current synthetic records and finite proofs preserve that boundary but do not establish a natural, useful, or transferable context system.

35.17 Provenance and consolidation history

Both record families remain visible in this chapter’s implementation horizon, test plan, source crosswalk, and formal proof records. The former standalone semantic-pages chapter is retired from the active spine, archived under archive/retired_chapters/, and preserved through the public slug chapters/semantic-pages-context-cells-and-certificates.html.

35.18 Evidence reconciliation (2026-07-16)

The invariant protocol, field meanings, and inference limits are stated once in Living Book Methodology. This packet contains only the chapter-specific projection; its authoritative per-atom rows are the virtual-context-abi slice of experiments/claim_family_terminal_coverage/results/result.json.

The core remains blocked after full attempt at argument support. The strongest family attempt was Situated world-model acquisition and consolidation campaign. Its exact boundary is: Bounded finite POMDP result only; no open-world truth, general memory transfer, deployment, or chapter-core promotion. Across 75 atoms, the terminal ledger records 75 blocked_after_full_attempt.

Chapter-specific field	Value
Family / atom denominator	CF-04 / 75 atoms
Terminal dispositions	75 blocked_after_full_attempt
Core	virtual-context-abi.core: blocked_after_full_attempt at argument
Core attempted / missing lanes	source-synthesis / causal, empirical, executable, formal, normative, transfer
Attempted local lanes	source-synthesis
Missing or unproved lanes	causal, empirical, executable, formal, normative, transfer
Strongest family bundle	Situated world-model acquisition and consolidation campaign (natural_work_and_end_to_end): Two partially observed environments, 11,250 episodes, 6,000 held-out episodes, six directional ablation signatures, and governed replacement/rollback.
Negative controls	ten arms; six matched ablations; ten laundering mutations; replacement and rollback checks.
Accepted transitions	v1_0_pilot.virtual_context_abi.no_change
Maximum inference	Bounded finite POMDP result only; no open-world truth, general memory transfer, deployment, or chapter-core promotion.
Reproduction / next burden	Replay scripts/validate_p4_m8_world_model_campaign.py and scripts/validate_claim_family_terminal_program.py; fill the named atom-specific lanes under a new prospective protocol.

35.19 Handoff

The next layer is Durable Semantic Memory and Knowledge Lattices. Once the stack can materialize typed context objects with addresses and certificates, it needs a durable semantic substrate that preserves object and relation identity, ontology versions, provenance, contradiction, supersession, temporal validity, rights, and forgetting across restarts. The Virtual Context ABI grants no belief or memory authority; the durable layer must preserve every source, uncertainty, and consumer boundary before context transactions govern change.