ltcai 7.0.0 → 7.2.0

package/frontend/src/components/FeedbackState.tsx

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

package/frontend/src/components/WorkspaceProfileSwitcher.tsx

@@ -0,0 +1,176 @@
+import * as React from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { Check, ChevronDown, UserCircle, Building2, ArrowRightLeft } from "lucide-react";
+import { latticeApi } from "@/api/client";
+import { t, type Language } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import { asArray } from "@/lib/utils";
+
+type WorkspaceRow = Record<string, unknown>;
+
+function workspaceId(row: WorkspaceRow): string {
+  return String(row.workspace_id || row.id || "");
+}
+
+function workspaceName(language: Language, row: WorkspaceRow): string {
+  const name = row.name;
+  if (typeof name === "string" && name.trim()) return name;
+  const id = workspaceId(row);
+  return id || t(language, "shell.workspace.personal");
+}
+
+function ownerEmail(profile: unknown): string | null {
+  if (!profile || typeof profile !== "object") return null;
+  const record = profile as Record<string, unknown>;
+  const candidate = record.email || record.owner_email || record.username || record.name;
+  return typeof candidate === "string" && candidate.trim() ? candidate : null;
+}
+
+/**
+ * Discoverable workspace + profile switcher for the Brain shell.
+ * Surfaces the active workspace and signed-in owner, and lets the user
+ * switch workspace or jump to account/workspace settings without hunting
+ * through the Settings tabs.
+ */
+export function WorkspaceProfileSwitcher({ language }: { language: Language }) {
+  const qc = useQueryClient();
+  const workspaceIdState = useAppStore((state) => state.workspaceId);
+  const setWorkspaceId = useAppStore((state) => state.setWorkspaceId);
+  const [open, setOpen] = React.useState(false);
+  const containerRef = React.useRef<HTMLDivElement | null>(null);
+
+  const profile = useQuery({ queryKey: ["profile"], queryFn: latticeApi.profile });
+  const registry = useQuery({ queryKey: ["workspaceRegistry"], queryFn: latticeApi.workspaceRegistry });
+
+  const workspaces = asArray<WorkspaceRow>(
+    (registry.data?.data as Record<string, unknown> | undefined)?.workspaces,
+  );
+  const owner = ownerEmail(profile.data?.data);
+
+  const activeWorkspace = workspaces.find((row) => workspaceId(row) === workspaceIdState);
+  const activeLabel = activeWorkspace
+    ? workspaceName(language, activeWorkspace)
+    : workspaceIdState || t(language, "shell.workspace.personal");
+
+  React.useEffect(() => {
+    if (!open) return;
+    const onPointer = (event: MouseEvent) => {
+      if (containerRef.current && !containerRef.current.contains(event.target as Node)) {
+        setOpen(false);
+      }
+    };
+    const onKey = (event: KeyboardEvent) => {
+      if (event.key === "Escape") setOpen(false);
+    };
+    window.addEventListener("mousedown", onPointer);
+    window.addEventListener("keydown", onKey);
+    return () => {
+      window.removeEventListener("mousedown", onPointer);
+      window.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+
+  const handleSwitch = (id: string) => {
+    if (id && id !== workspaceIdState) {
+      setWorkspaceId(id);
+      // Workspace scoping changes server responses; drop cached views.
+      qc.invalidateQueries();
+    }
+    setOpen(false);
+  };
+
+  return (
+    <div className="workspace-profile-switcher" ref={containerRef}>
+      <button
+        type="button"
+        className="workspace-profile-trigger"
+        aria-haspopup="dialog"
+        aria-expanded={open}
+        aria-label={t(language, "shell.workspace.label")}
+        onClick={() => setOpen((value) => !value)}
+      >
+        <Building2 className="h-3.5 w-3.5" aria-hidden="true" />
+        <span className="workspace-profile-trigger-text">
+          <span className="workspace-profile-trigger-name">{activeLabel}</span>
+          <span className="workspace-profile-trigger-owner">{owner || t(language, "shell.profile.signedOut")}</span>
+        </span>
+        <ChevronDown className="h-3.5 w-3.5" aria-hidden="true" />
+      </button>
+
+      {open ? (
+        <div className="workspace-profile-popover" role="dialog" aria-label={t(language, "shell.workspace.label")}>
+          <section className="workspace-profile-section" aria-label={t(language, "shell.profile.label")}>
+            <div className="workspace-profile-section-head">
+              <UserCircle className="h-3.5 w-3.5" aria-hidden="true" />
+              <span>{t(language, "shell.profile.label")}</span>
+            </div>
+            <div className="workspace-profile-owner-row">
+              <span className="workspace-profile-owner-label">{t(language, "shell.profile.owner")}</span>
+              <span className="workspace-profile-owner-value">{owner || t(language, "shell.profile.signedOut")}</span>
+            </div>
+            <button
+              type="button"
+              className="workspace-profile-link"
+              onClick={() => {
+                setOpen(false);
+                window.location.hash = "/account";
+              }}
+            >
+              {t(language, "shell.profile.manage")}
+            </button>
+          </section>
+
+          <section className="workspace-profile-section" aria-label={t(language, "shell.workspace.current")}>
+            <div className="workspace-profile-section-head">
+              <Building2 className="h-3.5 w-3.5" aria-hidden="true" />
+              <span>{t(language, "shell.workspace.current")}</span>
+            </div>
+            {workspaces.length === 0 ? (
+              <p className="workspace-profile-empty">{t(language, "shell.workspace.empty")}</p>
+            ) : (
+              <ul className="workspace-profile-list">
+                {workspaces.map((row) => {
+                  const id = workspaceId(row);
+                  const isActive = id === workspaceIdState;
+                  return (
+                    <li key={id}>
+                      <button
+                        type="button"
+                        className={`workspace-profile-item ${isActive ? "is-active" : ""}`}
+                        aria-current={isActive ? "true" : undefined}
+                        onClick={() => handleSwitch(id)}
+                      >
+                        <span className="workspace-profile-item-name">{workspaceName(language, row)}</span>
+                        {isActive ? (
+                          <span className="workspace-profile-item-flag">
+                            <Check className="h-3 w-3" aria-hidden="true" />
+                            {t(language, "shell.workspace.active")}
+                          </span>
+                        ) : (
+                          <span className="workspace-profile-item-switch">
+                            <ArrowRightLeft className="h-3 w-3" aria-hidden="true" />
+                            {t(language, "shell.workspace.switch")}
+                          </span>
+                        )}
+                      </button>
+                    </li>
+                  );
+                })}
+              </ul>
+            )}
+            <button
+              type="button"
+              className="workspace-profile-link"
+              onClick={() => {
+                setOpen(false);
+                window.location.hash = "/workspace-admin";
+              }}
+            >
+              {t(language, "shell.workspace.manageSpaces")}
+            </button>
+          </section>
+        </div>
+      ) : null}
+    </div>
+  );
+}

package/frontend/src/components/onboarding/AnalysisScreen.tsx

@@ -23,8 +23,11 @@ export function AnalysisScreen({
 
       <div className="ritual-fact-grid">
         {detected.map((item, idx) => (
-          <div key={idx} className="ritual-fact">
-            <div className="ritual-fact-label">{item.label}</div>
+          <div key={idx} className="ritual-fact ritual-fact--visual">
+            <div className="ritual-fact-head">
+              <span className="ritual-hardware-icon" aria-hidden="true">{item.icon}</span>
+              <div className="ritual-fact-label">{item.label}</div>
+            </div>
             <div className="ritual-fact-value">{item.value}</div>
             <div className="ritual-fact-detail">{item.detail}</div>
           </div>
@@ -57,11 +60,11 @@ export function AnalysisScreen({
 function buildDetectedFacts(analysis: FlowAnalysis | null, language: Language) {
   if (!analysis) {
     return [
-      { label: t(language, "flow.analysis.fact.computer"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.computerDetail") },
-      { label: t(language, "flow.analysis.fact.memory"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.memoryDetail") },
-      { label: t(language, "flow.analysis.fact.graphics"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.graphicsDetail") },
-      { label: t(language, "flow.analysis.fact.support"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.supportDetail") },
-      { label: t(language, "flow.analysis.fact.models"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.modelsDetail") },
+      { icon: t(language, "flow.analysis.hardware.icon.chip"), label: t(language, "flow.analysis.hardware.label.chip"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.computerDetail") },
+      { icon: t(language, "flow.analysis.hardware.icon.ram"), label: t(language, "flow.analysis.hardware.label.ram"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.memoryDetail") },
+      { icon: t(language, "flow.analysis.hardware.icon.gpu"), label: t(language, "flow.analysis.hardware.label.gpu"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.graphicsDetail") },
+      { icon: t(language, "flow.analysis.hardware.icon.support"), label: t(language, "flow.analysis.hardware.label.support"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.supportDetail") },
+      { icon: t(language, "flow.analysis.hardware.icon.models"), label: t(language, "flow.analysis.hardware.label.models"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.modelsDetail") },
     ];
   }
   const setupEnv = asRecord(analysis.setup?.environment);
@@ -81,27 +84,32 @@ function buildDetectedFacts(analysis: FlowAnalysis | null, language: Language) {
   ];
   return [
     {
-      label: t(language, "flow.analysis.fact.computer"),
+      icon: t(language, "flow.analysis.hardware.icon.chip"),
+      label: t(language, "flow.analysis.hardware.label.chip"),
       value: appleSilicon ? t(language, "flow.analysis.apple") : friendlyOs(profile.os, language),
       detail: t(language, "flow.analysis.readyDetail"),
     },
     {
-      label: t(language, "flow.analysis.fact.memory"),
+      icon: t(language, "flow.analysis.hardware.icon.ram"),
+      label: t(language, "flow.analysis.hardware.label.ram"),
       value: ramGb ? `${Math.round(ramGb)} GB` : t(language, "flow.analysis.detected"),
       detail: t(language, "flow.analysis.memoryReadyDetail"),
     },
     {
-      label: t(language, "flow.analysis.fact.graphics"),
+      icon: t(language, "flow.analysis.hardware.icon.gpu"),
+      label: t(language, "flow.analysis.hardware.label.gpu"),
       value: gpu.vendor || sysinfo.gpu_mem_gb ? t(language, "flow.analysis.localReady") : t(language, "flow.analysis.standardLocal"),
       detail: t(language, "flow.analysis.graphicsReadyDetail"),
     },
     {
-      label: t(language, "flow.analysis.fact.support"),
+      icon: t(language, "flow.analysis.hardware.icon.support"),
+      label: t(language, "flow.analysis.hardware.label.support"),
       value: installedRuntimes.length ? t(language, "flow.analysis.supportReady") : t(language, "flow.analysis.supportInstall"),
       detail: installedRuntimes.length ? t(language, "flow.analysis.supportReadyDetail") : t(language, "flow.analysis.supportInstallDetail"),
     },
     {
-      label: t(language, "flow.analysis.fact.models"),
+      icon: t(language, "flow.analysis.hardware.icon.models"),
+      label: t(language, "flow.analysis.hardware.label.models"),
       value: loadedModels.length ? t(language, "flow.analysis.modelsInstalled", { count: loadedModels.length }) : t(language, "flow.analysis.noModels"),
       detail: loadedModels.length ? t(language, "flow.analysis.modelsReadyDetail") : t(language, "flow.analysis.modelsInstallDetail"),
     },

package/frontend/src/components/onboarding/InstallScreen.tsx

@@ -81,6 +81,20 @@ export function InstallScreen({
         {t(language, "flow.install.body")}
       </div>
 
+      <section className="ritual-card ritual-expected-card" aria-label={t(language, "flow.install.expectedTitle")}>
+        <div className="ritual-fact-label">{t(language, "flow.install.expectedTitle")}</div>
+        <div className="ritual-time-estimate ritual-expected-line">{expectedLine(model, language)}</div>
+        <ol className="ritual-timeline">
+          {timelineSteps(model, language).map((step) => (
+            <li key={step.key} className="ritual-timeline-step">
+              <span className="ritual-timeline-name">{step.name}</span>
+              <span className="ritual-timeline-time">{step.time}</span>
+            </li>
+          ))}
+        </ol>
+        <div className="ritual-muted-hint">{t(language, "flow.install.expectedCompletion")}</div>
+      </section>
+
       <div className="ritual-install-brain">
         <LivingBrain
           state={brainStateForStage}
@@ -141,6 +155,47 @@ export function InstallScreen({
   );
 }
 
+function expectedLine(model: RecommendedModel, language: Language) {
+  const response = model.estimatedFirstResponseSeconds;
+  if (!model.downloadRequired || model.estimatedDownloadMinutes === 0) {
+    return t(language, "flow.install.expected.ready", { response });
+  }
+  if (model.estimatedDownloadMinutes === null) {
+    return t(language, "flow.install.expected.unknown", { response });
+  }
+  return t(language, "flow.install.expected", {
+    download: t(language, "flow.recommend.minutes", { count: model.estimatedDownloadMinutes }),
+    response,
+  });
+}
+
+function timelineSteps(model: RecommendedModel, language: Language) {
+  const downloadTime = model.downloadRequired && model.estimatedDownloadMinutes
+    ? t(language, "flow.install.timelineApprox", {
+        time: t(language, "flow.recommend.minutes", { count: model.estimatedDownloadMinutes }),
+      })
+    : t(language, "flow.install.timelineQuick");
+  return [
+    {
+      key: "download",
+      name: t(language, "flow.install.timelineStep.download"),
+      time: downloadTime,
+    },
+    {
+      key: "validate",
+      name: t(language, "flow.install.timelineStep.validate"),
+      time: t(language, "flow.install.timelineQuick"),
+    },
+    {
+      key: "load",
+      name: t(language, "flow.install.timelineStep.load"),
+      time: t(language, "flow.install.timelineApprox", {
+        time: `${model.estimatedFirstResponseSeconds}s`,
+      }),
+    },
+  ];
+}
+
 function friendlyInstallStage(stage: string): InstallStage {
   if (/download|pull|weights/i.test(stage)) return "download";
   if (/smoke|validate|verify|test/i.test(stage)) return "validate";

package/frontend/src/components/onboarding/RecommendationScreen.tsx

@@ -23,9 +23,13 @@ export function RecommendationScreen({
 
       <div className="ritual-model-list">
         {items[0]?.supported ? (
-          <Button onClick={() => onSelect(items[0])} className="ritual-primary-model-button">
-            {t(language, "flow.recommend.primary")}
-          </Button>
+          <div className="ritual-primary-cta">
+            <Button onClick={() => onSelect(items[0])} className="ritual-primary-model-button">
+              {t(language, "flow.recommend.primary")}
+            </Button>
+            <div className="ritual-time-estimate ritual-primary-note">{primaryNote(items[0], language)}</div>
+            <div className="ritual-muted-hint ritual-next-hint">{t(language, "flow.recommend.nextHint")}</div>
+          </div>
         ) : null}
         {items.slice(0, 3).map((model, index) => (
           <button
@@ -36,10 +40,23 @@ export function RecommendationScreen({
           >
             <div className="role">{rankLabel(model.role, index, language)}</div>
             <div className="name">{model.shortName}</div>
-            <div className="reason">{model.reason} · {model.size || t(language, "flow.recommend.sizeReady")}</div>
-            {!model.supported && <div className="ritual-model-warning">{t(language, "flow.recommend.unsupported")}</div>}
+            <div className="reason">
+              {model.reason} · {model.size || t(language, "flow.recommend.sizeReady")}
+              {comparisonLabel(model.role, language) ? (
+                <span className="ritual-model-comparison"> {comparisonLabel(model.role, language)}</span>
+              ) : null}
+            </div>
+            <div className="ritual-model-stats">
+              <span className="ritual-time-estimate">{timeEstimate(model, language)}</span>
+            </div>
+            {model.supported ? (
+              <span className="ritual-model-choose">{t(language, "flow.recommend.choose")}</span>
+            ) : (
+              <div className="ritual-model-warning">{t(language, "flow.recommend.unsupported")}</div>
+            )}
           </button>
         ))}
+        <div className="ritual-time-note">{t(language, "flow.recommend.timeNote")}</div>
       </div>
 
       <div className="ritual-action-row">
@@ -51,6 +68,39 @@ export function RecommendationScreen({
   );
 }
 
+function formatMinutes(minutes: number, language: Language) {
+  return t(language, "flow.recommend.minutes", { count: minutes });
+}
+
+function timeEstimate(model: RecommendedModel, language: Language) {
+  const response = model.estimatedFirstResponseSeconds;
+  if (!model.downloadRequired || model.estimatedDownloadMinutes === 0) {
+    return t(language, "flow.recommend.timeEstimate.ready", { response });
+  }
+  if (model.estimatedDownloadMinutes === null) {
+    return t(language, "flow.recommend.timeEstimate.unknown", { response });
+  }
+  return t(language, "flow.recommend.timeEstimate", {
+    download: formatMinutes(model.estimatedDownloadMinutes, language),
+    response,
+  });
+}
+
+function primaryNote(model: RecommendedModel, language: Language) {
+  if (!model.downloadRequired || model.estimatedDownloadMinutes === 0 || model.estimatedDownloadMinutes === null) {
+    return t(language, "flow.recommend.primaryNote.unknown");
+  }
+  return t(language, "flow.recommend.primaryNote", {
+    time: formatMinutes(model.estimatedDownloadMinutes, language),
+  });
+}
+
+function comparisonLabel(role: RecommendedModel["role"], language: Language) {
+  if (role === "faster") return t(language, "flow.recommend.comparison.faster");
+  if (role === "advanced") return t(language, "flow.recommend.comparison.advanced");
+  return "";
+}
+
 function rankLabel(role: RecommendedModel["role"], index: number, language: Language) {
   if (role === "best") return t(language, "flow.recommend.rank.best");
   if (role === "faster") return t(language, "flow.recommend.rank.faster");

package/frontend/src/components/onboarding/recommendationModel.ts

@@ -25,6 +25,12 @@ export type RecommendedModel = {
   downloadSize: string;
   storageLocation: string;
   externalHost: string;
+  /** Estimated download time in minutes. 0 when nothing needs downloading; null when size is unknown. */
+  estimatedDownloadMinutes: number | null;
+  /** Estimated seconds to first response after the model is loaded. */
+  estimatedFirstResponseSeconds: number;
+  /** Rough parameter scale (e.g. 8, 12, 70) parsed from the model name; null when unknown. */
+  parameterBillions: number | null;
 };
 
 export function buildRecommendations(analysis: FlowAnalysis | null): RecommendedModel[] {
@@ -75,6 +81,9 @@ export function fallbackModel(): RecommendedModel {
     downloadSize: "",
     storageLocation: "~/.latticeai/models",
     externalHost: "",
+    estimatedDownloadMinutes: 0,
+    estimatedFirstResponseSeconds: 5,
+    parameterBillions: 8,
   };
 }
 
@@ -87,6 +96,9 @@ function toRecommendedModel(row: ApiData): RecommendedModel {
     && row.load_status !== "runtime_update_needed"
     && row.status !== "not_recommended"
     && compatibility.supported !== false;
+  const downloadRequired = Boolean(row.download_required);
+  const downloadSize = String(row.download_size || row.size || "");
+  const parameterBillions = parseParameterBillions(`${name} ${id}`);
   return {
     id,
     loadId,
@@ -98,13 +110,58 @@ function toRecommendedModel(row: ApiData): RecommendedModel {
     role: "best",
     reason: String(row.reason || ""),
     supported,
-    downloadRequired: Boolean(row.download_required),
-    downloadSize: String(row.download_size || row.size || ""),
+    downloadRequired,
+    downloadSize,
     storageLocation: String(row.storage_location || row.local_path || "~/.latticeai/models"),
     externalHost: externalHostLabel(row),
+    estimatedDownloadMinutes: downloadRequired ? estimateDownloadMinutes(downloadSize) : 0,
+    estimatedFirstResponseSeconds: estimateFirstResponseSeconds(parameterBillions),
+    parameterBillions,
   };
 }
 
+/** Parse a download size string like "8GB", "8.5 GB", "512MB" into megabytes; null when unparseable. */
+export function parseDownloadMegabytes(value: string): number | null {
+  const match = String(value || "").match(/([\d.]+)\s*(t|g|m)?b?/i);
+  if (!match) return null;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) return null;
+  const unit = (match[2] || "g").toLowerCase();
+  if (unit === "t") return amount * 1024 * 1024;
+  if (unit === "m") return amount;
+  return amount * 1024; // gigabytes (default assumption for model weights)
+}
+
+/**
+ * Estimate download minutes from a size string, assuming a conservative ~15 Mbps
+ * (≈1.875 MB/s) average home connection. Returns null when the size is unknown so
+ * the UI can fall back to a "time unknown" message instead of showing 0.
+ */
+export function estimateDownloadMinutes(downloadSize: string): number | null {
+  const megabytes = parseDownloadMegabytes(downloadSize);
+  if (megabytes === null) return null;
+  const megabytesPerSecond = 15 / 8; // 15 Mbps
+  const minutes = megabytes / megabytesPerSecond / 60;
+  return Math.max(1, Math.round(minutes));
+}
+
+/** Pull a rough parameter scale (billions) out of a model name like "Gemma 12B" or "qwen-8b". */
+export function parseParameterBillions(text: string): number | null {
+  const match = String(text || "").match(/(\d{1,3}(?:\.\d)?)\s*b\b/i);
+  if (!match) return null;
+  const value = Number(match[1]);
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+
+/** Estimate seconds to first response from model scale: 8B→5s, 12B→10s, 70B→30s. */
+export function estimateFirstResponseSeconds(parameterBillions: number | null): number {
+  if (parameterBillions === null) return 8;
+  if (parameterBillions <= 9) return 5;
+  if (parameterBillions <= 16) return 10;
+  if (parameterBillions <= 40) return 18;
+  return 30;
+}
+
 function externalHostLabel(row: ApiData) {
   const raw = String(row.source_url || row.download_url || row.repository || row.provider || row.id || "");
   if (!raw) return "";

package/frontend/src/features/admin/AdminConsole.tsx

@@ -15,7 +15,7 @@ export function AdminConsole({ onBack }: { onBack: () => void }) {
   const qc = useQueryClient();
   const language = useAppStore((state) => state.language);
   const [filters, setFilters] = React.useState<AdminFilterState>({ q: "", actor: "", action: "", severity: "", limit: 50 });
-  const { summaryQ, statsQ, usersQ, auditQ, securityQ, securityEventsQ, policiesQ, rolesQ, retentionQ, indexQ } = useAdminConsoleData(filters);
+  const { summaryQ, statsQ, usersQ, auditQ, securityQ, securityEventsQ, policiesQ, rolesQ, retentionQ, indexQ, agentRuntimeQ, toolRegistryQ } = useAdminConsoleData(filters);
   const rebuildIndex = useMutation({
     mutationFn: latticeApi.rebuildIndex,
     onSuccess: () => void qc.invalidateQueries({ queryKey: ["indexStatus"] }),
@@ -139,6 +139,10 @@ export function AdminConsole({ onBack }: { onBack: () => void }) {
           </div>
         </AdminPanel>
 
+        <AdminPanel title={t(language, "admin.panel.runtimeTrust")} eyebrow={t(language, "admin.panel.contracts")}>
+          <RuntimeTrustPanel runtime={agentRuntimeQ.data?.data as ApiRecord | undefined} registry={toolRegistryQ.data?.data as ApiRecord | undefined} language={language} />
+        </AdminPanel>
+
       </section>
     </main>
   );
@@ -164,9 +168,45 @@ function useAdminConsoleData(filters: AdminFilterState) {
     rolesQ: useQuery({ queryKey: ["adminRoles"], queryFn: latticeApi.adminRoles }),
     retentionQ: useQuery({ queryKey: ["adminLogRetention"], queryFn: latticeApi.adminLogRetention }),
     indexQ: useQuery({ queryKey: ["indexStatus"], queryFn: latticeApi.indexStatus }),
+    agentRuntimeQ: useQuery({ queryKey: ["agentRuntime"], queryFn: latticeApi.agentRuntime }),
+    toolRegistryQ: useQuery({ queryKey: ["toolRegistryDiagnostics"], queryFn: latticeApi.toolRegistryDiagnostics }),
   };
 }
 
+function RuntimeTrustPanel({ runtime, registry, language }: { runtime?: ApiRecord; registry?: ApiRecord; language: "ko" | "en" }) {
+  const runtimeInfo = (runtime?.runtime || {}) as ApiRecord;
+  const health = (runtime?.health || {}) as ApiRecord;
+  const diagnostics = (registry?.diagnostics || {}) as ApiRecord;
+  const ready = Boolean(runtimeInfo.ready);
+  const registryReady = Boolean(diagnostics.ready);
+  const blocking = stringValue(runtimeInfo.unavailable_reason, ready ? t(language, "admin.runtime.readyDetail") : t(language, "admin.runtime.blockedFallback"));
+  return (
+    <div className="admin-runtime-trust">
+      <div className="admin-runtime-row">
+        <strong>{t(language, "admin.runtime.agent")}</strong>
+        <span className={ready ? "is-ok" : "is-warn"}>{ready ? t(language, "admin.status.ready") : t(language, "admin.status.unavailable")}</span>
+        <small>{blocking}</small>
+      </div>
+      <div className="admin-runtime-row">
+        <strong>{t(language, "admin.runtime.tools")}</strong>
+        <span className={registryReady ? "is-ok" : "is-warn"}>{registryReady ? t(language, "admin.runtime.aligned") : t(language, "admin.runtime.drift")}</span>
+        <small>
+          {t(language, "admin.runtime.toolCounts", {
+            registered: stringValue(diagnostics.registered_tools, "0"),
+            governed: stringValue(diagnostics.governed_tools, "0"),
+            described: stringValue(diagnostics.described_tools, "0"),
+          })}
+        </small>
+      </div>
+      <div className="admin-policy-strip">
+        <span>{t(language, "admin.runtime.mode", { mode: stringValue(runtimeInfo.mode, "unknown") })}</span>
+        <span>{t(language, "admin.runtime.execution", { mode: stringValue(runtimeInfo.execution_mode, "unknown") })}</span>
+        <span>{t(language, "admin.runtime.health", { status: stringValue(health.status, "unknown") })}</span>
+      </div>
+    </div>
+  );
+}
+
 function AdminLogFilters({
   filters,
   matched,