ltcai 6.5.0 → 6.6.0

package/README.md

@@ -200,31 +200,32 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release Preparation
 
-The current development target is **6.5.0 Brain Experience Readiness**:
-
-- Brain Home now gives normal users a readiness signal that explains whether
-  the Brain is waiting for its first memory, turning memories into topics, or
-  ready to explore as a connected map. That signal now comes from the backend
-  Memory Manager summary instead of a frontend-only estimate.
-- The Living Brain surface now includes a persistent depth progress rail, so
-  users can understand and reverse the path from conversation to memory,
-  topics, relationships, and the full knowledge graph.
-- Memory-save feedback now explicitly states that saved context is available
-  later with source-aware recall, closing the gap between "chat happened" and
-  "my Brain became more useful."
-- The release keeps the 6.4.0 quality hardening intact and focuses on
-  end-user comprehension rather than adding a new storage or graph schema.
+The current development target is **6.6.0 Brain Proof Runtime**:
+
+- Brain Home now shows backend-owned proof that the Brain is a durable context
+  store: saved context count, active-model continuity, graph/vector depth, and
+  the most recent recallable item.
+- Brain Home now gives first-time users a direct document upload CTA in the
+  empty state and composer, backed by workspace-scoped document ingestion.
+- `/api/memory/brain-proof` combines Memory Manager readiness, unified recall,
+  graph/vector state, and the active model id so the first screen can say
+  "model changed, context stayed" without guessing in the frontend.
+- App-factory interaction wiring now passes active-model state into the Memory
+  router through typed runtime context, keeping Brain proof assembly out of the
+  monolithic factory body.
+- The release keeps the 6.4.0/6.5.0 Brain readiness and quality hardening intact
+  while making the first-five-minute value proposition visible.
 - 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.5.0 release must use exact filenames:
+Expected artifacts for 6.6.0 release must use exact filenames:
 
-- `dist/ltcai-6.5.0-py3-none-any.whl`
-- `dist/ltcai-6.5.0.tar.gz`
-- `ltcai-6.5.0.tgz`
-- `dist/ltcai-6.5.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_6.5.0_aarch64.dmg`
+- `dist/ltcai-6.6.0-py3-none-any.whl`
+- `dist/ltcai-6.6.0.tar.gz`
+- `ltcai-6.6.0.tgz`
+- `dist/ltcai-6.6.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_6.6.0_aarch64.dmg`
 
 Do not upload `dist/*`. Package registry publishing remains owner-run.
 
@@ -243,6 +244,7 @@ Do not upload `dist/*`. Package registry publishing remains owner-run.
 
 | Version | Theme |
 | --- | --- |
+| 6.6.0 | Brain Proof Runtime: backend-owned Brain proof API, model-continuity wiring, first-screen proof that saved context can be recalled across model changes, and direct Brain Home document upload |
 | 6.5.0 | Brain Experience Readiness: Brain readiness signal, depth progress rail, source-aware memory-save feedback, and visual coverage for the first-memory loop |
 | 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 |

package/docs/CHANGELOG.md

@@ -3,6 +3,40 @@
 The top entry is the current release-preparation target. Older entries are
 historical and may describe behavior as it existed at that release.
 
+## [6.6.0] - 2026-06-18
+
+> Brain Proof Runtime. Makes the first-five-minute Brain value visible by
+> showing backend-owned evidence that saved context can be recalled and survives
+> model changes.
+
+### Added
+- `/api/memory/brain-proof`, backed by `MemoryService.brain_proof()`, combining
+  Brain readiness, durable memory counts, graph/vector depth, active model id,
+  and a unified recall sample.
+- Brain Home proof strip for recallable context, model-continuity, and
+  knowledge-store state.
+- Recent recall proof card that surfaces the latest memory/item the Brain can
+  bring back after a useful exchange.
+- Brain Home document upload CTA in the empty state and composer, giving the
+  first session a direct way to grow the Brain with files.
+- Unit coverage for model-independent Brain proof recall behavior.
+- Honest empty-state Brain proof: model-independent capability remains visible,
+  but continuity is only marked proven after durable evidence exists.
+
+### Changed
+- Interaction router runtime context now carries an active-model getter into
+  the Memory router, reducing app-factory inline wiring while preserving route
+  order.
+- Default Brain proof recall seeding is scoped to the current user/workspace
+  before falling back to conversation memory.
+- Chat-to-Knowledge-Graph ingestion now carries workspace scope into projected
+  graph nodes, and Brain proof conversation counts use scoped conversations so
+  another user/workspace cannot make an empty Brain look proven.
+- Direct Knowledge Graph ingest and document upload ingestion now resolve the
+  request workspace and project that scope into graph/source/document nodes.
+- Package/runtime/static metadata is synchronized to 6.6.0; package publish and
+  deployment remain owner-run only.
+
 ## [6.5.0] - 2026-06-18
 
 > Brain Experience Readiness. Uses the 6.4.0 quality baseline to improve what

