rememberstack 0.1.0__py3-none-any.whl

rememberstack/profiles/selfhost.py

@@ -0,0 +1,324 @@
+"""Executable self-host composition for the WP-0.4c Compose quickstart."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+from typing import Self
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from alembic import command
+from alembic.config import Config
+from pydantic import Field
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+import sqlalchemy
+from sqlalchemy import text
+from sqlalchemy.engine import Engine
+from sqlalchemy.engine import make_url
+
+from rememberstack.adapters import OpenRouterModelProvider
+from rememberstack.adapters import OpenRouterSettings
+from rememberstack.adapters.selfhost import LocalFSForgetManifestStore
+from rememberstack.adapters.selfhost import MinIOObjectStore
+from rememberstack.adapters.selfhost import MinIOSettings
+from rememberstack.model import DeploymentBootstrapInput
+from rememberstack.model import PipelineStage
+from rememberstack.spine import DeploymentBootstrapper
+from rememberstack.spine import RecipeRegistry
+from rememberstack.spine import seed_canonical_recipes
+from rememberstack.spine.settings import load_database_settings
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+    from rememberstack.adapters.selfhost import SelfHostWorkerLoop
+
+_SUPPORTED_WORKER_STAGES = (PipelineStage.CONVERT, PipelineStage.STRUCTURE)
+
+
+class SelfHostSettings(BaseSettings):
+    """One fresh self-host deployment's profile and process settings."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="REMEMBERSTACK_SELFHOST_", extra="ignore"
+    )
+
+    deployment_id: UUID
+    deployment_slug: str = Field(default="local", min_length=1)
+    deployment_name: str = Field(default="Local memory", min_length=1)
+    default_language: str = Field(default="en", min_length=1)
+    raw_bucket_name: str = Field(default="remember-raw", min_length=1)
+    artifacts_bucket_name: str = Field(default="remember-artifacts", min_length=1)
+    corpusfs_bucket_name: str = Field(default="remember-corpusfs", min_length=1)
+    lance_root: Path = Path("/var/lib/rememberstack/lance")
+    forget_manifest_root: Path = Path("/var/lib/rememberstack/forget-manifests")
+    migration_config: Path = Path("alembic.ini")
+    api_host: str = "0.0.0.0"
+    api_port: int = Field(default=8000, ge=1, le=65_535)
+    worker_rate_per_s: float = Field(default=20.0, gt=0)
+    worker_burst: float = Field(default=20.0, ge=1)
+    worker_fallback_poll_s: float = Field(default=5.0, gt=0)
+    worker_session_s: float = Field(default=3_600.0, gt=0)
+
+
+class _FreshDeploymentReadiness:
+    """Fail closed if a fresh quickstart sees portable forget history.
+
+    WP-0.4c establishes a fresh-deployment Compose skeleton. It must never
+    silently serve a restored deployment whose D74 manifests require the full
+    hard-forget recovery composition; finding any manifest stops startup.
+    """
+
+    def __init__(self, *, store: LocalFSForgetManifestStore) -> None:
+        """Bind the separately durable manifest root."""
+        self._store = store
+
+    def ensure_ready(self, *, deployment_id: UUID) -> tuple[UUID, ...]:
+        """Accept an empty root and refuse every non-empty restore."""
+        manifests = self._store.manifests(deployment_id=deployment_id)
+        if manifests:
+            raise RuntimeError(
+                "the Compose quickstart found portable hard-forget manifests;"
+                " restore requires the complete D74 self-host recovery profile"
+            )
+        return ()
+
+
+class SelfHostProfile:
+    """Compose the existing API and E0 workers over PostgreSQL, MinIO, and Lance."""
+
+    def __init__(
+        self,
+        *,
+        settings: SelfHostSettings,
+        engine: Engine,
+        raw_store: MinIOObjectStore,
+        artifact_store: MinIOObjectStore,
+        corpusfs_store: MinIOObjectStore,
+        model_provider: OpenRouterModelProvider,
+    ) -> None:
+        """Retain one dependency graph for an API, setup, or worker process."""
+        self._settings = settings
+        self._engine = engine
+        self._raw_store = raw_store
+        self._artifact_store = artifact_store
+        self._corpusfs_store = corpusfs_store
+        self._model_provider = model_provider
+
+    @classmethod
+    def from_settings(cls) -> Self:
+        """Load every external value through its typed settings boundary."""
+        profile_settings = SelfHostSettings.model_validate({})
+        minio_settings = MinIOSettings.model_validate({})
+        return cls(
+            settings=profile_settings,
+            engine=sqlalchemy.create_engine(
+                load_database_settings().sqlalchemy_url(), pool_pre_ping=True
+            ),
+            raw_store=MinIOObjectStore(
+                bucket=profile_settings.raw_bucket_name, settings=minio_settings
+            ),
+            artifact_store=MinIOObjectStore(
+                bucket=profile_settings.artifacts_bucket_name, settings=minio_settings
+            ),
+            corpusfs_store=MinIOObjectStore(
+                bucket=profile_settings.corpusfs_bucket_name, settings=minio_settings
+            ),
+            model_provider=OpenRouterModelProvider(
+                settings=OpenRouterSettings.model_validate({})
+            ),
+        )
+
+    def close(self) -> None:
+        """Dispose this process's explicitly owned database pool."""
+        self._engine.dispose()
+
+    def setup(self) -> None:
+        """Apply migrations, provision buckets, bootstrap core rows, and seed recipes."""
+        migration = Config(str(self._settings.migration_config))
+        migration.set_main_option(
+            "sqlalchemy.url", load_database_settings().sqlalchemy_url()
+        )
+        command.upgrade(config=migration, revision="head")
+        self._raw_store.ensure_bucket()
+        self._artifact_store.ensure_bucket()
+        self._corpusfs_store.ensure_bucket()
+        self._settings.forget_manifest_root.mkdir(parents=True, exist_ok=True)
+        DeploymentBootstrapper(engine=self._engine).bootstrap_deployment(
+            deployment_input=DeploymentBootstrapInput(
+                deployment_id=self._settings.deployment_id,
+                slug=self._settings.deployment_slug,
+                name=self._settings.deployment_name,
+                default_language=self._settings.default_language,
+                raw_bucket=f"s3://{self._settings.raw_bucket_name}",
+                artifacts_bucket=f"s3://{self._settings.artifacts_bucket_name}",
+                corpusfs_bucket=f"s3://{self._settings.corpusfs_bucket_name}",
+            )
+        )
+        seed_canonical_recipes(
+            registry=RecipeRegistry(engine=self._engine),
+            deployment_id=self._settings.deployment_id,
+        )
+
+    def api(self) -> FastAPI:
+        """Build the existing HTTP surface over this self-host dependency graph."""
+        from rememberstack.adapters.selfhost.lance import LanceChunkIndex
+        from rememberstack.spine import DocumentCatalog
+        from rememberstack.spine import ForgetCatalog
+        from rememberstack.surfaces import build_api
+        from rememberstack.surfaces import QueryEngine
+        from rememberstack.surfaces import RecipeExecutor
+        from rememberstack.surfaces import RecipeSurface
+        from rememberstack.workers.e0 import UploadIngestor
+
+        query_engine = QueryEngine(
+            engine=self._engine,
+            search_index=LanceChunkIndex(root=self._settings.lance_root),
+            model_provider=self._model_provider,
+            embedding_model="qwen/qwen3-embedding-8b",
+        )
+        app = build_api(
+            engine=query_engine,
+            deployment_id=self._settings.deployment_id,
+            admission=ForgetCatalog(engine=self._engine),
+            readiness=_FreshDeploymentReadiness(
+                store=LocalFSForgetManifestStore(
+                    root=self._settings.forget_manifest_root
+                )
+            ),
+            surface=RecipeSurface(
+                registry=RecipeRegistry(engine=self._engine),
+                executor=RecipeExecutor(query_engine=query_engine),
+                deployment_id=self._settings.deployment_id,
+            ),
+            ingest=UploadIngestor(
+                catalog=DocumentCatalog(engine=self._engine),
+                raw_store=self._raw_store,
+                admission=ForgetCatalog(engine=self._engine),
+            ),
+        )
+
+        @app.get("/healthz", include_in_schema=False)
+        def healthz() -> dict[str, str]:
+            """Prove the process can reach its authoritative PostgreSQL spine."""
+            with self._engine.connect() as connection:
+                connection.execute(text("SELECT 1")).scalar_one()
+            return {"status": "ok"}
+
+        return app
+
+    def worker_loop(self, *, stage: PipelineStage) -> SelfHostWorkerLoop:
+        """Build one E0 route's ordinary LISTEN/NOTIFY worker loop."""
+        from rememberstack.adapters.selfhost import SelfHostTaskQueue
+        from rememberstack.adapters.selfhost import SelfHostWorkerLoop
+        from rememberstack.adapters.selfhost import TokenBucket
+        from rememberstack.core import ConversionRouter
+        from rememberstack.core import MarkdownPassthroughConverter
+        from rememberstack.model import ProcessingLane
+        from rememberstack.spine import DocumentCatalog
+        from rememberstack.spine import WorkLedger
+        from rememberstack.spine import WorkLedgerSettings
+        from rememberstack.workers import ConvertHandler
+        from rememberstack.workers import HandlerRegistry
+        from rememberstack.workers import StructureHandler
+        from rememberstack.workers import Worker
+
+        if stage not in _SUPPORTED_WORKER_STAGES:
+            raise ValueError(f"the Compose skeleton has no handler for stage {stage}")
+        catalog = DocumentCatalog(engine=self._engine)
+        registry = HandlerRegistry()
+        if stage is PipelineStage.CONVERT:
+            registry.register(
+                stage=stage,
+                handler=ConvertHandler(
+                    catalog=catalog,
+                    raw_store=self._raw_store,
+                    artifact_store=self._artifact_store,
+                    router=ConversionRouter(
+                        routes={"text/markdown": MarkdownPassthroughConverter()}
+                    ),
+                ),
+            )
+        else:
+            registry.register(
+                stage=stage,
+                handler=StructureHandler(
+                    catalog=catalog,
+                    artifact_store=self._artifact_store,
+                    model_provider=self._model_provider,
+                ),
+            )
+        ledger = WorkLedger(engine=self._engine, settings=WorkLedgerSettings())
+        return SelfHostWorkerLoop(
+            worker=Worker(
+                ledger=ledger, registry=registry, queue=SelfHostTaskQueue(ledger=ledger)
+            ),
+            deployment_id=self._settings.deployment_id,
+            stage=stage,
+            lane=ProcessingLane.STEADY,
+            bucket=TokenBucket(
+                rate_per_s=self._settings.worker_rate_per_s,
+                capacity=self._settings.worker_burst,
+            ),
+            database_url=_psycopg_url(),
+            fallback_poll_s=self._settings.worker_fallback_poll_s,
+        )
+
+    def run_worker(self, *, stage: PipelineStage) -> None:
+        """Run one configured E0 route until the process is stopped or fails."""
+        loop = self.worker_loop(stage=stage)
+        while True:
+            loop.run_for(duration_s=self._settings.worker_session_s)
+
+
+def create_api() -> FastAPI:
+    """Uvicorn factory for the self-host API process."""
+    return SelfHostProfile.from_settings().api()
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run setup, API, or one E0 worker process for Docker Compose."""
+    parser = argparse.ArgumentParser(description="rememberstack self-host profile")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers.add_parser("setup", help="migrate and bootstrap the deployment")
+    subparsers.add_parser("api", help="serve the deployment HTTP API")
+    worker = subparsers.add_parser("worker", help="run one E0 worker route")
+    worker.add_argument(
+        "--stage",
+        choices=tuple(stage.value for stage in _SUPPORTED_WORKER_STAGES),
+        required=True,
+    )
+    args = parser.parse_args(argv)
+    settings = SelfHostSettings.model_validate({})
+    if args.command == "api":
+        import uvicorn
+
+        uvicorn.run(
+            create_api(),
+            host=settings.api_host,
+            port=settings.api_port,
+            access_log=True,
+        )
+        return 0
+    profile = SelfHostProfile.from_settings()
+    try:
+        if args.command == "setup":
+            profile.setup()
+            return 0
+        profile.run_worker(stage=PipelineStage(args.stage))
+        return 0
+    finally:
+        profile.close()
+
+
+def _psycopg_url() -> str:
+    """Remove SQLAlchemy's driver suffix for psycopg's native connection parser."""
+    url = make_url(load_database_settings().sqlalchemy_url())
+    return url.set(drivername="postgresql").render_as_string(hide_password=False)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rememberstack/profiles/selfhost_forget.py

@@ -0,0 +1,158 @@
+"""One explicit self-host composition for D74 hard-forget and readiness."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Self
+from uuid import UUID
+
+from sqlalchemy.engine import Engine
+
+from rememberstack.adapters.selfhost import LanceChunkIndex
+from rememberstack.adapters.selfhost import LocalFSForgetManifestStore
+from rememberstack.adapters.selfhost import LocalFSObjectStore
+from rememberstack.adapters.selfhost import LocalGitRepository
+from rememberstack.adapters.selfhost import SelfHostProjectionPurger
+from rememberstack.model import ForgetManifest
+from rememberstack.model import PipelineStage
+from rememberstack.spine import ForgetCatalog
+from rememberstack.spine import LifecycleCatalog
+from rememberstack.spine import ProjectionCatalog
+from rememberstack.workers import CorpusFsBuilder
+from rememberstack.workers import DeletionService
+from rememberstack.workers import GraphRebuildWorker
+from rememberstack.workers import HandlerRegistry
+from rememberstack.workers import HardForgetHandler
+from rememberstack.workers import HardForgetReadiness
+from rememberstack.workers import HardForgetService
+from rememberstack.workers import KnowledgeCommitDriver
+from rememberstack.workers import KnowledgeCycleForgetRebuilder
+from rememberstack.workers import ProjectionPairForgetRebuilder
+
+
+class SelfHostHardForget:
+    """The self-host request, worker registration, admission, and startup gate."""
+
+    def __init__(
+        self,
+        *,
+        catalog: ForgetCatalog,
+        service: HardForgetService,
+        handler: HardForgetHandler,
+        readiness: HardForgetReadiness,
+    ) -> None:
+        """Retain one shared coordinator graph for every self-host surface."""
+        self._catalog = catalog
+        self._service = service
+        self._handler = handler
+        self._readiness = readiness
+
+    @classmethod
+    def compose(
+        cls,
+        *,
+        engine: Engine,
+        manifest_root: Path,
+        object_roots: tuple[Path, ...],
+        snapshot_root: Path,
+        lance_root: Path,
+        p2_cache_root: Path,
+        mount_root: Path,
+        knowledge_repository: Path,
+        knowledge_author_name: str,
+        knowledge_author_email: str,
+        rebuild_workdir: Path,
+        knowledge_driver: KnowledgeCommitDriver,
+    ) -> Self:
+        """Compose only existing production workers and selected self-host stores."""
+        if not object_roots:
+            raise ValueError("hard-forget requires at least one ordinary object root")
+        catalog = ForgetCatalog(engine=engine)
+        manifest_store = LocalFSForgetManifestStore(root=manifest_root)
+        object_purgers = tuple(LocalFSObjectStore(root=root) for root in object_roots)
+        snapshot_store = LocalFSObjectStore(root=snapshot_root)
+        projection_catalog = ProjectionCatalog(engine=engine)
+        k_git = LocalGitRepository(
+            repository=knowledge_repository,
+            path_catalog=catalog,
+            author_name=knowledge_author_name,
+            author_email=knowledge_author_email,
+        )
+        service = HardForgetService(
+            catalog=catalog, manifest_store=manifest_store, k_git=k_git
+        )
+        handler = HardForgetHandler(
+            catalog=catalog,
+            deletion=DeletionService(catalog=LifecycleCatalog(engine=engine)),
+            object_purgers=object_purgers,
+            p1=LanceChunkIndex(root=lance_root),
+            projection_rebuilder=ProjectionPairForgetRebuilder(
+                graph=GraphRebuildWorker(
+                    catalog=projection_catalog, snapshot_store=snapshot_store
+                ),
+                corpus=CorpusFsBuilder(
+                    catalog=projection_catalog, snapshot_store=snapshot_store
+                ),
+                workdir=rebuild_workdir,
+            ),
+            projection_purger=SelfHostProjectionPurger(
+                object_purger=snapshot_store,
+                catalog=projection_catalog,
+                p2_cache_root=p2_cache_root,
+                mount_root=mount_root,
+            ),
+            knowledge_rebuilder=KnowledgeCycleForgetRebuilder(driver=knowledge_driver),
+            k_git=k_git,
+        )
+        readiness = HardForgetReadiness(
+            catalog=catalog,
+            manifest_store=manifest_store,
+            request_service=service,
+            handler=handler,
+        )
+        return cls(
+            catalog=catalog, service=service, handler=handler, readiness=readiness
+        )
+
+    def register(self, *, registry: HandlerRegistry) -> None:
+        """Install the one unlaned hard-forget worker handler."""
+        registry.register(stage=PipelineStage.HARD_FORGET, handler=self._handler)
+
+    def request(
+        self,
+        *,
+        deployment_id: UUID,
+        doc_id: UUID,
+        forget_id: UUID,
+        requested_at: datetime,
+    ) -> ForgetManifest:
+        """Submit one lineage request through the crash-safe acceptance cut."""
+        return self._service.request(
+            deployment_id=deployment_id,
+            doc_id=doc_id,
+            forget_id=forget_id,
+            requested_at=requested_at,
+        )
+
+    def ensure_ready(self, *, deployment_id: UUID) -> tuple[UUID, ...]:
+        """Re-honor every portable manifest before serving begins."""
+        return self._readiness.ensure_ready(deployment_id=deployment_id)
+
+    def assert_available(self, *, deployment_id: UUID) -> None:
+        """Implement the shared public/mount admission perimeter."""
+        self._catalog.assert_available(deployment_id=deployment_id)
+
+    def guard_ingest(
+        self,
+        *,
+        deployment_id: UUID,
+        source_kind: str,
+        source_ref: str,
+        content_hash: str,
+    ) -> None:
+        """Implement E0's before-bytes barrier and irreversible ingest guard."""
+        self._catalog.guard_ingest(
+            deployment_id=deployment_id,
+            source_kind=source_kind,
+            source_ref=source_ref,
+            content_hash=content_hash,
+        )

