ltcai 4.4.0 → 4.6.0

package/frontend/src/pages/Ask.tsx

@@ -1,200 +1,5 @@
-import * as React from "react";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { ImagePlus, MessageSquare, Send, Trash2 } from "lucide-react";
-import { latticeApi } from "@/api/client";
-import { DataPanel, EmptyState, EntityList, SourceBadge, StructuredView } from "@/components/primitives";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
-import { Textarea } from "@/components/ui/textarea";
-import { asArray } from "@/lib/utils";
-
-type Msg = { role?: string; content?: string; timestamp?: string };
-
-function fileToDataUrl(file: File) {
-  return new Promise<string>((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(String(reader.result || ""));
-    reader.onerror = () => reject(reader.error);
-    reader.readAsDataURL(file);
-  });
-}
+import { BrainConversation } from "@/components/BrainConversation";
 
 export function AskPage() {
-  const qc = useQueryClient();
-  const history = useQuery({ queryKey: ["chatHistory"], queryFn: latticeApi.chatHistory });
-  const models = useQuery({ queryKey: ["models"], queryFn: latticeApi.models });
-  const [conversationId, setConversationId] = React.useState<string | null>(null);
-  const conversation = useQuery({
-    queryKey: ["conversation", conversationId],
-    queryFn: () => latticeApi.conversation(conversationId || ""),
-    enabled: !!conversationId,
-  });
-  const [messages, setMessages] = React.useState<Msg[]>([]);
-  const [draft, setDraft] = React.useState("");
-  const [imageData, setImageData] = React.useState<string | null>(null);
-  const [trace, setTrace] = React.useState<unknown>(null);
-  const [streaming, setStreaming] = React.useState(false);
-
-  React.useEffect(() => {
-    if (conversation.data?.ok) setMessages(asArray<Msg>((conversation.data.data as Record<string, unknown>).messages || conversation.data.data));
-  }, [conversation.data]);
-
-  const send = async () => {
-    const message = draft.trim();
-    if (!message || streaming) return;
-    setDraft("");
-    setMessages((items) => [...items, { role: "user", content: message }, { role: "assistant", content: "" }]);
-    setStreaming(true);
-    try {
-      const result = await latticeApi.streamChat(
-        { message, conversation_id: conversationId || undefined, image_data: imageData || undefined },
-        {
-          onChunk: (_delta, fullText) => {
-            setMessages((items) => {
-              const next = [...items];
-              const last = next[next.length - 1] || { role: "assistant" };
-              next[next.length - 1] = { ...last, role: "assistant", content: fullText };
-              return next;
-            });
-          },
-          onTrace: setTrace,
-        },
-      );
-      if (result.error) {
-        setMessages((items) => {
-          const next = [...items];
-          next[next.length - 1] = { role: "assistant", content: `Unavailable: ${result.error}` };
-          return next;
-        });
-      }
-    } finally {
-      setStreaming(false);
-      setImageData(null);
-      await qc.invalidateQueries({ queryKey: ["chatHistory"] });
-    }
-  };
-
-  const deleteMutation = useMutation({
-    mutationFn: (id: string) => latticeApi.deleteConversation(id),
-    onSuccess: () => qc.invalidateQueries({ queryKey: ["chatHistory"] }),
-  });
-
-  return (
-    <div className="grid min-h-[calc(100vh-7rem)] gap-4 xl:grid-cols-[18rem_minmax(0,1fr)_22rem]">
-      <Card className="overflow-hidden">
-        <CardHeader>
-          <CardTitle className="flex items-center gap-2"><MessageSquare className="h-4 w-4" /> Conversations</CardTitle>
-          <CardDescription>Durable history from the backend conversation store.</CardDescription>
-        </CardHeader>
-        <CardContent className="space-y-2">
-          <SourceBadge result={history.data} />
-          {asArray<Record<string, unknown>>(history.data?.data).length ? asArray<Record<string, unknown>>(history.data?.data).map((item) => (
-            <button
-              key={String(item.id)}
-              onClick={() => setConversationId(String(item.id))}
-              className="block w-full rounded-md border border-border bg-background p-3 text-left text-sm transition hover:bg-muted"
-            >
-              <div className="font-medium">{String(item.title || item.id)}</div>
-              <div className="mt-1 flex items-center justify-between gap-2 text-xs text-muted-foreground">
-                <span>{String(item.updated_at || "")}</span>
-                <Trash2
-                  className="h-3.5 w-3.5"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    deleteMutation.mutate(String(item.id));
-                  }}
-                />
-              </div>
-            </button>
-          )) : <EmptyState title="No conversations" detail="Start a new exchange or sign in to load history." />}
-        </CardContent>
-      </Card>
-
-      <section className="flex min-h-[40rem] flex-col rounded-lg border border-border bg-card">
-        <div className="flex flex-wrap items-center justify-between gap-3 border-b border-border p-4">
-          <div>
-            <h1 className="text-xl font-semibold">Ask</h1>
-            <p className="text-sm text-muted-foreground">Streams through `/chat`; no local answer is fabricated when the model is unavailable.</p>
-          </div>
-          <div className="flex flex-wrap items-center gap-2">
-            <Badge variant="muted">{String((models.data?.data as Record<string, unknown>)?.current || "no model loaded")}</Badge>
-            <SourceBadge result={models.data} />
-          </div>
-        </div>
-        <div className="scrollbar-thin flex-1 space-y-3 overflow-auto p-4">
-          {messages.length ? messages.map((msg, index) => (
-            <div key={index} className={`flex ${msg.role === "user" ? "justify-end" : "justify-start"}`}>
-              <div className={`max-w-[78%] rounded-lg border p-3 text-sm ${msg.role === "user" ? "border-primary/30 bg-primary/15" : "border-border bg-background"}`}>
-                <div className="mb-1 text-xs uppercase text-muted-foreground">{msg.role || "message"}</div>
-                <div className="whitespace-pre-wrap">{msg.content}</div>
-              </div>
-            </div>
-          )) : <EmptyState title="Ready" detail="Ask a question once the backend and model are available." />}
-        </div>
-        <div className="border-t border-border p-4">
-          {imageData ? <Badge variant="success" className="mb-2">image attached</Badge> : null}
-          <Textarea
-            value={draft}
-            onChange={(e) => setDraft(e.target.value)}
-            onKeyDown={(e) => {
-              if (e.key === "Enter" && !e.shiftKey) {
-                e.preventDefault();
-                void send();
-              }
-            }}
-            placeholder="Ask the brain..."
-          />
-          <div className="mt-2 flex flex-wrap items-center justify-between gap-2">
-            <label className="inline-flex h-9 cursor-pointer items-center gap-2 rounded-md border border-border px-3 text-sm hover:bg-muted">
-              <ImagePlus className="h-4 w-4" />
-              Attach image
-              <input
-                type="file"
-                accept="image/*"
-                className="sr-only"
-                onChange={async (e) => {
-                  const file = e.target.files?.[0];
-                  if (file) setImageData(await fileToDataUrl(file));
-                }}
-              />
-            </label>
-            <Button disabled={!draft.trim() || streaming} onClick={() => void send()}>
-              <Send className="h-4 w-4" /> Send
-            </Button>
-          </div>
-        </div>
-      </section>
-
-      <aside className="space-y-4">
-        <ContextPreview question={draft || [...messages].reverse().find((m: Msg) => m.role === "user")?.content || ""} trace={trace} />
-      </aside>
-    </div>
-  );
-}
-
-function ContextPreview({ question, trace }: { question: string; trace: unknown }) {
-  const hybrid = useQuery({
-    queryKey: ["askHybrid", question],
-    queryFn: () => latticeApi.hybridSearch(question),
-    enabled: question.trim().length > 2,
-  });
-  const graph = useQuery({ queryKey: ["graph"], queryFn: latticeApi.graph });
-  return (
-    <>
-      <DataPanel title="Retrieval preview" result={hybrid.data}>
-        {(data) => <EntityList items={(data as Record<string, unknown>).matches || data} titleKey="title" metaKey="type" limit={5} />}
-      </DataPanel>
-      <DataPanel title="Graph context" result={graph.data}>
-        {(data) => <EntityList items={(data as Record<string, unknown>).nodes} titleKey="title" metaKey="type" limit={5} />}
-      </DataPanel>
-      <Card>
-        <CardHeader>
-          <CardTitle>Why this context</CardTitle>
-          <CardDescription>Trace emitted by `/chat` when the backend includes it.</CardDescription>
-        </CardHeader>
-        <CardContent>{trace ? <StructuredView value={trace} /> : <EmptyState title="No trace yet" />}</CardContent>
-      </Card>
-    </>
-  );
+  return <BrainConversation />;
 }

