ltcai 11.5.1 → 11.5.2

package/latticeai/api/local_files.py

@@ -310,6 +310,20 @@ def create_local_files_router(
         except PermissionError as exc:
             raise HTTPException(status_code=403, detail=str(exc)) from exc
 
+    @router.get("/api/ingestion/multimodal")
+    async def ingestion_multimodal_status(request: Request):
+        """What this install will do with a picture, a recording, or a video.
+
+        FEATURE_STATUS has described this answer — including which of the three
+        reasons a video would be refused for — since 11.2.0, but the pipeline
+        method that produces it had no route, so no surface could ever show it
+        and "why was my video not indexed?" had no answer short of reading the
+        server's environment.
+        """
+        require_user(request)
+        _require_pipeline()
+        return ingestion_pipeline.multimodal_status()
+
     @router.get("/api/ingestion/jobs")
     async def ingestion_jobs(request: Request, limit: int = 20):
         """Recent background ingestion jobs (newest first)."""

package/latticeai/api/permissions.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import hashlib
 import json
 import logging
 import os
@@ -15,7 +14,9 @@ from typing import Any, Dict, Optional, Tuple
 
 from fastapi import APIRouter, HTTPException, Request
 
+from latticeai.core.http_origin import request_external_origin
 from latticeai.core.io_utils import atomic_write_json
+from latticeai.core.security import sha256_hex
 
 _PERMISSION_ACTION_LABELS = {
     "list": "폴더 목록 보기",
@@ -39,16 +40,32 @@ class PermissionGateway:
         self.discord_permission_channel = config.discord_permission_channel
         self.permission_monitor_secret = config.permission_monitor_secret
         self.perm_queue_file = data_dir / "permission_queue.json"
-        explicit_ui_url = os.getenv("LATTICEAI_PERMISSION_UI_URL", "").strip()
-        public_url = os.getenv("LATTICEAI_PUBLIC_URL", "").strip().rstrip("/")
-        default_ui_url = f"http://127.0.0.1:{getattr(config, 'port', 4825)}/app#/admin/permissions"
-        self.permission_ui_url = explicit_ui_url or (
-            f"{public_url}/app#/admin/permissions" if public_url else default_ui_url
-        )
+        self._explicit_ui_url = os.getenv("LATTICEAI_PERMISSION_UI_URL", "").strip()
+        self._public_url = os.getenv("LATTICEAI_PUBLIC_URL", "").strip().rstrip("/")
+        # The worker's own port. Behind the desktop gateway this is the
+        # *internal* one, which is why a notification built from it sends the
+        # approver to a door only the gateway can open — hence
+        # ``_front_door``, learned from the request that asked for approval.
+        self._loopback_ui_origin = f"http://127.0.0.1:{getattr(config, 'port', 4825)}"
+        self._front_door: Optional[str] = None
+
+    @property
+    def permission_ui_url(self) -> str:
+        """Where to send the person who has to approve this.
+
+        Operator configuration wins — an explicit URL or a public URL is a
+        deliberate statement about how this install is reached. Only when
+        nothing is configured does the front door observed on the request that
+        triggered the approval beat the worker's own loopback address.
+        """
+        if self._explicit_ui_url:
+            return self._explicit_ui_url
+        base = self._public_url or self._front_door or self._loopback_ui_origin
+        return f"{base.rstrip('/')}/app#/admin/permissions"
 
     @staticmethod
     def token_hash(token: str) -> str:
-        return hashlib.sha256(str(token or "").encode("utf-8")).hexdigest()
+        return sha256_hex(str(token or ""))
 
     @staticmethod
     def token_hint(token: str) -> str:
@@ -78,9 +95,6 @@ class PermissionGateway:
         except Exception as exc:
             logging.warning("perm_queue_write failed: %s", exc)
 
-    def _perm_queue_remove(self, token: str) -> None:
-        self._perm_queue_remove_key(self.token_hash(token))
-
     def _perm_queue_remove_key(self, key: str) -> None:
         try:
             with self.perm_queue_lock:
@@ -117,7 +131,7 @@ class PermissionGateway:
 
     @staticmethod
     def content_fingerprint(content: str = "") -> str:
-        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+        return sha256_hex(content)
 
     def _notify_discord_permission_sync(self, token: str, path: str, action: str, user_email: str) -> None:
         sent = False
@@ -225,8 +239,20 @@ class PermissionGateway:
         email = self.get_current_user(request)
         if not email:
             raise HTTPException(status_code=401, detail="로컬 파일 접근은 로그인 세션이 필요합니다.")
+        # Every local-file approval passes through here immediately before the
+        # permission record (and its notification) is created, so this is the
+        # request whose front door the approver should be sent back to. The
+        # forwarded authority is only believed from a loopback or configured
+        # proxy peer — the same rule CSRF and the invite link use.
+        self.remember_front_door(request)
         return email
 
+    def remember_front_door(self, request: Request) -> None:
+        """Record the external origin this request came through, if any."""
+        origin = request_external_origin(request)
+        if origin:
+            self._front_door = origin
+
     def require_local_approval(
         self,
         *,

package/latticeai/api/search.py

@@ -32,6 +32,12 @@ class HybridSearchRequest(SearchRequest):
     image_fusion: bool = False
 
 
+class GraphSearchRequest(SearchRequest):
+    #: How far to walk out from the directly-matching nodes. The service
+    #: clamps this to 0–3; 0 means "matches only, no expansion".
+    expand_depth: int = 1
+
+
 class GraphNodeRequest(BaseModel):
     node_id: str = Field(..., min_length=1)
     include_neighbors: bool = True
@@ -164,6 +170,24 @@ def create_search_router(
         except ValueError as exc:
             _raise_graph_error(exc)
 
+    @router.post("/api/search/graph")
+    async def graph_search(req: GraphSearchRequest, request: Request) -> Dict[str, Any]:
+        """Relationship-aware search: direct matches plus what they connect to.
+
+        The third retrieval channel. It was in ``_ScopedSearchService._SCOPED``
+        from the start — so the workspace guard was ready for it — but no
+        handler ever called it, which made the allow-list entry the only
+        evidence the channel was supposed to be reachable at all.
+        """
+        try:
+            return _guarded(request).graph_search(
+                req.query,
+                limit=req.limit,
+                expand_depth=req.expand_depth,
+            )
+        except ValueError as exc:
+            _raise_graph_error(exc)
+
     @router.get("/api/graph")
     async def graph(request: Request, limit: int = 300) -> Dict[str, Any]:
         try:

package/latticeai/api/static_routes.py

@@ -25,7 +25,10 @@ PRODUCTION_CSP = (
     "style-src 'self' 'unsafe-inline'; "
     "img-src 'self' data: blob: http://127.0.0.1:*; "
     "font-src 'self' data:; "
-    "connect-src 'self' http://127.0.0.1:* ws://127.0.0.1:*; "
+    # No `ws:`: this product has no WebSocket endpoint anywhere. The live
+    # surfaces (chat, agent steps, index progress) are server-sent events, read
+    # with fetch/ReadableStream, which `connect-src` already covers over http.
+    "connect-src 'self' http://127.0.0.1:*; "
     "frame-src 'none'; "
     "object-src 'none'; "
     "base-uri 'none'; "

package/latticeai/cli/runtime.py

@@ -2,10 +2,15 @@
 
 from __future__ import annotations
 
-import importlib.util
 import os
 from pathlib import Path
 
+from latticeai.core.module_probe import module_available
+
+#: Historical name. ``cli.entrypoint`` imports it from here and the suite
+#: monkeypatches it there, so the binding has to exist on this module.
+_has_module = module_available
+
 
 def _load_env_file(path: Path) -> None:
     if not path.exists():
@@ -33,5 +38,4 @@ def _apply_extra_path() -> None:
     os.environ["PATH"] = os.pathsep.join(current)
 
 
-def _has_module(name: str) -> bool:
-    return importlib.util.find_spec(name) is not None
+

package/latticeai/core/config.py

@@ -18,6 +18,7 @@ concept and are read dynamically at call time.
 
 from __future__ import annotations
 
+import os
 import sys
 from dataclasses import dataclass
 from pathlib import Path
@@ -25,7 +26,50 @@ from typing import List, Mapping, Optional
 
 from latticeai.core.security import host_is_loopback
 
-__all__ = ["Config", "_value", "_str", "_bool", "_int"]
+__all__ = [
+    "Config",
+    "SSO_CALLBACK_PATH",
+    "default_data_dir",
+    "default_sso_redirect_uri",
+    "_value",
+    "_str",
+    "_bool",
+    "_int",
+]
+
+#: The path the identity provider sends the browser back to.
+SSO_CALLBACK_PATH = "/auth/sso/callback"
+
+
+def default_sso_redirect_uri(port: int) -> str:
+    """The redirect URI when the operator has registered none.
+
+    Named rather than inlined because ``api/auth`` has to recognise it: this
+    exact string means "nobody chose a callback URL", which is the only case in
+    which the login flow may substitute the front door it was actually reached
+    through. A URI the operator *did* configure is registered with the identity
+    provider and must be sent back verbatim.
+    """
+    return f"http://localhost:{port}{SSO_CALLBACK_PATH}"
+
+
+#: Where everything durable lives when the operator names nothing.
+DEFAULT_DATA_DIR_NAME = ".ltcai"
+
+
+def default_data_dir(env: Optional[Mapping[str, str]] = None) -> Path:
+    """The data directory ``LATTICEAI_DATA_DIR`` names, else ``~/.ltcai``.
+
+    Three runtime wiring modules each carried a byte-identical copy of this,
+    which meant a lazily-initialized service could disagree with ``Config``
+    about where the store lives — and the loser writes a second, invisible
+    copy of the user's data. ``env=None`` reads the live process environment,
+    which is what the lazy wiring paths need.
+    """
+    source = os.environ if env is None else env
+    raw = (source.get("LATTICEAI_DATA_DIR") or "").strip()
+    return Path(raw) if raw else Path.home() / DEFAULT_DATA_DIR_NAME
+
 
 def _value(env: Mapping[str, str], key: str, default: str = "") -> str:
     """Mirror the legacy ``env_value``: ``getenv(key) or default or ""`` (no strip)."""
@@ -177,14 +221,14 @@ class Config:
         # download path, the on-disk cache dir and the catalog key all agree.
         local_model = _value(env, "LATTICEAI_LOCAL_MODEL", "mlx-community/gemma-4-12B-it-4bit")
 
-        data_dir = Path(_value(env, "LATTICEAI_DATA_DIR", str(Path.home() / ".ltcai")))
+        data_dir = default_data_dir(env)
         static_dir = Path(_value(env, "LATTICEAI_STATIC_DIR", str(base_dir / "static")))
         if not static_dir.exists():
             packaged_static = Path(sys.prefix) / "static"
             if packaged_static.exists():
                 static_dir = packaged_static
 
-        default_sso_redirect = f"http://localhost:{port}/auth/sso/callback"
+        default_sso_redirect = default_sso_redirect_uri(port)
 
         return cls(
             app_mode=app_mode,

package/latticeai/core/csrf.py

@@ -29,6 +29,12 @@ Threat model, stated so the exemptions are checkable rather than vibes:
   the desktop shell, the VS Code extension). That is trusted only while the
   server is bound to loopback, where "not a browser" and "already on this
   machine" coincide. On a reachable bind it fails closed.
+* **Behind a proxy, ``Host`` is not the front door.** The desktop gateway
+  replaces it with the worker's internal authority, so the ``Origin == Host``
+  fallback below compared a browser's real origin against a port the browser
+  has never heard of and refused every write. The front door's own name comes
+  from :mod:`latticeai.core.http_origin`, which believes ``X-Forwarded-Host``
+  only from a peer that may forward.
 """
 
 from __future__ import annotations
@@ -48,6 +54,11 @@ from typing import (
 )
 from urllib.parse import urlsplit
 
+from latticeai.core.http_origin import (
+    FORWARDED_HOST_HEADER,
+    effective_host,
+)
+
 __all__ = [
     "CSRFDecision",
     "CSRFOriginPolicy",
@@ -176,6 +187,8 @@ class CSRFOriginPolicy:
         self,
         origin: Tuple[str, str, Optional[int]],
         host_header: Optional[str],
+        forwarded_host: Optional[str] = None,
+        peer: Optional[str] = None,
     ) -> bool:
         if any(_same_site(origin, trusted) for trusted in self._trusted):
             return True
@@ -184,7 +197,13 @@ class CSRFOriginPolicy:
         # page this server actually served — which is precisely "not cross
         # site". This is what keeps reverse-proxied hostnames working without
         # every operator having to enumerate them.
-        own = normalize_origin(host_header)
+        #
+        # "The request's own Host" is the *front door's*, not the internal one a
+        # proxy hop rewrote it to, which is why the forwarded authority is
+        # resolved first (and only from a peer that may forward).
+        own = normalize_origin(
+            effective_host(host=host_header, forwarded_host=forwarded_host, peer=peer)
+        )
         return own is not None and _same_site(origin, own)
 
     def evaluate(
@@ -196,6 +215,8 @@ class CSRFOriginPolicy:
         host: Optional[str],
         cookie_header: Optional[str],
         authorization: Optional[str],
+        forwarded_host: Optional[str] = None,
+        peer: Optional[str] = None,
     ) -> CSRFDecision:
         """Allow/deny one request. Pure: no I/O, no app state."""
         if method.upper() in SAFE_METHODS:
@@ -219,7 +240,7 @@ class CSRFOriginPolicy:
                     return CSRFDecision(True, "no-origin-loopback-bind")
                 return CSRFDecision(False, "no-origin-reachable-bind")
 
-        if self._origin_is_trusted(stated, host):
+        if self._origin_is_trusted(stated, host, forwarded_host, peer):
             return CSRFDecision(True, "same-site-or-trusted-origin")
         return CSRFDecision(False, "cross-site-origin")
 
@@ -261,6 +282,9 @@ class CSRFOriginGuardMiddleware:
             key.decode("latin-1").lower(): value.decode("latin-1")
             for key, value in scope.get("headers") or []
         }
+        # ``client`` is ``(host, port)`` under every ASGI server, and absent
+        # under a test transport that does not model a socket.
+        client = scope.get("client") or ()
         decision = self.policy.evaluate(
             method=str(scope.get("method") or "GET"),
             origin=headers.get("origin"),
@@ -268,6 +292,8 @@ class CSRFOriginGuardMiddleware:
             host=headers.get("host"),
             cookie_header=headers.get("cookie"),
             authorization=headers.get("authorization"),
+            forwarded_host=headers.get(FORWARDED_HOST_HEADER),
+            peer=client[0] if client else None,
         )
         if decision.allowed:
             await self.app(scope, receive, send)

package/latticeai/core/embedding_providers/__init__.py

@@ -15,7 +15,7 @@ swapped behind a single interface as long as every implementation agrees on:
 holds the five concrete text implementations:
 
 1. :class:`HashEmbeddingProvider`  — deterministic, offline, always-available
-   fallback (wraps the legacy :class:`~latticeai.core.local_embeddings.LocalEmbeddingModel`).
+   fallback (wraps :class:`~lattice_brain.embeddings.LocalEmbeddingModel`).
 2. :class:`MLXEmbeddingProvider`   — local Apple-Silicon embedding models.
 3. :class:`OllamaEmbeddingProvider` — a local/remote Ollama server.
 4. :class:`OpenAICompatibleEmbeddingProvider` — any ``/v1/embeddings`` endpoint
@@ -65,10 +65,8 @@ from __future__ import annotations
 # the two names it imported for its own use were part of its surface, and the
 # suite imports them from here. Re-exported in the redundant-alias form so they
 # read as deliberate rather than as leftover imports.
-from latticeai.core.local_embeddings import (
-    DEFAULT_EMBEDDING_DIM as DEFAULT_EMBEDDING_DIM,
-)
-from latticeai.core.local_embeddings import LocalEmbeddingModel as LocalEmbeddingModel
+from lattice_brain.embeddings import DEFAULT_EMBEDDING_DIM as DEFAULT_EMBEDDING_DIM
+from lattice_brain.embeddings import LocalEmbeddingModel as LocalEmbeddingModel
 
 from .base import _KNOWN_DIMS as _KNOWN_DIMS
 from .base import EmbeddingProvider as EmbeddingProvider

package/latticeai/core/embedding_providers/base.py

@@ -19,7 +19,7 @@ import struct
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence
 
-from latticeai.core.local_embeddings import DEFAULT_EMBEDDING_DIM
+from lattice_brain.embeddings import DEFAULT_EMBEDDING_DIM
 
 
 class EmbeddingUnavailable(RuntimeError):

package/latticeai/core/embedding_providers/text.py

@@ -14,7 +14,7 @@ import os
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
-from latticeai.core.local_embeddings import DEFAULT_EMBEDDING_DIM, LocalEmbeddingModel
+from lattice_brain.embeddings import DEFAULT_EMBEDDING_DIM, LocalEmbeddingModel
 
 from .base import (
     EmbeddingProvider,

package/latticeai/core/enterprise.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 
 import os
 from enum import Enum
-from typing import Dict, List, Protocol, runtime_checkable
+from typing import Dict, Protocol, runtime_checkable
 
 
 class Edition(str, Enum):
@@ -115,9 +115,6 @@ class CapabilityRegistry:
             # A misbehaving plugin must never break a Community request.
             return False
 
-    def available_capabilities(self) -> List[EnterpriseCapability]:
-        return [cap for cap in EnterpriseCapability if self.is_capability_enabled(cap)]
-
     def describe(self) -> Dict[str, object]:
         """Edition + capability matrix for ``/workspace/editions`` and admin UI."""
         return {

package/latticeai/core/http_origin.py

@@ -0,0 +1,146 @@
+"""Which host a request *really* arrived at, when something proxied it.
+
+The desktop front door is a reverse proxy: the browser talks to the gateway on
+one port and the gateway forwards to the worker on another.  ``Host`` is a
+hop-by-hop header, so it is replaced on the way out and the worker sees only its
+own internal authority — which is why every cookie-authenticated write through
+an adopted worker was rejected as ``csrf_origin_rejected``.  The gateway states
+the fact it destroyed in ``X-Forwarded-Host`` / ``X-Forwarded-Proto``; this
+module decides when to believe it.
+
+Threat model, so the rule is checkable rather than felt:
+
+* **A browser cannot set these headers.**  ``X-Forwarded-*`` are not on the
+  fetch-safelist and a page cannot add them cross-origin without a preflight
+  the CORS allowlist rejects.  So no *web page* can reach this code path.
+* **A local non-browser caller could already forge ``Origin``.**  curl on this
+  machine can send any ``Origin`` it likes, and the loopback exemption in
+  :mod:`latticeai.core.csrf` already trusts it.  Honouring a forwarded host from
+  the same caller widens nothing that was not already open.
+* **Anyone else is not trusted.**  Off-loopback the header is honoured only from
+  a peer the operator listed in ``LATTICEAI_TRUSTED_PROXIES`` — the same
+  allowlist ``latticeai.core.security.client_ip`` uses for the same reason, and
+  empty by default.
+
+The functions are pure: the caller supplies the headers and the peer address, so
+the policy is testable without an ASGI app or a socket.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+from typing import Any, Optional
+
+__all__ = [
+    "FORWARDED_HOST_HEADER",
+    "FORWARDED_PROTO_HEADER",
+    "effective_host",
+    "effective_origin",
+    "peer_may_forward",
+    "request_external_origin",
+]
+
+#: The authority the client asked for, as stated by the proxy in front of us.
+FORWARDED_HOST_HEADER = "x-forwarded-host"
+#: The scheme the client used to reach that proxy.
+FORWARDED_PROTO_HEADER = "x-forwarded-proto"
+
+# Only these two are ever taken from a forwarded scheme; anything else is a
+# value we would have to reason about, and the fallback is already correct.
+_KNOWN_SCHEMES = ("https", "http")
+
+
+def peer_may_forward(peer: Optional[str]) -> bool:
+    """Whether ``X-Forwarded-*`` from this direct peer may be believed.
+
+    Loopback, or a member of the configured trusted-proxy allowlist.  An
+    unparseable or absent peer is *not* trusted: a request whose origin we
+    cannot establish is exactly the one whose claims we must not take.
+    """
+    if not peer:
+        return False
+    try:
+        address = ipaddress.ip_address(str(peer).strip())
+    except ValueError:
+        return False
+    if address.is_loopback:
+        return True
+    from latticeai.core.security import _peer_is_trusted_proxy
+
+    return _peer_is_trusted_proxy(str(peer).strip())
+
+
+def _first(value: Optional[str]) -> str:
+    """The first entry of a possibly comma-joined forwarded header."""
+    return (value or "").split(",")[0].strip()
+
+
+def effective_host(
+    *,
+    host: Optional[str],
+    forwarded_host: Optional[str] = None,
+    peer: Optional[str] = None,
+) -> Optional[str]:
+    """The authority the client aimed at: the forwarded one when believable.
+
+    Falls back to the request's own ``Host`` in every other case — no proxy, a
+    peer we do not trust, or a forwarded header that is empty.  ``None`` only
+    when there is nothing to report at all (an HTTP/1.0 request with no ``Host``
+    and no proxy), which callers already have to handle.
+    """
+    if peer_may_forward(peer):
+        claimed = _first(forwarded_host)
+        if claimed:
+            return claimed
+    own = (host or "").strip()
+    return own or None
+
+
+def effective_origin(
+    *,
+    host: Optional[str],
+    scheme: str = "http",
+    forwarded_host: Optional[str] = None,
+    forwarded_proto: Optional[str] = None,
+    peer: Optional[str] = None,
+) -> Optional[str]:
+    """``scheme://authority`` for the front door this request came through.
+
+    ``scheme`` is what *this* server is speaking; the forwarded scheme wins when
+    the peer is trusted and states one we recognise, because a TLS-terminating
+    proxy speaks plain HTTP to us while the browser is on ``https`` and a link
+    built with the wrong scheme is a broken link.
+    """
+    authority = effective_host(host=host, forwarded_host=forwarded_host, peer=peer)
+    if not authority:
+        return None
+    resolved = (scheme or "http").strip().lower() or "http"
+    if peer_may_forward(peer):
+        claimed = _first(forwarded_proto).lower()
+        if claimed in _KNOWN_SCHEMES:
+            resolved = claimed
+    return f"{resolved}://{authority}"
+
+
+def request_external_origin(request: Any, *, fallback: Optional[str] = None) -> Optional[str]:
+    """:func:`effective_origin` for a live request — the *link-building* seam.
+
+    CSRF asks "is this same-origin?"; this asks the other question: "what URL
+    should I hand a person so they can come back here?" Both must read the same
+    front door, or an invite link mails out the internal worker port that only
+    the gateway can reach.
+
+    ``fallback`` is returned when the request states no authority at all, so a
+    caller with a configured public URL keeps it.
+    """
+    headers = getattr(request, "headers", None) or {}
+    client = getattr(request, "client", None)
+    url = getattr(request, "url", None)
+    origin = effective_origin(
+        host=headers.get("host"),
+        scheme=getattr(url, "scheme", "http") or "http",
+        forwarded_host=headers.get(FORWARDED_HOST_HEADER),
+        forwarded_proto=headers.get(FORWARDED_PROTO_HEADER),
+        peer=getattr(client, "host", None) if client else None,
+    )
+    return origin or fallback

package/latticeai/core/invitations.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import hashlib
 import json
 import secrets
 from datetime import datetime, timedelta
@@ -10,6 +9,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from latticeai.core.quiet import quiet
+from latticeai.core.security import sha256_hex
 
 from .timeutil import local_now as _now
 
@@ -19,7 +19,8 @@ def _iso(dt: datetime) -> str:
 
 
 def _hash_token(token: str) -> str:
-    return hashlib.sha256(token.encode("utf-8")).hexdigest()
+    """Strict by design: an invite code is always a string by the time it lands here."""
+    return sha256_hex(token)
 
 
 def _atomic_write(path: Path, data: Dict[str, Any]) -> None:

package/latticeai/core/io_utils.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 import hashlib
 import json
 import os
-from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
+from lattice_brain.utils import parse_iso as parse_iso
 from latticeai.core.quiet import quiet
 
 
@@ -27,15 +27,6 @@ def atomic_write_json(path: Path, payload: Dict[str, Any]) -> None:
         quiet()
 
 
-def parse_iso(value: Optional[str]) -> Optional[datetime]:
-    if not value:
-        return None
-    try:
-        return datetime.fromisoformat(str(value))
-    except (TypeError, ValueError):
-        return None
-
-
 def sha256_file(path: Path) -> str:
     digest = hashlib.sha256()
     with open(path, "rb") as fh:

package/latticeai/core/legacy_compatibility.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-LEGACY_COMPATIBILITY_VERSION = "11.5.1"
+LEGACY_COMPATIBILITY_VERSION = "11.5.2"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
-MARKETPLACE_VERSION = "11.5.1"
+MARKETPLACE_VERSION = "11.5.2"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/messages.py

@@ -623,6 +623,11 @@ MESSAGES: Dict[str, Dict[str, str]] = {
 }
 
 
+def bilingual(ko: str, en: str) -> Dict[str, str]:
+    """One Korean/English phrase pair, in the shape every caller renders."""
+    return {"ko": ko, "en": en}
+
+
 def resolve_language(request: Any, default: str = DEFAULT_LANGUAGE) -> str:
     """Language for this request: the product's choice, then the browser's.