ltcai 6.4.0 → 6.6.0

package/README.md

@@ -69,42 +69,42 @@ You need Lattice AI when:
 Choose the owner of the Brain. The profile is not a SaaS account by default; it
 is the local identity for the knowledge you keep.
 
-![Login](output/release/v6.4.0/screenshots/01-login.png)
+![Login](output/release/v6.5.0/screenshots/01-login.png)
 
 ### 2. Environment Analysis
 
 See what kind of local AI experience this computer can support before choosing a
 model.
 
-![Environment Analysis](output/release/v6.4.0/screenshots/02-environment-analysis.png)
+![Environment Analysis](output/release/v6.5.0/screenshots/02-environment-analysis.png)
 
 ### 3. Recommended Models
 
 Start with a short list: safest recommendation, faster model, stronger model.
 Advanced details stay available without overwhelming first-time users.
 
-![Recommended Models](output/release/v6.4.0/screenshots/03-recommended-models.png)
+![Recommended Models](output/release/v6.5.0/screenshots/03-recommended-models.png)
 
 ### 4. Install And Load
 
 Download and load only after consent. Lattice explains model size, local
 execution, and network use before work starts.
 
-![Install and Load](output/release/v6.4.0/screenshots/04-install-load-progress.png)
+![Install and Load](output/release/v6.5.0/screenshots/04-install-load-progress.png)
 
 ### 5. Brain Chat
 
 Talk normally. Useful decisions and context become memory, then appear later as
 topics, relationships, and graph structure.
 
-![Brain Chat Home](output/release/v6.4.0/screenshots/05-brain-chat-home.png)
+![Brain Chat Home](output/release/v6.5.0/screenshots/05-brain-chat-home.png)
 
 ### 6. Review Center
 
 Automation results are staged for review before they become durable decisions.
 Snooze, unsnooze, run now, approve, and dismiss actions stay explicit.
 
-![Review Center](output/release/v6.4.0/screenshots/13-review-center.png)
+![Review Center](output/release/v6.5.0/screenshots/13-review-center.png)
 
 ## Brain Depths
 
@@ -120,10 +120,10 @@ The user travels inward from everyday memory to deeper structure:
 
 Walkthrough:
 
-![v6.4.0 Living Brain walkthrough](output/release/v6.4.0/gifs/v6.4.0-living-brain-walkthrough.gif)
+![v6.5.0 Living Brain walkthrough](output/release/v6.5.0/gifs/v6.5.0-living-brain-walkthrough.gif)
 
 Screenshot index and capture notes:
-[output/release/v6.4.0/SCREENSHOT_INDEX.md](output/release/v6.4.0/SCREENSHOT_INDEX.md)
+[output/release/v6.5.0/SCREENSHOT_INDEX.md](output/release/v6.5.0/SCREENSHOT_INDEX.md)
 
 ## Install
 
@@ -200,31 +200,32 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release Preparation
 
-The current development target is **6.4.0 Digital Brain Quality Hardening**:
-
-- `lattice_brain.quality` adds a non-destructive Brain quality layer for
-  embedding fallback labelling, drift/re-index planning, BM25 lexical scoring,
-  hybrid fusion, reranker fallback contracts, memory candidate quality,
-  graph-edge confidence/evidence scoring, structured context guardrails, and
-  retrieval benchmark metrics.
-- Graph/search API reads now carry workspace scope through graph, node,
-  neighborhood, relationship, keyword, vector, graph, and hybrid search paths.
-- Memory Manager prune, compact, and clear operations are scoped to the
-  caller's workspace and owner boundary; unscoped graph clearing from Memory
-  Manager is blocked until a workspace-safe graph delete path exists.
-- Digital Brain quality documentation now records the 6.4.0 baseline, risk
-  register, validation checklist, and intentionally deferred work.
+The 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.4.0 release must use exact filenames:
+Expected artifacts for 6.6.0 release must use exact filenames:
 
