ltcai 8.9.0 → 9.1.0

package/latticeai/api/models.py

@@ -5,10 +5,8 @@ Extracted from ``server_app.py`` in v1.3.0. Paths and schemas unchanged:
 ``/setup/set-api-key``.
 
 Mirrors the established router-factory convention: the heavy provider/runtime
-helpers (engine_status, prepare_and_load_model, download_hf_model,
-verify_cloud_models, …) remain owned by server_app for now and are injected here
-as callables, so this module has no import cycle and adds no import-time
-side effects.
+helpers are injected as bound service callables. This module owns the sole
+translation from transport-neutral ``ModelRuntimeError`` failures to HTTP.
 """
 
 from __future__ import annotations
@@ -16,12 +14,14 @@ from __future__ import annotations
 import asyncio
 import logging
 import subprocess
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, NoReturn, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
+from latticeai.services.model_errors import ModelRuntimeError
+
 
 def _vision_capability(current_model_id: Optional[str], engines: Any) -> Dict[str, Any]:
     """Whether the active model can accept image input (VLM).
@@ -97,6 +97,7 @@ def create_models_router(
     *,
     model_router: Any,
     require_user: Callable[[Request], str],
+    require_admin: Callable[[Request], tuple],
     get_current_user: Callable[[Request], Optional[str]],
     load_users: Callable[[], Dict],
     get_user_role: Callable[..., str],
@@ -131,6 +132,27 @@ def create_models_router(
     REQUIRE_AUTH = require_auth
     _list_compat_profiles = list_compat_profiles
 
+    def _normalized_identity(value: Optional[str]) -> str:
+        return str(value or "").strip().lower()
+
+    def _authorize_model_admin(request: Request, claimed_email: Optional[str] = None) -> str:
+        """Authenticate model operations and gate host-global state to admins."""
+        current_user = require_user(request)
+        if REQUIRE_AUTH:
+            if claimed_email and _normalized_identity(claimed_email) != _normalized_identity(current_user):
+                raise HTTPException(status_code=403, detail="다른 사용자의 모델 자격 증명을 사용할 수 없습니다.")
+            require_admin(request)
+        return current_user
+
+    def _effective_email(current_user: str, claimed_email: Optional[str]) -> Optional[str]:
+        # Authenticated callers may only act as their session identity. The
+        # legacy body field remains usable solely in explicit no-auth/local
+        # mode for backward compatibility.
+        return current_user if REQUIRE_AUTH else claimed_email or current_user or None
+
+    def _raise_model_http(exc: ModelRuntimeError) -> NoReturn:
+        raise HTTPException(status_code=exc.status_code, detail=exc.detail) from exc
+
     def _recommended_with_engine_options(
         items: List[Dict[str, object]],
         engines: Optional[List[Dict[str, object]]] = None,
@@ -281,20 +303,26 @@ def create_models_router(
 
     @router.post("/engines/install")
     async def engines_install(req: InstallEngineRequest, request: Request):
-        require_user(request)
-        if req.confirmation_token:
-            return install_engine(req.engine, confirmation_token=req.confirmation_token)
-        return install_engine(req.engine)
+        _authorize_model_admin(request)
+        try:
+            if req.confirmation_token:
+                return install_engine(req.engine, confirmation_token=req.confirmation_token)
+            return install_engine(req.engine)
+        except ModelRuntimeError as exc:
+            _raise_model_http(exc)
 
     @router.post("/engines/verify-cloud")
     async def engines_verify_cloud(req: VerifyCloudRequest, request: Request):
-        require_user(request)
-        results = await verify_cloud_models(force=req.force, provider_filter=req.provider)
+        _authorize_model_admin(request)
+        try:
+            results = await verify_cloud_models(force=req.force, provider_filter=req.provider)
+        except ModelRuntimeError as exc:
+            _raise_model_http(exc)
         return {"verified": results, "ttl_seconds": CLOUD_VERIFY_TTL_SECONDS}
 
     @router.post("/engines/pull-model")
     async def pull_ollama_model(req: PullModelRequest, request: Request):
-        require_user(request)
+        _authorize_model_admin(request)
         if not req.allow_download:
             raise HTTPException(
                 status_code=403,
@@ -315,7 +343,10 @@ def create_models_router(
             raise HTTPException(status_code=400, detail="모델 이름이 비어 있습니다.")
 
         if provider == "ollama":
-            ensure_ollama_server()
+            try:
+                ensure_ollama_server()
+            except ModelRuntimeError as exc:
+                _raise_model_http(exc)
             ollama = local_binary("ollama")
             if not ollama:
                 raise HTTPException(status_code=400, detail="Ollama가 설치되지 않았습니다.")
@@ -342,19 +373,25 @@ def create_models_router(
 
         if provider in {"vllm", "llamacpp", "local_mlx", "mlx"}:
             download_provider = "local_mlx" if provider == "mlx" else provider
-            result = download_hf_model(model_name, download_provider)
+            try:
+                result = download_hf_model(model_name, download_provider)
+            except ModelRuntimeError as exc:
+                _raise_model_http(exc)
             return {"provider": provider, "model": model_name, "returncode": 0, **result}
 
         raise HTTPException(status_code=400, detail=f"{provider} 엔진 모델 다운로드는 아직 자동화되지 않았습니다.")
 
     @router.post("/engines/prepare-model")
     async def engines_prepare_model(req: PrepareModelRequest, request: Request):
-        require_user(request)
+        current_user = _authorize_model_admin(request, req.user_email)
         try:
             return await prepare_and_load_model(
-                req.model, request, engine=req.engine, user_email=req.user_email,
+                req.model, request, engine=req.engine,
+                user_email=_effective_email(current_user, req.user_email),
                 allow_download=req.allow_download,
             )
+        except ModelRuntimeError as exc:
+            _raise_model_http(exc)
         except HTTPException:
             raise
         except Exception as exc:
@@ -367,16 +404,17 @@ def create_models_router(
 
     @router.post("/engines/prepare-model/stream")
     async def engines_prepare_model_stream(req: PrepareModelRequest, request: Request):
-        require_user(request)
+        current_user = _authorize_model_admin(request, req.user_email)
+        effective_email = _effective_email(current_user, req.user_email)
 
         async def event_stream():
             try:
                 async for chunk in prepare_and_load_model_stream(
-                    req.model, request, engine=req.engine, user_email=req.user_email,
+                    req.model, request, engine=req.engine, user_email=effective_email,
                     allow_download=req.allow_download,
                 ):
                     yield chunk
-            except HTTPException as exc:
+            except (HTTPException, ModelRuntimeError) as exc:
                 yield sse_event("error", {
                     "status_code": exc.status_code,
                     "detail": exc.detail or "모델 준비에 실패했습니다.",
@@ -404,14 +442,10 @@ def create_models_router(
             raise HTTPException(status_code=400, detail="알 수 없는 프로바이더입니다.")
         if not req.key.strip():
             raise HTTPException(status_code=400, detail="API 키가 비어있습니다.")
-        current_user = get_current_user(request)
-        if REQUIRE_AUTH and not current_user:
-            raise HTTPException(status_code=401, detail="인증이 필요합니다.")
-        if req.user_email and req.user_email != current_user:
-            users = load_users()
-            if get_user_role(current_user or "", users) != "admin":
-                raise HTTPException(status_code=403, detail="다른 사용자의 API 키를 설정할 권한이 없습니다.")
-        target_email = (req.user_email or current_user or "").strip()
+        current_user = require_user(request)
+        if REQUIRE_AUTH and req.user_email and _normalized_identity(req.user_email) != _normalized_identity(current_user):
+            raise HTTPException(status_code=403, detail="다른 사용자의 API 키를 설정할 권한이 없습니다.")
+        target_email = str(_effective_email(current_user, req.user_email) or "").strip()
         if not target_email:
             raise HTTPException(status_code=400, detail="사용자 식별이 필요합니다. 로그인 후 다시 시도하세요.")
         set_user_api_key(target_email, req.provider, req.key.strip())
@@ -420,7 +454,8 @@ def create_models_router(
     # ── Models ────────────────────────────────────────────────────────────
 
     @router.get("/models")
-    async def list_models():
+    async def list_models(request: Request):
+        _authorize_model_admin(request)
         engines = await asyncio.to_thread(engine_status)
         recommended = _recommended_with_engine_options(
             list(filter_lower_family_versions(ENGINE_MODEL_CATALOG.get("local_mlx", []))),
@@ -457,6 +492,7 @@ def create_models_router(
 
     @router.post("/models/load")
     async def load_model(req: LoadModelRequest, request: Request):
+        current_user = _authorize_model_admin(request, req.user_email)
         try:
             from latticeai.core.model_compat import friendly_model_runtime_error, model_runtime_compatibility
 
@@ -471,10 +507,13 @@ def create_models_router(
             if compatibility.get("supported") is False:
                 raise HTTPException(status_code=400, detail=compatibility)
             return await prepare_and_load_model(
-                model_id, request, engine=req.engine, user_email=req.user_email,
+                model_id, request, engine=req.engine,
+                user_email=_effective_email(current_user, req.user_email),
                 adapter_path=req.adapter_path, draft_model_id=req.draft_model_id,
                 allow_download=req.allow_download,
             )
+        except ModelRuntimeError as exc:
+            _raise_model_http(exc)
         except HTTPException:
             raise
         except Exception as e:
@@ -485,7 +524,7 @@ def create_models_router(
 
     @router.post("/models/switch/{model_id:path}")
     async def switch_model(model_id: str, request: Request):
-        require_user(request)
+        _authorize_model_admin(request)
         try:
             _router.switch_model(model_id)
             return {"status": "ok", "current": _router.current_model_id}
@@ -494,13 +533,13 @@ def create_models_router(
 
     @router.delete("/models/unload/{model_id:path}")
     async def unload_model(model_id: str, request: Request):
-        require_user(request)
+        _authorize_model_admin(request)
         _router.unload_model(model_id)
         return {"status": "ok", "unloaded": model_id}
 
     @router.delete("/models/unload-all")
     async def unload_all_models(request: Request):
-        require_user(request)
+        _authorize_model_admin(request)
         unloaded = _router.loaded_model_ids
         _router.unload_all()
         return {"status": "ok", "unloaded": unloaded}
@@ -513,7 +552,7 @@ def create_models_router(
         hardware, load_strategy, license, safety_notes) from the structured registry.
         """
         require_user(request)
-        from auto_setup import probe as auto_setup_probe
+        from latticeai.setup.auto_setup import probe as auto_setup_probe
         from latticeai.services.model_recommendation import recommend_catalog
 
         profile = await asyncio.to_thread(lambda: auto_setup_probe().to_json())

package/latticeai/api/network.py

@@ -23,7 +23,7 @@ class PeerPushRequest(BaseModel):
     workspace_id: Optional[str] = None
 
 
-def create_network_router(*, network, identity, require_user) -> APIRouter:
+def create_network_router(*, network, identity, require_user, require_admin) -> APIRouter:
     router = APIRouter()
 
     @router.get("/network/identity")
@@ -33,12 +33,12 @@ def create_network_router(*, network, identity, require_user) -> APIRouter:
 
     @router.get("/network/peers")
     async def network_peers(request: Request):
-        require_user(request)
+        require_admin(request)
         return {"peers": network.list_peers()}
 
     @router.post("/network/peers")
     async def network_pair(req: PeerPairRequest, request: Request):
-        require_user(request)
+        require_admin(request)
         try:
             return {"status": "paired", "peer": network.add_peer(
                 name=req.name, base_url=req.base_url, public_key=req.public_key,
@@ -48,7 +48,7 @@ def create_network_router(*, network, identity, require_user) -> APIRouter:
 
     @router.delete("/network/peers/{peer_id}")
     async def network_unpair(peer_id: str, request: Request):
-        require_user(request)
+        require_admin(request)
         try:
             return network.remove_peer(peer_id)
         except FileNotFoundError as exc:
@@ -56,7 +56,7 @@ def create_network_router(*, network, identity, require_user) -> APIRouter:
 
     @router.post("/network/push/{peer_id}")
     async def network_push(peer_id: str, req: PeerPushRequest, request: Request):
-        require_user(request)
+        require_admin(request)
         try:
             return network.push_to_peer(peer_id, workspace_id=req.workspace_id)
         except FileNotFoundError as exc:

package/latticeai/api/permissions.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import json
 import logging
+import os
 import secrets
 import threading
 import time
@@ -14,6 +15,8 @@ from typing import Dict, Optional, Tuple
 
 from fastapi import APIRouter, HTTPException, Request
 
+from latticeai.core.io_utils import atomic_write_json
+
 
 _PERMISSION_ACTION_LABELS = {
     "list": "폴더 목록 보기",
@@ -37,6 +40,12 @@ 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
+        )
 
     @staticmethod
     def token_hash(token: str) -> str:
@@ -56,10 +65,9 @@ class PermissionGateway:
             return {}
 
     def _write_queue(self, queue: Dict) -> None:
-        self.perm_queue_file.parent.mkdir(parents=True, exist_ok=True)
-        tmp = self.perm_queue_file.with_suffix(self.perm_queue_file.suffix + ".tmp")
-        tmp.write_text(json.dumps(queue, ensure_ascii=False, indent=2), encoding="utf-8")
-        tmp.replace(self.perm_queue_file)
+        # Approval metadata contains local paths and identities. Keep writes
+        # atomic and private even when the caller's umask is permissive.
+        atomic_write_json(self.perm_queue_file, queue)
 
     def _perm_queue_write(self, token: str, record: Dict[str, object]) -> None:
         try:
@@ -72,8 +80,10 @@ class PermissionGateway:
             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:
-            key = self.token_hash(token)
             with self.perm_queue_lock:
                 queue = self._read_queue()
                 queue.pop(key, None)
@@ -81,6 +91,27 @@ class PermissionGateway:
         except Exception as exc:
             logging.warning("perm_queue_remove failed: %s", exc)
 
+    def resolve_approval_key(self, token_or_hint: str) -> str:
+        """Resolve either the private token or its UI-safe eight-char hint.
+
+        Only an authenticated administrator/monitor reaches approval routes.
+        Supporting a unique hint lets the admin UI act on pending requests
+        without ever receiving the bearer-grade full token.
+        """
+        value = str(token_or_hint or "")
+        direct_key = self.token_hash(value)
+        with self.local_approval_lock:
+            if direct_key in self.local_approvals:
+                return direct_key
+            matches = [
+                key
+                for key, record in self.local_approvals.items()
+                if len(value) == 8 and record.get("token_hint") == value
+            ]
+        if len(matches) > 1:
+            raise HTTPException(status_code=409, detail="요청 ID가 중복되었습니다. 관리자 목록을 새로고침하세요.")
+        return matches[0] if matches else direct_key
+
     @staticmethod
     def normalize_local_path_for_approval(path: str) -> str:
         return str(Path(path).expanduser().resolve())
@@ -91,6 +122,7 @@ class PermissionGateway:
 
     def _notify_discord_permission_sync(self, token: str, path: str, action: str, user_email: str) -> None:
         sent = False
+        token_hint = self.token_hint(token)
         if self.discord_bot_token and self.discord_permission_channel:
             action_label = _PERMISSION_ACTION_LABELS.get(action, action)
             expires_at_iso = time.strftime(
@@ -102,9 +134,9 @@ class PermissionGateway:
                 f"**경로:** `{path}`\n"
                 f"**작업:** {action_label}\n"
                 f"**요청자:** {user_email}\n"
-                f"**토큰:** `{token}`\n"
+                f"**요청 ID:** `{token_hint}`\n"
                 f"**만료:** {expires_at_iso}\n\n"
-                f"승인하려면 `승인 {token[:8]}` / 거부하려면 `거부 {token[:8]}` 라고 답장하세요."
+                f"승인/거부: {self.permission_ui_url}"
             )
             payload = json.dumps({"content": msg}, ensure_ascii=False).encode("utf-8")
             try:
@@ -139,15 +171,11 @@ class PermissionGateway:
                                 {"name": "경로", "value": f"`{path}`", "inline": False},
                                 {"name": "작업", "value": action_label, "inline": True},
                                 {"name": "요청자", "value": user_email, "inline": True},
-                                {"name": "토큰", "value": f"`{token}`", "inline": False},
+                                {"name": "요청 ID", "value": f"`{token_hint}`", "inline": False},
                                 {"name": "만료", "value": expires_at_iso, "inline": True},
                             ],
                             "footer": {
-                                "text": (
-                                    "승인: POST /permissions/approve/{token}  |  "
-                                    "거부: POST /permissions/deny/{token}  |  "
-                                    "목록: GET /permissions/pending"
-                                )
+                                "text": f"승인/거부 UI: {self.permission_ui_url}"
                             },
                         }
                     ]
@@ -216,9 +244,9 @@ class PermissionGateway:
         now = time.time()
         key = self.token_hash(token)
         with self.local_approval_lock:
-            expired = [key for key, value in self.local_approvals.items() if float(value.get("expires_at", 0)) < now]
-            for key in expired:
-                self.local_approvals.pop(key, None)
+            expired = [approval_key for approval_key, value in self.local_approvals.items() if float(value.get("expires_at", 0)) < now]
+            for expired_key in expired:
+                self.local_approvals.pop(expired_key, None)
             record = self.local_approvals.get(key)
         if not record:
             raise HTTPException(status_code=403, detail="파일 접근 승인이 만료되었거나 유효하지 않습니다.")
@@ -232,19 +260,31 @@ class PermissionGateway:
             raise HTTPException(status_code=403, detail="승인된 파일 내용과 요청 내용이 다릅니다.")
 
     def check_permission_auth(self, request: Request, token: Optional[str] = None) -> None:
+        """Authorize an approval decision.
+
+        Possession of the approval token is deliberately *not* sufficient:
+        the requester receives that token in order to poll status, so allowing
+        token ownership here would let them approve their own request.
+        """
+        _ = token  # retained for compatibility with existing call sites
         if self.permission_monitor_secret:
             auth_header = request.headers.get("Authorization", "")
-            if auth_header == f"Bearer {self.permission_monitor_secret}":
-                return
-        if token:
-            key = self.token_hash(token)
-            current_user = self.get_current_user(request)
-            with self.local_approval_lock:
-                record = self.local_approvals.get(key)
-            if current_user and record and record.get("user_email") == current_user:
+            expected = f"Bearer {self.permission_monitor_secret}"
+            if secrets.compare_digest(auth_header, expected):
                 return
         self.require_admin(request)
 
+    def require_permission_status_owner(self, *, token: str, user_email: str) -> None:
+        """Allow approval-status polling only to the original requester."""
+        key = self.token_hash(token)
+        with self.local_approval_lock:
+            record = self.local_approvals.get(key)
+        # Missing/expired tokens intentionally retain the generic status
+        # response. For a live request, however, a different account must not
+        # learn or poll its state even if it obtains the URL.
+        if record and record.get("user_email") != user_email:
+            raise HTTPException(status_code=403, detail="다른 사용자의 승인 상태는 조회할 수 없습니다.")
+
     def ensure_path_allowed(self, path: str, *, action: str) -> None:
         if action != "write":
             return
@@ -296,7 +336,7 @@ def create_permissions_router(
     @router.post("/permissions/approve/{token}")
     async def permissions_approve(token: str, request: Request):
         gateway.check_permission_auth(request, token)
-        key = gateway.token_hash(token)
+        key = gateway.resolve_approval_key(token)
         with gateway.local_approval_lock:
             record = gateway.local_approvals.get(key)
             if not record:
@@ -305,7 +345,7 @@ def create_permissions_router(
                 gateway.local_approvals.pop(key, None)
                 raise HTTPException(status_code=410, detail="토큰이 만료되었습니다.")
             record["approved"] = True
-        gateway._perm_queue_remove(token)
+        gateway._perm_queue_remove_key(key)
         logging.info(
             "Permission approved: token=%s path=%s action=%s user=%s",
             gateway.token_hint(token),
@@ -324,10 +364,10 @@ def create_permissions_router(
     @router.post("/permissions/deny/{token}")
     async def permissions_deny(token: str, request: Request):
         gateway.check_permission_auth(request, token)
-        key = gateway.token_hash(token)
+        key = gateway.resolve_approval_key(token)
         with gateway.local_approval_lock:
             record = gateway.local_approvals.pop(key, None)
-        gateway._perm_queue_remove(token)
+        gateway._perm_queue_remove_key(key)
         if not record:
             raise HTTPException(status_code=404, detail="토큰이 없거나 이미 처리되었습니다.")
         logging.info(
@@ -347,7 +387,8 @@ def create_permissions_router(
 
     @router.get("/permissions/status/{token}")
     async def permissions_status(token: str, request: Request):
-        require_user(request)
+        current_user = require_user(request)
+        gateway.require_permission_status_owner(token=token, user_email=current_user)
         now = time.time()
         key = gateway.token_hash(token)
         with gateway.local_approval_lock:

package/latticeai/api/plugins.py

@@ -40,8 +40,11 @@ def create_plugins_router(
     require_user: Callable[[Request], str],
     require_admin: Callable[[Request], Any],
     append_audit_event: Callable[..., None],
+    gate_write: Optional[Callable[[Request], Optional[str]]] = None,
     register_skill: Optional[Callable[[str, str], Any]] = None,
-    plugin_runners_factory: Optional[Callable[[], Dict[str, Callable[..., Any]]]] = None,
+    plugin_runners_factory: Optional[
+        Callable[[str, Optional[str]], Dict[str, Callable[..., Any]]]
+    ] = None,
     ui_file_response: Optional[Callable[[Path], Any]] = None,
     static_dir: Optional[Path] = None,
 ) -> APIRouter:
@@ -93,19 +96,30 @@ def create_plugins_router(
 
     @router.post("/plugins/enable")
     async def plugin_enable(req: PluginActionRequest, request: Request):
-        require_user(request)
-        return {"plugin": registry.set_enabled(req.plugin_id, True)}
+        admin_email, _ = require_admin(request)
+        plugin = registry.set_enabled(req.plugin_id, True)
+        append_audit_event("plugin_enable", user_email=admin_email, plugin=req.plugin_id)
+        return {"plugin": plugin}
 
     @router.post("/plugins/disable")
     async def plugin_disable(req: PluginActionRequest, request: Request):
-        require_user(request)
-        return {"plugin": registry.set_enabled(req.plugin_id, False)}
+        admin_email, _ = require_admin(request)
+        plugin = registry.set_enabled(req.plugin_id, False)
+        append_audit_event("plugin_disable", user_email=admin_email, plugin=req.plugin_id)
+        return {"plugin": plugin}
 
     @router.post("/plugins/execute")
     async def plugin_execute(req: PluginExecuteRequest, request: Request):
         current_user = require_user(request)
-        runners = plugin_runners_factory() if plugin_runners_factory else {}
-        result = registry.execute_action(req.plugin_id, req.action, req.args, runners=runners)
+        scope = gate_write(request) if gate_write is not None else None
+        runners = plugin_runners_factory(current_user, scope) if plugin_runners_factory else {}
+        result = registry.execute_action(
+            req.plugin_id,
+            req.action,
+            req.args,
+            runners=runners,
+            workspace_id=scope,
+        )
         append_audit_event("plugin_execute", user_email=current_user, plugin=req.plugin_id, action=req.action, status=result.status)
         return result.as_dict()
 

package/latticeai/api/portability.py

@@ -1,8 +1,8 @@
 """Knowledge Graph portability routes — local export / import / backup / restore.
 
-Reads (export, status) require a signed-in user. Mutating operations (import,
-backup, restore, file export) require admin because the graph is machine-global,
-not workspace-scoped. Nothing here touches a cloud service.
+Status reads require a signed-in user. Whole-graph exports, provenance, and all
+mutating operations require admin because the graph is machine-global, not
+workspace-scoped. Nothing here touches a cloud service.
 """
 
 from __future__ import annotations
@@ -97,14 +97,14 @@ def create_portability_router(
     @router.get("/api/knowledge-graph/provenance")
     async def recent_provenance(request: Request, limit: int = 50, source_type: Optional[str] = None):
         """Recent ingestions (provenance trail) for the ingestion-sources UI."""
-        require_user(request)
+        require_admin(request)
         _require_service()
         return service.recent_ingestions(limit=limit, source_type=source_type)
 
     @router.post("/api/knowledge-graph/export")
     async def export_graph(request: Request):
         """Logical JSON export of the whole graph (read-only)."""
-        require_user(request)
+        require_admin(request)
         _require_service()
         return service.export()
 

package/latticeai/api/realtime.py

@@ -12,7 +12,7 @@ import secrets
 from pathlib import Path
 from typing import Any, Callable, Optional, Set
 
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
@@ -48,8 +48,21 @@ def create_realtime_router(
         sub_id = secrets.token_urlsafe(12)
         sub = bus.add_subscriber(sub_id, workspace_scope=scope, user=user or None)
 
+        def refresh_authorization(current_sub) -> bool:
+            try:
+                refreshed_user = require_user(request)
+            except Exception:
+                return False
+            if refreshed_user != user:
+                return False
+            current_sub.workspace_scope = allowed_scopes(refreshed_user or None)
+            return True
+
         async def event_gen():
-            async for frame in bus.stream(sub):
+            async for frame in bus.stream(
+                sub,
+                refresh_authorization=refresh_authorization,
+            ):
                 if await request.is_disconnected():
                     break
                 yield frame
@@ -76,15 +89,30 @@ def create_realtime_router(
     @router.post("/realtime/presence/join")
     async def realtime_join(req: PresenceRequest, request: Request):
         user = require_user(request)
+        scope = allowed_scopes(user or None)
+        workspace_id = req.workspace_id
+        if scope is not None:
+            if workspace_id is None:
+                if not scope:
+                    raise HTTPException(status_code=403, detail="No accessible workspace for presence.")
+                workspace_id = "personal" if "personal" in scope else sorted(scope)[0]
+            elif workspace_id not in scope:
+                raise HTTPException(status_code=403, detail="Workspace presence access denied.")
         client_id = req.client_id or secrets.token_urlsafe(8)
-        record = bus.join(client_id, user=user or None, workspace_id=req.workspace_id)
+        try:
+            record = bus.join(client_id, user=user or None, workspace_id=workspace_id)
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
         return {"presence": record}
 
     @router.post("/realtime/presence/leave")
     async def realtime_leave(req: PresenceRequest, request: Request):
-        require_user(request)
+        user = require_user(request)
         if req.client_id:
-            bus.leave(req.client_id)
+            try:
+                bus.leave(req.client_id, user=user or None)
+            except PermissionError as exc:
+                raise HTTPException(status_code=403, detail=str(exc)) from exc
         return {"status": "ok"}
 
     return router

package/latticeai/api/setup.py

@@ -9,7 +9,7 @@ from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
 from latticeai.services.process_audit import command_plan
-from auto_setup import (
+from latticeai.setup.auto_setup import (
     plan as auto_setup_plan,
     preset as auto_setup_preset,
     probe as auto_setup_probe,
@@ -17,7 +17,7 @@ from auto_setup import (
     verify as auto_setup_verify,
 )
 from latticeai.models.router import parse_model_ref
-from setup_wizard import get_recommendations, install_stream, open_url, scan_environment
+from latticeai.setup.wizard import get_recommendations, install_stream, open_url, scan_environment
 
 
 class SetupInstallRequest(BaseModel):