ltcai 9.0.0 → 9.1.0

package/latticeai/services/search_service.py

@@ -34,34 +34,86 @@ class SearchService:
             raise ValueError("knowledge graph is disabled")
         return self.graph_store
 
-    def _scope(self, matches, allowed_workspaces):
+    def _scope(
+        self,
+        matches,
+        allowed_workspaces,
+        *,
+        include_legacy_global: bool = False,
+    ):
         """Drop matches scoped to workspaces the caller is not a member of
-        (None = no scoping; legacy-global rows stay visible — documented)."""
+        (None = no scoping; legacy-global requires an explicit opt-in)."""
         if allowed_workspaces is None:
             return matches
         graph = self._require_graph()
-        return graph.filter_scoped_nodes(matches, allowed_workspaces)
-
-    def _graph_search(self, graph, query: str, *, limit: int, allowed_workspaces=None):
         try:
-            return graph.search(query, limit, allowed_workspaces=allowed_workspaces)
+            return graph.filter_scoped_nodes(
+                matches,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
+        except TypeError:
+            # Compatibility for pre-opt-in graph implementations.  Rebuild the
+            # policy here instead of invoking their legacy fail-open filter.
+            candidates = list(matches)
+            scopes = graph.workspaces_of(
+                [item.get("id") or item.get("node_id") for item in candidates]
+            )
+            allowed = {str(item) for item in allowed_workspaces if item}
+            visible = []
+            for item in candidates:
+                node_id = str(item.get("id") or item.get("node_id") or "")
+                if not node_id or node_id not in scopes:
+                    continue
+                scope = scopes[node_id]
+                if scope is None and include_legacy_global:
+                    visible.append(item)
+                elif scope is not None and str(scope) in allowed:
+                    visible.append(item)
+            return visible
+
+    def _graph_search(
+        self,
+        graph,
+        query: str,
+        *,
+        limit: int,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ):
+        try:
+            return graph.search(
+                query,
+                limit,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
         except TypeError:
             payload = graph.search(query, limit)
             if allowed_workspaces is not None:
                 payload = {
                     **payload,
-                    "matches": graph.filter_scoped_nodes(
+                    "matches": self._scope(
                         payload.get("matches", []),
                         allowed_workspaces,
+                        include_legacy_global=include_legacy_global,
                     ),
                 }
             return payload
 
-    def _relationship_search(self, graph, *, allowed_workspaces=None, **kwargs):
+    def _relationship_search(
+        self,
+        graph,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+        **kwargs,
+    ):
         try:
             return graph.relationship_search(
                 **kwargs,
                 allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
             )
         except TypeError:
             payload = graph.relationship_search(**kwargs)
@@ -72,25 +124,42 @@ class SearchService:
                         {"id": (rel.get("source") or {}).get("id")},
                         {"id": (rel.get("target") or {}).get("id")},
                     ]
-                    if len(graph.filter_scoped_nodes(endpoints, allowed_workspaces)) == 2:
+                    if len(
+                        self._scope(
+                            endpoints,
+                            allowed_workspaces,
+                            include_legacy_global=include_legacy_global,
+                        )
+                    ) == 2:
                         kept.append(rel)
                 payload = {**payload, "relationships": kept}
             return payload
 
-    def _traverse(self, graph, node_id: str, *, depth: int, limit: int, allowed_workspaces=None):
+    def _traverse(
+        self,
+        graph,
+        node_id: str,
+        *,
+        depth: int,
+        limit: int,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ):
         try:
             return graph.traverse(
                 node_id,
                 depth=depth,
                 limit=limit,
                 allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
             )
         except TypeError:
             neighborhood = graph.traverse(node_id, depth=depth, limit=limit)
             if allowed_workspaces is not None:
-                nodes = graph.filter_scoped_nodes(
+                nodes = self._scope(
                     neighborhood.get("nodes", []),
                     allowed_workspaces,
+                    include_legacy_global=include_legacy_global,
                 )
                 kept = {item.get("id") for item in nodes}
                 edges = [
@@ -100,25 +169,48 @@ class SearchService:
                 neighborhood = {**neighborhood, "nodes": nodes, "edges": edges}
             return neighborhood
 
-    def _get_node(self, graph, node_id: str, *, allowed_workspaces=None):
+    def _get_node(
+        self,
+        graph,
+        node_id: str,
+        *,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ):
         try:
-            return graph.get_node(node_id, allowed_workspaces=allowed_workspaces)
+            return graph.get_node(
+                node_id,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
         except TypeError:
             node = graph.get_node(node_id)
             if allowed_workspaces is not None:
-                visible = graph.filter_scoped_nodes([node], allowed_workspaces)
+                visible = self._scope(
+                    [node],
+                    allowed_workspaces,
+                    include_legacy_global=include_legacy_global,
+                )
                 if not visible:
                     raise ValueError(f"graph node not found: {node_id}")
                 return visible[0]
             return node
 
-    def keyword_search(self, query: str, *, limit: int = 30, allowed_workspaces=None) -> Dict[str, Any]:
+    def keyword_search(
+        self,
+        query: str,
+        *,
+        limit: int = 30,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         graph = self._require_graph()
         payload = self._graph_search(
             graph,
             query,
             limit=limit,
             allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
         )
         matches = []
         for rank, match in enumerate(payload.get("matches", []), start=1):
@@ -136,9 +228,25 @@ class SearchService:
                 "metadata": match.get("metadata") or {},
                 "updated_at": match.get("updated_at"),
             })
-        return {"query": query, "mode": "keyword", "matches": self._scope(matches, allowed_workspaces)}
+        return {
+            "query": query,
+            "mode": "keyword",
+            "matches": self._scope(
+                matches,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            ),
+        }
 
-    def vector_search(self, query: str, *, limit: int = 30, min_score: float = 0.0, allowed_workspaces=None) -> Dict[str, Any]:
+    def vector_search(
+        self,
+        query: str,
+        *,
+        limit: int = 30,
+        min_score: float = 0.0,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         graph = self._require_graph()
         payload = graph.vector_search(query, limit=limit, min_score=min_score)
         matches = []
@@ -163,10 +271,22 @@ class SearchService:
             "mode": "vector",
             "embedding_model": payload.get("embedding_model"),
             "embedding_dim": payload.get("embedding_dim"),
-            "matches": self._scope(matches, allowed_workspaces),
+            "matches": self._scope(
+                matches,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            ),
         }
 
-    def graph_search(self, query: str, *, limit: int = 30, expand_depth: int = 1, allowed_workspaces=None) -> Dict[str, Any]:
+    def graph_search(
+        self,
+        query: str,
+        *,
+        limit: int = 30,
+        expand_depth: int = 1,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         graph = self._require_graph()
         limit = max(1, min(int(limit or 30), 100))
         expand_depth = max(0, min(int(expand_depth or 1), 3))
@@ -175,12 +295,14 @@ class SearchService:
             query,
             limit=max(limit, 10),
             allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
         ).get("matches", [])
         relationships = self._relationship_search(
             graph,
             query=query,
             limit=limit,
             allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
         ).get("relationships", [])
         by_id: Dict[str, Dict[str, Any]] = {}
 
@@ -229,6 +351,7 @@ class SearchService:
                     depth=expand_depth,
                     limit=limit * 3,
                     allowed_workspaces=allowed_workspaces,
+                    include_legacy_global=include_legacy_global,
                 )
             except Exception:
                 neighborhood = {"nodes": [], "edges": []}
@@ -256,7 +379,16 @@ class SearchService:
             match["rank"] = rank
             match["score"] = round(float(match["score"]), 6)
             match["source_scores"]["graph"] = round(float(match["source_scores"]["graph"]), 6)
-        return {"query": query, "mode": "graph", "expand_depth": expand_depth, "matches": self._scope(matches, allowed_workspaces)}
+        return {
+            "query": query,
+            "mode": "graph",
+            "expand_depth": expand_depth,
+            "matches": self._scope(
+                matches,
+                allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            ),
+        }
 
     def hybrid_search(
         self,
@@ -268,14 +400,30 @@ class SearchService:
         graph_limit: int = 30,
         weights: Optional[Mapping[str, float]] = None,
         allowed_workspaces=None,
+        include_legacy_global: bool = False,
     ) -> Dict[str, Any]:
         weights = {**DEFAULT_HYBRID_WEIGHTS, **dict(weights or {})}
         # Scope each channel at the source so out-of-scope rows never enter the
         # fusion set (defense-in-depth — the fused result is re-scoped below too).
         channels = {
-            "keyword": self.keyword_search(query, limit=keyword_limit, allowed_workspaces=allowed_workspaces),
-            "vector": self.vector_search(query, limit=vector_limit, allowed_workspaces=allowed_workspaces),
-            "graph": self.graph_search(query, limit=graph_limit, allowed_workspaces=allowed_workspaces),
+            "keyword": self.keyword_search(
+                query,
+                limit=keyword_limit,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            ),
+            "vector": self.vector_search(
+                query,
+                limit=vector_limit,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            ),
+            "graph": self.graph_search(
+                query,
+                limit=graph_limit,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            ),
         }
         fused: Dict[str, Dict[str, Any]] = {}
         for source, payload in channels.items():
@@ -304,7 +452,11 @@ class SearchService:
                     current.setdefault("graph_context", [])
                     current["graph_context"].extend(result.get("graph_context") or [])
 
-        matches = self._scope(sorted(fused.values(), key=lambda item: item["score"], reverse=True), allowed_workspaces)[: max(1, min(limit, 100))]
+        matches = self._scope(
+            sorted(fused.values(), key=lambda item: item["score"], reverse=True),
+            allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )[: max(1, min(limit, 100))]
         for rank, match in enumerate(matches, start=1):
             match["rank"] = rank
             match["score"] = round(float(match["score"]), 6)
@@ -327,14 +479,28 @@ class SearchService:
             "matches": matches,
         }
 
-    def graph(self, *, limit: int = 300, allowed_workspaces=None) -> Dict[str, Any]:
+    def graph(
+        self,
+        *,
+        limit: int = 300,
+        allowed_workspaces=None,
+        include_legacy_global: bool = False,
+    ) -> Dict[str, Any]:
         graph = self._require_graph()
         try:
-            return graph.graph(limit=limit, allowed_workspaces=allowed_workspaces)
+            return graph.graph(
+                limit=limit,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
         except TypeError:
             payload = graph.graph(limit=limit)
             if allowed_workspaces is not None:
-                nodes = graph.filter_scoped_nodes(payload.get("nodes", []), allowed_workspaces)
+                nodes = self._scope(
+                    payload.get("nodes", []),
+                    allowed_workspaces,
+                    include_legacy_global=include_legacy_global,
+                )
                 kept = {node.get("id") for node in nodes}
                 edges = [
                     edge for edge in payload.get("edges", [])
@@ -351,9 +517,15 @@ class SearchService:
         depth: int = 1,
         limit: int = 100,
         allowed_workspaces=None,
+        include_legacy_global: bool = False,
     ) -> Dict[str, Any]:
         graph = self._require_graph()
-        node = self._get_node(graph, node_id, allowed_workspaces=allowed_workspaces)
+        node = self._get_node(
+            graph,
+            node_id,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )
         payload = {"node": node}
         if include_neighbors:
             neighborhood = self._traverse(
@@ -362,6 +534,7 @@ class SearchService:
                 depth=depth,
                 limit=limit,
                 allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
             )
             payload["neighborhood"] = neighborhood
         return payload
@@ -374,6 +547,7 @@ class SearchService:
         relationship_type: str = "",
         limit: int = 30,
         allowed_workspaces=None,
+        include_legacy_global: bool = False,
     ) -> Dict[str, Any]:
         graph = self._require_graph()
         payload = self._relationship_search(
@@ -383,6 +557,7 @@ class SearchService:
             relationship_type=relationship_type,
             limit=limit,
             allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
         )
         return payload
 

package/latticeai/services/tool_dispatch.py

@@ -20,8 +20,9 @@ from latticeai.core.agent_prompts import (
     MEMORY_UPDATER_PROMPT,
     PLANNER_PROMPT,
 )
+from latticeai.core.policy import role_has_capability
 from latticeai.core.tool_registry import ToolPermission, ToolPolicy
-from tools import AGENT_ROOT, DEFAULT_TOOL_REGISTRY, ToolError, ensure_agent_root
+from latticeai.tools import AGENT_ROOT, DEFAULT_TOOL_REGISTRY, ToolError, ensure_agent_root
 
 
 def _default_load_users() -> Dict[str, Any]:
@@ -36,6 +37,12 @@ FILE_CREATE_ACTIONS = set(DEFAULT_TOOL_REGISTRY.file_create_actions)
 TOOL_GOVERNANCE: Dict[str, ToolPolicy] = dict(DEFAULT_TOOL_REGISTRY.governance)
 TOOL_GOVERNANCE_DEFAULT: ToolPolicy = DEFAULT_TOOL_REGISTRY.default_policy
 ADMIN_ONLY_TOOLS: frozenset[str] = DEFAULT_TOOL_REGISTRY.admin_only_tools
+EXPLICIT_CONSENT_TOOLS: frozenset[str] = frozenset({
+    "local_list",
+    "local_read",
+    "local_write",
+    "read_document",
+})
 LOCAL_WRITE_BLOCKED_PREFIXES = DEFAULT_TOOL_REGISTRY.local_write_blocked_prefixes
 RISK_LEVEL_MAP = DEFAULT_TOOL_REGISTRY.risk_level_map
 
@@ -98,14 +105,22 @@ class ToolDispatchService:
         return self.registry.manifest()
 
     def check_role(self, tool_name: str, current_user: str) -> None:
-        if tool_name not in self.registry.admin_only_tools:
+        admin_only = tool_name in self.registry.admin_only_tools
+        capability = self.policy_for(tool_name, {}).get("capability")
+        if not admin_only and not capability:
             return
         users = self.load_users()
-        if self.get_user_role(current_user, users) != "admin":
+        role = str(self.get_user_role(current_user, users) or "user")
+        if admin_only and role not in {"admin", "owner"}:
             raise HTTPException(
                 status_code=403,
                 detail=f"'{tool_name}' 툴은 관리자 전용입니다.",
             )
+        if capability and not role_has_capability(role, capability):
+            raise HTTPException(
+                status_code=403,
+                detail=f"'{tool_name}' 툴에는 '{capability}' capability가 필요합니다.",
+            )
 
     def user_role(self, current_user: str) -> str:
         users = self.load_users()
@@ -132,6 +147,14 @@ class ToolDispatchService:
         when explicitly excluded from a hardening pass.
         """
         policy = self.policy_for(tool_name, args or {})
