ltcai 8.8.0 → 8.9.0

package/lattice_brain/graph/retrieval.py

@@ -55,9 +55,18 @@ class KnowledgeGraphRetrievalMixin:
                 extracted = meta.get("extracted") or {}
                 node_id = row["id"]
                 chunk_count = conn.execute(
-                    f"SELECT COUNT(*) AS c FROM {nt} WHERE type='Chunk' AND metadata_json LIKE ?",
-                    (f"%{node_id}%",),
+                    "SELECT COUNT(*) AS c FROM chunks WHERE source_node=?",
+                    (node_id,),
                 ).fetchone()["c"]
+                if not chunk_count:
+                    # Legacy projections represented chunks as graph nodes and
+                    # linked them only through metadata_json. Keep read
+                    # compatibility without making the fragile LIKE path the
+                    # primary query.
+                    chunk_count = conn.execute(
+                        f"SELECT COUNT(*) AS c FROM {nt} WHERE type='Chunk' AND metadata_json LIKE ?",
+                        (f"%{node_id}%",),
+                    ).fetchone()["c"]
                 documents.append(
                     {
                         "id": node_id,
@@ -255,7 +264,7 @@ class KnowledgeGraphRetrievalMixin:
             node.pop("_raw_importance", None)
         return {"nodes": nodes, "edges": edges}
 
-    def search(self, query: str, limit: int = 30) -> Dict[str, Any]:
+    def search(self, query: str, limit: int = 30, *, allowed_workspaces=None) -> Dict[str, Any]:
         query = str(query or "").strip()
         q = f"%{query}%"
         limit = max(1, min(int(limit or 30), 100))
@@ -347,9 +356,7 @@ class KnowledgeGraphRetrievalMixin:
             # the legacy LIKE path regardless of FTS bm25 tie ordering.
             rows = sorted(rows, key=lambda r: r["id"])
             rows = sorted(rows, key=score, reverse=True)[:limit]
-        return {
-            "query": query,
-            "matches": [
+        matches = [
                 {
                     "id": row["id"],
                     "type": row["type"],
@@ -359,15 +366,17 @@ class KnowledgeGraphRetrievalMixin:
                     "updated_at": row["updated_at"],
                 }
                 for row in rows
-            ],
-        }
+            ]
+        if allowed_workspaces is not None:
+            matches = self.filter_scoped_nodes(matches, allowed_workspaces)
+        return {"query": query, "matches": matches}
 
-    def context_for_query(self, query: str, limit: int = 6) -> str:
+    def context_for_query(self, query: str, limit: int = 6, *, allowed_workspaces=None) -> str:
         """Return compact graph-backed RAG context for chat generation."""
         query = str(query or "").strip()
         if not query:
             return ""
-        matches = self.search(query, limit).get("matches", [])
+        matches = self.search(query, limit, allowed_workspaces=allowed_workspaces).get("matches", [])
         if not matches:
             topics = _topic_candidates(query, limit=4)
             if topics:
@@ -404,6 +413,8 @@ class KnowledgeGraphRetrievalMixin:
                     )
                     if len(matches) >= limit:
                         break
+                if allowed_workspaces is not None:
+                    matches = self.filter_scoped_nodes(matches, allowed_workspaces)
         lines = []
         for match in matches[:limit]:
             meta = match.get("metadata") or {}
@@ -420,8 +431,10 @@ class KnowledgeGraphRetrievalMixin:
             )
         return "\n".join(lines)
 
-    def neighbors(self, node_id: str) -> Dict[str, Any]:
+    def neighbors(self, node_id: str, *, allowed_workspaces=None) -> Dict[str, Any]:
         """Return direct neighbors (1-hop) of a node."""
+        if allowed_workspaces is not None and not self.filter_scoped_nodes([{"id": node_id}], allowed_workspaces):
+            raise ValueError(f"graph node not found: {node_id}")
         nt, et = self._read_tables()
         with self._connect() as conn:
             edge_rows = conn.execute(
@@ -458,9 +471,17 @@ class KnowledgeGraphRetrievalMixin:
                         list(neighbor_ids),
                     )
                 ]
+        if allowed_workspaces is not None:
+            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            kept = {node.get("id") for node in nodes}
+            edges = [
+                edge for edge in edges
+                if (edge.get("from") == node_id or edge.get("from") in kept)
+                and (edge.get("to") == node_id or edge.get("to") in kept)
+            ]
         return {"node_id": node_id, "neighbors": nodes, "edges": edges}
 
