pbuffer 0.1.0__tar.gz

pbuffer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 5000Stadia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pbuffer-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: pbuffer
+Version: 0.1.0
+Summary: A world-state database: an append-only log of everything true in a world - places, people, objects, knowledge, time. Deploy it under a game, AI agent, or real-world tracker for permanent, queryable world memory: current state, location, history, and who-knows-what, answered by deterministic queries instead of model calls.
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.28; extra == "mcp"
+Dynamic: license-file
+
+# pattern-buffer
+
+[![tests](https://github.com/5000Stadia/pattern-buffer/actions/workflows/ci.yml/badge.svg)](https://github.com/5000Stadia/pattern-buffer/actions/workflows/ci.yml)
+
+> A data structure that maps whatever world it's shown — real or fiction.
+> The memory under the holodeck.
+
+**A pattern buffer that never degrades.**
+
+One append-only log of perspective-scoped, time-indexed assertions about entities; every other structure — current state, space, knowledge, history, the rendered world — is a disposable projection over it. Fiction simulation and real-world tracking are the same machine under one policy switch.
+
+**A world-encapsulation framework, engine-independent by construction.** The substrate's only outside dependency is an injected model callable `(prompt, schema) -> json` — no host concept (players, turns, scenes, sessions) ever reaches inside it — so any engine sits on top: a game runtime, a household or job-site tracker, an agent's long-term memory. Fiction and tracking aren't two systems; they are two *instances* of one substrate, differing only in resolution policy and provenance discipline.
+
+> A player places a pipe in a drawer in session 12 of a D&D campaign. Two hundred sessions pass without a mention. At retirement, the player opens the drawer — and the pipe is there, exactly as placed, with the original moment's full history behind it. No maintenance was ever performed. In this architecture, **silence is persistence**: state is folded from the log, never re-inferred and never kept alive by mention. The world remembers so the model doesn't have to.
+
+**Status: pre-1.0; substrate validated, ingestion fidelity is the open
+front.** The engine passes its 419-test invariant suite, and the chapter test
+(ingest a complete noir mystery, delete the prose, interrogate the store
+against a hand-authored answer key) has been graded across three full runs.
+The substrate's invariants held in all of them — sealed containers stayed
+sealed, contradictions were flagged and never merged, knowledge frames never
+leaked, the two-time-axis fold answered late-revealed history correctly. Each
+run also surfaced exactly one engine refinement at the fold (a working
+assumption outholding evidence; a wrong inference outholding authored canon),
+each fixed, tested, and generalized the same day — that progression is now
+the **evidence-rank** rule. A registry-first ingestion pipeline
+(whole-document scaffold → parallel compact-grammar extraction → audited
+single commit) replaced serial prompt-iterated extraction after measurement
+showed prose contracts fragment differently every round; identity and key
+fragmentation died as failure classes, and pass-0 registry quality is where
+the remaining extraction failures concentrate. Run 4, with its checkable
+predictions, is in flight. Not yet installable from PyPI; the shipped example
+world with a zero-API-key query tour lands once a verified run stamps it.
+
+## What this is
+
+A storage and retrieval substrate that lets a language model maintain a complete, queryable, durable model of a world — places, objects, people, relationships, histories, and unknowns — such that any state question is answered by a deterministic query, never by re-reading prose; the world accretes and is re-enterable; and the same engine serves authored fiction (a holodeck, a campaign, a mystery) and real-world tracking (a household, a job site, a vehicle), differing only in resolution policy and provenance discipline.
+
+The buffer holds the pattern; materialization is re-entry; degradation is the failure we exist to prevent; the arch is how the operator steps outside the world to inspect it; and where nothing has been established, you don't get invented detail — **you see the grid.**
+
+## Documents
+
+- **[docs/WHITEPAPER.md](docs/WHITEPAPER.md)** — the canonical, comprehensive design reference. Principles, primitives, durability, frames, provenance, thunks, reference resolution, ingestion discipline, identity, the operation algebra, projection, both modes, embedding hazards, evaluation, and the decision record. Start here.
+- **[docs/LEXICON.md](docs/LEXICON.md)** — the working vocabulary and its naming discipline.
+- **[docs/ADOPTION.md](docs/ADOPTION.md)** — for agents (and humans) integrating the library: exact signatures, typed outcomes, the three-seam recipe, MUST/NEVER rules.
+- **[docs/HOST-DISCIPLINE.md](docs/HOST-DISCIPLINE.md)** — the adopter's discipline brief: the seven categories every fact must be classified along to ingest with fidelity, and the structural retrieval strategies (the four correlation axes + the correlation sweep) to surface every relevant, related detail for any subject.
+- **[docs/INGESTION-PLAYBOOK.md](docs/INGESTION-PLAYBOOK.md)** — evidence-based rules for deserializing narrative into a world: the extractor contract, feeding mechanics, what the gate guards, and measured ingestion baselines.
+- **[docs/reference/assertion-world-model-original.md](docs/reference/assertion-world-model-original.md)** — the framework-agnostic design document this project was founded on, preserved verbatim for lineage.
+
+## The road
+
+1. ~~Recover and commit the *Last Honest Meter* eval seed (the chapter test's ground truth).~~ Done — v1-final, `evals/last_honest_meter/`.
+2. ~~Engine spike: `PatternBuffer` + derived indexes + classifier + projector + resolver + `refer()` tier 1.~~ Done — `src/patternbuffer/`.
+3. ~~The chapter test, runs 1–4~~: substrate validated; registry-first ingestion (INGEST-V2) landed; run 4 scored **22/33 (best graded run, all remaining failures extraction-class not shape-class)** — the substrate holds; ingestion fidelity (pass-0 registry quality) is the open score lever. Receipts: `evals/results/`.
+4. ~~The shipped example world: `examples/anchor/`~~ — stamped (`STAMP.json`, run 4): a bible-verified noir mystery as a queryable database, with a zero-API-key scripted tour and 8 open truth-maintenance conflict flags shipped visibly (honesty is the product). Not yet packaged to PyPI.
+5. ~~The messy-dialogue micro-eval (the honest bridge from fiction ingestion to tracking-mode ingestion).~~ Done — **10/10** on the reality-divergence battery (`evals/results/2026-06-12-micro-v1-final/`); tracking-mode ingestion validated against sloppy conversational fragments.
+6. ~~The porcelain API + host integration.~~ Done — and proven in the strongest form. The frozen contract (`porcelain-v0.1`, additive-only): five load-bearing verbs — `ingest` (+`ingest_structured`) / `snapshot` / `ask` / `materialize` / `resolve`+`refer()` — over a fuller read-and-identity family (`state`, `where`, `aggregate`, `neighborhood`, `frame_diff`, `who_knows`, `correlate`, `route`, `entities`, `facts`, build sessions, `axis_heads`, …). The first *live* host, [Construct](https://github.com/5000Stadia/construct) (an interactive-fiction engine — `pattern` → `construct` loads it → `holonovel`), runs **entirely on this contract**: zero engine-internal reaches, its 800+-test suite green on the pure public surface. The engine-independent claim, demonstrated rather than asserted. (Intended primary host: [Kernos](https://github.com/5000Stadia/Kernos), adapter pattern.)
+7. ~~The interactive-fiction milestone (thunk stability across sessions, frame-scoped NPCs, multi-path mystery, clocks, loop closure).~~ Met in the field — every item is exercised in [Construct](https://github.com/5000Stadia/construct)'s live suite (the first host runs entirely on the frozen porcelain). These are host-layer criteria, proven by the adopter, not a further engine deliverable.
+8. ~~The MCP wrapper~~ — built: `pip install pbuffer[mcp]` → `patternbuffer-mcp --world w.world --world-id w:id` serves the frozen porcelain's **37 deterministic verbs** over stdio to any MCP client — read, query, and *build* a world with zero Python (the genuinely model-free subset; model-backed verbs are V1.1 via sampling). One server ↔ one world; a connected client is a fully **trusted world principal** — frame entitlement for untrusted consumers stays host-mediated. The framework-agnostic claim, proven by demonstration. Far field: the first host's V2 roadmap publicly assigns branch-worlds simulation and its curiosity loop to this engine — the two roadmaps meet in the middle.
+
+## License
+
+MIT

pbuffer-0.1.0/README.md

@@ -0,0 +1,63 @@
+# pattern-buffer
+
+[![tests](https://github.com/5000Stadia/pattern-buffer/actions/workflows/ci.yml/badge.svg)](https://github.com/5000Stadia/pattern-buffer/actions/workflows/ci.yml)
+
+> A data structure that maps whatever world it's shown — real or fiction.
+> The memory under the holodeck.
+
+**A pattern buffer that never degrades.**
+
+One append-only log of perspective-scoped, time-indexed assertions about entities; every other structure — current state, space, knowledge, history, the rendered world — is a disposable projection over it. Fiction simulation and real-world tracking are the same machine under one policy switch.
+
+**A world-encapsulation framework, engine-independent by construction.** The substrate's only outside dependency is an injected model callable `(prompt, schema) -> json` — no host concept (players, turns, scenes, sessions) ever reaches inside it — so any engine sits on top: a game runtime, a household or job-site tracker, an agent's long-term memory. Fiction and tracking aren't two systems; they are two *instances* of one substrate, differing only in resolution policy and provenance discipline.
+
+> A player places a pipe in a drawer in session 12 of a D&D campaign. Two hundred sessions pass without a mention. At retirement, the player opens the drawer — and the pipe is there, exactly as placed, with the original moment's full history behind it. No maintenance was ever performed. In this architecture, **silence is persistence**: state is folded from the log, never re-inferred and never kept alive by mention. The world remembers so the model doesn't have to.
+
+**Status: pre-1.0; substrate validated, ingestion fidelity is the open
+front.** The engine passes its 419-test invariant suite, and the chapter test
+(ingest a complete noir mystery, delete the prose, interrogate the store
+against a hand-authored answer key) has been graded across three full runs.
+The substrate's invariants held in all of them — sealed containers stayed
+sealed, contradictions were flagged and never merged, knowledge frames never
+leaked, the two-time-axis fold answered late-revealed history correctly. Each
+run also surfaced exactly one engine refinement at the fold (a working
+assumption outholding evidence; a wrong inference outholding authored canon),
+each fixed, tested, and generalized the same day — that progression is now
+the **evidence-rank** rule. A registry-first ingestion pipeline
+(whole-document scaffold → parallel compact-grammar extraction → audited
+single commit) replaced serial prompt-iterated extraction after measurement
+showed prose contracts fragment differently every round; identity and key
+fragmentation died as failure classes, and pass-0 registry quality is where
+the remaining extraction failures concentrate. Run 4, with its checkable
+predictions, is in flight. Not yet installable from PyPI; the shipped example
+world with a zero-API-key query tour lands once a verified run stamps it.
+
+## What this is
+
+A storage and retrieval substrate that lets a language model maintain a complete, queryable, durable model of a world — places, objects, people, relationships, histories, and unknowns — such that any state question is answered by a deterministic query, never by re-reading prose; the world accretes and is re-enterable; and the same engine serves authored fiction (a holodeck, a campaign, a mystery) and real-world tracking (a household, a job site, a vehicle), differing only in resolution policy and provenance discipline.
+
+The buffer holds the pattern; materialization is re-entry; degradation is the failure we exist to prevent; the arch is how the operator steps outside the world to inspect it; and where nothing has been established, you don't get invented detail — **you see the grid.**
+
+## Documents
+
+- **[docs/WHITEPAPER.md](docs/WHITEPAPER.md)** — the canonical, comprehensive design reference. Principles, primitives, durability, frames, provenance, thunks, reference resolution, ingestion discipline, identity, the operation algebra, projection, both modes, embedding hazards, evaluation, and the decision record. Start here.
+- **[docs/LEXICON.md](docs/LEXICON.md)** — the working vocabulary and its naming discipline.
+- **[docs/ADOPTION.md](docs/ADOPTION.md)** — for agents (and humans) integrating the library: exact signatures, typed outcomes, the three-seam recipe, MUST/NEVER rules.
+- **[docs/HOST-DISCIPLINE.md](docs/HOST-DISCIPLINE.md)** — the adopter's discipline brief: the seven categories every fact must be classified along to ingest with fidelity, and the structural retrieval strategies (the four correlation axes + the correlation sweep) to surface every relevant, related detail for any subject.
+- **[docs/INGESTION-PLAYBOOK.md](docs/INGESTION-PLAYBOOK.md)** — evidence-based rules for deserializing narrative into a world: the extractor contract, feeding mechanics, what the gate guards, and measured ingestion baselines.
+- **[docs/reference/assertion-world-model-original.md](docs/reference/assertion-world-model-original.md)** — the framework-agnostic design document this project was founded on, preserved verbatim for lineage.
+
+## The road
+
+1. ~~Recover and commit the *Last Honest Meter* eval seed (the chapter test's ground truth).~~ Done — v1-final, `evals/last_honest_meter/`.
+2. ~~Engine spike: `PatternBuffer` + derived indexes + classifier + projector + resolver + `refer()` tier 1.~~ Done — `src/patternbuffer/`.
+3. ~~The chapter test, runs 1–4~~: substrate validated; registry-first ingestion (INGEST-V2) landed; run 4 scored **22/33 (best graded run, all remaining failures extraction-class not shape-class)** — the substrate holds; ingestion fidelity (pass-0 registry quality) is the open score lever. Receipts: `evals/results/`.
+4. ~~The shipped example world: `examples/anchor/`~~ — stamped (`STAMP.json`, run 4): a bible-verified noir mystery as a queryable database, with a zero-API-key scripted tour and 8 open truth-maintenance conflict flags shipped visibly (honesty is the product). Not yet packaged to PyPI.
+5. ~~The messy-dialogue micro-eval (the honest bridge from fiction ingestion to tracking-mode ingestion).~~ Done — **10/10** on the reality-divergence battery (`evals/results/2026-06-12-micro-v1-final/`); tracking-mode ingestion validated against sloppy conversational fragments.
+6. ~~The porcelain API + host integration.~~ Done — and proven in the strongest form. The frozen contract (`porcelain-v0.1`, additive-only): five load-bearing verbs — `ingest` (+`ingest_structured`) / `snapshot` / `ask` / `materialize` / `resolve`+`refer()` — over a fuller read-and-identity family (`state`, `where`, `aggregate`, `neighborhood`, `frame_diff`, `who_knows`, `correlate`, `route`, `entities`, `facts`, build sessions, `axis_heads`, …). The first *live* host, [Construct](https://github.com/5000Stadia/construct) (an interactive-fiction engine — `pattern` → `construct` loads it → `holonovel`), runs **entirely on this contract**: zero engine-internal reaches, its 800+-test suite green on the pure public surface. The engine-independent claim, demonstrated rather than asserted. (Intended primary host: [Kernos](https://github.com/5000Stadia/Kernos), adapter pattern.)
+7. ~~The interactive-fiction milestone (thunk stability across sessions, frame-scoped NPCs, multi-path mystery, clocks, loop closure).~~ Met in the field — every item is exercised in [Construct](https://github.com/5000Stadia/construct)'s live suite (the first host runs entirely on the frozen porcelain). These are host-layer criteria, proven by the adopter, not a further engine deliverable.
+8. ~~The MCP wrapper~~ — built: `pip install pbuffer[mcp]` → `patternbuffer-mcp --world w.world --world-id w:id` serves the frozen porcelain's **37 deterministic verbs** over stdio to any MCP client — read, query, and *build* a world with zero Python (the genuinely model-free subset; model-backed verbs are V1.1 via sampling). One server ↔ one world; a connected client is a fully **trusted world principal** — frame entitlement for untrusted consumers stays host-mediated. The framework-agnostic claim, proven by demonstration. Far field: the first host's V2 roadmap publicly assigns branch-worlds simulation and its curiosity loop to this engine — the two roadmaps meet in the middle.
+
+## License
+
+MIT

pbuffer-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pbuffer"
+version = "0.1.0"
+description = "A world-state database: an append-only log of everything true in a world - places, people, objects, knowledge, time. Deploy it under a game, AI agent, or real-world tracker for permanent, queryable world memory: current state, location, history, and who-knows-what, answered by deterministic queries instead of model calls."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+mcp = ["mcp>=1.28,<2"]
+
+[project.scripts]
+patternbuffer-mcp = "patternbuffer.mcp:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"

pbuffer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pbuffer-0.1.0/src/patternbuffer/__init__.py

@@ -0,0 +1,317 @@
+"""patternbuffer: an append-only world-state substrate.
+
+One append-only log of perspective-scoped, time-indexed assertions per
+world; every other structure — current state, space, knowledge, history,
+the rendered world — is a disposable projection over it.
+
+The engine is host-blind: its single outside dependency is an injected
+model callable ``(prompt, schema) -> json``. See docs/WHITEPAPER.md.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+from patternbuffer.buffer import PatternBuffer
+from patternbuffer.classify import Classifier
+from patternbuffer.identity import IdentityRegistry
+from patternbuffer.indexes import Indexes
+from patternbuffer.ingest import Ingestor
+from patternbuffer.model import ATTR_PREFIX, CANON, META_ATTRIBUTES
+from patternbuffer.project import Materialization, Projector
+from patternbuffer.refer import Refer, Resolution
+from patternbuffer.roles import _make_engine_roles
+from patternbuffer.salience import SalienceIndex
+from patternbuffer.semantics import AttributeSemantics
+from patternbuffer.thunks import (
+    INVENT_UNDER_CANON,
+    OBSERVE_OR_UNKNOWN,
+    POLICIES,
+    Resolver,
+)
+from patternbuffer.tmaint import TruthMaintenance
+
+__version__ = "0.0.1"
+
+STANCES = frozenset({"fiction", "reality", "hypothetical"})  # letter 026; fixed enum
+__all__ = ["World", "Materialization", "Resolution", "__version__"]
+
+
+class World:
+    """The named, individual unit: one PatternBuffer + its physics
+    (resolution policy, decay configuration) + derived indexes (§16).
+
+    ``World("campaign.world", world_id="w:campaign", model=callable)`` is
+    the entire harness interface — a parameter, not a framework. Role
+    capabilities are minted here and nowhere else.
+    """
+
+    def __init__(
+        self,
+        path: str | Path,
+        world_id: str,
+        model: Callable[[str, dict], Any] | None = None,
+        policy: str = INVENT_UNDER_CANON,
+        clock: Callable[[], float] = time.time,
+        stance: str = "fiction",
+        title: str = "",
+        description: str = "",
+        attribute_default: Callable[[str], dict | None] | None = None,
+    ) -> None:
+        if policy not in POLICIES:
+            raise ValueError(f"unknown policy {policy!r}")
+        if stance not in STANCES:
+            raise ValueError(f"unknown stance {stance!r} (fixed enum; letter 026)")
+        self.world_id = world_id
+        self.policy = policy
+        self.buffer = PatternBuffer(path, world_id)
+        self.semantics = AttributeSemantics(self.buffer)
+        roles = _make_engine_roles()
+        self.classifier = Classifier(self.buffer, model or _no_model, self.semantics)
+        self.registry = IdentityRegistry(self.buffer, roles["ingestor"], self.semantics)
+        self.indexes = Indexes(
+            self.buffer, self.classifier, self.registry.resolve, self.semantics
+        )
+        self.indexes.set_closure_provider(self.registry.closure)
+        self.indexes.set_correlation_provider(self.registry.correlation_set)
+        self.registry.set_kind_provider(lambda e: self.indexes.fold_key(e, "kind"))
+        self.salience_index = SalienceIndex(self.buffer, self.classifier, self.indexes)
+        self.indexes.set_salience_provider(self.salience_index.salience)
+        self.truth = TruthMaintenance(
+            self.buffer, self.classifier, self.indexes, roles["truth_maintenance"],
+            self.semantics,
+        )
+        # SHAPE-FIX-V1 retype wiring: retraction authority + rules-mode
+        # durability for the corrected kind row (the set_kind_provider idiom —
+        # truth/classifier post-date the registry).
+        self.registry.set_retract_provider(self.truth.retract)
+        self.registry.set_classify_provider(
+            lambda rows: self.classifier.classify_rows(rows, model=False)
+        )
+        # Win 4 (durable-contradiction veto, HD 089): the registry reads
+        # standing folds + durability verdicts through late-bound lookups.
+        self.registry.set_fold_provider(self.indexes.fold_key)
+        self.registry.set_durability_provider(self.classifier.durability)
+        self.resolver = Resolver(
+            self.buffer, self.classifier, self.indexes, roles["resolver"],
+            model or _no_model, policy,
+        )
+        self.projector = Projector(
+            self.buffer, self.classifier, self.indexes, self.semantics,
+            self.salience_index.salience,
+        )
+        self.ingestor = Ingestor(
+            self.buffer, self.classifier, self.registry, roles["ingestor"],
+            model, observe_mode=(policy == OBSERVE_OR_UNKNOWN), clock=clock,
+            resolver_role=roles["resolver"],
+            semantics=self.semantics,
+            attribute_default=attribute_default,
+            # Write-time containment-cycle gate (HD 002): the ancestor walk
+            # is the derived containment chain — locate folds the family.
+            containment_ancestors=lambda parent, frame, vf: set(
+                self.indexes.locate(parent, frame=frame, valid_as_of=vf)
+            ),
+        )
+        self.refer = Refer(self.buffer, self.indexes, self.registry, model,
+                           ingestor=self.ingestor)
+        # The World Charter (letter 026): a fresh world's genesis write
+        # asserts its self-description — stance is ontological stored
+        # truth (does this world claim to describe reality?), distinct
+        # from operational policy. Ordinary appends; amendable forever.
+        if self.buffer.head() == 0:
+            charter = [
+                {"entity": "world:self", "attribute": "kind", "value": "world",
+                 "timeless": True},
+                {"entity": "world:self", "attribute": "stance", "value": stance,
+                 "timeless": True},
+            ]
+            if title:
+                charter.append({"entity": "world:self", "attribute": "title",
+                                "value": title, "timeless": True})
+            if description:
+                charter.append({"entity": "world:self", "attribute": "description",
+                                "value": description, "timeless": True})
+            self.ingestor.classify_inline = False
+            self.ingest_structured(charter)
+            self.ingestor.classify_inline = True
+            for row in self.buffer.all_rows():
+                self.classifier.set(row.id, "CONSTITUTIVE", 1.0)
+
+    # Reads (deterministic, no LLM — P7).
+
+    def locate(self, entity: str, **kw) -> list[str]:
+        return self.indexes.locate(entity, **kw)
+
+    def contents(self, container: str, **kw) -> list[str]:
+        return self.indexes.contents(container, **kw)
+
+    # PLACE-FEATURE-ABSTRACTION-V1 — the compositional axis (part_of).
+    def composition(self, entity: str, **kw) -> list[str]:
+        return self.indexes.composition(entity, **kw)
+
+    def features(self, place: str, **kw) -> list[str]:
+        return self.indexes.features(place, **kw)
+
+    # WHO-KNOWS-INVERSE-V1 — the computed "who knows X" read.
+    def who_knows(self, entity: str, attribute: str, value: Any = None, **kw) -> list[str]:
+        return self.indexes.who_knows(entity, attribute, value, **kw)
+
+    def state(self, entity: str, attribute: str, frame: str = CANON, **kw):
+        return self.indexes.fold_key(entity, attribute, frame, **kw)
+
+    # AKA-CORRELATION-V1 — the explicit, opt-in correlated identity surface.
+    def state_union(self, entity: str, attribute: str, frame: str = CANON, **kw):
+        return self.indexes.state_union(entity, attribute, frame, **kw)
+
+    def correlations(self, entity: str, **kw) -> list[str]:
+        return self.registry.correlations(entity, **kw)
+
+    def correlate(self, a: str, b: str, evidence: str, **kw) -> dict:
+        return self.registry.correlate(a, b, evidence, **kw)
+
+    def correlation_conflicts(self, **kw) -> list[dict]:
+        return self.registry.correlation_conflicts(**kw)
+
+    def path(self, a: str, b: str, **kw) -> list[str] | None:
+        return self.indexes.path(a, b, **kw)
+
+    def route(self, a: str, b: str, **kw) -> dict:
+        return self.indexes.route(a, b, **kw)
+
+    def salience(
+        self, entity: str, frame: str = CANON, as_of: float | None = None
+    ) -> float:
+        return self.salience_index.salience(entity, frame, as_of)
+
+    def confidence(
+        self,
+        entity: str,
+        attribute: str,
+        frame: str | list[str] = CANON,
+        as_of: float | None = None,
+        asserted_as_of: int | None = None,
+    ) -> dict:
+        return self.indexes.confidence(
+            entity, attribute, frame=frame, as_of=as_of,
+            asserted_as_of=asserted_as_of,
+        )
+
+    def neighborhood(self, entity: str, **kw) -> dict:
+        return self.indexes.neighborhood(entity, **kw)
+
+    def aggregate(self, container: str, member_attribute: str, op: str, **kw) -> dict:
+        return self.indexes.aggregate(container, member_attribute, op, **kw)
+
+    def fidelity_audit(self, frame: str = CANON, as_of: float | None = None) -> dict:
+        """Structural ingestion-fidelity gaps, derived (INGESTION-FIDELITY-V1).
+        Read-only; run after a build's classification + `truth.scan()` (it never
+        classifies or scans). The engine surfaces gaps; the host joins arc/cast
+        severity and drives targeted re-extraction."""
+        from patternbuffer.classify import EVENT, STATE
+
+        collisions = self.registry.name_collisions(frame=frame, valid_as_of=as_of)
+
+        unstamped: list[dict] = []
+        entities: set[str] = set()
+        for row in self.buffer.visible(frame=frame):
+            if row.entity.startswith("a:") or row.entity.startswith(ATTR_PREFIX):
+                continue
+            eid = self.registry.resolve(row.entity)
+            if eid.startswith(("obj:", "person:")):
+                entities.add(eid)
+            # Meta/identity edges (same_as/distinct_from/aka/source…) are
+            # classified EVENT and carry no valid_from BY DESIGN — bookkeeping,
+            # never a spine fact; they are not an unstamped gap.
+            if row.attribute in META_ATTRIBUTES:
+                continue
+            if row.valid_from is None and self.classifier.get(row.id) is not None \
+                    and self.classifier.durability(row.id) in (STATE, EVENT):
+                unstamped.append({"entity": eid, "attribute": row.attribute,
+                                  "assertion_id": row.id})
+
+        orphans = sorted(
+            e for e in entities
+            if not self.indexes.locate(e, frame=frame, valid_as_of=as_of)
+        )
+
+        conflicts = [
+            {"entity": c.entity, "attribute": c.attribute, "frame": c.frame,
+             "kind": c.kind, "assertion_ids": list(c.assertion_ids)}
+            for c in self.truth.open_conflicts()
+        ]
+
+        live = sum(1 for g in collisions if g["live"])
+        return {
+            "frame": frame,
+            "name_collisions": collisions,
+            "unstamped_timed": unstamped,
+            "orphan_entities": orphans,
+            "open_conflicts": conflicts,
+            "summary": {
+                "name_collisions": live,          # live-fragmentation groups only
+                "name_collisions_total": len(collisions),
+                "unstamped_timed": len(unstamped),
+                "orphan_entities": len(orphans),
+                "open_conflicts": len(conflicts),
+            },
+        }
+
+    def materialize(self, scope, **kw) -> Materialization:
+        return self.projector.materialize(scope, **kw)
+
+    # Writes (each behind its role).
+
+    def ingest(self, text: str, context: str = "", frame: str | None = None,
+               classify: str = "inline", extract: str = "full",
+               cursor_authoritative: bool = False, pov: str | None = None) -> list:
+        return self.ingestor.ingest(text, context, frame=frame, classify=classify,
+                                    extract=extract,
+                                    cursor_authoritative=cursor_authoritative,
+                                    pov=pov)
+
+    def extract(self, text: str, context: str = "", extract: str = "full",
+                pov: str | None = None) -> list:
+        """Read-only extraction (INGEST-LATENCY-V2): the host parallelizes these,
+        then ingest_structured()s the results serially. No write. `pov`
+        (SHAPE-FIX-V1 4c): the viewpoint entity id for deixis binding."""
+        return self.ingestor.extract(text, context, extract=extract, pov=pov)
+
+    def ingest_structured(self, items: list[dict], frame: str | None = None,
+                          classify: str = "inline",
+                          cursor_authoritative: bool = False) -> list:
+        return self.ingestor.ingest_structured(
+            items, frame=frame, classify=classify,
+            cursor_authoritative=cursor_authoritative)
+
+    def resolve(self, entity: str, aspect: str, frame: str = CANON, access=None):
+        return self.resolver.resolve(entity, aspect, frame, access)
+
+    @property
+    def porcelain(self):
+        """The frozen host surface (PORCELAIN-V1). Lazy; import-local to
+        avoid circularity."""
+        if not hasattr(self, "_porcelain"):
+            from patternbuffer.porcelain import Porcelain
+            self._porcelain = Porcelain(self)
+        return self._porcelain
+
+    def charter(self) -> dict[str, Any]:
+        """The world's self-description, read from world:self (letter 026)."""
+        out: dict[str, Any] = {}
+        for attr, result in self.indexes.current_state("world:self").items():
+            if result.winner is not None:
+                out[attr] = result.winner.value
+        return out
+
+    def close(self) -> None:
+        # An open build session never outlives the buffer: abort (restore the
+        # classify toggle, classify nothing) before closing (BUILD-SESSION-V1).
+        if hasattr(self, "_porcelain"):
+            self._porcelain.abort_build()
+        self.buffer.close()
+
+
+def _no_model(prompt: str, schema: dict) -> Any:
+    raise RuntimeError("no model callable injected for this operation")