ltcai 6.2.0 → 6.3.0

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

@@ -0,0 +1,38 @@
+import type { BrainDepth, MemoryFragment } from "./types";
+import { t } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import { layerStyle, polarPoint } from "./graphLayout";
+
+export function BrainMemoryLayer({
+  memories,
+  depth,
+  onRecallMemory,
+}: {
+  memories: MemoryFragment[];
+  depth: BrainDepth;
+  onRecallMemory: (fragment: MemoryFragment) => void;
+}) {
+  const language = useAppStore((state) => state.language);
+  const visible = memories.slice(0, depth >= 3 ? 8 : 6);
+  if (!visible.length) return <div className="memory-fragment is-empty">{t(language, "brain.memory.empty")}</div>;
+
+  return (
+    <>
+      {visible.map((memory, index) => {
+        const point = polarPoint(index, visible.length, depth >= 3 ? 39 : 31, depth >= 3 ? 24 : 18, -112);
+        return (
+          <button
+            key={memory.id}
+            type="button"
+            className="memory-fragment"
+            style={layerStyle({ "--x": `${point.x}%`, "--y": `${point.y}%`, "--delay": `${index * 55}ms` })}
+            onClick={() => onRecallMemory(memory)}
+          >
+            <span>{memory.kind}</span>
+            <strong>{memory.title}</strong>
+          </button>
+        );
+      })}
+    </>
+  );
+}

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

@@ -0,0 +1,74 @@
+import * as React from "react";
+import { t } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import type { BrainDepth, KnowledgeConcept, MemoryFragment } from "./types";
+
+export function BrainOverviewPanel({
+  memories,
+  concepts,
+  onOpenDepth,
+}: {
+  memories: MemoryFragment[];
+  concepts: KnowledgeConcept[];
+  onOpenDepth: (depth: BrainDepth) => void;
+}) {
+  const language = useAppStore((state) => state.language);
+  const recent = memories.slice(0, 3);
+  const older = memories.slice(3, 6);
+  const topics = concepts.slice(0, 4);
+
+  return (
+    <section className="brain-overview-panel" aria-label={t(language, "brain.aria.overview")}>
+      <div className="brain-overview-head">
+        <div>
+          <span>{t(language, "brain.overview.kicker")}</span>
+          <strong>{t(language, "brain.overview.title")}</strong>
+        </div>
+        <button type="button" onClick={() => onOpenDepth(5)}>{t(language, "brain.overview.graph")}</button>
+      </div>
+      <div className="brain-overview-grid">
+        <BrainOverviewColumn
+          title={t(language, "brain.overview.recent")}
+          empty={t(language, "brain.overview.recentEmpty")}
+          items={recent.map((memory) => memory.title)}
+          onOpen={() => onOpenDepth(2)}
+        />
+        <BrainOverviewColumn
+          title={t(language, "brain.overview.older")}
+          empty={t(language, "brain.overview.olderEmpty")}
+          items={older.map((memory) => memory.title)}
+          onOpen={() => onOpenDepth(2)}
+        />
+        <BrainOverviewColumn
+          title={t(language, "brain.overview.topics")}
+          empty={t(language, "brain.overview.topicsEmpty")}
+          items={topics.map((concept) => concept.label)}
+          onOpen={() => onOpenDepth(3)}
+        />
+      </div>
+    </section>
+  );
+}
+
+function BrainOverviewColumn({
+  title,
+  empty,
+  items,
+  onOpen,
+}: {
+  title: string;
+  empty: string;
+  items: string[];
+  onOpen: () => void;
+}) {
+  return (
+    <button type="button" className="brain-overview-column" onClick={onOpen}>
+      <span>{title}</span>
+      {items.length ? (
+        items.slice(0, 3).map((item) => <strong key={item}>{item}</strong>)
+      ) : (
+        <em>{empty}</em>
+      )}
+    </button>
+  );
+}

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

