ltcai 7.0.0 → 7.1.0

package/README.md

@@ -200,26 +200,25 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release
 
-The current release is **7.0.0 Brain Productization Loop**:
-
-- Brain Home starts with ingestion: files, folders, notes, and web pages can be
-  added directly from the first screen.
-- Every Brain answer can show memory proof and source citations instead of
-  asking users to trust an ungrounded chat bubble.
-- The model-continuity demo lets users recheck the same Brain evidence after
-  changing models.
-- The first-run loop is optimized for five minutes: add source, ask, see proof,
-  then switch or deepen.
-- CI now includes a deterministic recall/KG quality eval so the Brain proof
-  promise is guarded before release.
-
-Expected artifacts for 7.0.0 release must use exact filenames:
-
-- `dist/ltcai-7.0.0-py3-none-any.whl`
-- `dist/ltcai-7.0.0.tar.gz`
-- `ltcai-7.0.0.tgz`
-- `dist/ltcai-7.0.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_7.0.0_aarch64.dmg`
+The current release is **7.1.0 Brain Usability Completion**:
+
+- First-run onboarding now explains detected hardware, recommendation timing,
+  install progress, and the next action in plain language.
+- Brain Home shows ingestion progress for files, folders, notes, and web pages,
+  including memory emergence after content lands.
+- Knowledge Graph exploration adds search suggestions, type filters, time
+  exploration, focus movement, and neighbor highlighting.
+- Chat answers surface inline source citations and accessible proof payloads.
+- Workspace/profile/admin entry points, empty/error feedback, consent revoke
+  feedback, and VS Code extension sync status are visible in the product shell.
+
+Expected artifacts for 7.1.0 release must use exact filenames:
+
+- `dist/ltcai-7.1.0-py3-none-any.whl`
+- `dist/ltcai-7.1.0.tar.gz`
+- `ltcai-7.1.0.tgz`
+- `dist/ltcai-7.1.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_7.1.0_aarch64.dmg`
 
 Do not upload `dist/*`. Package registry publishing remains owner-run.
 
@@ -238,6 +237,7 @@ Do not upload `dist/*`. Package registry publishing remains owner-run.
 
 | Version | Theme |
 | --- | --- |
+| 7.1.0 | Brain Usability Completion: clearer first-run onboarding, ingestion progress/emergence, richer graph controls, inline answer proof, workspace/profile/admin discovery, empty/error/consent feedback, and VS Code sync status |
 | 7.0.0 | Brain Productization Loop: first-screen ingestion for files/folders/notes/web, answer-level memory proof and source citations, model-continuity demo flow, five-minute first-run loop, and recall/KG quality eval in CI |
 | 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 |

package/docs/CHANGELOG.md

@@ -4,6 +4,29 @@ 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.
 
+## [7.1.0] - 2026-06-20
+
+> Brain Usability Completion. Completes the 7.1.0 first-run through editor-sync
+> usability pass: clear onboarding, visible ingestion, graph controls, inline
+> proof, workspace/admin discovery, feedback states, and VS Code sync status.
+
+### Added
+- Hardware visualization, expected timing, install timeline, and next-action
+  copy in first-run onboarding.
+- Brain Home ingestion stage disclosure and memory emergence timeline for file,
+  folder, note, and URL sources.
+- Knowledge Graph search suggestions, entity type filters, recent/all-time time
+  exploration, focus clearing, and neighbor highlighting.
+- Inline answer citation markers with keyboard-accessible proof cards.
+- Workspace/profile switcher, Admin Console gate, consent revoke feedback, and
+  shared empty/error feedback surfaces in the Brain shell.
+- VS Code extension heartbeat/status endpoint plus extension and main-app sync
+  indicators for connected/indexing/synced/offline states.
+
+### Changed
+- Package/runtime/static metadata is synchronized to 7.1.0; package publish and
+  deployment remain owner-run only.
+
 ## [7.0.0] - 2026-06-18
 
 > Brain Productization Loop. Turns the Brain proof work into a first-five-minute

package/frontend/src/App.tsx

@@ -5,6 +5,12 @@ import { useAppStore } from "@/store/appStore";
 import { parseHash, productShellRoutes } from "@/routes";
 import { BrainHome } from "@/features/brain/BrainHome";
 import { AdminConsole } from "@/features/admin/AdminConsole";