-- `dist/ltcai-6.4.0-py3-none-any.whl`
-- `dist/ltcai-6.4.0.tar.gz`
-- `ltcai-6.4.0.tgz`
-- `dist/ltcai-6.4.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_6.4.0_aarch64.dmg`
+- `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,8 @@ 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 |
 | 6.3.0 | Product Hardening Completion: Brain archive/provenance/ingestion UX polish, Review Center Run Now contract hardening, local model runtime status, app-factory review wiring, shim smoke, i18n guard, and exact release artifacts |

package/docs/CHANGELOG.md

@@ -3,6 +3,68 @@
 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
+> normal users can understand: how alive the Brain is, where they are in the
+> memory-to-graph journey, and what changed after a useful exchange is saved.
+
+### Added
+- Brain Home readiness strip that classifies the current Brain as waiting for
+  its first memory, forming topics, or ready for map exploration.
+- Backend-owned Brain readiness summary from `MemoryService`, exposed through
+  `/api/memory/manager` and `/api/memory/brain-quality`, so the UI no longer
+  has to infer Brain growth from local fragments.
+- Persistent depth progress rail across the Living Brain surface so the
+  memory -> topics -> relationships -> graph journey is visible and reversible.
+- Source-aware memory-save detail under chat feedback, making the recall loop
+  explicit after a conversation enriches the Brain.
+- Visual regression assertions for Brain readiness, depth progress, and
+  source-aware memory-save feedback.
+
+### Changed
+- Brain overview empty states now guide first-memory use without exposing graph
+  internals or administrator language.
+- Brain readiness now uses the same memory, graph, relationship, and source
+  health signals that the Memory Manager reports, keeping product UX aligned
+  with backend Brain state.
+- Package/runtime/static metadata is synchronized to 6.5.0; package publish and
+  deployment remain owner-run only.
+
 ## [6.4.0] - 2026-06-17
 
 > Digital Brain Quality Hardening. Tightens workspace-scoped Brain retrieval

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

@@ -445,6 +445,8 @@ 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

@@ -1,8 +1,8 @@
 import * as React from "react";
-import { ShieldCheck } from "lucide-react";
+import { DatabaseZap, ShieldCheck } from "lucide-react";
 import { LanguageSwitcher } from "@/components/LanguageSwitcher";
 import { t, type Language } from "@/i18n";
-import type { BrainDepth, 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";
@@ -20,9 +20,13 @@ export function BrainConversation({
   streamRef,
   memories,
   concepts,
+  readiness,
+  proof,
+  uploadingDocument,
   onOpenDepth,
   onDraftChange,
   onImageDataChange,
+  onUploadDocument,
   onSend,
 }: {
   language: Language;
@@ -37,9 +41,13 @@ export function BrainConversation({
   streamRef: React.RefObject<HTMLDivElement | null>;
   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 (
@@ -66,10 +74,18 @@ export function BrainConversation({
         <BrainOverviewPanel
           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}`}>
@@ -79,7 +95,13 @@ export function BrainConversation({
         )}
       </div>
 
-      {memoryFeedback ? <div className="brain-save-feedback" role="status">{memoryFeedback}</div> : null}
+      {memoryFeedback ? (
+        <div className="brain-save-feedback" role="status">
+          <DatabaseZap className="h-3.5 w-3.5" />
+          <span>{memoryFeedback}</span>
+          <small>{t(language, "brain.saved.detail")}</small>
+        </div>
+      ) : null}
 
       <BrainCarePanel language={language} />
 
@@ -88,8 +110,10 @@ export function BrainConversation({
         draft={draft}
         streaming={streaming}
         imageData={imageData}
+        uploadingDocument={uploadingDocument}
         onDraftChange={onDraftChange}
         onImageDataChange={onImageDataChange}
+        onUploadDocument={onUploadDocument}
         onSend={onSend}
       />
     </section>
@@ -99,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)}>