ltcai 6.2.0 → 6.3.1

package/frontend/src/pages/Capture.tsx

@@ -1,33 +1,35 @@
 import * as React from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { FolderPlus, Globe2, HardDrive, Upload } from "lucide-react";
+import { AlertCircle, CheckCircle2, FolderPlus, Globe2, HardDrive, Loader2, RotateCcw, Upload } from "lucide-react";
 import { latticeApi } from "@/api/client";
 import { ActionButton, DataPanel, EntityList, OperationResult, StructuredView, Tabs } from "@/components/primitives";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
 import { Input } from "@/components/ui/input";
+import { t, type Language } from "@/i18n";
 import { asArray } from "@/lib/utils";
+import { useAppStore } from "@/store/appStore";
 
 type CaptureTab = "files" | "local" | "browser" | "pipeline";
 
-const tabs: Array<{ id: CaptureTab; label: string }> = [
-  { id: "files", label: "Files" },
-  { id: "local", label: "Folders" },
-  { id: "browser", label: "Web" },
-  { id: "pipeline", label: "Flow" },
-];
-
 export function CapturePage({ initialTab }: { initialTab?: string }) {
+  const language = useAppStore((state) => state.language);
   const [tab, setTab] = React.useState<CaptureTab>((initialTab as CaptureTab) || "files");
+  const tabs: Array<{ id: CaptureTab; label: string }> = [
+    { id: "files", label: t(language, "capture.tab.files") },
+    { id: "local", label: t(language, "capture.tab.local") },
+    { id: "browser", label: t(language, "capture.tab.browser") },
+    { id: "pipeline", label: t(language, "capture.tab.pipeline") },
+  ];
   React.useEffect(() => {
     if (initialTab === "pipeline" || initialTab === "local" || initialTab === "files") setTab(initialTab);
   }, [initialTab]);
   return (
     <div className="space-y-5">
       <header className="page-hero">
-        <div className="page-kicker"><Upload className="h-4 w-4" /> Add</div>
-        <h1 className="page-title">Feed the brain what matters.</h1>
-        <p className="page-copy">Drop in files, connect folders, or save a page. Lattice remembers the origin of every idea it learns.</p>
+        <div className="page-kicker"><Upload className="h-4 w-4" /> {t(language, "capture.kicker")}</div>
+        <h1 className="page-title">{t(language, "capture.title")}</h1>
+        <p className="page-copy">{t(language, "capture.body")}</p>
       </header>
       <Tabs tabs={tabs} value={tab} onChange={(id) => setTab(id as CaptureTab)} />
       {tab === "files" ? <FilesPanel /> : null}
@@ -39,41 +41,133 @@ export function CapturePage({ initialTab }: { initialTab?: string }) {
 }
 
 function FilesPanel() {
+  const language = useAppStore((state) => state.language);
   const qc = useQueryClient();
   const docs = useQuery({ queryKey: ["documents"], queryFn: () => latticeApi.documents(200) });
+  const [queue, setQueue] = React.useState<UploadQueueItem[]>([]);
   const upload = useMutation({
-    mutationFn: (files: FileList) => Promise.all(Array.from(files).map((file) => latticeApi.uploadDocument(file))),
-    onSuccess: () => qc.invalidateQueries({ queryKey: ["documents"] }),
+    mutationFn: (files: File[]) => uploadFiles(files, setQueue),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: ["documents"] });
+      void qc.invalidateQueries({ queryKey: ["graphStats"] });
+      void qc.invalidateQueries({ queryKey: ["memoryManager"] });
+    },
   });