+import { WorkspaceProfileSwitcher } from "@/components/WorkspaceProfileSwitcher";
+import { AdminAccessGate } from "@/components/AdminAccessGate";
+import { t, type Language } from "@/i18n";
+import { latticeApi } from "@/api/client";
+import { useQuery } from "@tanstack/react-query";
+import { FeedbackState } from "@/components/FeedbackState";
 
 const ActPage = React.lazy(() => import("@/pages/Act").then((module) => ({ default: module.ActPage })));
 const BrainPage = React.lazy(() => import("@/pages/Brain").then((module) => ({ default: module.BrainPage })));
@@ -95,6 +101,7 @@ function BrainShell({
   active: string;
   children: React.ReactNode;
 }) {
+  const language = useAppStore((state) => state.language);
   return (
     <main className="brain-shell-page" aria-label="Lattice workspace">
       <nav className="brain-shell-nav" aria-label="Brain workspace navigation">
@@ -103,19 +110,92 @@ function BrainShell({
             key={item.id}
             type="button"
             className={item.id === active ? "is-active" : ""}
+            aria-current={item.id === active ? "page" : undefined}
             onClick={() => navigateHash(`/${item.path}`)}
           >
             {item.label}
           </button>
         ))}
+        <div className="brain-shell-switchers" aria-label={t(language, "shell.workspace.label")}>
+          <VsCodeSyncStatus language={language} />
+          <WorkspaceProfileSwitcher language={language} />
+          <AdminAccessGate language={language} />
+        </div>
       </nav>
       <section className="brain-shell-content">
+        <ExternalConsentStatus language={language} />
         {children}
       </section>
     </main>
   );
 }
 
