ltcai 11.5.1 → 11.5.2

package/latticeai/runtime/router_registration.py

@@ -83,6 +83,7 @@ def build_auth_admin_security_router_bundle(
     secure_cookies: bool,
     invite_authorized: Any,
     ensure_identity: Any,
+    sso_default_redirect_uri: str,
     create_admin_router: Any,
     require_admin: Any,
     get_history: Any,
@@ -138,6 +139,7 @@ def build_auth_admin_security_router_bundle(
         invite_gate_enabled=invite_gate_enabled,
         invite_authorized=invite_authorized,
         ensure_identity=ensure_identity,
+        default_redirect_uri=sso_default_redirect_uri,
     )
 
     def graph_stats_safe() -> dict[str, Any]:
@@ -376,6 +378,7 @@ def register_health_and_model_routers(
     engine_status: Any,
     get_current_user: Any,
     require_auth: bool,
+    externally_reachable: bool,
     app_version: str,
     app_mode: str,
     create_models_router: Any,
@@ -411,6 +414,7 @@ def register_health_and_model_routers(
             engine_status=engine_status,
             get_current_user=get_current_user,
             require_auth=require_auth,
+            externally_reachable=externally_reachable,
             app_version=app_version,
             app_mode=app_mode,
         ),

package/latticeai/runtime/runtime_context.py

@@ -25,7 +25,7 @@ Two properties keep it honest:
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Set
+from typing import Any, Dict, Set
 
 
 class RuntimeContext:
@@ -257,21 +257,9 @@ class RuntimeContext:
                 f"RuntimeContext.{name} was read before it was built{hint}"
             ) from None
 
-    @property
-    def produced_by(self) -> Dict[str, str]:
-        """Attribute name → the phase that published it, for the order test."""
-        return dict(self._produced)
-
     def names(self) -> Set[str]:
         return set(self._produced)
 
-    def phases_run(self) -> List[str]:
-        seen: List[str] = []
-        for phase in self._produced.values():
-            if phase not in seen:
-                seen.append(phase)
-        return seen
-
     def __repr__(self) -> str:  # pragma: no cover - debugging aid
         return f"<RuntimeContext phase={self._phase!r} names={len(self._produced)}>"
 

package/latticeai/runtime/service_singletons.py

@@ -0,0 +1,55 @@
+"""The rebinding half of the process-wide service singletons.
+
+Four wiring modules create one service each — the permission dial, the network
+boundary, the hybrid policy, the feature switchboard — and all four had the
+same problem and the same four-line answer to it: a lazy first caller (a tool
+dispatch, a feature gate) can ask for the service *before* routers know the
+configured data dir or the audit sink, and if the later explicit call were
+allowed to be a no-op the service would stay pinned to the fallback path with
+its audit events going nowhere.
+
+So explicit arguments rebind rather than being dropped. That rule was written
+out four times; it lives here once, because "the second caller silently loses"
+is precisely the kind of divergence that produces a second, invisible copy of
+the user's data and no failing test.
+
+The singleton *slot* deliberately stays a module global in each wiring module:
+the modules are the unit of process state, and the suite resets them by
+assigning ``_SHARED = None``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Optional, TypeVar
+
+from latticeai.core.config import default_data_dir
+
+ServiceT = TypeVar("ServiceT")
+
+__all__ = ["singleton_data_dir", "rebind_singleton"]
+
+
+def singleton_data_dir(data_dir: Optional[Path]) -> Path:
+    """Where a *first* lazy caller should put the store."""
+    return Path(data_dir) if data_dir is not None else default_data_dir()
+
+
+def rebind_singleton(
+    service: ServiceT,
+    *,
+    data_dir: Optional[Path] = None,
+    audit: Optional[Callable[..., None]] = None,
+) -> ServiceT:
+    """Apply explicit arguments to an already-created singleton, then return it.
+
+    ``None`` means "the caller did not say", never "unset it" — a router that
+    mounts without an audit sink must not silence a sink an earlier caller
+    already supplied.
+    """
+    rebindable: Any = service
+    if data_dir is not None:
+        rebindable.rebind_data_dir(Path(data_dir))
+    if audit is not None:
+        rebindable.rebind_audit(audit)
+    return service

package/latticeai/services/architecture_readiness.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List
 
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
-ARCHITECTURE_VERSION_TARGET = "11.5.1"
+ARCHITECTURE_VERSION_TARGET = "11.5.2"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/brain_intelligence/proposals.py

@@ -31,11 +31,6 @@ class BrainProposalsMixin(_Core):
     # is absent they report ``available: False`` rather than falling back to a
     # direct write.
 
-    def attach_review_queue(self, review_queue: Any) -> None:
-        """Bind the review queue proposals are written to (composition root)."""
-        self._review_queue_service = review_queue
-        self._synthesizer = None
-
     def _review_queue(self) -> Any:
         """The queue to propose into, or ``None`` when there is none.
 

package/latticeai/services/change_proposals.py

@@ -21,7 +21,6 @@ change audit log. The classification itself lives in
 from __future__ import annotations
 
 import difflib
-import hashlib
 import logging
 import os
 import tempfile
@@ -30,6 +29,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from latticeai.core.quiet import quiet
+from latticeai.core.security import sha256_hex
 from latticeai.core.tool_governor import classify_tool_call
 from latticeai.core.workspace_reorganization import (
     REORG_KIND,
@@ -90,7 +90,7 @@ class ProposalConflictError(ValueError):
 
 
 def _sha256_text(content: str) -> str:
-    return hashlib.sha256(content.encode("utf-8")).hexdigest()
+    return sha256_hex(content)
 
 
 def _unified_diff(before: str, after: str, path: str) -> List[str]:
@@ -272,40 +272,6 @@ class ChangeProposalService:
         )
         return item
 
-    def propose_file_delete(
-        self,
-        *,
-        path: str,
-        proposed_by: str = "agent",
-        reason: str = "",
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        base_exists, before = self._snapshot(path)
-        item = self._review_queue.create(
-            title=f"파일 삭제 제안: {path}",
-            summary=reason or "기존 파일을 삭제하는 작업이라 검토 후 적용됩니다.",
-            source="change_proposal",
-            kind="file_delete",
-            payload={
-                "path": path,
-                "diff": _unified_diff(before, "", path),
-                "tier": "large",
-                "before_bytes": len(before.encode("utf-8")),
-                "after_bytes": 0,
-                "base_exists": base_exists,
-                "base_sha256": _sha256_text(before) if base_exists else "",
-            },
-            provenance={"proposed_by": proposed_by, "reason": reason},
-            user_email=user_email,
-            workspace_id=workspace_id,
-        )
-        self._audit(
-            "change_proposal_created", user_email=user_email,
-            proposal_id=item.get("id"), path=path, kind="file_delete", tier="large",
-        )
-        return item
-
     def propose_reorganization(
         self,
         *,

package/latticeai/services/chronicle.py

@@ -48,6 +48,7 @@ from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
 
 from latticeai.core.timeutil import parse_iso
 from latticeai.core.timezones import get_timezone
+from latticeai.core.workspace_os_utils import graph_scope_kwargs
 
 LOGGER = logging.getLogger(__name__)
 
@@ -249,12 +250,9 @@ def _empty_lanes() -> Dict[str, int]:
     return {lane: 0 for lane in _LANES}
 
 
-def _scope_kwargs(workspace_id: Optional[str]) -> Dict[str, Any]:
-    """The scoped-read kwargs the graph store expects (house pattern)."""
-    return {
-        "allowed_workspaces": {workspace_id} if workspace_id is not None else None,
-        "include_legacy_global": workspace_id is None,
-    }
+
+#: Historical module-local name for the shared rule.
+_scope_kwargs = graph_scope_kwargs
 
 
 def _on_day(rows: Sequence[Any], day: str) -> List[Any]:

package/latticeai/services/command_center.py

@@ -28,6 +28,7 @@ from typing import Any, Dict, List, Optional
 
 from latticeai.core.timeutil import local_now, parse_iso
 from latticeai.core.timeutil import now_iso as _now
+from latticeai.core.workspace_os_utils import graph_scope_kwargs
 
 LOGGER = logging.getLogger(__name__)
 
@@ -48,6 +49,8 @@ def _clip(text: Any, limit: int = 160) -> str:
     return value[:limit]
 
 
+
+
 class CommandCenterService:
     def __init__(
         self,
@@ -73,10 +76,7 @@ class CommandCenterService:
     # ── scoped reads ─────────────────────────────────────────────────────
 
     def _scope_kwargs(self, workspace_id: Optional[str]) -> Dict[str, Any]:
-        return {
-            "allowed_workspaces": {workspace_id} if workspace_id is not None else None,
-            "include_legacy_global": workspace_id is None,
-        }
+        return graph_scope_kwargs(workspace_id)
 
     def _history(
         self, *, user_email: Optional[str], workspace_id: Optional[str], limit: int

package/latticeai/services/evidence_actions.py

@@ -28,6 +28,8 @@ import logging
 import re
 from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence
 
+from latticeai.core.messages import bilingual
+
 LOGGER = logging.getLogger(__name__)
 
 __all__ = ["EvidenceActionService", "EVIDENCE_ACTIONS"]
@@ -38,8 +40,9 @@ _EXCERPT_CHARS = 600
 _MAX_SOURCES = 8
 
 
-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
 
 
 # The action catalog is closed and deterministic — the UI renders exactly

package/latticeai/services/hybrid_chat.py

@@ -13,7 +13,6 @@ auto-commit — so a headless caller stages nothing rather than writing.
 
 from __future__ import annotations
 
-import json
 import logging
 from typing import Any, AsyncIterator, Dict, Optional
 
@@ -21,6 +20,7 @@ from latticeai.core.network_boundary import (
     NetworkBoundaryMode,
     normalize_network_mode,
 )
+from latticeai.core.sse import sse_frame
 from latticeai.services.cloud_egress_audit import record_cloud_egress
 from latticeai.services.cloud_extraction import plan_kg_expansion_rich
 from latticeai.services.cloud_streaming import (
@@ -36,7 +36,7 @@ logger = logging.getLogger(__name__)
 
 
 def _sse(data: Dict[str, Any]) -> str:
-    return f"data: {json.dumps(data, ensure_ascii=False)}\n\n"
+    return sse_frame(None, data)
 
 
 def _scope_key(user_email: Optional[str], workspace_id: Optional[str]) -> str:

package/latticeai/services/hybrid_policy.py

@@ -12,16 +12,13 @@ Persisted under the data dir, scoped like NetworkBoundaryService
 
 from __future__ import annotations
 
-import json
-import threading
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Set
+from typing import Any, Dict, List, Optional, Set
 
-from latticeai.core.io_utils import atomic_write_json
 from latticeai.core.network_boundary import (
     HARD_BLOCK_METADATA_FLAGS,
     HARD_BLOCK_NODE_TYPES,
 )
+from latticeai.services.mode_store import JsonBackedModeService
 
 DEFAULT_BLOCKED_TYPES: List[str] = []
 DEFAULT_BLOCKED_FLAGS: List[str] = sorted(HARD_BLOCK_METADATA_FLAGS)
@@ -39,51 +36,15 @@ def _default_policy() -> Dict[str, Any]:
     }
 
 
-class HybridPolicyService:
+class HybridPolicyService(JsonBackedModeService[Dict[str, Any]]):
     """Load / save hybrid cloud policy."""
 
-    def __init__(
-        self,
-        *,
-        data_dir: Path,
-        audit: Optional[Callable[..., None]] = None,
-    ) -> None:
-        self._path = Path(data_dir) / "hybrid_policy.json"
-        self._audit = audit or (lambda *a, **kw: None)
-        self._lock = threading.Lock()
-
-    def rebind_data_dir(self, data_dir: Path) -> None:
-        with self._lock:
-            self._path = Path(data_dir) / "hybrid_policy.json"
+    FILENAME = "hybrid_policy.json"
 
-    def rebind_audit(self, audit: Callable[..., None]) -> None:
-        with self._lock:
-            self._audit = audit
+    def _default_entry(self) -> Any:
+        return _default_policy()
 
-    def _read(self) -> Dict[str, Any]:
-        base = {
-            "default": _default_policy(),
-            "users": {},
-            "workspaces": {},
-        }
-        if not self._path.exists():
-            return base
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-        except Exception:
-            return base
-        if not isinstance(data, dict):
-            return base
-        data.setdefault("default", _default_policy())
-        data.setdefault("users", {})
-        data.setdefault("workspaces", {})
-        return data
-
-    def _write(self, data: Dict[str, Any]) -> None:
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        atomic_write_json(self._path, data)
-
-    def _resolve_raw(
+    def _resolve_from(
         self,
         data: Dict[str, Any],
         *,
@@ -116,16 +77,6 @@ class HybridPolicyService:
             policy["min_extraction_confidence"] = 0.55
         return policy
 
-    def resolve(
-        self,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        with self._lock:
-            data = self._read()
-        return self._resolve_raw(data, user_email=user_email, workspace_id=workspace_id)
-
     def set_policy(
         self,
         patch: Dict[str, Any],
@@ -144,7 +95,7 @@ class HybridPolicyService:
         clean = {k: v for k, v in (patch or {}).items() if k in allowed}
         with self._lock:
             data = self._read()
-            previous = self._resolve_raw(
+            previous = self._resolve_from(
                 data, user_email=user_email, workspace_id=workspace_id
             )
             if workspace_id:

package/latticeai/services/mode_store.py

@@ -0,0 +1,132 @@
+"""The shared storage half of the scoped preference dials.
+
+``PermissionModeService``, ``NetworkBoundaryService`` and ``HybridPolicyService``
+are three different policies over one identical store: a JSON file under the
+data dir holding ``{"default": …, "users": {…}, "workspaces": {…}}``, guarded by
+a lock, rebindable after lazy construction, and read defensively enough that a
+truncated or hand-edited file degrades to defaults instead of taking the app
+down.
+
+That half was written three times, character for character. Three copies of a
+"corrupt file falls back to defaults" rule is three chances for one of them to
+grow an exception path the others do not have — and the symptom would be one
+dial silently forgetting a user's choice while the other two remember. The
+storage lives here once; each service supplies only what actually differs:
+the file name, what an unset ``default`` means, and how a scope resolves.
+
+Deliberately *not* shared: ``set_mode``/``set_policy``. They look similar but
+their write shapes differ (a scalar mode replaces, a policy patch merges) and
+their audit events carry different payloads, so folding them together would
+mean a parameterised method with more branches than the two bodies it replaced.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import Any, Callable, ClassVar, Dict, Generic, Optional, TypeVar
+
+from latticeai.core.io_utils import atomic_write_json
+
+#: What ``resolve`` hands back — an enum member for the mode dials, a plain
+#: dict for the policy service.
+ResolvedT = TypeVar("ResolvedT")
+
+__all__ = ["JsonBackedModeService"]
+
+
+class JsonBackedModeService(Generic[ResolvedT]):
+    """A lock-guarded, scope-aware JSON preference file.
+
+    Subclasses set :attr:`FILENAME` and implement :meth:`_default_entry` and
+    :meth:`_resolve_from`.
+    """
+
+    #: File name under the data dir. Subclasses must set this.
+    FILENAME: ClassVar[str] = ""
+
+    def __init__(
+        self,
+        *,
+        data_dir: Path,
+        audit: Optional[Callable[..., None]] = None,
+    ) -> None:
+        self._path = Path(data_dir) / self.FILENAME
+        self._audit = audit or (lambda *a, **kw: None)
+        self._lock = threading.Lock()
+
+    # ── rebinding ────────────────────────────────────────────────────────────
+    def rebind_data_dir(self, data_dir: Path) -> None:
+        """Point the store at the app's real data dir.
+
+        The wiring may instantiate a service lazily before routers know the
+        configured data dir; rebinding keeps one file of record instead of
+        stranding writes under the fallback path.
+        """
+        with self._lock:
+            self._path = Path(data_dir) / self.FILENAME
+
+    def rebind_audit(self, audit: Callable[..., None]) -> None:
+        """Attach the real audit sink once app wiring provides one."""
+        with self._lock:
+            self._audit = audit
+
+    # ── what each subclass must decide ───────────────────────────────────────
+    def _default_entry(self) -> Any:
+        """The ``default`` bucket's value when the file does not say.
+
+        Called fresh at every use because the policy service's answer is a
+        mutable dict; a shared instance would let one caller's edit leak into
+        the next caller's defaults.
+        """
+        raise NotImplementedError
+
+    def _resolve_from(
+        self,
+        data: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        workspace_id: Optional[str],
+    ) -> ResolvedT:
+        """Apply this dial's scope precedence to already-loaded ``data``.
+
+        Pure over ``data`` and lock-free, so holders of ``_lock`` can reuse it
+        without re-entering a non-reentrant lock.
+        """
+        raise NotImplementedError
+
+    # ── storage ──────────────────────────────────────────────────────────────
+    def _empty(self) -> Dict[str, Any]:
+        return {"default": self._default_entry(), "users": {}, "workspaces": {}}
+
+    def _read(self) -> Dict[str, Any]:
+        if not self._path.exists():
+            return self._empty()
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8"))
+        except Exception:
+            return self._empty()
+        if not isinstance(data, dict):
+            return self._empty()
+        data.setdefault("default", self._default_entry())
+        data.setdefault("users", {})
+        data.setdefault("workspaces", {})
+        return data
+
+    def _write(self, data: Dict[str, Any]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write_json(self._path, data)
+
+    # ── reading ──────────────────────────────────────────────────────────────
+    def resolve(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> ResolvedT:
+        with self._lock:
+            data = self._read()
+        return self._resolve_from(
+            data, user_email=user_email, workspace_id=workspace_id,
+        )

package/latticeai/services/model_capability_registry.py

@@ -636,11 +636,6 @@ def get_all_capabilities() -> List[ModelCapability]:
     return [*_REGISTRY, *_LEGACY_REGISTRY]
 
 
-def get_recommended_capabilities() -> List[ModelCapability]:
-    """Current-generation entries: catalog, download and recommendation input."""
-    return list(_REGISTRY)
-
-
 def get_legacy_capabilities() -> List[ModelCapability]:
     """Recognised-only entries: never offered, never recommended, still named."""
     return list(_LEGACY_REGISTRY)
@@ -663,12 +658,6 @@ def is_recognized_model(model_id: str) -> bool:
     return get_capability(model_id) is not None
 
 
-def is_recommended_model(model_id: str) -> bool:
-    """True only for current-generation entries — the download/offer gate."""
-    cap = get_capability(model_id)
-    return cap is not None and cap.lifecycle == RECOMMENDED
-
-
 def build_engine_model_catalog() -> Dict[str, List[Dict[str, Any]]]:
     """Return legacy ENGINE_MODEL_CATALOG shape, enriched with rich fields.
 
@@ -717,7 +706,3 @@ def get_verified_models() -> List[Dict[str, Any]]:
         if c.verification.hf_exists and c.verification.has_config and c.verification.has_tokenizer
     ]
 
-
-# Back-compat: expose a simple list mirroring the old top-level for mlx.
-# Recommended entries only — same reasoning as build_engine_model_catalog.
-LOCAL_MLX_MODELS = [c.to_legacy_dict() for c in _REGISTRY if "local_mlx" in c.provider_hints]

package/latticeai/services/model_catalog.py

@@ -15,10 +15,6 @@ import re
 import sys
 from typing import Any, Dict, List, Optional
 
-from latticeai.services.model_capability_registry import (
-    LOCAL_MLX_MODELS as _LOCAL_MLX_MODELS,
-)
-
 # 5.2.0: Delegate catalog data to the structured capability registry (rich + verified).
 # This keeps backward compat for every `from ...model_catalog import ENGINE_MODEL_CATALOG`.
 from latticeai.services.model_capability_registry import (
@@ -178,9 +174,6 @@ get_all_capabilities = _get_all_capabilities
 get_capability = _get_capability
 get_verified_models = _get_verified_models
 
-# Convenience re-export for tests / places that did `from ...model_catalog import LOCAL_MLX_MODELS`
-LOCAL_MLX_MODELS = _LOCAL_MLX_MODELS  # type: ignore[name-defined]
-
 _VERSIONED_MODEL_PATTERNS = (
     ("gemma", re.compile(r"\bgemma[-\s]?(\d+(?:\.\d+)?)", re.IGNORECASE)),
     ("qwen", re.compile(r"\bqwen[-\s]?(\d+(?:\.\d+)?)", re.IGNORECASE)),

package/latticeai/services/model_loading.py

@@ -6,7 +6,6 @@ Re-exports will be added in model_runtime for compat.
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
 import queue
 import subprocess
@@ -15,6 +14,8 @@ from functools import partial
 from pathlib import Path
 from typing import Any, AsyncIterator, Dict, Optional
 
+from latticeai.core.sse import sse_frame
+
 from .model_errors import ModelRuntimeError
 
 
@@ -243,7 +244,7 @@ async def prepare_and_load_model(
 
 
 def sse_event(event: str, data: Dict[str, object]) -> str:
-    return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
+    return sse_frame(event, data)
 
 
 async def prepare_and_load_model_stream(