ltcai 6.5.0 → 6.7.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.5.0/screenshots/01-login.png)
+![Login](output/release/v6.7.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.5.0/screenshots/02-environment-analysis.png)
+![Environment Analysis](output/release/v6.7.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.5.0/screenshots/03-recommended-models.png)
+![Recommended Models](output/release/v6.7.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.5.0/screenshots/04-install-load-progress.png)
+![Install and Load](output/release/v6.7.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.5.0/screenshots/05-brain-chat-home.png)
+![Brain Chat Home](output/release/v6.7.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.5.0/screenshots/13-review-center.png)
+![Review Center](output/release/v6.7.0/screenshots/13-review-center.png)
 
 ## Brain Depths
 
@@ -120,10 +120,10 @@ The user travels inward from everyday memory to deeper structure:
 
 Walkthrough:
 
-![v6.5.0 Living Brain walkthrough](output/release/v6.5.0/gifs/v6.5.0-living-brain-walkthrough.gif)
+![v6.7.0 Living Brain walkthrough](output/release/v6.7.0/gifs/v6.7.0-living-brain-walkthrough.gif)
 
 Screenshot index and capture notes:
-[output/release/v6.5.0/SCREENSHOT_INDEX.md](output/release/v6.5.0/SCREENSHOT_INDEX.md)
+[output/release/v6.7.0/SCREENSHOT_INDEX.md](output/release/v6.7.0/SCREENSHOT_INDEX.md)
 
 ## Install
 
@@ -198,33 +198,31 @@ npm run docs:check-links
 
 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 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:
-
-- `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`
+## Current Release
+
+The current release is **6.7.0 Brain IA Cleanup**:
+
+- Brain Home now surfaces direct actions for adding documents, searching the
+  graph, changing models, and opening settings.
+- The rich Capture, Brain explorer, Library, System, and Act pages are mounted
+  inside a shared Brain shell instead of existing only as hard-to-discover
+  compatibility routes.
+- `routes.ts` now separates product shell routes from legacy compatibility
+  aliases, so visible IA and old entry URLs can evolve independently.
+- Rich pages are code-split with lazy route loading. The first Brain Home bundle
+  stays below the previous warning threshold while graph/search/model/settings
+  surfaces load when opened.
+- The release keeps the 6.6.0 backend-owned Brain proof loop and
+  workspace-scoped ingestion intact while making the product actions more
+  obvious in the first five minutes.
+
+Expected artifacts for 6.7.0 release must use exact filenames:
+
+- `dist/ltcai-6.7.0-py3-none-any.whl`
+- `dist/ltcai-6.7.0.tar.gz`
+- `ltcai-6.7.0.tgz`
+- `dist/ltcai-6.7.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_6.7.0_aarch64.dmg`
 
 Do not upload `dist/*`. Package registry publishing remains owner-run.
 
@@ -243,6 +241,8 @@ Do not upload `dist/*`. Package registry publishing remains owner-run.
 
 | Version | Theme |
 | --- | --- |
+| 6.7.0 | Brain IA Cleanup: reachable rich pages, separated product routes vs compatibility aliases, shared Brain shell navigation, and lazy-loaded rich pages |
+| 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

@@ -1,7 +1,64 @@
 # Changelog
 
-The top entry is the current release-preparation target. Older entries are
-historical and may describe behavior as it existed at that release.
+The top entry is either the current unreleased main-branch work or the current
+release line. Older entries are historical and may describe behavior as it
+existed at that release.
+
+## [6.7.0] - 2026-06-18
+
+> Brain IA Cleanup. Makes rich product pages reachable from Brain Home,
+> separates visible product IA from legacy compatibility aliases, and
+> code-splits heavy pages out of the first Brain bundle.
+
+### Changed
+- Brain Home now exposes direct action routes for adding documents, searching
+  the knowledge graph, changing models, and opening settings, so the rich
+  Capture, Brain explorer, Library, and System pages are reachable from the
+  first Brain flow.
+- The post-onboarding app shell now mounts Capture, Brain explorer/graph,
+  Library, System, and Act pages inside a shared Brain shell navigation instead
+  of leaving those rich pages as compatibility-only routes.
+- `routes.ts` now keeps product shell routes and compatibility aliases in
+  separate maps while preserving old hash/entry URLs.
+- Rich pages now load through `React.lazy`, splitting Brain explorer, Capture,
+  Library, System, and Act chunks away from the initial Brain Home bundle.
+- Package/runtime/static metadata is synchronized to 6.7.0; package publish and
+  deployment remain owner-run only.
+
+## [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.
+- Refreshed README-linked release evidence under `output/release/v6.6.0/`.
+- 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
 

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/App.tsx

@@ -2,11 +2,16 @@ import * as React from "react";
 import { type BrainState } from "@/components/LivingBrain";
 import { ProductFlow, readProductFlowComplete } from "@/components/ProductFlow";
 import { useAppStore } from "@/store/appStore";
-import { parseHash } from "@/routes";
-import { ActPage } from "@/pages/Act";
+import { parseHash, productShellRoutes } from "@/routes";
 import { BrainHome } from "@/features/brain/BrainHome";
 import { AdminConsole } from "@/features/admin/AdminConsole";
 
