ltcai 11.5.1 → 11.5.2

package/latticeai/core/model_compat.py

@@ -12,7 +12,6 @@
 
 from __future__ import annotations
 
-import importlib.util
 import json
 import logging
 import re
@@ -22,6 +21,8 @@ from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
+from latticeai.core.module_probe import module_available as _module_available
+
 logger = logging.getLogger(__name__)
 
 
@@ -198,13 +199,6 @@ GEMMA4_MLX_LM_MODULES = ("mlx_lm.models.gemma4", "mlx_lm.models.gemma4_text")
 GEMMA4_UNIFIED_ID_PATTERN = re.compile(r"gemma[-_/ ]?4[-_/ ]?12b", re.I)
 
 
-def _module_available(module: str) -> bool:
-    try:
-        return importlib.util.find_spec(module) is not None
-    except (ImportError, ModuleNotFoundError, AttributeError, ValueError):
-        return False
-
-
 def _is_gemma4(model_id: str) -> bool:
     raw = str(model_id or "").lower()
     return bool(re.search(r"gemma[-_/ ]?4", raw))

package/latticeai/core/module_probe.py

@@ -0,0 +1,37 @@
+"""One answer to "is this module importable?".
+
+Four modules asked it four different ways: two consulted ``find_spec``, one
+imported for real, and they disagreed about which failures mean "no" and which
+should escape. The disagreement mattered — the setup probe's copy imports for
+real *on purpose*, because a native wheel like ``mlx`` can have a perfectly
+findable spec on the wrong architecture and still raise when it loads. A copy
+that only looked for the spec would report the runtime as present and let the
+recommendation engine plan an install around a module that cannot run.
+
+So the two behaviours stay, named: ``strict=False`` asks whether Python can
+*find* the module (cheap, no side effects, no import cost); ``strict=True``
+actually imports it and answers whether it *works*.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+
+__all__ = ["module_available"]
+
+
+def module_available(name: str, *, strict: bool = False) -> bool:
+    """Report whether ``name`` can be imported, never raising.
+
+    A probe that raises is a probe that takes the caller down for asking, and
+    every caller here is deciding what to *offer* the user — "I could not tell"
+    and "it is not there" lead to the same honest answer.
+    """
+    try:
+        if strict:
+            importlib.import_module(name)
+            return True
+        return importlib.util.find_spec(name) is not None
+    except Exception:
+        return False

package/latticeai/core/run_explain.py

@@ -30,6 +30,8 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Mapping, Optional, Sequence
 
+from latticeai.core.messages import bilingual as _bilingual
+
 __all__ = ["explain_run", "STRAIN_LEVELS"]
 
 
@@ -53,8 +55,9 @@ _REPAIR_GROUPS: Dict[str, tuple] = {
 }
 
 
-def _phrase(ko: str, en: str) -> Dict[str, str]:
-    return {"ko": ko, "en": en}
+
+#: Historical module-local name for the shared phrase-pair helper.
+_phrase = _bilingual
 
 
 def _int(value: Any) -> int:

package/latticeai/core/run_store.py

@@ -21,7 +21,6 @@ Design constraints (deliberate, matching :mod:`latticeai.services.funnel_metrics
 
 from __future__ import annotations
 
-import hashlib
 import json
 import logging
 import os
@@ -34,6 +33,7 @@ from typing import Any, Dict, List, Optional
 from latticeai.core.agent import AgentRunContext, AgentState
 from latticeai.core.agent_trace import LoopTrace
 from latticeai.core.quiet import quiet
+from latticeai.core.security import sha256_hex
 
 LOGGER = logging.getLogger(__name__)
 
@@ -44,7 +44,7 @@ _RUN_ID_RE = re.compile(r"^[A-Za-z0-9_-]{8,64}$")
 
 def hash_approval_token(token: str) -> str:
     """Stable digest used both at save and at resume comparison time."""
-    return hashlib.sha256(str(token or "").encode("utf-8")).hexdigest()
+    return sha256_hex(str(token or ""))
 
 
 def serialize_run_context(ctx: AgentRunContext) -> Dict[str, Any]:

package/latticeai/core/security.py

@@ -13,6 +13,19 @@ from fastapi import HTTPException
 from latticeai.core.quiet import quiet
 
 
+def sha256_hex(text: str) -> str:
+    """The one UTF-8 SHA-256 hex digest.
+
+    Six modules each carried this three-token expression, and they did not
+    agree on what to do with ``None``: two coerced it away, one raised. The
+    helper stays **strict** on purpose — coercing here would silently give
+    every caller the digest of the empty string, which is a valid-looking
+    token hash for "no token at all". Each call site keeps the contract it
+    already had, stated in its own body where a reader can see it.
+    """
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
 def hash_password(password: str) -> str:
     salt = secrets.token_hex(16)
     key = hashlib.scrypt(password.encode(), salt=salt.encode(), n=16384, r=8, p=1)

package/latticeai/core/sessions.py

@@ -6,7 +6,6 @@ holding raw tokens are migrated transparently on load (sessions survive the
 upgrade; the raw token never touches disk again).
 """
 