@@ -0,0 +1,43 @@
+import type { KnowledgeConcept, RelationshipThread } from "./types";
+import { layoutGraphNodes } from "./graphLayout";
+
+export function BrainRelationshipLayer({
+  concepts,
+  relationships,
+}: {
+  concepts: KnowledgeConcept[];
+  relationships: RelationshipThread[];
+}) {
+  const visibleConcepts = concepts.slice(0, 10);
+  const layout = layoutGraphNodes(visibleConcepts, 30, 20);
+  const positionById = new Map(layout.map((item) => [item.node.id, item]));
+  const visibleRelationships = relationships
+    .map((relationship, index) => {
+      const source = positionById.get(relationship.source) || layout[index % Math.max(layout.length, 1)];
+      const target = positionById.get(relationship.target) || layout[(index + 3) % Math.max(layout.length, 1)];
+      return source && target && source.node.id !== target.node.id ? { relationship, source, target } : null;
+    })
+    .filter(Boolean)
+    .slice(0, 8) as Array<{
+      relationship: RelationshipThread;
+      source: ReturnType<typeof layoutGraphNodes>[number];
+      target: ReturnType<typeof layoutGraphNodes>[number];
+    }>;
+
+  if (!visibleRelationships.length) return null;
+
+  return (
+    <svg className="relationship-weave" viewBox="0 0 100 100" aria-hidden>
+      {visibleRelationships.map(({ relationship, source, target }, index) => (
+        <line
+          key={`${relationship.id}-${index}`}
+          x1={source.x}
+          y1={source.y}
+          x2={target.x}
+          y2={target.y}
+          style={{ animationDelay: `${index * 80}ms` }}
+        />
+      ))}
+    </svg>
+  );
+}

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

@@ -0,0 +1,53 @@
+import type { BrainDepth, KnowledgeConcept, KnowledgeGraphModel, MemoryFragment, RelationshipThread } from "./types";
+import { BrainGraphLayer, BrainKnowledgeLayer } from "./BrainGraphLayer";
+import { BrainMemoryLayer } from "./BrainMemoryLayer";
+import { BrainRelationshipLayer } from "./BrainRelationshipLayer";
+
+export function DepthEmergence({
+  depth,
+  memories,
+  concepts,
+  relationships,
+  graphModel,
+  graphSearch,
+  selectedGraphId,
+  onGraphSearch,
+  onSelectGraphNode,
+  onRecallMemory,
+}: {
+  depth: BrainDepth;
+  memories: MemoryFragment[];
+  concepts: KnowledgeConcept[];
+  relationships: RelationshipThread[];
+  graphModel: KnowledgeGraphModel;
+  graphSearch: string;
+  selectedGraphId: string | null;
+  onGraphSearch: (value: string) => void;
+  onSelectGraphNode: (id: string | null) => void;
+  onRecallMemory: (fragment: MemoryFragment) => void;
+}) {
+  if (depth === 1) return null;
+
+  return (
+    <>
+      {depth >= 2 ? (
+        <BrainMemoryLayer memories={memories} depth={depth} onRecallMemory={onRecallMemory} />
+      ) : null}
+      {depth >= 3 && depth < 5 ? (
+        <BrainKnowledgeLayer concepts={concepts} depth={depth} />
+      ) : null}
+      {depth >= 4 && depth < 5 ? (
+        <BrainRelationshipLayer concepts={concepts} relationships={relationships} />
+      ) : null}
+      {depth >= 5 ? (
+        <BrainGraphLayer
+          model={graphModel}
+          search={graphSearch}
+          selectedId={selectedGraphId}
+          onSearch={onGraphSearch}
+          onSelect={onSelectGraphNode}
+        />
+      ) : null}
+    </>
+  );
+}

package/frontend/src/features/brain/types.ts

@@ -35,10 +35,10 @@ export type KnowledgeGraphModel = {
   edges: RelationshipThread[];
 };
 
