ltcai 4.6.1 → 4.7.0

package/frontend/src/App.tsx

@@ -1,7 +1,22 @@
 import * as React from "react";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { ImagePlus, Search, Send } from "lucide-react";
-import { latticeApi } from "@/api/client";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Activity,
+  Archive,
+  ArrowLeft,
+  ChevronDown,
+  DatabaseBackup,
+  Download,
+  Eye,
+  ImagePlus,
+  RotateCcw,
+  Search,
+  Send,
+  ServerCog,
+  ShieldCheck,
+  Users,
+} from "lucide-react";
+import { latticeApi, type ApiResult } from "@/api/client";
 import { Button } from "@/components/ui/button";
 import { type BrainState, LivingBrain, triggerBrainRecall } from "@/components/LivingBrain";
 import { ProductFlow, readProductFlowComplete } from "@/components/ProductFlow";
@@ -51,9 +66,16 @@ const DEPTHS: Array<{ level: BrainDepth; label: string; state: BrainState }> = [
   { level: 5, label: "Knowledge Graph", state: "synthesizing" },
 ];
 
+const STARTER_PROMPTS = [
+  "Remember this decision: ",
+  "What do I already know about ",
+  "Help me turn this project context into a plan: ",
+];
+
 export default function App() {
   const theme = useAppStore((state) => state.theme);
   const [flowComplete, setFlowComplete] = React.useState(readProductFlowComplete);
+  const route = useHashRoute();
   const { state: brainState, intensity, setBrain } = useBrainState();
 
   React.useEffect(() => {
@@ -78,11 +100,35 @@ export default function App() {
   return (
     <div className="brain-space">
       <div className="brain-field" />
-      <BrainHome brainState={brainState} intensity={intensity} onBrainChange={setBrain} />
+      {route.startsWith("/admin") ? (
+        <AdminConsole onBack={() => navigateHash("/brain")} />
+      ) : (
+        <BrainHome brainState={brainState} intensity={intensity} onBrainChange={setBrain} />
+      )}
     </div>
   );
 }
 
+function useHashRoute() {
+  const read = React.useCallback(() => {
+    const hash = window.location.hash.replace(/^#/, "");
+    return hash.startsWith("/") ? hash : "/brain";
+  }, []);
+  const [route, setRoute] = React.useState(read);
+
+  React.useEffect(() => {
+    const onHashChange = () => setRoute(read());
+    window.addEventListener("hashchange", onHashChange);
+    return () => window.removeEventListener("hashchange", onHashChange);
+  }, [read]);
+
+  return route;
+}
+
+function navigateHash(route: string) {
+  window.location.hash = route;
+}
+
 function useBrainState() {
   const [state, setState] = React.useState<BrainState>("idle");
   const [intensity, setIntensity] = React.useState(0.58);
@@ -274,14 +320,33 @@ function BrainHome({
             <h1>Lattice Brain</h1>
             <span>{currentDepth.label}</span>
           </div>
+          <div className="brain-ownership-strip" aria-label="Brain ownership guarantees">
+            <span>Local-first</span>
+            <span>Portable</span>
+            <span>Private</span>
+          </div>
           <div>{modelName}</div>
+          <button className="brain-admin-link" type="button" onClick={() => navigateHash("/admin")}>
+            <ShieldCheck className="h-3.5 w-3.5" />
+            Admin
+          </button>
         </div>
 
         <div ref={streamRef} className="brain-stream">
           {messages.length === 0 ? (
             <div className="mind-empty">
-              <div className="mind-empty-kicker">Begin</div>
-              <div>What are you thinking about?</div>
+              <div className="mind-empty-kicker">Your durable context</div>
+              <div className="mind-empty-title">Start with what should not be forgotten.</div>
+              <p>
+                Lattice keeps your documents, conversations, projects, and decisions available while models can change around them.
+              </p>
+              <div className="mind-empty-prompts" aria-label="Starter prompts">
+                {STARTER_PROMPTS.map((prompt) => (
+                  <button key={prompt} type="button" onClick={() => setDraft(prompt)}>
+                    {prompt}
+                  </button>
+                ))}
+              </div>
             </div>
           ) : (
             messages.map((message, index) => (
@@ -292,6 +357,8 @@ function BrainHome({
           )}
         </div>
 
+        <BrainCarePanel />
+
         <div className="brain-composer">
           <textarea
             value={draft}
@@ -329,6 +396,318 @@ function BrainHome({
   );
 }
 
+function AdminConsole({ onBack }: { onBack: () => void }) {
+  const qc = useQueryClient();
+  const summaryQ = useQuery({ queryKey: ["adminSummary"], queryFn: latticeApi.adminSummary });
+  const statsQ = useQuery({ queryKey: ["adminStats"], queryFn: latticeApi.adminStats });
+  const usersQ = useQuery({ queryKey: ["adminUsers"], queryFn: latticeApi.adminUsers });
+  const auditQ = useQuery({ queryKey: ["adminAudit"], queryFn: latticeApi.adminAudit });
+  const securityQ = useQuery({ queryKey: ["adminSecurity"], queryFn: latticeApi.adminSecurity });
+  const securityEventsQ = useQuery({ queryKey: ["adminSecurityEvents"], queryFn: () => latticeApi.adminSecurityEvents(50) });
+  const policiesQ = useQuery({ queryKey: ["adminPolicies"], queryFn: latticeApi.adminPolicies });
+  const indexQ = useQuery({ queryKey: ["indexStatus"], queryFn: latticeApi.indexStatus });
+  const rebuildIndex = useMutation({
+    mutationFn: latticeApi.rebuildIndex,
+    onSuccess: () => void qc.invalidateQueries({ queryKey: ["indexStatus"] }),
+  });
+
+  const users = asArray(usersQ.data?.data);
+  const auditEvents = asArray((auditQ.data?.data as ApiRecord | undefined)?.recent_events);
+  const securityEvents = asArray((securityEventsQ.data?.data as ApiRecord | undefined)?.events);
+  const policies = asArray((policiesQ.data?.data as ApiRecord | undefined)?.policies);
+
+  return (
+    <main className="admin-console" aria-label="Lattice Admin">
+      <header className="admin-console-header">
+        <button className="admin-back-button" type="button" onClick={onBack}>
+          <ArrowLeft className="h-4 w-4" />
+          Brain
+        </button>
+        <div>
+          <span>Separate admin workspace</span>
+          <h1>Admin Console</h1>
+          <p>Users, logs, security, and Brain health stay out of the normal user experience.</p>
+        </div>
+      </header>
+
+      <section className="admin-metrics" aria-label="Admin overview">
+        <AdminMetric icon={<Users className="h-4 w-4" />} label="Users" value={String(users.length)} detail={sourceLabel(usersQ.data)} />
+        <AdminMetric
+          icon={<Activity className="h-4 w-4" />}
+          label="Recent logs"
+          value={String(auditEvents.length + securityEvents.length)}
+          detail={sourceLabel(auditQ.data)}
+        />
+        <AdminMetric
+          icon={<ShieldCheck className="h-4 w-4" />}
+          label="Security"
+          value={adminStatusLabel(securityQ.data?.data, "status") || (securityQ.data?.ok ? "Ready" : "Unavailable")}
+          detail={sourceLabel(securityQ.data)}
+        />
+        <AdminMetric
+          icon={<ServerCog className="h-4 w-4" />}
+          label="Brain index"
+          value={adminStatusLabel(indexQ.data?.data, "status") || (indexQ.data?.ok ? "Indexed" : "Unknown")}
+          detail={indexDetail(indexQ.data?.data)}
+        />
+      </section>
+
+      <section className="admin-grid">
+        <AdminPanel title="User Directory" eyebrow="People">
+          <AdminList
+            items={users.slice(0, 8)}
+            empty="No users reported by the admin API."
+            render={(item) => {
+              const user = item as ApiRecord;
+              return (
+                <>
+                  <strong>{stringValue(user.name || user.email || user.id, "Local user")}</strong>
+                  <span>{stringValue(user.role || user.status || user.workspace_id, "member")}</span>
+                </>
+              );
+            }}
+          />
+        </AdminPanel>
+
+        <AdminPanel title="Activity Logs" eyebrow="Audit">
+          <AdminList
+            items={auditEvents.slice(0, 8)}
+            empty="No recent audit events."
+            render={(item) => renderLogRow(item as ApiRecord)}
+          />
+        </AdminPanel>
+
+        <AdminPanel title="Security Events" eyebrow="Protection">
+          <AdminList
+            items={securityEvents.slice(0, 8)}
+            empty="No security events reported."
+            render={(item) => renderLogRow(item as ApiRecord)}
+          />
+        </AdminPanel>
+
+        <AdminPanel title="Brain Operations" eyebrow="Maintenance">
+          <div className="admin-operation">
+            <div>
+              <strong>{indexDetail(indexQ.data?.data)}</strong>
+              <span>{summaryText(summaryQ.data?.data) || summaryText(statsQ.data?.data) || "Local Brain services are separated from user chat."}</span>
+            </div>
+            <Button variant="outline" size="sm" disabled={rebuildIndex.isPending} onClick={() => rebuildIndex.mutate()}>
+              <RotateCcw className="h-3.5 w-3.5" />
+              {rebuildIndex.isPending ? "Rebuilding" : "Rebuild index"}
+            </Button>
+          </div>
+          <div className="admin-policy-strip">
+            {policies.slice(0, 5).map((item, index) => {
+              const policy = item as ApiRecord;
+              return <span key={`${stringValue(policy.id || policy.name, "policy")}-${index}`}>{stringValue(policy.name || policy.id, "Policy")}</span>;
+            })}
+            {!policies.length ? <span>Policy API quiet</span> : null}
+          </div>
+        </AdminPanel>
+      </section>
+    </main>
+  );
+}
+
+function AdminMetric({ icon, label, value, detail }: { icon: React.ReactNode; label: string; value: string; detail: string }) {
+  return (
+    <div className="admin-metric">
+      <div>{icon}</div>
+      <span>{label}</span>
+      <strong>{value}</strong>
+      <small>{detail}</small>
+    </div>
+  );
+}
+
+function AdminPanel({ eyebrow, title, children }: { eyebrow: string; title: string; children: React.ReactNode }) {
+  return (
+    <section className="admin-panel">
+      <div className="admin-panel-head">
+        <span>{eyebrow}</span>
+        <h2>{title}</h2>
+      </div>
+      {children}
+    </section>
+  );
+}
+
+function AdminList({ items, empty, render }: { items: unknown[]; empty: string; render: (item: unknown) => React.ReactNode }) {
+  if (!items.length) return <div className="admin-empty">{empty}</div>;
+  return <div className="admin-list">{items.map((item, index) => <div key={index} className="admin-list-row">{render(item)}</div>)}</div>;
+}
+
+function BrainCarePanel() {
+  const qc = useQueryClient();
+  const [expanded, setExpanded] = React.useState(false);
+  const [archivePath, setArchivePath] = React.useState("");
+  const [passphrase, setPassphrase] = React.useState("");
+  const [latestResult, setLatestResult] = React.useState<ApiResult | null>(null);
+  const portabilityQ = useQuery({ queryKey: ["portability"], queryFn: latticeApi.graphPortability });
+  const backupHealthQ = useQuery({ queryKey: ["backupHealth"], queryFn: latticeApi.backupHealth });
+  const rememberResult = React.useCallback((result: ApiResult) => setLatestResult(result), []);
+
+  const exportGraph = useCareMutation(() => latticeApi.graphExport(), undefined, rememberResult);
+  const backupGraph = useCareMutation(() => latticeApi.graphBackup(), () => {
+    void qc.invalidateQueries({ queryKey: ["backupHealth"] });
+    void qc.invalidateQueries({ queryKey: ["portability"] });
+  }, rememberResult);
+  const archiveBrain = useCareMutation(
+    () => latticeApi.brainArchive({ path: archivePath.trim() || null, passphrase }),
+    () => void qc.invalidateQueries({ queryKey: ["backupHealth"] }),
+    rememberResult,
+  );
+  const inspectArchive = useCareMutation(() => latticeApi.brainArchiveInspect({
+    path: archivePath.trim(),
+    passphrase: passphrase || null,
+  }), undefined, rememberResult);
+  const restorePreview = useCareMutation(() => latticeApi.brainArchiveRestore({
+    path: archivePath.trim(),
+    passphrase,
+    dry_run: true,
+    confirm: false,
+  }), undefined, rememberResult);
+
+  const portableFormat = portabilityLabel(portabilityQ.data?.data);
+  const backupStatus = backupHealthLabel(backupHealthQ.data?.data);
+
+  return (
+    <section className={`brain-care-panel ${expanded ? "is-expanded" : "is-collapsed"}`} aria-label="Care for my Brain">
+      <button
+        className="brain-care-summary"
+        type="button"
+        aria-expanded={expanded}
+        aria-controls="brain-care-details"
+        onClick={() => setExpanded((value) => !value)}
+      >
+        <span className="brain-care-summary-main">
+          <span><ShieldCheck className="h-3.5 w-3.5" /> Care for my Brain</span>
+          <strong>Own it locally. Keep it portable.</strong>
+        </span>
+        <div className="brain-care-proof" aria-label="Ownership model">
+          <span>Private</span>
+          <span>{portableFormat}</span>
+          <span>{backupStatus}</span>
+        </div>
+        <ChevronDown className="brain-care-toggle h-4 w-4" aria-hidden="true" />
+      </button>
+
+      {expanded ? (
+        <div id="brain-care-details" className="brain-care-details">
+          <div className="brain-care-actions">
+            <CareButton
+              icon={<Download className="h-3.5 w-3.5" />}
+              label="Export"
+              detail="Take it with you"
+              pending={exportGraph.isPending}
+              onClick={() => exportGraph.mutate()}
+            />
+            <CareButton
+              icon={<DatabaseBackup className="h-3.5 w-3.5" />}
+              label="Backup"
+              detail="Save a copy"
+              pending={backupGraph.isPending}
+              onClick={() => backupGraph.mutate()}
+            />
+            <CareButton
+              icon={<Archive className="h-3.5 w-3.5" />}
+              label="Archive"
+              detail="Encrypted Brain"
+              pending={archiveBrain.isPending}
+              disabled={!passphrase.trim()}
+              onClick={() => archiveBrain.mutate()}
+            />
+          </div>
+
+          <div className="brain-care-archive">
+            <input
+              value={archivePath}
+              onChange={(event) => setArchivePath(event.target.value)}
+              placeholder="Paste an archive path to inspect or preview"
+              aria-label="Brain archive path"
+            />
+            <input
+              type="password"
+              value={passphrase}
+              onChange={(event) => setPassphrase(event.target.value)}
+              placeholder="Archive passphrase"
+              aria-label="Brain archive passphrase"
+            />
+            <div className="brain-care-archive-actions">
+              <Button
+                variant="outline"
+                size="sm"
+                disabled={!archivePath.trim() || inspectArchive.isPending}
+                onClick={() => inspectArchive.mutate()}
+              >
+                <Eye className="h-3.5 w-3.5" /> Inspect
+              </Button>
+              <Button
+                variant="outline"
+                size="sm"
+                disabled={!archivePath.trim() || !passphrase.trim() || restorePreview.isPending}
+                onClick={() => restorePreview.mutate()}
+              >
+                <RotateCcw className="h-3.5 w-3.5" /> Restore preview
+              </Button>
+            </div>
+          </div>
+
+          {latestResult ? (
+            <div className={`brain-care-result ${latestResult.ok ? "is-ok" : "is-error"}`} role="status">
+              {summarizeCareResult(latestResult)}
+            </div>
+          ) : (
+            <p className="brain-care-note">
+              Restore preview checks an archive without changing your Brain. Confirmed restore stays in Settings.
+            </p>
+          )}
+        </div>
+      ) : null}
+    </section>
+  );
+}
+
+function useCareMutation<T extends ApiResult>(
+  mutationFn: () => Promise<T>,
+  onSuccess?: () => void,
+  onResult?: (result: T) => void,
+) {
+  return useMutation({
+    mutationFn,
+    onSuccess: (result) => {
+      onResult?.(result);
+      onSuccess?.();
+    },
+  });
+}
+
+function CareButton({
+  icon,
+  label,
+  detail,
+  pending,
+  disabled,
+  onClick,
+}: {
+  icon: React.ReactNode;
+  label: string;
+  detail: string;
+  pending?: boolean;
+  disabled?: boolean;
+  onClick: () => void;
+}) {
+  return (
+    <button className="brain-care-button" type="button" disabled={disabled || pending} onClick={onClick}>
+      {icon}
+      <span>
+        <strong>{pending ? "Working" : label}</strong>
+        <small>{detail}</small>
+      </span>
+    </button>
+  );
+}
+
 function DepthEmergence({
   depth,
   memories,
@@ -633,6 +1012,70 @@ function currentModelName(data: unknown) {
   return firstLoaded ? textValue(firstLoaded, ["name", "id", "model_id"], "local mind") : "local mind";
 }
 
+function portabilityLabel(data: unknown) {
+  const record = isRecord(data) ? data : {};
+  return textValue(record, ["archive_format", "format", "graph_schema_version", "schema_version"], ".latticebrain");
+}
+
+function backupHealthLabel(data: unknown) {
+  const record = isRecord(data) ? data : {};
+  const count = record.count || record.backups || record.available;
+  if (count !== undefined && count !== null && count !== "") return `${count} backups`;
+  return "Backups ready";
+}
+
+function summarizeCareResult(result: ApiResult) {
+  if (!result.ok) return result.error || "Brain care action could not complete.";
+  const data = isRecord(result.data) ? result.data : {};
+  const directMessage = textValue(data, ["message", "status", "path", "archive_path", "backup_path", "export_path"]);
+  if (directMessage) return directMessage;
+  return "Brain care action completed.";
+}
+
+function renderLogRow(event: ApiRecord) {
+  const action = stringValue(event.action || event.event || event.type || event.name, "Event");
+  const actor = stringValue(event.actor || event.user || event.user_id || event.workspace_id, "system");
+  const when = stringValue(event.timestamp || event.time || event.created_at || event.ts, "recently");
+  return (
+    <>
+      <strong>{action}</strong>
+      <span>{actor} · {when}</span>
+    </>
+  );
+}
+
+function sourceLabel(result?: ApiResult<unknown>) {
+  if (!result) return "Loading";
+  return result.ok ? "Live" : result.error || "Unavailable";
+}
+
+function adminStatusLabel(data: unknown, key: string) {
+  const record = isRecord(data) ? data : {};
+  return textValue(record, [key, "health", "state", "overall_status"]);
+}
+
+function indexDetail(data: unknown) {
+  const record = isRecord(data) ? data : {};
+  const docs = record.documents ?? record.document_count ?? record.docs;
+  const chunks = record.chunks ?? record.chunk_count ?? record.vectors;
+  if (docs !== undefined || chunks !== undefined) {
+    return `${stringValue(docs, "0")} docs · ${stringValue(chunks, "0")} chunks`;
+  }
+  return textValue(record, ["message", "detail", "status"], "Index status ready");
+}
+
+function summaryText(data: unknown) {
+  const record = isRecord(data) ? data : {};
+  return textValue(record, ["summary", "message", "status", "detail"]);
+}
+
+function stringValue(value: unknown, fallback = "") {
+  if (typeof value === "string" && value.trim()) return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return fallback;
+}
+
 function fileToDataUrl(file: File) {
   return new Promise<string>((resolve, reject) => {
     const reader = new FileReader();

package/frontend/src/api/client.ts

@@ -417,12 +417,14 @@ export const latticeApi = {
   computerMemory: () => get("/workspace/computer-memory", {}),
   setComputerMemory: (enabled: boolean) => post("/workspace/computer-memory", { enabled, consent: { approved: enabled } }, {}),
   adminSummary: () => get("/admin/summary", {}),
+  adminStats: () => get("/admin/stats", {}),
   adminUsers: () => get("/admin/users", []),
   adminAudit: () => get("/admin/audit", { recent_events: [] }),
   adminRoles: () => get("/admin/roles", { roles: [] }),
   adminPolicies: () => get("/admin/policies", { policies: [] }),
   adminProductHardening: () => get("/admin/product-hardening", {}),
   adminSecurity: () => get("/admin/security/overview", {}),
+  adminSecurityEvents: (limit = 50) => get("/admin/security/events", { events: [] }, { limit }),
   vpcStatus: () => get("/vpc/status", {}),
   toolPermissions: () => get("/tools/permissions", { permissions: [] }),
 };

package/frontend/src/components/ProductFlow.tsx

@@ -178,7 +178,11 @@ function LoginScreen({ onSuccess }: { onSuccess: () => void }) {
   return (
     <div>
       <div className="ritual-title">Welcome to your mind.</div>
-      <div className="ritual-subtitle">This is private. Everything stays on your machine. Begin by opening a local profile for your Brain.</div>
+      <div className="ritual-subtitle">
+        Models will change. Your knowledge should not. Lattice keeps your documents, conversations, decisions, and context together as a private Brain you own.
+      </div>
+
+      <ProductPromise />
 
       <form onSubmit={submit} className="ritual-card" style={{ maxWidth: 420, margin: "0 auto" }}>
         <div style={{ display: "grid", gap: "0.85rem" }}>
@@ -202,13 +206,32 @@ function LoginScreen({ onSuccess }: { onSuccess: () => void }) {
           {busy ? "Opening the Brain..." : "Open my Brain"} 
         </Button>
         <div style={{ fontSize: "0.75rem", color: "hsl(var(--fg-muted))", marginTop: "0.6rem" }}>
-          Your first conversation will feel like coming home.
+          Local profile first. Model choice comes later.
         </div>
       </form>
     </div>
   );
 }
 
+function ProductPromise() {
+  return (
+    <div className="ritual-promise" aria-label="Lattice AI product promise">
+      <div>
+        <span>Durable knowledge</span>
+        <strong>Your work becomes long-lived context.</strong>
+      </div>
+      <div>
+        <span>Replaceable models</span>
+        <strong>The model is a voice, not the asset.</strong>
+      </div>
+      <div>
+        <span>User ownership</span>
+        <strong>Back up, restore, and move your Brain.</strong>
+      </div>
+    </div>
+  );
+}
+
 function AnalysisScreen({
   analysis,
   error,
@@ -223,7 +246,7 @@ function AnalysisScreen({
     <div>
       <div className="ritual-title">Understanding your home.</div>
       <div className="ritual-subtitle">
-        We are learning what kind of mind this computer can support. Your Brain will live here — quietly, privately, powerfully.
+        Lattice is checking what this computer can support so your Brain can run locally instead of turning your memories into a cloud dependency.
       </div>
 
       <div className="ritual-fact-grid">
@@ -273,7 +296,7 @@ function RecommendationScreen({
     <div>
       <div className="ritual-title">How shall your mind think today?</div>
       <div className="ritual-subtitle">
-        A short, honest list chosen for the computer you are on right now. Pick the one that feels right.
+        The model is the current voice of your Brain. You can replace it later; your knowledge stays.
       </div>
 
       <div style={{ maxWidth: 560, margin: "0 auto" }}>
@@ -365,7 +388,7 @@ function InstallScreen({
       <div className="ritual-title">Bring this mind home.</div>
       <div className="ritual-subtitle">
         <strong>{model.shortName}</strong> — {model.reason}.<br />
-        We will download (if needed), validate, and load it. Nothing happens without your explicit consent.
+        This gives your Brain a local voice. Download, validation, and loading happen only with your consent.
       </div>
 
       {/* Living Brain reacts to the ceremony of installation */}