rememberstack 0.1.0__py3-none-any.whl

rememberstack/adapters/selfhost/projection.py

@@ -0,0 +1,80 @@
+"""D74 purge acknowledgement for self-host projection bytes and caches."""
+
+from pathlib import Path
+from pathlib import PurePosixPath
+import shutil
+from uuid import UUID
+
+from rememberstack.model import ObjectKey
+from rememberstack.ports import ObjectPurgePort
+from rememberstack.spine import ProjectionCatalog
+
+
+class SelfHostProjectionPurger:
+    """Erase old durable P2/P3 prefixes, registry rows, and local serving copies."""
+
+    def __init__(
+        self,
+        *,
+        object_purger: ObjectPurgePort,
+        catalog: ProjectionCatalog,
+        p2_cache_root: Path,
+        mount_root: Path,
+    ) -> None:
+        """Bind explicit durable and local-cache roots without inventing providers."""
+        self._object_purger = object_purger
+        self._catalog = catalog
+        self._p2_cache_root = p2_cache_root.resolve()
+        self._mount_root = mount_root.resolve()
+
+    def purge_projections(
+        self, *, deployment_id: UUID, prefixes: tuple[ObjectKey, ...]
+    ) -> None:
+        """Idempotently erase every manifest-nominated old projection copy."""
+        self._object_purger.purge_objects(keys=(), prefixes=prefixes)
+        self._catalog.purge_snapshot_prefixes(
+            deployment_id=deployment_id,
+            prefixes=tuple(prefix.root for prefix in prefixes),
+        )
+        for prefix in prefixes:
+            for path in self._serving_paths(deployment_id=deployment_id, prefix=prefix):
+                self._remove(path=path)
+
+    def verify_projections_purged(
+        self, *, deployment_id: UUID, prefixes: tuple[ObjectKey, ...]
+    ) -> None:
+        """Prove durable bytes, registry rows, caches, and mounts are absent."""
+        self._object_purger.verify_objects_purged(keys=(), prefixes=prefixes)
+        roots = tuple(prefix.root for prefix in prefixes)
+        if self._catalog.snapshot_prefixes_exist(
+            deployment_id=deployment_id, prefixes=roots
+        ):
+            raise RuntimeError("projection purge verification found registry rows")
+        remaining = [
+            str(path)
+            for prefix in prefixes
+            for path in self._serving_paths(deployment_id=deployment_id, prefix=prefix)
+            if path.exists() or path.is_symlink()
+        ]
+        if remaining:
+            raise RuntimeError(
+                f"projection purge verification found serving copies: {remaining!r}"
+            )
+
+    def _serving_paths(
+        self, *, deployment_id: UUID, prefix: ObjectKey
+    ) -> tuple[Path, Path]:
+        """Return the exact P2 cache and P3 versioned mount for one prefix."""
+        version = PurePosixPath(prefix.root).name
+        return (
+            self._p2_cache_root / str(deployment_id) / version,
+            self._mount_root / str(deployment_id) / f"p3-{version}",
+        )
+
+    @staticmethod
+    def _remove(*, path: Path) -> None:
+        """Remove one exact serving copy, treating absence as success."""
+        if path.is_symlink() or path.is_file():
+            path.unlink(missing_ok=True)
+        elif path.is_dir():
+            shutil.rmtree(path)

rememberstack/adapters/selfhost/queue.py

