pbuffer 0.1.0__py3-none-any.whl

patternbuffer/testing.py

@@ -0,0 +1,92 @@
+"""Test doubles for the engine's single outside dependency.
+
+The engine takes one injected callable ``(prompt, schema) -> json`` at
+World construction (whitepaper §17.1). ``StubModel`` is that callable
+for tests: it replays canned responses and records every call, so tests
+can assert both what the engine asked and that deterministic paths made
+no model call at all.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+
+class StubModelExhausted(AssertionError):
+    """Raised when the engine makes a model call the test did not script."""
+
+
+class StubModel:
+    """A scripted ``(prompt, schema) -> json`` callable.
+
+    Responses are returned in FIFO order. Every call is recorded in
+    ``calls`` as ``(prompt, schema)`` tuples. An unscripted call raises
+    ``StubModelExhausted`` — the no-LLM-on-deterministic-paths invariant
+    (P7) is asserted by scripting zero responses.
+    """
+
+    def __init__(
+        self,
+        responses: list[Any] | None = None,
+        fallback: "Callable[[str, dict[str, Any]], Any] | None" = None,
+    ) -> None:
+        self._responses: list[Any] = list(responses or [])
+        self._fallback = fallback
+        self.calls: list[tuple[str, dict[str, Any]]] = []
+
+    def enqueue(self, response: Any) -> None:
+        """Script one more response."""
+        self._responses.append(response)
+
+    def __call__(self, prompt: str, schema: dict[str, Any]) -> Any:
+        self.calls.append((prompt, schema))
+        if self._responses:
+            response = self._responses.pop(0)
+            logger.debug("StubModel call #%d -> %r", len(self.calls), response)
+            return response
+        if self._fallback is not None:
+            return self._fallback(prompt, schema)
+        raise StubModelExhausted(
+            f"unscripted model call (call #{len(self.calls)}): "
+            f"{prompt[:120]!r}"
+        )
+
+
+def rule_classifier_fallback(movable_prefixes: tuple[str, ...] = ("obj:",)):
+    """A deterministic classify-fallback for tests: places and furniture
+    are structure; everything else movable is STATE. Raises on non-classify
+    prompts so unscripted extraction/resolution still fails loudly."""
+
+    def _durability(subject: str) -> str:
+        if subject.startswith("place:") or subject.split(":")[-1] in {"desk", "drawer"}:
+            return "CONSTITUTIVE"
+        return "STATE"
+
+    def fallback(prompt: str, schema: dict[str, Any]) -> Any:
+        if not prompt.startswith("Classify the lifetime"):
+            raise StubModelExhausted(f"unscripted non-classify call: {prompt[:80]!r}")
+        # Batch path (INGEST-HARDENING-V1): the schema asks for `verdicts` and the
+        # prompt lists facts as "N. entity · attribute · value".
+        if "verdicts" in schema.get("properties", {}):
+            verdicts = []
+            for line in prompt.splitlines():
+                m = re.match(r"\s*(\d+)\.\s+(\S+)\s+·", line)
+                if m:
+                    verdicts.append({
+                        "index": int(m.group(1)),
+                        "durability": _durability(m.group(2)),
+                        "class_confidence": 0.9,
+                    })
+            return {"verdicts": verdicts}
+        # Per-row path.
+        subject = ""
+        for line in prompt.splitlines():
+            if line.startswith("Subject: "):
+                subject = line.removeprefix("Subject: ")
+        return {"durability": _durability(subject), "class_confidence": 0.9}
+
+    return fallback

patternbuffer/thunks.py

@@ -0,0 +1,245 @@
+"""Thunks and the resolver: the lazy world (whitepaper §8, P3).
+
+An unresolved aspect is a first-class row (value_type='unresolved') whose
+value carries its policy and any accreted constraints. Forcing evaluates
+exactly once; the memo is the fold (generated rows supersede the thunk's
+key). Thunks move without resolving — containment supersession touches
+the holder, never the thunk row.
+
+The resolver is the only component that may append `generated` (§12).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from patternbuffer.buffer import PatternBuffer
+from patternbuffer.classify import CONSTITUTIVE, DISPOSITIONAL, Classifier
+from patternbuffer.codec import json_default
+from patternbuffer.indexes import Indexes
+from patternbuffer.model import CANON, Assertion
+from patternbuffer.roles import WriterRole
+
+logger = logging.getLogger(__name__)
+
+INVENT_UNDER_CANON = "invent_under_canon"
+OBSERVE_OR_UNKNOWN = "observe_or_unknown"
+DENY = "deny"
+POLICIES = frozenset({INVENT_UNDER_CANON, OBSERVE_OR_UNKNOWN, DENY})
+
+UNKNOWN = object()  # the honest answer in observe_or_unknown worlds
+
+_RESOLVE_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "items": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "value": {},
+                    "detail": {"type": "string"},
+                },
+                "required": ["value"],
+            },
+        }
+    },
+    "required": ["items"],
+}
+
+
+class ResolutionDenied(PermissionError):
+    """The thunk's policy refuses resolution (deny/reserve)."""
+
+
+@dataclass(frozen=True, slots=True)
+class ThunkView:
+    entity: str
+    aspect: str
+    policy: str
+    constraints: tuple[str, ...]
+    assertion_id: str
+
+
+class Resolver:
+    def __init__(
+        self,
+        buffer: PatternBuffer,
+        classifier: Classifier,
+        indexes: Indexes,
+        role: WriterRole,
+        model: Callable[[str, dict], Any],
+        world_policy: str = INVENT_UNDER_CANON,
+    ) -> None:
+        if world_policy not in POLICIES:
+            raise ValueError(f"unknown policy {world_policy!r}")
+        self._buffer = buffer
+        self._classifier = classifier
+        self._indexes = indexes
+        self._role = role
+        self._model = model
+        self._world_policy = world_policy
+
+    # ----------------------------------------------------------- the table
+
+    def thunk_table(self, frame: str = CANON) -> list[ThunkView]:
+        """The frontier: open (un-superseded, unresolved) aspects."""
+        out = []
+        for row in self._buffer.visible(frame=frame):
+            if row.value_type != "unresolved":
+                continue
+            result = self._indexes.fold_key(row.entity, row.attribute, frame)
+            if result.winner is None or result.winner.id != row.id:
+                continue  # superseded: resolved or overwritten
+            if self._resolved_marker(row) is not None:
+                continue
+            spec = row.value if isinstance(row.value, dict) else {}
+            out.append(
+                ThunkView(
+                    entity=row.entity,
+                    aspect=row.attribute,
+                    policy=spec.get("policy", self._world_policy),
+                    constraints=tuple(spec.get("constraints", ())),
+                    assertion_id=row.id,
+                )
+            )
+        return out
+
+    def _resolved_marker(self, thunk_row: Assertion) -> Assertion | None:
+        markers = self._buffer.visible(entity=thunk_row.id, attribute="resolved_by")
+        return markers[0] if markers else None
+
+    # ------------------------------------------------------------- forcing
+
+    def resolve(
+        self,
+        entity: str,
+        aspect: str,
+        frame: str = CANON,
+        access: object | None = None,
+    ) -> list[Assertion] | object:
+        """Force a thunk per policy. Memoized: a second force serves the
+        cache. `access` is the observer-position seam (spec §9.2) —
+        accepted, not yet exercised in the spike."""
+        thunk = self._find_thunk_row(entity, aspect, frame)
+
+        # Memoized: a spent thunk serves its cache, forever, identically.
+        if thunk is not None:
+            marker = self._resolved_marker(thunk)
+            if marker is not None:
+                ids = marker.value if isinstance(marker.value, list) else [marker.value]
+                return [self._buffer.get(i) for i in ids]
+
+        # Concrete state on the key answers without any thunk machinery.
+        fold = self._indexes.fold_key(entity, aspect, frame)
+        if fold.winner is not None and fold.winner.value_type != "unresolved":
+            return [fold.winner]
+
+        if thunk is None:
+            return UNKNOWN if self._world_policy == OBSERVE_OR_UNKNOWN else []
+
+        spec = thunk.value if isinstance(thunk.value, dict) else {}
+        policy = spec.get("policy", self._world_policy)
+        if policy == DENY:
+            raise ResolutionDenied(f"{entity}·{aspect} is sealed (policy=deny)")
+        if policy == OBSERVE_OR_UNKNOWN:
+            return UNKNOWN  # never invents; only observation resolves
+        return self._invent(thunk, spec, frame)
+
+    def _find_thunk_row(self, entity: str, aspect: str, frame: str) -> Assertion | None:
+        canonical = self._indexes.resolve_entity(entity)
+        rows = [
+            r
+            for r in self._buffer.visible(attribute=aspect, frame=frame)
+            if r.value_type == "unresolved"
+            and self._indexes.resolve_entity(r.entity) == canonical
+        ]
+        return rows[-1] if rows else None
+
+    def _invent(self, thunk_row: Assertion, spec: dict, frame: str) -> list[Assertion]:
+        constraints = self._inherited_constraints(thunk_row.entity, frame)
+        constraints += [str(c) for c in spec.get("constraints", ())]
+        prompt = (
+            f"Resolve an unestablished aspect of a fictional world: the "
+            f"{thunk_row.attribute} of {thunk_row.entity}.\n"
+            "Invent content CONSISTENT WITH every constraint below; introduce "
+            "nothing that contradicts them. Plain, concrete items only.\n\n"
+            "Constraints (canon, in force):\n- " + "\n- ".join(constraints or ["(none)"])
+        )
+        out = self._model(prompt, _RESOLVE_SCHEMA)
+        appended: list[Assertion] = []
+        if thunk_row.attribute == "contents":
+            # Contents are never literal rows on one key (P2: emptiness and
+            # contents derive from the tree). Invention mints entities with
+            # containment edges; the contents query serves them forever.
+            for item in out["items"]:
+                eid = f"obj:gen_{self._buffer.head() + 1}"
+                kind_row = self._buffer.append(
+                    entity=eid, attribute="kind", value=str(item.get("kind", "object")),
+                    frame=frame, status="generated", role=self._role,
+                )
+                name_row = self._buffer.append(
+                    entity=eid, attribute="name", value=str(item["value"]),
+                    frame=frame, status="generated", role=self._role,
+                )
+                edge = self._buffer.append(
+                    entity=eid, attribute="in", value=thunk_row.entity,
+                    value_type="entity", valid_from=thunk_row.valid_from,
+                    frame=frame, status="generated", role=self._role,
+                )
+                self._classifier.classify(kind_row)   # guardrail: CONSTITUTIVE
+                self._classifier.classify(name_row)   # guardrail: CONSTITUTIVE
+                # The resolver holds the world context here: invented
+                # contents are movables. Judgment injected, log untouched.
+                self._classifier.set(edge.id, "STATE")
+                appended.append(edge)
+        else:
+            for item in out["items"]:
+                row = self._buffer.append(
+                    entity=thunk_row.entity,
+                    attribute=thunk_row.attribute,
+                    value=item["value"],
+                    value_type="literal",
+                    valid_from=thunk_row.valid_from,
+                    frame=frame,
+                    status="generated",
+                    role=self._role,
+                )
+                self._classifier.classify(row)
+                appended.append(row)
+        marker = self._buffer.append(
+            entity=thunk_row.id,
+            attribute="resolved_by",
+            value=[a.id for a in appended],
+            status="generated",
+            role=self._role,
+        )
+        self._classifier.classify(marker)  # closed under its own operations
+        logger.info(
+            "resolved %s·%s -> %d generated row(s)",
+            thunk_row.entity, thunk_row.attribute, len(appended),
+        )
+        return appended
+
+    def _inherited_constraints(self, entity: str, frame: str) -> list[str]:
+        """Constraint inheritance: CONSTITUTIVE + DISPOSITIONAL rows of the
+        entity and every containment ancestor (whitepaper §8)."""
+        constraints: list[str] = []
+        scope = [entity, *self._indexes.locate(entity, frame=frame)]
+        for holder in scope:
+            for attr, result in self._indexes.current_state(holder, frame=frame).items():
+                row = result.winner
+                if row is None or row.value_type == "unresolved":
+                    continue
+                if result.quantity is not None:
+                    continue  # an accrue running total is not a scene-invention
+                              # constraint, and its winner is a delta row, never
+                              # the value (never inherit a delta as a constraint)
+                if self._classifier.durability(row.id) in {CONSTITUTIVE, DISPOSITIONAL}:
+                    constraints.append(
+                        f"{holder} · {attr} · {json.dumps(row.value, default=json_default)}"
+                    )
+        return constraints

