ltcai 6.0.0 → 6.2.0

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

@@ -0,0 +1,98 @@
+import { asArray } from "@/lib/utils";
+import type { ApiRecord, KnowledgeConcept, KnowledgeGraphModel, MemoryFragment, RelationshipThread } from "./types";
+import { clamp } from "./graphLayout";
+
+export function buildMemoryFragments(memoryData: unknown, historyData: unknown): MemoryFragment[] {
+  const memory = isRecord(memoryData) ? memoryData : {};
+  const sourceRows = asArray<ApiRecord>(memory.sources).length
+    ? asArray<ApiRecord>(memory.sources)
+    : asArray<ApiRecord>(memory.tiers);
+  const sourceFragments = sourceRows.map((item, index) => ({
+    id: textValue(item, ["id", "source", "label"], `memory-${index}`),
+    title: textValue(item, ["title", "label", "source", "path", "name"], "Workspace memory"),
+    kind: titleValue(item, ["type", "source_type", "kind", "health"], "Memory"),
+  }));
+  const conversationFragments = asArray<ApiRecord>(historyData).map((item, index) => ({
+    id: textValue(item, ["id", "conversation_id"], `conversation-${index}`),
+    title: textValue(item, ["title", "summary", "id"], "Conversation"),
+    kind: "Conversation",
+  }));
+
+  return uniqueById([...sourceFragments, ...conversationFragments]).slice(0, 10);
+}
+
+export function parseKnowledgeGraph(data: unknown): KnowledgeGraphModel {
+  const graph = isRecord(data) ? data : {};
+  const rawNodes = asArray<ApiRecord>(graph.nodes);
+  const rawEdges = asArray<ApiRecord>(graph.edges);
+  const nodes = rawNodes.flatMap((node): KnowledgeConcept[] => {
+    const id = textValue(node, ["id", "node_id", "title", "label"]);
+    if (!id) return [];
+    const metadata = isRecord(node.metadata) ? node.metadata : {};
+    const type = titleValue(node, ["type", "kind", "category"], "Concept");
+    const label = textValue(node, ["title", "label", "name"], id.replace(/^[^:]+:/, ""));
+    const summary = textValue(node, ["summary", "description", "snippet"]) || textValue(metadata, ["summary", "description", "relative_path", "filename"]);
+    const importance = clamp(numberValue(node, ["importance_norm", "importance", "score"]) || 0.5, 0.08, 1);
+    return [{ id, label, type, summary, importance }];
+  }).sort((left, right) => right.importance - left.importance);
+  const ids = new Set(nodes.map((node) => node.id));
+  const edges = rawEdges.flatMap((edge, index): RelationshipThread[] => {
+    const source = textValue(edge, ["from", "source", "source_id"]);
+    const target = textValue(edge, ["to", "target", "target_id"]);
+    if (!source || !target || !ids.has(source) || !ids.has(target)) return [];
+    return [{
+      id: textValue(edge, ["id"], `edge-${index}`),
+      source,
+      target,
+      label: titleValue(edge, ["type", "label", "relationship"], "Relates"),
+      weight: numberValue(edge, ["weight", "score", "confidence"]) || 1,
+    }];
+  });
+  return { nodes, edges };
+}
+
+export function currentModelName(data: unknown) {
+  const record = isRecord(data) ? data : {};
+  const current = textValue(record, ["current", "current_model", "local_model"]);
+  if (current) return current;
+  const loaded = asArray<ApiRecord>(record.loaded || record.loaded_models);
+  const firstLoaded = loaded.find((item) => item.id || item.name || item.model_id);
+  return firstLoaded ? textValue(firstLoaded, ["name", "id", "model_id"], "local mind") : "local mind";
+}
+
+function uniqueById<T extends { id: string }>(items: T[]) {
+  const seen = new Set<string>();
+  return items.filter((item) => {
+    if (seen.has(item.id)) return false;
+    seen.add(item.id);
+    return true;
+  });
+}
+
+export function isRecord(value: unknown): value is ApiRecord {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export function textValue(record: ApiRecord, keys: string[], fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value;
+    if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  }
+  return fallback;
+}
+
+function titleValue(record: ApiRecord, keys: string[], fallback = "") {
+  const value = textValue(record, keys, fallback);
+  return value
+    .replace(/[_-]+/g, " ")
+    .replace(/\b\w/g, (character) => character.toUpperCase());
+}
+
+function numberValue(record: ApiRecord, keys: string[]) {
+  for (const key of keys) {
+    const value = Number(record[key]);
+    if (Number.isFinite(value)) return value;
+  }
+  return 0;
+}

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

