ltcai 6.1.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/i18n.ts

@@ -79,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 브레인입니다. 모델은 바꿀 수 있고, 외부 전송은 사용자가 선택할 때만 시작됩니다.",
@@ -124,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",
@@ -197,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.",
@@ -242,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",
   },
 };
 

package/frontend/src/styles.css

@@ -2982,6 +2982,58 @@ body {
   box-shadow: 0 0 0 1px hsl(var(--brain-core) / 0.25);
 }
 
+.ritual-form {
+  max-width: 420px;
+  margin: 0 auto;
+}
+
+.ritual-field-stack {
+  display: grid;
+  gap: 0.85rem;
+}
+
+.ritual-field-label {
+  margin-bottom: 0.25rem;
+  color: hsl(var(--fg-muted));
+  font-size: 0.75rem;
+  font-weight: 760;
+  letter-spacing: 0;
+  text-transform: uppercase;
+}
+
+.ritual-error {
+  margin-top: 0.85rem;
+  padding: 0.6rem 0.85rem;
+  border: 1px solid hsl(var(--destructive) / 0.4);
+  border-radius: 8px;
+  background: hsl(var(--destructive) / 0.12);
+  font-size: 0.9rem;
+}
+
+.ritual-full-button,
+.ritual-primary-model-button,
+.ritual-model-card {
+  width: 100%;
+}
+
+.ritual-full-button {
+  margin-top: 1rem;
+}
+
+.ritual-note,
+.ritual-local-note {
+  color: hsl(var(--fg-muted));
+  font-size: 0.75rem;
+}
+
+.ritual-note {
+  margin-top: 0.6rem;
+}
+
+.ritual-local-note {
+  margin-top: 0.9rem;
+}
+
 .ritual-fact-grid {
   display: grid;
   grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
@@ -3011,6 +3063,59 @@ body {
   color: hsl(var(--fg));
 }
 
+.ritual-fact-detail,
+.ritual-muted-text,
+.ritual-muted-hint,
+.ritual-status-card {
+  color: hsl(var(--fg-muted));
+}
+
+.ritual-fact-detail {
+  margin-top: 0.2rem;
+  font-size: 0.8rem;
+}
+
+.ritual-analysis-card,
+.ritual-centered-actions {
+  margin-top: 1rem;
+}
+
+.ritual-centered-actions {
+  display: flex;
+  justify-content: center;
+}
+
+.ritual-inline-row {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+}
+
+.ritual-core-icon {
+  color: hsl(var(--brain-core));
+}
+
+.ritual-strong-text {
+  font-weight: 620;
+}
+
+.ritual-muted-text {
+  font-size: 0.9rem;
+}
+
+.ritual-wide-button {
+  min-width: 260px;
+}
+
+.ritual-model-list {
+  max-width: 560px;
+  margin: 0 auto;
+}
+
+.ritual-primary-model-button {
+  margin-bottom: 0.85rem;
+}
+
 .ritual-model-card {
   text-align: left;
   padding: 1.15rem 1.35rem;
@@ -3046,6 +3151,80 @@ body {
   margin-top: 0.25rem;
 }
 
+.ritual-model-warning {
+  margin-top: 0.35rem;
+  color: hsl(var(--destructive));
+  font-size: 0.85rem;
+}
+
+.ritual-action-row,
+.ritual-button-row {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.75rem;
+  flex-wrap: wrap;
+}
+
+.ritual-action-row {
+  margin-top: 1.1rem;
+}
+
+.ritual-muted-hint {
+  font-size: 0.82rem;
+}
+
+.ritual-install-brain {
+  margin: 0.6rem auto 1rem;
+}
+
+.ritual-consent-panel {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(220px, 0.9fr);
+  gap: 1rem;
+  max-width: 620px;
+  margin: 0 auto 1rem;
+  padding: 1rem;
+  border: 1px solid hsl(var(--border) / 0.6);
+  border-radius: 8px;
+  background: hsl(var(--bg) / 0.48);
+  text-align: left;
+}
+
+.ritual-consent-panel strong {
+  display: block;
+  margin-bottom: 0.25rem;
+}
+
+.ritual-consent-panel p {
+  margin: 0;
+  color: hsl(var(--fg-muted));
+  font-size: 0.9rem;
+}
+
+.ritual-consent-panel dl {
+  display: grid;
+  gap: 0.45rem;
+  margin: 0;
+}
+
+.ritual-consent-panel dl div {
+  display: grid;
+  grid-template-columns: 110px minmax(0, 1fr);
+  gap: 0.5rem;
+}
+
+.ritual-consent-panel dt {
+  color: hsl(var(--fg-muted));
+  font-size: 0.78rem;
+}
+
+.ritual-consent-panel dd {
+  margin: 0;
+  overflow-wrap: anywhere;
+  font-size: 0.86rem;
+}
+
 .ritual-progress {
   margin: 1.5rem 0;
 }
@@ -3077,6 +3256,11 @@ body {
   color: hsl(var(--fg));
 }
 
+.ritual-stage-icon {
+  width: 15px;
+  height: 15px;
+}
+
 .ritual-bar {
   height: 6px;
   background: hsl(var(--border) / 0.6);
@@ -3092,12 +3276,48 @@ body {
   transition: width 280ms ease;
 }
 
+.ritual-bar-fill.progress-0 { width: 4%; }
+.ritual-bar-fill.progress-10 { width: 10%; }
+.ritual-bar-fill.progress-20 { width: 20%; }
+.ritual-bar-fill.progress-30 { width: 30%; }
+.ritual-bar-fill.progress-40 { width: 40%; }
+.ritual-bar-fill.progress-50 { width: 50%; }
+.ritual-bar-fill.progress-60 { width: 60%; }
+.ritual-bar-fill.progress-70 { width: 70%; }
+.ritual-bar-fill.progress-80 { width: 80%; }
+.ritual-bar-fill.progress-90 { width: 90%; }
+.ritual-bar-fill.progress-100 { width: 100%; }
+
 .ritual-status {
   font-size: 0.95rem;
   color: hsl(var(--fg-muted));
   margin: 0.8rem 0;
 }
 
+.ritual-status-card {
+  max-width: 540px;
+  margin: 0.8rem auto 0;
+  font-size: 0.86rem;
+}
+
+.ritual-error-card {
+  border-color: hsl(var(--destructive) / 0.45);
+  background: hsl(var(--destructive) / 0.07);
+}
+
+.ritual-install-error {
+  margin-bottom: 1rem;
+}
+
+.ritual-error-detail {
+  margin-top: 0.5rem;
+  font-size: 0.85rem;
+}
+
+.ritual-button-row {
+  margin-top: 1rem;
+}
+
 .ritual-success {
   text-align: center;
   padding: 1.5rem;

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "6.1.0"
+__version__ = "6.2.0"
 
 __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.1.0"
+MULTI_AGENT_VERSION = "6.2.0"
 
 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.1.0"
+__version__ = "6.2.0"