patternbuffer/tmaint.py

@@ -0,0 +1,122 @@
+"""Truth maintenance: conflict detection (derived) and retraction (log).
+
+A fired flag is a sidecar row pointing at the assertions in tension —
+both rows coexist in the log untouched (whitepaper §5.1/§7.2). The flag
+stands until an explicit retraction/supersession resolves it; resolution
+is never required for the flag to exist, and a silent merge is the
+failure the chapter test's feature 8 exists to catch.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from patternbuffer.buffer import PatternBuffer
+from patternbuffer.classify import Classifier
+from patternbuffer.indexes import Indexes
+from patternbuffer.model import ATTR_PREFIX, Assertion
+from patternbuffer.roles import WriterRole
+from patternbuffer.semantics import AttributeSemantics
+
+logger = logging.getLogger(__name__)
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS sidecar_conflicts (
+  key_entity    TEXT NOT NULL,
+  key_attribute TEXT NOT NULL,
+  key_frame     TEXT NOT NULL,
+  kind          TEXT NOT NULL,
+  assertion_ids TEXT NOT NULL,
+  PRIMARY KEY (key_entity, key_attribute, key_frame, kind)
+);
+"""
+
+
+@dataclass(frozen=True, slots=True)
+class Conflict:
+    entity: str
+    attribute: str
+    frame: str
+    kind: str  # 'constitutive_contradiction' | 'cross_source'
+    assertion_ids: tuple[str, ...]
+
+
+class TruthMaintenance:
+    def __init__(
+        self,
+        buffer: PatternBuffer,
+        classifier: Classifier,
+        indexes: Indexes,
+        role: WriterRole,
+        semantics: AttributeSemantics | None = None,
+    ) -> None:
+        self._buffer = buffer
+        self._classifier = classifier
+        self._indexes = indexes
+        self._role = role
+        self._semantics = semantics or AttributeSemantics(buffer)
+        buffer.raw_connection().executescript(_SCHEMA)
+
+    def scan(self) -> list[Conflict]:
+        """Re-derive the conflict table from the log. Rebuildable: the
+        table is dropped and refilled on every scan."""
+        keys: set[tuple[str, str, str]] = set()
+        for row in self._buffer.visible():
+            if (
+                row.entity.startswith("a:")
+                or row.entity.startswith(ATTR_PREFIX)
+                or self._semantics.is_set_valued(row.attribute)
+            ):
+                continue
+            fold_attr = self._indexes.fold_attribute(row.attribute)
+            keys.add(
+                (
+                    self._indexes._resolve(row.entity),
+                    "in" if fold_attr == self._indexes.fold_attribute("in") else row.attribute,
+                    row.frame,
+                )
+            )
+        conflicts: list[Conflict] = []
+        for entity, attribute, frame in sorted(keys):
+            result = self._indexes.fold_key(entity, attribute, frame)
+            if result.conflicted:
+                kind = (
+                    "constitutive_contradiction"
+                    if result.winner is not None
+                    and self._classifier.durability(result.winner.id) == "CONSTITUTIVE"
+                    else "cross_source"
+                )
+                conflicts.append(
+                    Conflict(entity, attribute, frame, kind, result.conflicting)
+                )
+        conn = self._buffer.raw_connection()
+        conn.execute("DELETE FROM sidecar_conflicts")
+        for c in conflicts:
+            conn.execute(
+                "INSERT OR REPLACE INTO sidecar_conflicts VALUES (?, ?, ?, ?, ?)",
+                (c.entity, c.attribute, c.frame, c.kind, ",".join(c.assertion_ids)),
+            )
+        conn.commit()
+        if conflicts:
+            logger.info("truth maintenance: %d open conflict(s)", len(conflicts))
+        return conflicts
+
+    def open_conflicts(self) -> list[Conflict]:
+        rows = self._buffer.raw_connection().execute(
+            "SELECT key_entity, key_attribute, key_frame, kind, assertion_ids"
+            " FROM sidecar_conflicts ORDER BY key_entity"
+        ).fetchall()
+        return [Conflict(r[0], r[1], r[2], r[3], tuple(r[4].split(","))) for r in rows]
+
+    def retract(self, target: Assertion | str, reason: str) -> Assertion:
+        """Append a retraction meta-assertion. The target survives in the
+        log; folds exclude it from the retraction's asserted_at onward."""
+        target_id = target if isinstance(target, str) else target.id
+        return self._buffer.append(
+            entity=target_id,
+            attribute="retracts",
+            value=reason,
+            status="retracted",
+            role=self._role,
+        )