package/frontend/openapi.json

@@ -3757,7 +3757,7 @@
   },
   "info": {
     "title": "Lattice AI Server (local)",
-    "version": "5.6.0"
+    "version": "6.6.0"
   },
   "openapi": "3.1.0",
   "paths": {
@@ -6941,6 +6941,70 @@
         "summary": "Local Agent Status"
       }
     },
+    "/api/memory/brain-proof": {
+      "get": {
+        "operationId": "brain_proof_api_memory_brain_proof_get",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "q",
+            "required": false,
+            "schema": {
+              "default": "",
+              "title": "Q",
+              "type": "string"
+            }
+          },
+          {
+            "in": "query",
+            "name": "limit",
+            "required": false,
+            "schema": {
+              "default": 3,
+              "title": "Limit",
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            },
+            "description": "Successful Response"
+          },
+          "422": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            },
+            "description": "Validation Error"
+          }
+        },
+        "summary": "Brain Proof"
+      }
+    },
+    "/api/memory/brain-quality": {
+      "get": {
+        "operationId": "brain_quality_summary_api_memory_brain_quality_get",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            },
+            "description": "Successful Response"
+          }
+        },
+        "summary": "Brain Quality Summary"
+      }
+    },
     "/api/memory/clear": {
       "post": {
         "operationId": "memory_clear_api_memory_clear_post",

package/frontend/src/api/client.ts

@@ -446,6 +446,7 @@ export const latticeApi = {
   browserReadUrl: (url: string) => post("/api/browser/read-url", { url }, {}),
   memoryManager: () => get("/api/memory/manager", { sources: [], tiers: [], usage: {} }),
   memoryBrainQuality: () => get("/api/memory/brain-quality", {}),
+  memoryBrainProof: (query = "", limit = 3) => get("/api/memory/brain-proof", { proofs: {}, recall: { items: [] }, model_continuity: {}, claims: {} }, { q: query, limit }),
   memoryRecall: (query: string, limit = 20) => post("/api/memory/recall", { query, limit }, { matches: [] }),
   memoryCompact: () => post("/api/memory/compact", {}, {}),
   memoryRebuild: () => post("/api/memory/rebuild", { target: "vector" }, {}),

package/frontend/src/api/openapi.ts

@@ -1550,6 +1550,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/memory/brain-proof": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Brain Proof */
+        get: operations["brain_proof_api_memory_brain_proof_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/memory/brain-quality": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Brain Quality Summary */
+        get: operations["brain_quality_summary_api_memory_brain_quality_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/memory/clear": {
         parameters: {
             query?: never;
@@ -10322,6 +10356,58 @@ export interface operations {
             };
         };
     };
+    brain_proof_api_memory_brain_proof_get: {
+        parameters: {
+            query?: {
+                q?: string;
+                limit?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    brain_quality_summary_api_memory_brain_quality_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
     memory_clear_api_memory_clear_post: {
         parameters: {
             query?: never;

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

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { ImagePlus, Send } from "lucide-react";
+import { FileUp, ImagePlus, Send } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { t, type Language } from "@/i18n";
 
@@ -8,16 +8,20 @@ export function BrainComposer({
   draft,
   streaming,
   imageData,
+  uploadingDocument,
   onDraftChange,
   onImageDataChange,
+  onUploadDocument,
   onSend,
 }: {
   language: Language;
   draft: string;
   streaming: boolean;
   imageData: string | null;
+  uploadingDocument: boolean;
   onDraftChange: (value: string) => void;
   onImageDataChange: (value: string | null) => void;
+  onUploadDocument: (file: File) => void;
   onSend: () => void;
 }) {
   return (
@@ -34,6 +38,21 @@ export function BrainComposer({
         placeholder={t(language, "brain.placeholder")}
       />
       <div className="brain-composer-actions">
+        <label className={`brain-document-input ${uploadingDocument ? "is-disabled" : ""}`}>
+          <FileUp className="h-3.5 w-3.5" />
+          <span>{uploadingDocument ? t(language, "brain.upload.uploading") : t(language, "brain.upload.ctaShort")}</span>
+          <input
+            type="file"
+            accept=".pdf,.docx,.xlsx,.pptx,.txt,.md,.csv,application/pdf,text/plain,text/markdown,text/csv"
+            className="sr-only"
+            disabled={uploadingDocument}
+            onChange={(event) => {
+              const file = event.target.files?.[0];
+              event.currentTarget.value = "";
+              if (file) onUploadDocument(file);
+            }}
+          />
+        </label>
         <label className="brain-image-input">
           <ImagePlus className="h-3.5 w-3.5" />
           <span>{t(language, "brain.image")}</span>

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

@@ -2,7 +2,7 @@ import * as React from "react";
 import { DatabaseZap, ShieldCheck } from "lucide-react";
 import { LanguageSwitcher } from "@/components/LanguageSwitcher";
 import { t, type Language } from "@/i18n";
-import type { BrainDepth, BrainReadiness, KnowledgeConcept, MemoryFragment, Message } from "./types";
+import type { BrainDepth, BrainProof, BrainReadiness, KnowledgeConcept, MemoryFragment, Message } from "./types";
 import { BrainCarePanel } from "./BrainCarePanel";
 import { BrainComposer } from "./BrainComposer";
 import { BrainOverviewPanel } from "./BrainOverviewPanel";
@@ -21,9 +21,12 @@ export function BrainConversation({
   memories,
   concepts,
   readiness,
+  proof,
+  uploadingDocument,
   onOpenDepth,
   onDraftChange,
   onImageDataChange,
+  onUploadDocument,
   onSend,
 }: {
   language: Language;
@@ -39,9 +42,12 @@ export function BrainConversation({
   memories: MemoryFragment[];
   concepts: KnowledgeConcept[];
   readiness: BrainReadiness;
+  proof: BrainProof;
+  uploadingDocument: boolean;
   onOpenDepth: (depth: BrainDepth) => void;
   onDraftChange: (value: string) => void;
   onImageDataChange: (value: string | null) => void;
+  onUploadDocument: (file: File) => void;
   onSend: () => void;
 }) {
   return (
@@ -69,10 +75,17 @@ export function BrainConversation({
           memories={memories}
           concepts={concepts}
           readiness={readiness}
+          proof={proof}
           onOpenDepth={onOpenDepth}
         />
         {messages.length === 0 ? (
-          <BrainEmptyState language={language} starterPrompts={starterPrompts} onDraftChange={onDraftChange} />
+          <BrainEmptyState
+            language={language}
+            starterPrompts={starterPrompts}
+            uploadingDocument={uploadingDocument}
+            onDraftChange={onDraftChange}
+            onUploadDocument={onUploadDocument}
+          />
         ) : (
           messages.map((message, index) => (
             <div key={`${message.role}-${index}`} className={`brain-message ${message.role}`}>
@@ -97,8 +110,10 @@ export function BrainConversation({
         draft={draft}
         streaming={streaming}
         imageData={imageData}
+        uploadingDocument={uploadingDocument}
         onDraftChange={onDraftChange}
         onImageDataChange={onImageDataChange}
+        onUploadDocument={onUploadDocument}
         onSend={onSend}
       />
     </section>
@@ -108,17 +123,37 @@ export function BrainConversation({
 function BrainEmptyState({
   language,
   starterPrompts,
+  uploadingDocument,
   onDraftChange,
+  onUploadDocument,
 }: {
   language: Language;
   starterPrompts: string[];
+  uploadingDocument: boolean;
   onDraftChange: (value: string) => void;
+  onUploadDocument: (file: File) => void;
 }) {
   return (
     <div className="mind-empty">
       <div className="mind-empty-kicker">{t(language, "brain.empty.kicker")}</div>
       <div className="mind-empty-title">{t(language, "brain.empty.title")}</div>
       <p>{t(language, "brain.empty.body")}</p>
+      <label className={`mind-empty-upload ${uploadingDocument ? "is-disabled" : ""}`}>
+        <DatabaseZap className="h-3.5 w-3.5" />
+        <span>{uploadingDocument ? t(language, "brain.upload.uploading") : t(language, "brain.upload.cta")}</span>
+        <input
+          type="file"
+          accept=".pdf,.docx,.xlsx,.pptx,.txt,.md,.csv,application/pdf,text/plain,text/markdown,text/csv"
+          className="sr-only"
+          disabled={uploadingDocument}
+          onChange={(event) => {
+            const file = event.target.files?.[0];
+            event.currentTarget.value = "";
+            if (file) onUploadDocument(file);
+          }}
+        />
+      </label>
+      <small className="mind-empty-upload-hint">{t(language, "brain.upload.hint")}</small>
       <div className="mind-empty-prompts" aria-label={t(language, "brain.aria.starterPrompts")}>
         {starterPrompts.map((prompt) => (
           <button key={prompt} type="button" onClick={() => onDraftChange(prompt)}>

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 { buildBrainReadiness, 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),
@@ -55,6 +61,10 @@ export function BrainHome({
     [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(
     () => [
@@ -123,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);
     }
   }
 
@@ -242,9 +279,12 @@ export function BrainHome({
         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/BrainOverviewPanel.tsx

@@ -1,23 +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, BrainReadiness, 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")}>
@@ -60,10 +68,63 @@ export function BrainOverviewPanel({
           {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,