ltcai 6.3.1 → 6.5.0

package/latticeai/api/knowledge_graph.py

@@ -27,12 +27,32 @@ class KnowledgeGraphIngestRequest(BaseModel):
     metadata: Optional[Dict[str, Any]] = None
 
 
+def _format_context(matches: list, limit: int) -> str:
+    """Mirror ``KnowledgeGraphRetrievalMixin.context_for_query`` formatting for a
+    pre-filtered match list, so scoped callers get identical context lines minus
+    the rows they are not allowed to see."""
+    lines = []
+    for match in matches[:limit]:
+        meta = match.get("metadata") or {}
+        source = (
+            meta.get("relative_path")
+            or meta.get("filename")
+            or meta.get("conversation_id")
+            or meta.get("source")
+            or match.get("id")
+        )
+        summary = " ".join(str(match.get("summary") or "").split())[:700]
+        lines.append(f"- [{match.get('type')}] {match.get('title')} | source={source} | {summary}")
+    return "\n".join(lines)
+
+
 def create_knowledge_graph_router(
     *,
     get_graph: Callable[[], Any],
     require_graph: Callable[[], None],
     require_user: Callable[[Request], str],
     static_dir: Path,
+    allowed_workspaces_for: Optional[Callable[[Optional[str]], Any]] = None,
 ) -> APIRouter:
     router = APIRouter()
 