+  const beginUpload = React.useCallback((files: FileList | File[]) => {
+    const nextFiles = Array.from(files);
+    if (!nextFiles.length) return;
+    upload.mutate(nextFiles);
+  }, [upload]);
   return (
     <div className="grid gap-4 xl:grid-cols-[0.75fr_1.25fr]">
       <Card>
         <CardHeader>
-          <CardTitle className="flex items-center gap-2"><Upload className="h-4 w-4" /> Add documents</CardTitle>
-          <CardDescription>Choose files and Lattice will prepare them for search and memory.</CardDescription>
+          <CardTitle className="flex items-center gap-2"><Upload className="h-4 w-4" /> {t(language, "capture.files.title")}</CardTitle>
+          <CardDescription>{t(language, "capture.files.description")}</CardDescription>
         </CardHeader>
         <CardContent>
-          <label className="flex min-h-56 cursor-pointer flex-col items-center justify-center gap-3 rounded-lg border border-dashed border-border bg-muted/30 p-6 text-center transition hover:bg-muted/50">
+          <label
+            className="flex min-h-56 cursor-pointer flex-col items-center justify-center gap-3 rounded-lg border border-dashed border-border bg-muted/30 p-6 text-center transition hover:bg-muted/50"
+            onDragOver={(event) => event.preventDefault()}
+            onDrop={(event) => {
+              event.preventDefault();
+              beginUpload(event.dataTransfer.files);
+            }}
+          >
             <Upload className="h-7 w-7 text-primary" />
-            <span className="text-lg font-semibold">Choose files</span>
-            <span className="max-w-sm text-sm leading-6 text-muted-foreground">PDF, Office files, notes, markdown, text, and spreadsheets are all welcome.</span>
-            <input type="file" multiple className="sr-only" onChange={(e) => e.target.files && upload.mutate(e.target.files)} />
+            <span className="text-lg font-semibold">{t(language, "capture.files.drop")}</span>
+            <span className="max-w-sm text-sm leading-6 text-muted-foreground">{t(language, "capture.files.dropDetail")}</span>
+            <input type="file" multiple className="sr-only" onChange={(e) => e.target.files && beginUpload(e.target.files)} />
           </label>
-          {upload.data ? (
-            <div className="mt-3 space-y-2">
-              {upload.data.map((item, index) => <OperationResult key={index} result={item} successLabel="Upload completed" />)}
-            </div>
-          ) : null}
+          <DocumentUploadQueue queue={queue} onRetry={(file) => beginUpload([file])} />
         </CardContent>
       </Card>
-      <DataPanel title="Uploaded documents" result={docs.data}>
-        {(data) => <EntityList items={(data as Record<string, unknown>).documents || data} titleKey="filename" metaKey="ingest_state" limit={12} />}
+      <DataPanel title={t(language, "capture.files.uploaded")} result={docs.data}>
+        {(data) => (
+          <div className="space-y-3">
+            <EntityList items={(data as Record<string, unknown>).documents || data} titleKey="filename" metaKey="ingest_state" limit={12} />
+            <div className="rounded-md border border-border bg-background/55 p-3 text-sm text-muted-foreground">
+              {t(language, "capture.files.completed")}
+            </div>
+          </div>
+        )}
       </DataPanel>
     </div>
   );
 }
 