+function ExternalConsentStatus({ language }: { language: Language }) {
+  const externalConsent = useAppStore((state) => state.externalConsent);
+  const setExternalConsent = useAppStore((state) => state.setExternalConsent);
+
+  return (
+    <section className="external-consent-status" aria-label={t(language, "feedback.consent.aria")}>
+      <FeedbackState
+        tone={externalConsent ? "empty" : "error"}
+        language={language}
+        title={externalConsent ? t(language, "feedback.consent.activeTitle") : t(language, "feedback.consent.revokedTitle")}
+        body={externalConsent ? t(language, "feedback.consent.activeBody") : t(language, "feedback.consent.revokedBody")}
+        actionLabel={externalConsent ? t(language, "feedback.consent.revoke") : t(language, "feedback.consent.reenable")}
+        onAction={() => setExternalConsent(!externalConsent)}
+      />
+    </section>
+  );
+}
+
+function VsCodeSyncStatus({ language }: { language: Language }) {
+  const bridge = useQuery({
+    queryKey: ["workspaceVscodeStatus"],
+    queryFn: latticeApi.workspaceVscodeStatus,
+    refetchInterval: 15000,
+  });
+  const index = useQuery({
+    queryKey: ["index"],
+    queryFn: latticeApi.indexStatus,
+    refetchInterval: 15000,
+  });
+  const data = bridge.data?.data as Record<string, unknown> | undefined;
+  const lastSeen = Number(data?.last_seen_ms || 0);
+  const connected = Boolean(data?.connected) || (lastSeen > 0 && Date.now() - lastSeen < 60000);
+  const indexData = index.data?.data as Record<string, unknown> | undefined;
+  const indexStatus = String(indexData?.status || indexData?.state || "");
+  const indexing = /index|build|running|pending/i.test(indexStatus);
+  const state = bridge.isLoading
+    ? "checking"
+    : !connected
+      ? "offline"
+      : indexing
+        ? "indexing"
+        : "synced";
+  const labelKey = `shell.sync.${state}`;
+  const detail = connected
+    ? t(language, "shell.sync.detail")
+    : t(language, "shell.sync.detailOffline");
+
+  return (
+    <button
+      type="button"
+      className={`vscode-sync-status is-${state}`}
+      aria-label={`${t(language, "shell.sync.label")}: ${t(language, labelKey)}`}
+      title={`${t(language, "shell.sync.label")}: ${t(language, labelKey)}\n${detail}`}
+      onClick={() => {
+        window.location.hash = "/settings";
+      }}
+    >
+      <span className="vscode-sync-dot" aria-hidden="true" />
+      <span className="vscode-sync-copy">
+        <strong>{t(language, "shell.sync.label")}</strong>
+        <small>{t(language, labelKey)}</small>
+      </span>
+    </button>
+  );
+}
+
 function PageLoader() {
   return (
     <div className="brain-shell-loader" role="status">

package/frontend/src/api/client.ts

@@ -416,6 +416,12 @@ export const latticeApi = {
   },
   health: () => get("/health", {}),
   workspaceOs: () => get("/workspace/os", { counts: {}, models: {}, workspace_registry: { workspaces: [] } }),
+  workspaceVscodeStatus: () => get("/workspace/vscode/status", {
+    connected: false,
+    last_seen_ms: 0,
+    status: "offline",
+    index_status: "unknown",
+  }),
   indexStatus: () => get("/api/index/status", {}),
   rebuildIndex: () => post("/api/index/rebuild", { full: false, include_nodes: true, include_chunks: true }, {}),
   graph: () => get("/knowledge-graph/graph", { nodes: [], edges: [] }),

package/frontend/src/components/AdminAccessGate.tsx

@@ -0,0 +1,70 @@
+import * as React from "react";
+import { ShieldCheck, Lock } from "lucide-react";
+import { t, type Language } from "@/i18n";
+import { useAppStore, type WorkspaceMode } from "@/store/appStore";
+
+const MODES: WorkspaceMode[] = ["basic", "advanced", "admin"];
+
+/**
+ * Role-aware admin entry point for the Brain shell.
+ *
+ * Mode is the access proxy used across the app (SystemPage gates the admin
+ * tab and AdminPanel on `mode`). When the user is in advanced/admin mode we
+ * surface a discoverable Admin Console button plus a compact mode switcher.
+ * In basic mode the console is hidden behind an explained affordance that
+ * promotes the user to admin mode rather than failing silently.
+ */
+export function AdminAccessGate({ language }: { language: Language }) {
+  const mode = useAppStore((state) => state.mode);
+  const setMode = useAppStore((state) => state.setMode);
+  const canSeeAdmin = mode === "advanced" || mode === "admin";
+
+  return (
+    <div className="admin-access-gate">
+      {canSeeAdmin ? (
+        <button
+          type="button"
+          className="admin-access-button"
+          title={t(language, "shell.admin.tooltip")}
+          aria-label={t(language, "shell.admin.open")}
+          onClick={() => {
+            window.location.hash = "/admin";
+          }}
+        >
+          <ShieldCheck className="h-3.5 w-3.5" aria-hidden="true" />
+          <span>{t(language, "shell.admin.label")}</span>
+        </button>
+      ) : (
+        <button
+          type="button"
+          className="admin-access-button is-locked"
+          title={t(language, "shell.admin.needsMode")}
+          aria-label={t(language, "shell.admin.needsMode")}
+          onClick={() => setMode("admin")}
+        >
+          <Lock className="h-3.5 w-3.5" aria-hidden="true" />
+          <span>{t(language, "shell.admin.enable")}</span>
+        </button>
+      )}
+
+      <div
+        className="mode-switcher-mini"
+        role="group"
+        aria-label={t(language, "shell.mode.label")}
+        title={t(language, "shell.mode.info")}
+      >
+        {MODES.map((item) => (
+          <button
+            key={item}
+            type="button"
+            className={mode === item ? "is-active" : ""}
+            aria-pressed={mode === item}
+            onClick={() => setMode(item)}
+          >
+            {t(language, `shell.mode.${item}`)}
+          </button>
+        ))}
+      </div>
+    </div>
+  );
+}

package/frontend/src/components/BrainConversation.tsx

@@ -3,13 +3,17 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { ImagePlus, MessageSquare, Plus, Send, Trash2 } from "lucide-react";
 import { latticeApi } from "@/api/client";
 import { EmptyState, EntityList, SourceBadge, StructuredView } from "@/components/primitives";
+import { FeedbackState } from "@/components/FeedbackState";
 import { type BrainState, LivingBrain } from "@/components/LivingBrain";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Textarea } from "@/components/ui/textarea";
 import { asArray } from "@/lib/utils";
+import { t, type Language } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
 
-type Msg = { role?: string; content?: string; timestamp?: string };
+type Citation = { id: string; source: string; title: string; snippet: string; score: number | null };
+type Msg = { role?: string; content?: string; timestamp?: string; citations?: Citation[] };
 type BrainActivity = BrainState;
 type BrainVitals = {
   connected: boolean;
@@ -49,7 +53,58 @@ function usageNumber(data: unknown, key: string) {
   return Number.isFinite(value) ? value : null;
 }
 
+// Pull human-readable citation records out of the heterogeneous streaming trace.
+// The backend trace shape varies, so we defensively scan the common containers
+// (matches / sources / retrieved / context / chunks) for source-like records.
+function extractCitations(trace: unknown): Citation[] {
+  if (!trace || typeof trace !== "object") return [];
+  const record = trace as Record<string, unknown>;
+  const containerKeys = ["matches", "sources", "retrieved", "context", "chunks", "citations", "evidence"];
+  let rows: Array<Record<string, unknown>> = [];
+  for (const key of containerKeys) {
+    const candidate = asArray<Record<string, unknown>>(record[key]);
+    if (candidate.length) {
+      rows = candidate;
+      break;
+    }
+  }
+  if (!rows.length && Array.isArray(trace)) rows = trace as Array<Record<string, unknown>>;
+
+  const seen = new Set<string>();
+  const citations: Citation[] = [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    const title = String(row.title || row.name || row.heading || row.label || row.id || "").trim();
+    const source = String(row.source || row.type || row.origin || row.kind || row.provider || "memory").trim();
+    const snippet = String(row.snippet || row.text || row.content || row.summary || row.excerpt || "").trim();
+    if (!title && !snippet) continue;
+    const scoreRaw = Number(row.score ?? row.relevance ?? row.similarity);
+    const score = Number.isFinite(scoreRaw) ? Math.round((scoreRaw <= 1 ? scoreRaw * 100 : scoreRaw)) : null;
+    const id = String(row.id || `${source}:${title}:${snippet.slice(0, 24)}`);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    citations.push({ id, source: source || "memory", title: title || snippet.slice(0, 48), snippet, score });
+    if (citations.length >= 6) break;
+  }
+  return citations;
+}
+
+// Anchor citation chips after the first N sentences (conservative heuristic).
+// Each segment carries an optional citation index so chips stay tied to text.
+function splitWithCitations(content: string, citationCount: number): Array<{ text: string; citation: number | null }> {
+  if (!citationCount || !content) return [{ text: content, citation: null }];
+  const sentences = content.match(/[^.!?。！？\n]+[.!?。！？]?\s*/g);
+  if (!sentences || sentences.length <= 1) return [{ text: content, citation: 0 }];
+  const segments: Array<{ text: string; citation: number | null }> = [];
+  sentences.forEach((sentence, index) => {
+    const citation = index < citationCount ? index : null;
+    segments.push({ text: sentence, citation });
+  });
+  return segments;
+}
+
 export function BrainConversation({ className }: { className?: string }) {
+  const language = useAppStore((state) => state.language);
   const qc = useQueryClient();
   const history = useQuery({ queryKey: ["chatHistory"], queryFn: latticeApi.chatHistory });
   const models = useQuery({ queryKey: ["models"], queryFn: latticeApi.models });
@@ -94,7 +149,20 @@ export function BrainConversation({ className }: { className?: string }) {
               return next;
             });
           },
-          onTrace: setTrace,
+          onTrace: (incoming) => {
+            setTrace(incoming);
+            const citations = extractCitations(incoming);
+            if (citations.length) {
+              setMessages((items) => {
+                const next = [...items];
+                const last = next[next.length - 1];
+                if (last && last.role === "assistant") {
+                  next[next.length - 1] = { ...last, citations };
+                }
+                return next;
+              });
+            }
+          },
         },
       );
       if (result.error) {
@@ -167,7 +235,15 @@ export function BrainConversation({ className }: { className?: string }) {
               <div key={`${msg.role || "message"}-${index}`} className={`brain-message-row ${msg.role === "user" ? "from-user" : "from-brain"}`}>
                 <div className="brain-message-bubble">
                   <div className="brain-message-role">{msg.role === "user" ? "You" : "Brain"}</div>
-                  <div className="whitespace-pre-wrap">{msg.content}</div>
+                  {msg.role === "user" ? (
+                    <div className="whitespace-pre-wrap">{msg.content}</div>
+                  ) : (
+                    <MessageWithCitations
+                      language={language}
+                      content={msg.content || ""}
+                      citations={msg.citations || []}
+                    />
+                  )}
                 </div>
               </div>
             )) : (
@@ -239,6 +315,122 @@ export function BrainConversation({ className }: { className?: string }) {
   );
 }
 
