ltcai 6.5.0 → 6.7.0

package/latticeai/services/memory_service.py

@@ -115,6 +115,26 @@ class MemoryService:
             return data
         return []
 
+    def _scoped_conversations(self, *, user_email: Optional[str], workspace_id: Optional[str]) -> List[Dict[str, Any]]:
+        if not user_email:
+            return self._conversations()
+        target_workspace = workspace_id or "personal"
+        scoped: List[Dict[str, Any]] = []
+        for conversation in self._conversations():
+            messages = conversation.get("messages") or []
+            if not isinstance(messages, list):
+                continue
+            kept = [
+                message
+                for message in messages
+                if isinstance(message, dict)
+                and message.get("user_email") == user_email
+                and (message.get("workspace_id") or "personal") == target_workspace
+            ]
+            if kept:
+                scoped.append({**conversation, "messages": kept})
+        return scoped
+
     def _kg_stats(self) -> Optional[Dict[str, Any]]:
         if not self._enable_graph:
             return None
@@ -193,7 +213,7 @@ class MemoryService:
         else:
             project_mem = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
         snaps = self._snapshots(workspace_id=workspace_id)
-        convs = self._conversations()
+        convs = self._scoped_conversations(user_email=user_email, workspace_id=workspace_id)
         kg_stats = self._kg_stats()
         kg_index = self._kg_index()
 
@@ -273,6 +293,106 @@ class MemoryService:
         """Return the backend-owned Brain readiness signal for API consumers."""
         return self.manager(user_email=user_email, workspace_id=workspace_id)["brain_readiness"]
 
+    def brain_proof(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        active_model: Optional[str] = None,
+        recall_query: str = "",
+        limit: int = 3,
+    ) -> Dict[str, Any]:
+        """Return the proof points that make Brain feel model-independent.
+
+        This is intentionally backend-owned instead of UI-derived: the first-run
+        Brain screen needs to show the durable stores it can actually recall
+        from, and the model continuity claim must be independent from whichever
+        LLM is currently loaded.
+        """
+        manager = self.manager(user_email=user_email, workspace_id=workspace_id)
+        sources = {str(source.get("id")): source for source in manager.get("sources", []) if isinstance(source, dict)}
+        readiness = manager.get("brain_readiness") or {}
+        conversation_count = int(sources.get("conversation", {}).get("count") or 0)
+        workspace_count = int(sources.get("workspace", {}).get("count") or 0)
+        graph_count = int(sources.get("graph", {}).get("count") or 0)
+        vector_count = int(sources.get("vector", {}).get("count") or 0)
+        query = recall_query.strip() or self._latest_recall_query(user_email=user_email, workspace_id=workspace_id)
+        recall = self.recall(query, user_email=user_email, workspace_id=workspace_id, limit=limit) if query else {"query": "", "results": [], "count": 0, "source": "live"}
+        recall_items = [
+            {
+                "id": item.get("id"),
+                "source": item.get("source"),
+                "title": item.get("title"),
+                "snippet": item.get("snippet"),
+                "score": item.get("score", 0),
+            }
+            for item in recall.get("results", [])[: max(1, min(limit, 8))]
+        ]
+        durable_items = workspace_count + conversation_count + graph_count
+        # Capability and proof are deliberately separated. The brain is
+        # architecturally model-independent, so the capability is always true.
+        # The proof stays false until there is durable evidence on disk.
+        has_durable_evidence = durable_items > 0
+        proven_continuity = has_durable_evidence
+        return {
+            "status": readiness.get("state") or "quiet",
+            "readiness": readiness,
+            "model_continuity": {
+                "active_model": active_model or "",
+                "brain_owner": "lattice_brain",
+                # Design capability: the brain is built to outlive any model.
+                "capability": True,
+                # Proof: only true when durable evidence exists to recall.
+                "survives_model_switch": proven_continuity,
+                "proven": proven_continuity,
+                "context_store": "workspace + conversation + graph + vector",
+            },
+            "proofs": {
+                "durable_items": durable_items,
+                "has_durable_evidence": has_durable_evidence,
+                "workspace_memories": workspace_count,
+                "conversations": conversation_count,
+                "graph_concepts": graph_count,
+                "vector_items": vector_count,
+                "healthy_sources": readiness.get("signals", {}).get("healthy_sources", 0),
+            },
+            "recall": {
+                "query": recall.get("query") or query,
+                "items": recall_items,
+                "count": recall.get("count", 0),
+            },
+            "claims": {
+                "can_recall_user_context": bool(recall_items or durable_items > 0),
+                # Proven, not asserted: no durable evidence means no continuity claim.
+                "keeps_context_across_models": proven_continuity,
+                "is_knowledge_store": bool(graph_count or vector_count or workspace_count or conversation_count),
+            },
+            "generated_at": _now(),
+        }
+
+    def _latest_recall_query(self, *, user_email: Optional[str], workspace_id: Optional[str]) -> str:
+        for memory in self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal"):
+            content = str(memory.get("content") or "").strip()
+            if content:
+                return content[:96]
+        for conversation in self._conversations():
+            messages = conversation.get("messages") or []
+            if not isinstance(messages, list):
+                continue
+            for message in reversed(messages[-8:]):
+                if not isinstance(message, dict):
+                    continue
+                if user_email and message.get("user_email") != user_email:
+                    continue
+                message_workspace = message.get("workspace_id") or "personal"
+                target_workspace = workspace_id or "personal"
+                if message_workspace != target_workspace:
+                    continue
+                content = str(message.get("content") or "").strip()
+                if content:
+                    return content[:96]
+        return ""
+
     def tiers(self) -> Dict[str, Any]:
         return {"tiers": list(TIERS), "workspace_kinds": list(WORKSPACE_KINDS)}
 
