superlocalmemory 4.1.13 → 4.1.15

package/src/superlocalmemory/core/ollama_embedder.py

@@ -1,266 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Ollama Embedding Provider — lightweight HTTP-based embeddings.
-
-Uses Ollama's /api/embed endpoint for fast local embeddings without
-loading PyTorch or sentence-transformers into the process.
-
-Typical latency: <1 second (vs 30s cold start for sentence-transformers).
-Memory: ~0 MB in the SLM process (Ollama manages its own memory).
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-import numpy as np
-
-if TYPE_CHECKING:
-    pass
-
-logger = logging.getLogger(__name__)
-
-# Fisher variance constants (must match EmbeddingService)
-_FISHER_VAR_MIN = 0.05
-_FISHER_VAR_MAX = 2.0
-_FISHER_VAR_RANGE = _FISHER_VAR_MAX - _FISHER_VAR_MIN
-
-# Ollama connect/response timeouts
-_CONNECT_TIMEOUT = 5.0
-_RESPONSE_TIMEOUT = 30.0
-
-
-class OllamaEmbedder:
-    """Embedding service backed by a local Ollama instance.
-
-    Drop-in replacement for EmbeddingService. Implements the same
-    public interface (embed, embed_batch, compute_fisher_params,
-    is_available, dimension) so the engine can swap transparently.
-
-    V3.3.27: Session-scoped LRU cache eliminates redundant HTTP calls.
-    The store pipeline calls embed() 200+ times for the same texts
-    across different components (type_router, scene_builder, consolidator,
-    entropy_gate, sheaf_checker). Caching avoids ~215 Ollama roundtrips
-    per remember call, reducing latency from 30s to ~3s on Mode B.
-    """
-
-    _CACHE_MAX_SIZE = 2048  # entries — covers a full store + recall cycle
-
-    def __init__(
-        self,
-        model: str = "nomic-embed-text",
-        base_url: str = "http://localhost:11434",
-        dimension: int = 768,
-    ) -> None:
-        self._model = model
-        self._base_url = base_url.rstrip("/")
-        self._dimension = dimension
-        self._available: bool | None = None  # lazy-checked
-        # V3.3.27: Session-scoped embedding cache (text -> normalized vector)
-        self._embed_cache: dict[str, list[float]] = {}
-        self._cache_hits: int = 0
-        self._cache_misses: int = 0
-
-    # ------------------------------------------------------------------
-    # Public interface (matches EmbeddingService)
-    # ------------------------------------------------------------------
-
-    @property
-    def is_available(self) -> bool:
-        """Check if Ollama is reachable and the model is pulled."""
-        if self._available is not None:
-            return self._available
-        self._available = self._check_availability()
-        return self._available
-
-    @property
-    def dimension(self) -> int:
-        return self._dimension
-
-    def embed(self, text: str) -> list[float] | None:
-        """Embed a single text. Returns normalized vector or None on failure.
-
-        V3.3.27: Returns cached result if the same text was embedded
-        earlier in this session, avoiding redundant Ollama HTTP calls.
-        """
-        if not text or not text.strip():
-            raise ValueError("Cannot embed empty text")
-        from superlocalmemory.core.recall_gate import wait_for_foreground_idle
-        wait_for_foreground_idle()
-
-        # V3.3.27: Check cache first
-        cache_key = text.strip()
-        if cache_key in self._embed_cache:
-            self._cache_hits += 1
-            return self._embed_cache[cache_key]
-
-        try:
-            result = self._call_ollama_embed(text)
-            # Cache the result (evict oldest if over limit)
-            if result is not None:
-                if len(self._embed_cache) >= self._CACHE_MAX_SIZE:
-                    # Evict first entry (oldest insertion)
-                    first_key = next(iter(self._embed_cache))
-                    del self._embed_cache[first_key]
-                self._embed_cache[cache_key] = result
-            self._cache_misses += 1
-            return result
-        except Exception as exc:
-            logger.warning("Ollama embed failed: %s", exc)
-            return None
-
-    def embed_batch(self, texts: list[str]) -> list[list[float] | None]:
-        """Embed a batch of texts. Uses the batch API when available.
-
-        V3.3.27: Skips already-cached texts, only sends uncached to Ollama.
-        """
-        if not texts:
-            raise ValueError("Cannot embed empty batch")
-        from superlocalmemory.core.recall_gate import is_background_work
-        if is_background_work():
-            return [self.embed(text) for text in texts]
-
-        # V3.3.27: Split into cached and uncached
-        results: list[list[float] | None] = [None] * len(texts)
-        uncached_indices: list[int] = []
-        uncached_texts: list[str] = []
-
-        for i, text in enumerate(texts):
-            key = text.strip()
-            if key in self._embed_cache:
-                results[i] = self._embed_cache[key]
-                self._cache_hits += 1
-            else:
-                uncached_indices.append(i)
-                uncached_texts.append(text)
-
-        if not uncached_texts:
-            return results  # All cached — zero HTTP calls
-
-        try:
-            batch_results = self._call_ollama_embed_batch(uncached_texts)
-            for idx, emb in zip(uncached_indices, batch_results):
-                results[idx] = emb
-                if emb is not None:
-                    key = texts[idx].strip()
-                    if len(self._embed_cache) >= self._CACHE_MAX_SIZE:
-                        first_key = next(iter(self._embed_cache))
-                        del self._embed_cache[first_key]
-                    self._embed_cache[key] = emb
-                self._cache_misses += 1
-            return results
-        except Exception as exc:
-            logger.warning("Ollama batch embed failed: %s", exc)
-            return results  # Return whatever was cached + None for rest
-
-    def compute_fisher_params(
-        self, embedding: list[float],
-    ) -> tuple[list[float], list[float]]:
-        """Compute Fisher-Rao parameters from a raw embedding."""
-        arr = np.asarray(embedding, dtype=np.float64)
-        norm = float(np.linalg.norm(arr))
-        if norm < 1e-10:
-            mean = np.zeros(len(arr), dtype=np.float64)
-            variance = np.full(len(arr), _FISHER_VAR_MAX, dtype=np.float64)
-            return mean.tolist(), variance.tolist()
-        mean = arr / norm
-        abs_mean = np.abs(mean)
-        max_val = float(np.max(abs_mean)) + 1e-10
-        signal_strength = abs_mean / max_val
-        variance = _FISHER_VAR_MAX - _FISHER_VAR_RANGE * signal_strength
-        variance = np.clip(variance, _FISHER_VAR_MIN, _FISHER_VAR_MAX)
-        return mean.tolist(), variance.tolist()
-
-    def unload(self) -> None:
-        """No-op for Ollama (Ollama manages its own model lifecycle)."""
-
-    # ------------------------------------------------------------------
-    # Internal
-    # ------------------------------------------------------------------
-
-    def _check_availability(self) -> bool:
-        """Verify Ollama is running and has the embedding model."""
-        import httpx
-
-        try:
-            resp = httpx.get(
-                f"{self._base_url}/api/tags",
-                timeout=_CONNECT_TIMEOUT,
-            )
-            if resp.status_code != 200:
-                return False
-            models = resp.json().get("models", [])
-            model_names = [m.get("name", "").split(":")[0] for m in models]
-            model_base = self._model.split(":")[0]
-            if model_base not in model_names:
-                logger.info(
-                    "Ollama running but model '%s' not found (have: %s)",
-                    self._model, ", ".join(model_names),
-                )
-                return False
-            return True
-        except Exception as exc:
-            logger.debug("Ollama not reachable: %s", exc)
-            return False
-
-    def _call_ollama_embed(self, text: str) -> list[float]:
-        """Call Ollama embed endpoint for a single text.
-
-        v3.4.52: ``keep_alive: -1`` pins the embedding model in VRAM
-        forever so subsequent calls have no cold-start latency. Industry
-        pattern (Hindsight, Zep, Supermemory) — without this, Ollama
-        unloads after 5min idle and the next call takes 20-30s.
-        """
-        import httpx
-
-        resp = httpx.post(
-            f"{self._base_url}/api/embed",
-            json={"model": self._model, "input": [text], "keep_alive": -1},
-            timeout=httpx.Timeout(_RESPONSE_TIMEOUT, connect=_CONNECT_TIMEOUT),
-        )
-        resp.raise_for_status()
-        data = resp.json()
-        # Ollama /api/embed returns {"embeddings": [[...]]}
-        vec = data["embeddings"][0]
-        return self._normalize_checked(vec)
-
-    def _call_ollama_embed_batch(self, texts: list[str]) -> list[list[float] | None]:
-        """Call Ollama embed endpoint with batch input.
-
-        v3.4.52: ``keep_alive: -1`` pins the embedding model — see
-        ``_call_ollama_embed`` docstring for rationale.
-        """
-        import httpx
-
-        resp = httpx.post(
-            f"{self._base_url}/api/embed",
-            json={"model": self._model, "input": texts, "keep_alive": -1},
-            timeout=httpx.Timeout(_RESPONSE_TIMEOUT, connect=_CONNECT_TIMEOUT),
-        )
-        resp.raise_for_status()
-        data = resp.json()
-        vectors = data.get("embeddings", [])
-        return [self._normalize_checked(v) for v in vectors]
-
-    def _normalize_checked(self, vec: list[float]) -> list[float]:
-        """Reject provider drift before a vector can enter any durable store."""
-        actual = len(vec)
-        if actual != self._dimension:
-            raise ValueError(
-                f"Ollama embedding dimension {actual} != expected {self._dimension}"
-            )
-        return self._normalize(vec)
-
-    @staticmethod
-    def _normalize(vec: list[float]) -> list[float]:
-        """L2-normalize embedding vector."""
-        arr = np.asarray(vec, dtype=np.float32)
-        norm = float(np.linalg.norm(arr))
-        if norm > 1e-10:
-            arr = arr / norm
-        return arr.tolist()

