ltcai 6.3.1 → 6.4.0

package/README.md

@@ -69,42 +69,42 @@ You need Lattice AI when:
 Choose the owner of the Brain. The profile is not a SaaS account by default; it
 is the local identity for the knowledge you keep.
 
-![Login](output/release/v6.3.1/screenshots/01-login.png)
+![Login](output/release/v6.4.0/screenshots/01-login.png)
 
 ### 2. Environment Analysis
 
 See what kind of local AI experience this computer can support before choosing a
 model.
 
-![Environment Analysis](output/release/v6.3.1/screenshots/02-environment-analysis.png)
+![Environment Analysis](output/release/v6.4.0/screenshots/02-environment-analysis.png)
 
 ### 3. Recommended Models
 
 Start with a short list: safest recommendation, faster model, stronger model.
 Advanced details stay available without overwhelming first-time users.
 
-![Recommended Models](output/release/v6.3.1/screenshots/03-recommended-models.png)
+![Recommended Models](output/release/v6.4.0/screenshots/03-recommended-models.png)
 
 ### 4. Install And Load
 
 Download and load only after consent. Lattice explains model size, local
 execution, and network use before work starts.
 
-![Install and Load](output/release/v6.3.1/screenshots/04-install-load-progress.png)
+![Install and Load](output/release/v6.4.0/screenshots/04-install-load-progress.png)
 
 ### 5. Brain Chat
 
 Talk normally. Useful decisions and context become memory, then appear later as
 topics, relationships, and graph structure.
 
-![Brain Chat Home](output/release/v6.3.1/screenshots/05-brain-chat-home.png)
+![Brain Chat Home](output/release/v6.4.0/screenshots/05-brain-chat-home.png)
 
 ### 6. Review Center
 
 Automation results are staged for review before they become durable decisions.
 Snooze, unsnooze, run now, approve, and dismiss actions stay explicit.
 
-![Review Center](output/release/v6.3.1/screenshots/13-review-center.png)
+![Review Center](output/release/v6.4.0/screenshots/13-review-center.png)
 
 ## Brain Depths
 
@@ -120,10 +120,10 @@ The user travels inward from everyday memory to deeper structure:
 
 Walkthrough:
 
-![v6.3.1 Living Brain walkthrough](output/release/v6.3.1/gifs/v6.3.1-living-brain-walkthrough.gif)
+![v6.4.0 Living Brain walkthrough](output/release/v6.4.0/gifs/v6.4.0-living-brain-walkthrough.gif)
 
 Screenshot index and capture notes:
-[output/release/v6.3.1/SCREENSHOT_INDEX.md](output/release/v6.3.1/SCREENSHOT_INDEX.md)
+[output/release/v6.4.0/SCREENSHOT_INDEX.md](output/release/v6.4.0/SCREENSHOT_INDEX.md)
 
 ## Install
 
@@ -200,39 +200,31 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release Preparation
 