@@ -0,0 +1,137 @@
+"""The self-host delivery shell: LISTEN/NOTIFY wake-ups + SKIP LOCKED claiming (D62/D67).
+
+Work is Postgres rows; this shell only delivers wake-ups. The schema-owned
+insert trigger provides the transactional initial wake; `announce` re-announces
+existing rows through the spine's notification primitive; the worker loop
+sleeps on LISTEN with a slow fallback poll and claims only its configured
+route, consulting a token bucket around each claim.
+"""
+
+from collections.abc import Callable
+import logging
+import time
+from uuid import UUID
+
+import psycopg
+
+from rememberstack.model import PipelineStage
+from rememberstack.model import ProcessingLane
+from rememberstack.model import QueueRoute
+from rememberstack.model import RunResultOutcome
+from rememberstack.model import UTCDateTime
+from rememberstack.spine.work_ledger import WorkLedger
+from rememberstack.workers import RunResult
+from rememberstack.workers import Worker
+
+_logger = logging.getLogger(__name__)
+
+_WAKE_CHANNEL = "queue_wake"
+
+
+class SelfHostTaskQueue:
+    """The delivery-only announce adapter: wake an existing committed row.
+
+    Satisfies the task-queue port. Route and due-time snapshots are accepted
+    per the port contract but carry no state — the woken worker re-reads
+    Postgres, which is the only authority (D67).
+    """
+
+    def __init__(self, *, ledger: WorkLedger) -> None:
+        """Bind the adapter to the spine's notification primitive."""
+        self._ledger = ledger
+
+    def announce(
+        self,
+        *,
+        processing_id: UUID,
+        route_snapshot: QueueRoute,
+        not_before_snapshot: UTCDateTime,
+    ) -> None:
+        """Schedule at-least-once delivery by waking listeners for the row."""
+        del route_snapshot, not_before_snapshot  # snapshots are hints, never state
+        self._ledger.wake(processing_id=processing_id)
+
+
+class TokenBucket:
+    """A per-route claim rate limit: refill at a fixed rate up to a capacity."""
+
+    def __init__(
+        self,
+        *,
+        rate_per_s: float,
+        capacity: float,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        """Start full; `clock` is injectable for deterministic tests."""
+        self._rate_per_s = rate_per_s
+        self._capacity = capacity
+        self._clock = clock
+        self._tokens = capacity
+        self._refilled_at = clock()
+
+    def try_acquire(self) -> bool:
+        """Take one token if available; never blocks."""
+        now = self._clock()
+        self._tokens = min(
+            self._capacity, self._tokens + (now - self._refilled_at) * self._rate_per_s
+        )
+        self._refilled_at = now
+        if self._tokens < 1.0:
+            return False
+        self._tokens -= 1.0
+        return True
+
+
+class SelfHostWorkerLoop:
+    """One route's worker loop: sleep on LISTEN, drain due work, fall back to polling."""
+
+    def __init__(
+        self,
+        *,
+        worker: Worker,
+        deployment_id: UUID,
+        stage: PipelineStage,
+        lane: ProcessingLane | None,
+        bucket: TokenBucket,
+        database_url: str,
+        fallback_poll_s: float = 30.0,
+    ) -> None:
+        """Bind the loop to its route, rate limit, and LISTEN connection source."""
+        self._worker = worker
+        self._deployment_id = deployment_id
+        self._stage = stage
+        self._lane = lane
+        self._bucket = bucket
+        self._database_url = database_url
+        self._fallback_poll_s = fallback_poll_s
+
+    def drain_due(self) -> tuple[RunResult, ...]:
+        """Claim and run due work on the route until none remains or tokens run out."""
+        results: list[RunResult] = []
+        while self._bucket.try_acquire():
+            result = self._worker.run_one(
+                deployment_id=self._deployment_id, stage=self._stage, lane=self._lane
+            )
+            if result.outcome is RunResultOutcome.NO_WORK:
+                break
+            results.append(result)
+        return tuple(results)
+
+    def run_for(self, *, duration_s: float) -> tuple[RunResult, ...]:
+        """Listen, drain on every wake, and fall back to polling, for a bounded time.
+
+        The production loop is this method called with a large duration under a
+        supervisor; tests call it with a short one. Missed notifications are
+        covered by the fallback poll, per the packaging design.
+        """
+        results: list[RunResult] = list(self.drain_due())
+        deadline = time.monotonic() + duration_s
+        with psycopg.connect(self._database_url, autocommit=True) as connection:
+            connection.execute(f"LISTEN {_WAKE_CHANNEL}")
+            while (remaining := deadline - time.monotonic()) > 0:
+                timeout = min(remaining, self._fallback_poll_s)
+                woken = list(connection.notifies(timeout=timeout, stop_after=1))
+                if woken:
+                    _logger.debug("wake received: %s", woken[0].payload)
+                results.extend(self.drain_due())
+        return tuple(results)

rememberstack/adapters/selfhost/telemetry.py

@@ -0,0 +1,45 @@
+"""Simple JSON-lines telemetry for self-hosted process logs."""
+
+import json
+import sys
+from threading import Lock
+import traceback
+from typing import TextIO
+
+from rememberstack.model import TelemetryEvent
+
+
+class JsonLineTelemetry:
+    """Write one complete structured event per line to a process-owned stream."""
+
+    def __init__(self, *, stream: TextIO | None = None) -> None:
+        """Use stdout by default and serialize concurrent worker writes."""
+        self._stream = stream or sys.stdout
+        self._lock = Lock()
+
+    def export_event(self, *, event: TelemetryEvent) -> None:
+        """Write and flush one ordinary event."""
+        self._write(payload=event.model_dump(mode="json"))
+
+    def export_exception(
+        self, *, event: TelemetryEvent, exception: BaseException
+    ) -> None:
+        """Write the event plus the supplied exception's complete cause chain."""
+        payload = event.model_dump(mode="json")
+        payload["exception"] = {
+            "type": type(exception).__qualname__,
+            "message": str(exception),
+            "traceback": "".join(
+                traceback.TracebackException.from_exception(exception).format(
+                    chain=True
+                )
+            ),
+        }
+        self._write(payload=payload)
+
+    def _write(self, *, payload: dict[str, object]) -> None:
+        """Keep every event atomic at the stream boundary."""
+        line = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+        with self._lock:
+            self._stream.write(line + "\n")
+            self._stream.flush()

rememberstack/adapters/selfhost/watcher.py

@@ -0,0 +1,70 @@
+"""The local-directory watched source: watch a folder on the self-host tier.
+
+The genuinely useful self-host connector (and the lifecycle machinery's test
+double with real semantics): source_ref = the file's relative path, revision
+= mtime+size, deletion = the file is gone. Cloud connectors (Drive) implement
+the same port behind their provider adapters.
+"""
+
+from collections.abc import Mapping
+from datetime import datetime
+from datetime import UTC
+from pathlib import Path
+
+from rememberstack.model import SourceItem
+
+_MIME_BY_SUFFIX = {".md": "text/markdown", ".txt": "text/plain", ".html": "text/html"}
+
+
+class LocalDirectoryWatcher:
+    """Watch one directory tree of text documents."""
+
+    def __init__(self, *, root: Path) -> None:
+        """Bind the watcher to its directory (created if absent)."""
+        self._root = root
+        self._root.mkdir(parents=True, exist_ok=True)
+
+    def poll(self, *, known: Mapping[str, str]) -> tuple[SourceItem, ...]:
+        """Every current file, plus deletion markers for vanished refs.
+
+        Paths that resolve outside the root (symlinks pointing elsewhere)
+        are skipped: a writable watched directory must not become a lever
+        for ingesting arbitrary readable files into memory.
+        """
+        base = self._root.resolve()
+        items: list[SourceItem] = []
+        seen: set[str] = set()
+        for path in sorted(self._root.rglob("*")):
+            if not path.is_file() or path.suffix not in _MIME_BY_SUFFIX:
+                continue
+            if not path.resolve().is_relative_to(base):
+                continue  # a symlink escaping the root is not a watched file
+            ref = path.relative_to(self._root).as_posix()
+            seen.add(ref)
+            stat = path.stat()
+            items.append(
+                SourceItem(
+                    source_ref=ref,
+                    revision=f"{stat.st_mtime_ns}:{stat.st_size}",
+                    modified_at=datetime.fromtimestamp(stat.st_mtime, tz=UTC),
+                    filename=path.name,
+                    mime=_MIME_BY_SUFFIX[path.suffix],
+                )
+            )
+        for ref in sorted(set(known) - seen):
+            items.append(
+                SourceItem(
+                    source_ref=ref,
+                    revision="deleted",
+                    modified_at=datetime.now(tz=UTC),
+                    deleted=True,
+                )
+            )
+        return tuple(items)
+
+    def fetch(self, *, source_ref: str) -> bytes:
+        """The file's current bytes; refs escaping the root are refused."""
+        path = (self._root / source_ref).resolve()
+        if not path.is_relative_to(self._root.resolve()):
+            raise PermissionError(f"{source_ref!r} escapes the watched root")
+        return path.read_bytes()

rememberstack/adapters/testing/__init__.py

@@ -0,0 +1,15 @@
+"""Test-tier adapters: in-memory doubles outside the two-maintained-adapter set."""
+
+from rememberstack.adapters.testing.cost_meter import NoopCostMeter
+from rememberstack.adapters.testing.model_provider import FakeModelProvider
+from rememberstack.adapters.testing.queue import RecordedAnnouncement
+from rememberstack.adapters.testing.queue import RecordingTaskQueue
+from rememberstack.adapters.testing.telemetry import RecordingTelemetry
+
+__all__ = (
+    "FakeModelProvider",
+    "NoopCostMeter",
+    "RecordedAnnouncement",
+    "RecordingTaskQueue",
+    "RecordingTelemetry",
+)

rememberstack/adapters/testing/cost_meter.py

@@ -0,0 +1,13 @@
+"""A no-op cost meter for tests that invoke stage handlers directly."""
+
+from rememberstack.model import ProviderCallUsage
+
+
+class NoopCostMeter:
+    """Accept provider accounting without persisting it."""
+
+    def record(
+        self, *, call_key: str, tier: str | None, usage: ProviderCallUsage
+    ) -> None:
+        """Discard one test-only call record."""
+        del call_key, tier, usage

rememberstack/adapters/testing/model_provider.py

@@ -0,0 +1,83 @@
+"""A deterministic in-memory model provider for behavior tests (no network)."""
+
+from decimal import Decimal
+import hashlib
+
+from rememberstack.model import EmbeddingRequest
+from rememberstack.model import EmbeddingResponse
+from rememberstack.model import GeneratedResponse
+from rememberstack.model import ModelRequest
+from rememberstack.model import ProviderCallUsage
+from rememberstack.model import StructuredResponseModel
+
+_EMBEDDING_DIMENSION = 8
+
+
+class FakeModelProvider:
+    """Deterministic embeddings and canned structured generations for proofs."""
+
+    def __init__(
+        self,
+        *,
+        generate_payload: dict[str, object] | None = None,
+        generate_payloads: dict[str, dict[str, object]] | None = None,
+        generate_router: object | None = None,
+    ) -> None:
+        """Bind canned payloads: one default, one per response-type name, or a
+        router callable (prompt, type_name) -> payload for per-call behavior."""
+        self._generate_payload = generate_payload
+        self._generate_payloads = generate_payloads or {}
+        self._generate_router = generate_router
+        self.embedded_texts: list[str] = []
+        self.generated_prompts: list[str] = []
+
+    def generate[ResponseT: StructuredResponseModel](
+        self, *, request: ModelRequest, response_type: type[ResponseT]
+    ) -> GeneratedResponse[ResponseT]:
+        """Return the canned payload validated as the caller's declared type."""
+        self.generated_prompts.append(request.prompt)
+        if callable(self._generate_router):
+            output = response_type.model_validate(
+                self._generate_router(request.prompt, response_type.__name__)
+            )
+        else:
+            payload = self._generate_payloads.get(
+                response_type.__name__, self._generate_payload
+            )
+            if payload is None:
+                raise AssertionError(f"no canned payload for {response_type.__name__}")
+            output = response_type.model_validate(payload)
+        return GeneratedResponse(
+            output=output,
+            usage=_fake_usage(
+                model_name=request.model, tokens_in=len(request.prompt.split())
+            ),
+        )
+
+    def embed(self, *, request: EmbeddingRequest) -> EmbeddingResponse:
+        """Return one deterministic content-derived vector per input text."""
+        self.embedded_texts.extend(request.texts)
+        return EmbeddingResponse(
+            vectors=tuple(_vector_for(text=text) for text in request.texts),
+            usage=_fake_usage(
+                model_name=request.model,
+                tokens_in=sum(len(text.split()) for text in request.texts),
+            ),
+        )
+
+
+def _fake_usage(*, model_name: str, tokens_in: int) -> ProviderCallUsage:
+    """Return deterministic zero-cost accounting for one in-memory provider call."""
+    return ProviderCallUsage(
+        model_name=model_name,
+        tokens_in=tokens_in,
+        tokens_out=0,
+        cost_usd=Decimal(0),
+        latency_ms=0,
+    )
+
+
+def _vector_for(*, text: str) -> tuple[float, ...]:
+    """Derive a stable pseudo-vector from the text content."""
+    digest = hashlib.sha256(text.encode("utf-8")).digest()
+    return tuple(byte / 255.0 for byte in digest[:_EMBEDDING_DIMENSION])

rememberstack/adapters/testing/queue.py

@@ -0,0 +1,43 @@
+"""The test-tier task queue: records announcements in memory, delivers nothing."""
+
+from uuid import UUID
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+
+from rememberstack.model import QueueRoute
+from rememberstack.model import UTCDateTime
+
+
+class RecordedAnnouncement(BaseModel):
+    """One announce call as the port received it, for assertions."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    processing_id: UUID
+    route_snapshot: QueueRoute
+    not_before_snapshot: UTCDateTime
+
+
+class RecordingTaskQueue:
+    """Satisfies the task-queue port; tests assert on the recorded announcements."""
+
+    def __init__(self) -> None:
+        """Start with an empty announcement log."""
+        self.announcements: list[RecordedAnnouncement] = []
+
+    def announce(
+        self,
+        *,
+        processing_id: UUID,
+        route_snapshot: QueueRoute,
+        not_before_snapshot: UTCDateTime,
+    ) -> None:
+        """Record the announcement; delivery is the test's job, if any."""
+        self.announcements.append(
+            RecordedAnnouncement(
+                processing_id=processing_id,
+                route_snapshot=route_snapshot,
+                not_before_snapshot=not_before_snapshot,
+            )
+        )

rememberstack/adapters/testing/telemetry.py

@@ -0,0 +1,22 @@
+"""In-memory telemetry exporter preserving exception identity for tests."""
+
+from rememberstack.model import TelemetryEvent
+
+
+class RecordingTelemetry:
+    """Record structured events and original exception objects in call order."""
+
+    def __init__(self) -> None:
+        """Start with no exports."""
+        self.events: list[TelemetryEvent] = []
+        self.exceptions: list[tuple[TelemetryEvent, BaseException]] = []
+
+    def export_event(self, *, event: TelemetryEvent) -> None:
+        """Record a non-exception event."""
+        self.events.append(event)
+
+    def export_exception(
+        self, *, event: TelemetryEvent, exception: BaseException
+    ) -> None:
+        """Record the exact exception instance supplied by the worker."""
+        self.exceptions.append((event, exception))

rememberstack/client.py

@@ -0,0 +1,19 @@
+"""Public dependency-light client API."""
+
+from rememberstack.model.client import ConnectorCreate
+from rememberstack.model.client import ConnectorDescriptor
+from rememberstack.model.client import ConnectorNotFoundError
+from rememberstack.model.client import ToolDescriptor
+from rememberstack.surfaces.sdk import ClientSettings
+from rememberstack.surfaces.sdk import MemoryApiError
+from rememberstack.surfaces.sdk import MemoryClient
+
+__all__ = (
+    "ClientSettings",
+    "ConnectorCreate",
+    "ConnectorDescriptor",
+    "ConnectorNotFoundError",
+    "MemoryApiError",
+    "MemoryClient",
+    "ToolDescriptor",
+)

rememberstack/core/__init__.py

@@ -0,0 +1,127 @@
+"""Pure domain logic package."""
+
+from rememberstack.core.blockizer import block_hash
+from rememberstack.core.blockizer import blockize
+from rememberstack.core.blockizer import BLOCKIZER_VERSION
+from rememberstack.core.blockizer import normalized_block_text
+from rememberstack.core.chunker import chunk_content_hash
+from rememberstack.core.chunker import CHUNKER_VERSION
+from rememberstack.core.chunker import chunker_version
+from rememberstack.core.chunker import ChunkerParams
+from rememberstack.core.chunker import count_tokens
+from rememberstack.core.chunker import extraction_input_hash
+from rememberstack.core.chunker import is_anchor
+from rememberstack.core.chunker import pack_blocks
+from rememberstack.core.consumption_skill import CONSUMPTION_SKILL_VERSION
+from rememberstack.core.consumption_skill import render_consumption_skill
+from rememberstack.core.conversion import ConversionRouter
+from rememberstack.core.conversion import Converter
+from rememberstack.core.conversion import MarkdownPassthroughConverter
+from rememberstack.core.conversion import PASSTHROUGH_CONVERTER_VERSION
+from rememberstack.core.core_manifest import CORE_MANIFEST
+from rememberstack.core.core_manifest import CoreManifest
+from rememberstack.core.core_manifest import EntityTypeDefinition
+from rememberstack.core.core_manifest import PredicateDefinition
+from rememberstack.core.core_manifest import PredicateSignatureDefinition
+from rememberstack.core.extension_packs import ExtensionPack
+from rememberstack.core.extension_packs import PackEntityType
+from rememberstack.core.extension_packs import PackPredicate
+from rememberstack.core.extension_packs import WORK_PACK
+from rememberstack.core.forget import source_identity_hash
+from rememberstack.core.knowledge_authored import authored_declaration_is_empty
+from rememberstack.core.knowledge_authored import knowledge_citation_reference
+from rememberstack.core.knowledge_authored import KnowledgeAuthoredDeclarationError
+from rememberstack.core.knowledge_authored import parse_knowledge_authored_frontmatter
+from rememberstack.core.knowledge_compile import knowledge_compile_order
+from rememberstack.core.knowledge_compile import KnowledgeCompileGraphError
+from rememberstack.core.knowledge_compile import KnowledgePageValidationError
+from rememberstack.core.knowledge_compile import validate_knowledge_page_output
+from rememberstack.core.knowledge_fact_sheet import compose_knowledge_page
+from rememberstack.core.knowledge_fact_sheet import KnowledgeFactLifecycle
+from rememberstack.core.knowledge_fact_sheet import render_knowledge_fact_sheet
+from rememberstack.core.knowledge_hashing import knowledge_content_hash
+from rememberstack.core.knowledge_hashing import knowledge_inputs_hash
+from rememberstack.core.knowledge_hashing import knowledge_summary_hash
+from rememberstack.core.knowledge_planner import knowledge_planning_input_hash
+from rememberstack.core.knowledge_planner import primary_knowledge_plan_trigger
+from rememberstack.core.knowledge_planner import route_knowledge_plan
+from rememberstack.core.knowledge_writer import cap_knowledge_writer_bundle
+from rememberstack.core.knowledge_writer import knowledge_writer_coverage
+from rememberstack.core.knowledge_writer import render_knowledge_writer_bundle
+from rememberstack.core.ranking import DEFAULT_EVIDENCE_COUNT_WEIGHT
+from rememberstack.core.ranking import DEFAULT_GRAPH_DISTANCE_WEIGHT
+from rememberstack.core.ranking import DEFAULT_RRF_K
+from rememberstack.core.ranking import reciprocal_rank_fusion
+from rememberstack.core.ranking import rerank_by_signal
+from rememberstack.core.ranking import rerank_by_weighted_signals
+from rememberstack.core.recipe_linter import KNOWN_OPS
+from rememberstack.core.recipe_linter import lint_recipe
+from rememberstack.core.recipe_linter import RecipeLintError
+from rememberstack.core.section_snap import SECTION_ROLES
+from rememberstack.core.section_snap import snap_sections
+from rememberstack.core.storage_routing import HOT_MIME_PREFIXES
+from rememberstack.core.storage_routing import storage_class_for
+
+__all__ = (
+    "BLOCKIZER_VERSION",
+    "CHUNKER_VERSION",
+    "ChunkerParams",
+    "chunk_content_hash",
+    "chunker_version",
+    "count_tokens",
+    "extraction_input_hash",
+    "is_anchor",
+    "pack_blocks",
+    "CORE_MANIFEST",
+    "ExtensionPack",
+    "PackEntityType",
+    "PackPredicate",
+    "WORK_PACK",
+    "ConversionRouter",
+    "CONSUMPTION_SKILL_VERSION",
+    "Converter",
+    "CoreManifest",
+    "EntityTypeDefinition",
+    "MarkdownPassthroughConverter",
+    "PASSTHROUGH_CONVERTER_VERSION",
+    "PredicateDefinition",
+    "PredicateSignatureDefinition",
+    "block_hash",
+    "blockize",
+    "normalized_block_text",
+    "HOT_MIME_PREFIXES",
+    "storage_class_for",
+    "source_identity_hash",
+    "SECTION_ROLES",
+    "snap_sections",
+    "DEFAULT_EVIDENCE_COUNT_WEIGHT",
+    "DEFAULT_GRAPH_DISTANCE_WEIGHT",
+    "DEFAULT_RRF_K",
+    "KNOWN_OPS",
+    "KnowledgeCompileGraphError",
+    "KnowledgeAuthoredDeclarationError",
+    "KnowledgeFactLifecycle",
+    "KnowledgePageValidationError",
+    "knowledge_content_hash",
+    "knowledge_citation_reference",
+    "knowledge_compile_order",
+    "knowledge_inputs_hash",
+    "knowledge_planning_input_hash",
+    "knowledge_summary_hash",
+    "primary_knowledge_plan_trigger",
+    "parse_knowledge_authored_frontmatter",
+    "compose_knowledge_page",
+    "RecipeLintError",
+    "lint_recipe",
+    "reciprocal_rank_fusion",
+    "render_consumption_skill",
+    "render_knowledge_fact_sheet",
+    "cap_knowledge_writer_bundle",
+    "knowledge_writer_coverage",
+    "render_knowledge_writer_bundle",
+    "route_knowledge_plan",
+    "rerank_by_signal",
+    "rerank_by_weighted_signals",
+    "validate_knowledge_page_output",
+    "authored_declaration_is_empty",
+)