-import hashlib
 import json
 import logging
 import secrets
@@ -16,6 +15,7 @@ from pathlib import Path
 from typing import Dict, Optional
 
 from latticeai.core.io_utils import atomic_write_json
+from latticeai.core.security import sha256_hex
 
 SESSION_TTL = 60 * 60 * 24  # 24 hours
 SESSION_REFRESH_THRESHOLD = 60 * 15  # only persist if >15 min since last bump
@@ -25,7 +25,8 @@ _HEX64 = frozenset("0123456789abcdef")
 
 
 def _hash_token(token: str) -> str:
-    return hashlib.sha256((token or "").encode("utf-8")).hexdigest()
+    """Session keys are hashed at rest; a missing token hashes the empty string."""
+    return sha256_hex(token or "")
 
 
 def _looks_hashed(key: str) -> bool:

package/latticeai/core/sse.py

@@ -0,0 +1,25 @@
+"""The one Server-Sent Events frame builder.
+
+Five modules each formatted their own frame — three in the
+``event:``/``data:`` shape and two in the bare ``data:`` shape — with the same
+``json.dumps(..., ensure_ascii=False)`` payload. They agreed by accident, and a
+frame that disagrees by one byte is a stream the browser silently stops
+parsing, so the agreement is now structural rather than coincidental.
+
+``event=None`` produces the bare shape; a named event produces the prefixed
+one. Both are byte-identical to the copies they replaced.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+__all__ = ["sse_frame"]
+
+
+def sse_frame(event: Optional[str], data: Any) -> str:
+    """Render one SSE frame, terminated by the blank line that ends it."""
+    payload = json.dumps(data, ensure_ascii=False)
+    prefix = f"event: {event}\n" if event else ""
+    return f"{prefix}data: {payload}\n\n"

package/latticeai/core/users.py

@@ -100,15 +100,6 @@ def user_id_for_email(users: Dict[str, Any], email: Optional[str]) -> Optional[s
     return stable_user_id(normalized)
 
 
-def email_for_user_id(users: Dict[str, Any], user_id: Optional[str]) -> Optional[str]:
-    if not user_id:
-        return None
-    for email, user in (users or {}).items():
-        if isinstance(user, dict) and user.get("id") == user_id:
-            return email
-    return None
-
-
 def migrate_knowledge_graph_identity(db_path: Path, email_to_id: Dict[str, str]) -> int:
     """Rewrite KG owner/creator identity columns from email to stable UUIDs."""
     if not db_path.exists() or not email_to_id:

package/latticeai/core/workspace_graph_trace.py

@@ -6,16 +6,10 @@ from typing import Any, Dict, List, Optional
 from latticeai.core.quiet import quiet
 
 from .timeutil import now_iso as _now
-from .workspace_os_utils import _json_hash, _listify
+from .workspace_os_utils import WorkspaceStoreMixin, _json_hash, _listify
 
 
-class WorkspaceGraphTrace:
-    def __init__(self, store: Any):
-        self._store = store
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._store, name)
-
+class WorkspaceGraphTrace(WorkspaceStoreMixin):
     def build_graph_trace(
         self,
         question: str,

package/latticeai/core/workspace_os.py

@@ -53,7 +53,6 @@ from .workspace_permissions import (  # type: ignore
 from .workspace_plugins import WorkspacePluginManager
 from .workspace_relationships import WorkspaceRelationships
 from .workspace_relationships import shortest_path as _shortest_path
-from .workspace_reorganization import plan_reorganization
 from .workspace_review_items import WorkspaceReviewItems
 from .workspace_runs import WorkspaceRuns
 from .workspace_skills import WorkspaceSkills
@@ -844,15 +843,6 @@ class WorkspaceOSStore:
     # Agent-native workspace: folder reorganization (v11.1.0)
     # ------------------------------------------------------------------
 
-    def preview_reorganization(
-        self, *, root: str = "", resolve_path: Callable[[str], Any], graph: Any = None,
-        max_moves: int = 20,
-    ) -> Dict[str, Any]:
-        """What a reorganization would do — read-only, nothing is staged."""
-        return plan_reorganization(
-            root=root, resolve_path=resolve_path, graph=graph, max_moves=max_moves
-        )
-
     def propose_reorganization(
         self, *, root: str = "", change_proposals: Any, graph: Any = None,
         user_email: Optional[str] = None, workspace_id: Optional[str] = None,

package/latticeai/core/workspace_os_constants.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import Dict
 
-WORKSPACE_OS_VERSION = "11.5.1"
+WORKSPACE_OS_VERSION = "11.5.2"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/core/workspace_os_utils.py

@@ -17,6 +17,40 @@ from .io_utils import (
 from .io_utils import parse_iso as _parse_iso  # noqa: F401 - legacy helper re-export
 
 
+class WorkspaceStoreMixin:
+    """A collaborator that reads and writes through ``WorkspaceOSStore``.
+
+    The store was decomposed into managers that each own one branch of the state
+    document, and every one of them needs the same two things: a reference to the
+    store, and for anything it does not implement itself (``load_state``,
+    ``_scoped``, ``record_timeline_event``) to reach the store instead of raising
+    ``AttributeError``. Four managers wrote that out identically; the pair lives
+    here so a fifth cannot invent a third spelling of it.
+    """
+
+    def __init__(self, store: Any) -> None:
+        self._store = store
+
+    def __getattr__(self, name: str) -> Any:
+        # Only reached for attributes this manager does not define, so the
+        # store is the answer for every state-document operation.
+        return getattr(self._store, name)
+
+
+def graph_scope_kwargs(workspace_id: Any) -> Dict[str, Any]:
+    """The scoped-read kwargs the graph store expects (house pattern).
+
+    ``workspace_id is None`` means "unscoped caller": it reads everything it is
+    allowed to, legacy rows that predate workspaces included. A named workspace
+    reads only that workspace and never the legacy pool — which is the whole
+    isolation guarantee, so it is stated once.
+    """
+    return {
+        "allowed_workspaces": {workspace_id} if workspace_id is not None else None,
+        "include_legacy_global": workspace_id is None,
+    }
+
+
 def _safe_slug(raw: str) -> str:
     value = "".join(ch if ch.isalnum() or ch in "-_." else "-" for ch in str(raw or "").strip())
     value = "-".join(part for part in value.split("-") if part)

package/latticeai/core/workspace_review_items.py

@@ -14,16 +14,10 @@ from __future__ import annotations
 from typing import Any, Dict, List, Optional
 
 from .timeutil import now_iso as _now
-from .workspace_os_utils import _json_hash, _listify
+from .workspace_os_utils import WorkspaceStoreMixin, _json_hash, _listify
 
 
-class WorkspaceReviewItems:
-    def __init__(self, store: Any):
-        self._store = store
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._store, name)
-
+class WorkspaceReviewItems(WorkspaceStoreMixin):
     def create_review_item(
         self,
         *,

package/latticeai/core/workspace_runs.py

@@ -8,16 +8,10 @@ from lattice_brain.runtime.contracts import run_record_contract, workflow_run_co
 from lattice_brain.runtime.statuses import RUN_ACTIVE_STATUSES, RUN_TERMINAL_STATUSES
 
 from .timeutil import now_iso as _now
-from .workspace_os_utils import _json_hash, _listify
+from .workspace_os_utils import WorkspaceStoreMixin, _json_hash, _listify
 
 
-class WorkspaceRuns:
-    def __init__(self, store: Any):
-        self._store = store
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._store, name)
-
+class WorkspaceRuns(WorkspaceStoreMixin):
     def list_agents(self, workspace_id: Optional[str] = None) -> Dict[str, Any]:
         state = self.load_state()
         runs = self._scoped(_listify(state.get("agent_runs")), workspace_id)

package/latticeai/core/workspace_skills.py

@@ -6,15 +6,10 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from .timeutil import now_iso as _now
+from .workspace_os_utils import WorkspaceStoreMixin
 
 
-class WorkspaceSkills:
-    def __init__(self, store: Any):
-        self._store = store
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._store, name)
-
+class WorkspaceSkills(WorkspaceStoreMixin):
     def list_skill_registry(self, skills_dir: Path, marketplace: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
         state = self.load_state()
         registry = state.setdefault("skill_registry", {})

package/latticeai/models/router/documents.py

@@ -21,23 +21,6 @@ class _DocumentMixin(_Core):
 
     # ── Document Generation Pipeline ──────────────────────────────────────
 
-    async def generate_document(
-        self,
-        message: str,
-        system_prompt: str,
-        *,
-        max_tokens: int = 8192,
-        temperature: float = 0.3,
-    ) -> str:
-        """Generate a document using a specialized system prompt with graph context."""
-        return await self.generate_document_as(
-            None,
-            message,
-            system_prompt,
-            max_tokens=max_tokens,
-            temperature=temperature,
-        )
-
     async def generate_document_as(
         self,
         model_id: str | None,
@@ -98,24 +81,6 @@ class _DocumentMixin(_Core):
             raise RuntimeError(self._local_server_error_hint(cloud, e)) from e
         return normalize_branding(response.choices[0].message.content or "")
 
-    async def stream_generate_document(
-        self,
-        message: str,
-        system_prompt: str,
-        *,
-        max_tokens: int = 8192,
-        temperature: float = 0.3,
-    ) -> AsyncIterator[str]:
-        """Stream document generation with specialized system prompt."""
-        async for chunk in self.stream_generate_document_as(
-            None,
-            message,
-            system_prompt,
-            max_tokens=max_tokens,
-            temperature=temperature,
-        ):
-            yield chunk
-
     async def stream_generate_document_as(
         self,
         model_id: str | None,

package/latticeai/models/router/registry.py

@@ -107,10 +107,6 @@ class _RegistryMixin(_Core):
                 self.unload_model(victim)
                 local_ids = [model_id for model_id in self._cache if self._is_local_model(model_id)]
 
-    def _is_cloud_current(self) -> bool:
-        with self._lock:
-            return bool(self._current and isinstance(self._cache.get(self._current), CloudModel))
-
     def _local_server_error_hint(self, cloud: CloudModel, error: Exception) -> str:
         raw = str(error)
         if cloud.provider == "lmstudio":

package/latticeai/runtime/access_runtime.py

@@ -7,6 +7,21 @@ from typing import Any, Callable, Dict, Optional
 from latticeai.core.quiet import quiet
 
 
+def is_externally_reachable(config: Any) -> bool:
+    """Whether anything but this machine can open a socket to this worker.
+
+    The single definition of the second half of ``trusted_local_owner``.  It is
+    read here (to decide who the anonymous caller is) and by the ``/health``
+    router (to *state* the posture, so the Rust front door can mirror it on its
+    own native lanes instead of guessing).  Two derivations of one fact is how
+    a gateway ends up serving a graph the worker would have refused.
+    """
+    return bool(
+        getattr(config, "is_public", False)
+        or getattr(config, "network_exposed", False)
+    )
+
+
 def build_access_runtime(
     *,
     config: Any,
@@ -29,10 +44,7 @@ def build_access_runtime(
     # but project the identity as an owner at authorization boundaries.  Never
     # extend this trust to public or non-loopback bindings, even if an invalid
     # caller constructs this runtime with ``require_auth=False`` directly.
-    externally_reachable = bool(
-        getattr(config, "is_public", False)
-        or getattr(config, "network_exposed", False)
-    )
+    externally_reachable = is_externally_reachable(config)
     trusted_local_owner = not require_auth and not externally_reachable
     effective_require_auth = bool(require_auth or externally_reachable)
 

package/latticeai/runtime/build_phases/features.py

@@ -305,6 +305,7 @@ def phase_interaction(ctx: RuntimeContext) -> None:
     from latticeai.core.model_compat import (
         list_cached_profiles as _list_compat_profiles,
     )
+    from latticeai.runtime.access_runtime import is_externally_reachable
     from latticeai.runtime.chat_wiring import build_interaction_contexts
     from latticeai.runtime.model_wiring import register_model_runtime_routers
     from latticeai.runtime.platform_services_runtime import build_brain_network
@@ -340,6 +341,7 @@ def phase_interaction(ctx: RuntimeContext) -> None:
             engine_status=service.engine_status,
             get_current_user=ctx.get_current_user,
             require_auth=ctx.REQUIRE_AUTH,
+            externally_reachable=is_externally_reachable(ctx.CONFIG),
             app_version=ctx.APP_VERSION,
             app_mode=ctx.APP_MODE,
             require_user=ctx.require_user,

package/latticeai/runtime/build_phases/web.py

@@ -310,6 +310,7 @@ def phase_web(ctx: RuntimeContext) -> None:
         create_security_router as _create_security_router,
     )
     from latticeai.api.static_routes import create_static_routes_router
+    from latticeai.core.config import default_sso_redirect_uri
     from latticeai.core.policy import policy_matrix
     from latticeai.core.product_hardening import build_product_hardening_status
     from latticeai.core.security import hash_password
@@ -408,6 +409,7 @@ def phase_web(ctx: RuntimeContext) -> None:
 
     foundation_router_bundle = build_auth_admin_security_router_bundle(
         create_auth_router=create_auth_router,
+        sso_default_redirect_uri=default_sso_redirect_uri(ctx.DEFAULT_PORT),
         load_users=ctx.load_users,
         save_users=ctx.save_users,
         hash_password=hash_password,

package/latticeai/runtime/feature_toggle_wiring.py

@@ -1,9 +1,11 @@
 """Wire the feature switchboard into the running app (v11.2.0).
 