+        if source in {"mcp", "plugin"} and tool_name in EXPLICIT_CONSENT_TOOLS:
+            raise HTTPException(
+                status_code=403,
+                detail=(
+                    f"'{tool_name}' requires the dedicated local-file approval flow "
+                    "and cannot run through MCP or plugins."
+                ),
+            )
         if not trusted_admin:
             self.check_role(tool_name, current_user)
         if policy["destructive"] or policy["risk"] == "destructive":
@@ -143,13 +166,13 @@ class ToolDispatchService:
             require_auto_approval
             and not trusted_admin
             and not policy["auto_approve"]
-            and self.user_role(current_user) != "admin"
+            and self.user_role(current_user) not in {"admin", "owner"}
         ):
             raise HTTPException(
                 status_code=403,
                 detail=(
                     f"'{tool_name}' 툴은 명시 승인이 필요합니다. "
-                    "9.0.0에서는 승인 UI가 없는 직접 실행 경로에서 기본 차단됩니다."
+                    "현재 릴리스에서는 승인 UI가 없는 직접 실행 경로에서 기본 차단됩니다."
                 ),
             )
         return policy

package/latticeai/services/triggers.py

@@ -209,13 +209,23 @@ class TriggerService:
     def on_brain_event(self, event: str, payload: Optional[Dict[str, Any]] = None) -> int:
         """Fire workflows whose brain_event trigger matches this ingestion."""
         payload = payload or {}