-The current development target is **6.3.1 Access Runtime / i18n Follow-up**:
-
-- `App.tsx` now delegates the main Brain and Admin surfaces to focused feature
-  modules instead of owning the full product shell.
-- `ProductFlow.tsx` is an orchestration layer; onboarding screens live in
-  dedicated components, use design-system classes, and avoid inline style
-  layout.
-- Model download consent states download size, storage location, external
-  target, and a "do later" path before any model fetch starts.
-- Admin Console and onboarding copy use the shared i18n map for Korean/English
-  coverage instead of embedding user-facing English in component bodies.
-- Historical root modules now shrink into compatibility shims while runtime
-  code lives under package modules.
-- Interaction/tool router assembly uses typed context objects to reduce
-  app-factory parameter sprawl while preserving route order.
-- Release smoke automation now checks wheel install, npm tgz contents, static
-  assets, and Tauri artifacts after exact-version artifact validation.
-- Brain archive, memory provenance, document ingestion, Review Center Run Now,
-  local model runtime, root-shim smoke, and app-factory review wiring now have
-  dedicated UX/backend hardening coverage for the 6.3 line.
-- Access-control helper closures are extracted from `app_factory.py` into a
-  focused runtime module with direct unit coverage for role lookup, token
-  extraction, user enforcement, admin enforcement, and public user projection.
-- Capture and Review Center copy now route through the shared Korean/English
-  i18n map for tabs, placeholders, action labels, empty states, and feedback.
-
-Expected artifacts for 6.3.1 release must use exact filenames:
-
-- `dist/ltcai-6.3.1-py3-none-any.whl`
-- `dist/ltcai-6.3.1.tar.gz`
-- `ltcai-6.3.1.tgz`
-- `dist/ltcai-6.3.1.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_6.3.1_aarch64.dmg`
+The current development target is **6.4.0 Digital Brain Quality Hardening**:
+
+- `lattice_brain.quality` adds a non-destructive Brain quality layer for
+  embedding fallback labelling, drift/re-index planning, BM25 lexical scoring,
+  hybrid fusion, reranker fallback contracts, memory candidate quality,
+  graph-edge confidence/evidence scoring, structured context guardrails, and
+  retrieval benchmark metrics.
+- Graph/search API reads now carry workspace scope through graph, node,
+  neighborhood, relationship, keyword, vector, graph, and hybrid search paths.
+- Memory Manager prune, compact, and clear operations are scoped to the
+  caller's workspace and owner boundary; unscoped graph clearing from Memory
+  Manager is blocked until a workspace-safe graph delete path exists.
+- Digital Brain quality documentation now records the 6.4.0 baseline, risk
+  register, validation checklist, and intentionally deferred work.
+- The release remains local-first: no automatic web/email/calendar ingestion,
+  no package publishing, no production deployment, and no external reranker or
+  embedding API use without explicit opt-in.
+
+Expected artifacts for 6.4.0 release must use exact filenames:
+
+- `dist/ltcai-6.4.0-py3-none-any.whl`
+- `dist/ltcai-6.4.0.tar.gz`
+- `ltcai-6.4.0.tgz`
+- `dist/ltcai-6.4.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_6.4.0_aarch64.dmg`
 
 Do not upload `dist/*`. Package registry publishing remains owner-run.
 
@@ -251,6 +243,7 @@ Do not upload `dist/*`. Package registry publishing remains owner-run.
 
 | Version | Theme |
 | --- | --- |
+| 6.4.0 | Digital Brain Quality Hardening: workspace-scoped graph/search/memory reads and mutations, Brain quality primitives, structured context guardrails, and retrieval benchmark coverage |
 | 6.3.1 | Access Runtime / i18n Follow-up: app-factory access-control extraction, focused access runtime tests, and Capture/Review Center i18n coverage |
 | 6.3.0 | Product Hardening Completion: Brain archive/provenance/ingestion UX polish, Review Center Run Now contract hardening, local model runtime status, app-factory review wiring, shim smoke, i18n guard, and exact release artifacts |
 | 6.2.0 | Product Decomposition / Release Smoke Automation: App and ProductFlow feature extraction, legacy root shim shrink, model download consent UX, typed router contexts, localized smoke tests, and wheel/npm/static/Tauri release smoke |

package/docs/CHANGELOG.md

@@ -3,6 +3,37 @@
 The top entry is the current release-preparation target. Older entries are
 historical and may describe behavior as it existed at that release.
 