-Same shape as ``permission_mode_wiring``: one process-wide service, an
-idempotent router mount guarded on ``app.state``, and explicit arguments that
-*rebind* an already-created service rather than being dropped — a lazy first
-caller must not pin the store to a fallback data dir with no audit sink.
+Same shape as ``permission_mode_wiring``: one process-wide service and an
+idempotent router mount guarded on ``app.state``. The rebinding rule that shape
+turns on — explicit arguments *rebind* an already-created service rather than
+being dropped, so a lazy first caller cannot pin the store to a fallback data
+dir with no audit sink — is shared, in
+:mod:`latticeai.runtime.service_singletons`.
 
 The one job unique to this module is :func:`bind_feature_gates`: it points each
 opt-in gate's resolver at the service, which is the step that turns a persisted
@@ -18,11 +20,14 @@ them back, and "the environment answers again" has to be reachable.
 
 from __future__ import annotations
 
-import os
 import threading
 from pathlib import Path
 from typing import Any, Callable, List, Optional, Tuple
 
+from latticeai.runtime.service_singletons import (
+    rebind_singleton,
+    singleton_data_dir,
+)
 from latticeai.services.feature_toggles import FeatureToggleService
 
 _LOCK = threading.Lock()
@@ -47,13 +52,6 @@ GATE_BINDINGS: Tuple[Tuple[str, str, str], ...] = (
 CHOICE_FEATURE = "vector_backend"
 
 
-def _default_data_dir() -> Path:
-    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
-    if raw:
-        return Path(raw)
-    return Path.home() / ".ltcai"
-
-
 def _boolean_gates() -> List[Tuple[str, Any]]:
     """``[(feature id, gate)]`` — imports are here, not at module import."""
     from importlib import import_module
@@ -80,15 +78,11 @@ def get_feature_toggle_service(
     with _LOCK:
         if _SHARED is None:
             _SHARED = FeatureToggleService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 audit=audit,
             )
             return _SHARED
-        if data_dir is not None:
-            _SHARED.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _SHARED.rebind_audit(audit)
-        return _SHARED
+        return rebind_singleton(_SHARED, data_dir=data_dir, audit=audit)
 
 
 def bind_feature_gates(service: Optional[FeatureToggleService] = None) -> None:

package/latticeai/runtime/network_boundary_wiring.py

@@ -11,6 +11,10 @@ from latticeai.core.network_boundary import (
     DEFAULT_NETWORK_MODE,
     normalize_network_mode,
 )
+from latticeai.runtime.service_singletons import (
+    rebind_singleton,
+    singleton_data_dir,
+)
 from latticeai.services.hybrid_policy import HybridPolicyService
 from latticeai.services.network_boundary_service import NetworkBoundaryService
 
@@ -19,13 +23,6 @@ _SHARED: Optional[NetworkBoundaryService] = None
 _POLICY: Optional[HybridPolicyService] = None
 
 
-def _default_data_dir() -> Path:
-    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
-    if raw:
-        return Path(raw)
-    return Path.home() / ".ltcai"
-
-
 def _env_default_mode() -> Any:
     return normalize_network_mode(
         os.environ.get("LATTICEAI_NETWORK_MODE", DEFAULT_NETWORK_MODE.value)
@@ -41,16 +38,12 @@ def get_network_boundary_service(
     with _LOCK:
         if _SHARED is None:
             _SHARED = NetworkBoundaryService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 default_mode=_env_default_mode(),
                 audit=audit,
             )
             return _SHARED
-        if data_dir is not None:
-            _SHARED.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _SHARED.rebind_audit(audit)
-        return _SHARED
+        return rebind_singleton(_SHARED, data_dir=data_dir, audit=audit)
 
 
 def get_hybrid_policy_service(
@@ -62,15 +55,11 @@ def get_hybrid_policy_service(
     with _LOCK:
         if _POLICY is None:
             _POLICY = HybridPolicyService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 audit=audit,
             )
             return _POLICY
-        if data_dir is not None:
-            _POLICY.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _POLICY.rebind_audit(audit)
-        return _POLICY
+        return rebind_singleton(_POLICY, data_dir=data_dir, audit=audit)
 
 
 def resolve_active_network_mode(

package/latticeai/runtime/permission_mode_wiring.py

@@ -15,19 +15,16 @@ from pathlib import Path
 from typing import Any, Callable, Optional
 
 from latticeai.core.permission_mode import DEFAULT_MODE, normalize_mode
+from latticeai.runtime.service_singletons import (
+    rebind_singleton,
+    singleton_data_dir,
+)
 from latticeai.services.permission_mode_service import PermissionModeService
 
 _LOCK = threading.Lock()
 _SHARED: Optional[PermissionModeService] = None
 
 
-def _default_data_dir() -> Path:
-    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
-    if raw:
-        return Path(raw)
-    return Path.home() / ".ltcai"
-
-
 def _env_default_mode() -> Any:
     return normalize_mode(os.environ.get("LATTICEAI_PERMISSION_MODE", DEFAULT_MODE.value))
 
@@ -48,16 +45,12 @@ def get_permission_mode_service(
     with _LOCK:
         if _SHARED is None:
             _SHARED = PermissionModeService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 default_mode=_env_default_mode(),
                 audit=audit,
             )
             return _SHARED
-        if data_dir is not None:
-            _SHARED.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _SHARED.rebind_audit(audit)
-        return _SHARED
+        return rebind_singleton(_SHARED, data_dir=data_dir, audit=audit)
 
 
 def resolve_active_permission_mode(