-        source_type = str(payload.get("source_type") or event.split(".", 1)[-1] or "")
+        source_type = str(payload.get("source_type") or _ingestion_source_type(event, payload) or "")
+        event_workspace = str(payload.get("workspace_id") or "personal").strip()
+        event_user = str(payload.get("user_email") or "").strip().lower()
         fired = 0
         with self._lock:
             state = self._load_state()
             for item in self._triggered_workflows():
                 if item["kind"] != "brain_event":
                     continue
+                workflow_workspace = str(item["workflow"].get("workspace_id") or "personal").strip()
+                workflow_user = str(item["workflow"].get("user_email") or "").strip().lower()
+                if event_workspace != workflow_workspace:
+                    continue
+                # Owned workflows only respond to their owner's ingestion.
+                # Ownerless legacy workflows remain compatible in personal.
+                if workflow_user and workflow_user != event_user:
+                    continue
                 wanted = str(item["config"].get("source_type") or "").strip()
                 if wanted and wanted != source_type:
                     continue
@@ -237,6 +247,8 @@ class TriggerService:
                     "event": event,
                     "source_type": source_type,
                     "node_id": payload.get("node_id"),
+                    "user_email": payload.get("user_email"),
+                    "workspace_id": payload.get("workspace_id"),
                 })
             self._save_state(state)
         return fired
