anagrapheus 0.1.1__tar.gz

anagrapheus-0.1.1/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.3
+Name: anagrapheus
+Version: 0.1.1
+Summary: Event-sourced timeline, belief store, and identity layer for long-running agents.
+Author: Anentropic
+Author-email: Anentropic <ego@anentropic.com>
+Requires-Dist: anyio>=4.0
+Requires-Dist: doxastica>=0.2
+Requires-Dist: pydantic>=2.11
+Requires-Dist: pydantic-ai-slim>=2
+Requires-Dist: pydantic-ai-slim[anthropic]>=2 ; extra == 'anthropic'
+Requires-Dist: pydantic-ai-slim[openai]>=2 ; extra == 'openai'
+Requires-Python: >=3.14
+Provides-Extra: anthropic
+Provides-Extra: openai
+Description-Content-Type: text/markdown
+
+# anagrapheus
+
+[![CI](https://github.com/anentropic/anagrapheus/actions/workflows/ci.yml/badge.svg)](https://github.com/anentropic/anagrapheus/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/anagrapheus)](https://pypi.org/project/anagrapheus/)
+[![Python](https://img.shields.io/badge/python-3.14%2B-blue)](https://www.python.org/)
+[![License: BSD-3-Clause](https://img.shields.io/badge/license-BSD--3--Clause-blue)](https://github.com/anentropic/anagrapheus/blob/main/LICENSE)
+
+An event-sourced timeline, belief store and identity layer for long-running LLM agents. One append-only event log is the authoritative record of a run; per-agent beliefs, entity identity, a consolidated history and assembled prompts are all projections of it that can be dropped and rebuilt. Every model call made through `PinnedModel`, and every tool wrapped with `pinned_tool`, is pinned to the log, so a recorded run replays offline, exactly, without reaching the model, and a run whose prompts have changed reports where it diverged instead of quietly drawing new answers.
+
+It is for Python developers building agents and simulations that run for many turns and hold private beliefs about each other: negotiations, games, interactive fiction. It builds on [pydantic-ai](https://ai.pydantic.dev/) for the model call and works with any provider pydantic-ai supports.
+
+## Installation
+
+anagrapheus needs Python 3.14 or later.
+
+```bash
+pip install anagrapheus  # or: uv add anagrapheus
+```
+
+The base install runs offline. To call a real provider, add its extra: `anagrapheus[anthropic]` or `anagrapheus[openai]` (the OpenAI SDK, also used for OpenAI-compatible routes such as OpenRouter).
+
+## Documentation
+
+**[anentropic.github.io/anagrapheus](https://anentropic.github.io/anagrapheus/)** has a getting-started tutorial, how-to guides for each layer, explanations of the design, and the API reference.
+
+A worked example, a four-round EU and UK negotiation that uses every layer, lives in [`examples/negotiation/`](examples/negotiation/). From a clone, run it offline with `uv run python -m examples.negotiation`.
+
+## Development
+
+See [DEVELOP.md](DEVELOP.md) for the full guide.
+
+### Setup
+
+```bash
+# Install dependencies (the dev group includes the anthropic and openai extras)
+uv sync --dev
+
+# Install git hooks
+prek install
+```
+
+### Quality gates
+
+Before committing, run the hooks:
+
+```bash
+prek run --all-files  # file hygiene, ruff lint and format, uv lock, basedpyright, blacken-docs
+```
+
+The hooks do not run the tests. Run each gate individually with:
+
+```bash
+uv run basedpyright         # Type checking (strict mode)
+uv run ruff check           # Linting
+uv run ruff format --check  # Formatting
+uv run pytest               # Tests
+```
+
+`uv run pytest` skips the live smoke tests, which reach a real provider. Opt in with `uv run pytest -m tier3`, which needs an API key for at least one of the routes in `tests/tier3`.
+
+### Docs
+
+```bash
+uv sync --dev --group docs
+just docs-serve  # or: just docs-build
+```
+
+Both recipes regenerate `CHANGELOG.md` with git-cliff before building.
+
+## License
+
+BSD-3-Clause. See [LICENSE](LICENSE).

anagrapheus-0.1.1/README.md

@@ -0,0 +1,72 @@
+# anagrapheus
+
+[![CI](https://github.com/anentropic/anagrapheus/actions/workflows/ci.yml/badge.svg)](https://github.com/anentropic/anagrapheus/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/anagrapheus)](https://pypi.org/project/anagrapheus/)
+[![Python](https://img.shields.io/badge/python-3.14%2B-blue)](https://www.python.org/)
+[![License: BSD-3-Clause](https://img.shields.io/badge/license-BSD--3--Clause-blue)](https://github.com/anentropic/anagrapheus/blob/main/LICENSE)
+
+An event-sourced timeline, belief store and identity layer for long-running LLM agents. One append-only event log is the authoritative record of a run; per-agent beliefs, entity identity, a consolidated history and assembled prompts are all projections of it that can be dropped and rebuilt. Every model call made through `PinnedModel`, and every tool wrapped with `pinned_tool`, is pinned to the log, so a recorded run replays offline, exactly, without reaching the model, and a run whose prompts have changed reports where it diverged instead of quietly drawing new answers.
+
+It is for Python developers building agents and simulations that run for many turns and hold private beliefs about each other: negotiations, games, interactive fiction. It builds on [pydantic-ai](https://ai.pydantic.dev/) for the model call and works with any provider pydantic-ai supports.
+
+## Installation
+
+anagrapheus needs Python 3.14 or later.
+
+```bash
+pip install anagrapheus  # or: uv add anagrapheus
+```
+
+The base install runs offline. To call a real provider, add its extra: `anagrapheus[anthropic]` or `anagrapheus[openai]` (the OpenAI SDK, also used for OpenAI-compatible routes such as OpenRouter).
+
+## Documentation
+
+**[anentropic.github.io/anagrapheus](https://anentropic.github.io/anagrapheus/)** has a getting-started tutorial, how-to guides for each layer, explanations of the design, and the API reference.
+
+A worked example, a four-round EU and UK negotiation that uses every layer, lives in [`examples/negotiation/`](examples/negotiation/). From a clone, run it offline with `uv run python -m examples.negotiation`.
+
+## Development
+
+See [DEVELOP.md](DEVELOP.md) for the full guide.
+
+### Setup
+
+```bash
+# Install dependencies (the dev group includes the anthropic and openai extras)
+uv sync --dev
+
+# Install git hooks
+prek install
+```
+
+### Quality gates
+
+Before committing, run the hooks:
+
+```bash
+prek run --all-files  # file hygiene, ruff lint and format, uv lock, basedpyright, blacken-docs
+```
+
+The hooks do not run the tests. Run each gate individually with:
+
+```bash
+uv run basedpyright         # Type checking (strict mode)
+uv run ruff check           # Linting
+uv run ruff format --check  # Formatting
+uv run pytest               # Tests
+```
+
+`uv run pytest` skips the live smoke tests, which reach a real provider. Opt in with `uv run pytest -m tier3`, which needs an API key for at least one of the routes in `tests/tier3`.
+
+### Docs
+
+```bash
+uv sync --dev --group docs
+just docs-serve  # or: just docs-build
+```
+
+Both recipes regenerate `CHANGELOG.md` with git-cliff before building.
+
+## License
+
+BSD-3-Clause. See [LICENSE](LICENSE).

anagrapheus-0.1.1/pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "anagrapheus"
+version = "0.1.1"
+description = "Event-sourced timeline, belief store, and identity layer for long-running agents."
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "anyio>=4.0",
+    "doxastica>=0.2",
+    "pydantic>=2.11",
+    "pydantic-ai-slim>=2",
+]
+
+[[project.authors]]
+name = "Anentropic"
+email = "ego@anentropic.com"
+
+[project.optional-dependencies]
+anthropic = ["pydantic-ai-slim[anthropic]>=2"]
+openai = ["pydantic-ai-slim[openai]>=2"]
+
+[build-system]
+requires = ["uv_build>=0.9.18,<1.0.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "anagrapheus[anthropic,openai]",
+    "basedpyright>=1.38.0",
+    "ipython>=9.10.0",
+    "pdbpp>=0.12.0.post1",
+    "pytest>=8.0.0",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.15.1",
+    "hypothesis>=6.130",
+]
+docs = [
+    "mkdocs>=1.6.0",
+    "mkdocs-material>=9.7.0",
+    "mkdocstrings[python]>=0.26.0",
+    "mkdocs-gen-files>=0.5.0",
+    "mkdocs-literate-nav>=0.6.0",
+    "mkdocs-section-index>=0.3.0",
+]
+
+[tool.pyright]
+pythonVersion = "3.14"
+typeCheckingMode = "strict"
+include = [
+    "src",
+    "tests",
+]
+reportPrivateUsage = false
+
+[tool.ruff]
+target-version = "py314"
+line-length = 100
+src = ["src"]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",
+    "I",
+    "UP",
+    "B",
+    "SIM",
+    "TCH",
+    "D",
+]
+ignore = [
+    "D1",
+    "D202",
+    "D203",
+    "D212",
+    "D401",
+    "D413",
+]
+
+[tool.ruff.lint.flake8-type-checking]
+runtime-evaluated-base-classes = [
+    "pydantic.BaseModel",
+    "anagrapheus.timeline.envelope.DomainEvent",
+]
+
+[tool.pytest.ini_options]
+addopts = "-v -m 'not tier3'"
+markers = ["tier3: reaches a real provider; needs a key for at least one route in tests/tier3"]

anagrapheus-0.1.1/pyproject.toml.orig

@@ -0,0 +1,92 @@
+[project]
+name = "anagrapheus"
+version = "0.1.1"
+description = "Event-sourced timeline, belief store, and identity layer for long-running agents."
+readme = "README.md"
+authors = [
+    { name = "Anentropic", email = "ego@anentropic.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "anyio>=4.0",
+    "doxastica>=0.2",
+    "pydantic>=2.11",
+    "pydantic-ai-slim>=2",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.18,<1.0.0"]
+build-backend = "uv_build"
+
+[project.optional-dependencies]
+# Only tier 3 -- the live smoke test -- needs a real provider. Kept out of the base
+# install so the library stays provider-agnostic: pydantic-ai is the seam, and which
+# provider sits behind it is the consumer's choice.
+anthropic = ["pydantic-ai-slim[anthropic]>=2"]
+# The OpenAI SDK, which pydantic-ai uses for OpenAI itself and for every
+# OpenAI-compatible route -- OpenRouter among them. Named for what it installs, as
+# pydantic-ai names its own extra, rather than for one provider that uses it.
+openai = ["pydantic-ai-slim[openai]>=2"]
+
+[dependency-groups]
+dev = [
+    "anagrapheus[anthropic,openai]",
+    "basedpyright>=1.38.0",
+    "ipython>=9.10.0",
+    "pdbpp>=0.12.0.post1",
+    "pytest>=8.0.0",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.15.1",
+    "hypothesis>=6.130",
+]
+docs = [
+    "mkdocs>=1.6.0",
+    "mkdocs-material>=9.7.0",
+    "mkdocstrings[python]>=0.26.0",
+    "mkdocs-gen-files>=0.5.0",
+    "mkdocs-literate-nav>=0.6.0",
+    "mkdocs-section-index>=0.3.0",
+]
+
+[tool.pyright]
+# The minimum supported version, not the dev version: an explicit pythonVersion
+# overrides the running interpreter, so setting it to the dev version lets newer
+# stdlib and typing APIs type-check clean on *every* CI leg -- including the
+# minimum-version leg whose job is to catch them -- and fail at runtime instead.
+# Kept in step with requires-python and ruff's target-version below.
+pythonVersion = "3.14"
+typeCheckingMode = "strict"
+include = ["src", "tests"]
+reportPrivateUsage = false
+
+[tool.ruff]
+target-version = "py314"
+line-length = 100
+src = ["src"]
+
+[tool.ruff.lint.flake8-type-checking]
+# pydantic resolves field annotations at model build; imports its models use must
+# stay runtime even when they look annotation-only.
+runtime-evaluated-base-classes = [
+    "pydantic.BaseModel",
+    "anagrapheus.timeline.envelope.DomainEvent",
+]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "SIM", "TCH", "D"]
+ignore = [
+    "D1",    # don't require docstrings everywhere
+    "D202",  # allow blank line after docstring (common in tests)
+    "D203",  # conflicts with D211 (no blank line before class docstring)
+    "D212",  # conflicts with D213 (multiline summary on second line)
+    "D401",  # imperative mood is awkward for dunder methods
+    "D413",  # blank line after last section not required
+]
+
+[tool.pytest.ini_options]
+addopts = "-v -m 'not tier3'"
+markers = [
+    # Tier 3 costs money and needs a key, so it is excluded by default rather than
+    # skipped noisily on every local run. `-m tier3` opts in.
+    "tier3: reaches a real provider; needs a key for at least one route in tests/tier3",
+]

anagrapheus-0.1.1/src/anagrapheus/__init__.py

@@ -0,0 +1,45 @@
+"""Event-sourced timeline, belief store, identity and chronicle for long-running agents."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from . import assembly, beliefs, chronicle, identity, provider, timeline
+
+if TYPE_CHECKING:
+    from anagrapheus.timeline.registry import EventTypeRegistry
+
+__all__ = [
+    "assembly",
+    "beliefs",
+    "chronicle",
+    "identity",
+    "provider",
+    "register_builtin_events",
+    "timeline",
+]
+
+# A library logs and never configures: without this, a consumer that has not set up
+# logging would see Python's last-resort handler print our warnings to stderr. Every
+# module logs under `anagrapheus.<subpackage>.<module>`, so one `getLogger("anagrapheus")`
+# turns all of it up or down.
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+
+def register_builtin_events(registry: EventTypeRegistry) -> None:
+    """
+    Register every event type this library emits, across all its subpackages.
+
+    Under-registering is a live failure mode rather than an untidiness: an application
+    that uses the pin ledger and the identity layer over one stream, but registers only
+    one subpackage's events, gets an
+    :class:`~anagrapheus.timeline.errors.UnknownEventType` the first time a reader
+    reaches the other's. Library events all live under the reserved namespace and can
+    never collide with an application's own, so registering them all is free.
+
+    The per-subpackage functions remain for a consumer using only one of them.
+    """
+    timeline.register_builtin_events(registry)
+    identity.register_builtin_events(registry)
+    beliefs.register_builtin_events(registry)

anagrapheus-0.1.1/src/anagrapheus/assembly/__init__.py

@@ -0,0 +1,81 @@
+"""
+Prompt assembly: what a model is shown, built only from what its role was granted.
+
+Prompt assembly is a projection of the log, like any other read model. This package
+gives it a shape:
+
+- a **grant** of :mod:`~anagrapheus.assembly.slices`, each reading at one position and
+  remembering what it handed out, so a role can read nothing it was not granted and a
+  context always knows its sources;
+- **parts** carrying a register, a rank and their sources, structured rather than
+  rendered (:mod:`~anagrapheus.assembly.parts`);
+- :func:`~anagrapheus.assembly.assemble.assemble`, which checks citations and labels
+  and fits a :class:`~anagrapheus.assembly.assemble.Budget` that never sheds a binding
+  part.
+
+Rendering, slot names, budgets and every schema are the application's. Pinning does
+not change: the rendered messages go through
+:class:`~anagrapheus.provider.PinnedModel` as before, and its content-addressed key
+makes any assembly change a miss.
+"""
+
+# Design: note 07; upstream agent-core doc 00 §2.
+
+from __future__ import annotations
+
+from anagrapheus.assembly.assemble import DEFAULT_SHED_ORDER, Budget, assemble, slices_of
+from anagrapheus.assembly.errors import (
+    AssemblyError,
+    BudgetExceeded,
+    MislabelledPart,
+    NotGranted,
+    StaleRead,
+    UncitedSource,
+)
+from anagrapheus.assembly.parts import (
+    Context,
+    EventRef,
+    GivenRef,
+    Part,
+    Register,
+    SectionRef,
+    Source,
+)
+from anagrapheus.assembly.render import render_labelled
+from anagrapheus.assembly.slices import (
+    BeliefSlice,
+    ChronicleSlice,
+    EventsSlice,
+    Given,
+    LogSlice,
+    Slice,
+    handed_out,
+)
+
+__all__ = [
+    "DEFAULT_SHED_ORDER",
+    "AssemblyError",
+    "BeliefSlice",
+    "Budget",
+    "BudgetExceeded",
+    "ChronicleSlice",
+    "Context",
+    "EventRef",
+    "EventsSlice",
+    "Given",
+    "GivenRef",
+    "LogSlice",
+    "MislabelledPart",
+    "NotGranted",
+    "Part",
+    "Register",
+    "SectionRef",
+    "Slice",
+    "Source",
+    "StaleRead",
+    "UncitedSource",
+    "assemble",
+    "handed_out",
+    "render_labelled",
+    "slices_of",
+]

anagrapheus-0.1.1/src/anagrapheus/assembly/assemble.py

@@ -0,0 +1,202 @@
+"""
+Putting a context together: run the assembler, check what it built, fit the budget.
+
+``assemble`` is small on purpose. The assembler is the application's and is required
+to be pure; what the library adds is the four checks that make a context trustworthy
+whatever the assembler does:
+
+- **The grant holds slices and nothing else.** A grant is a dataclass, and a field
+  that is not a :class:`~anagrapheus.assembly.slices.Slice` is refused, because a
+  store or a table in a grant is a way round every other check here.
+- **The slices agree on a position.** Two slices at different positions would build a
+  context no single moment of the log describes.
+- **A part cites only what was handed out**, and **prose is labelled as prose**: a
+  part citing a chronicle section must be ``generated``, and every section read must
+  be cited by one. That catches prose that loses its citation; it cannot stop an
+  assembler that cites a section *and* copies its words elsewhere, which is the limit
+  of checking structure rather than text.
+- **A grant is read for one assembly.** Its slices must be unread when it arrives, so
+  the context's ``read`` is exactly this call's.
+- **The budget never sheds a binding part**, and says what it shed.
+
+**Determinism is the contract this rests on.** Same log, same position, same grant: same
+parts, so the same rendered bytes, so a replay hits its pins. Nothing here can check
+that an assembler is pure. The application's own tests can: build a context over a fixed
+log at a fixed position, and compare
+:meth:`~anagrapheus.assembly.parts.Context.describe` with a stored golden.
+"""
+
+# Design: note 07 §4; upstream NVM U42 (the binding layer never sheds).
+
+from __future__ import annotations
+
+import dataclasses
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from anagrapheus.assembly.errors import (
+    AssemblyError,
+    BudgetExceeded,
+    MislabelledPart,
+    UncitedSource,
+)
+from anagrapheus.assembly.parts import Context, Register, SectionRef
+from anagrapheus.assembly.slices import Slice, handed_out
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Sequence
+
+    from anagrapheus.assembly.parts import Part
+
+__all__ = ["DEFAULT_SHED_ORDER", "Budget", "assemble", "slices_of"]
+
+#: Which registers a budget sheds first. ``binding`` is never in it.
+DEFAULT_SHED_ORDER: tuple[Register, ...] = (
+    Register.considered,
+    Register.generated,
+    Register.craft,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Budget:
+    """
+    How much a context may hold, and what goes first when it holds too much.
+
+    ``count`` is the application's token counter — the library does not guess at one.
+    Parts are shed register by register in ``order``, lowest ``rank`` first and, among
+    equals, the later part first. ``binding`` may not appear in ``order``: the binding
+    layer never sheds, because a context missing a binding fact is wrong, not short.
+    """
+
+    total: int
+    count: Callable[[Part], int]
+    order: tuple[Register, ...] = DEFAULT_SHED_ORDER
+
+    def __post_init__(self) -> None:
+        if Register.binding in self.order:
+            raise ValueError("a budget may never shed binding parts")
+
+    def fit(self, parts: Sequence[Part]) -> tuple[tuple[Part, ...], tuple[Part, ...]]:
+        """``(kept, shed)``, with ``kept`` in assembly order."""
+        sizes = [self.count(p) for p in parts]
+        binding = sum(
+            n for p, n in zip(parts, sizes, strict=True) if p.register is Register.binding
+        )
+        if binding > self.total:
+            raise BudgetExceeded(
+                f"the binding parts alone come to {binding} against a total of {self.total}; "
+                f"a call that cannot carry its invariants is not made"
+            )
+        used = sum(sizes)
+        dropped: set[int] = set()
+        for register in self.order:
+            candidates = sorted(
+                (i for i, p in enumerate(parts) if p.register is register),
+                key=lambda i: (parts[i].rank, -i),
+            )
+            for i in candidates:
+                if used <= self.total:
+                    break
+                dropped.add(i)
+                used -= sizes[i]
+        if used > self.total:
+            raise BudgetExceeded(
+                f"{used} remain against a total of {self.total} after shedding every "
+                f"register this budget may shed"
+            )
+        kept = tuple(p for i, p in enumerate(parts) if i not in dropped)
+        shed = tuple(p for i, p in enumerate(parts) if i in dropped)
+        return kept, shed
+
+
+def slices_of(grant: object) -> tuple[Slice, ...]:
+    """
+    A grant's slices, refusing a grant that holds anything else.
+
+    Frozen, so the assembler cannot swap a field for a store after the check has run.
+    """
+    if not dataclasses.is_dataclass(grant) or isinstance(grant, type):
+        raise TypeError(f"a grant is a dataclass instance of slices, not {type(grant).__name__}")
+    params: object = getattr(type(grant), "__dataclass_params__", None)
+    if not getattr(params, "frozen", False):
+        raise TypeError(
+            f"grant {type(grant).__name__} is not frozen; an assembler could replace a "
+            f"slice with a store after the grant was checked"
+        )
+    found: list[Slice] = []
+    for field in dataclasses.fields(grant):
+        value: object = getattr(grant, field.name)
+        if not isinstance(value, Slice):
+            raise TypeError(
+                f"grant field {field.name!r} holds a {type(value).__name__}, which is not a "
+                f"slice; a grant that carries a store is a way round the firewall"
+            )
+        found.append(value)
+    return tuple(found)
+
+
+def assemble[G](
+    role: str,
+    assembler: Callable[[G], Iterable[Part]],
+    grant: G,
+    *,
+    budget: Budget | None = None,
+) -> Context:
+    """
+    Run ``assembler`` over ``grant`` and return what ``role`` will be shown.
+
+    Raises :class:`~anagrapheus.assembly.errors.UncitedSource` for a part citing what
+    the grant never handed out, :class:`~anagrapheus.assembly.errors.MislabelledPart`
+    for prose presented as anything but ``generated``, and
+    :class:`~anagrapheus.assembly.errors.BudgetExceeded` when the binding parts alone
+    do not fit.
+    """
+    slices = slices_of(grant)
+    positions = {s.upto_seq for s in slices if s.upto_seq is not None}
+    if len(positions) > 1:
+        raise AssemblyError(
+            f"the slices in this grant read at different positions {sorted(positions)}; a "
+            f"context must describe one moment of the log"
+        )
+    if handed_out(slices):
+        # Ledgers live on the slices, so a reused grant would carry the last call's
+        # reads into this one's context, and let a part cite what this call never read.
+        raise AssemblyError(
+            "this grant was already read from; a grant is opened for one assembly, so "
+            "its context describes that call and no other"
+        )
+    parts = tuple(assembler(grant))
+    read = handed_out(slices)
+    known = set(read)
+    labelled: set[SectionRef] = set()
+    for part in parts:
+        for source in part.sources:
+            if source not in known:
+                raise UncitedSource(
+                    f"part {part.slot!r} cites {source}, which this grant never handed out"
+                )
+            if isinstance(source, SectionRef):
+                if part.register is not Register.generated:
+                    raise MislabelledPart(
+                        f"part {part.slot!r} cites chronicle prose as {part.register.value}; "
+                        f"model-written prose is advisory and must be labelled generated"
+                    )
+                labelled.add(source)
+    unlabelled = [s for s in read if isinstance(s, SectionRef) and s not in labelled]
+    if unlabelled:
+        # Checking only what parts cite would let prose in under another register by
+        # leaving the citation off. Every section read must be accounted for by a
+        # generated part, which makes an omitted citation an error rather than a bypass.
+        raise MislabelledPart(
+            f"{len(unlabelled)} chronicle section(s) were read and no generated part cites "
+            f"them ({unlabelled[0].section_id!r} first); read prose only to show it as prose"
+        )
+    kept, shed = (parts, ()) if budget is None else budget.fit(parts)
+    return Context(
+        role=role,
+        upto_seq=next(iter(positions), None),
+        parts=kept,
+        shed=shed,
+        read=read,
+    )