+const ActPage = React.lazy(() => import("@/pages/Act").then((module) => ({ default: module.ActPage })));
+const BrainPage = React.lazy(() => import("@/pages/Brain").then((module) => ({ default: module.BrainPage })));
+const CapturePage = React.lazy(() => import("@/pages/Capture").then((module) => ({ default: module.CapturePage })));
+const LibraryPage = React.lazy(() => import("@/pages/Library").then((module) => ({ default: module.LibraryPage })));
+const SystemPage = React.lazy(() => import("@/pages/System").then((module) => ({ default: module.SystemPage })));
+
 export default function App() {
   const theme = useAppStore((state) => state.theme);
   const language = useAppStore((state) => state.language);
@@ -41,7 +46,41 @@ export default function App() {
       {rawRoute.startsWith("/admin") ? (
         <AdminConsole onBack={() => navigateHash("/brain")} />
       ) : parsed.primary === "act" ? (
-        <ActPage initialTab={parsed.tab} />
+        <BrainShell active={parsed.primary}>
+          <React.Suspense fallback={<PageLoader />}>
+            <ActPage initialTab={parsed.tab} />
+          </React.Suspense>
+        </BrainShell>
+      ) : parsed.primary === "capture" ? (
+        <BrainShell active={parsed.primary}>
+          <React.Suspense fallback={<PageLoader />}>
+            <CapturePage initialTab={parsed.tab} />
+          </React.Suspense>
+        </BrainShell>
+      ) : parsed.primary === "library" ? (
+        <BrainShell active={parsed.primary}>
+          <React.Suspense fallback={<PageLoader />}>
+            <LibraryPage initialTab={parsed.tab} />
+          </React.Suspense>
+        </BrainShell>
+      ) : parsed.primary === "system" ? (
+        <BrainShell active={parsed.primary}>
+          <React.Suspense fallback={<PageLoader />}>
+            <SystemPage initialTab={parsed.tab} />
+          </React.Suspense>
+        </BrainShell>
+      ) : parsed.primary === "memory" ? (
+        <BrainShell active="memory">
+          <React.Suspense fallback={<PageLoader />}>
+            <BrainPage initialTab="memory" />
+          </React.Suspense>
+        </BrainShell>
+      ) : parsed.primary === "brain" && parsed.tab && parsed.tab !== "conversation" ? (
+        <BrainShell active="brain">
+          <React.Suspense fallback={<PageLoader />}>
+            <BrainPage initialTab={parsed.tab} />
+          </React.Suspense>
+        </BrainShell>
       ) : (
         <BrainHome brainState={brainState} intensity={intensity} onBrainChange={setBrain} />
       )}
@@ -49,6 +88,42 @@ export default function App() {
   );
 }
 
+function BrainShell({
+  active,
+  children,
+}: {
+  active: string;
+  children: React.ReactNode;
+}) {
+  return (
+    <main className="brain-shell-page" aria-label="Lattice workspace">
+      <nav className="brain-shell-nav" aria-label="Brain workspace navigation">
+        {productShellRoutes.map((item) => (
+          <button
+            key={item.id}
+            type="button"
+            className={item.id === active ? "is-active" : ""}
+            onClick={() => navigateHash(`/${item.path}`)}
+          >
+            {item.label}
+          </button>
+        ))}
+      </nav>
+      <section className="brain-shell-content">
+        {children}
+      </section>
+    </main>
+  );
+}
+
+function PageLoader() {
+  return (
+    <div className="brain-shell-loader" role="status">
+      Loading Brain workspace...
+    </div>
+  );
+}
+
 function useHashRoute() {
   const read = React.useCallback(() => {
     const hash = window.location.hash.replace(/^#/, "");

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

@@ -1,8 +1,8 @@
 import * as React from "react";
-import { DatabaseZap, ShieldCheck } from "lucide-react";
+import { Cpu, DatabaseZap, FileUp, Search, Settings, 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 (
@@ -57,7 +63,25 @@ export function BrainConversation({
           <span>{t(language, "brain.portable")}</span>
           <span>{t(language, "brain.private")}</span>
         </div>
-        <div>{modelName}</div>
+        <div className="brain-flow-actions" aria-label={t(language, "brain.aria.actions")}>
+          <button type="button" onClick={() => navigateHash("/capture")}>
+            <FileUp className="h-3.5 w-3.5" />
+            {t(language, "brain.action.add")}
+          </button>
+          <button type="button" onClick={() => navigateHash("/knowledge-graph")}>
+            <Search className="h-3.5 w-3.5" />
+            {t(language, "brain.action.find")}
+          </button>
+          <button type="button" onClick={() => navigateHash("/models")}>
+            <Cpu className="h-3.5 w-3.5" />
+            {t(language, "brain.action.model")}
+          </button>
+          <button type="button" onClick={() => navigateHash("/settings")}>
+            <Settings className="h-3.5 w-3.5" />
+            {t(language, "brain.action.settings")}
+          </button>
+        </div>
+        <div className="brain-model-pill">{modelName}</div>
         <button className="brain-admin-link" type="button" onClick={() => navigateHash("/admin")}>
           <ShieldCheck className="h-3.5 w-3.5" />
           {t(language, "brain.admin")}
@@ -69,10 +93,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 +128,10 @@ export function BrainConversation({
         draft={draft}
         streaming={streaming}
         imageData={imageData}
+        uploadingDocument={uploadingDocument}
         onDraftChange={onDraftChange}
         onImageDataChange={onImageDataChange}
+        onUploadDocument={onUploadDocument}
         onSend={onSend}
       />
     </section>
@@ -108,17 +141,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)}>