-    def get_node(self, node_id: str) -> Dict[str, Any]:
+    def get_node(self, node_id: str, *, allowed_workspaces=None) -> Dict[str, Any]:
         node_id = str(node_id or "").strip()
         if not node_id:
             raise ValueError("node_id required")
@@ -480,7 +501,7 @@ class KnowledgeGraphRetrievalMixin:
                 f"SELECT COUNT(*) AS c FROM {et} WHERE from_node=? OR to_node=?",
                 (node_id, node_id),
             ).fetchone()["c"]
-        return {
+        node = {
             "id": row["id"],
             "type": row["type"],
             "title": row["title"],
@@ -489,6 +510,9 @@ class KnowledgeGraphRetrievalMixin:
             "updated_at": row["updated_at"],
             "degree": degree,
         }
+        if allowed_workspaces is not None and not self.filter_scoped_nodes([node], allowed_workspaces):
+            raise ValueError(f"graph node not found: {node_id}")
+        return node
 
     def relationship_search(
         self,
@@ -497,6 +521,7 @@ class KnowledgeGraphRetrievalMixin:
         node_id: str = "",
         relationship_type: str = "",
         limit: int = 30,
+        allowed_workspaces=None,
     ) -> Dict[str, Any]:
         query = str(query or "").strip()
         node_id = str(node_id or "").strip()
@@ -535,11 +560,7 @@ class KnowledgeGraphRetrievalMixin:
                     """,
                 (*params, limit),
             ).fetchall()
-        return {
-            "query": query,
-            "node_id": node_id,
-            "relationship_type": relationship_type,
-            "relationships": [
+        relationships = [
                 {
                     "id": row["id"],
                     "type": row["type"],
@@ -562,15 +583,32 @@ class KnowledgeGraphRetrievalMixin:
                     },
                 }
                 for row in rows
-            ],
+            ]
+        if allowed_workspaces is not None:
+            kept = []
+            for rel in relationships:
+                endpoints = [
+                    {"id": (rel.get("source") or {}).get("id")},
+                    {"id": (rel.get("target") or {}).get("id")},
+                ]
+                if len(self.filter_scoped_nodes(endpoints, allowed_workspaces)) == 2:
+                    kept.append(rel)
+            relationships = kept
+        return {
+            "query": query,
+            "node_id": node_id,
+            "relationship_type": relationship_type,
+            "relationships": relationships,
         }
 
     def traverse(
-        self, node_id: str, *, depth: int = 1, limit: int = 100
+        self, node_id: str, *, depth: int = 1, limit: int = 100, allowed_workspaces=None
     ) -> Dict[str, Any]:
         node_id = str(node_id or "").strip()
         if not node_id:
             raise ValueError("node_id required")
+        if allowed_workspaces is not None and not self.filter_scoped_nodes([{"id": node_id}], allowed_workspaces):
+            raise ValueError(f"graph node not found: {node_id}")
         depth = max(0, min(int(depth or 1), 4))
         limit = max(1, min(int(limit or 100), 500))
         nt, et = self._read_tables()
@@ -617,10 +655,7 @@ class KnowledgeGraphRetrievalMixin:
                     """,
                 list(visited),
             ).fetchall()