@@ -40,6 +60,21 @@ def create_knowledge_graph_router(
         require_graph()
         return get_graph()
 
+    def _scoped(request: Request):
+        """Authenticate the caller and resolve their allowed workspace set.
+
+        Returns ``(graph, allowed)``. ``allowed is None`` means no scoping
+        (single-user / no-auth mode); otherwise it is the set of workspace ids
+        the caller may read. Legacy-global rows (no workspace) stay visible —
+        the documented pre-v4 compatibility behavior enforced by
+        ``filter_scoped_nodes``.
+        """
+        user = require_user(request)
+        allowed = None
+        if allowed_workspaces_for is not None and user:
+            allowed = allowed_workspaces_for(user)
+        return graph(), allowed
+
     @router.get("/graph")
     async def knowledge_graph_page(request: Request):
         """Serve the interactive knowledge graph canvas UI."""
@@ -81,8 +116,10 @@ def create_knowledge_graph_router(
 
     @router.get("/knowledge-graph/graph")
     async def knowledge_graph_data(request: Request, limit: int = 300):
-        require_user(request)
-        return graph().graph(limit)
+        kg, allowed = _scoped(request)
+        if allowed is None:
+            return kg.graph(limit)
+        return kg.graph(limit, allowed_workspaces=allowed)
 
     @router.get("/knowledge-graph/documents")
     async def knowledge_graph_documents(request: Request, limit: int = 200):
@@ -91,27 +128,51 @@ def create_knowledge_graph_router(
         Backs the Files view so uploaded content is visible end-to-end:
         upload → Files → Knowledge Graph → Hybrid Search → Chat.
         """
-        require_user(request)
-        return graph().list_documents(limit)
+        kg, allowed = _scoped(request)
+        payload = kg.list_documents(limit)
+        if allowed is not None:
+            documents = kg.filter_scoped_nodes(payload.get("documents", []), allowed)
+            payload = {**payload, "documents": documents, "total": len(documents)}
+        return payload
 
     @router.get("/knowledge-graph/search")
     async def knowledge_graph_search(q: str, request: Request, limit: int = 30):
-        require_user(request)
+        kg, allowed = _scoped(request)
         if not q or not q.strip():
             return {"query": q, "matches": []}
-        return graph().search(q, limit)
+        payload = kg.search(q, limit)
+        if allowed is not None:
+            payload = {**payload, "matches": kg.filter_scoped_nodes(payload.get("matches", []), allowed)}
+        return payload
 
     @router.get("/knowledge-graph/context")
     async def knowledge_graph_context(q: str, request: Request, limit: int = 6):
-        require_user(request)
-        return {"query": q, "context": graph().context_for_query(q, limit)}
+        kg, allowed = _scoped(request)
+        if allowed is None:
+            return {"query": q, "context": kg.context_for_query(q, limit)}
+        # Scoped mode: derive context from scope-filtered search matches so the
+        # RAG context never carries content from workspaces the caller can't read.
+        matches = kg.filter_scoped_nodes(kg.search(q, limit).get("matches", []), allowed)
+        return {"query": q, "context": _format_context(matches, limit)}
 
     @router.get("/knowledge-graph/neighbors/{node_id:path}")
     async def knowledge_graph_neighbors(node_id: str, request: Request):
-        require_user(request)
+        kg, allowed = _scoped(request)
         if not node_id:
             raise HTTPException(status_code=400, detail="node_id required")
-        return graph().neighbors(node_id)
+        if allowed is not None and not kg.filter_scoped_nodes([{"id": node_id}], allowed):
+            raise HTTPException(status_code=404, detail="node not found")
+        payload = kg.neighbors(node_id)
+        if allowed is not None:
+            neighbors = kg.filter_scoped_nodes(payload.get("neighbors", []), allowed)
+            kept = {n.get("id") for n in neighbors}
+            edges = [
+                e for e in payload.get("edges", [])
+                if (e.get("from") == node_id or e.get("from") in kept)
+                and (e.get("to") == node_id or e.get("to") in kept)
+            ]
+            payload = {**payload, "neighbors": neighbors, "edges": edges}
+        return payload
 
     @router.post("/knowledge-graph/ingest")
     async def knowledge_graph_ingest(req: KnowledgeGraphIngestRequest, request: Request):

package/latticeai/api/local_files.py

@@ -48,6 +48,7 @@ def create_local_files_router(
     local_kg_watcher,
     hooks=None,
     data_dir: Optional[Path] = None,
+    allowed_workspaces_for=None,
 ) -> APIRouter:
     router = APIRouter()
 
@@ -210,6 +211,7 @@ def create_local_files_router(
             require_graph=require_graph,
             require_user=require_user,
             static_dir=static_dir,
+            allowed_workspaces_for=allowed_workspaces_for,
         )
     )
 

package/latticeai/api/memory.py

@@ -51,6 +51,12 @@ def create_memory_router(
         scope = gate_read(request)
         return service.manager(user_email=user, workspace_id=scope)
 
+    @router.get("/api/memory/brain-quality")
+    async def brain_quality_summary(request: Request):
+        user = require_user(request)
+        scope = gate_read(request)
+        return service.brain_quality_summary(user_email=user, workspace_id=scope)
+
     @router.get("/api/memory/tiers")
     async def memory_tiers(request: Request):
         require_user(request)
@@ -74,16 +80,16 @@ def create_memory_router(
     @router.post("/api/memory/prune")
     async def memory_prune(req: PruneRequest, request: Request):
         user = require_user(request)
-        gate_write(request)
-        result = service.prune(ids=req.ids, kind=req.kind, user_email=user)
+        scope = gate_write(request)
+        result = service.prune(ids=req.ids, kind=req.kind, user_email=user, workspace_id=scope)
         append_audit_event("memory_prune", user_email=user, count=result.get("count", 0))
         return result
 
     @router.post("/api/memory/compact")
     async def memory_compact(request: Request):
         user = require_user(request)
-        gate_write(request)
-        result = service.compact(user_email=user)
+        scope = gate_write(request)
+        result = service.compact(user_email=user, workspace_id=scope)
         append_audit_event("memory_compact", user_email=user, compacted=result.get("compacted", 0))
         return result
 
@@ -98,9 +104,9 @@ def create_memory_router(
     @router.post("/api/memory/clear")
     async def memory_clear(req: ClearRequest, request: Request):
         user = require_user(request)
-        gate_write(request)
+        scope = gate_write(request)
         try:
-            result = service.clear(scope=req.scope, confirm=req.confirm, user_email=user)
+            result = service.clear(scope=req.scope, confirm=req.confirm, user_email=user, workspace_id=scope)
         except ValueError as exc:
             raise HTTPException(status_code=400, detail=str(exc)) from exc
         append_audit_event("memory_clear", user_email=user, scope=req.scope)

package/latticeai/api/search.py

@@ -51,7 +51,15 @@ class _ScopedSearchService:
     """Injects the caller's workspace scope into every search call —
     enforcement lives at this one chokepoint, not in each handler."""
 
-    _SCOPED = {"keyword_search", "vector_search", "graph_search", "hybrid_search"}
+    _SCOPED = {
+        "keyword_search",
+        "vector_search",
+        "graph_search",
+        "hybrid_search",
+        "graph",
+        "node",
+        "relationships",
+    }
 
     def __init__(self, service: SearchService, allowed):
         self._service = service

package/latticeai/api/tools.py

@@ -202,6 +202,7 @@ def create_tools_router(
     install_mcp=None,
     mcp_public_item=None,
     hooks=None,
+    allowed_workspaces_for=None,
 ) -> APIRouter:
     if tool_context is not None:
         config = tool_context.config
@@ -227,6 +228,7 @@ def create_tools_router(
         install_mcp = tool_context.install_mcp
         mcp_public_item = tool_context.mcp_public_item
         hooks = tool_context.hooks
+        allowed_workspaces_for = tool_context.allowed_workspaces_for
 
     api_router = APIRouter()
     HOOKS = hooks
@@ -486,6 +488,7 @@ def create_tools_router(
         local_kg_watcher=LOCAL_KG_WATCHER,
         hooks=HOOKS,
         data_dir=DATA_DIR,
+        allowed_workspaces_for=allowed_workspaces_for,
     ))
     api_router.include_router(create_computer_use_router(
         model_router=router,

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "6.3.1"
+MARKETPLACE_VERSION = "6.5.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "6.3.1"
+WORKSPACE_OS_VERSION = "6.5.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/runtime/chat_wiring.py

@@ -88,6 +88,7 @@ def build_interaction_contexts(
         install_mcp=install_mcp,
         mcp_public_item=mcp_public_item,
         hooks=hooks,
+        allowed_workspaces_for=allowed_workspaces_for,
     )
     interaction_router_context = InteractionRouterContext(
         chat_context=chat_context,

package/latticeai/services/memory_service.py

@@ -132,9 +132,66 @@ class MemoryService:
             return None
 
     # ── Memory Manager: sources / usage / health ──────────────────────────
+    def _brain_readiness(
+        self,
+        *,
+        memory_count: int,
+        concept_count: Optional[int],
+        relationship_count: Optional[int],
+        healthy_sources: int,
+    ) -> Dict[str, Any]:
+        """Summarize how ready the user's Brain is for the product UI.
+
+        The frontend should render this signal instead of re-deriving it from
+        UI fragments. Keeping it here makes the score auditable and keeps the
+        Memory Manager as the single owner of cross-tier Brain growth signals.
+        """
+        concepts = max(0, int(concept_count or 0))
+        relationships = max(0, int(relationship_count or 0))
+        memories = max(0, int(memory_count or 0))
+        healthy = max(0, int(healthy_sources or 0))
+        score = min(100, round(memories * 12 + concepts * 8 + relationships * 4 + healthy * 3))
+
+        if memories < 1 and concepts < 1:
+            state = "quiet"
+            depth = 2
+            title_key = "brain.readiness.quiet"
+            action_key = "brain.readiness.start"
+            score = max(12, score)
+        elif concepts < 3 or relationships < 2:
+            state = "forming"
+            depth = 3 if concepts < 3 else 4
+            title_key = "brain.readiness.forming"
+            action_key = "brain.readiness.grow"
+            score = max(38, score)
+        else:
+            state = "alive"
+            depth = 5
+            title_key = "brain.readiness.alive"
+            action_key = "brain.readiness.map"
+            score = max(72, score)
+
+        return {
+            "score": score,
+            "state": state,
+            "depth": depth,
+            "title_key": title_key,
+            "action_key": action_key,
+            "signals": {
+                "memory_count": memories,
+                "concept_count": concepts,
+                "relationship_count": relationships,
+                "healthy_sources": healthy,
+            },
+            "source": "memory_service",
+        }
+
     def manager(self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        ws_mem = self._workspace_memories(user_email=user_email, workspace_id="personal")
-        project_mem = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"]
+        ws_mem = self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal")
+        if workspace_id is None:
+            project_mem = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"]
+        else:
+            project_mem = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
         snaps = self._snapshots(workspace_id=workspace_id)
         convs = self._conversations()
         kg_stats = self._kg_stats()
@@ -195,15 +252,27 @@ class MemoryService:
         total_bytes = ws_bytes + kg_bytes + conv_bytes
         healthy = sum(1 for s in sources if s["health"] == "ok")
         overall = "ok" if healthy >= 4 else "degraded" if healthy >= 1 else "unavailable"
+        memory_ids = {m.get("id") for m in [*ws_mem, *project_mem] if m.get("id")}
+        memory_count = len(memory_ids) + len(snaps) + len(convs)
         return {
             "sources": sources,
             "tiers": list(TIERS),
             "usage": {"total_items": total_items, "total_bytes": total_bytes, "sources": len(sources)},
+            "brain_readiness": self._brain_readiness(
+                memory_count=memory_count,
+                concept_count=node_total,
+                relationship_count=edge_total,
+                healthy_sources=healthy,
+            ),
             "health": overall,
             "graph_enabled": self._enable_graph,
             "generated_at": _now(),
         }
 
+    def brain_quality_summary(self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        """Return the backend-owned Brain readiness signal for API consumers."""
+        return self.manager(user_email=user_email, workspace_id=workspace_id)["brain_readiness"]
+
     def tiers(self) -> Dict[str, Any]:
         return {"tiers": list(TIERS), "workspace_kinds": list(WORKSPACE_KINDS)}
 
@@ -268,10 +337,13 @@ class MemoryService:
     # ── inspect a single tier ─────────────────────────────────────────────
     def inspect(self, source: str, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None, limit: int = 50) -> Dict[str, Any]:
         if source == "workspace":
-            items = self._workspace_memories(user_email=user_email, workspace_id="personal")[:limit]
+            items = self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal")[:limit]
             return {"source": source, "items": items, "count": len(items)}
         if source == "project":
-            items = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"][:limit]
+            if workspace_id is None:
+                items = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"][:limit]
+            else:
+                items = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)[:limit]
             return {"source": source, "items": items, "count": len(items)}
         if source == "agent":
             items = self._snapshots(workspace_id=workspace_id)[:limit]
@@ -287,12 +359,39 @@ class MemoryService:
         raise KeyError(source)
 
     # ── mutating operations ───────────────────────────────────────────────
-    def prune(self, *, ids: Optional[List[str]] = None, kind: Optional[str] = None, user_email: Optional[str] = None) -> Dict[str, Any]:
+    def prune(
+        self,
+        *,
+        ids: Optional[List[str]] = None,
+        kind: Optional[str] = None,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        # Ownership guard: a caller may only prune memories they own. Both the
+        # explicit-id and kind paths are intersected with the caller's own
+        # memories, so a forged id for another user's memory is refused, not
+        # silently deleted.
+        owned_ids = {
+            m["id"]
+            for m in self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
+            if m.get("id")
+        }
         removed: List[str] = []
-        target_ids = list(ids or [])
+        skipped: List[str] = []
+        target_ids: List[str] = []
+        seen: set = set()
+        for mid in (ids or []):
+            if mid in seen:
+                continue
+            seen.add(mid)
+            if mid in owned_ids:
+                target_ids.append(mid)
+            else:
+                skipped.append(mid)
         if kind:
-            for m in self._workspace_memories(user_email=user_email, workspace_id=None):
-                if m.get("kind") == kind and m.get("id"):
+            for m in self._workspace_memories(user_email=user_email, workspace_id=workspace_id):
+                if m.get("kind") == kind and m.get("id") and m["id"] not in seen:
+                    seen.add(m["id"])
                     target_ids.append(m["id"])
         for mid in target_ids:
             try:
@@ -300,14 +399,22 @@ class MemoryService:
                 removed.append(mid)
             except Exception:
                 continue
-        return {"removed": removed, "count": len(removed)}
+        result: Dict[str, Any] = {"removed": removed, "count": len(removed)}
+        if skipped:
+            result["skipped"] = skipped
+        return result
 
-    def compact(self, *, user_email: Optional[str] = None) -> Dict[str, Any]:
+    def compact(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
         """Dedupe workspace memories with identical (kind, content)."""
         seen: set = set()
         removed: List[str] = []
         # Oldest first so the first occurrence (oldest) is kept.
-        memories = list(reversed(self._workspace_memories(user_email=user_email, workspace_id=None)))
+        memories = list(reversed(self._workspace_memories(user_email=user_email, workspace_id=workspace_id)))
         for m in memories:
             key = (m.get("kind"), str(m.get("content") or "").strip())
             if key in seen:
@@ -332,21 +439,23 @@ class MemoryService:
                 return {"status": "error", "detail": str(exc)}
         return {"status": "error", "detail": f"Unknown rebuild target: {target}"}
 
-    def clear(self, *, scope: str, confirm: bool = False, user_email: Optional[str] = None) -> Dict[str, Any]:
+    def clear(
+        self,
+        *,
+        scope: str,
+        confirm: bool = False,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
         if not confirm:
             raise ValueError("clear requires confirm=true")
         if scope in WORKSPACE_KINDS:
-            result = self.prune(kind=scope, user_email=user_email)
+            result = self.prune(kind=scope, user_email=user_email, workspace_id=workspace_id)
             return {"cleared": scope, **result}
         if scope == "workspace":
-            ids = [m["id"] for m in self._workspace_memories(user_email=user_email, workspace_id=None) if m.get("id")]
-            result = self.prune(ids=ids, user_email=user_email)
+            ids = [m["id"] for m in self._workspace_memories(user_email=user_email, workspace_id=workspace_id) if m.get("id")]
+            result = self.prune(ids=ids, user_email=user_email, workspace_id=workspace_id)
             return {"cleared": "workspace", **result}
         if scope == "graph":
-            if not self._enable_graph:
-                return {"status": "unavailable", "detail": "Knowledge graph disabled."}
-            try:
-                return {"cleared": "graph", "result": self._kg.clear_all()}
-            except Exception as exc:
-                return {"status": "error", "detail": str(exc)}
+            raise ValueError("graph clear is disabled from Memory Manager because it is not workspace-scoped")
         raise ValueError(f"unsupported clear scope: {scope}")

package/latticeai/services/router_context.py

@@ -34,6 +34,10 @@ class ToolRouterContext:
     install_mcp: Any
     mcp_public_item: Any
     hooks: Any = None
+    # Resolves a caller email to their allowed workspace set (None = no scoping,
+    # i.e. single-user / no-auth mode). Threaded to the knowledge-graph router so
+    # its read endpoints enforce the same workspace boundary as /api/search.
+    allowed_workspaces_for: Any = None
 
 
 @dataclass(frozen=True)

package/latticeai/services/search_service.py

@@ -179,10 +179,12 @@ class SearchService:
         allowed_workspaces=None,
     ) -> 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),
-            "vector": self.vector_search(query, limit=vector_limit),
-            "graph": self.graph_search(query, limit=graph_limit),
+            "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),
         }
         fused: Dict[str, Dict[str, Any]] = {}
         for source, payload in channels.items():
@@ -234,14 +236,50 @@ class SearchService:
             "matches": matches,
         }
 
-    def graph(self, *, limit: int = 300) -> Dict[str, Any]:
-        return self._require_graph().graph(limit=limit)
-
-    def node(self, node_id: str, *, include_neighbors: bool = True, depth: int = 1, limit: int = 100) -> Dict[str, Any]:
+    def graph(self, *, limit: int = 300, allowed_workspaces=None) -> Dict[str, Any]:
         graph = self._require_graph()
-        payload = {"node": graph.get_node(node_id)}
+        try:
+            return graph.graph(limit=limit, allowed_workspaces=allowed_workspaces)
+        except TypeError:
+            payload = graph.graph(limit=limit)
+            if allowed_workspaces is not None:
+                nodes = graph.filter_scoped_nodes(payload.get("nodes", []), allowed_workspaces)
+                kept = {node.get("id") for node in nodes}
+                edges = [
+                    edge for edge in payload.get("edges", [])
+                    if edge.get("from") in kept and edge.get("to") in kept
+                ]
+                payload = {**payload, "nodes": nodes, "edges": edges}
+            return payload
+
+    def node(
+        self,
+        node_id: str,
+        *,
+        include_neighbors: bool = True,
+        depth: int = 1,
+        limit: int = 100,
+        allowed_workspaces=None,
+    ) -> Dict[str, Any]:
+        graph = self._require_graph()
+        node = graph.get_node(node_id)
+        if allowed_workspaces is not None:
+            visible = graph.filter_scoped_nodes([node], allowed_workspaces)
+            if not visible:
+                raise ValueError(f"graph node not found: {node_id}")
+            node = visible[0]
+        payload = {"node": node}
         if include_neighbors:
-            payload["neighborhood"] = graph.traverse(node_id, depth=depth, limit=limit)
+            neighborhood = graph.traverse(node_id, depth=depth, limit=limit)
+            if allowed_workspaces is not None:
+                nodes = graph.filter_scoped_nodes(neighborhood.get("nodes", []), allowed_workspaces)
+                kept = {item.get("id") for item in nodes}
+                edges = [
+                    edge for edge in neighborhood.get("edges", [])
+                    if edge.get("from") in kept and edge.get("to") in kept
+                ]
+                neighborhood = {**neighborhood, "nodes": nodes, "edges": edges}
+            payload["neighborhood"] = neighborhood
         return payload
 
     def relationships(
@@ -251,13 +289,26 @@ class SearchService:
         node_id: str = "",
         relationship_type: str = "",
         limit: int = 30,
+        allowed_workspaces=None,
     ) -> Dict[str, Any]:
-        return self._require_graph().relationship_search(
+        graph = self._require_graph()
+        payload = graph.relationship_search(
             query=query,
             node_id=node_id,
             relationship_type=relationship_type,
             limit=limit,
         )
+        if allowed_workspaces is not None:
+            kept = []
+            for rel in payload.get("relationships", []):
+                endpoints = [
+                    {"id": (rel.get("source") or {}).get("id")},
+                    {"id": (rel.get("target") or {}).get("id")},
+                ]
+                if len(graph.filter_scoped_nodes(endpoints, allowed_workspaces)) == 2:
+                    kept.append(rel)
+            payload = {**payload, "relationships": kept}
+        return payload
 
     def index_status(self) -> Dict[str, Any]:
         return self._require_graph().index_status()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "6.3.1",
+  "version": "6.5.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "6.3.1"
+version = "6.5.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "6.3.1"
+version = "6.5.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "6.3.1",
+  "version": "6.5.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "6.3.1",
+  "version": "6.5.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-t1jx1BR9.js",
-    "assets/index-Div5vMlq.css": "/static/app/assets/index-Div5vMlq.css"
+    "index.html": "/static/app/assets/index-C1J_1441.js",
+    "assets/index-CdCVz_i4.css": "/static/app/assets/index-CdCVz_i4.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-t1jx1BR9.js",
+      "file": "assets/index-C1J_1441.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-Div5vMlq.css"
+        "assets/index-CdCVz_i4.css"
       ]
     }
   }