-export const DEPTHS: Array<{ level: BrainDepth; label: string; state: BrainState }> = [
-  { level: 1, label: "Living Brain", state: "idle" },
-  { level: 2, label: "Memory Layer", state: "recalling" },
-  { level: 3, label: "Knowledge Layer", state: "synthesizing" },
-  { level: 4, label: "Relationship Layer", state: "planning" },
-  { level: 5, label: "Knowledge Graph", state: "synthesizing" },
+export const DEPTHS: Array<{ level: BrainDepth; labelKey: string; state: BrainState }> = [
+  { level: 1, labelKey: "brain.depthLabel.1", state: "idle" },
+  { level: 2, labelKey: "brain.depthLabel.2", state: "recalling" },
+  { level: 3, labelKey: "brain.depthLabel.3", state: "synthesizing" },
+  { level: 4, labelKey: "brain.depthLabel.4", state: "planning" },
+  { level: 5, labelKey: "brain.depthLabel.5", state: "synthesizing" },
 ];

package/frontend/src/features/review/ReviewCard.tsx

@@ -89,7 +89,9 @@ export function ReviewCard({ item, feedback, onAction }: ReviewCardProps) {
         </div>
       ) : null}
       {feedback ? (
-        <p className="mt-2 text-xs text-emerald-300">{feedback} - item stays open until you approve or dismiss.</p>
+        <p className={`mt-2 text-xs ${/fail|error|unavailable/i.test(feedback) ? "text-amber-300" : "text-emerald-300"}`}>
+          {feedback} - item stays open until you approve or dismiss.
+        </p>
       ) : null}
     </div>
   );

package/frontend/src/features/review/ReviewInbox.tsx