-        return {
-            "root": node_id,
-            "depth": depth,
-            "nodes": [
+        nodes = [
                 {
                     "id": row["id"],
                     "type": row["type"],
@@ -630,9 +665,13 @@ class KnowledgeGraphRetrievalMixin:
                     "updated_at": row["updated_at"],
                 }
                 for row in node_rows
-            ],
-            "edges": list(edges_by_id.values()),
-        }
+            ]
+        edges = list(edges_by_id.values())
+        if allowed_workspaces is not None:
+            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            kept = {node.get("id") for node in nodes}
+            edges = [edge for edge in edges if edge.get("from") in kept and edge.get("to") in kept]
+        return {"root": node_id, "depth": depth, "nodes": nodes, "edges": edges}
 
     def _iter_vector_source_items(
         self,

package/lattice_brain/graph/runtime.py

@@ -0,0 +1,16 @@
+"""Runtime hooks for the knowledge graph package."""
+
+from __future__ import annotations
+
+from typing import Any
+
+_llm_router_ref: Any = None
+
+
+def set_llm_router(router_instance: Any) -> None:
+    global _llm_router_ref
+    _llm_router_ref = router_instance
+
+
+def get_llm_router() -> Any:
+    return _llm_router_ref

package/lattice_brain/runtime/multi_agent.py

@@ -21,7 +21,7 @@ from typing import Any, Callable, Dict, List, Optional
 from .contracts import multi_agent_contract
 
 
-MULTI_AGENT_VERSION = "8.8.0"
+MULTI_AGENT_VERSION = "8.9.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "8.8.0"
+__version__ = "8.9.0"

package/latticeai/api/chat.py

@@ -286,6 +286,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
     group_history_conversations = context.group_history_conversations
     get_conversation_messages = context.get_conversation_messages
     conversation_title = context.conversation_title
+    allowed_workspaces_for = context.allowed_workspaces_for
 
     CONFIG = context.config
     CHAT_SERVICE = context.chat_service
@@ -314,6 +315,18 @@ def create_chat_router(context: AppContext) -> APIRouter:
         except Exception as exc:
             logging.warning("chat message bridge failed: %s", exc)
 
+    def history_scope_for_user(user_email: Optional[str]) -> Dict:
+        require_auth = bool(getattr(CONFIG, "require_auth", False))
+        scoped_user = user_email if require_auth else None
+        allowed = None
+        if require_auth and scoped_user and allowed_workspaces_for is not None:
+            allowed = allowed_workspaces_for(scoped_user)
+        return {
+            "user_email": scoped_user,
+            "allowed_workspaces": allowed,
+            "include_legacy_global": not require_auth,
+        }
+
     def recent_chat_context(
         limit: int = 10,
         include_image_missing_replies: bool = True,
@@ -449,14 +462,14 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 except Exception as e:
                     logging.warning("knowledge graph clear event ingest failed: %s", e)
             if command == "/clear_all":
-                result = clear_history(0)
+                result = clear_history(0, **history_scope_for_user(effective_email))
                 answer = f"채팅창을 정리했습니다. 화면에서 제거 {result.get('removed', 0)}개. 감사 로그와 지식 그래프/RAG 데이터는 유지됩니다."
             else:
                 if req.conversation_id:
-                    result = clear_conversation(req.conversation_id)
+                    result = clear_conversation(req.conversation_id, **history_scope_for_user(effective_email))
                     answer = f"현재 대화방 채팅창을 정리했습니다. 화면에서 제거 {result.get('removed', 0)}개. 감사 로그와 지식 그래프/RAG 데이터는 유지됩니다."
                 else:
-                    result = clear_history(0)
+                    result = clear_history(0, **history_scope_for_user(effective_email))
                     answer = f"채팅창을 정리했습니다. 화면에서 제거 {result.get('removed', 0)}개. 감사 로그와 지식 그래프/RAG 데이터는 유지됩니다."
             append_audit_event(
                 "clear_command",
@@ -791,20 +804,20 @@ def create_chat_router(context: AppContext) -> APIRouter:
     @api_router.get("/history")
     async def fetch_history(request: Request):
         """웹 화면에서 이전 대화를 불러올 수 있도록 히스토리를 반환합니다."""
-        require_user(request)
-        return get_history()
+        current_user = require_user(request)
+        return get_history(**history_scope_for_user(current_user))
 
     @api_router.get("/history/conversations")
     async def fetch_history_conversations(request: Request):
         """저장된 히스토리를 대화 단위로 묶어 반환합니다."""
-        require_user(request)
-        return group_history_conversations()
+        current_user = require_user(request)
+        return group_history_conversations(get_history(**history_scope_for_user(current_user)))
 
     @api_router.get("/history/conversations/{conversation_id:path}")
     async def fetch_history_conversation(conversation_id: str, request: Request):
         """선택한 대화의 메시지를 반환합니다."""
-        require_user(request)
-        messages = get_conversation_messages(conversation_id)
+        current_user = require_user(request)
+        messages = get_conversation_messages(conversation_id, **history_scope_for_user(current_user))
         if not messages:
             raise HTTPException(status_code=404, detail="대화를 찾을 수 없습니다.")
         return {"id": conversation_id, "messages": messages}
@@ -814,7 +827,11 @@ def create_chat_router(context: AppContext) -> APIRouter:
     async def delete_history_conversation(conversation_id: str, request: Request):
         """선택한 대화방의 메시지만 삭제합니다."""
         email = require_user(request)
-        result = clear_conversation(conversation_id, request.query_params.get("started_at"))
+        result = clear_conversation(
+            conversation_id,
+            request.query_params.get("started_at"),
+            **history_scope_for_user(email),
+        )
         append_audit_event(
             "conversation_delete",
             user_email=email,
@@ -829,7 +846,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
     @api_router.delete("/history")
     async def delete_history(request: Request, keep_last: int = 0):
         email = require_user(request)
-        result = clear_history(keep_last)
+        result = clear_history(keep_last, **history_scope_for_user(email))
         append_audit_event(
             "history_delete",
             user_email=email,
@@ -842,11 +859,11 @@ def create_chat_router(context: AppContext) -> APIRouter:
     @api_router.get("/history/search")
     async def search_history(q: str, request: Request):
         """키워드로 채팅 히스토리를 검색합니다."""
-        require_user(request)
+        current_user = require_user(request)
         if not q or not q.strip():
             return {"results": [], "query": q}
         q_lower = q.strip().lower()
-        history = get_history()
+        history = get_history(**history_scope_for_user(current_user))
         matches = [item for item in history if q_lower in (item.get("content") or "").lower()]
         grouped: Dict[str, Dict] = {}
         for item in matches:
@@ -991,7 +1008,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
             }
 
         # Auto-approve and run to completion (default behaviour)
-        _AGENT_RUNTIME.approve(ctx, current_user)
+        _AGENT_RUNTIME.approve(ctx, current_user, approved_by_human=True)
         return await _agent_finish(ctx, req, lang_hint, current_user, max_steps, max_retry)
 
     

package/latticeai/api/mcp.py

@@ -30,6 +30,7 @@ from latticeai.core.mcp_registry import (
     SKILLS_DIR,
 )
 from latticeai.core.tool_registry import MCP_TOOL_DESCRIPTIONS
+from latticeai.services.tool_dispatch import enforce_tool_policy
 from tools import AGENT_ROOT, execute_tool
 
 
@@ -392,7 +393,7 @@ def create_mcp_router(
                     args.get("limit", 6),
                 )
             }
-        _check_tool_role(req.action, current_user)
-        return _tool_response(execute_tool, req.action, req.args or {})
+        enforce_tool_policy(req.action, req.args or {}, current_user=current_user, source="mcp")
+        return _tool_response(execute_tool, req.action, req.args or {}, source="mcp")
 
     return router

package/latticeai/api/models.py

@@ -67,6 +67,7 @@ class LoadModelRequest(BaseModel):
 
 class InstallEngineRequest(BaseModel):
     engine: str
+    confirmation_token: Optional[str] = None
 
 
 class SetApiKeyRequest(BaseModel):
@@ -99,7 +100,7 @@ def create_models_router(
     get_current_user: Callable[[Request], Optional[str]],
     load_users: Callable[[], Dict],
     get_user_role: Callable[..., str],
-    install_engine: Callable[[str], Dict],
+    install_engine: Callable[..., Dict],
     verify_cloud_models: Callable[..., Any],
     normalize_local_model_request: Callable[..., str],
     download_hf_model: Callable[..., Dict],
@@ -281,6 +282,8 @@ 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)
 
     @router.post("/engines/verify-cloud")

package/latticeai/api/permissions.py

@@ -30,6 +30,7 @@ class PermissionGateway:
         self.get_current_user = get_current_user
         self.local_approval_ttl_seconds = 5 * 60
         self.local_approval_lock = threading.Lock()
+        self.perm_queue_lock = threading.Lock()
         self.local_approvals: Dict[str, Dict[str, object]] = {}
         self.discord_permission_webhook_url = config.discord_permission_webhook
         self.discord_bot_token = config.discord_bot_token
@@ -37,26 +38,46 @@ class PermissionGateway:
         self.permission_monitor_secret = config.permission_monitor_secret
         self.perm_queue_file = data_dir / "permission_queue.json"
 
+    @staticmethod
+    def token_hash(token: str) -> str:
+        return hashlib.sha256(str(token or "").encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def token_hint(token: str) -> str:
+        value = str(token or "")
+        return value[:8] if value else ""
+
+    def _read_queue(self) -> Dict:
+        if not self.perm_queue_file.exists():
+            return {}
+        try:
+            return json.loads(self.perm_queue_file.read_text(encoding="utf-8"))
+        except Exception:
+            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)
+
     def _perm_queue_write(self, token: str, record: Dict[str, object]) -> None:
         try:
-            queue: Dict = {}
-            if self.perm_queue_file.exists():
-                try:
-                    queue = json.loads(self.perm_queue_file.read_text(encoding="utf-8"))
-                except Exception:
-                    queue = {}
-            queue[token] = {**record, "notified": False}
-            self.perm_queue_file.write_text(json.dumps(queue, ensure_ascii=False, indent=2), encoding="utf-8")
+            key = self.token_hash(token)
+            with self.perm_queue_lock:
+                queue = self._read_queue()
+                queue[key] = {**record, "token_hint": self.token_hint(token), "notified": False}
+                self._write_queue(queue)
         except Exception as exc:
             logging.warning("perm_queue_write failed: %s", exc)
 
     def _perm_queue_remove(self, token: str) -> None:
         try:
-            if not self.perm_queue_file.exists():
-                return
-            queue: Dict = json.loads(self.perm_queue_file.read_text(encoding="utf-8"))
-            queue.pop(token, None)
-            self.perm_queue_file.write_text(json.dumps(queue, ensure_ascii=False, indent=2), encoding="utf-8")
+            key = self.token_hash(token)
+            with self.perm_queue_lock:
+                queue = self._read_queue()
+                queue.pop(key, None)
+                self._write_queue(queue)
         except Exception as exc:
             logging.warning("perm_queue_remove failed: %s", exc)
 
@@ -156,9 +177,10 @@ class PermissionGateway:
             "approved": False,
         }
         if action == "write":
+            self.ensure_path_allowed(path, action="write")
             record["content_hash"] = self.content_fingerprint(content)
         with self.local_approval_lock:
-            self.local_approvals[token] = record
+            self.local_approvals[self.token_hash(token)] = {**record, "token_hint": self.token_hint(token)}
         self._perm_queue_write(token, record)
         action_label = _PERMISSION_ACTION_LABELS.get(action, action)
         return {
@@ -190,12 +212,14 @@ class PermissionGateway:
         if not token:
             raise HTTPException(status_code=403, detail="파일 접근 승인 토큰이 필요합니다.")
         normalized = self.normalize_local_path_for_approval(path)
+        self.ensure_path_allowed(normalized, action=action)
         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)
-            record = self.local_approvals.get(token)
+            record = self.local_approvals.get(key)
         if not record:
             raise HTTPException(status_code=403, detail="파일 접근 승인이 만료되었거나 유효하지 않습니다.")
         if not record.get("approved"):
@@ -213,13 +237,25 @@ class PermissionGateway:
             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(token)
+                record = self.local_approvals.get(key)
             if current_user and record and record.get("user_email") == current_user:
                 return
         self.require_admin(request)
 
+    def ensure_path_allowed(self, path: str, *, action: str) -> None:
+        if action != "write":
+            return
+        normalized = self.normalize_local_path_for_approval(path)
+        from latticeai.services.tool_dispatch import LOCAL_WRITE_BLOCKED_PREFIXES
+
+        for prefix in LOCAL_WRITE_BLOCKED_PREFIXES:
+            normalized_prefix = str(Path(prefix).expanduser()).rstrip("/")
+            if normalized == normalized_prefix or normalized.startswith(normalized_prefix + "/"):
+                raise HTTPException(status_code=403, detail=f"쓰기 금지 경로입니다: {prefix}")
+
 
 def create_permissions_router(
     *,
@@ -243,11 +279,11 @@ def create_permissions_router(
         now = time.time()
         with gateway.local_approval_lock:
             result = {}
-            for tok, rec in list(gateway.local_approvals.items()):
+            for token_hash, rec in list(gateway.local_approvals.items()):
                 expires_at = float(rec.get("expires_at", 0))
                 if expires_at < now:
                     continue
-                result[tok] = {
+                result[str(rec.get("token_hint") or token_hash[:8])] = {
                     "path": rec.get("path"),
                     "action": rec.get("action"),
                     "action_label": _PERMISSION_ACTION_LABELS.get(str(rec.get("action", "")), str(rec.get("action", ""))),
@@ -260,25 +296,26 @@ 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)
         with gateway.local_approval_lock:
-            record = gateway.local_approvals.get(token)
+            record = gateway.local_approvals.get(key)
             if not record:
                 raise HTTPException(status_code=404, detail="토큰이 없거나 만료되었습니다.")
             if float(record.get("expires_at", 0)) < time.time():
-                gateway.local_approvals.pop(token, None)
+                gateway.local_approvals.pop(key, None)
                 raise HTTPException(status_code=410, detail="토큰이 만료되었습니다.")
             record["approved"] = True
         gateway._perm_queue_remove(token)
         logging.info(
             "Permission approved: token=%s path=%s action=%s user=%s",
-            token,
+            gateway.token_hint(token),
             record.get("path"),
             record.get("action"),
             record.get("user_email"),
         )
         return {
             "ok": True,
-            "token": token,
+            "token_hint": gateway.token_hint(token),
             "path": record.get("path"),
             "action": record.get("action"),
             "user_email": record.get("user_email"),
@@ -287,14 +324,15 @@ 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)
         with gateway.local_approval_lock:
-            record = gateway.local_approvals.pop(token, None)
+            record = gateway.local_approvals.pop(key, None)
         gateway._perm_queue_remove(token)
         if not record:
             raise HTTPException(status_code=404, detail="토큰이 없거나 이미 처리되었습니다.")
         logging.info(
             "Permission denied: token=%s path=%s action=%s user=%s",
-            token,
+            gateway.token_hint(token),
             record.get("path"),
             record.get("action"),
             record.get("user_email"),
@@ -302,7 +340,7 @@ def create_permissions_router(
         return {
             "ok": True,
             "denied": True,
-            "token": token,
+            "token_hint": gateway.token_hint(token),
             "path": record.get("path"),
             "action": record.get("action"),
         }
@@ -311,17 +349,18 @@ def create_permissions_router(
     async def permissions_status(token: str, request: Request):
         require_user(request)
         now = time.time()
+        key = gateway.token_hash(token)
         with gateway.local_approval_lock:
-            record = gateway.local_approvals.get(token)
+            record = gateway.local_approvals.get(key)
         if not record:
-            return {"status": "denied_or_expired", "token": token}
+            return {"status": "denied_or_expired", "token_hint": gateway.token_hint(token)}
         if float(record.get("expires_at", 0)) < now:
-            return {"status": "expired", "token": token}
+            return {"status": "expired", "token_hint": gateway.token_hint(token)}
         if record.get("approved"):
-            return {"status": "approved", "token": token}
+            return {"status": "approved", "token_hint": gateway.token_hint(token)}
         return {
             "status": "pending",
-            "token": token,
+            "token_hint": gateway.token_hint(token),
             "expires_in": round(float(record.get("expires_at", 0)) - now),
         }
 

package/latticeai/api/setup.py

@@ -8,6 +8,7 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
+from latticeai.services.process_audit import command_plan
 from auto_setup import (
     plan as auto_setup_plan,
     preset as auto_setup_preset,
@@ -21,6 +22,7 @@ from setup_wizard import get_recommendations, install_stream, open_url, scan_env
 
 class SetupInstallRequest(BaseModel):
     items: List[Dict]
+    confirmation_token: Optional[str] = None
 
 
 def create_setup_router(*, model_router, require_user) -> APIRouter:
@@ -83,11 +85,19 @@ def create_setup_router(*, model_router, require_user) -> APIRouter:
                     command = ["lattice-ai", "models", "load", str(model_id)]
                 else:
                     command = ["huggingface-cli", "download", str(model_id), "--quiet"]
+                step_plan = command_plan(
+                    command,
+                    name=f"weights:{model_id}",
+                    purpose="auto_setup_install",
+                    metadata={"model_id": str(model_id)},
+                )
                 zero_config["plan"]["steps"] = [{
                     "name": f"weights:{model_id}",
                     "why": "추론에 사용할 모델 가중치",
                     "command": command,
                     "requires_admin": False,
+                    "command_plan": step_plan,
+                    "confirmation_token": step_plan["confirmation_token"],
                 }]
             if isinstance(zero_config.get("preset"), dict):
                 zero_config["preset"].setdefault("model", {})["id"] = model_id
@@ -107,9 +117,14 @@ def create_setup_router(*, model_router, require_user) -> APIRouter:
     @api_router.post("/setup/install")
     async def setup_install(req: SetupInstallRequest, request: Request):
         """선택된 항목을 순서대로 설치 · 로드하는 SSE 스트림."""
-        require_user(request)
+        user_email = require_user(request)
         async def _gen():
-            async for chunk in install_stream(req.items, router):
+            async for chunk in install_stream(
+                req.items,
+                router,
+                confirmation_token=req.confirmation_token,
+                user_email=user_email,
+            ):
                 yield chunk
         return StreamingResponse(_gen(), media_type="text/event-stream",
                                  headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})