ltcai 10.8.0 → 10.9.0

package/latticeai/api/review_queue.py

@@ -19,6 +19,7 @@ from typing import Any, Callable, Dict, List, Optional
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel, Field
 
+from latticeai.core.messages import http_error, resolve_language, translate
 from latticeai.services.change_proposals import ProposalConflictError
 from latticeai.services.review_queue import InvalidReviewTransition, ReviewQueueService
 
@@ -129,7 +130,7 @@ def create_review_queue_router(
         try:
             return service.get(item_id, workspace_id=scope)
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
 
     @router.post("/automation/reviews/{item_id}/approve", response_model=ReviewItem)
     async def approve_item(item_id: str, request: Request):
@@ -141,12 +142,16 @@ def create_review_queue_router(
             try:
                 stored = service.get(item_id, workspace_id=scope)
             except FileNotFoundError as exc:
-                raise HTTPException(status_code=404, detail="review item not found") from exc
+                raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
             if stored.get("source") == "change_proposal":
                 if stored.get("effective_status") not in ("pending", "snoozed"):
                     raise HTTPException(
                         status_code=409,
-                        detail=f"cannot 'approve' a review item in status {stored.get('status')!r}",
+                        detail=translate(
+                    "review.cannot_approve_in_status",
+                    resolve_language(request),
+                    status=stored.get("status"),
+                ),
                     )
                 try:
                     applied = change_proposals.approve_and_apply(
@@ -177,7 +182,7 @@ def create_review_queue_router(
                 item_id, workspace_id=scope, reason=(req.reason if req else None)
             )
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event("review_item_dismiss", user_email=user, item_id=item_id)
@@ -190,7 +195,7 @@ def create_review_queue_router(
         try:
             item = service.snooze(item_id, until=req.until, workspace_id=scope)
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event("review_item_snooze", user_email=user, item_id=item_id)
@@ -211,7 +216,7 @@ def create_review_queue_router(
                 workspace_id=scope,
             )
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event("review_item_run_now", user_email=user, item_id=item_id)
@@ -224,7 +229,7 @@ def create_review_queue_router(
         try:
             item = fn(item_id, workspace_id=scope)
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event(f"review_item_{action}", user_email=user, item_id=item_id)

package/latticeai/api/setup.py

@@ -9,6 +9,7 @@ from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
 from lattice_brain.ingestion import IngestionItem
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.models.router import parse_model_ref
 from latticeai.services.process_audit import command_plan
 from latticeai.setup.auto_setup import (
@@ -184,27 +185,25 @@ def create_setup_router(
         }
         url = auth_urls.get(mcp_id)
         if not url:
-            raise HTTPException(status_code=404, detail=f"알 수 없는 MCP: {mcp_id}")
+            raise http_error(404, "mcp.unknown_id", resolve_language(request), mcp_id=mcp_id)
         open_url(url)
         return {"status": "ok", "opened": url, "mcp_id": mcp_id}
     
     
     # ── First Value Loop demo corpus (backlog #3, review §3.3 P0) ────────────
 
-    def _require_demo_pipeline():
+    def _require_demo_pipeline(request: Request):
         if ingestion_pipeline is None or not ingestion_pipeline.available():
-            raise HTTPException(
-                status_code=503, detail="Knowledge Graph ingestion is disabled.",
-            )
+            raise http_error(503, "capture.ingestion_disabled", resolve_language(request))
         if knowledge_graph is None:
-            raise HTTPException(status_code=503, detail="Knowledge Graph is disabled.")
+            raise http_error(503, "common.graph_disabled", resolve_language(request))
 
     def _demo_workspace(request: Request, body_workspace: Optional[str], user: str) -> Optional[str]:
         header = request.headers.get("X-Workspace-Id")
         header = header.strip() if header and header.strip() else None
         supplied = [value for value in (body_workspace, header) if value]
         if len(set(supplied)) > 1:
-            raise HTTPException(status_code=403, detail="Workspace selectors must match.")
+            raise http_error(403, "common.workspace_mismatch", resolve_language(request))
         requested = supplied[0] if supplied else None
         if workspace_service is None:
             return requested
@@ -217,7 +216,7 @@ def create_setup_router(
     async def demo_corpus_status(request: Request):
         """Whether the demo corpus is installed + the suggestion chips."""
         require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
         return {
             "installed": bool(installed),
@@ -236,7 +235,7 @@ def create_setup_router(
         instead of duplicating.
         """
         user = require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         workspace_id = _demo_workspace(request, req.workspace_id if req else None, user)
         results = []
         ingested = 0
@@ -285,7 +284,7 @@ def create_setup_router(
     async def demo_corpus_remove(request: Request):
         """Remove every demo document (node + chunks + edges + orphan source)."""
         require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
         removed = []
         for doc in installed:
@@ -314,7 +313,7 @@ def create_setup_router(
         }
         url = urls.get(permission_id)
         if not url:
-            raise HTTPException(status_code=404, detail="알 수 없는 권한 설정입니다.")
+            raise http_error(404, "setup.unknown_permission", resolve_language(request))
         open_url(url)
         return {"status": "ok", "opened": url, "permission": permission_id}
     return api_router

package/latticeai/api/static_routes.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import hashlib
 import hmac
+import re
 import secrets
 import subprocess
 import time
@@ -40,6 +42,59 @@ SYSINFO_READINESS_ROOMY_MAX = 55.0
 SYSINFO_READINESS_TIGHT_MAX = 80.0
 
 
+def _probe_host_capacity() -> Dict[str, Any]:
+    """Sample CPU / RAM / GPU on this machine. Blocking — call off the loop.
+
+    Extracted from the route so the subprocess sampling can be handed to a
+    worker thread, and so the parsing is testable without an HTTP request.
+    """
+    result: Dict[str, Any] = {
+        "cpu_pct": 0.0,
+        "ram_pct": 0.0,
+        "gpu_mem_pct": 0.0,
+        "gpu_mem_gb": 0.0,
+        "readiness": "roomy",
+    }
+    try:
+        # CPU
+        top_out = subprocess.run(["top", "-l", "1", "-n", "0"], capture_output=True, text=True, timeout=4).stdout
+        for line in top_out.splitlines():
+            if "CPU usage" in line:
+                m = re.search(r"([\d.]+)% user.*?([\d.]+)% sys", line)
+                if m:
+                    result["cpu_pct"] = round(float(m.group(1)) + float(m.group(2)), 1)
+        # RAM
+        vm_out = subprocess.run(["vm_stat"], capture_output=True, text=True, timeout=4).stdout
+        pages: dict = {}
+        for line in vm_out.splitlines():
+            for key in ["Pages free", "Pages active", "Pages inactive", "Pages wired down", "Pages occupied by compressor"]:
+                if line.startswith(key):
+                    m = re.search(r"(\d+)", line)
+                    if m:
+                        pages[key] = int(m.group(1))
+        total = sum(pages.values())
+        used = total - pages.get("Pages free", 0)
+        result["ram_pct"] = round(used / total * 100, 1) if total else 0.0
+        # GPU (MLX / Apple Silicon unified memory)
+        try:
+            import mlx.core as _mx
+            hw_out = subprocess.run(["sysctl", "-n", "hw.memsize"], capture_output=True, text=True, timeout=2).stdout
+            total_bytes = int(hw_out.strip())
+            gpu_bytes = _mx.get_active_memory() + _mx.get_cache_memory()
+            result["gpu_mem_gb"] = round(gpu_bytes / (1024 ** 3), 2)
+            result["gpu_mem_pct"] = round(gpu_bytes / total_bytes * 100, 1) if total_bytes else 0.0
+        except Exception:
+            quiet()
+    except Exception as e:
+        result["error"] = str(e)
+    result["readiness"] = host_capacity_readiness(
+        cpu_pct=float(result.get("cpu_pct") or 0.0),
+        ram_pct=float(result.get("ram_pct") or 0.0),
+        gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
+    )
+    return result
+
+
 def host_capacity_readiness(
     *,
     cpu_pct: float = 0.0,
@@ -278,54 +333,15 @@ def create_static_routes_router(
 
         ``readiness`` is ``roomy`` | ``tight`` | ``low`` so basic System copy
         does not re-interpret raw percents on the client.
+
+        The probe itself is three subprocesses — ``top -l 1`` alone samples for
+        about a second — so it runs on a worker thread. Run inline it held the
+        event loop for the whole sample, and this route is hit on the System
+        screen *and* during first-run analysis, i.e. exactly while an answer is
+        streaming: one status poll used to stall every open stream.
         """
         require_user(request)
-        import re as _re
-        result: Dict[str, Any] = {
-            "cpu_pct": 0.0,
-            "ram_pct": 0.0,
-            "gpu_mem_pct": 0.0,
-            "gpu_mem_gb": 0.0,
-            "readiness": "roomy",
-        }
-        try:
-            # CPU
-            top_out = subprocess.run(["top", "-l", "1", "-n", "0"], capture_output=True, text=True, timeout=4).stdout
-            for line in top_out.splitlines():
-                if "CPU usage" in line:
-                    m = _re.search(r"([\d.]+)% user.*?([\d.]+)% sys", line)
-                    if m:
-                        result["cpu_pct"] = round(float(m.group(1)) + float(m.group(2)), 1)
-            # RAM
-            vm_out = subprocess.run(["vm_stat"], capture_output=True, text=True, timeout=4).stdout
-            pages: dict = {}
-            for line in vm_out.splitlines():
-                for key in ["Pages free", "Pages active", "Pages inactive", "Pages wired down", "Pages occupied by compressor"]:
-                    if line.startswith(key):
-                        m = _re.search(r"(\d+)", line)
-                        if m:
-                            pages[key] = int(m.group(1))
-            total = sum(pages.values())
-            used  = total - pages.get("Pages free", 0)
-            result["ram_pct"] = round(used / total * 100, 1) if total else 0.0
-            # GPU (MLX / Apple Silicon unified memory)
-            try:
-                import mlx.core as _mx
-                hw_out = subprocess.run(["sysctl", "-n", "hw.memsize"], capture_output=True, text=True, timeout=2).stdout
-                total_bytes = int(hw_out.strip())
-                gpu_bytes = _mx.get_active_memory() + _mx.get_cache_memory()
-                result["gpu_mem_gb"]  = round(gpu_bytes / (1024 ** 3), 2)
-                result["gpu_mem_pct"] = round(gpu_bytes / total_bytes * 100, 1) if total_bytes else 0.0
-            except Exception:
-                quiet()
-        except Exception as e:
-            result["error"] = str(e)
-        result["readiness"] = host_capacity_readiness(
-            cpu_pct=float(result.get("cpu_pct") or 0.0),
-            ram_pct=float(result.get("ram_pct") or 0.0),
-            gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
-        )
-        return result
+        return await asyncio.to_thread(_probe_host_capacity)
 
     return StaticRoutesBundle(
         api_router,

package/latticeai/api/tools.py

@@ -19,6 +19,7 @@ from latticeai.api.computer_use import create_computer_use_router
 from latticeai.api.local_files import create_local_files_router
 from latticeai.api.mcp import create_mcp_router
 from latticeai.api.permissions import create_permissions_router
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.services.router_context import ToolRouterContext
 from latticeai.services.tool_dispatch import (
     TOOL_GOVERNANCE,
@@ -510,7 +511,7 @@ def create_tools_router(
         )
         target = Path(path).expanduser().resolve()
         if not target.exists() or not target.is_file():
-            raise HTTPException(status_code=404, detail="File not found")
+            raise http_error(404, "common.file_not_found", resolve_language(request))
         import pypdfium2 as pdfium
         doc = None
         try:
@@ -527,7 +528,7 @@ def create_tools_router(
                 pages.append({"page": i + 1, "b64": b64})
             return {"total": total, "pages": pages}
         except Exception as e:
-            raise HTTPException(status_code=500, detail=f"PDF 렌더링 실패: {e}")
+            raise http_error(500, "tools.pdf_render_failed", resolve_language(request), reason=e)
         finally:
             if doc is not None:
                 try:
@@ -544,9 +545,9 @@ def create_tools_router(
         rel = unquote(path).lstrip("/")
         target = (AGENT_ROOT / rel).resolve()
         if AGENT_ROOT not in target.parents and target != AGENT_ROOT:
-            raise HTTPException(status_code=403, detail="경로가 작업 공간 밖입니다.")
+            raise http_error(403, "tools.path_outside_workspace", resolve_language(request))
         if not target.exists() or not target.is_file():
-            raise HTTPException(status_code=404, detail="파일이 없습니다.")
+            raise http_error(404, "common.file_not_found", resolve_language(request))
         return FileResponse(
             path=target,
             filename=target.name,
@@ -570,9 +571,9 @@ def create_tools_router(
         rel = unquote(path).lstrip("/")
         target = (AGENT_ROOT / rel).resolve()
         if AGENT_ROOT not in target.parents and target != AGENT_ROOT:
-            raise HTTPException(status_code=403, detail="경로가 작업 공간 밖입니다.")
+            raise http_error(403, "tools.path_outside_workspace", resolve_language(request))
         if not target.exists() or not target.is_dir():
-            raise HTTPException(status_code=404, detail="디렉터리가 없습니다.")
+            raise http_error(404, "tools.directory_not_found", resolve_language(request))
         try:
             payload, filename = zip_workspace_dir(rel)
         except ToolError as exc:

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 = "10.8.0"
+LEGACY_COMPATIBILITY_VERSION = "10.9.0"
 
 
 @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 = "10.8.0"
+MARKETPLACE_VERSION = "10.9.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/mcp_registry.py

@@ -4,6 +4,7 @@ Lattice AI — MCP Registry data & pure helper functions.
 Extracted from server.py to reduce module size.
 """
 
+import asyncio
 import json
 import logging
 import os
@@ -354,6 +355,13 @@ async def install_skill(plugin: str, skill: str) -> Dict:
     }
 
 
+def _run_installer(command: List[str], timeout: int) -> "subprocess.CompletedProcess[str]":
+    """Run one package-installer command. Blocking — call off the event loop."""
+    return subprocess.run(
+        command, capture_output=True, text=True, timeout=timeout, check=False
+    )
+
+
 def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
     """Return bound MCP state helpers for given data_dir. No global side effects."""
     MCP_FILE = Path(data_dir) / "mcp_installs.json"
@@ -445,11 +453,15 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             status = "needs_auth"
             message = "커넥터 인증이 필요합니다. Codex 앱의 connector 설정에서 계정을 연결하면 바로 사용할 수 있습니다."
         elif item.get("install_mode") == "pip":
+            # Package installers are minutes of network I/O. On the event loop
+            # they froze every other request for the whole install; each one now
+            # runs on a worker thread instead.
             packages = item.get("pip_packages") or []
             for pkg in packages:
-                completed = subprocess.run(
+                completed = await asyncio.to_thread(
+                    _run_installer,
                     [sys.executable, "-m", "pip", "install", "--upgrade", pkg],
-                    capture_output=True, text=True, timeout=900, check=False,
+                    900,
                 )
                 if completed.returncode != 0:
                     raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
@@ -458,7 +470,9 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             pkg = item.get("package", "")
             version = item.get("package_version")
             pkg_str = f"{pkg}=={version}" if version else pkg
-            completed = subprocess.run([sys.executable, "-m", "pip", "install", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            completed = await asyncio.to_thread(
+                _run_installer, [sys.executable, "-m", "pip", "install", pkg_str], 300
+            )
             if completed.returncode != 0:
                 raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
             message = f"pip 패키지 설치 완료: {pkg_str}"
@@ -466,7 +480,9 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             pkg = item.get("package", "")
             version = item.get("package_version")
             pkg_str = f"{pkg}@{version}" if version else pkg
-            completed = subprocess.run(["npm", "install", "-g", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            completed = await asyncio.to_thread(
+                _run_installer, ["npm", "install", "-g", pkg_str], 300
+            )
             if completed.returncode != 0:
                 raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
             message = f"npm 패키지 설치 완료: {pkg_str}"

package/latticeai/core/messages.py

@@ -155,6 +155,228 @@ MESSAGES: Dict[str, Dict[str, str]] = {
         "ko": "저장할 내용이 없습니다. 텍스트나 페이지 내용을 함께 보내주세요.",
         "en": "Nothing to capture — send text, html, or a selection.",
     },
+    # ── shared ──────────────────────────────────────────────────────────
+    "common.user_mismatch": {
+        "ko": "로그인한 사용자와 요청한 사용자가 다릅니다.",
+        "en": "user_email must match the authenticated user.",
+    },
+    "common.workspace_mismatch": {
+        "ko": "작업 공간 지정이 서로 다릅니다.",
+        "en": "Workspace selectors must match.",
+    },
+    "common.workspace_unreadable": {
+        "ko": "'{workspace}' 작업 공간을 읽을 권한이 없습니다.",
+        "en": "Workspace '{workspace}' is not readable.",
+    },
+    "common.file_not_found": {
+        "ko": "파일을 찾을 수 없습니다.",
+        "en": "File not found.",
+    },
+    "common.path_required": {
+        "ko": "경로를 입력해주세요.",
+        "en": "A path is required.",
+    },
+    "common.graph_disabled": {
+        "ko": "지식 그래프가 꺼져 있습니다.",
+        "en": "The Knowledge Graph is turned off.",
+    },
+    "common.graph_unavailable": {
+        "ko": "지식 그래프를 사용할 수 없습니다.",
+        "en": "The Knowledge Graph is not available.",
+    },
+    # ── chat ────────────────────────────────────────────────────────────
+    "chat.model_not_loaded": {
+        "ko": "'{model}' 모델이 아직 준비되지 않았습니다.",
+        "en": "Model '{model}' is not loaded.",
+    },
+    "chat.no_model_loaded": {
+        "ko": "불러온 모델이 없습니다. 모델을 먼저 준비해주세요.",
+        "en": "No model is loaded. Prepare a model first.",
+    },
+    "chat.conversation_not_found": {
+        "ko": "대화를 찾을 수 없습니다.",
+        "en": "That conversation no longer exists.",
+    },
+    "chat.file_name_collision": {
+        "ko": "'{name}' 이름의 파일이 너무 많습니다. 다른 이름을 지정해 주세요.",
+        "en": "Too many files are already named '{name}'. Please choose another name.",
+    },
+    "chat.file_generation_failed": {
+        "ko": "파일 내용을 만들지 못했습니다.",
+        "en": "The file content could not be generated.",
+    },
+    # ── memory / graph ──────────────────────────────────────────────────
+    "memory.unknown_source": {
+        "ko": "'{source}'는 알 수 없는 기억 출처입니다.",
+        "en": "Unknown memory source: {source}.",
+    },
+    "graph.node_id_required": {
+        "ko": "노드 식별자가 필요합니다.",
+        "en": "A node id is required.",
+    },
+    "graph.node_not_found": {
+        "ko": "노드를 찾을 수 없습니다.",
+        "en": "That node was not found.",
+    },
+    "graph.unsupported_type": {
+        "ko": "지원하는 종류: message, ai_response, note",
+        "en": "Supported types are: message, ai_response, note.",
+    },
+    # ── ingestion / folders ─────────────────────────────────────────────
+    "ingestion.job_not_found": {
+        "ko": "수집 작업을 찾을 수 없습니다.",
+        "en": "That ingestion job was not found.",
+    },
+    "ingestion.watch_unavailable": {
+        "ko": "폴더 감시 기능을 사용할 수 없습니다.",
+        "en": "The folder watch service is unavailable.",
+    },
+    "ingestion.watch_enable_failed": {
+        "ko": "폴더 감시를 켜지 못했습니다.",
+        "en": "Turning folder watch on did not succeed.",
+    },
+    "ingestion.watch_selector_required": {
+        "ko": "감시 항목 또는 경로가 필요합니다.",
+        "en": "A watch id or a path is required.",
+    },
+    "ingestion.watch_not_found": {
+        "ko": "감시 중인 폴더를 찾을 수 없습니다.",
+        "en": "That watched folder was not found.",
+    },
+    "portability.verification_failed": {
+        "ko": "보관 파일 검증에 실패했습니다.",
+        "en": "Archive verification failed.",
+    },
+    # ── review queue ────────────────────────────────────────────────────
+    "review.item_not_found": {
+        "ko": "검토 항목을 찾을 수 없습니다.",
+        "en": "That review item was not found.",
+    },
+    "review.cannot_approve_in_status": {
+        "ko": "'{status}' 상태의 검토 항목은 승인할 수 없습니다.",
+        "en": "A review item in status '{status}' cannot be approved.",
+    },
+    # ── projects ────────────────────────────────────────────────────────
+    "project.not_found": {
+        "ko": "프로젝트를 찾을 수 없습니다.",
+        "en": "That project was not found.",
+    },
+    # ── network boundary ────────────────────────────────────────────────
+    "boundary.policy_not_configured": {
+        "ko": "혼합 검색 정책 서비스가 설정되지 않았습니다.",
+        "en": "The hybrid policy service is not configured.",
+    },
+    # ── models ──────────────────────────────────────────────────────────
+    "models.other_user_credentials": {
+        "ko": "다른 사용자의 모델 자격 증명을 사용할 수 없습니다.",
+        "en": "You cannot use another user's model credentials.",
+    },
+    "models.download_consent_required": {
+        "ko": "모델 내려받기는 사용자가 직접 동의해야 시작됩니다.",
+        "en": "Model downloads require explicit consent (allow_download=true).",
+    },
+    "models.identifier_empty": {
+        "ko": "모델 식별자가 비어 있습니다.",
+        "en": "The model identifier is empty.",
+    },
+    "models.name_empty": {
+        "ko": "모델 이름이 비어 있습니다.",
+        "en": "The model name is empty.",
+    },
+    "models.ollama_missing": {
+        "ko": "Ollama가 설치되어 있지 않습니다.",
+        "en": "Ollama is not installed.",
+    },
+    "models.download_timeout": {
+        "ko": "모델 내려받기 시간이 초과되었습니다.",
+        "en": "The model download timed out.",
+    },
+    "models.pull_failed": {
+        "ko": "모델 내려받기에 실패했습니다.",
+        "en": "The model download failed.",
+    },
+    "models.download_not_automated": {
+        "ko": "{provider} 엔진의 모델 내려받기는 아직 자동화되지 않았습니다.",
+        "en": "Model downloads for the {provider} engine are not automated yet.",
+    },
+    "models.unknown_provider": {
+        "ko": "알 수 없는 제공자입니다.",
+        "en": "Unknown provider.",
+    },
+    "models.api_key_empty": {
+        "ko": "API 키가 비어 있습니다.",
+        "en": "The API key is empty.",
+    },
+    "models.other_user_api_key": {
+        "ko": "다른 사용자의 API 키를 설정할 권한이 없습니다.",
+        "en": "You are not allowed to set another user's API key.",
+    },
+    "models.sign_in_required": {
+        "ko": "사용자 확인이 필요합니다. 로그인 후 다시 시도하세요.",
+        "en": "Sign in first, then try again.",
+    },
+    # ── tools / files ───────────────────────────────────────────────────
+    "tools.pdf_render_failed": {
+        "ko": "PDF를 그리지 못했습니다: {reason}",
+        "en": "The PDF could not be rendered: {reason}",
+    },
+    "tools.path_outside_workspace": {
+        "ko": "경로가 작업 공간 밖입니다.",
+        "en": "That path is outside the workspace.",
+    },
+    "tools.directory_not_found": {
+        "ko": "디렉터리를 찾을 수 없습니다.",
+        "en": "That directory was not found.",
+    },
+    # ── MCP / setup ─────────────────────────────────────────────────────
+    "mcp.connector_not_found": {
+        "ko": "커넥터를 찾을 수 없습니다.",
+        "en": "That connector was not found.",
+    },
+    "mcp.name_required": {
+        "ko": "이름은 필수입니다.",
+        "en": "A name is required.",
+    },
+    "mcp.package_required": {
+        "ko": "패키지는 필수입니다.",
+        "en": "A package is required.",
+    },
+    "mcp.item_not_found": {
+        "ko": "항목을 찾을 수 없습니다.",
+        "en": "That item was not found.",
+    },
+    "mcp.unknown_id": {
+        "ko": "알 수 없는 MCP입니다: {mcp_id}",
+        "en": "Unknown MCP: {mcp_id}",
+    },
+    "setup.unknown_permission": {
+        "ko": "알 수 없는 권한 설정입니다.",
+        "en": "Unknown permission setting.",
+    },
+    "models.public_mode_blocks_local": {
+        "ko": (
+            "공개 모드에서는 로컬 MLX 모델을 불러올 수 없습니다. "
+            "openai:, openrouter:, groq:, together: 모델을 쓰거나 "
+            "LATTICEAI_ALLOW_LOCAL_MODELS=true 로 설정하세요."
+        ),
+        "en": (
+            "Public mode does not load local MLX models. Use an openai:, "
+            "openrouter:, groq: or together: model, or set "
+            "LATTICEAI_ALLOW_LOCAL_MODELS=true."
+        ),
+    },
+    "models.public_model_missing": {
+        "ko": (
+            "공개 모델이 준비되지 않았습니다. OPENAI_API_KEY 와 "
+            "LATTICEAI_PUBLIC_MODEL={model} 을 설정하거나, OpenAI 호환 모델로 "
+            "/models/load 를 호출하세요."
+        ),
+        "en": (
+            "No public model is loaded. Set OPENAI_API_KEY and "
+            "LATTICEAI_PUBLIC_MODEL={model}, or call /models/load with an "
+            "OpenAI-compatible model."
+        ),
+    },
 }
 
 

package/latticeai/core/workspace_os_constants.py

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