ltcai 6.4.0 → 6.6.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
@@ -132,6 +152,60 @@ 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=workspace_id or "personal")
         if workspace_id is None:
@@ -139,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()
 
@@ -198,15 +272,127 @@ 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 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)}
 
@@ -283,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.4.0",
+  "version": "6.6.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.4.0"
+version = "6.6.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

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

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "6.4.0",
+  "version": "6.6.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-CbvcAQ6B.js",
+    "assets/index-C8toxDpv.css": "/static/app/assets/index-C8toxDpv.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-CbvcAQ6B.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-C8toxDpv.css"
       ]
     }
   }