@@ -0,0 +1,26 @@
+import * as React from "react";
+import type { KnowledgeConcept } from "./types";
+
+export function layoutGraphNodes(nodes: KnowledgeConcept[], radiusX: number, radiusY: number) {
+  return nodes.map((node, index) => {
+    const point = polarPoint(index, nodes.length, radiusX, radiusY, -88);
+    return { node, x: point.x, y: point.y };
+  });
+}
+
+export function polarPoint(index: number, total: number, radiusX: number, radiusY: number, offsetDegrees = -90) {
+  const count = Math.max(total, 1);
+  const angle = ((360 / count) * index + offsetDegrees) * Math.PI / 180;
+  return {
+    x: 50 + Math.cos(angle) * radiusX,
+    y: 50 + Math.sin(angle) * radiusY,
+  };
+}
+
+export function layerStyle(values: Record<string, string>) {
+  return values as React.CSSProperties;
+}
+
+export function clamp(value: number, min: number, max: number) {
+  return Math.max(min, Math.min(max, value));
+}

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

@@ -0,0 +1,44 @@
+import type { BrainState } from "@/components/LivingBrain";
+
+export type ApiRecord = Record<string, unknown>;
+export type BrainDepth = 1 | 2 | 3 | 4 | 5;
+
+export type Message = {
+  role: "user" | "assistant";
+  content: string;
+};
+
+export type MemoryFragment = {
+  id: string;
+  title: string;
+  kind: string;
+};
+
+export type KnowledgeConcept = {
+  id: string;
+  label: string;
+  type: string;
+  summary: string;
+  importance: number;
+};
+
+export type RelationshipThread = {
+  id: string;
+  source: string;
+  target: string;
+  label: string;
+  weight: number;
+};
+
+export type KnowledgeGraphModel = {
+  nodes: KnowledgeConcept[];
+  edges: RelationshipThread[];
+};
+
+export const DEPTHS: Array<{ level: BrainDepth; label: string; state: BrainState }> = [
+  { level: 1, label: "Living Brain", state: "idle" },
+  { level: 2, label: "Memory Layer", state: "recalling" },
+  { level: 3, label: "Knowledge Layer", state: "synthesizing" },
+  { level: 4, label: "Relationship Layer", state: "planning" },
+  { level: 5, label: "Knowledge Graph", state: "synthesizing" },
+];

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