+// Renders assistant text with inline, keyboard-accessible citation chips that are
+// linked to a proof list below. Selecting a chip highlights and reveals its source.
+function MessageWithCitations({
+  language,
+  content,
+  citations,
+}: {
+  language: Language;
+  content: string;
+  citations: Citation[];
+}) {
+  const [activeId, setActiveId] = React.useState<string | null>(null);
+  const [announce, setAnnounce] = React.useState("");
+  const listRef = React.useRef<HTMLOListElement | null>(null);
+
+  if (!citations.length) {
+    return <div className="whitespace-pre-wrap">{content}</div>;
+  }
+
+  const segments = splitWithCitations(content, citations.length);
+
+  const focusListItem = (id: string) => {
+    const node = listRef.current?.querySelector<HTMLLIElement>(`[data-citation-target="${id}"]`);
+    node?.focus?.();
+    node?.scrollIntoView?.({ block: "nearest" });
+  };
+
+  const toggle = (citation: Citation) => {
+    setActiveId((prev) => {
+      const next = prev === citation.id ? null : citation.id;
+      if (next) {
+        const idx = citations.findIndex((c) => c.id === citation.id) + 1;
+        setAnnounce(t(language, "brain.citation.announce.open", { num: idx, title: citation.title }));
+        focusListItem(citation.id);
+      } else {
+        setAnnounce(t(language, "brain.citation.announce.close"));
+      }
+      return next;
+    });
+  };
+
+  const onChipKey = (event: React.KeyboardEvent<HTMLSpanElement>, citation: Citation) => {
+    if (event.key === "Enter" || event.key === " " || event.key === "Spacebar") {
+      event.preventDefault();
+      toggle(citation);
+    } else if (event.key === "Escape" && activeId) {
+      event.preventDefault();
+      setActiveId(null);
+      setAnnounce(t(language, "brain.citation.announce.close"));
+    }
+  };
+
+  return (
+    <div className="brain-message-cited">
+      <div className="whitespace-pre-wrap brain-message-text">
+        {segments.map((segment, index) => {
+          const citation = segment.citation != null ? citations[segment.citation] : null;
+          const num = segment.citation != null ? segment.citation + 1 : 0;
+          return (
+            <React.Fragment key={index}>
+              {segment.text}
+              {citation ? (
+                <span
+                  role="button"
+                  tabIndex={0}
+                  className={`citation-chip ${activeId === citation.id ? "is-active" : ""}`}
+                  data-citation-id={citation.id}
+                  aria-pressed={activeId === citation.id}
+                  aria-label={t(language, "brain.citation.chip.long", { num, title: citation.title })}
+                  onClick={() => toggle(citation)}
+                  onKeyDown={(event) => onChipKey(event, citation)}
+                >
+                  {t(language, "brain.citation.chip", { num })}
+                </span>
+              ) : null}
+            </React.Fragment>
+          );
+        })}
+      </div>
+
+      <div className="brain-answer-proof" aria-label={t(language, "brain.citation.region")}>
+        <div className="brain-answer-proof-head">
+          <span>{t(language, "brain.answerProof.title")}</span>
+          <strong>{t(language, "brain.citation.count", { count: citations.length })}</strong>
+        </div>
+        <ol ref={listRef}>
+          {citations.map((citation, index) => {
+            const isActive = activeId === citation.id;
+            return (
+              <li
+                key={citation.id}
+                data-citation-target={citation.id}
+                className={isActive ? "is-cited" : ""}
+                tabIndex={-1}
+                aria-current={isActive ? "true" : undefined}
+              >
+                <span>{t(language, "brain.citation.preview.from")}{citation.source}</span>
+                <strong>{t(language, "brain.citation.chip", { num: index + 1 })} · {citation.title}</strong>
+                {citation.snippet ? (
+                  <small>{t(language, "brain.citation.preview.snippet")}{citation.snippet}</small>
+                ) : null}
+                {citation.score != null ? (
+                  <small className="brain-citation-score">{t(language, "brain.citation.score", { score: citation.score })}</small>
+                ) : null}
+              </li>
+            );
+          })}
+        </ol>
+        <small className="brain-citation-tip">{t(language, "brain.citation.keyboard.tip")}</small>
+      </div>
+
+      <div className="sr-only" role="status" aria-live="polite">{announce}</div>
+    </div>
+  );
+}
+
 function RecentConversations({
   conversations,
   result,
@@ -248,23 +440,32 @@ function RecentConversations({
   onDelete,
 }: {
   conversations: Array<Record<string, unknown>>;
-  result?: Parameters<typeof SourceBadge>[0]["result"];
+  result?: { source?: string; ok?: boolean; status?: number; error?: string };
   activeId: string | null;
   onNew: () => void;
   onSelect: (id: string) => void;
   onDelete: (id: string) => void;
 }) {
+  const language = useAppStore((state) => state.language);
   return (
     <section className="brain-side-panel">
       <div className="brain-side-head">
         <div>
           <h3>Recent conversations</h3>
-          <SourceBadge result={result} />
+          <SourceBadge result={result as Parameters<typeof SourceBadge>[0]["result"]} />
         </div>
         <Button variant="outline" size="sm" onClick={onNew}><Plus className="h-4 w-4" /> New</Button>
       </div>
       <div className="brain-conversation-list soft-scrollbar">
-        {conversations.length ? conversations.slice(0, 8).map((item) => {
+        {!result?.ok && result?.source === "unavailable" ? (
+          <FeedbackState
+            tone="error"
+            language={language}
+            title={t(language, "feedback.error.title")}
+            body={result.error || t(language, "feedback.error.body")}
+            onAction={() => window.location.reload()}
+          />
+        ) : conversations.length ? conversations.slice(0, 8).map((item) => {
           const id = String(item.id || item.conversation_id || "");
           return (
             <div key={id} className={`brain-conversation-item ${activeId === id ? "is-active" : ""}`}>
@@ -277,13 +478,23 @@ function RecentConversations({
               </button>
             </div>
           );
-        }) : <EmptyState title="No conversations yet" detail="New exchanges will appear here." />}
+        }) : (
+          <FeedbackState
+            tone="empty"
+            language={language}
+            title="No conversations yet"
+            body="New exchanges will appear here."
+            actionLabel="Start a conversation"
+            onAction={onNew}
+          />
+        )}
       </div>
     </section>
   );
 }
 
 function MemoryNearby({ question, trace }: { question: string; trace: unknown }) {
+  const language = useAppStore((state) => state.language);
   const hybrid = useQuery({
     queryKey: ["brainNearbyMemory", question],
     queryFn: () => latticeApi.hybridSearch(question),
@@ -299,10 +510,23 @@ function MemoryNearby({ question, trace }: { question: string; trace: unknown })
       </div>
       {hybrid.data?.ok ? (
         <EntityList items={(hybrid.data.data as Record<string, unknown>).matches || hybrid.data.data} titleKey="title" metaKey="type" limit={4} />
+      ) : hybrid.data?.source === "unavailable" ? (
+        <FeedbackState
+          tone="error"
+          language={language}
+          title={t(language, "feedback.error.title")}
+          body={hybrid.data.error || t(language, "feedback.error.body")}
+          onAction={() => void hybrid.refetch()}
+        />
       ) : trace ? (
         <StructuredView value={trace} limit={4} />
       ) : (
-        <EmptyState title="Quiet for now" detail="Relevant memory wakes up as the conversation gets specific." />
+        <FeedbackState
+          tone="empty"
+          language={language}
+          title="Quiet for now"
+          body="Relevant memory wakes up as the conversation gets specific."
+        />
       )}
     </section>
   );

package/frontend/src/components/FeedbackState.tsx

@@ -0,0 +1,45 @@
+import * as React from "react";
+import { AlertTriangle, Inbox, RotateCcw } from "lucide-react";
+import { t, type Language } from "@/i18n";
+
+export type FeedbackTone = "empty" | "error";
+
+/**
+ * Shared empty / error feedback surface so every view tells the user what just
+ * happened and what to do next, instead of a blank or silent failure.
+ */
+export function FeedbackState({
+  tone,
+  language,
+  title,
+  body,
+  actionLabel,
+  onAction,
+}: {
+  tone: FeedbackTone;
+  language: Language;
+  title: string;
+  body?: string;
+  actionLabel?: string;
+  onAction?: () => void;
+}) {
+  const isError = tone === "error";
+  const resolvedActionLabel = actionLabel || (isError ? t(language, "feedback.retry") : undefined);
+  return (
+    <div className={`feedback-state is-${tone}`} role={isError ? "alert" : "status"}>
+      <span className="feedback-state-icon" aria-hidden="true">
+        {isError ? <AlertTriangle className="h-4 w-4" /> : <Inbox className="h-4 w-4" />}
+      </span>
+      <div className="feedback-state-body">
+        <strong>{title}</strong>
+        {body ? <span>{body}</span> : null}
+      </div>
+      {resolvedActionLabel && onAction ? (
+        <button type="button" className="feedback-state-action" onClick={onAction}>
+          {isError ? <RotateCcw className="h-3.5 w-3.5" /> : null}
+          {resolvedActionLabel}
+        </button>
+      ) : null}
+    </div>
+  );
+}