@@ -245,15 +257,37 @@ class TriggerService:
         """A post_tool hook runner: ingestion events fan into triggers."""
         def runner(context):
             event = str(getattr(context, "event", "") or "")
-            if not event.startswith("kg_ingest."):
-                return {"status": "ok", "output": "not an ingestion event"}
             payload = context.payload if isinstance(context.payload, dict) else {}
-            fired = self.on_brain_event(event, payload)
+            source_type = _ingestion_source_type(event, payload)
+            if not source_type:
+                return {"status": "ok", "output": "not an ingestion event"}
+            if str(payload.get("status") or "ok") != "ok":
+                return {"status": "ok", "output": "ignored failed ingestion event"}
+            fired = self.on_brain_event(
+                f"kg_ingest.{source_type}",
+                {
+                    **payload,
+                    "source_type": source_type,
+                    "user_email": getattr(context, "user_email", None) or payload.get("user_email"),
+                    "workspace_id": getattr(context, "workspace_id", None) or payload.get("workspace_id"),
+                },
+            )
             return {"status": "ok", "output": f"fired {fired} workflow trigger(s)"}
         return runner
 
     # ── execution + lifecycle ──────────────────────────────────────────────
     def _fire(self, workflow_id: str, trigger_info: Dict[str, Any]) -> None:
+        try:
+            workflows = list(self._store.load_state().get("workflows") or [])
+            workflow = next((wf for wf in workflows if wf.get("id") == workflow_id), None) or {}
+        except Exception:
+            workflow = {}
+        trigger_info = dict(trigger_info)
+        if not trigger_info.get("user_email"):
+            trigger_info["user_email"] = workflow.get("user_email")
+        if not trigger_info.get("workspace_id"):
+            trigger_info["workspace_id"] = workflow.get("workspace_id")
+
         def _run():
             try:
                 result = self._run_workflow(workflow_id, {"__trigger__": trigger_info})
@@ -285,6 +319,8 @@ class TriggerService:
                 source=source,
                 run_result=result,
                 trigger_info=trigger_info,
+                user_email=trigger_info.get("user_email") or workflow.get("user_email"),
+                workspace_id=trigger_info.get("workspace_id") or workflow.get("workspace_id"),
             )
         except Exception as exc:
             logging.warning("review_sink enqueue failed for %s: %s", workflow_id, exc)
@@ -326,4 +362,17 @@ class TriggerService:
             self._thread.join(timeout=2)
 
 
+def _ingestion_source_type(event: str, payload: Dict[str, Any]) -> str:
+    """Normalize the real dispatch event (``tool.kg_ingest.*``) and legacy form."""
+    tool = str(payload.get("tool") or "").strip()
+    if tool.startswith("kg_ingest."):
+        return tool.removeprefix("kg_ingest.").strip()
+    normalized = str(event or "").strip()
+    if normalized.startswith("tool.kg_ingest."):
+        return normalized.removeprefix("tool.kg_ingest.").strip()
+    if normalized.startswith("kg_ingest."):
+        return normalized.removeprefix("kg_ingest.").strip()
+    return ""
+
+
 __all__ = ["TriggerService", "TRIGGER_HOOK_NAME", "MIN_INTERVAL_SECONDS"]

package/latticeai/services/upload_service.py

@@ -11,7 +11,7 @@ from typing import Optional
 from fastapi import HTTPException, Request, UploadFile
 
 from lattice_brain.ingestion import IngestionItem
-from tools import ToolError, read_document
+from latticeai.tools import ToolError, read_document
 
 
 def _workspace_scope_from_request(request: Request) -> Optional[str]:
@@ -35,9 +35,20 @@ async def process_uploaded_document(
     append_audit_event,
     enforce_rate_limit,
     hooks=None,
+    workspace_service=None,
 ) -> dict:
     enforce_rate_limit(current_user, "upload")
-    workspace_id = _workspace_scope_from_request(request)
+    requested_workspace = _workspace_scope_from_request(request)
+    if workspace_service is not None:
+        try:
+            workspace_id = workspace_service.resolve_write_scope(
+                requested_workspace,
+                current_user or None,
+            )
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
+    else:
+        workspace_id = requested_workspace
     suffix = Path(file.filename or "upload").suffix.lower()
     allowed = {".pdf", ".docx", ".xlsx", ".pptx", ".txt", ".md", ".csv"}
     if suffix not in allowed:

package/latticeai/setup/__init__.py

@@ -0,0 +1,25 @@
+"""Setup services owned by the :mod:`latticeai` package."""
+
+from .auto_setup import (
+    InstallPlan,
+    Recommendation,
+    SystemProfile,
+    plan,
+    preset,
+    probe,
+    recommend,
+    run_all,
+    verify,
+)
+
+__all__ = [
+    "InstallPlan",
+    "Recommendation",
+    "SystemProfile",
+    "plan",
+    "preset",
+    "probe",
+    "recommend",
+    "run_all",
+    "verify",
+]