package/frontend/src/pages/Brain.tsx

@@ -3,15 +3,17 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import cytoscape, { Core, ElementDefinition } from "cytoscape";
 import { BrainCircuit, DatabaseBackup, Filter, Focus, Layers3, LocateFixed, Search, Sparkles } from "lucide-react";
 import { latticeApi } from "@/api/client";
-import { ActionButton, DataPanel, EmptyState, EntityList, LoadingPanel, OperationResult, StatGrid, StructuredView, Tabs } from "@/components/primitives";
+import { BrainConversation } from "@/components/BrainConversation";
+import { ActionButton, DataPanel, EmptyState, EntityList, KeyValueList, LoadingPanel, OperationResult, StatGrid, StructuredView, Tabs } from "@/components/primitives";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
 import { Input } from "@/components/ui/input";
 import { Textarea } from "@/components/ui/textarea";
+import { useAppStore } from "@/store/appStore";
 import { asArray, fmtNumber, pct, shortId, titleize } from "@/lib/utils";
 
-type BrainTab = "overview" | "graph" | "search" | "memory" | "provenance" | "portability";
+type BrainTab = "conversation" | "memory" | "knowledge" | "relationships" | "graph" | "portability";
 type LabelMode = "important" | "all" | "off";
 
 type GraphNode = {
@@ -60,12 +62,12 @@ type ExplorerModel = ParsedGraph & {
 };
 
 const tabs: Array<{ id: BrainTab; label: string }> = [
-  { id: "overview", label: "Overview" },
+  { id: "conversation", label: "Brain" },
+  { id: "memory", label: "Memories" },
+  { id: "knowledge", label: "Knowledge" },
+  { id: "relationships", label: "Relationships" },
   { id: "graph", label: "Graph" },
-  { id: "search", label: "Search" },
-  { id: "memory", label: "Memory" },
-  { id: "provenance", label: "Provenance" },
-  { id: "portability", label: "Portability" },
+  { id: "portability", label: "Care" },
 ];
 
 const groupDefinitions = [
@@ -405,15 +407,17 @@ function CytoscapeGraph({
     <div
       ref={hostRef}
       data-testid="brain-cytoscape"
-      className="h-[620px] min-h-[32rem] w-full overflow-hidden rounded-md border border-border bg-background brain-grid"
+      className="brain-grid h-[620px] min-h-[32rem] w-full overflow-hidden rounded-lg border border-border bg-background/80"
     />
   );
 }
 
 export function BrainPage({ initialTab }: { initialTab?: string }) {
-  const [tab, setTab] = React.useState<BrainTab>((initialTab as BrainTab) || "graph");
+  const mode = useAppStore((state) => state.mode);
+  const normalizedInitialTab = normalizeBrainTab(initialTab);
+  const [tab, setTab] = React.useState<BrainTab>(normalizedInitialTab);
   React.useEffect(() => {
-    if (initialTab && tabs.some((item) => item.id === initialTab)) setTab(initialTab as BrainTab);
+    setTab(normalizeBrainTab(initialTab));
   }, [initialTab]);
   const graph = useQuery({ queryKey: ["graph"], queryFn: latticeApi.graph });
   const stats = useQuery({ queryKey: ["graphStats"], queryFn: latticeApi.graphStats });
@@ -423,68 +427,90 @@ export function BrainPage({ initialTab }: { initialTab?: string }) {
   const memory = useQuery({ queryKey: ["memoryManager"], queryFn: latticeApi.memoryManager });
 
   return (
-    <div className="space-y-4">
-      <header className="grid gap-4 xl:grid-cols-[1.4fr_0.6fr]">
-        <div>
-          <div className="flex items-center gap-2 text-sm text-primary"><BrainCircuit className="h-4 w-4" /> Graph-first Digital Brain</div>
-          <h1 className="mt-2 text-3xl font-semibold tracking-normal">Brain</h1>
-          <p className="mt-2 max-w-3xl text-sm text-muted-foreground">
-            Explore the knowledge graph, memory, provenance, retrieval, and portable brain state. Empty states reflect live API availability.
-          </p>
-        </div>
-        <div className="rounded-md border border-border bg-card p-4">
-          <div className="text-xs uppercase text-muted-foreground">Provenance coverage</div>
-          <div className="mt-2 text-3xl font-semibold">{pct((coverage.data?.data as Record<string, unknown>)?.coverage_ratio)}</div>
-          <div className="mt-2 text-sm text-muted-foreground">Source: {coverage.data?.source || "loading"}</div>
-        </div>
-      </header>
+    <div className="space-y-5">
+      {tab === "conversation" ? null : (
+        <header className="brain-layer-header">
+          <div>
+            <div className="page-kicker"><BrainCircuit className="h-4 w-4" /> {tabLabel(tab)}</div>
+            <h1>{tabHeadline(tab)}</h1>
+          </div>
+          <div className="brain-layer-meter">
+            <span>Source coverage</span>
+            <strong>{pct((coverage.data?.data as Record<string, unknown>)?.coverage_ratio)}</strong>
+          </div>
+        </header>
+      )}
       <Tabs tabs={tabs} value={tab} onChange={(id) => setTab(id as BrainTab)} />
 
-      {tab === "overview" ? (
+      {tab === "conversation" ? <BrainConversation /> : null}
+      {tab === "memory" ? <MemoryPanel /> : null}
+      {tab === "knowledge" ? <HybridSearch /> : null}
+      {tab === "relationships" ? (
         <div className="grid gap-4 xl:grid-cols-2">
-          <DataPanel title="Brain status" result={stats.data}>
+          <DataPanel title="Brain activity" result={stats.data}>
             {(data) => <GraphStatus data={data as Record<string, unknown>} />}
           </DataPanel>
-          <DataPanel title="Retrieval index" result={index.data}>
+          <DataPanel title="Retrieval rhythm" result={index.data}>
             {(data) => <RetrievalStatus data={data as Record<string, unknown>} />}
           </DataPanel>
-          <DataPanel title="Memory tiers" result={memory.data}>
+          <DataPanel title="Memory layers" result={memory.data}>
             {(data) => <MemoryStatus data={data as Record<string, unknown>} />}
           </DataPanel>
-          <DataPanel title="Recent provenance" result={provenance.data}>
+          <DataPanel title="Recent sources" result={provenance.data}>
             {(data) => <EntityList items={(data as Record<string, unknown>).items || data} titleKey="source" metaKey="source_type" />}
           </DataPanel>
         </div>
       ) : null}
 
       {tab === "graph" ? (
-        graph.isLoading ? <LoadingPanel title="Knowledge graph" /> : (
-          <DataPanel title="Digital Brain explorer" description="Interactive Cytoscape.js explorer backed by /knowledge-graph/graph." result={graph.data}>
+        graph.isLoading ? <LoadingPanel title="Deep graph" /> : (
+          <DataPanel title="Advanced relationship graph" description={mode === "basic" ? "Open the deepest layer when you want to inspect the underlying relationships." : "Explore relationships, sources, and graph structure."} result={graph.data}>
             {(data) => <DigitalBrainExplorer data={data} />}
           </DataPanel>
         )
       ) : null}
-
-      {tab === "search" ? <HybridSearch /> : null}
-      {tab === "memory" ? <MemoryPanel /> : null}
-      {tab === "provenance" ? <ProvenancePanel /> : null}
       {tab === "portability" ? <PortabilityPanel /> : null}
     </div>
   );
 }
 
+function normalizeBrainTab(tab?: string): BrainTab {
+  if (tab === "overview" || tab === "chat" || tab === "ask") return "conversation";
+  if (tab === "search") return "knowledge";
+  if (tab === "provenance" || tab === "sources") return "relationships";
+  return tabs.some((item) => item.id === tab) ? tab as BrainTab : "conversation";
+}
+
+function tabLabel(tab: BrainTab) {
+  return tabs.find((item) => item.id === tab)?.label || "Brain";
+}
+
+function tabHeadline(tab: BrainTab) {
+  if (tab === "memory") return "Memories, before mechanics.";
+  if (tab === "knowledge") return "Knowledge, gathered into recall.";
+  if (tab === "relationships") return "Relationships, when you need the why.";
+  if (tab === "graph") return "The graph, intentionally opened.";
+  if (tab === "portability") return "Care for the Brain.";
+  return "Talk to your Brain.";
+}
+
 function GraphStatus({ data }: { data: Record<string, unknown> }) {
+  const mode = useAppStore((state) => state.mode);
   const nodeTypes = Object.keys((data.nodes as Record<string, unknown>) || {});
   const edgeTypes = Object.keys((data.edges as Record<string, unknown>) || {});
   return (
     <div className="space-y-3">
       <StatGrid stats={[
-        { label: "Nodes", value: data.total_nodes ?? nodeTypes.reduce((sum, key) => sum + Number(((data.nodes as Record<string, unknown>) || {})[key] || 0), 0) },
-        { label: "Edges", value: data.total_edges ?? edgeTypes.reduce((sum, key) => sum + Number(((data.edges as Record<string, unknown>) || {})[key] || 0), 0) },
-        { label: "Node types", value: nodeTypes.length },
-        { label: "Edge types", value: edgeTypes.length },
+        { label: "Memories", value: data.total_nodes ?? nodeTypes.reduce((sum, key) => sum + Number(((data.nodes as Record<string, unknown>) || {})[key] || 0), 0) },
+        { label: "Links", value: data.total_edges ?? edgeTypes.reduce((sum, key) => sum + Number(((data.edges as Record<string, unknown>) || {})[key] || 0), 0) },
+        { label: "Memory kinds", value: nodeTypes.length },
+        { label: "Link kinds", value: edgeTypes.length },
       ]} />
-      <StructuredView value={{ node_types: nodeTypes, edge_types: edgeTypes }} />
+      {mode === "basic" ? (
+        <div className="flex flex-wrap gap-1">
+          {[...nodeTypes, ...edgeTypes].slice(0, 10).map((item) => <Badge key={item} variant="muted">{titleize(item)}</Badge>)}
+        </div>
+      ) : <StructuredView value={{ memory_kinds: nodeTypes, link_kinds: edgeTypes }} />}
     </div>
   );
 }
@@ -515,10 +541,11 @@ function MemoryStatus({ data }: { data: Record<string, unknown> }) {
 }
 
 function DigitalBrainExplorer({ data }: { data: unknown }) {
+  const mode = useAppStore((state) => state.mode);
   const parsed = React.useMemo(() => parseGraph(data), [data]);
   const [search, setSearch] = React.useState("");
   const [groupFilter, setGroupFilter] = React.useState("all");
-  const [minImportance, setMinImportance] = React.useState(0);
+  const [minImportance, setMinImportance] = React.useState(mode === "basic" ? 0.1 : 0);
   const [labelMode, setLabelMode] = React.useState<LabelMode>("important");
   const [collapsedGroups, setCollapsedGroups] = React.useState<Set<string>>(new Set());
   const [selectedId, setSelectedId] = React.useState<string | null>(null);
@@ -544,11 +571,14 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
       return next;
     });
   };
+  React.useEffect(() => {
+    if (mode === "basic" && minImportance < 0.1) setMinImportance(0.1);
+  }, [mode, minImportance]);
   if (!parsed.nodes.length) {
     return (
       <EmptyState
-        title="No graph records yet"
-        detail="Capture a document, note, or local folder to create graph nodes with provenance."
+        title="No relationship records yet"
+        detail="Capture a document, note, or local folder to create connected memories with sources."
       />
     );
   }
@@ -557,7 +587,7 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
       <div className="grid gap-3 xl:grid-cols-[1fr_220px_180px_170px]">
         <div className="relative">
           <Search className="pointer-events-none absolute left-3 top-2.5 h-4 w-4 text-muted-foreground" />
-          <Input className="pl-9" value={search} onChange={(event) => setSearch(event.target.value)} placeholder="Search graph labels, types, provenance..." />
+          <Input className="pl-9" value={search} onChange={(event) => setSearch(event.target.value)} placeholder={mode === "basic" ? "Search ideas, files, people, and notes..." : "Search graph labels, types, provenance..."} />
         </div>
         <select className="h-9 rounded-md border border-border bg-background px-3 text-sm" value={groupFilter} onChange={(event) => setGroupFilter(event.target.value)}>
           <option value="all">All semantic groups</option>
@@ -574,9 +604,9 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
         <Card>
           <CardHeader className="flex-row items-start justify-between gap-3">
             <div>
-              <CardTitle className="flex items-center gap-2"><Layers3 className="h-4 w-4" /> Semantic map</CardTitle>
+              <CardTitle className="flex items-center gap-2"><Layers3 className="h-4 w-4" /> Deep graph</CardTitle>
               <CardDescription>
-                Showing {fmtNumber(model.visibleNodes.length)} nodes and {fmtNumber(model.visibleEdges.length)} relationships from {fmtNumber(model.totalNodes)} graph nodes.
+                Showing {fmtNumber(model.visibleNodes.length)} ideas and {fmtNumber(model.visibleEdges.length)} connections from {fmtNumber(model.totalNodes)} saved items.
               </CardDescription>
             </div>
             <Badge variant={model.hiddenByFilters ? "warning" : "success"}>{model.hiddenByFilters ? `${fmtNumber(model.hiddenByFilters)} filtered` : "all in view"}</Badge>
@@ -594,11 +624,11 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
                 value={minImportance}
                 onChange={(event) => setMinImportance(Number(event.target.value))}
                 className="w-44"
-                aria-label="Minimum graph importance"
+                aria-label="Minimum relationship importance"
               />
               <Badge variant="muted">{Math.round(minImportance * 100)}%+</Badge>
               {selectedId ? <Button variant="outline" size="sm" onClick={() => setSelectedId(null)}>Clear focus</Button> : null}
-              {search.trim() ? <Button variant="outline" size="sm" onClick={() => backendSearch.mutate()} disabled={backendSearch.isPending}>Search brain</Button> : null}
+              {search.trim() ? <Button variant="outline" size="sm" onClick={() => backendSearch.mutate()} disabled={backendSearch.isPending}>Search all memories</Button> : null}
             </div>
             <div className="flex flex-wrap gap-2">
               {model.groups.map((group) => (
@@ -620,7 +650,7 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
           <Card>
             <CardHeader>
               <CardTitle className="flex items-center gap-2"><Focus className="h-4 w-4" /> Focus</CardTitle>
-              <CardDescription>Click a node to inspect its neighborhood.</CardDescription>
+              <CardDescription>Click any idea to see why it matters.</CardDescription>
             </CardHeader>
             <CardContent className="space-y-3">
               {selected ? (
@@ -634,11 +664,18 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
                     </div>
                   </div>
                   {selected.summary ? <p className="text-sm text-muted-foreground">{selected.summary}</p> : null}
-                  <StructuredView value={{
-                    id: selected.id,
-                    degree: selected.degree,
-                    source: selected.source || "not reported",
-                  }} />
+                  {mode === "basic" ? (
+                    <KeyValueList data={{
+                      connections: selected.degree,
+                      source: selected.source || "not reported",
+                    }} />
+                  ) : (
+                    <StructuredView value={{
+                      id: selected.id,
+                      degree: selected.degree,
+                      source: selected.source || "not reported",
+                    }} />
+                  )}
                 </>
               ) : selectedGroup ? (
                 <div className="space-y-2">
@@ -646,13 +683,13 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
                   <div className="text-lg font-semibold">{selectedGroup.label}</div>
                   <Button variant="outline" onClick={() => toggleGroup(selectedGroup.id)}>Expand group</Button>
                 </div>
-              ) : <EmptyState title="No node selected" detail="Select a node or collapsed group in the graph." />}
+              ) : <EmptyState title="Nothing selected" detail="Select an item or collapsed group in the graph." />}
             </CardContent>
           </Card>
           <Card>
             <CardHeader>
-              <CardTitle>Important nodes</CardTitle>
-              <CardDescription>Highest-ranked visible graph records.</CardDescription>
+              <CardTitle>Important ideas</CardTitle>
+              <CardDescription>What Lattice thinks is most connected right now.</CardDescription>
             </CardHeader>
             <CardContent className="space-y-2">
               {model.visibleNodes.slice(0, 8).map((node) => (
@@ -687,12 +724,12 @@ function HybridSearch() {
   return (
     <Card>
       <CardHeader>
-        <CardTitle className="flex items-center gap-2"><Search className="h-4 w-4" /> Hybrid search</CardTitle>
-        <CardDescription>Calls the backend fused search endpoint and renders records with returned source scores.</CardDescription>
+        <CardTitle className="flex items-center gap-2"><Search className="h-4 w-4" /> Brain search</CardTitle>
+        <CardDescription>Find ideas across memories, documents, and connections.</CardDescription>
       </CardHeader>
       <CardContent className="space-y-3">
         <div className="flex flex-col gap-2 sm:flex-row">
-          <Input placeholder="Search memories, graph nodes, and indexed documents" value={query} onChange={(e) => setQuery(e.target.value)} onKeyDown={(e) => e.key === "Enter" && search.mutate()} />
+          <Input placeholder="Search memories, indexed documents, and relationships" value={query} onChange={(e) => setQuery(e.target.value)} onKeyDown={(e) => e.key === "Enter" && search.mutate()} />
           <Button onClick={() => search.mutate()} disabled={!query.trim() || search.isPending}>Search</Button>
         </div>
         {search.data ? (
@@ -717,7 +754,7 @@ function MemoryPanel() {
       <Card>
         <CardHeader>
           <CardTitle className="flex items-center gap-2"><Sparkles className="h-4 w-4" /> Recall</CardTitle>
-          <CardDescription>Searches the real memory recall endpoint.</CardDescription>
+          <CardDescription>Bring back related memories from your workspace.</CardDescription>
         </CardHeader>
         <CardContent className="space-y-3">
           <Input value={query} onChange={(e) => setQuery(e.target.value)} placeholder="Recall memories about..." />
@@ -741,7 +778,7 @@ function ProvenancePanel() {
       <DataPanel title="Coverage" result={coverage.data}>
         {(data) => <StructuredView value={data} />}
       </DataPanel>
-      <DataPanel title="Recent ingestion provenance" result={provenance.data}>
+      <DataPanel title="Recent sources" result={provenance.data}>
         {(data) => <EntityList items={(data as Record<string, unknown>).items || data} titleKey="source" metaKey="source_type" limit={14} />}
       </DataPanel>
     </div>
@@ -770,22 +807,22 @@ function PortabilityPanel() {
       <Card>
         <CardHeader>
           <CardTitle className="flex items-center gap-2"><DatabaseBackup className="h-4 w-4" /> Export, backup, import</CardTitle>
-          <CardDescription>Every control calls a real portability endpoint. Import is dry-run by default from a pasted export artifact.</CardDescription>
+          <CardDescription>Export, back up, or preview an import before changing your brain.</CardDescription>
         </CardHeader>
         <CardContent className="space-y-3">
           <div className="flex flex-wrap gap-2">
-            <ActionButton label="Export graph artifact" action={() => latticeApi.graphExport()} />
+            <ActionButton label="Export Brain" action={() => latticeApi.graphExport()} />
             <ActionButton label="Create backup" action={() => latticeApi.graphBackup()} />
           </div>
-          <Textarea value={artifact} onChange={(e) => setArtifact(e.target.value)} placeholder="Paste an exported graph artifact for dry-run import" />
+          <Textarea value={artifact} onChange={(e) => setArtifact(e.target.value)} placeholder="Paste an exported Brain artifact to preview import" />
           <Button
             variant="outline"
             disabled={!artifact.trim() || importMutation.isPending}
             onClick={() => importMutation.mutate()}
           >
-            Dry-run import
+            Preview import
           </Button>
-          {importMutation.data ? <OperationResult result={importMutation.data} successLabel="Dry run completed" /> : null}
+          {importMutation.data ? <OperationResult result={importMutation.data} successLabel="Import preview completed" /> : null}
         </CardContent>
       </Card>
     </div>
@@ -798,9 +835,9 @@ function PortabilityStatus({ data }: { data: Record<string, unknown> }) {
   return (
     <div className="space-y-3">
       <StatGrid stats={[
-        { label: "Schema", value: data.graph_schema_version || data.schema_version || "reported" },
-        { label: "Nodes", value: (stats.total_nodes as number) || Object.values((stats.nodes as Record<string, unknown>) || {}).reduce((sum: number, value) => sum + Number(value || 0), 0) },
-        { label: "Edges", value: (stats.total_edges as number) || Object.values((stats.edges as Record<string, unknown>) || {}).reduce((sum: number, value) => sum + Number(value || 0), 0) },
+        { label: "Brain format", value: data.graph_schema_version || data.schema_version || "reported" },
+        { label: "Memories", value: (stats.total_nodes as number) || Object.values((stats.nodes as Record<string, unknown>) || {}).reduce((sum: number, value) => sum + Number(value || 0), 0) },
+        { label: "Links", value: (stats.total_edges as number) || Object.values((stats.edges as Record<string, unknown>) || {}).reduce((sum: number, value) => sum + Number(value || 0), 0) },
         { label: "Storage", value: storage.engine || "reported" },
       ]} />
       <StructuredView value={data} />