ltcai 4.5.1 → 4.6.1

package/frontend/src/api/client.ts

@@ -341,6 +341,7 @@ export const latticeApi = {
   connectFolder: (path: string) => post("/knowledge-graph/local/index", { path, approved: true, watch_enabled: true, consent: { approved: true, source: "desktop-spa" } }, {}),
   localWatchStop: (source_id: string) => post("/knowledge-graph/local/watch/stop", { source_id }, {}),
   models: () => get("/models", { catalog: [], loaded: [], recommended: [] }),
+  setupScan: () => get("/setup/scan", { environment: {}, recommendations: {}, zero_config: {} }),
   modelRecommendations: (engine = "local_mlx") => get("/models/recommendations", { profile: {}, recommendations: { models: [], families: [], counts: {} } }, { engine }),
   installEngine: (engine: string) => post("/engines/install", { engine }, {}),
   prepareModel: (model: string, engine?: string, allow_download = false) => post("/engines/prepare-model", { model, engine: engine || null, allow_download }, {}),

package/frontend/src/components/BrainConversation.tsx

@@ -0,0 +1,309 @@
+import * as React from "react";
+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 { 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";
+
+type Msg = { role?: string; content?: string; timestamp?: string };
+type BrainActivity = BrainState;
+type BrainVitals = {
+  connected: boolean;
+  memories: number;
+  knowledge: number;
+  conversations: number;
+  model: string | null;
+};
+
+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);
+  });
+}
+
+function newConversationId() {
+  const suffix = globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.round(Math.random() * 10000)}`;
+  return `brain-${suffix}`;
+}
+
+function currentModelName(data: unknown) {
+  const record = data && typeof data === "object" ? data as Record<string, unknown> : {};
+  if (typeof record.current === "string" && record.current) return record.current;
+  const loaded = asArray<Record<string, unknown>>(record.loaded);
+  const firstLoaded = loaded.find((item) => item.id || item.name || item.model_id);
+  if (firstLoaded) return String(firstLoaded.name || firstLoaded.id || firstLoaded.model_id);
+  return null;
+}
+
+function usageNumber(data: unknown, key: string) {
+  const record = data && typeof data === "object" ? data as Record<string, unknown> : {};
+  const usage = record.usage && typeof record.usage === "object" ? record.usage as Record<string, unknown> : {};
+  const value = Number(usage[key] ?? record[key]);
+  return Number.isFinite(value) ? value : null;
+}
+
+export function BrainConversation({ className }: { className?: string }) {
+  const qc = useQueryClient();
+  const history = useQuery({ queryKey: ["chatHistory"], queryFn: latticeApi.chatHistory });
+  const models = useQuery({ queryKey: ["models"], queryFn: latticeApi.models });
+  const memory = useQuery({ queryKey: ["memoryManager"], queryFn: latticeApi.memoryManager });
+  const agentRuntime = useQuery({ queryKey: ["agentRuntime"], queryFn: latticeApi.agentRuntime, refetchInterval: 12000 });
+  const [conversationId, setConversationId] = React.useState<string | null>(null);
+  const [selectedConversationId, setSelectedConversationId] = React.useState<string | null>(null);
+  const conversation = useQuery({
+    queryKey: ["conversation", selectedConversationId],
+    queryFn: () => latticeApi.conversation(selectedConversationId || ""),
+    enabled: !!selectedConversationId,
+  });
+  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;
+    const activeConversationId = conversationId || newConversationId();
+    if (!conversationId) setConversationId(activeConversationId);
+    setDraft("");
+    setMessages((items) => [...items, { role: "user", content: message }, { role: "assistant", content: "" }]);
+    setStreaming(true);
+    try {
+      const result = await latticeApi.streamChat(
+        { message, conversation_id: activeConversationId, 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"] });
+      await qc.invalidateQueries({ queryKey: ["memoryManager"] });
+    }
+  };
+
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => latticeApi.deleteConversation(id),
+    onSuccess: async (_result, id) => {
+      if (conversationId === id) {
+        setConversationId(null);
+        setSelectedConversationId(null);
+        setMessages([]);
+      }
+      await qc.invalidateQueries({ queryKey: ["chatHistory"] });
+    },
+  });
+
+  const historyItems = asArray<Record<string, unknown>>(history.data?.data);
+  const memoryData = memory.data?.data;
+  const runtimeData = agentRuntime.data?.data as Record<string, unknown> | undefined;
+  const runs = asArray<Record<string, unknown>>(runtimeData?.runs);
+  const activity: BrainActivity =
+    streaming ? "thinking" :
+    imageData ? "recalling" :
+    runs.some((run) => String(run.status || run.state || "").match(/running|active|queued/i)) ? "acting" :
+    draft.trim().length > 2 ? "listening" :
+    trace ? "recalling" :
+    "idle";
+  const vitals: BrainVitals = {
+    connected: Boolean(models.data?.ok),
+    memories: usageNumber(memoryData, "total_items") ?? asArray((memoryData as Record<string, unknown> | undefined)?.sources).length,
+    knowledge: usageNumber(memoryData, "sources") ?? asArray((memoryData as Record<string, unknown> | undefined)?.tiers).length,
+    conversations: historyItems.length,
+    model: currentModelName(models.data?.data),
+  };
+
+  return (
+    <div className={className}>
+      <div className="brain-conversation-grid">
+        <section className="brain-presence-column" aria-label="Living Brain presence">
+          <LivingBrain state={activity} size="normal" />
+        </section>
+
+        <section className="brain-chat-panel premium-surface" aria-label="Conversation with Lattice Brain">
+          <div className="brain-chat-head">
+            <div>
+              <div className="brain-chat-kicker"><MessageSquare className="h-4 w-4" /> Conversation</div>
+              <h1>Talk to your Brain.</h1>
+            </div>
+            <div className="brain-chat-model">
+              <Badge variant="muted">{currentModelName(models.data?.data) || "model readying"}</Badge>
+              <SourceBadge result={models.data} />
+            </div>
+          </div>
+
+          <div className="brain-message-stream soft-scrollbar">
+            {messages.length ? messages.map((msg, index) => (
+              <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>
+                </div>
+              </div>
+            )) : (
+              <div className="brain-empty-conversation">
+                <EmptyState
+                  title="What should we think through?"
+                  detail="Bring a question, a project, or a loose thought. Lattice will answer through your private memory when a model is ready."
+                />
+              </div>
+            )}
+          </div>
+
+          <div className="brain-composer">
+            {imageData ? <Badge variant="success" className="mb-2">image attached</Badge> : null}
+            <Textarea
+              value={draft}
+              onChange={(event) => setDraft(event.target.value)}
+              onKeyDown={(event) => {
+                if (event.key === "Enter" && !event.shiftKey) {
+                  event.preventDefault();
+                  void send();
+                }
+              }}
+              placeholder="Ask the Brain anything..."
+            />
+            <div className="brain-composer-actions">
+              <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" />
+                Image
+                <input
+                  type="file"
+                  accept="image/*"
+                  className="sr-only"
+                  onChange={async (event) => {
+                    const file = event.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="brain-context-column" aria-label="Conversation memory">
+          <RecentConversations
+            conversations={historyItems}
+            result={history.data}
+            activeId={conversationId}
+            onNew={() => {
+              setConversationId(null);
+              setSelectedConversationId(null);
+              setMessages([]);
+              setTrace(null);
+            }}
+            onSelect={(id) => {
+              setConversationId(id);
+              setSelectedConversationId(id);
+              setTrace(null);
+            }}
+            onDelete={(id) => deleteMutation.mutate(id)}
+          />
+          <MemoryNearby question={draft || [...messages].reverse().find((msg) => msg.role === "user")?.content || ""} trace={trace} />
+        </aside>
+      </div>
+    </div>
+  );
+}
+
+function RecentConversations({
+  conversations,
+  result,
+  activeId,
+  onNew,
+  onSelect,
+  onDelete,
+}: {
+  conversations: Array<Record<string, unknown>>;
+  result?: Parameters<typeof SourceBadge>[0]["result"];
+  activeId: string | null;
+  onNew: () => void;
+  onSelect: (id: string) => void;
+  onDelete: (id: string) => void;
+}) {
+  return (
+    <section className="brain-side-panel">
+      <div className="brain-side-head">
+        <div>
+          <h3>Recent conversations</h3>
+          <SourceBadge result={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) => {
+          const id = String(item.id || item.conversation_id || "");
+          return (
+            <div key={id} className={`brain-conversation-item ${activeId === id ? "is-active" : ""}`}>
+              <button onClick={() => onSelect(id)} className="min-w-0 text-left">
+                <span>{String(item.title || id || "Conversation")}</span>
+                <small>{String(item.updated_at || item.started_at || "")}</small>
+              </button>
+              <button className="brain-delete-button" onClick={() => onDelete(id)} aria-label="Delete conversation">
+                <Trash2 className="h-3.5 w-3.5" />
+              </button>
+            </div>
+          );
+        }) : <EmptyState title="No conversations yet" detail="New exchanges will appear here." />}
+      </div>
+    </section>
+  );
+}
+
+function MemoryNearby({ question, trace }: { question: string; trace: unknown }) {
+  const hybrid = useQuery({
+    queryKey: ["brainNearbyMemory", question],
+    queryFn: () => latticeApi.hybridSearch(question),
+    enabled: question.trim().length > 2,
+  });
+  return (
+    <section className="brain-side-panel">
+      <div className="brain-side-head">
+        <div>
+          <h3>Memory nearby</h3>
+          <SourceBadge result={hybrid.data} />
+        </div>
+      </div>
+      {hybrid.data?.ok ? (
+        <EntityList items={(hybrid.data.data as Record<string, unknown>).matches || hybrid.data.data} titleKey="title" metaKey="type" limit={4} />
+      ) : trace ? (
+        <StructuredView value={trace} limit={4} />
+      ) : (
+        <EmptyState title="Quiet for now" detail="Relevant memory wakes up as the conversation gets specific." />
+      )}
+    </section>
+  );
+}

package/frontend/src/components/FirstRunGuide.tsx

@@ -41,9 +41,9 @@ export function FirstRunGuide() {
     { label: "Meet your Mac", done: recs.isSuccess, icon: Cpu, action: "models", detail: "Let Lattice inspect what can run locally." },
     { label: "Pick a brain", done: Boolean(topPick || currentModel), icon: Library, action: "models", detail: "Use the recommended local model." },
     { label: "Install locally", done: Boolean(currentModel || loadedModels.length), icon: Download, action: "models", detail: "Download only with explicit consent." },
-    { label: "Try a question", done: Boolean(readyProfile || currentModel || loadedModels.length), icon: PlayCircle, action: "chat", detail: "Confirm the model can answer." },
+    { label: "Talk to Brain", done: Boolean(readyProfile || currentModel || loadedModels.length), icon: PlayCircle, action: "chat", detail: "Confirm the model can answer." },
     { label: "Set the pace", done: Boolean(mode), icon: SlidersHorizontal, action: "settings", detail: "Stay Calm or switch deeper." },
-    { label: "Explore memory", done: true, icon: Layers3, action: "knowledge-graph", detail: "Open the living map." },
+    { label: "Explore deeply", done: true, icon: Layers3, action: "knowledge-graph", detail: "Open advanced relationships." },
   ];
   const completed = steps.filter((step) => step.done).length;
   const nextStep = steps.find((step) => !step.done) || steps[steps.length - 1];
@@ -53,13 +53,13 @@ export function FirstRunGuide() {
     <section className="arrival-panel" aria-label="First 10 minutes">
       <div className="arrival-copy">
         <div className="page-kicker"><CheckCircle2 className="h-4 w-4" /> First 10 minutes</div>
-        <h2>Build your Digital Brain without guessing.</h2>
+        <h2>Build your living Brain without guessing.</h2>
         <p>
           Start with a space, let Lattice recommend a private local model, then add the first pieces of knowledge.
           Every step keeps the next action visible.
         </p>
         <div className="arrival-actions">
-          <Button onClick={() => go(nextStep.action)}>{nextStep.done ? "Open memory map" : `Continue: ${nextStep.label}`}</Button>
+          <Button onClick={() => go(nextStep.action)}>{nextStep.done ? "Open relationships" : `Continue: ${nextStep.label}`}</Button>
           <Button variant="outline" onClick={() => go("models")}>Set up model</Button>
           <Button variant="ghost" onClick={() => {
             try { localStorage.setItem("lattice.onboarding.dismissed", "true"); } catch {}

package/frontend/src/components/LivingBrain.tsx

@@ -0,0 +1,212 @@
+import * as React from "react";
+import { cn } from "@/lib/utils";
+
+export type BrainState = "idle" | "listening" | "thinking" | "recalling" | "synthesizing" | "planning" | "acting" | "resting";
+
+export interface LivingBrainProps {
+  state?: BrainState;
+  intensity?: number; // 0-1 how "alive" it feels right now
+  onPulse?: () => void; // allow parent to trigger a memory pulse
+  size?: "normal" | "large" | "trace";
+  label?: string;
+  className?: string;
+  showLabel?: boolean;
+  depth?: number; // 0-5 progressive exploration depth; higher = more "open" / revealing
+  onInteract?: () => void; // called on click to advance exploration (travel deeper)
+}
+
+/**
+ * The Living Brain — the primary visual and emotional object in the product.
+ * It is not decoration. It is the other participant.
+ * It breathes. It reacts. It remembers.
+ */
+export function LivingBrain({
+  state = "idle",
+  intensity = 0.6,
+  onPulse,
+  size = "large",
+  label,
+  className,
+  showLabel = true,
+  depth = 0,
+  onInteract,
+}: LivingBrainProps) {
+  const [isPulsing, setIsPulsing] = React.useState(false);
+  const organismRef = React.useRef<HTMLButtonElement>(null);
+
+  // External trigger for memory / important recall moments
+  React.useEffect(() => {
+    if (onPulse) {
+      const handler = () => firePulse();
+      // allow global window event too for simplicity across components
+      window.addEventListener("brain:recall", handler as EventListener);
+      return () => window.removeEventListener("brain:recall", handler as EventListener);
+    }
+  }, [onPulse]);
+
+  function firePulse() {
+    setIsPulsing(true);
+    if (organismRef.current) {
+      organismRef.current.classList.add("pulse");
+      // clean after animation
+      window.setTimeout(() => {
+        if (organismRef.current) organismRef.current.classList.remove("pulse");
+        setIsPulsing(false);
+      }, 1350);
+    }
+    onPulse?.();
+  }
+
+  // Auto gentle pulse when recalling or high intensity
+  React.useEffect(() => {
+    if ((state === "recalling" || intensity > 0.82) && !isPulsing) {
+      const t = window.setTimeout(() => firePulse(), 180);
+      return () => clearTimeout(t);
+    }
+  }, [state, intensity]);
+
+  const dataState = state;
+  const isLarge = size === "large";
+  const isTrace = size === "trace";
+
+  const dynamicIntensity = Math.max(0.35, Math.min(1, intensity));
+  const effectiveDepth = Math.max(0, Math.min(5, depth || 0));
+  const canTravel = state !== "thinking";
+
+  const handleClick = () => {
+    if (!canTravel) return;
+    firePulse();
+    onInteract?.();
+  };
+
+  return (
+    <div
+      className={cn(
+        "brain-presence select-none",
+        isLarge && "large",
+        isTrace && "trace",
+        className,
+        effectiveDepth > 0 && "is-exploring"
+      )}
+      aria-label="Your living Brain"
+      role="group"
+      data-depth={effectiveDepth}
+    >
+      <button
+        type="button"
+        ref={organismRef}
+        className={cn("brain-organism", `size-${size}`, `depth-${effectiveDepth}`)}
+        data-state={dataState}
+        aria-label={effectiveDepth < 5 ? "Travel deeper into your Brain" : "Rest inside the Knowledge Graph"}
+        aria-disabled={!canTravel}
+        style={{
+          transform: `scale(${0.96 + (dynamicIntensity - 0.5) * 0.09 + effectiveDepth * 0.015})`,
+        }}
+        onClick={handleClick}
+        title={effectiveDepth < 5 ? "Travel deeper into your Brain" : "The core of your knowledge"}
+      >
+        {/* Living anatomical presence. The glow opens with depth; the folds make it unmistakably a Brain. */}
+        <div className="brain-core" style={{ transform: `scale(${1 + effectiveDepth * 0.045})` }}>
+          <svg className="brain-anatomy" viewBox="0 0 220 174" aria-hidden>
+            <path
+              className="brain-lobe brain-lobe-left"
+              d="M102 30c-13-20-44-19-55 1-18 1-29 16-28 33-13 8-18 25-11 39-9 16-1 36 17 42 5 19 27 26 43 15 13 10 33 8 43-5 5-7 8-16 8-27V52c0-8-6-17-17-22Z"
+            />
+            <path
+              className="brain-lobe brain-lobe-right"
+              d="M118 30c13-20 44-19 55 1 18 1 29 16 28 33 13 8 18 25 11 39 9 16 1 36-17 42-5 19-27 26-43 15-13 10-33 8-43-5-5-7-8-16-8-27V52c0-8 6-17 17-22Z"
+            />
+            <path className="brain-bridge" d="M103 48c9-8 24-8 33 0 7 6 9 16 5 25-5 11-16 15-31 12-15 3-26-1-31-12-4-9-2-19 5-25 5-4 12-6 19 0Z" />
+            <path className="brain-stem" d="M92 137c10 9 26 9 36 0 1 14 7 25 20 33H76c12-8 17-19 16-33Z" />
+            <path className="brain-fold fold-a" d="M48 50c18-11 38-8 47 8" />
+            <path className="brain-fold fold-b" d="M34 82c22-8 45-5 58 8" />
+            <path className="brain-fold fold-c" d="M43 119c18 5 35 2 49-11" />
+            <path className="brain-fold fold-d" d="M172 50c-18-11-38-8-47 8" />
+            <path className="brain-fold fold-e" d="M186 82c-22-8-45-5-58 8" />
+            <path className="brain-fold fold-f" d="M177 119c-18 5-35 2-49-11" />
+            <path className="brain-fold fold-mid" d="M110 38c-5 30-5 70 0 112" />
+          </svg>
+        </div>
+
+        {/* Breathing field expands as we go deeper. */}
+        <div
+          className="brain-aura"
+          style={{
+            animationDuration: state === "thinking" ? "1.65s" : state === "recalling" ? "2.4s" : "6.8s",
+            transform: `scale(${1 + effectiveDepth * 0.12})`,
+            opacity: 0.65 + effectiveDepth * 0.05
+          }}
+        />
+
+        {/* Thought activity — increases and starts to "resolve" into structure at higher depths */}
+        <div className="thought-activity" aria-hidden>
+          {Array.from({ length: Math.min(12, 5 + effectiveDepth * 2) }).map((_, i) => (
+            <div
+              key={i}
+              className={cn("thought-particle", effectiveDepth >= 3 && "resolving")}
+              style={{
+                left: `${18 + ((i * 13 + effectiveDepth * 4) % 64)}%`,
+                top: `${22 + (i % 5) * 14}%`,
+                animationDelay: `-${i * 0.55 + (intensity * 1.1) - effectiveDepth * 0.2}s`,
+                animationDuration: `${2.8 + (1 - dynamicIntensity) * 1.6 - effectiveDepth * 0.15}s`,
+              }}
+            />
+          ))}
+        </div>
+
+        {/* Memory ripples — more and stronger as depth increases (echoes surfacing) */}
+        {Array.from({ length: 1 + Math.floor(effectiveDepth / 1.5) }).map((_, i) => (
+          <div
+            key={i}
+            className="memory-ripple"
+            aria-hidden
+            style={{
+              inset: `${18 + i * 6}%`,
+              animationDelay: `${180 + i * 220}ms`,
+              opacity: 0.55 + effectiveDepth * 0.06
+            }}
+          />
+        ))}
+
+        {/* Relationship structure appears only near the deepest layers. */}
+        {effectiveDepth >= 4 && (
+          <svg className="brain-inner-structure" viewBox="0 0 100 100" aria-hidden>
+            <g stroke="hsl(var(--brain-core) / 0.35)" strokeWidth="0.6" fill="none">
+              <circle cx="50" cy="50" r="18" />
+              <circle cx="50" cy="50" r="28" />
+              <path d="M32 50 Q50 32 68 50" />
+              <path d="M32 50 Q50 68 68 50" />
+            </g>
+          </svg>
+        )}
+      </button>
+
+      {showLabel && !isTrace && (
+        <div className="brain-presence-label" data-state={state}>
+          <span className="dot" />
+          {label || (effectiveDepth > 0 ? `Depth ${effectiveDepth}` : humanState(state))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function humanState(s: BrainState) {
+  switch (s) {
+    case "listening": return "Listening";
+    case "thinking": return "Thinking with you";
+    case "recalling": return "Remembering";
+    case "synthesizing": return "Making sense";
+    case "planning": return "Planning";
+    case "acting": return "Acting";
+    case "resting": return "With you";
+    default: return "Here";
+  }
+}
+
+// Helper to broadcast recall pulses from anywhere (conversation, memory surface, etc)
+export function triggerBrainRecall() {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent("brain:recall"));
+  }
+}