@@ -38,11 +38,21 @@ export function ReviewInbox() {
       action === "unsnooze" ? () => latticeApi.unsnoozeReviewItem(item.id) :
       () => latticeApi.runNowReviewItem(item.id);
     const result = await call();
+    if (!result.ok) {
+      setRunFeedback((prev) => ({
+        ...prev,
+        [item.id]: result.error || `${action} failed`,
+      }));
+      return result;
+    }
     if (result.ok) {
       if (action === "run_now") {
+        const payload = result.data.payload || {};
+        const provenance = result.data.provenance || {};
+        const runId = String(payload.last_run_id || provenance.run_id || "");
         setRunFeedback((prev) => ({
           ...prev,
-          [item.id]: hadRunBefore ? "Regenerated" : "Executed",
+          [item.id]: runId ? `${hadRunBefore ? "Regenerated" : "Executed"} · ${runId}` : hadRunBefore ? "Regenerated" : "Executed",
         }));
       } else {
         setRunFeedback((prev) => {

package/frontend/src/i18n.ts

@@ -18,11 +18,24 @@ export const COPY: Record<Language, TextMap> = {
     "brain.depth.3": "주제",
     "brain.depth.4": "관계",
     "brain.depth.5": "전체 지식 그래프",
+    "brain.depthLabel.1": "살아있는 Brain",
+    "brain.depthLabel.2": "기억 계층",
+    "brain.depthLabel.3": "지식 계층",
+    "brain.depthLabel.4": "관계 계층",
+    "brain.depthLabel.5": "지식 그래프",
     "brain.view.memories": "기억 보기",
     "brain.view.topics": "주제 보기",
     "brain.view.relationships": "관계 보기",
     "brain.view.graph": "그래프로 보기",
     "brain.surface": "돌아가기",
+    "brain.aria.home": "Lattice Brain",
+    "brain.aria.exploration": "Brain 탐색",
+    "brain.aria.quickViews": "Brain 빠른 보기",
+    "brain.aria.conversation": "대화",
+    "brain.aria.ownership": "Brain 소유 보장",
+    "brain.aria.starterPrompts": "시작 프롬프트",
+    "brain.aria.overview": "Brain 한눈에 보기",
+    "brain.aria.graph": "지식 그래프",
     "brain.title": "Lattice Brain",
     "brain.local": "로컬 우선",
     "brain.portable": "이동 가능",
@@ -54,28 +67,50 @@ export const COPY: Record<Language, TextMap> = {
     "brain.overview.olderEmpty": "대화가 쌓이면 과거 기억이 보입니다.",
     "brain.overview.topics": "주요 주제",
     "brain.overview.topicsEmpty": "주제가 형성되는 중입니다.",
+    "brain.memory.empty": "기억이 조용합니다.",
+    "brain.knowledge.empty": "지식이 형성되는 중입니다.",
     "brain.graph.empty": "아직 맞는 지식이 없습니다.",
     "brain.graph.summaryFallback": "이 개념은 가장 깊은 지식 계층의 일부입니다.",
     "brain.graph.focused": "대화와 문서에서 함께 나온 내용이 선으로 이어집니다.",
     "brain.graph.emptyFocus": "대화, 문서, 프로젝트를 쌓으면 Brain 그래프가 자랍니다.",
+    "brain.graph.search": "검색",
+    "brain.graph.searchAria": "지식 그래프 검색",
     "care.title": "내 Brain 돌보기",
     "care.subtitle": "내 컴퓨터에 두고, 필요하면 옮길 수 있습니다.",
     "care.private": "개인 보관",
+    "care.ownershipModel": "소유 모델",
     "care.export": "내보내기",
     "care.export.detail": "다른 곳으로 가져가기",
     "care.backup": "백업",
     "care.backup.detail": "복사본 저장",
+    "care.backup.count": "백업 {count}개",
+    "care.backup.ready": "백업 준비됨",
     "care.archive": "보관 파일",
     "care.archive.detail": "암호화된 Brain",
     "care.path.placeholder": "확인하거나 미리 볼 보관 파일 경로",
     "care.path.label": "Brain 보관 파일 경로",
     "care.passphrase.placeholder": "보관 파일 비밀번호",
     "care.passphrase.label": "Brain 보관 파일 비밀번호",
+    "care.passphrase.confirmPlaceholder": "비밀번호 다시 입력",
+    "care.passphrase.confirmLabel": "Brain 보관 파일 비밀번호 확인",
+    "care.passphrase.tooShort": "비밀번호는 12자 이상이어야 합니다.",
+    "care.passphrase.tooSimple": "대문자, 소문자, 숫자, 기호 중 3종류 이상을 섞어 주세요.",
+    "care.passphrase.mismatch": "비밀번호 확인이 일치하지 않습니다.",
+    "care.passphrase.strong": "비밀번호 강도가 충분합니다.",
+    "care.path.ready": "보관 파일 경로 형식이 올바릅니다.",
+    "care.path.invalidChars": "보관 파일 경로에 사용할 수 없는 문자가 있습니다.",
+    "care.path.extension": ".latticebrain, .zip, .json 파일만 확인할 수 있습니다.",
     "care.inspect": "확인",
     "care.restorePreview": "복원 미리보기",
     "care.note": "복원 미리보기는 Brain을 바꾸지 않고 보관 파일만 확인합니다. 실제 복원은 설정에서 확정합니다.",
     "care.working": "진행 중",
+    "care.result.error": "Brain 관리 작업을 완료하지 못했습니다.",
+    "care.result.completed": "Brain 관리 작업 완료",
+    "care.result.path": "파일: {path}",
+    "care.result.contents": "기억 {memories}개 · 연결 {links}개 · 대화 {conversations}개",
+    "care.result.dryRun": "미리보기만 실행되어 현재 Brain은 바뀌지 않았습니다.",
     "admin.back": "Brain",
+    "admin.aria.console": "Lattice 관리자",
     "admin.kicker": "분리된 관리자 작업공간",
     "admin.title": "Admin Console",
     "admin.body": "사용자, 로그, 보안, Brain 상태는 일반 사용자 화면과 분리됩니다.",
@@ -173,7 +208,9 @@ export const COPY: Record<Language, TextMap> = {
     "flow.login.title": "내 AI 브레인의 주인을 정합니다.",
     "flow.login.body": "Lattice AI는 내 지식과 맥락을 이 컴퓨터에 보관하는 로컬 우선 AI 브레인입니다. 모델은 바꿀 수 있고, 외부 전송은 사용자가 선택할 때만 시작됩니다.",
     "flow.name": "이름",
+    "flow.name.placeholder": "나",
     "flow.email": "이메일",
+    "flow.email.placeholder": "you@local",
     "flow.password": "비밀번호",
     "flow.password.placeholder": "로컬 Brain 비밀번호",
     "flow.login.busy": "Brain 여는 중...",
@@ -189,6 +226,7 @@ export const COPY: Record<Language, TextMap> = {
     "flow.promise.model.v": "모델은 목소리이고, 자산은 Brain입니다.",
     "flow.promise.ownership.k": "사용자 소유",
     "flow.promise.ownership.v": "백업, 복원, 이동을 직접 결정합니다.",
+    "flow.promise.aria": "Lattice AI 제품 약속",
     "flow.analysis.title": "이 컴퓨터에서 가능한 경험을 확인합니다.",
     "flow.analysis.body": "스펙 점수가 아니라, 이 Mac에서 어떤 로컬 AI 브레인 경험이 편한지 알려드립니다. 확인은 로컬 상태를 읽는 것이고, 클라우드 모델은 선택 사항입니다.",
     "flow.analysis.finding": "가장 편한 설정을 찾는 중...",
@@ -196,6 +234,10 @@ export const COPY: Record<Language, TextMap> = {
     "flow.analysis.wait": "잠시만 기다리면 자동으로 정리됩니다.",
     "flow.analysis.error": "Lattice가 이 컴퓨터를 끝까지 확인하지 못했습니다. 그래도 안전한 기본값으로 계속할 수 있습니다.",
     "flow.analysis.continue": "추천 모델 보기",
+    "flow.analysis.bestFit": "{model}이 이 컴퓨터에 가장 잘 맞습니다.",
+    "flow.analysis.privateRecommended": "이 컴퓨터에는 개인 로컬 Brain을 추천합니다.",
+    "flow.analysis.os.windows": "Windows PC",
+    "flow.analysis.os.linux": "Linux 컴퓨터",
     "flow.recommend.title": "추천대로 시작하세요.",
     "flow.recommend.body": "모델은 Brain의 현재 목소리입니다. 가장 안전한 추천, 더 빠른 모델, 더 강한 모델만 먼저 보여드립니다.",
     "flow.recommend.primary": "추천대로 시작하기",
@@ -203,6 +245,10 @@ export const COPY: Record<Language, TextMap> = {
     "flow.recommend.back": "뒤로",
     "flow.recommend.skip": "모델 없이 Brain 열기",
     "flow.recommend.hint": "잘 모르겠다면 추천대로 시작하면 됩니다.",
+    "flow.recommend.rank.best": "추천",
+    "flow.recommend.rank.faster": "빠른 선택",
+    "flow.recommend.rank.advanced": "고급 선택",
+    "flow.recommend.rank.choice": "선택 {index}",
     "flow.install.title": "모델을 설치하고 시작합니다.",
     "flow.install.body": "이 모델이 Brain의 로컬 목소리가 됩니다. 인터넷은 다운로드할 때만 필요하고, 실행과 기억은 이 컴퓨터에서 유지됩니다.",
     "flow.install.wait": "Brain이 사용할 모델을 기다리고 있습니다.",
@@ -235,11 +281,24 @@ export const COPY: Record<Language, TextMap> = {
     "brain.depth.3": "Topics",
     "brain.depth.4": "Relationships",
     "brain.depth.5": "Full knowledge graph",
+    "brain.depthLabel.1": "Living Brain",
+    "brain.depthLabel.2": "Memory Layer",
+    "brain.depthLabel.3": "Knowledge Layer",
+    "brain.depthLabel.4": "Relationship Layer",
+    "brain.depthLabel.5": "Knowledge Graph",
     "brain.view.memories": "Memories",
     "brain.view.topics": "Topics",
     "brain.view.relationships": "Relationships",
     "brain.view.graph": "Graph",
     "brain.surface": "Back",
+    "brain.aria.home": "Lattice Brain",
+    "brain.aria.exploration": "Brain exploration",
+    "brain.aria.quickViews": "Brain quick views",
+    "brain.aria.conversation": "Conversation",
+    "brain.aria.ownership": "Brain ownership guarantees",
+    "brain.aria.starterPrompts": "Starter prompts",
+    "brain.aria.overview": "Brain overview",
+    "brain.aria.graph": "Knowledge Graph",
     "brain.title": "Lattice Brain",
     "brain.local": "Local-first",
     "brain.portable": "Portable",
@@ -271,28 +330,50 @@ export const COPY: Record<Language, TextMap> = {
     "brain.overview.olderEmpty": "Earlier memories appear as conversations accumulate.",
     "brain.overview.topics": "Main topics",
     "brain.overview.topicsEmpty": "Topics are still forming.",
+    "brain.memory.empty": "Memory is quiet",
+    "brain.knowledge.empty": "Knowledge is forming",
     "brain.graph.empty": "No matching knowledge yet",
     "brain.graph.summaryFallback": "This concept is part of the deepest knowledge layer.",
     "brain.graph.focused": "Ideas that appeared together in conversations and documents are connected by lines.",
     "brain.graph.emptyFocus": "Your Brain graph grows as you add conversations, documents, and projects.",
+    "brain.graph.search": "Search",
+    "brain.graph.searchAria": "Search knowledge graph",
     "care.title": "Care for my Brain",
     "care.subtitle": "Own it locally. Keep it portable.",
     "care.private": "Private",
+    "care.ownershipModel": "Ownership model",
     "care.export": "Export",
     "care.export.detail": "Take it with you",
     "care.backup": "Backup",
     "care.backup.detail": "Save a copy",
+    "care.backup.count": "{count} backups",
+    "care.backup.ready": "Backups ready",
     "care.archive": "Archive",
     "care.archive.detail": "Encrypted Brain",
     "care.path.placeholder": "Paste an archive path to inspect or preview",
     "care.path.label": "Brain archive path",
     "care.passphrase.placeholder": "Archive passphrase",
     "care.passphrase.label": "Brain archive passphrase",
+    "care.passphrase.confirmPlaceholder": "Repeat passphrase",
+    "care.passphrase.confirmLabel": "Confirm Brain archive passphrase",
+    "care.passphrase.tooShort": "Use at least 12 characters.",
+    "care.passphrase.tooSimple": "Mix at least three of uppercase, lowercase, numbers, and symbols.",
+    "care.passphrase.mismatch": "Passphrases do not match.",
+    "care.passphrase.strong": "Passphrase strength is sufficient.",
+    "care.path.ready": "Archive path format looks valid.",
+    "care.path.invalidChars": "Archive path contains unsupported characters.",
+    "care.path.extension": "Use a .latticebrain, .zip, or .json archive.",
     "care.inspect": "Inspect",
     "care.restorePreview": "Restore preview",
     "care.note": "Restore preview checks an archive without changing your Brain. Confirmed restore stays in Settings.",
     "care.working": "Working",
+    "care.result.error": "Brain care action could not complete.",
+    "care.result.completed": "Brain care action completed.",
+    "care.result.path": "File: {path}",
+    "care.result.contents": "{memories} memories · {links} links · {conversations} conversations",
+    "care.result.dryRun": "Preview only; your current Brain was not changed.",
     "admin.back": "Brain",
+    "admin.aria.console": "Lattice Admin",
     "admin.kicker": "Separate admin workspace",
     "admin.title": "Admin Console",
     "admin.body": "Users, logs, security, and Brain health stay out of the normal user experience.",
@@ -390,7 +471,9 @@ export const COPY: Record<Language, TextMap> = {
     "flow.login.title": "Choose the owner of your AI Brain.",
     "flow.login.body": "Lattice AI is a local-first Digital Brain that keeps your knowledge on this computer. Models can change; external transfer starts only when you choose it.",
     "flow.name": "Name",
+    "flow.name.placeholder": "You",
     "flow.email": "Email",
+    "flow.email.placeholder": "you@local",
     "flow.password": "Password",
     "flow.password.placeholder": "Local Brain password",
     "flow.login.busy": "Opening Brain...",
@@ -406,6 +489,7 @@ export const COPY: Record<Language, TextMap> = {
     "flow.promise.model.v": "The model is the voice; the Brain is the asset.",
     "flow.promise.ownership.k": "User owned",
     "flow.promise.ownership.v": "You decide when to back up, restore, or move it.",
+    "flow.promise.aria": "Lattice AI product promise",
     "flow.analysis.title": "Checking what this computer can do.",
     "flow.analysis.body": "This is not a spec test. Lattice reads local capability and explains what AI Brain experience this Mac can support. Cloud models remain optional.",
     "flow.analysis.finding": "Finding the easiest setup...",
@@ -413,6 +497,10 @@ export const COPY: Record<Language, TextMap> = {
     "flow.analysis.wait": "This will be summarized automatically in a moment.",
     "flow.analysis.error": "Lattice could not finish checking this computer. You can still continue with a safe default.",
     "flow.analysis.continue": "View recommended models",
+    "flow.analysis.bestFit": "{model} looks like the best fit.",
+    "flow.analysis.privateRecommended": "A private local Brain is recommended for this computer.",
+    "flow.analysis.os.windows": "Windows PC",
+    "flow.analysis.os.linux": "Linux computer",
     "flow.recommend.title": "Start with the recommendation.",
     "flow.recommend.body": "The model is your Brain's current voice. You see the safest recommendation, a faster model, and a stronger model first.",
     "flow.recommend.primary": "Start with recommendation",
@@ -420,6 +508,10 @@ export const COPY: Record<Language, TextMap> = {
     "flow.recommend.back": "Back",
     "flow.recommend.skip": "Open Brain without a model",
     "flow.recommend.hint": "If unsure, start with the recommendation.",
+    "flow.recommend.rank.best": "Best Experience",
+    "flow.recommend.rank.faster": "Faster",
+    "flow.recommend.rank.advanced": "Advanced",
+    "flow.recommend.rank.choice": "Choice {index}",
     "flow.install.title": "Install the model and start.",
     "flow.install.body": "This model becomes your Brain's local voice. Internet is needed only for download; execution and memory stay on this computer.",
     "flow.install.wait": "Waiting for the model your Brain will use.",

package/frontend/src/pages/Brain.tsx

@@ -457,7 +457,7 @@ export function BrainPage({ initialTab }: { initialTab?: string }) {
             {(data) => <MemoryStatus data={data as Record<string, unknown>} />}
           </DataPanel>
           <DataPanel title="Recent sources" result={provenance.data}>
-            {(data) => <EntityList items={(data as Record<string, unknown>).items || data} titleKey="source" metaKey="source_type" />}
+            {(data) => <SourceProvenanceList items={(data as Record<string, unknown>).items || data} />}
           </DataPanel>
         </div>
       ) : null}
@@ -527,6 +527,7 @@ function RetrievalStatus({ data }: { data: Record<string, unknown> }) {
 
 function MemoryStatus({ data }: { data: Record<string, unknown> }) {
   const usage = isRecord(data.usage) ? data.usage : {};
+  const sources = asArray<Record<string, unknown>>(data.sources || data.tiers);
   return (
     <div className="space-y-3">
       <StatGrid stats={[
@@ -535,7 +536,7 @@ function MemoryStatus({ data }: { data: Record<string, unknown> }) {
         { label: "Bytes", value: usage.total_bytes ?? 0 },
         { label: "Health", value: data.health || "reported" },
       ]} />
-      <EntityList items={data.sources || data.tiers} titleKey="label" metaKey="health" />
+      <SourceProvenanceList items={sources} limit={6} />
     </div>
   );
 }
@@ -667,15 +668,20 @@ function DigitalBrainExplorer({ data }: { data: unknown }) {
                   {mode === "basic" ? (
                     <KeyValueList data={{
                       connections: selected.degree,
-                      source: selected.source || "not reported",
+                      source: selected.source || "Source not recorded",
+                      source_type: sourceType(selected.raw),
+                      created_at: sourceCreatedAt(selected.raw) || "Created time not recorded",
                     }} />
                   ) : (
                     <StructuredView value={{
                       id: selected.id,
                       degree: selected.degree,
-                      source: selected.source || "not reported",
+                      source: selected.source || "Source not recorded",
+                      source_type: sourceType(selected.raw),
+                      created_at: sourceCreatedAt(selected.raw) || "Created time not recorded",
                     }} />
                   )}
+                  {selected.source ? <Button variant="outline" size="sm" onClick={() => void navigator.clipboard?.writeText(selected.source)}>Copy source</Button> : null}
                 </>
               ) : selectedGroup ? (
                 <div className="space-y-2">
@@ -779,12 +785,64 @@ function ProvenancePanel() {
         {(data) => <StructuredView value={data} />}
       </DataPanel>
       <DataPanel title="Recent sources" result={provenance.data}>
-        {(data) => <EntityList items={(data as Record<string, unknown>).items || data} titleKey="source" metaKey="source_type" limit={14} />}
+        {(data) => <SourceProvenanceList items={(data as Record<string, unknown>).items || data} limit={14} />}
       </DataPanel>
     </div>
   );
 }
 
+function SourceProvenanceList({ items, limit = 8 }: { items: unknown; limit?: number }) {
+  const rows = asArray<Record<string, unknown>>(items).slice(0, limit);
+  if (!rows.length) return <EmptyState title="No sources yet" detail="New memories will show their chat, manual, document, or import origin here." />;
+  return (
+    <div className="grid gap-2">
+      {rows.map((item, index) => {
+        const title = String(item.title || item.label || item.source_title || item.filename || item.path || item.source || `Source ${index + 1}`);
+        const path = String(item.path || item.source_path || item.source || item.conversation_id || "");
+        const type = sourceType(item);
+        const created = sourceCreatedAt(item);
+        return (
+          <div key={String(item.id || item.source_id || title)} className="rounded-lg border border-border bg-background/55 p-3">
+            <div className="flex flex-wrap items-start justify-between gap-2">
+              <div>
+                <div className="font-medium">{title}</div>
+                <div className="mt-1 text-xs text-muted-foreground">
+                  {type} · {created || "Created time not recorded"}
+                </div>
+              </div>
+              <Badge variant="muted">{path ? "inspectable" : "missing provenance"}</Badge>
+            </div>
+            {path ? (
+              <div className="mt-2 flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
+                <span className="break-all">{path}</span>
+                <Button variant="outline" size="sm" onClick={() => void navigator.clipboard?.writeText(path)}>Copy source</Button>
+              </div>
+            ) : (
+              <p className="mt-2 text-xs text-muted-foreground">This older memory did not record a source path or conversation. It remains searchable, but provenance is incomplete.</p>
+            )}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+function sourceType(item: Record<string, unknown>) {
+  const metadata = isRecord(item.metadata) ? item.metadata : {};
+  const raw = String(item.source_type || item.type || item.kind || metadata.source_type || metadata.role || "").toLowerCase();
+  if (/chat|conversation|message/.test(raw)) return "chat";
+  if (/document|upload|file|pdf|markdown|text/.test(raw)) return "document";
+  if (/import|archive|restore/.test(raw)) return "import";
+  if (/manual|note/.test(raw)) return "manual";
+  return "source unknown";
+}
+
+function sourceCreatedAt(item: Record<string, unknown>) {
+  const metadata = isRecord(item.metadata) ? item.metadata : {};
+  const value = item.created_at || item.timestamp || item.updated_at || metadata.created_at || metadata.timestamp;
+  return value ? String(value) : "";
+}
+
 function PortabilityPanel() {
   const qc = useQueryClient();
   const [artifact, setArtifact] = React.useState("");