ltcai 6.5.0 → 6.6.0

package/frontend/src/features/brain/brainData.ts

@@ -1,5 +1,5 @@
 import { asArray } from "@/lib/utils";
-import type { ApiRecord, BrainDepth, BrainReadiness, KnowledgeConcept, KnowledgeGraphModel, MemoryFragment, RelationshipThread } from "./types";
+import type { ApiRecord, BrainDepth, BrainProof, BrainReadiness, KnowledgeConcept, KnowledgeGraphModel, MemoryFragment, RelationshipThread } from "./types";
 import { clamp } from "./graphLayout";
 
 export function buildMemoryFragments(memoryData: unknown, historyData: unknown): MemoryFragment[] {
@@ -86,6 +86,51 @@ export function buildBrainReadiness(memoryData: unknown, fallbackMemoryCount: nu
   return fallbackBrainReadiness(fallbackMemoryCount, fallbackConceptCount);
 }
 
+export function buildBrainProof(data: unknown, fallbackModelName = ""): BrainProof {
+  const proof = isRecord(data) ? data : {};
+  const modelContinuity = isRecord(proof.model_continuity) ? proof.model_continuity : {};
+  const proofs = isRecord(proof.proofs) ? proof.proofs : {};
+  const recall = isRecord(proof.recall) ? proof.recall : {};
+  const claims = isRecord(proof.claims) ? proof.claims : {};
+  const durableItems = numberValue(proofs, ["durable_items", "durableItems"]);
+  return {
+    status: textValue(proof, ["status"], "quiet"),
+    modelContinuity: {
+      activeModel: textValue(modelContinuity, ["active_model", "activeModel"], fallbackModelName),
+      brainOwner: textValue(modelContinuity, ["brain_owner", "brainOwner"], "lattice_brain"),
+      capability: booleanValue(modelContinuity, ["capability"], true),
+      survivesModelSwitch: booleanValue(modelContinuity, ["survives_model_switch", "survivesModelSwitch"], false),
+      proven: booleanValue(modelContinuity, ["proven"], false),
+      contextStore: textValue(modelContinuity, ["context_store", "contextStore"], "workspace + conversation + graph + vector"),
+    },
+    proofs: {
+      durableItems,
+      hasDurableEvidence: booleanValue(proofs, ["has_durable_evidence", "hasDurableEvidence"], durableItems > 0),
+      workspaceMemories: numberValue(proofs, ["workspace_memories", "workspaceMemories"]),
+      conversations: numberValue(proofs, ["conversations"]),
+      graphConcepts: numberValue(proofs, ["graph_concepts", "graphConcepts"]),
+      vectorItems: numberValue(proofs, ["vector_items", "vectorItems"]),
+      healthySources: numberValue(proofs, ["healthy_sources", "healthySources"]),
+    },
+    recall: {
+      query: textValue(recall, ["query"]),
+      count: numberValue(recall, ["count"]),
+      items: asArray<ApiRecord>(recall.items).map((item, index) => ({
+        id: textValue(item, ["id"], `recall-${index}`),
+        source: titleValue(item, ["source"], "Memory"),
+        title: textValue(item, ["title"], "Memory"),
+        snippet: textValue(item, ["snippet"]),
+        score: numberValue(item, ["score"]),
+      })),
+    },
+    claims: {
+      canRecallUserContext: booleanValue(claims, ["can_recall_user_context", "canRecallUserContext"], false),
+      keepsContextAcrossModels: booleanValue(claims, ["keeps_context_across_models", "keepsContextAcrossModels"], false),
+      isKnowledgeStore: booleanValue(claims, ["is_knowledge_store", "isKnowledgeStore"], false),
+    },
+  };
+}
+
 function uniqueById<T extends { id: string }>(items: T[]) {
   const seen = new Set<string>();
   return items.filter((item) => {
@@ -167,3 +212,11 @@ function numberValue(record: ApiRecord, keys: string[]) {
   }
   return 0;
 }
+
+function booleanValue(record: ApiRecord, keys: string[], fallback: boolean) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "boolean") return value;
+  }
+  return fallback;
+}

package/frontend/src/features/brain/types.ts

@@ -50,6 +50,43 @@ export type BrainReadiness = {
   };
 };
 