+type UploadQueueItem = {
+  id: string;
+  file: File;
+  name: string;
+  size: number;
+  status: "queued" | "uploading" | "done" | "failed";
+  result?: Awaited<ReturnType<typeof latticeApi.uploadDocument>>;
+};
+
+async function uploadFiles(files: File[], setQueue: React.Dispatch<React.SetStateAction<UploadQueueItem[]>>) {
+  const rows = files.map((file) => ({
+    id: `${file.name}-${file.size}-${file.lastModified}-${Date.now()}`,
+    file,
+    name: file.name,
+    size: file.size,
+    status: "queued" as const,
+  }));
+  setQueue((items) => [...rows, ...items].slice(0, 12));
+  const results = [];
+  for (const row of rows) {
+    setQueue((items) => items.map((item) => item.id === row.id ? { ...item, status: "uploading" } : item));
+    const result = await latticeApi.uploadDocument(row.file);
+    results.push(result);
+    setQueue((items) => items.map((item) => item.id === row.id ? { ...item, status: result.ok ? "done" : "failed", result } : item));
+  }
+  return results;
+}
+
+function DocumentUploadQueue({ queue, onRetry }: { queue: UploadQueueItem[]; onRetry: (file: File) => void }) {
+  const language = useAppStore((state) => state.language);
+  if (!queue.length) return null;
+  return (
+    <div className="mt-4 space-y-2">
+      {queue.map((item) => {
+        const detail = uploadResultDetail(item, language);
+        return (
+          <div key={item.id} className="rounded-md border border-border bg-background/55 p-3 text-sm">
+            <div className="flex flex-wrap items-start justify-between gap-3">
+              <div>
+                <div className="flex items-center gap-2 font-medium">
+                  {item.status === "done" ? <CheckCircle2 className="h-4 w-4 text-emerald-400" /> : item.status === "failed" ? <AlertCircle className="h-4 w-4 text-amber-400" /> : <Loader2 className="h-4 w-4 animate-spin text-primary" />}
+                  {item.name}
+                </div>
+                <div className="mt-1 text-xs text-muted-foreground">
+                  {Math.max(1, Math.round(item.size / 1024))} KB · {detail}
+                </div>
+              </div>
+              {item.status === "failed" ? (
+                <Button size="sm" variant="outline" onClick={() => onRetry(item.file)}>
+                  <RotateCcw className="h-3.5 w-3.5" /> {t(language, "capture.retry")}
+                </Button>
+              ) : null}
+            </div>
+            {item.result ? <OperationResult result={item.result} successLabel={t(language, "capture.files.success")} /> : null}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+function uploadResultDetail(item: UploadQueueItem, language: Language) {
+  if (item.status === "queued") return t(language, "capture.files.queued");
+  if (item.status === "uploading") return t(language, "capture.files.uploading");
+  if (!item.result?.ok) return item.result?.error || t(language, "capture.files.failed");
+  const data = item.result.data || {};
+  const node = String(data.node_id || data.graph_node || data.provenance_id || "");
+  return node ? t(language, "capture.files.capturedWithNode", { node }) : t(language, "capture.files.captured");
+}
+
 function LocalPanel() {
+  const language = useAppStore((state) => state.language);
   const qc = useQueryClient();
   const [path, setPath] = React.useState("");
   const local = useQuery({ queryKey: ["localSources"], queryFn: latticeApi.localSources });
@@ -86,16 +180,16 @@ function LocalPanel() {
     <div className="grid gap-4 xl:grid-cols-[0.9fr_1.1fr]">
       <Card>
         <CardHeader>
-          <CardTitle className="flex items-center gap-2"><FolderPlus className="h-4 w-4" /> Connect a folder</CardTitle>
-          <CardDescription>Point Lattice at a folder you want it to remember.</CardDescription>
+          <CardTitle className="flex items-center gap-2"><FolderPlus className="h-4 w-4" /> {t(language, "capture.local.title")}</CardTitle>
+          <CardDescription>{t(language, "capture.local.description")}</CardDescription>
         </CardHeader>
         <CardContent className="space-y-3">
-          <Input value={path} onChange={(e) => setPath(e.target.value)} placeholder="Folder path on this Mac" />
-          <Button disabled={!path.trim() || connect.isPending} onClick={() => connect.mutate()}>Connect Folder</Button>
-          {connect.data ? <OperationResult result={connect.data} successLabel="Folder connection requested" /> : null}
+          <Input value={path} onChange={(e) => setPath(e.target.value)} placeholder={t(language, "capture.local.placeholder")} />
+          <Button disabled={!path.trim() || connect.isPending} onClick={() => connect.mutate()}>{t(language, "capture.local.connect")}</Button>
+          {connect.data ? <OperationResult result={connect.data} successLabel={t(language, "capture.local.success")} /> : null}
         </CardContent>
       </Card>
-      <DataPanel title="Connected sources" result={local.data}>
+      <DataPanel title={t(language, "capture.local.sources")} result={local.data}>
         {(data) => (
           <div className="space-y-3">
             <EntityList items={(data as Record<string, unknown>).sources} titleKey="path" metaKey="status" />
@@ -110,7 +204,7 @@ function LocalPanel() {
           </div>
         )}
       </DataPanel>
-      <DataPanel title="Folder access" result={agent.data} className="xl:col-span-2">
+      <DataPanel title={t(language, "capture.local.access")} result={agent.data} className="xl:col-span-2">
         {(data) => <StructuredView value={data} />}
       </DataPanel>
     </div>
@@ -118,43 +212,45 @@ function LocalPanel() {
 }
 
 function BrowserPanel() {
+  const language = useAppStore((state) => state.language);
   const [url, setUrl] = React.useState("");
   const read = useMutation({ mutationFn: () => latticeApi.browserReadUrl(url) });
   return (
     <Card>
       <CardHeader>
-        <CardTitle className="flex items-center gap-2"><Globe2 className="h-4 w-4" /> Save a web page</CardTitle>
-        <CardDescription>Capture a page so Lattice can remember the useful parts.</CardDescription>
+        <CardTitle className="flex items-center gap-2"><Globe2 className="h-4 w-4" /> {t(language, "capture.browser.title")}</CardTitle>
+        <CardDescription>{t(language, "capture.browser.description")}</CardDescription>
       </CardHeader>
       <CardContent className="space-y-3">
         <div className="flex flex-col gap-2 sm:flex-row">
-          <Input value={url} onChange={(e) => setUrl(e.target.value)} placeholder="https://example.com/article" />
-          <Button disabled={!url.trim() || read.isPending} onClick={() => read.mutate()}>Capture URL</Button>
+          <Input value={url} onChange={(e) => setUrl(e.target.value)} placeholder={t(language, "capture.browser.placeholder")} />
+          <Button disabled={!url.trim() || read.isPending} onClick={() => read.mutate()}>{t(language, "capture.browser.capture")}</Button>
         </div>
-        {read.data ? <OperationResult result={read.data} successLabel="URL capture requested" /> : null}
+        {read.data ? <OperationResult result={read.data} successLabel={t(language, "capture.browser.success")} /> : null}
       </CardContent>
     </Card>
   );
 }
 
 function PipelinePanel() {
+  const language = useAppStore((state) => state.language);
   const index = useQuery({ queryKey: ["index"], queryFn: latticeApi.indexStatus });
   const stats = useQuery({ queryKey: ["graphStats"], queryFn: latticeApi.graphStats });
   return (
     <div className="grid gap-4 xl:grid-cols-2">
-      <DataPanel title="Processing status" result={index.data}>
+      <DataPanel title={t(language, "capture.pipeline.status")} result={index.data}>
         {(data) => <StructuredView value={data} />}
       </DataPanel>
-      <DataPanel title="Brain growth" result={stats.data}>
+      <DataPanel title={t(language, "capture.pipeline.growth")} result={stats.data}>
         {(data) => <StructuredView value={data} />}
       </DataPanel>
       <Card className="xl:col-span-2">
         <CardHeader>
-          <CardTitle className="flex items-center gap-2"><HardDrive className="h-4 w-4" /> Refresh memory</CardTitle>
-          <CardDescription>Refresh search when you want Lattice to re-check captured material.</CardDescription>
+          <CardTitle className="flex items-center gap-2"><HardDrive className="h-4 w-4" /> {t(language, "capture.pipeline.refresh")}</CardTitle>
+          <CardDescription>{t(language, "capture.pipeline.description")}</CardDescription>
         </CardHeader>
         <CardContent>
-          <ActionButton label="Rebuild retrieval index" action={() => latticeApi.rebuildIndex()} invalidate={["index"]} />
+          <ActionButton label={t(language, "capture.pipeline.rebuild")} action={() => latticeApi.rebuildIndex()} invalidate={["index"]} />
         </CardContent>
       </Card>
     </div>

package/frontend/src/pages/Library.tsx

@@ -109,12 +109,20 @@ function ModelsPanel() {
             const profile = (data as Record<string, unknown>).profile as Record<string, unknown> | undefined;
             return (
               <div className="space-y-4">
-                <StatGrid stats={[
-                  { label: "Computer", value: profile?.os ? `${String(profile.os)} ${String(profile.arch || "")}` : "detected" },
-                  { label: "Memory", value: recommendation?.ram_gb ? `${String(recommendation.ram_gb)} GB` : "checking" },
-                  { label: "Top pick", value: topPick?.name || topPick?.id || "choose below" },
-                  { label: "Current", value: current?.name || currentId || "none" },
-                ]} />
+                <ModelRuntimeSummary
+                  profile={profile || {}}
+                  recommendation={recommendation || {}}
+                  current={current}
+                  currentId={currentId}
+                  latestProgress={latestProgress}
+                  lastResult={lastResult}
+                  onReload={() => {
+                    if (current) void prepareModel(String(current.recommended_load_id || current.id || currentId), String(current.recommended_engine || current.engine || "local_mlx"), consent);
+                  }}
+                  onUnload={() => {
+                    if (currentId) void latticeApi.unloadModel(currentId).then(() => qc.invalidateQueries({ queryKey: ["models"] }));
+                  }}
+                />
                 <div className="grid gap-2 md:grid-cols-3 xl:grid-cols-6">
                   {[
                     ["Environment Analysis", true, Cpu],
@@ -296,6 +304,64 @@ function AlternativeModels({ compatibility }: { compatibility: Record<string, un
   );
 }
 
+function ModelRuntimeSummary({
+  profile,
+  recommendation,
+  current,
+  currentId,
+  latestProgress,
+  lastResult,
+  onReload,
+  onUnload,
+}: {
+  profile: Record<string, unknown>;
+  recommendation: Record<string, unknown>;
+  current?: Record<string, unknown>;
+  currentId: string;
+  latestProgress: Record<string, unknown> | null;
+  lastResult: Record<string, unknown> | null;
+  onReload: () => void;
+  onUnload: () => void;
+}) {
+  const loadedName = String(current?.name || current?.id || currentId || "");
+  const engine = String(current?.engine || current?.recommended_engine || latestProgress?.engine || "local_mlx");
+  const cachePath = String(current?.local_path || current?.storage_location || recommendation.cache_path || recommendation.storage_location || "~/.cache/huggingface / ~/.latticeai/models");
+  const progressStage = String(latestProgress?.stage || lastResult?.stage || (loadedName ? "ready" : "idle"));
+  return (
+    <div className="space-y-3">
+      <StatGrid stats={[
+        { label: "Computer", value: profile?.os ? `${String(profile.os)} ${String(profile.arch || "")}` : "detected" },
+        { label: "Engine", value: engine },
+        { label: "Loaded model", value: loadedName || "No local model loaded" },
+        { label: "Runtime state", value: progressStage },
+      ]} />
+      <div className="rounded-lg border border-border bg-background/55 p-3 text-sm">
+        <div className="flex flex-wrap items-start justify-between gap-3">
+          <div>
+            <div className="font-medium">{loadedName ? "Local model runtime is available" : "No model is loaded yet"}</div>
+            <div className="mt-1 text-muted-foreground">Cache/storage: {cachePath}</div>
+          </div>
+          <div className="flex flex-wrap gap-2">
+            <Button variant="outline" size="sm" disabled={!loadedName} onClick={onReload}>Reload</Button>
+            <Button variant="outline" size="sm" disabled={!loadedName} onClick={onUnload}>Unload</Button>
+          </div>
+        </div>
+        {latestProgress ? (
+          <div className="mt-3">
+            <div className="flex justify-between text-xs text-muted-foreground">
+              <span>{String(latestProgress.message || "Preparing model")}</span>
+              <span>{Number(latestProgress.percent || 0)}%</span>
+            </div>
+            <div className="mt-1 h-2 overflow-hidden rounded-full bg-muted">
+              <div className="h-full bg-primary" style={{ width: `${Number(latestProgress.percent || 8)}%` }} />
+            </div>
+          </div>
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
 function ModelRecovery({ error }: { error: Record<string, unknown> }) {
   const guidance = asArray<string>(error.recovery_guidance);
   return (

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "6.2.0"
+__version__ = "6.3.1"
 
 __all__ = [
     "AgentRuntime",

package/lattice_brain/runtime/multi_agent.py

@@ -19,7 +19,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "6.2.0"
+MULTI_AGENT_VERSION = "6.3.1"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "6.2.0"
+__version__ = "6.3.1"