@@ -71,16 +71,21 @@ export function ReviewCard({ item, feedback, onAction }: ReviewCardProps) {
       ) : null}
 
       {actionable ? (
-        <div className="mt-4 flex flex-wrap gap-2">
-          <ActionButton
-            label="Run now"
-            successLabel={hadRun ? "Regenerated" : "Executed"}
-            action={() => onAction(item, "run_now", hadRun)}
-            invalidate={[]}
-          />
-          <ActionButton label="Approve" action={() => onAction(item, "approve")} invalidate={[]} />
-          {!snoozed ? <ActionButton label="Snooze 1 day" action={() => onAction(item, "snooze")} invalidate={[]} /> : null}
-          <ActionButton label="Dismiss" action={() => onAction(item, "dismiss")} invalidate={[]} variant="destructive" />
+        <div className="mt-4 grid gap-2">
+          <p className="text-xs leading-5 text-muted-foreground">
+            Run now previews the action without approving it. Approve or dismiss when the result looks right.
+          </p>
+          <div className="flex flex-wrap gap-2" aria-label="Review actions">
+            <ActionButton
+              label="Run now"
+              successLabel={hadRun ? "Regenerated" : "Executed"}
+              action={() => onAction(item, "run_now", hadRun)}
+              invalidate={[]}
+            />
+            <ActionButton label="Approve" action={() => onAction(item, "approve")} invalidate={[]} />
+            {!snoozed ? <ActionButton label="Snooze 1 day" action={() => onAction(item, "snooze")} invalidate={[]} /> : null}
+            <ActionButton label="Dismiss" action={() => onAction(item, "dismiss")} invalidate={[]} variant="destructive" />
+          </div>
         </div>
       ) : null}
       {feedback ? (

package/frontend/src/i18n.ts

@@ -31,6 +31,10 @@ export const COPY: Record<Language, TextMap> = {
     "brain.empty.kicker": "내 오래가는 기억",
     "brain.empty.title": "잊으면 안 되는 맥락부터 말해 주세요.",
     "brain.empty.body": "문서, 대화, 프로젝트, 결정이 이 컴퓨터의 Brain에 쌓이고 나중에 주제와 관계로 다시 보입니다.",
+    "brain.empty.trail.label": "첫 Brain 흐름",
+    "brain.empty.trail.save": "1. 첫 기억 저장",
+    "brain.empty.trail.recall": "2. Brain Home에서 확인",
+    "brain.empty.trail.backup": "3. 백업으로 소유",
     "brain.prompt.remember": "이 프로젝트 목표를 기억해줘: ",
     "brain.prompt.know": "이 문서를 내 Brain에 넣고 요약해줘: ",
     "brain.prompt.plan": "지난 결정들을 나중에 찾을 수 있게 정리해줘: ",
@@ -75,6 +79,96 @@ export const COPY: Record<Language, TextMap> = {
     "admin.kicker": "분리된 관리자 작업공간",
     "admin.title": "Admin Console",
     "admin.body": "사용자, 로그, 보안, Brain 상태는 일반 사용자 화면과 분리됩니다.",
+    "admin.overview": "관리 개요",
+    "admin.metric.users": "사용자",
+    "admin.metric.logs": "최근 로그",
+    "admin.metric.security": "보안",
+    "admin.metric.index": "Brain 인덱스",
+    "admin.status.ready": "준비됨",
+    "admin.status.unavailable": "사용 불가",
+    "admin.status.indexed": "인덱싱됨",
+    "admin.status.unknown": "알 수 없음",
+    "admin.panel.users": "사용자 디렉터리",
+    "admin.panel.people": "사람",
+    "admin.panel.roles": "역할 권한",
+    "admin.panel.access": "접근",
+    "admin.panel.logs": "활동 로그",
+    "admin.panel.audit": "감사",
+    "admin.panel.securityEvents": "보안 이벤트",
+    "admin.panel.protection": "보호",
+    "admin.panel.brainOps": "Brain 운영",
+    "admin.panel.maintenance": "유지보수",
+    "admin.empty.users": "관리 API가 보고한 사용자가 없습니다.",
+    "admin.empty.roles": "보고된 역할 매트릭스가 없습니다.",
+    "admin.empty.audit": "최근 감사 이벤트가 없습니다.",
+    "admin.empty.security": "보고된 보안 이벤트가 없습니다.",
+    "admin.fallback.localUser": "로컬 사용자",
+    "admin.fallback.member": "멤버",
+    "admin.fallback.role": "역할",
+    "admin.fallback.noCaps": "권한 없음",
+    "admin.filters.label": "감사 로그 필터",
+    "admin.filters.search": "로그 검색",
+    "admin.filters.searchAria": "감사 로그 검색",
+    "admin.filters.severityAria": "심각도별 필터",
+    "admin.filters.all": "모든 심각도",
+    "admin.filters.informational": "정보",
+    "admin.filters.notice": "알림",
+    "admin.filters.warning": "경고",
+    "admin.filters.high": "높음",
+    "admin.filters.matched": "{count}개 일치",
+    "admin.brain.summaryFallback": "로컬 Brain 서비스는 사용자 대화와 분리되어 있습니다.",
+    "admin.brain.rebuilding": "재구성 중",
+    "admin.brain.rebuild": "인덱스 재구성",
+    "admin.policy.fallback": "정책",
+    "admin.policy.quiet": "정책 API 대기 중",
+    "admin.retention.days": "{days}일 보관",
+    "admin.retention.detail": "{events}개 보관 · {candidates}개 내보내기/정리 검토 가능",
+    "admin.log.event": "이벤트",
+    "admin.log.system": "시스템",
+    "admin.log.recently": "최근",
+    "admin.source.loading": "불러오는 중",
+    "admin.source.live": "라이브",
+    "admin.index.ready": "인덱스 상태 준비됨",
+    "flow.analysis.fact.computer": "컴퓨터",
+    "flow.analysis.fact.memory": "메모리",
+    "flow.analysis.fact.graphics": "그래픽",
+    "flow.analysis.fact.support": "로컬 지원",
+    "flow.analysis.fact.models": "모델",
+    "flow.analysis.checking": "확인 중",
+    "flow.analysis.fact.computerDetail": "운영체제와 칩",
+    "flow.analysis.fact.memoryDetail": "로컬 사고를 위한 여유 공간",
+    "flow.analysis.fact.graphicsDetail": "로컬 가속 지원",
+    "flow.analysis.fact.supportDetail": "설치된 모델 도우미",
+    "flow.analysis.fact.modelsDetail": "설치된 로컬 Brain",
+    "flow.analysis.apple": "Apple Silicon Mac",
+    "flow.analysis.detected": "감지됨",
+    "flow.analysis.localReady": "로컬 가속 준비됨",
+    "flow.analysis.standardLocal": "표준 로컬 모드",
+    "flow.analysis.supportReady": "준비됨",
+    "flow.analysis.supportInstall": "준비 예정",
+    "flow.analysis.modelsInstalled": "{count}개 이미 설치됨",
+    "flow.analysis.noModels": "아직 설치된 모델 없음",
+    "flow.analysis.readyDetail": "로컬 Digital Brain 사용 준비 완료",
+    "flow.analysis.memoryReadyDetail": "추천 모델에 충분한 컨텍스트",
+    "flow.analysis.graphicsReadyDetail": "Lattice가 가장 좋은 경로를 선택합니다.",
+    "flow.analysis.supportReadyDetail": "설치된 모델 도우미가 감지되었습니다.",
+    "flow.analysis.supportInstallDetail": "Lattice가 필요한 항목을 추가합니다.",
+    "flow.analysis.modelsReadyDetail": "즉시 로드할 수 있는 모델이 있습니다.",
+    "flow.analysis.modelsInstallDetail": "Lattice가 첫 설치를 안내합니다.",
+    "flow.recommend.reason.best": "최적 경험",
+    "flow.recommend.reason.faster": "빠른 선택",
+    "flow.recommend.reason.advanced": "고급 선택",
+    "flow.recommend.reason.default": "추천",
+    "flow.recommend.sizeReady": "준비됨",
+    "flow.recommend.fallbackName": "추천 Brain",
+    "flow.install.stage.download": "모델 파일을 받는 중입니다.",
+    "flow.install.stage.validate": "Brain이 응답할 수 있는지 확인 중입니다.",
+    "flow.install.stage.load": "Brain을 불러오는 중입니다.",
+    "flow.install.stage.error": "확인이 필요한 일이 있습니다.",
+    "flow.install.step.install": "준비",
+    "flow.install.step.download": "다운로드",
+    "flow.install.step.validate": "확인",
+    "flow.install.step.load": "로드",
     "flow.shell": "내 로컬 AI 브레인 만들기",
     "flow.login.title": "내 AI 브레인의 주인을 정합니다.",
     "flow.login.body": "Lattice AI는 내 지식과 맥락을 이 컴퓨터에 보관하는 로컬 우선 AI 브레인입니다. 모델은 바꿀 수 있고, 외부 전송은 사용자가 선택할 때만 시작됩니다.",
@@ -107,6 +201,7 @@ export const COPY: Record<Language, TextMap> = {
     "flow.recommend.primary": "추천대로 시작하기",
     "flow.recommend.unsupported": "이 컴퓨터에서 추가 확인이 필요합니다",
     "flow.recommend.back": "뒤로",
+    "flow.recommend.skip": "모델 없이 Brain 열기",
     "flow.recommend.hint": "잘 모르겠다면 추천대로 시작하면 됩니다.",
     "flow.install.title": "모델을 설치하고 시작합니다.",
     "flow.install.body": "이 모델이 Brain의 로컬 목소리가 됩니다. 인터넷은 다운로드할 때만 필요하고, 실행과 기억은 이 컴퓨터에서 유지됩니다.",
@@ -119,7 +214,16 @@ export const COPY: Record<Language, TextMap> = {
     "flow.install.start": "다운로드하고 시작하기",
     "flow.install.busy": "모델 준비 중...",
     "flow.install.enter": "Brain으로 들어가기",
+    "flow.install.later": "나중에 하기",
     "flow.install.local": "모델 다운로드와 외부 통신은 사용자가 시작할 때만 진행됩니다.",
+    "flow.consent.title": "다운로드 전 확인",
+    "flow.consent.body": "시작하면 아래 모델 파일을 외부 저장소에서 받아 이 컴퓨터에 저장합니다.",
+    "flow.consent.ready": "이미 준비된 모델이거나, 선택하기 전에는 외부 접속을 시작하지 않습니다.",
+    "flow.consent.size": "다운로드 크기",
+    "flow.consent.sizeUnknown": "런타임 확인 후 표시",
+    "flow.consent.location": "저장 위치",
+    "flow.consent.external": "외부 접속 대상",
+    "flow.consent.externalNone": "선택 전 외부 접속 없음",
   },
   en: {
     "language.label": "Language",
@@ -144,6 +248,10 @@ export const COPY: Record<Language, TextMap> = {
     "brain.empty.kicker": "Durable memory",
     "brain.empty.title": "Start with context that should not be forgotten.",
     "brain.empty.body": "Documents, conversations, projects, and decisions accumulate in the Brain on this computer, then reappear as topics and relationships.",
+    "brain.empty.trail.label": "First Brain flow",
+    "brain.empty.trail.save": "1. Save first memory",
+    "brain.empty.trail.recall": "2. See it in Brain Home",
+    "brain.empty.trail.backup": "3. Own it with backup",
     "brain.prompt.remember": "Remember this project goal: ",
     "brain.prompt.know": "Put this document into my Brain and summarize it: ",
     "brain.prompt.plan": "Organize past decisions so I can find them later: ",
@@ -188,6 +296,96 @@ export const COPY: Record<Language, TextMap> = {
     "admin.kicker": "Separate admin workspace",
     "admin.title": "Admin Console",
     "admin.body": "Users, logs, security, and Brain health stay out of the normal user experience.",
+    "admin.overview": "Admin overview",
+    "admin.metric.users": "Users",
+    "admin.metric.logs": "Recent logs",
+    "admin.metric.security": "Security",
+    "admin.metric.index": "Brain index",
+    "admin.status.ready": "Ready",
+    "admin.status.unavailable": "Unavailable",
+    "admin.status.indexed": "Indexed",
+    "admin.status.unknown": "Unknown",
+    "admin.panel.users": "User Directory",
+    "admin.panel.people": "People",
+    "admin.panel.roles": "Role Permissions",
+    "admin.panel.access": "Access",
+    "admin.panel.logs": "Activity Logs",
+    "admin.panel.audit": "Audit",
+    "admin.panel.securityEvents": "Security Events",
+    "admin.panel.protection": "Protection",
+    "admin.panel.brainOps": "Brain Operations",
+    "admin.panel.maintenance": "Maintenance",
+    "admin.empty.users": "No users reported by the admin API.",
+    "admin.empty.roles": "No role matrix reported.",
+    "admin.empty.audit": "No recent audit events.",
+    "admin.empty.security": "No security events reported.",
+    "admin.fallback.localUser": "Local user",
+    "admin.fallback.member": "member",
+    "admin.fallback.role": "role",
+    "admin.fallback.noCaps": "No caps",
+    "admin.filters.label": "Audit log filters",
+    "admin.filters.search": "Search logs",
+    "admin.filters.searchAria": "Search audit logs",
+    "admin.filters.severityAria": "Filter by severity",
+    "admin.filters.all": "All severities",
+    "admin.filters.informational": "Informational",
+    "admin.filters.notice": "Notice",
+    "admin.filters.warning": "Warning",
+    "admin.filters.high": "High",
+    "admin.filters.matched": "{count} matched",
+    "admin.brain.summaryFallback": "Local Brain services are separated from user chat.",
+    "admin.brain.rebuilding": "Rebuilding",
+    "admin.brain.rebuild": "Rebuild index",
+    "admin.policy.fallback": "Policy",
+    "admin.policy.quiet": "Policy API quiet",
+    "admin.retention.days": "{days} day retention",
+    "admin.retention.detail": "{events} retained · {candidates} ready for export/prune review",
+    "admin.log.event": "Event",
+    "admin.log.system": "system",
+    "admin.log.recently": "recently",
+    "admin.source.loading": "Loading",
+    "admin.source.live": "Live",
+    "admin.index.ready": "Index status ready",
+    "flow.analysis.fact.computer": "Computer",
+    "flow.analysis.fact.memory": "Memory",
+    "flow.analysis.fact.graphics": "Graphics",
+    "flow.analysis.fact.support": "Local Support",
+    "flow.analysis.fact.models": "Models",
+    "flow.analysis.checking": "Checking",
+    "flow.analysis.fact.computerDetail": "Operating system and chip",
+    "flow.analysis.fact.memoryDetail": "Available room for local thinking",
+    "flow.analysis.fact.graphicsDetail": "Local acceleration support",
+    "flow.analysis.fact.supportDetail": "Installed model helpers",
+    "flow.analysis.fact.modelsDetail": "Installed local Brains",
+    "flow.analysis.apple": "Apple Silicon Mac",
+    "flow.analysis.detected": "Detected",
+    "flow.analysis.localReady": "Local acceleration ready",
+    "flow.analysis.standardLocal": "Standard local mode",
+    "flow.analysis.supportReady": "Ready",
+    "flow.analysis.supportInstall": "Will be prepared",
+    "flow.analysis.modelsInstalled": "{count} already installed",
+    "flow.analysis.noModels": "None installed yet",
+    "flow.analysis.readyDetail": "Ready for local Digital Brain use",
+    "flow.analysis.memoryReadyDetail": "Enough context for the recommended model",
+    "flow.analysis.graphicsReadyDetail": "Lattice will choose the best available path",
+    "flow.analysis.supportReadyDetail": "Installed model helpers detected",
+    "flow.analysis.supportInstallDetail": "Lattice will add what is needed",
+    "flow.analysis.modelsReadyDetail": "One can be loaded immediately",
+    "flow.analysis.modelsInstallDetail": "Lattice will guide the first install",
+    "flow.recommend.reason.best": "Best Experience",
+    "flow.recommend.reason.faster": "Faster",
+    "flow.recommend.reason.advanced": "Advanced",
+    "flow.recommend.reason.default": "Recommended",
+    "flow.recommend.sizeReady": "ready",
+    "flow.recommend.fallbackName": "Recommended Brain",
+    "flow.install.stage.download": "Getting the model files.",
+    "flow.install.stage.validate": "Checking that the Brain can answer.",
+    "flow.install.stage.load": "Loading the Brain.",
+    "flow.install.stage.error": "Something needs attention.",
+    "flow.install.step.install": "Install",
+    "flow.install.step.download": "Download",
+    "flow.install.step.validate": "Validate",
+    "flow.install.step.load": "Load",
     "flow.shell": "Create your local AI Brain",
     "flow.login.title": "Choose the owner of your AI Brain.",
     "flow.login.body": "Lattice AI is a local-first Digital Brain that keeps your knowledge on this computer. Models can change; external transfer starts only when you choose it.",
@@ -220,6 +418,7 @@ export const COPY: Record<Language, TextMap> = {
     "flow.recommend.primary": "Start with recommendation",
     "flow.recommend.unsupported": "This computer needs one more check",
     "flow.recommend.back": "Back",
+    "flow.recommend.skip": "Open Brain without a model",
     "flow.recommend.hint": "If unsure, start with the recommendation.",
     "flow.install.title": "Install the model and start.",
     "flow.install.body": "This model becomes your Brain's local voice. Internet is needed only for download; execution and memory stay on this computer.",
@@ -232,7 +431,16 @@ export const COPY: Record<Language, TextMap> = {
     "flow.install.start": "Download and start",
     "flow.install.busy": "Preparing model...",
     "flow.install.enter": "Enter Brain",
+    "flow.install.later": "Do later",
     "flow.install.local": "Downloads and external communication start only when you choose them.",
+    "flow.consent.title": "Before downloading",
+    "flow.consent.body": "Starting will fetch these model files from an external repository and store them on this computer.",
+    "flow.consent.ready": "This model is already ready, or no external connection starts until you choose it.",
+    "flow.consent.size": "Download size",
+    "flow.consent.sizeUnknown": "Reported by runtime",
+    "flow.consent.location": "Storage location",
+    "flow.consent.external": "External target",
+    "flow.consent.externalNone": "No external connection before selection",
   },
 };