+export type BrainProof = {
+  status: "quiet" | "forming" | "alive" | string;
+  modelContinuity: {
+    activeModel: string;
+    brainOwner: string;
+    capability: boolean;
+    survivesModelSwitch: boolean;
+    proven: boolean;
+    contextStore: string;
+  };
+  proofs: {
+    durableItems: number;
+    hasDurableEvidence: boolean;
+    workspaceMemories: number;
+    conversations: number;
+    graphConcepts: number;
+    vectorItems: number;
+    healthySources: number;
+  };
+  recall: {
+    query: string;
+    count: number;
+    items: Array<{
+      id: string;
+      source: string;
+      title: string;
+      snippet: string;
+      score: number;
+    }>;
+  };
+  claims: {
+    canRecallUserContext: boolean;
+    keepsContextAcrossModels: boolean;
+    isKnowledgeStore: boolean;
+  };
+};
+
 export const DEPTHS: Array<{ level: BrainDepth; labelKey: string; state: BrainState }> = [
   { level: 1, labelKey: "brain.depthLabel.1", state: "idle" },
   { level: 2, labelKey: "brain.depthLabel.2", state: "recalling" },

package/frontend/src/i18n.ts

@@ -53,6 +53,13 @@ export const COPY: Record<Language, TextMap> = {
     "brain.prompt.know": "이 문서를 내 Brain에 넣고 요약해줘: ",
     "brain.prompt.plan": "지난 결정들을 나중에 찾을 수 있게 정리해줘: ",
     "brain.placeholder": "Brain에게 말하기...",
+    "brain.upload.cta": "파일/문서 넣기",
+    "brain.upload.ctaShort": "문서",
+    "brain.upload.uploading": "넣는 중",
+    "brain.upload.hint": "업로드하면 실제 기억과 그래프로 다시 보입니다.",
+    "brain.upload.pending": "{name}을 Brain에 넣는 중입니다.",
+    "brain.upload.saved": "{name}이 Brain에 저장됐습니다.",
+    "brain.upload.failed": "문서를 넣지 못했습니다: {reason}",
     "brain.image": "이미지",
     "brain.unavailable": "지금은 답할 수 없음",
     "brain.imageAttached": "이미지 첨부됨",
@@ -77,6 +84,21 @@ export const COPY: Record<Language, TextMap> = {
     "brain.readiness.start": "첫 기억 보기",
     "brain.readiness.grow": "주제 키우기",
     "brain.readiness.map": "지도 보기",
+    "brain.proof.aria": "Brain 증거",
+    "brain.proof.context": "다시 불러올 맥락",
+    "brain.proof.contextValue": "{count}개 저장됨",
+    "brain.proof.contextEmpty": "첫 기억 대기",
+    "brain.proof.model": "모델 교체 후에도 유지",
+    "brain.proof.noModel": "모델 미로드",
+    "brain.proof.modelPending": "저장 후 증명됨",
+    "brain.proof.store": "지식 저장소",
+    "brain.proof.storeValue": "주제 {topics}개 · 벡터 {vectors}개",
+    "brain.proof.recall": "방금 Brain이 다시 꺼낸 기억",
+    "brain.proof.recallEmpty.kicker": "Brain 증거 자리",
+    "brain.proof.recallEmpty.title": "첫 대화 후 여기에 다시 꺼낸 기억이 표시됩니다.",
+    "brain.proof.recallEmpty.detail": "아직 저장된 기억이 없어서 가짜 예시는 보여주지 않습니다.",
+    "brain.proof.recallPending": "기억은 저장됐고 recall 증거를 준비 중입니다.",
+    "brain.proof.recallPending.detail": "인덱싱이 끝나면 이 자리에서 실제 기억을 다시 보여줍니다.",
     "brain.memory.empty.kicker": "첫 기억",
     "brain.memory.empty": "기억이 조용합니다.",
     "brain.knowledge.empty": "지식이 형성되는 중입니다.",
@@ -385,6 +407,13 @@ export const COPY: Record<Language, TextMap> = {
     "brain.prompt.know": "Put this document into my Brain and summarize it: ",
     "brain.prompt.plan": "Organize past decisions so I can find them later: ",
     "brain.placeholder": "Talk to your Brain...",
+    "brain.upload.cta": "Add file or document",
+    "brain.upload.ctaShort": "Document",
+    "brain.upload.uploading": "Adding...",
+    "brain.upload.hint": "After upload, it reappears as real memory and graph context.",
+    "brain.upload.pending": "Adding {name} to Brain.",
+    "brain.upload.saved": "{name} was saved to Brain.",
+    "brain.upload.failed": "Could not add the document: {reason}",
     "brain.image": "Image",
     "brain.unavailable": "Unavailable",
     "brain.imageAttached": "Image attached",
@@ -409,6 +438,21 @@ export const COPY: Record<Language, TextMap> = {
     "brain.readiness.start": "View first memory",
     "brain.readiness.grow": "Grow topics",
     "brain.readiness.map": "Open map",
+    "brain.proof.aria": "Brain proof",
+    "brain.proof.context": "Recallable context",
+    "brain.proof.contextValue": "{count} saved",
+    "brain.proof.contextEmpty": "Waiting for first memory",
+    "brain.proof.model": "Survives model switches",
+    "brain.proof.noModel": "No model loaded",
+    "brain.proof.modelPending": "Proven after saving",
+    "brain.proof.store": "Knowledge store",
+    "brain.proof.storeValue": "{topics} topics · {vectors} vectors",
+    "brain.proof.recall": "Just recalled by Brain",
+    "brain.proof.recallEmpty.kicker": "Brain proof slot",
+    "brain.proof.recallEmpty.title": "After your first exchange, recalled memory appears here.",
+    "brain.proof.recallEmpty.detail": "No saved memory yet, so Lattice does not show a fake example.",
+    "brain.proof.recallPending": "Memory is saved; recall proof is preparing.",
+    "brain.proof.recallPending.detail": "When indexing finishes, this slot shows the actual memory Brain can bring back.",
     "brain.memory.empty.kicker": "First memory",
     "brain.memory.empty": "Memory is quiet",
     "brain.knowledge.empty": "Knowledge is forming",

package/frontend/src/styles.css

@@ -1475,6 +1475,91 @@ body {
   transition: width 260ms ease;
 }
 
+.brain-proof-strip {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0.58rem;
+  margin-top: 0.62rem;
+}
+
+.brain-proof-point {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  align-items: center;
+  gap: 0.12rem 0.44rem;
+  min-height: 4.1rem;
+  border: 1px solid hsl(var(--border) / 0.5);
+  border-radius: 8px;
+  background: hsl(var(--surface) / 0.56);
+  padding: 0.58rem;
+  color: hsl(var(--fg));
+}
+
+.brain-proof-point svg {
+  grid-row: span 2;
+  color: hsl(var(--knowledge));
+}
+
+.brain-proof-point span {
+  overflow: hidden;
+  color: hsl(var(--fg-muted));
+  font-size: 0.62rem;
+  font-weight: 820;
+  text-overflow: ellipsis;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+
+.brain-proof-point strong {
+  overflow: hidden;
+  font-size: 0.75rem;
+  line-height: 1.2;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.brain-recall-proof {
+  display: grid;
+  width: 100%;
+  gap: 0.2rem;
+  margin-top: 0.62rem;
+  border: 1px solid hsl(var(--memory) / 0.34);
+  border-radius: 8px;
+  background: hsl(var(--memory) / 0.07);
+  color: hsl(var(--fg));
+  padding: 0.68rem;
+  text-align: left;
+}
+
+.brain-recall-proof.is-empty {
+  border-color: hsl(var(--border) / 0.5);
+  background: hsl(var(--surface) / 0.5);
+}
+
+.brain-recall-proof span {
+  color: hsl(var(--fg-muted));
+  font-size: 0.64rem;
+  font-weight: 820;
+  text-transform: uppercase;
+}
+
+.brain-recall-proof strong,
+.brain-recall-proof small {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.brain-recall-proof strong {
+  font-size: 0.86rem;
+}
+
+.brain-recall-proof small {
+  color: hsl(var(--fg-muted));
+  font-size: 0.76rem;
+}
+
 .brain-save-feedback {
   display: grid;
   grid-template-columns: auto minmax(0, 1fr);
@@ -2766,6 +2851,7 @@ body {
   font-size: 0.88rem;
 }
 
+.brain-document-input,
 .brain-image-input {
   display: inline-flex;
   cursor: pointer;
@@ -2778,6 +2864,19 @@ body {
   font-size: 0.78rem;
 }
 
+.brain-document-input {
+  border-color: hsl(var(--memory) / 0.42);
+  background: hsl(var(--memory) / 0.08);
+  color: hsl(var(--fg));
+  font-weight: 760;
+}
+
+.brain-document-input.is-disabled,
+.mind-empty-upload.is-disabled {
+  cursor: wait;
+  opacity: 0.68;
+}
+
 .mind-empty-kicker {
   margin-bottom: 0.4rem;
   font-size: 0.72rem;
@@ -2864,6 +2963,37 @@ body {
   line-height: 1.45;
 }
 
+.mind-empty-upload {
+  display: inline-flex;
+  cursor: pointer;
+  align-items: center;
+  justify-content: center;
+  gap: 0.42rem;
+  margin-top: 1rem;
+  border: 1px solid hsl(var(--memory) / 0.46);
+  border-radius: 999px;
+  background: hsl(var(--memory) / 0.1);
+  color: hsl(var(--fg));
+  padding: 0.55rem 0.9rem;
+  font-size: 0.82rem;
+  font-weight: 820;
+  transition: border-color 150ms ease, background 150ms ease, transform 150ms ease;
+}
+
+.mind-empty-upload:hover,
+.mind-empty-upload:focus-within {
+  border-color: hsl(var(--memory) / 0.72);
+  background: hsl(var(--memory) / 0.16);
+  transform: translateY(-1px);
+}
+
+.mind-empty-upload-hint {
+  display: block;
+  margin-top: 0.42rem;
+  color: hsl(var(--fg-muted));
+  font-size: 0.72rem;
+}
+
 .mind-empty-prompts {
   display: flex;
   flex-wrap: wrap;
@@ -2964,6 +3094,9 @@ body {
   .brain-overview-grid {
     grid-template-columns: 1fr;
   }
+  .brain-proof-strip {
+    grid-template-columns: 1fr;
+  }
   .brain-overview-head {
     align-items: flex-start;
     flex-direction: column;

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "6.5.0"
+__version__ = "6.6.0"
 
 __all__ = [
     "AgentRuntime",

package/lattice_brain/graph/ingest.py

@@ -15,6 +15,7 @@ class KnowledgeGraphIngestMixin:
         user_nickname: Optional[str] = None,
         source: Optional[str] = None,
         conversation_id: Optional[str] = None,
+        workspace_id: Optional[str] = None,
         raw: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         content = str(content or "")
@@ -28,6 +29,7 @@ class KnowledgeGraphIngestMixin:
             "role": role,
             "source": source,
             "conversation_id": conversation_id,
+            "workspace_id": workspace_id,
             "user_email": user_email,
             "user_nickname": user_nickname,
             "chars": len(content),
@@ -47,7 +49,9 @@ class KnowledgeGraphIngestMixin:
                 "Chat",
                 chat_title,
                 summary=_clean_text(content)[:400],
-                metadata={"source": source, "conversation_id": conversation_id},
+                metadata={"source": source, "conversation_id": conversation_id, "workspace_id": workspace_id},
+                owner=user_email,
+                workspace_id=workspace_id,
             )
 
             # ── 2. Person node  (점: 명사 — 사람) ─────────────────────────────
@@ -61,6 +65,8 @@ class KnowledgeGraphIngestMixin:
                     "Person",
                     user_nickname or user_email or "Unknown",
                     metadata={"email": user_email, "nickname": user_nickname},
+                    owner=user_email,
+                    workspace_id=workspace_id,
                 )
                 # 선: 동사 — Person이 Chat을 "작성함"
                 self._upsert_edge(
@@ -81,6 +87,8 @@ class KnowledgeGraphIngestMixin:
                 summary=_clean_text(content)[:500],
                 metadata=metadata,
                 raw=raw or metadata,
+                owner=user_email,
+                workspace_id=workspace_id,
             )
             # 선: Chat이 메시지를 "포함함"
             self._upsert_edge(
@@ -97,6 +105,8 @@ class KnowledgeGraphIngestMixin:
                     f"chunk {index + 1}",
                     summary=chunk[:500],
                     metadata={"index": index, "source_node": node_id},
+                    owner=user_email,
+                    workspace_id=workspace_id,
                 )
                 self._upsert_chunk(
                     conn,
@@ -118,7 +128,9 @@ class KnowledgeGraphIngestMixin:
                     cid,
                     node_t,
                     concept,
-                    metadata={"auto_extracted": True, "source": source},
+                    metadata={"auto_extracted": True, "source": source, "workspace_id": workspace_id},
+                    owner=user_email,
+                    workspace_id=workspace_id,
                 )
                 # 선: Chat이 개념을 "언급함"
                 self._upsert_edge(
@@ -155,8 +167,10 @@ class KnowledgeGraphIngestMixin:
                     sem_type,
                     sem_title,
                     summary=item["summary"],
-                    metadata={"auto_extracted": True, "source_node": node_id},
+                    metadata={"auto_extracted": True, "source_node": node_id, "workspace_id": workspace_id},
                     raw=item,
+                    owner=user_email,
+                    workspace_id=workspace_id,
                 )
                 # 선: Chat이 Task/Decision을 "생성함"
                 self._upsert_edge(conn, conv_id, sem_id, "생성함", weight=0.9)
@@ -236,6 +250,8 @@ class KnowledgeGraphIngestMixin:
                 summary=(text or filename)[:500],
                 metadata=metadata,
                 raw=metadata,
+                owner=owner or uploader,
+                workspace_id=workspace_id,
             )
             self._ingest_structure_nodes(conn, file_id, filename, doc_meta)
 
@@ -265,6 +281,8 @@ class KnowledgeGraphIngestMixin:
                     "Person",
                     uploader,
                     metadata={"email": uploader},
+                    owner=uploader,
+                    workspace_id=workspace_id,
                 )
                 # 선: 동사 — Person이 Document를 "업로드함"
                 self._upsert_edge(conn, person_id, file_id, "업로드함", weight=1.0)
@@ -272,7 +290,15 @@ class KnowledgeGraphIngestMixin:
             # ── Chat 노드와 연결 ──────────────────────────────────────────────
             if conversation_id:
                 conv_id = f"conversation:{_slug(conversation_id)}"
-                self._upsert_node(conn, conv_id, "Chat", conversation_id)
+                self._upsert_node(
+                    conn,
+                    conv_id,
+                    "Chat",
+                    conversation_id,
+                    metadata={"conversation_id": conversation_id, "workspace_id": workspace_id},
+                    owner=owner or uploader,
+                    workspace_id=workspace_id,
+                )
                 # 선: 동사 — Chat이 Document를 "언급함"
                 self._upsert_edge(conn, conv_id, file_id, "언급함", weight=0.8)
 
@@ -286,7 +312,9 @@ class KnowledgeGraphIngestMixin:
                     "Chunk",
                     f"{filename} chunk {index + 1}",
                     summary=chunk[:500],
-                    metadata={"index": index, "source_node": file_id},
+                    metadata={"index": index, "source_node": file_id, "workspace_id": workspace_id},
+                    owner=owner or uploader,
+                    workspace_id=workspace_id,
                 )
                 self._upsert_chunk(
                     conn,
@@ -308,7 +336,9 @@ class KnowledgeGraphIngestMixin:
                     cid,
                     node_t,
                     concept,
-                    metadata={"auto_extracted": True, "source_file": filename},
+                    metadata={"auto_extracted": True, "source_file": filename, "workspace_id": workspace_id},
+                    owner=owner or uploader,
+                    workspace_id=workspace_id,
                 )
                 # 선: 동사 — Document가 Concept을 "포함함"
                 self._upsert_edge(conn, file_id, cid, "포함함", weight=0.8)
@@ -342,8 +372,11 @@ class KnowledgeGraphIngestMixin:
                         "auto_extracted": True,
                         "source_node": file_id,
                         "filename": filename,
+                        "workspace_id": workspace_id,
                     },
                     raw=item,
+                    owner=owner or uploader,
+                    workspace_id=workspace_id,
                 )
                 # 선: Document가 Task/Decision을 "포함함"
                 self._upsert_edge(conn, file_id, sem_id, "포함함", weight=0.9)
@@ -474,6 +507,8 @@ class KnowledgeGraphIngestMixin:
             label,
             summary=str(source_uri or title or source_type)[:400],
             metadata=meta,
+            owner=meta.get("owner"),
+            workspace_id=meta.get("workspace_id"),
         )
         # 선: 콘텐츠 노드가 "이 출처에서 색인됨" (indexed_from → SOURCE)
         self._upsert_edge(

package/lattice_brain/ingestion.py

@@ -267,6 +267,7 @@ class IngestionPipeline:
             user_nickname=meta.get("user_nickname"),
             source=meta.get("source") or source_type,
             conversation_id=item.conversation_id,
+            workspace_id=item.workspace_id,
             raw=meta.get("raw"),
         )
         # ingest_message reports message/response node ids; normalize the keys

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.5.0"
+MULTI_AGENT_VERSION = "6.6.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.5.0"
+__version__ = "6.6.0"

package/latticeai/api/knowledge_graph.py

@@ -27,6 +27,14 @@ class KnowledgeGraphIngestRequest(BaseModel):
     metadata: Optional[Dict[str, Any]] = None
 
 
+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
+
+
 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
@@ -178,6 +186,7 @@ def create_knowledge_graph_router(
     async def knowledge_graph_ingest(req: KnowledgeGraphIngestRequest, request: Request):
         current_user = require_user(request)
         kg = graph()
+        workspace_id = _workspace_scope_from_request(request)
         event_type = (req.type or "").strip().lower()
         if event_type not in {"message", "ai_response", "note"}:
             raise HTTPException(status_code=400, detail="지원하는 type: message, ai_response, note")
@@ -189,10 +198,12 @@ def create_knowledge_graph_router(
             user_nickname=req.user_nickname,
             source=req.source or "mcp",
             conversation_id=req.conversation_id,
+            workspace_id=workspace_id,
             raw={
                 "type": req.type,
                 "title": req.title,
                 "content": req.content,
+                "workspace_id": workspace_id,
                 "metadata": req.metadata or {},
             },
         )

package/latticeai/api/memory.py

@@ -42,6 +42,7 @@ def create_memory_router(
     gate_read: Callable[[Request], Optional[str]],
     gate_write: Callable[[Request], Optional[str]],
     append_audit_event: Callable[..., None],
+    active_model_getter: Callable[[], str] | None = None,
 ) -> APIRouter:
     router = APIRouter()
 
@@ -57,6 +58,19 @@ def create_memory_router(
         scope = gate_read(request)
         return service.brain_quality_summary(user_email=user, workspace_id=scope)
 
+    @router.get("/api/memory/brain-proof")
+    async def brain_proof(request: Request, q: str = "", limit: int = 3):
+        user = require_user(request)
+        scope = gate_read(request)
+        active_model = active_model_getter() if active_model_getter else ""
+        return service.brain_proof(
+            user_email=user,
+            workspace_id=scope,
+            active_model=active_model,
+            recall_query=q,
+            limit=limit,
+        )
+
     @router.get("/api/memory/tiers")
     async def memory_tiers(request: Request):
         require_user(request)

package/latticeai/app_factory.py

@@ -736,6 +736,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
                             source_type="chat_message",
                             text=message,
                             owner=user_email,
+                            workspace_id=workspace_id,
                             conversation_id=conversation_id,
                             metadata={
                                 "role": role,
@@ -1447,6 +1448,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         agent_registry=AGENT_REGISTRY,
         memory_service=MEMORY_SERVICE,
         platform=PLATFORM,
+        active_model_getter=lambda: router.current_model_id or "",
     )
     register_interaction_routers(
         app,

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "6.5.0"
+MARKETPLACE_VERSION = "6.6.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.5.0"
+WORKSPACE_OS_VERSION = "6.6.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

@@ -63,6 +63,7 @@ def build_interaction_contexts(
     agent_registry: Any,
     memory_service: Any,
     platform: Any,
+    active_model_getter: Any = None,
 ) -> tuple[ToolRouterContext, InteractionRouterContext]:
     tool_router_context = ToolRouterContext(
         config=config,
@@ -101,6 +102,7 @@ def build_interaction_contexts(
         agent_registry=agent_registry,
         memory_service=memory_service,
         platform=platform,
+        active_model_getter=active_model_getter,
     )
     return tool_router_context, interaction_router_context