package/src/superlocalmemory/core/ollama_validator.py

@@ -1,315 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Ask the local model server whether a model exists, before trusting it.
-
-Mode B runs on Ollama, and a user picking a model there picks it by typing a
-name. Two things then go wrong silently.
-
-**The name is wrong.** Nothing happens at the moment of the mistake; the config
-saves, the daemon starts, and every write quietly falls back to a worse path.
-The error a user eventually sees is unrelated to what they did.
-
-**The name is right and the shape is different.** Every embedding model emits a
-vector of a fixed width. `nomic-embed-text` emits 768 numbers,
-`mxbai-embed-large` emits 1024. Vectors of different widths cannot be compared,
-so a store holding both answers similarity questions with noise — and it does so
-without failing, because nothing in a similarity search knows the difference
-between a bad answer and a good one. **This is the single silent-and-catastrophic
-change a user can make**, so it is refused rather than warned about, and the
-refusal says the one command that would make it safe.
-
-There are two Ollama roles and they are separate models with separate names:
-the embedding model (`embedding.ollama_model`) turns text into vectors, and the
-generation model (`llm.model` when the provider is Ollama) writes summaries.
-They are validated independently because a machine can perfectly well have one
-and not the other.
-"""
-
-from __future__ import annotations
-
-import logging
-import sqlite3
-from dataclasses import dataclass
-from pathlib import Path
-
-__all__ = [
-    "EMBEDDING",
-    "GENERATION",
-    "OllamaProbe",
-    "DimensionChange",
-    "validate_ollama_model",
-    "stored_embedding_dimension",
-    "check_embedding_model_change",
-    "same_embedding_model",
-]
-
-logger = logging.getLogger(__name__)
-
-EMBEDDING = "embedding"
-GENERATION = "generation"
-
-DEFAULT_BASE_URL = "http://localhost:11434"
-
-#: Long enough for a cold model load, short enough that a wedged server is not
-#: mistaken for a slow one.
-_CONNECT_TIMEOUT = 3.0
-_RESPONSE_TIMEOUT = 60.0
-
-_PROBE_TEXT = "superlocalmemory model probe"
-_PROBE_PROMPT = "Reply with the single word: ok"
-
-
-@dataclass(frozen=True)
-class OllamaProbe:
-    """What the server said when asked about one model."""
-
-    ok: bool
-    message: str
-    dimension: int | None = None
-
-    def __bool__(self) -> bool:  # pragma: no cover - convenience only
-        return self.ok
-
-
-@dataclass(frozen=True)
-class DimensionChange:
-    """A model change that would put two vector widths in one store."""
-
-    allowed: bool
-    message: str
-    stored_dimension: int | None = None
-    new_dimension: int | None = None
-
-
-def same_embedding_model(left: str, right: str) -> bool:
-    """True when two names are two spellings of one model.
-
-    ``nomic-ai/nomic-embed-text-v1.5`` is the HuggingFace name and
-    ``nomic-embed-text`` is the Ollama pull name for the same weights. Warning
-    about a dimension change between them would be a false alarm, and a false
-    alarm about the one thing that is genuinely dangerous is how a real warning
-    gets ignored.
-    """
-    def base(name: str) -> str:
-        stem = name.strip().lower().rsplit("/", 1)[-1]
-        # An Ollama tag is PART OF THE IDENTITY, not packaging.
-        # ``qwen3-embedding:0.6b`` emits 1024 numbers and ``qwen3-embedding:8b``
-        # emits 4096, and stripping the tag made this function call them the
-        # same model — which then skipped the width check that exists to stop
-        # exactly that swap. Only ``:latest`` means "whatever the bare name
-        # means", so only that one is dropped.
-        if stem.endswith(":latest"):
-            stem = stem[: -len(":latest")]
-        # A HuggingFace revision suffix on an otherwise identical name is
-        # packaging; ``nomic-embed-text-v1.5`` and ``nomic-embed-text`` are the
-        # same weights under two registries' conventions.
-        if ":" not in stem:
-            for suffix in ("-v1.5", "-v1", "-v2"):
-                if stem.endswith(suffix):
-                    stem = stem[: -len(suffix)]
-        return stem
-
-    return base(left) == base(right)
-
-
-def validate_ollama_model(
-    model_name: str,
-    role: str = EMBEDDING,
-    *,
-    base_url: str = DEFAULT_BASE_URL,
-    timeout: float = _RESPONSE_TIMEOUT,
-) -> OllamaProbe:
-    """Ask the server to actually use the model, and report what happened.
-
-    Listing the installed models is not enough: a name can be present and the
-    model still fail to load. So this runs the smallest real request for the
-    role and reads the answer, which is also the only way to learn an embedding
-    model's width.
-    """
-    if role not in (EMBEDDING, GENERATION):
-        raise ValueError(f"role must be {EMBEDDING!r} or {GENERATION!r}, got {role!r}")
-    name = (model_name or "").strip()
-    if not name:
-        return OllamaProbe(False, "No model name given.")
-
-    try:
-        import httpx
-    except ImportError:  # pragma: no cover - httpx is a hard dependency
-        return OllamaProbe(False, "httpx is not installed, so Ollama cannot be reached.")
-
-    url = base_url.rstrip("/")
-    request_timeout = httpx.Timeout(timeout, connect=_CONNECT_TIMEOUT)
-
-    try:
-        if role == EMBEDDING:
-            response = httpx.post(
-                f"{url}/api/embed",
-                json={"model": name, "input": [_PROBE_TEXT]},
-                timeout=request_timeout,
-            )
-        else:
-            response = httpx.post(
-                f"{url}/api/generate",
-                json={"model": name, "prompt": _PROBE_PROMPT, "stream": False},
-                timeout=request_timeout,
-            )
-    except httpx.ConnectError:
-        return OllamaProbe(
-            False,
-            f"Ollama is not running at {url}. Start it with: ollama serve",
-        )
-    except httpx.TimeoutException:
-        return OllamaProbe(
-            False,
-            f"Ollama did not answer within {timeout:.0f}s. The model may still be "
-            f"downloading — check with: ollama list",
-        )
-    except Exception as exc:  # noqa: BLE001 - the message is the product here
-        return OllamaProbe(False, f"Could not reach Ollama at {url}: {exc}")
-
-    if response.status_code == 404 or _looks_missing(response):
-        return OllamaProbe(
-            False,
-            f"Ollama has no model called {name!r}. Run: ollama pull {name}",
-        )
-    if role == EMBEDDING and _refuses_embeddings(response):
-        return OllamaProbe(
-            False,
-            f"{name!r} is not an embedding model — the server refused the "
-            f"request. Pick a model built for embeddings, such as "
-            f"nomic-embed-text.",
-        )
-    if response.status_code != 200:
-        return OllamaProbe(
-            False,
-            f"Ollama answered {response.status_code} for {name!r}: "
-            f"{response.text[:200]}",
-        )
-
-    try:
-        payload = response.json()
-    except ValueError:
-        return OllamaProbe(False, f"Ollama returned something that is not JSON for {name!r}.")
-
-    if role == EMBEDDING:
-        vectors = payload.get("embeddings") or []
-        if not vectors or not isinstance(vectors[0], list) or not vectors[0]:
-            return OllamaProbe(
-                False,
-                f"{name!r} answered but returned no vector, so it is not an "
-                f"embedding model. Pick one built for embeddings, such as "
-                f"nomic-embed-text.",
-            )
-        width = len(vectors[0])
-        return OllamaProbe(True, f"{name} emits {width}-dimensional vectors.", width)
-
-    text = str(payload.get("response") or "").strip()
-    if not text:
-        return OllamaProbe(
-            False,
-            f"{name!r} answered but wrote nothing, so it cannot be used to "
-            f"generate summaries.",
-        )
-    return OllamaProbe(True, f"{name} answered a probe prompt.")
-
-
-def _refuses_embeddings(response: object) -> bool:
-    """A generation-only model answers an embedding request with a refusal.
-
-    The server's own wording is about its build flags and means nothing to
-    somebody who typed a chat model's name into an embedding field.
-    """
-    status = getattr(response, "status_code", 0)
-    try:
-        lowered = response.text.lower()  # type: ignore[attr-defined]
-    except Exception:  # pragma: no cover - defensive
-        lowered = ""
-    if status == 501:
-        return True
-    return "does not support embed" in lowered or "not support embeddings" in lowered
-
-
-def _looks_missing(response: object) -> bool:
-    """Ollama reports an unknown model as a 400 with a body that says so."""
-    try:
-        body = response.text  # type: ignore[attr-defined]
-    except Exception:  # pragma: no cover - defensive
-        return False
-    lowered = body.lower()
-    return "not found" in lowered and "model" in lowered
-
-
-def stored_embedding_dimension(db_path: str | Path) -> int | None:
-    """The vector width this store already holds, or None if it holds none."""
-    path = Path(db_path)
-    if not path.exists():
-        return None
-    try:
-        conn = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
-    except sqlite3.Error:
-        return None
-    try:
-        row = conn.execute(
-            "SELECT dimension FROM embedding_metadata "
-            "WHERE dimension IS NOT NULL AND dimension > 0 LIMIT 1"
-        ).fetchone()
-    except sqlite3.Error:
-        return None
-    finally:
-        conn.close()
-    return int(row[0]) if row else None
-
-
-def check_embedding_model_change(
-    new_model: str,
-    *,
-    db_path: str | Path,
-    current_model: str = "",
-    base_url: str = DEFAULT_BASE_URL,
-) -> DimensionChange:
-    """Decide whether switching the embedding model is safe for this store.
-
-    Refuses rather than warns. A warning printed into a log is not a decision,
-    and the outcome of getting this wrong is a store whose similarity search is
-    quietly meaningless.
-    """
-    # The width is asked for FIRST, always. Recognising two names as the same
-    # model may soften the message, but it must never stand in for measuring —
-    # a name that merely looks familiar is exactly how a different-width model
-    # would get through.
-    probe = validate_ollama_model(new_model, EMBEDDING, base_url=base_url)
-    if not probe.ok:
-        return DimensionChange(False, probe.message)
-
-    familiar = bool(current_model) and same_embedding_model(current_model, new_model)
-    stored = stored_embedding_dimension(db_path)
-    if familiar and (stored is None or stored == probe.dimension):
-        return DimensionChange(
-            True,
-            f"{new_model} is another name for the model already in use, and it "
-            f"emits the same {probe.dimension}-dimensional vectors.",
-            stored,
-            probe.dimension,
-        )
-    if stored is None:
-        return DimensionChange(
-            True,
-            f"{probe.message} This store holds no vectors yet, so nothing has to "
-            f"be rebuilt.",
-            None,
-            probe.dimension,
-        )
-    if stored == probe.dimension:
-        return DimensionChange(True, probe.message, stored, probe.dimension)
-
-    return DimensionChange(
-        False,
-        f"{new_model} emits {probe.dimension}-dimensional vectors and this store "
-        f"holds {stored}-dimensional ones. Vectors of different widths cannot be "
-        f"compared, so every memory already stored would become unfindable by "
-        f"meaning. Rebuild them first with: slm db migrate",
-        stored,
-        probe.dimension,
-    )

package/src/superlocalmemory/core/operation_policy.py

@@ -1,92 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-
-"""Declarative per-operation policy record for the V4 admission layer.
-
-OperationPolicy is a plain frozen dataclass — a pure data declaration with no
-behaviour. The OperationPolicyRegistry owns all evaluation logic. A policy
-declares WHAT is required; the registry decides WHAT to DO when requirements
-are not met.
-
-Part of SuperLocalMemory V4 | Phase 4: Admission/Policy Layer
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import FrozenSet
-
-from superlocalmemory.core.actor_context import ActorRole, Transport
-from superlocalmemory.core.operation_request import OperationKind
-
-# Pre-compute the frozenset of all transports once; used as the default for
-# policies that allow every transport (most operations).
-_ALL_TRANSPORTS: frozenset[Transport] = frozenset(Transport)
-
-# Sensitive/administrative operations that are restricted to fewer transports
-# by default. The registry may override these at construction time.
-_ADMIN_TRANSPORTS: frozenset[Transport] = frozenset({
-    Transport.CLI,
-    Transport.INTERNAL,
-    Transport.DASHBOARD,
-})
-_MESH_TRANSPORTS: frozenset[Transport] = frozenset({
-    Transport.MESH,
-    Transport.MCP,
-    Transport.HTTP,
-    Transport.INTERNAL,
-})
-
-
-@dataclass(frozen=True, slots=True)
-class OperationPolicy:
-    """Declarative policy for one operation kind.
-
-    The registry stores one OperationPolicy per OperationKind (and
-    optionally per transport when transport-specific overrides are needed,
-    though the V4 default table uses one per kind).
-
-    Field semantics
-    ---------------
-    required_roles          Actor must hold at least ONE of these roles.
-                            Empty frozenset → deny all (explicit deny policy).
-    required_authentication Actor.is_authenticated must be True.
-    allowed_transports      Actor.transport must be in this set.
-    requires_schema_capability  Non-empty → DB must expose this capability.
-    max_payload_bytes       Advisory only — payload > this is ANNOTATED, not
-                            rejected (double-rejection is avoided; the ingest
-                            gate already enforces the 1 MiB hard cap).
-    deadline_budget_ms      Advisory request deadline.
-    audit_level             "none" | "standard" | "full" — governs log detail.
-    redaction_policy        "none" | "scrub" | "full" — governs PII scrub.
-    resource_ownership_check Whether the coordinator must verify ownership.
-    allow_cross_profile     Whether the actor may target a non-active profile.
-    fail_closed_in_company_mode Informational — the registry uses the ``mode``
-                            argument to evaluate(), not this field, for
-                            unknown-kind fallback behaviour.
-    """
-
-    kind: OperationKind
-    required_roles: FrozenSet[ActorRole] = field(
-        default_factory=lambda: frozenset({ActorRole.OWNER})
-    )
-    required_authentication: bool = True
-    allowed_transports: FrozenSet[Transport] = field(
-        default_factory=lambda: _ALL_TRANSPORTS
-    )
-    requires_schema_capability: str = ""
-    max_payload_bytes: int = 1_048_576          # 1 MiB — advisory only
-    deadline_budget_ms: int = 30_000
-    audit_level: str = "standard"              # "none" | "standard" | "full"
-    redaction_policy: str = "scrub"            # "none" | "scrub" | "full"
-    resource_ownership_check: bool = True
-    allow_cross_profile: bool = False
-    fail_closed_in_company_mode: bool = True    # informational; see docstring
-
-
-__all__ = [
-    "OperationPolicy",
-    "_ALL_TRANSPORTS",
-    "_ADMIN_TRANSPORTS",
-    "_MESH_TRANSPORTS",
-]