pbuffer-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,25 @@
+patternbuffer/__init__.py,sha256=TldvxbxoDG2Uh5ZWic5vae41Lk2ygFV2nDtD0McCp2Y,14084
+patternbuffer/buffer.py,sha256=EHwZ0dZpugw_pEcmw4alKldBcx-lpT6wa1zMHpBM34k,11502
+patternbuffer/classify.py,sha256=UWclf-HX8NXvv90QdWhyPPrPNhkYPNhtbKlKoPSS8Kc,15829
+patternbuffer/codec.py,sha256=yitrIOZKvzQwkUWDXfyXgl3ISZyaw7lqIsQ5TmaxY74,4544
+patternbuffer/dump.py,sha256=LUmh9FWu1JyOg5qvsqwcKrE84f6jMJ_lcgMIwydJrTI,4152
+patternbuffer/identity.py,sha256=lAa0lGp4YbPTGd5DjCCq8cwqmgwzdLHevbiw9eVtOss,62237
+patternbuffer/indexes.py,sha256=vaGPmTsGnsRSndKbpvqC4VylrxpdIFn6T2nxQkrJUd8,71177
+patternbuffer/ingest.py,sha256=0CuyO2j2ccnq3ixE6Tcv_3rn2mjHf6mTKlFjbDB48Ug,31479
+patternbuffer/mcp.py,sha256=RNq7CrbMs0XvO0e3quGZdZDerDTeRBGzaW9lSsAtSf8,12707
+patternbuffer/model.py,sha256=KD1qyvKGYaMfQqu_4IP_Z8gTBk80tTRDz_SvTMYwKB4,3594
+patternbuffer/porcelain.py,sha256=ho9nKGABjYBcA4rpyTfhSCjGFZlC4pROlXdebscw45E,45546
+patternbuffer/project.py,sha256=p5eTP2n9NhNY_QrqQgdjgUZ1whrOjuKzPtEHoOv2wzo,20069
+patternbuffer/refer.py,sha256=MHPrHCTmcqsxBKl4GHGoZHwY6kiepjsxiO1Ku5PvcvA,11482
+patternbuffer/roles.py,sha256=99cMRA9OBahf6FrsNhq3jieGJvJdRaacwMBmpaQLyJA,2832
+patternbuffer/salience.py,sha256=6pW5UQlJzq9Saze7n--UGRA88g_TkhPhkPt29yD6Vgc,5881
+patternbuffer/semantics.py,sha256=3pdyYVCg6F7U3-8wNkBSzr__NZPLM5za2Yz8iC6_qLA,7132
+patternbuffer/testing.py,sha256=PrypcXSNw1zYARNs6nmpul9YiAAHxE4vnLVeX8twFYI,3554
+patternbuffer/thunks.py,sha256=14kDo0lpPv3od4gUmFA7IER9VlW097QbgrBmFrLArHw,10076
+patternbuffer/tmaint.py,sha256=uoQ4-fSDmjt0tcziIRozX5aubzVu_PKWRTX2eSuL2yw,4527
+pbuffer-0.1.0.dist-info/licenses/LICENSE,sha256=hdX78D_ZnB_tB1okAu3IZkSQ7EHby2xULfQv0GtKNyQ,1067
+pbuffer-0.1.0.dist-info/METADATA,sha256=zaOBHCuG1ceTgTQIf9F6o37SOsBChFZuc3Emq3IHMO8,8990
+pbuffer-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pbuffer-0.1.0.dist-info/entry_points.txt,sha256=pzltldXdPgdO0roKOrnJX09uDcKzZwbEoKRP-L3DEGQ,61
+pbuffer-0.1.0.dist-info/top_level.txt,sha256=jVATFoYr1S5GedARCY2mZlb48Gu4CwJwrCuL3_6HZgI,14
+pbuffer-0.1.0.dist-info/RECORD,,

pbuffer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pbuffer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+patternbuffer-mcp = patternbuffer.mcp:main

pbuffer-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+patternbuffer