rememberstack/profiles/selfhost_operations.py

@@ -0,0 +1,95 @@
+"""Self-host composition root for the optional local operational commands."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Self
+from uuid import UUID
+
+import sqlalchemy
+from sqlalchemy.engine import Engine
+
+from rememberstack.adapters.selfhost import LocalFSObjectStore
+from rememberstack.adapters.selfhost import SelfHostTaskQueue
+from rememberstack.model import DeadLetterReplayResult
+from rememberstack.model import OperationalReport
+from rememberstack.model import ProcessingLane
+from rememberstack.spine import ForgetCatalog
+from rememberstack.spine import OperationalCatalog
+from rememberstack.spine import OperationalSettings
+from rememberstack.spine import ProjectionCatalog
+from rememberstack.spine import WorkLedger
+from rememberstack.spine import WorkLedgerSettings
+from rememberstack.spine.settings import load_database_settings
+from rememberstack.workers import CorpusFsBuilder
+from rememberstack.workers import DeadLetterReplayer
+from rememberstack.workers import GraphRebuildWorker
+
+
+class SelfHostOperations:
+    """Compose local adapters around one explicitly owned database engine."""
+
+    def __init__(self, *, engine: Engine) -> None:
+        """Take ownership of an engine created for one CLI invocation."""
+        self._engine = engine
+
+    @classmethod
+    def from_settings(cls) -> Self:
+        """Create the local composition from the typed database setting."""
+        return cls(
+            engine=sqlalchemy.create_engine(load_database_settings().sqlalchemy_url())
+        )
+
+    def close(self) -> None:
+        """Dispose the command-owned connection pool."""
+        self._engine.dispose()
+
+    def inspect(self, *, deployment_id: UUID) -> OperationalReport:
+        """Build one bounded typed report."""
+        return OperationalCatalog(
+            engine=self._engine, settings=OperationalSettings()
+        ).inspect(deployment_id=deployment_id)
+
+    def replay(
+        self,
+        *,
+        deployment_id: UUID,
+        processing_id: UUID,
+        attempt_allowance: int,
+        lane: ProcessingLane | None,
+        not_before: datetime | None,
+    ) -> DeadLetterReplayResult:
+        """Compose the authoritative replay transition with local delivery."""
+        ForgetCatalog(engine=self._engine).assert_available(deployment_id=deployment_id)
+        ledger = WorkLedger(engine=self._engine, settings=WorkLedgerSettings())
+        return DeadLetterReplayer(
+            ledger=ledger, queue=SelfHostTaskQueue(ledger=ledger)
+        ).replay(
+            deployment_id=deployment_id,
+            processing_id=processing_id,
+            attempt_allowance=attempt_allowance,
+            lane=lane,
+            not_before=not_before,
+        )
+
+    def rebuild(
+        self,
+        *,
+        plane: str,
+        deployment_id: UUID,
+        snapshot_root: Path,
+        workdir: Path,
+        version: str,
+    ) -> dict[str, object]:
+        """Invoke the existing whole-rebuild implementation for P2 or P3."""
+        ForgetCatalog(engine=self._engine).assert_available(deployment_id=deployment_id)
+        catalog = ProjectionCatalog(engine=self._engine)
+        store = LocalFSObjectStore(root=snapshot_root)
+        if plane == "p2":
+            return GraphRebuildWorker(catalog=catalog, snapshot_store=store).rebuild(
+                deployment_id=deployment_id, workdir=workdir, version=version
+            )
+        if plane == "p3":
+            return CorpusFsBuilder(catalog=catalog, snapshot_store=store).build(
+                deployment_id=deployment_id, version=version
+            )
+        raise ValueError(f"unknown projection plane {plane!r}")

rememberstack/py.typed

@@ -0,0 +1 @@
+

rememberstack/spine/__init__.py

@@ -0,0 +1,93 @@
+"""Postgres spine package."""
+
+from rememberstack.spine.backfill import BackfillFinalizer
+from rememberstack.spine.backfill import BackfillSeeder
+from rememberstack.spine.backfill import BackfillSeederSettings
+from rememberstack.spine.chunk_catalog import ChunkCatalog
+from rememberstack.spine.claim_catalog import ClaimCatalog
+from rememberstack.spine.clustering import EntityClusterer
+from rememberstack.spine.component_versions import ComponentVersionRegistrar
+from rememberstack.spine.consumption import ConsumptionCatalog
+from rememberstack.spine.consumption import ConsumptionDeploymentNotFoundError
+from rememberstack.spine.deployment_bootstrap import DeploymentBootstrapper
+from rememberstack.spine.document_catalog import DocumentCatalog
+from rememberstack.spine.entity_registry import EntityRegistry
+from rememberstack.spine.entity_registry import T0_RESOLVER_VERSION
+from rememberstack.spine.extension_packs import install_pack
+from rememberstack.spine.extension_packs import PackAnchorError
+from rememberstack.spine.extension_packs import PackConflictError
+from rememberstack.spine.fact_catalog import FactCatalog
+from rememberstack.spine.forget import ForgetCatalog
+from rememberstack.spine.knowledge import KnowledgeCommitBusyError
+from rememberstack.spine.knowledge import KnowledgeCompilationError
+from rememberstack.spine.knowledge import KnowledgeCompileContextMissingError
+from rememberstack.spine.knowledge import KnowledgeControlPlane
+from rememberstack.spine.knowledge import KnowledgeDispatchUnavailableError
+from rememberstack.spine.lifecycle import LifecycleCatalog
+from rememberstack.spine.observation_adjudication import OBSERVATION_ADJUDICATOR_VERSION
+from rememberstack.spine.observation_adjudication import ObservationAdjudicator
+from rememberstack.spine.observation_adjudication import ObservationSettings
+from rememberstack.spine.operations import error_class_from_traceback
+from rememberstack.spine.operations import OperationalCatalog
+from rememberstack.spine.operations import OperationalSettings
+from rememberstack.spine.projection import ProjectionCatalog
+from rememberstack.spine.recipes import CANONICAL_RECIPES
+from rememberstack.spine.recipes import RecipeRegistry
+from rememberstack.spine.recipes import seed_canonical_recipes
+from rememberstack.spine.resolver import CascadeResolver
+from rememberstack.spine.resolver import RESOLVER_VERSION
+from rememberstack.spine.resolver import seed_resolver_version
+from rememberstack.spine.review import ReviewQueue
+from rememberstack.spine.supersession import ADJUDICATOR_VERSION
+from rememberstack.spine.supersession import SupersessionAdjudicator
+from rememberstack.spine.supersession import SupersessionSettings
+from rememberstack.spine.sync import SyncCatalog
+from rememberstack.spine.work_ledger import WorkLedger
+from rememberstack.spine.work_ledger import WorkLedgerSettings
+
+__all__ = (
+    "BackfillFinalizer",
+    "BackfillSeeder",
+    "BackfillSeederSettings",
+    "ChunkCatalog",
+    "ClaimCatalog",
+    "EntityRegistry",
+    "PackAnchorError",
+    "PackConflictError",
+    "install_pack",
+    "ADJUDICATOR_VERSION",
+    "CascadeResolver",
+    "SupersessionAdjudicator",
+    "SupersessionSettings",
+    "SyncCatalog",
+    "FactCatalog",
+    "ForgetCatalog",
+    "OBSERVATION_ADJUDICATOR_VERSION",
+    "ObservationAdjudicator",
+    "ObservationSettings",
+    "OperationalCatalog",
+    "OperationalSettings",
+    "error_class_from_traceback",
+    "RESOLVER_VERSION",
+    "LifecycleCatalog",
+    "KnowledgeCompilationError",
+    "KnowledgeCommitBusyError",
+    "KnowledgeCompileContextMissingError",
+    "KnowledgeControlPlane",
+    "KnowledgeDispatchUnavailableError",
+    "ProjectionCatalog",
+    "CANONICAL_RECIPES",
+    "RecipeRegistry",
+    "seed_canonical_recipes",
+    "ReviewQueue",
+    "seed_resolver_version",
+    "T0_RESOLVER_VERSION",
+    "ComponentVersionRegistrar",
+    "ConsumptionCatalog",
+    "ConsumptionDeploymentNotFoundError",
+    "EntityClusterer",
+    "DocumentCatalog",
+    "DeploymentBootstrapper",
+    "WorkLedger",
+    "WorkLedgerSettings",
+)