@@ -349,7 +469,7 @@ class MemoryService:
             items = self._snapshots(workspace_id=workspace_id)[:limit]
             return {"source": source, "items": items, "count": len(items)}
         if source == "conversation":
-            convs = self._conversations()
+            convs = self._scoped_conversations(user_email=user_email, workspace_id=workspace_id)
             items = [{"id": c.get("id"), "title": c.get("title") or c.get("id"), "messages": len(c.get("messages") or [])} for c in convs[:limit]]
             return {"source": source, "items": items, "count": len(convs)}
         if source == "graph":

package/latticeai/services/router_context.py

@@ -54,3 +54,4 @@ class InteractionRouterContext:
     agent_registry: Any
     memory_service: Any
     platform: Any
+    active_model_getter: Any = None

package/latticeai/services/upload_service.py

@@ -6,6 +6,7 @@ import logging
 import tempfile
 from datetime import datetime
 from pathlib import Path
+from typing import Optional
 
 from fastapi import HTTPException, Request, UploadFile
 
@@ -13,6 +14,14 @@ from lattice_brain.ingestion import IngestionItem
 from tools import ToolError, read_document
 
 
+def _workspace_scope_from_request(request: Request) -> Optional[str]:
+    header = request.headers.get("X-Workspace-Id")
+    if header and header.strip():
+        return header.strip()
+    query = request.query_params.get("workspace_id")
+    return query.strip() if query and query.strip() else None
+
+
 async def process_uploaded_document(
     *,
     request: Request,
@@ -28,6 +37,7 @@ async def process_uploaded_document(
     hooks=None,
 ) -> dict:
     enforce_rate_limit(current_user, "upload")
+    workspace_id = _workspace_scope_from_request(request)
     suffix = Path(file.filename or "upload").suffix.lower()
     allowed = {".pdf", ".docx", ".xlsx", ".pptx", ".txt", ".md", ".csv"}
     if suffix not in allowed:
@@ -83,6 +93,7 @@ async def process_uploaded_document(
                         path=tmp_path,
                         mime_type=file.content_type,
                         owner=current_user,
+                        workspace_id=workspace_id,
                         conversation_id=request.query_params.get("conversation_id"),
                         metadata={"extracted": result},
                     ),
@@ -101,6 +112,7 @@ async def process_uploaded_document(
                     original_filename=file.filename,
                     mime_type=file.content_type,
                     uploader=current_user,
+                    workspace_id=workspace_id,
                     conversation_id=request.query_params.get("conversation_id"),
                     extracted=result,
                 )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "6.5.0",
+  "version": "6.7.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.5.0"
+version = "6.7.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "6.5.0"
+version = "6.7.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.5.0",
+  "version": "6.7.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,13 +1,20 @@
 {
-  "version": "6.5.0",
+  "version": "6.7.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-C1J_1441.js",
-    "assets/index-CdCVz_i4.css": "/static/app/assets/index-CdCVz_i4.css"
+    "_primitives-Bcm5lZRu.js": "/static/app/assets/primitives-Bcm5lZRu.js",
+    "_textarea-C2PLu6_O.js": "/static/app/assets/textarea-C2PLu6_O.js",
+    "index.html": "/static/app/assets/index-C950aES_.js",
+    "assets/index-ztppMg0c.css": "/static/app/assets/index-ztppMg0c.css",
+    "src/pages/Act.tsx": "/static/app/assets/Act-DGN37eR4.js",
+    "src/pages/Brain.tsx": "/static/app/assets/Brain-HDcIwPHW.js",
+    "src/pages/Capture.tsx": "/static/app/assets/Capture--eZfb_Ex.js",
+    "src/pages/Library.tsx": "/static/app/assets/Library-BbagRFyd.js",
+    "src/pages/System.tsx": "/static/app/assets/System-C6pd3Mp_.js"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -16,16 +23,87 @@
       "src": "../node_modules/@tauri-apps/api/core.js",
       "isDynamicEntry": true
     },
+    "_primitives-Bcm5lZRu.js": {
+      "file": "assets/primitives-Bcm5lZRu.js",
+      "name": "primitives",
+      "imports": [
+        "index.html"
+      ]
+    },
+    "_textarea-C2PLu6_O.js": {
+      "file": "assets/textarea-C2PLu6_O.js",
+      "name": "textarea",
+      "imports": [
+        "index.html"
+      ]
+    },
     "index.html": {
-      "file": "assets/index-C1J_1441.js",
+      "file": "assets/index-C950aES_.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
       "dynamicImports": [
-        "../node_modules/@tauri-apps/api/core.js"
+        "../node_modules/@tauri-apps/api/core.js",
+        "src/pages/Act.tsx",
+        "src/pages/Brain.tsx",
+        "src/pages/Capture.tsx",
+        "src/pages/Library.tsx",
+        "src/pages/System.tsx"
       ],
       "css": [
-        "assets/index-CdCVz_i4.css"
+        "assets/index-ztppMg0c.css"
+      ]
+    },
+    "src/pages/Act.tsx": {
+      "file": "assets/Act-DGN37eR4.js",
+      "name": "Act",
+      "src": "src/pages/Act.tsx",
+      "isDynamicEntry": true,
+      "imports": [
+        "index.html",
+        "_primitives-Bcm5lZRu.js",
+        "_textarea-C2PLu6_O.js"
+      ]
+    },
+    "src/pages/Brain.tsx": {
+      "file": "assets/Brain-HDcIwPHW.js",
+      "name": "Brain",
+      "src": "src/pages/Brain.tsx",
+      "isDynamicEntry": true,
+      "imports": [
+        "index.html",
+        "_primitives-Bcm5lZRu.js",
+        "_textarea-C2PLu6_O.js"
+      ]
+    },
+    "src/pages/Capture.tsx": {
+      "file": "assets/Capture--eZfb_Ex.js",
+      "name": "Capture",
+      "src": "src/pages/Capture.tsx",
+      "isDynamicEntry": true,
+      "imports": [
+        "index.html",
+        "_primitives-Bcm5lZRu.js"
+      ]
+    },
+    "src/pages/Library.tsx": {
+      "file": "assets/Library-BbagRFyd.js",
+      "name": "Library",
+      "src": "src/pages/Library.tsx",
+      "isDynamicEntry": true,
+      "imports": [
+        "index.html",
+        "_primitives-Bcm5lZRu.js"
+      ]
+    },
+    "src/pages/System.tsx": {
+      "file": "assets/System-C6pd3Mp_.js",
+      "name": "System",
+      "src": "src/pages/System.tsx",
+      "isDynamicEntry": true,
+      "imports": [
+        "index.html",
+        "_primitives-Bcm5lZRu.js"
       ]
     }
   }