ltcai 6.4.0 → 6.6.0

package/frontend/src/features/brain/BrainHome.tsx

@@ -5,7 +5,7 @@ import { type BrainState, LivingBrain, triggerBrainRecall } from "@/components/L
 import { useAppStore } from "@/store/appStore";
 import { t } from "@/i18n";
 import { BrainConversation } from "./BrainConversation";
-import { buildMemoryFragments, currentModelName, parseKnowledgeGraph } from "./brainData";
+import { buildBrainProof, buildBrainReadiness, buildMemoryFragments, currentModelName, parseKnowledgeGraph } from "./brainData";
 import { DepthEmergence } from "./DepthEmergence";
 import { DEPTHS, type BrainDepth, type MemoryFragment, type Message } from "./types";
 
@@ -29,6 +29,8 @@ export function BrainHome({
   const [graphSearch, setGraphSearch] = React.useState("");
   const [selectedGraphId, setSelectedGraphId] = React.useState<string | null>(null);
   const [memoryFeedback, setMemoryFeedback] = React.useState<string | null>(null);
+  const [uploadingDocument, setUploadingDocument] = React.useState(false);
+  const [lastRecallQuery, setLastRecallQuery] = React.useState("");
   const streamRef = React.useRef<HTMLDivElement>(null);
   const recallTimerRef = React.useRef<number | null>(null);
 
@@ -36,6 +38,10 @@ export function BrainHome({
   const historyQ = useQuery({ queryKey: ["chatHistory"], queryFn: latticeApi.chatHistory });
   const graphQ = useQuery({ queryKey: ["graph"], queryFn: latticeApi.graph });
   const modelsQ = useQuery({ queryKey: ["models"], queryFn: latticeApi.models });
+  const brainProofQ = useQuery({
+    queryKey: ["memoryBrainProof", lastRecallQuery],
+    queryFn: () => latticeApi.memoryBrainProof(lastRecallQuery, 3),
+  });
 
   const memoryFragments = React.useMemo(
     () => buildMemoryFragments(memoriesQ.data?.data, historyQ.data?.data),
@@ -46,11 +52,19 @@ export function BrainHome({
     () => graphModel.nodes.slice(0, 10),
     [graphModel.nodes],
   );
+  const brainReadiness = React.useMemo(
+    () => buildBrainReadiness(memoriesQ.data?.data, memoryFragments.length, knowledgeConcepts.length),
+    [knowledgeConcepts.length, memoriesQ.data, memoryFragments.length],
+  );
   const relationshipThreads = React.useMemo(
     () => graphModel.edges.slice(0, 10),
     [graphModel.edges],
   );
   const modelName = React.useMemo(() => currentModelName(modelsQ.data?.data), [modelsQ.data]);
+  const brainProof = React.useMemo(
+    () => buildBrainProof(brainProofQ.data?.data, modelName),
+    [brainProofQ.data, modelName],
+  );
   const currentDepth = DEPTHS[explorationDepth - 1];
   const starterPrompts = React.useMemo(
     () => [
@@ -119,12 +133,39 @@ export function BrainHome({
         });
       } else {
         setMemoryFeedback(t(language, "brain.saved", { topics: knowledgeConcepts.length, memories: memoryFragments.length }));
+        setLastRecallQuery(text);
       }
     } finally {
       setStreaming(false);
       void qc.invalidateQueries({ queryKey: ["chatHistory"] });
       void qc.invalidateQueries({ queryKey: ["memoryManager"] });
       void qc.invalidateQueries({ queryKey: ["graph"] });
+      void qc.invalidateQueries({ queryKey: ["memoryBrainProof"] });
+    }
+  }
+
+  async function uploadDocument(file: File) {
+    if (uploadingDocument) return;
+
+    setUploadingDocument(true);
+    setMemoryFeedback(t(language, "brain.upload.pending", { name: file.name }));
+    onBrainChange("recalling", 0.86);
+
+    try {
+      const result = await latticeApi.uploadDocument(file);
+      if (result.error) {
+        setMemoryFeedback(t(language, "brain.upload.failed", { reason: result.error }));
+        return;
+      }
+
+      setMemoryFeedback(t(language, "brain.upload.saved", { name: file.name }));
+      setLastRecallQuery(file.name);
+      triggerBrainRecall();
+      void qc.invalidateQueries({ queryKey: ["memoryManager"] });
+      void qc.invalidateQueries({ queryKey: ["graph"] });
+      void qc.invalidateQueries({ queryKey: ["memoryBrainProof"] });
+    } finally {
+      setUploadingDocument(false);
     }
   }
 
@@ -186,6 +227,21 @@ export function BrainHome({
             <button type="button" className={explorationDepth === 5 ? "is-active" : ""} onClick={() => jumpToDepth(5)}>{t(language, "brain.view.graph")}</button>
           </div>
 
+          <div className="brain-depth-rail" aria-label={t(language, "brain.depthRail.aria")}>
+            {DEPTHS.map((depth) => (
+              <button
+                key={depth.level}
+                type="button"
+                className={depth.level <= explorationDepth ? "is-revealed" : ""}
+                aria-current={depth.level === explorationDepth ? "step" : undefined}
+                onClick={() => jumpToDepth(depth.level)}
+              >
+                <span>{depth.level}</span>
+                <strong>{t(language, `brain.depth.${depth.level}`)}</strong>
+              </button>
+            ))}
+          </div>
+
           <div className="brain-field-layer" aria-hidden={explorationDepth < 2}>
             <DepthEmergence
               depth={explorationDepth}
@@ -222,9 +278,13 @@ export function BrainHome({
         streamRef={streamRef}
         memories={memoryFragments}
         concepts={knowledgeConcepts}
+        readiness={brainReadiness}
+        proof={brainProof}
+        uploadingDocument={uploadingDocument}
         onOpenDepth={jumpToDepth}
         onDraftChange={setDraft}
         onImageDataChange={setImageData}
+        onUploadDocument={(file) => void uploadDocument(file)}
         onSend={() => void send()}
       />
     </main>

package/frontend/src/features/brain/BrainMemoryLayer.tsx

@@ -14,7 +14,14 @@ export function BrainMemoryLayer({
 }) {
   const language = useAppStore((state) => state.language);
   const visible = memories.slice(0, depth >= 3 ? 8 : 6);
-  if (!visible.length) return <div className="memory-fragment is-empty">{t(language, "brain.memory.empty")}</div>;
+  if (!visible.length) {
+    return (
+      <div className="memory-fragment is-empty">
+        <span>{t(language, "brain.memory.empty.kicker")}</span>
+        <strong>{t(language, "brain.memory.empty")}</strong>
+      </div>
+    );
+  }
 
   return (
     <>

package/frontend/src/features/brain/BrainOverviewPanel.tsx

@@ -1,21 +1,31 @@
 import * as React from "react";
+import { BrainCircuit, DatabaseZap, Repeat2 } from "lucide-react";
 import { t } from "@/i18n";
 import { useAppStore } from "@/store/appStore";
-import type { BrainDepth, KnowledgeConcept, MemoryFragment } from "./types";
+import type { BrainDepth, BrainProof, BrainReadiness, KnowledgeConcept, MemoryFragment } from "./types";
 
 export function BrainOverviewPanel({
   memories,
   concepts,
+  readiness,
+  proof,
   onOpenDepth,
 }: {
   memories: MemoryFragment[];
   concepts: KnowledgeConcept[];
+  readiness: BrainReadiness;
+  proof: BrainProof;
   onOpenDepth: (depth: BrainDepth) => void;
 }) {
   const language = useAppStore((state) => state.language);
   const recent = memories.slice(0, 3);
   const older = memories.slice(3, 6);
   const topics = concepts.slice(0, 4);
+  const hasDurableProof = proof.proofs.hasDurableEvidence || proof.modelContinuity.proven;
+  const hasRecallProof = proof.recall.items.length > 0;
+  const modelProofValue = proof.modelContinuity.proven && proof.claims.keepsContextAcrossModels
+    ? proof.modelContinuity.activeModel || t(language, "brain.proof.noModel")
+    : t(language, "brain.proof.modelPending");
 
   return (
     <section className="brain-overview-panel" aria-label={t(language, "brain.aria.overview")}>
@@ -46,10 +56,75 @@ export function BrainOverviewPanel({
           onOpen={() => onOpenDepth(3)}
         />
       </div>
+      <div className="brain-readiness-strip" data-state={readiness.state}>
+        <div>
+          <span>{t(language, "brain.readiness.kicker")}</span>
+          <strong>{t(language, readiness.titleKey)}</strong>
+        </div>
+        <div className="brain-readiness-meter" aria-label={t(language, "brain.readiness.aria")}>
+          <i style={{ width: `${readiness.score}%` }} />
+        </div>
+        <button type="button" onClick={() => onOpenDepth(readiness.depth)}>
+          {t(language, readiness.actionKey)}
+        </button>
+      </div>
+      <div className="brain-proof-strip" aria-label={t(language, "brain.proof.aria")}>
+        <BrainProofPoint
+          icon={<DatabaseZap className="h-4 w-4" />}
+          label={t(language, "brain.proof.context")}
+          value={hasDurableProof
+            ? t(language, "brain.proof.contextValue", { count: proof.proofs.durableItems })
+            : t(language, "brain.proof.contextEmpty")}
+        />
+        <BrainProofPoint
+          icon={<Repeat2 className="h-4 w-4" />}
+          label={t(language, "brain.proof.model")}
+          value={modelProofValue}
+        />
+        <BrainProofPoint
+          icon={<BrainCircuit className="h-4 w-4" />}
+          label={t(language, "brain.proof.store")}
+          value={t(language, "brain.proof.storeValue", {
+            topics: proof.proofs.graphConcepts,
+            vectors: proof.proofs.vectorItems,
+          })}
+        />
+      </div>
+      {hasRecallProof ? (
+        <button type="button" className="brain-recall-proof" onClick={() => onOpenDepth(2)}>
+          <span>{t(language, "brain.proof.recall")}</span>
+          <strong>{proof.recall.items[0].title}</strong>
+          <small>{proof.recall.items[0].snippet || proof.recall.query}</small>
+        </button>
+      ) : (
+        <div className="brain-recall-proof is-empty" role="status">
+          <span>{t(language, "brain.proof.recallEmpty.kicker")}</span>
+          <strong>{t(language, hasDurableProof ? "brain.proof.recallPending" : "brain.proof.recallEmpty.title")}</strong>
+          <small>{t(language, hasDurableProof ? "brain.proof.recallPending.detail" : "brain.proof.recallEmpty.detail")}</small>
+        </div>
+      )}
     </section>
   );
 }
 
+function BrainProofPoint({
+  icon,
+  label,
+  value,
+}: {
+  icon: React.ReactNode;
+  label: string;
+  value: string;
+}) {
+  return (
+    <div className="brain-proof-point">
+      {icon}
+      <span>{label}</span>
+      <strong>{value}</strong>
+    </div>
+  );
+}
+
 function BrainOverviewColumn({
   title,
   empty,

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

@@ -1,5 +1,5 @@
 import { asArray } from "@/lib/utils";
-import type { ApiRecord, 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[] {
@@ -60,6 +60,77 @@ export function currentModelName(data: unknown) {
   return firstLoaded ? textValue(firstLoaded, ["name", "id", "model_id"], "local mind") : "local mind";
 }
 
+export function buildBrainReadiness(memoryData: unknown, fallbackMemoryCount: number, fallbackConceptCount: number): BrainReadiness {
+  const memory = isRecord(memoryData) ? memoryData : {};
+  const backend = isRecord(memory.brain_readiness) ? memory.brain_readiness : {};
+  const backendState = textValue(backend, ["state"]);
+  const backendDepth = numberValue(backend, ["depth"]);
+  const backendScore = numberValue(backend, ["score"]);
+  if ((backendState === "quiet" || backendState === "forming" || backendState === "alive") && isBrainDepth(backendDepth)) {
+    const signals = isRecord(backend.signals) ? backend.signals : {};
+    return {
+      score: clamp(Math.round(backendScore || 0), 0, 100),
+      state: backendState,
+      depth: backendDepth,
+      titleKey: textValue(backend, ["title_key", "titleKey"], `brain.readiness.${backendState}`),
+      actionKey: textValue(backend, ["action_key", "actionKey"], readinessActionKey(backendState)),
+      source: "memory_service",
+      signals: {
+        memoryCount: numberValue(signals, ["memory_count", "memoryCount"]),
+        conceptCount: numberValue(signals, ["concept_count", "conceptCount"]),
+        relationshipCount: numberValue(signals, ["relationship_count", "relationshipCount"]),
+        healthySources: numberValue(signals, ["healthy_sources", "healthySources"]),
+      },
+    };
+  }
+  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) => {
@@ -69,6 +140,51 @@ function uniqueById<T extends { id: string }>(items: T[]) {
   });
 }
 
+function fallbackBrainReadiness(memoryCount: number, conceptCount: number): BrainReadiness {
+  const score = Math.min(100, Math.round(memoryCount * 12 + conceptCount * 10));
+  if (memoryCount < 1) {
+    return {
+      score: Math.max(12, score),
+      state: "quiet",
+      depth: 2,
+      titleKey: "brain.readiness.quiet",
+      actionKey: "brain.readiness.start",
+      source: "frontend_fallback",
+      signals: { memoryCount, conceptCount, relationshipCount: 0, healthySources: 0 },
+    };
+  }
+  if (conceptCount < 3) {
+    return {
+      score: Math.max(38, score),
+      state: "forming",
+      depth: 3,
+      titleKey: "brain.readiness.forming",
+      actionKey: "brain.readiness.grow",
+      source: "frontend_fallback",
+      signals: { memoryCount, conceptCount, relationshipCount: 0, healthySources: 0 },
+    };
+  }
+  return {
+    score: Math.max(72, score),
+    state: "alive",
+    depth: 5,
+    titleKey: "brain.readiness.alive",
+    actionKey: "brain.readiness.map",
+    source: "frontend_fallback",
+    signals: { memoryCount, conceptCount, relationshipCount: 0, healthySources: 0 },
+  };
+}
+
+function readinessActionKey(state: "quiet" | "forming" | "alive") {
+  if (state === "quiet") return "brain.readiness.start";
+  if (state === "forming") return "brain.readiness.grow";
+  return "brain.readiness.map";
+}
+
+function isBrainDepth(value: number): value is BrainDepth {
+  return value >= 1 && value <= 5 && Number.isInteger(value);
+}
+
 export function isRecord(value: unknown): value is ApiRecord {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -96,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

@@ -35,6 +35,58 @@ export type KnowledgeGraphModel = {
   edges: RelationshipThread[];
 };
 
+export type BrainReadiness = {
+  score: number;
+  state: "quiet" | "forming" | "alive";
+  depth: BrainDepth;
+  titleKey: string;
+  actionKey: string;
+  source: "memory_service" | "frontend_fallback";
+  signals: {
+    memoryCount: number;
+    conceptCount: number;
+    relationshipCount: number;
+    healthySources: number;
+  };
+};
+
+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

@@ -31,6 +31,7 @@ export const COPY: Record<Language, TextMap> = {
     "brain.aria.home": "Lattice Brain",
     "brain.aria.exploration": "Brain 탐색",
     "brain.aria.quickViews": "Brain 빠른 보기",
+    "brain.depthRail.aria": "Brain 깊이 진행 상태",
     "brain.aria.conversation": "대화",
     "brain.aria.ownership": "Brain 소유 보장",
     "brain.aria.starterPrompts": "시작 프롬프트",
@@ -52,11 +53,19 @@ 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": "이미지 첨부됨",
     "brain.send": "보내기",
     "brain.saved": "기억에 저장됨 · 연결된 주제 {topics}개 · 관련 기억 {memories}개",
+    "brain.saved.detail": "출처와 함께 나중에 다시 불러올 수 있습니다.",
     "brain.recalled": "기억을 다시 꺼냈습니다: {title}",
     "brain.overview.kicker": "Brain 한눈에 보기",
     "brain.overview.title": "기억과 주제를 바로 확인하세요.",
@@ -67,6 +76,30 @@ export const COPY: Record<Language, TextMap> = {
     "brain.overview.olderEmpty": "대화가 쌓이면 과거 기억이 보입니다.",
     "brain.overview.topics": "주요 주제",
     "brain.overview.topicsEmpty": "주제가 형성되는 중입니다.",
+    "brain.readiness.kicker": "Brain 준비도",
+    "brain.readiness.aria": "Brain 준비도 점수",
+    "brain.readiness.quiet": "첫 기억을 기다리고 있습니다.",
+    "brain.readiness.forming": "기억이 주제로 자라는 중입니다.",
+    "brain.readiness.alive": "기억과 관계가 연결되어 있습니다.",
+    "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": "지식이 형성되는 중입니다.",
     "brain.graph.empty": "아직 맞는 지식이 없습니다.",
@@ -352,6 +385,7 @@ export const COPY: Record<Language, TextMap> = {
     "brain.aria.home": "Lattice Brain",
     "brain.aria.exploration": "Brain exploration",
     "brain.aria.quickViews": "Brain quick views",
+    "brain.depthRail.aria": "Brain depth progress",
     "brain.aria.conversation": "Conversation",
     "brain.aria.ownership": "Brain ownership guarantees",
     "brain.aria.starterPrompts": "Starter prompts",
@@ -373,11 +407,19 @@ 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",
     "brain.send": "Send",
     "brain.saved": "Saved to memory · {topics} linked topics · {memories} related memories",
+    "brain.saved.detail": "Available later with source-aware recall.",
     "brain.recalled": "Recalled this memory: {title}",
     "brain.overview.kicker": "Brain at a glance",
     "brain.overview.title": "See memories and topics immediately.",
@@ -388,6 +430,30 @@ export const COPY: Record<Language, TextMap> = {
     "brain.overview.olderEmpty": "Earlier memories appear as conversations accumulate.",
     "brain.overview.topics": "Main topics",
     "brain.overview.topicsEmpty": "Topics are still forming.",
+    "brain.readiness.kicker": "Brain readiness",
+    "brain.readiness.aria": "Brain readiness score",
+    "brain.readiness.quiet": "Waiting for the first memory.",
+    "brain.readiness.forming": "Memories are becoming topics.",
+    "brain.readiness.alive": "Memories and relationships are connected.",
+    "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",
     "brain.graph.empty": "No matching knowledge yet",