ltcai 6.3.0 → 6.4.0

package/frontend/src/pages/Capture.tsx

@@ -6,28 +6,30 @@ import { ActionButton, DataPanel, EntityList, OperationResult, StructuredView, T
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
 import { Input } from "@/components/ui/input";
+import { t, type Language } from "@/i18n";
 import { asArray } from "@/lib/utils";
+import { useAppStore } from "@/store/appStore";
 
 type CaptureTab = "files" | "local" | "browser" | "pipeline";
 
-const tabs: Array<{ id: CaptureTab; label: string }> = [
-  { id: "files", label: "Files" },
-  { id: "local", label: "Folders" },
-  { id: "browser", label: "Web" },
-  { id: "pipeline", label: "Flow" },
-];
-
 export function CapturePage({ initialTab }: { initialTab?: string }) {
+  const language = useAppStore((state) => state.language);
   const [tab, setTab] = React.useState<CaptureTab>((initialTab as CaptureTab) || "files");
+  const tabs: Array<{ id: CaptureTab; label: string }> = [
+    { id: "files", label: t(language, "capture.tab.files") },
+    { id: "local", label: t(language, "capture.tab.local") },
+    { id: "browser", label: t(language, "capture.tab.browser") },
+    { id: "pipeline", label: t(language, "capture.tab.pipeline") },
+  ];
   React.useEffect(() => {
     if (initialTab === "pipeline" || initialTab === "local" || initialTab === "files") setTab(initialTab);
   }, [initialTab]);
   return (
     <div className="space-y-5">
       <header className="page-hero">
-        <div className="page-kicker"><Upload className="h-4 w-4" /> Add</div>
-        <h1 className="page-title">Feed the brain what matters.</h1>
-        <p className="page-copy">Drop in files, connect folders, or save a page. Lattice remembers the origin of every idea it learns.</p>
+        <div className="page-kicker"><Upload className="h-4 w-4" /> {t(language, "capture.kicker")}</div>
+        <h1 className="page-title">{t(language, "capture.title")}</h1>
+        <p className="page-copy">{t(language, "capture.body")}</p>
       </header>
       <Tabs tabs={tabs} value={tab} onChange={(id) => setTab(id as CaptureTab)} />
       {tab === "files" ? <FilesPanel /> : null}
@@ -39,6 +41,7 @@ export function CapturePage({ initialTab }: { initialTab?: string }) {
 }
 
 function FilesPanel() {
+  const language = useAppStore((state) => state.language);
   const qc = useQueryClient();
   const docs = useQuery({ queryKey: ["documents"], queryFn: () => latticeApi.documents(200) });
   const [queue, setQueue] = React.useState<UploadQueueItem[]>([]);
@@ -59,8 +62,8 @@ function FilesPanel() {
     <div className="grid gap-4 xl:grid-cols-[0.75fr_1.25fr]">
       <Card>
         <CardHeader>
-          <CardTitle className="flex items-center gap-2"><Upload className="h-4 w-4" /> Add documents</CardTitle>
-          <CardDescription>Choose files and Lattice will prepare them for search and memory.</CardDescription>
+          <CardTitle className="flex items-center gap-2"><Upload className="h-4 w-4" /> {t(language, "capture.files.title")}</CardTitle>
+          <CardDescription>{t(language, "capture.files.description")}</CardDescription>
         </CardHeader>
         <CardContent>
           <label
@@ -72,19 +75,19 @@ function FilesPanel() {
             }}
           >
             <Upload className="h-7 w-7 text-primary" />
-            <span className="text-lg font-semibold">Drop files or choose documents</span>
-            <span className="max-w-sm text-sm leading-6 text-muted-foreground">Each file is queued, parsed, written to Memory, and linked into the Brain graph with source metadata.</span>
+            <span className="text-lg font-semibold">{t(language, "capture.files.drop")}</span>
+            <span className="max-w-sm text-sm leading-6 text-muted-foreground">{t(language, "capture.files.dropDetail")}</span>
             <input type="file" multiple className="sr-only" onChange={(e) => e.target.files && beginUpload(e.target.files)} />
           </label>
           <DocumentUploadQueue queue={queue} onRetry={(file) => beginUpload([file])} />
         </CardContent>
       </Card>
-      <DataPanel title="Uploaded documents" result={docs.data}>
+      <DataPanel title={t(language, "capture.files.uploaded")} result={docs.data}>
         {(data) => (
           <div className="space-y-3">
             <EntityList items={(data as Record<string, unknown>).documents || data} titleKey="filename" metaKey="ingest_state" limit={12} />
             <div className="rounded-md border border-border bg-background/55 p-3 text-sm text-muted-foreground">
-              Completed uploads appear here after they enter Memory. Graph links may continue building briefly after parsing finishes.
+              {t(language, "capture.files.completed")}
             </div>
           </div>
         )}
@@ -122,11 +125,12 @@ async function uploadFiles(files: File[], setQueue: React.Dispatch<React.SetStat
 }
 
 function DocumentUploadQueue({ queue, onRetry }: { queue: UploadQueueItem[]; onRetry: (file: File) => void }) {
+  const language = useAppStore((state) => state.language);
   if (!queue.length) return null;
   return (
     <div className="mt-4 space-y-2">
       {queue.map((item) => {
-        const detail = uploadResultDetail(item);
+        const detail = uploadResultDetail(item, language);
         return (
           <div key={item.id} className="rounded-md border border-border bg-background/55 p-3 text-sm">
             <div className="flex flex-wrap items-start justify-between gap-3">
@@ -141,11 +145,11 @@ function DocumentUploadQueue({ queue, onRetry }: { queue: UploadQueueItem[]; onR
               </div>
               {item.status === "failed" ? (
                 <Button size="sm" variant="outline" onClick={() => onRetry(item.file)}>
-                  <RotateCcw className="h-3.5 w-3.5" /> Retry
+                  <RotateCcw className="h-3.5 w-3.5" /> {t(language, "capture.retry")}
                 </Button>
               ) : null}
             </div>
-            {item.result ? <OperationResult result={item.result} successLabel="Entered Brain and graph queue" /> : null}
+            {item.result ? <OperationResult result={item.result} successLabel={t(language, "capture.files.success")} /> : null}
           </div>
         );
       })}
@@ -153,16 +157,17 @@ function DocumentUploadQueue({ queue, onRetry }: { queue: UploadQueueItem[]; onR
   );
 }
 
-function uploadResultDetail(item: UploadQueueItem) {
-  if (item.status === "queued") return "Waiting in the ingest queue";
-  if (item.status === "uploading") return "Parsing and sending to Memory";
-  if (!item.result?.ok) return item.result?.error || "Ingest failed before it entered the Brain";
+function uploadResultDetail(item: UploadQueueItem, language: Language) {
+  if (item.status === "queued") return t(language, "capture.files.queued");
+  if (item.status === "uploading") return t(language, "capture.files.uploading");
+  if (!item.result?.ok) return item.result?.error || t(language, "capture.files.failed");
   const data = item.result.data || {};
   const node = String(data.node_id || data.graph_node || data.provenance_id || "");
-  return node ? `Captured with source metadata · ${node}` : "Captured with source metadata";
+  return node ? t(language, "capture.files.capturedWithNode", { node }) : t(language, "capture.files.captured");
 }
 
 function LocalPanel() {
+  const language = useAppStore((state) => state.language);
   const qc = useQueryClient();
   const [path, setPath] = React.useState("");
   const local = useQuery({ queryKey: ["localSources"], queryFn: latticeApi.localSources });
@@ -175,16 +180,16 @@ function LocalPanel() {
     <div className="grid gap-4 xl:grid-cols-[0.9fr_1.1fr]">
       <Card>
         <CardHeader>
-          <CardTitle className="flex items-center gap-2"><FolderPlus className="h-4 w-4" /> Connect a folder</CardTitle>
-          <CardDescription>Point Lattice at a folder you want it to remember.</CardDescription>
+          <CardTitle className="flex items-center gap-2"><FolderPlus className="h-4 w-4" /> {t(language, "capture.local.title")}</CardTitle>
+          <CardDescription>{t(language, "capture.local.description")}</CardDescription>
         </CardHeader>
         <CardContent className="space-y-3">
-          <Input value={path} onChange={(e) => setPath(e.target.value)} placeholder="Folder path on this Mac" />
-          <Button disabled={!path.trim() || connect.isPending} onClick={() => connect.mutate()}>Connect Folder</Button>
-          {connect.data ? <OperationResult result={connect.data} successLabel="Folder connection requested" /> : null}
+          <Input value={path} onChange={(e) => setPath(e.target.value)} placeholder={t(language, "capture.local.placeholder")} />
+          <Button disabled={!path.trim() || connect.isPending} onClick={() => connect.mutate()}>{t(language, "capture.local.connect")}</Button>
+          {connect.data ? <OperationResult result={connect.data} successLabel={t(language, "capture.local.success")} /> : null}
         </CardContent>
       </Card>
-      <DataPanel title="Connected sources" result={local.data}>
+      <DataPanel title={t(language, "capture.local.sources")} result={local.data}>
         {(data) => (
           <div className="space-y-3">
             <EntityList items={(data as Record<string, unknown>).sources} titleKey="path" metaKey="status" />
@@ -199,7 +204,7 @@ function LocalPanel() {
           </div>
         )}
       </DataPanel>
-      <DataPanel title="Folder access" result={agent.data} className="xl:col-span-2">
+      <DataPanel title={t(language, "capture.local.access")} result={agent.data} className="xl:col-span-2">
         {(data) => <StructuredView value={data} />}
       </DataPanel>
     </div>
@@ -207,43 +212,45 @@ function LocalPanel() {
 }
 
 function BrowserPanel() {
+  const language = useAppStore((state) => state.language);
   const [url, setUrl] = React.useState("");
   const read = useMutation({ mutationFn: () => latticeApi.browserReadUrl(url) });
   return (
     <Card>
       <CardHeader>
-        <CardTitle className="flex items-center gap-2"><Globe2 className="h-4 w-4" /> Save a web page</CardTitle>
-        <CardDescription>Capture a page so Lattice can remember the useful parts.</CardDescription>
+        <CardTitle className="flex items-center gap-2"><Globe2 className="h-4 w-4" /> {t(language, "capture.browser.title")}</CardTitle>
+        <CardDescription>{t(language, "capture.browser.description")}</CardDescription>
       </CardHeader>
       <CardContent className="space-y-3">
         <div className="flex flex-col gap-2 sm:flex-row">
-          <Input value={url} onChange={(e) => setUrl(e.target.value)} placeholder="https://example.com/article" />
-          <Button disabled={!url.trim() || read.isPending} onClick={() => read.mutate()}>Capture URL</Button>
+          <Input value={url} onChange={(e) => setUrl(e.target.value)} placeholder={t(language, "capture.browser.placeholder")} />
+          <Button disabled={!url.trim() || read.isPending} onClick={() => read.mutate()}>{t(language, "capture.browser.capture")}</Button>
         </div>
-        {read.data ? <OperationResult result={read.data} successLabel="URL capture requested" /> : null}
+        {read.data ? <OperationResult result={read.data} successLabel={t(language, "capture.browser.success")} /> : null}
       </CardContent>
     </Card>
   );
 }
 
 function PipelinePanel() {
+  const language = useAppStore((state) => state.language);
   const index = useQuery({ queryKey: ["index"], queryFn: latticeApi.indexStatus });
   const stats = useQuery({ queryKey: ["graphStats"], queryFn: latticeApi.graphStats });
   return (
     <div className="grid gap-4 xl:grid-cols-2">
-      <DataPanel title="Processing status" result={index.data}>
+      <DataPanel title={t(language, "capture.pipeline.status")} result={index.data}>
         {(data) => <StructuredView value={data} />}
       </DataPanel>
-      <DataPanel title="Brain growth" result={stats.data}>
+      <DataPanel title={t(language, "capture.pipeline.growth")} result={stats.data}>
         {(data) => <StructuredView value={data} />}
       </DataPanel>
       <Card className="xl:col-span-2">
         <CardHeader>
-          <CardTitle className="flex items-center gap-2"><HardDrive className="h-4 w-4" /> Refresh memory</CardTitle>
-          <CardDescription>Refresh search when you want Lattice to re-check captured material.</CardDescription>
+          <CardTitle className="flex items-center gap-2"><HardDrive className="h-4 w-4" /> {t(language, "capture.pipeline.refresh")}</CardTitle>
+          <CardDescription>{t(language, "capture.pipeline.description")}</CardDescription>
         </CardHeader>
         <CardContent>
-          <ActionButton label="Rebuild retrieval index" action={() => latticeApi.rebuildIndex()} invalidate={["index"]} />
+          <ActionButton label={t(language, "capture.pipeline.rebuild")} action={() => latticeApi.rebuildIndex()} invalidate={["index"]} />
         </CardContent>
       </Card>
     </div>

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "6.3.0"
+__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.0"
+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.0"
+__version__ = "6.4.0"