+## [6.4.0] - 2026-06-17
+
+> Digital Brain Quality Hardening. Tightens workspace-scoped Brain retrieval
+> and memory mutation boundaries while adding non-destructive quality primitives
+> for embeddings, retrieval, memory, graph validation, context assembly, and
+> benchmarks.
+
+### Added
+- `lattice_brain.quality` with embedding fallback labelling, drift/re-index
+  planning, BM25 lexical scoring, hybrid fusion, reranker fallback contracts,
+  memory candidate scoring/deduplication/conflict/retention helpers, graph edge
+  confidence/evidence metrics, structured context guardrails, and retrieval
+  benchmark metric calculation.
+- `docs/v6.4/BRAIN_QUALITY_BASELINE.md` documenting the 6.4.0 Digital Brain
+  quality baseline, risk register, validation items, and deferred work.
+- Refreshed README release evidence screenshots and walkthrough GIF under
+  `output/release/v6.4.0/`.
+- Unit coverage for Brain quality primitives and workspace-scoped graph/search
+  and memory-manager mutation boundaries.
+
+### Changed
+- `/api/graph*`, `/knowledge-graph/*`, and hybrid-search service paths now
+  preserve workspace scope across graph, node, neighborhood, relationship,
+  keyword, vector, graph, and hybrid retrieval.
+- Memory Manager prune, compact, and clear operations now intersect requested
+  ids/kinds with the caller's scoped memory set.
+- Memory Manager graph clear is blocked because the existing graph clear path
+  is not workspace-scoped.
+- Package/runtime/static metadata is synchronized to 6.4.0; package publish and
+  deployment remain owner-run only.
+
 ## [6.3.1] - 2026-06-17
 
 > Access Runtime / i18n Follow-up. Closes the next app-factory decomposition

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "6.3.1"
+__version__ = "6.4.0"
 
 __all__ = [
     "AgentRuntime",
@@ -45,6 +45,7 @@ __all__ = [
     "IngestionPipeline",
     "KGPortabilityService",
     "KnowledgeGraphStore",
+    "LatticeBrainQuality",
     "MultiAgentOrchestrator",
     "PostgresConfig",
     "PostgresEngine",
@@ -65,6 +66,7 @@ _LAZY = {
     "ConversationStore": ("conversations", "ConversationStore"),
     "BrainMemory": ("memory", "BrainMemory"),
     "KnowledgeGraphStore": ("graph.store", "KnowledgeGraphStore"),
+    "LatticeBrainQuality": ("quality", "LatticeBrainQuality"),
     "IngestionItem": ("ingestion", "IngestionItem"),
     "IngestionPipeline": ("ingestion", "IngestionPipeline"),
     "KGPortabilityService": ("portability", "KGPortabilityService"),

package/lattice_brain/quality.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+lattice_brain/quality.py
+Pure Python Quality Layer for Lattice Brain (v6.4+ hardening)
+- Does not modify any DB schema or existing APIs
+- Self-contained, dependency-free core (stdlib only)
+"""
+
+from __future__ import annotations
+import math
+import time
+import hashlib
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from collections import defaultdict
+import re
+
+# -----------------------------
+# 1. Embedding Fallback Labelling + Drift/Reindex Plan
+# -----------------------------
+@dataclass
+class EmbeddingLabel:
+    vector_id: str
+    label: str
+    confidence: float
+    drift_score: float = 0.0
+    needs_reindex: bool = False
+
+class EmbeddingFallbackLabeller:
+    """Fallback labelling when primary embedding unavailable + drift detection"""
+
+    def __init__(self, drift_threshold: float = 0.15):
+        self.drift_threshold = drift_threshold
+        self.label_cache: Dict[str, EmbeddingLabel] = {}
+        self.vector_cache: Dict[str, List[float]] = {}
+
+    def label(self, vector_id: str, embedding: Optional[List[float]] = None,
+              metadata: Optional[Dict] = None) -> EmbeddingLabel:
+        if embedding is None:
+            label = "unembedded_fallback"
+            conf = 0.3
+        else:
+            # Simple hash-based pseudo-label for determinism
+            h = hashlib.md5(str(embedding[:4]).encode()).hexdigest()[:8]
+            label = f"emb_cluster_{h}"
+            conf = 0.85
+
+        drift = self._compute_drift(vector_id, embedding)
+        needs_reindex = drift > self.drift_threshold
+
+        el = EmbeddingLabel(vector_id, label, conf, drift, needs_reindex)
+        self.label_cache[vector_id] = el
+        if embedding is not None:
+            self.vector_cache[vector_id] = [float(value) for value in embedding]
+        return el
+
+    def _compute_drift(self, vector_id: str, new_emb: Optional[List[float]]) -> float:
+        old = self.vector_cache.get(vector_id)
+        if old is None or new_emb is None:
+            return 0.0
+        return self._cosine_distance(old, new_emb)
+
+    def _cosine_distance(self, a: List[float], b: List[float]) -> float:
+        if not a or not b or len(a) != len(b):
+            return 1.0
+        dot = sum(x*y for x,y in zip(a,b))
+        na = math.sqrt(sum(x*x for x in a))
+        nb = math.sqrt(sum(x*x for x in b))
+        return 1.0 - (dot / (na*nb + 1e-9))
+
+    def generate_reindex_plan(self) -> List[str]:
+        return [vid for vid, lab in self.label_cache.items() if lab.needs_reindex]
+
+# -----------------------------
+# 2. BM25 Lexical Scoring + Hybrid Fusion + Reranker Interface
+# -----------------------------
+class BM25Scorer:
+    def __init__(self, k1: float = 1.5, b: float = 0.75):
+        self.k1 = k1
+        self.b = b
+        self.doc_freqs: Dict[str, int] = defaultdict(int)
+        self.doc_lens: Dict[str, int] = {}
+        self.corpus_size = 0
+        self.avgdl = 0.0
+
+    def fit(self, corpus: Dict[str, str]):
+        self.corpus_size = len(corpus)
+        total_len = 0
+        for did, text in corpus.items():
+            tokens = self._tokenize(text)
+            self.doc_lens[did] = len(tokens)
+            total_len += len(tokens)
+            for t in set(tokens):
+                self.doc_freqs[t] += 1
+        self.avgdl = total_len / max(1, self.corpus_size)
+
+    def score(self, query: str, doc_id: str, doc_text: str) -> float:
+        tokens = self._tokenize(query)
+        doc_tokens = self._tokenize(doc_text)
+        score = 0.0
+        for t in tokens:
+            if t not in doc_tokens:
+                continue
+            tf = doc_tokens.count(t)
+            df = self.doc_freqs.get(t, 0)
+            idf = math.log((self.corpus_size - df + 0.5) / (df + 0.5) + 1)
+            denom = tf + self.k1 * (1 - self.b + self.b * self.doc_lens.get(doc_id, 0) / self.avgdl)
+            score += idf * tf * (self.k1 + 1) / (denom + 1e-9)
+        return score
+
+    def _tokenize(self, text: str) -> List[str]:
+        return re.findall(r'\w+', text.lower())
+
+class HybridFusion:
+    """Hybrid fusion of lexical (BM25) + vector scores"""
+    def __init__(self, alpha: float = 0.6):
+        self.alpha = alpha  # weight for vector score
+        self.bm25 = BM25Scorer()
+
+    def fuse(self, query: str, candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        # candidates: [{"id": , "text": , "vector_score": }]
+        corpus = {c["id"]: c.get("text", "") for c in candidates}
+        self.bm25.fit(corpus)
+        results = []
+        for c in candidates:
+            lex = self.bm25.score(query, c["id"], c.get("text", ""))
+            vec = c.get("vector_score", 0.5)
+            fused = self.alpha * vec + (1 - self.alpha) * (lex / 10.0)  # normalize rough
+            c["fused_score"] = round(fused, 4)
+            results.append(c)
+        return sorted(results, key=lambda x: x["fused_score"], reverse=True)
+
+class RerankerInterface:
+    """Pluggable reranker interface"""
+    def rerank(self, query: str, candidates: List[Dict], top_k: int = 5) -> List[Dict]:
+        # Default local-safe fallback: preserve fused ordering without making
+        # unearned cross-encoder claims.
+        for c in candidates:
+            c["rerank_score"] = c.get("fused_score", 0.0)
+        return sorted(candidates, key=lambda x: x.get("rerank_score", 0), reverse=True)[:top_k]
+
+# -----------------------------
+# 3. Memory Candidate Extraction / Scoring / Dedupe / Merge / Conflict / Retention
+# -----------------------------
+@dataclass
+class MemoryCandidate:
+    id: str
+    content: str
+    score: float = 0.0
+    source: str = "unknown"
+    timestamp: float = field(default_factory=time.time)
+    conflicts: List[str] = field(default_factory=list)
+
+class MemoryQualityManager:
+    def extract_candidates(self, memories: List[Dict]) -> List[MemoryCandidate]:
+        return [MemoryCandidate(m["id"], m["content"], m.get("score", 0.6), m.get("source", "mem")) for m in memories]
+
+    def score_candidates(self, cands: List[MemoryCandidate], query: str) -> List[MemoryCandidate]:
+        for c in cands:
+            # simple lexical overlap score
+            overlap = sum(1 for w in query.lower().split() if w in c.content.lower())
+            c.score = min(1.0, 0.4 + overlap * 0.15)
+        return sorted(cands, key=lambda x: x.score, reverse=True)
+
+    def dedupe(self, cands: List[MemoryCandidate], threshold: float = 0.85) -> List[MemoryCandidate]:
+        kept = []
+        seen = set()
+        for c in cands:
+            h = hashlib.md5(c.content.encode()).hexdigest()[:16]
+            if h not in seen:
+                seen.add(h)
+                kept.append(c)
+        return kept
+
+    def merge(self, cands: List[MemoryCandidate]) -> List[MemoryCandidate]:
+        # naive merge by content prefix
+        merged = {}
+        for c in cands:
+            key = c.content[:30]
+            if key not in merged or c.score > merged[key].score:
+                merged[key] = c
+        return list(merged.values())
+
+    def detect_conflicts(self, cands: List[MemoryCandidate]) -> List[MemoryCandidate]:
+        # Lightweight local heuristic; LLM conflict classifiers can replace it.
+        for i, c in enumerate(cands):
+            if "not" in c.content.lower() or "반대" in c.content:
+                c.conflicts.append("conflict:possible_negation")
+        return cands
+
+    def apply_retention(self, cands: List[MemoryCandidate], max_age_days: int = 90) -> List[MemoryCandidate]:
+        now = time.time()
+        return [c for c in cands if (now - c.timestamp) < max_age_days * 86400]
+
+# -----------------------------
+# 4. Graph Edge Validation / Confidence / Evidence / Duplicate Merge / Quality Metrics
+# -----------------------------
+@dataclass
+class GraphEdgeQuality:
+    edge_id: str
+    confidence: float
+    evidence_count: int
+    is_duplicate: bool = False
+    quality_score: float = 0.0
+
+class GraphEdgeQualityManager:
+    def validate_edge(self, edge: Dict[str, Any]) -> GraphEdgeQuality:
+        conf = edge.get("confidence", 0.7)
+        ev = len(edge.get("evidence", []))
+        q = min(1.0, conf * 0.75 + min(ev, 5) / 5 * 0.3)
+        return GraphEdgeQuality(edge.get("id", "e0"), conf, ev, quality_score=q)
+
+    def detect_duplicate_edges(self, edges: List[Dict]) -> List[str]:
+        seen = {}
+        dups = []
+        for e in edges:
+            key = (e.get("source"), e.get("target"), e.get("type"))
+            if key in seen:
+                dups.append(e.get("id"))
+            else:
+                seen[key] = e.get("id")
+        return dups
+
+    def merge_duplicate_edges(self, edges: List[Dict]) -> List[Dict]:
+        # keep highest confidence
+        best = {}
+        for e in edges:
+            key = (e.get("source"), e.get("target"), e.get("type"))
+            if key not in best or e.get("confidence", 0) > best[key].get("confidence", 0):
+                best[key] = e
+        return list(best.values())
+
+    def compute_quality_metrics(self, edges: List[Dict]) -> Dict[str, float]:
+        if not edges:
+            return {"avg_conf": 0.0, "avg_evidence": 0.0, "dup_rate": 0.0}
+        confs = [e.get("confidence", 0.5) for e in edges]
+        evs = [len(e.get("evidence", [])) for e in edges]
+        dups = len(self.detect_duplicate_edges(edges))
+        return {
+            "avg_conf": round(sum(confs)/len(confs), 3),
+            "avg_evidence": round(sum(evs)/len(evs), 2),
+            "dup_rate": round(dups / len(edges), 3)
+        }
+
+# -----------------------------
+# 5. Structured Context Assembly + Guardrails
+# -----------------------------
+@dataclass
+class ContextGuardrails:
+    known: bool = True
+    inferred: bool = False
+    stale: bool = False
+    unknown: bool = False
+    confidence: float = 0.8
+    timestamp: float = field(default_factory=time.time)
+    attribution: str = "system"
+
+class StructuredContextAssembler:
+    SECTIONS = ["Facts", "Decisions", "Preferences", "Relationships", "Projects", "Recent Events"]
+
+    def assemble(self, items: List[Dict[str, Any]]) -> Dict[str, List[Dict]]:
+        ctx: Dict[str, List[Dict]] = {s: [] for s in self.SECTIONS}
+        for item in items:
+            section = item.get("section", "Facts")
+            if section not in ctx:
+                section = "Facts"
+            guard = ContextGuardrails(
+                known=item.get("known", True),
+                inferred=item.get("inferred", False),
+                stale=item.get("stale", False),
+                unknown=item.get("unknown", False),
+                confidence=item.get("confidence", 0.75),
+                attribution=item.get("attribution", "user")
+            )
+            item["guardrails"] = guard.__dict__
+            ctx[section].append(item)
+        return ctx
+
+    def apply_guardrails(self, ctx: Dict[str, List[Dict]]) -> Dict[str, List[Dict]]:
+        cleaned = {}
+        for sec, items in ctx.items():
+            cleaned[sec] = [i for i in items if not i.get("guardrails", {}).get("unknown", False)]
+        return cleaned
+
+# -----------------------------
+# 6. Retrieval Benchmark Fixture Runner
+# -----------------------------
+class RetrievalBenchmarkRunner:
+    def __init__(self):
+        self.results: List[Dict] = []
+
+    def run_fixture(self, fixture_name: str, queries: List[Any], top_k: int = 5) -> Dict[str, Any]:
+        start = time.time()
+        judged = [q for q in queries if isinstance(q, dict)]
+        if judged:
+            recalls = []
+            precisions = []
+            ndcgs = []
+            for query in judged:
+                relevant = set(query.get("relevant") or [])
+                retrieved = list(query.get("retrieved") or [])[:top_k]
+                if not relevant:
+                    continue
+                hits = [doc_id for doc_id in retrieved if doc_id in relevant]
+                recalls.append(len(hits) / len(relevant))
+                precisions.append(len(hits) / max(1, len(retrieved)))
+                dcg = sum(
+                    1.0 / math.log2(rank + 2)
+                    for rank, doc_id in enumerate(retrieved)
+                    if doc_id in relevant
+                )
+                ideal = sum(1.0 / math.log2(rank + 2) for rank in range(min(len(relevant), top_k)))
+                ndcgs.append(dcg / ideal if ideal else 0.0)
+            recall = sum(recalls) / len(recalls) if recalls else 0.0
+            precision = sum(precisions) / len(precisions) if precisions else 0.0
+            ndcg = sum(ndcgs) / len(ndcgs) if ndcgs else 0.0
+        else:
+            recall = precision = ndcg = 0.0
+        metrics = {
+            "fixture": fixture_name,
+            "queries": len(queries),
+            "avg_latency_ms": round((time.time() - start) * 1000 / max(1, len(queries)), 2),
+            "recall@5": round(recall, 4),
+            "precision@5": round(precision, 4),
+            "ndcg@5": round(ndcg, 4),
+            "top_k": top_k,
+            "judged": len(judged),
+        }
+        self.results.append(metrics)
+        return metrics
+
+    def summary(self) -> Dict[str, Any]:
+        if not self.results:
+            return {"status": "no runs"}
+        return {
+            "total_runs": len(self.results),
+            "avg_recall": round(sum(r["recall@5"] for r in self.results) / len(self.results), 3)
+        }
+
+# -----------------------------
+# Main Quality Layer Facade
+# -----------------------------
+class LatticeBrainQuality:
+    """Main entry point - pure Python quality hardening layer"""
+    def __init__(self):
+        self.embed_labeller = EmbeddingFallbackLabeller()
+        self.hybrid = HybridFusion()
+        self.reranker = RerankerInterface()
+        self.memory_mgr = MemoryQualityManager()
+        self.graph_mgr = GraphEdgeQualityManager()
+        self.context_assembler = StructuredContextAssembler()
+        self.benchmark = RetrievalBenchmarkRunner()
+
+    def full_quality_pass(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """End-to-end quality pipeline (non-destructive)"""
+        result = {"status": "ok", "timestamp": time.time()}
+
+        # embedding
+        if "embeddings" in payload:
+            labels = [self.embed_labeller.label(e["id"], e.get("vector")) for e in payload["embeddings"]]
+            result["embedding_labels"] = [label.__dict__ for label in labels]
+            result["reindex_plan"] = self.embed_labeller.generate_reindex_plan()
+
+        # hybrid retrieval
+        if "retrieval" in payload:
+            fused = self.hybrid.fuse(payload["retrieval"]["query"], payload["retrieval"]["candidates"])
+            reranked = self.reranker.rerank(payload["retrieval"]["query"], fused)
+            result["retrieval"] = {"fused": fused, "reranked": reranked}
+
+        # memory
+        if "memories" in payload:
+            cands = self.memory_mgr.extract_candidates(payload["memories"])
+            cands = self.memory_mgr.score_candidates(cands, payload.get("query", ""))
+            cands = self.memory_mgr.dedupe(cands)
+            cands = self.memory_mgr.merge(cands)
+            cands = self.memory_mgr.detect_conflicts(cands)
+            cands = self.memory_mgr.apply_retention(cands)
+            result["memory_candidates"] = [c.__dict__ for c in cands]
+
+        # graph
+        if "graph_edges" in payload:
+            eqs = [self.graph_mgr.validate_edge(e) for e in payload["graph_edges"]]
+            result["graph_quality"] = [q.__dict__ for q in eqs]
+            result["graph_metrics"] = self.graph_mgr.compute_quality_metrics(payload["graph_edges"])
+
+        # context
+        if "context_items" in payload:
+            ctx = self.context_assembler.assemble(payload["context_items"])
+            ctx = self.context_assembler.apply_guardrails(ctx)
+            result["structured_context"] = ctx
+
+        return result
+
+
+__all__ = [
+    "BM25Scorer",
+    "ContextGuardrails",
+    "EmbeddingFallbackLabeller",
+    "EmbeddingLabel",
+    "GraphEdgeQuality",
+    "GraphEdgeQualityManager",
+    "HybridFusion",
+    "LatticeBrainQuality",
+    "MemoryCandidate",
+    "MemoryQualityManager",
+    "RetrievalBenchmarkRunner",
+    "RerankerInterface",
+    "StructuredContextAssembler",
+]

package/lattice_brain/runtime/multi_agent.py

@@ -19,7 +19,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "6.3.1"
+MULTI_AGENT_VERSION = "6.4.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__ = "6.3.1"
+__version__ = "6.4.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

@@ -74,16 +74,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 +98,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.4.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.4.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

@@ -133,8 +133,11 @@ class MemoryService:
 
     # ── Memory Manager: sources / usage / health ──────────────────────────
     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()
@@ -268,10 +271,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 +293,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 +333,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 +373,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.4.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.4.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

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

package/static/app/asset-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "6.3.1",
+  "version": "6.4.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"