ltcai 8.0.0 → 8.2.0

package/frontend/src/features/brain/BrainOverviewPanel.tsx

@@ -1,149 +0,0 @@
-import * as React from "react";
-import { BrainCircuit, DatabaseZap, Repeat2 } from "lucide-react";
-import { t } from "@/i18n";
-import { useAppStore } from "@/store/appStore";
-import type { BrainDepth, BrainProof, BrainReadiness, KnowledgeConcept, MemoryFragment } from "./types";
-
-export function BrainOverviewPanel({
-  memories,
-  concepts,
-  readiness,
-  proof,
-  onOpenDepth,
-}: {
-  memories: MemoryFragment[];
-  concepts: KnowledgeConcept[];
-  readiness: BrainReadiness;
-  proof: BrainProof;
-  onOpenDepth: (depth: BrainDepth) => void;
-}) {
-  const language = useAppStore((state) => state.language);
-  const recent = memories.slice(0, 3);
-  const older = memories.slice(3, 6);
-  const topics = concepts.slice(0, 4);
-  const hasDurableProof = proof.proofs.hasDurableEvidence || proof.modelContinuity.proven;
-  const hasRecallProof = proof.recall.items.length > 0;
-  const modelProofValue = proof.modelContinuity.proven && proof.claims.keepsContextAcrossModels
-    ? proof.modelContinuity.activeModel || t(language, "brain.proof.noModel")
-    : t(language, "brain.proof.modelPending");
-
-  return (
-    <section className="brain-overview-panel" aria-label={t(language, "brain.aria.overview")}>
-      <div className="brain-overview-head">
-        <div>
-          <span>{t(language, "brain.overview.kicker")}</span>
-          <strong>{t(language, "brain.overview.title")}</strong>
-        </div>
-        <button type="button" onClick={() => onOpenDepth(5)}>{t(language, "brain.overview.graph")}</button>
-      </div>
-      <div className="brain-overview-grid">
-        <BrainOverviewColumn
-          title={t(language, "brain.overview.recent")}
-          empty={t(language, "brain.overview.recentEmpty")}
-          items={recent.map((memory) => memory.title)}
-          onOpen={() => onOpenDepth(2)}
-        />
-        <BrainOverviewColumn
-          title={t(language, "brain.overview.older")}
-          empty={t(language, "brain.overview.olderEmpty")}
-          items={older.map((memory) => memory.title)}
-          onOpen={() => onOpenDepth(2)}
-        />
-        <BrainOverviewColumn
-          title={t(language, "brain.overview.topics")}
-          empty={t(language, "brain.overview.topicsEmpty")}
-          items={topics.map((concept) => concept.label)}
-          onOpen={() => onOpenDepth(3)}
-        />
-      </div>
-      <div className="brain-readiness-strip" data-state={readiness.state}>
-        <div>
-          <span>{t(language, "brain.readiness.kicker")}</span>
-          <strong>{t(language, readiness.titleKey)}</strong>
-        </div>
-        <div className="brain-readiness-meter" aria-label={t(language, "brain.readiness.aria")}>
-          <i style={{ width: `${readiness.score}%` }} />
-        </div>
-        <button type="button" onClick={() => onOpenDepth(readiness.depth)}>
-          {t(language, readiness.actionKey)}
-        </button>
-      </div>
-      <div className="brain-proof-strip" aria-label={t(language, "brain.proof.aria")}>
-        <BrainProofPoint
-          icon={<DatabaseZap className="h-4 w-4" />}
-          label={t(language, "brain.proof.context")}
-          value={hasDurableProof
-            ? t(language, "brain.proof.contextValue", { count: proof.proofs.durableItems })
-            : t(language, "brain.proof.contextEmpty")}
-        />
-        <BrainProofPoint
-          icon={<Repeat2 className="h-4 w-4" />}
-          label={t(language, "brain.proof.model")}
-          value={modelProofValue}
-        />
-        <BrainProofPoint
-          icon={<BrainCircuit className="h-4 w-4" />}
-          label={t(language, "brain.proof.store")}
-          value={t(language, "brain.proof.storeValue", {
-            topics: proof.proofs.graphConcepts,
-            vectors: proof.proofs.vectorItems,
-          })}
-        />
-      </div>
-      {hasRecallProof ? (
-        <button type="button" className="brain-recall-proof" onClick={() => onOpenDepth(2)}>
-          <span>{t(language, "brain.proof.recall")}</span>
-          <strong>{proof.recall.items[0].title}</strong>
-          <small>{proof.recall.items[0].snippet || proof.recall.query}</small>
-        </button>
-      ) : (
-        <div className="brain-recall-proof is-empty" role="status">
-          <span>{t(language, "brain.proof.recallEmpty.kicker")}</span>
-          <strong>{t(language, hasDurableProof ? "brain.proof.recallPending" : "brain.proof.recallEmpty.title")}</strong>
-          <small>{t(language, hasDurableProof ? "brain.proof.recallPending.detail" : "brain.proof.recallEmpty.detail")}</small>
-        </div>
-      )}
-    </section>
-  );
-}
-
-function BrainProofPoint({
-  icon,
-  label,
-  value,
-}: {
-  icon: React.ReactNode;
-  label: string;
-  value: string;
-}) {
-  return (
-    <div className="brain-proof-point">
-      {icon}
-      <span>{label}</span>
-      <strong>{value}</strong>
-    </div>
-  );
-}
-
-function BrainOverviewColumn({
-  title,
-  empty,
-  items,
-  onOpen,
-}: {
-  title: string;
-  empty: string;
-  items: string[];
-  onOpen: () => void;
-}) {
-  return (
-    <button type="button" className="brain-overview-column" onClick={onOpen}>
-      <span>{title}</span>
-      {items.length ? (
-        items.slice(0, 3).map((item) => <strong key={item}>{item}</strong>)
-      ) : (
-        <em>{empty}</em>
-      )}
-    </button>
-  );
-}

package/frontend/src/features/brain/BrainRelationshipLayer.tsx

@@ -1,43 +0,0 @@
-import type { KnowledgeConcept, RelationshipThread } from "./types";
-import { layoutGraphNodes } from "./graphLayout";
-
-export function BrainRelationshipLayer({
-  concepts,
-  relationships,
-}: {
-  concepts: KnowledgeConcept[];
-  relationships: RelationshipThread[];
-}) {
-  const visibleConcepts = concepts.slice(0, 10);
-  const layout = layoutGraphNodes(visibleConcepts, 30, 20);
-  const positionById = new Map(layout.map((item) => [item.node.id, item]));
-  const visibleRelationships = relationships
-    .map((relationship, index) => {
-      const source = positionById.get(relationship.source) || layout[index % Math.max(layout.length, 1)];
-      const target = positionById.get(relationship.target) || layout[(index + 3) % Math.max(layout.length, 1)];
-      return source && target && source.node.id !== target.node.id ? { relationship, source, target } : null;
-    })
-    .filter(Boolean)
-    .slice(0, 8) as Array<{
-      relationship: RelationshipThread;
-      source: ReturnType<typeof layoutGraphNodes>[number];
-      target: ReturnType<typeof layoutGraphNodes>[number];
-    }>;
-
-  if (!visibleRelationships.length) return null;
-
-  return (
-    <svg className="relationship-weave" viewBox="0 0 100 100" aria-hidden>
-      {visibleRelationships.map(({ relationship, source, target }, index) => (
-        <line
-          key={`${relationship.id}-${index}`}
-          x1={source.x}
-          y1={source.y}
-          x2={target.x}
-          y2={target.y}
-          style={{ animationDelay: `${index * 80}ms` }}
-        />
-      ))}
-    </svg>
-  );
-}

package/frontend/src/features/brain/DepthEmergence.tsx

@@ -1,53 +0,0 @@
-import type { BrainDepth, KnowledgeConcept, KnowledgeGraphModel, MemoryFragment, RelationshipThread } from "./types";
-import { BrainGraphLayer, BrainKnowledgeLayer } from "./BrainGraphLayer";
-import { BrainMemoryLayer } from "./BrainMemoryLayer";
-import { BrainRelationshipLayer } from "./BrainRelationshipLayer";
-
-export function DepthEmergence({
-  depth,
-  memories,
-  concepts,
-  relationships,
-  graphModel,
-  graphSearch,
-  selectedGraphId,
-  onGraphSearch,
-  onSelectGraphNode,
-  onRecallMemory,
-}: {
-  depth: BrainDepth;
-  memories: MemoryFragment[];
-  concepts: KnowledgeConcept[];
-  relationships: RelationshipThread[];
-  graphModel: KnowledgeGraphModel;
-  graphSearch: string;
-  selectedGraphId: string | null;
-  onGraphSearch: (value: string) => void;
-  onSelectGraphNode: (id: string | null) => void;
-  onRecallMemory: (fragment: MemoryFragment) => void;
-}) {
-  if (depth === 1) return null;
-
-  return (
-    <>
-      {depth >= 2 ? (
-        <BrainMemoryLayer memories={memories} depth={depth} onRecallMemory={onRecallMemory} />
-      ) : null}
-      {depth >= 3 && depth < 5 ? (
-        <BrainKnowledgeLayer concepts={concepts} depth={depth} />
-      ) : null}
-      {depth >= 4 && depth < 5 ? (
-        <BrainRelationshipLayer concepts={concepts} relationships={relationships} />
-      ) : null}
-      {depth >= 5 ? (
-        <BrainGraphLayer
-          model={graphModel}
-          search={graphSearch}
-          selectedId={selectedGraphId}
-          onSearch={onGraphSearch}
-          onSelect={onSelectGraphNode}
-        />
-      ) : null}
-    </>
-  );
-}

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

@@ -1,246 +0,0 @@
-import { asArray } from "@/lib/utils";
-import type { ApiRecord, BrainDepth, BrainProof, BrainReadiness, 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);
-    const createdAt = timestampValue(node, ["created_at", "createdAt", "added_at", "addedAt", "timestamp", "updated_at", "updatedAt"])
-      ?? timestampValue(metadata, ["created_at", "createdAt", "added_at", "addedAt", "timestamp", "updated_at", "updatedAt"]);
-    return [{ id, label, type, summary, importance, ...(createdAt !== undefined ? { createdAt } : {}) }];
-  }).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";
-}
-
-export function buildBrainReadiness(memoryData: unknown, fallbackMemoryCount: number, fallbackConceptCount: number): BrainReadiness {
-  const memory = isRecord(memoryData) ? memoryData : {};
-  const backend = isRecord(memory.brain_readiness) ? memory.brain_readiness : {};
-  const backendState = textValue(backend, ["state"]);
-  const backendDepth = numberValue(backend, ["depth"]);
-  const backendScore = numberValue(backend, ["score"]);
-  if ((backendState === "quiet" || backendState === "forming" || backendState === "alive") && isBrainDepth(backendDepth)) {
-    const signals = isRecord(backend.signals) ? backend.signals : {};
-    return {
-      score: clamp(Math.round(backendScore || 0), 0, 100),
-      state: backendState,
-      depth: backendDepth,
-      titleKey: textValue(backend, ["title_key", "titleKey"], `brain.readiness.${backendState}`),
-      actionKey: textValue(backend, ["action_key", "actionKey"], readinessActionKey(backendState)),
-      source: "memory_service",
-      signals: {
-        memoryCount: numberValue(signals, ["memory_count", "memoryCount"]),
-        conceptCount: numberValue(signals, ["concept_count", "conceptCount"]),
-        relationshipCount: numberValue(signals, ["relationship_count", "relationshipCount"]),
-        healthySources: numberValue(signals, ["healthy_sources", "healthySources"]),
-      },
-    };
-  }
-  return fallbackBrainReadiness(fallbackMemoryCount, fallbackConceptCount);
-}
-
-export function buildBrainProof(data: unknown, fallbackModelName = ""): BrainProof {
-  const proof = isRecord(data) ? data : {};
-  const modelContinuity = isRecord(proof.model_continuity) ? proof.model_continuity : {};
-  const proofs = isRecord(proof.proofs) ? proof.proofs : {};
-  const recall = isRecord(proof.recall) ? proof.recall : {};
-  const claims = isRecord(proof.claims) ? proof.claims : {};
-  const durableItems = numberValue(proofs, ["durable_items", "durableItems"]);
-  return {
-    status: textValue(proof, ["status"], "quiet"),
-    modelContinuity: {
-      activeModel: textValue(modelContinuity, ["active_model", "activeModel"], fallbackModelName),
-      brainOwner: textValue(modelContinuity, ["brain_owner", "brainOwner"], "lattice_brain"),
-      capability: booleanValue(modelContinuity, ["capability"], true),
-      survivesModelSwitch: booleanValue(modelContinuity, ["survives_model_switch", "survivesModelSwitch"], false),
-      proven: booleanValue(modelContinuity, ["proven"], false),
-      contextStore: textValue(modelContinuity, ["context_store", "contextStore"], "workspace + conversation + graph + vector"),
-    },
-    proofs: {
-      durableItems,
-      hasDurableEvidence: booleanValue(proofs, ["has_durable_evidence", "hasDurableEvidence"], durableItems > 0),
-      workspaceMemories: numberValue(proofs, ["workspace_memories", "workspaceMemories"]),
-      conversations: numberValue(proofs, ["conversations"]),
-      graphConcepts: numberValue(proofs, ["graph_concepts", "graphConcepts"]),
-      vectorItems: numberValue(proofs, ["vector_items", "vectorItems"]),
-      healthySources: numberValue(proofs, ["healthy_sources", "healthySources"]),
-    },
-    recall: {
-      query: textValue(recall, ["query"]),
-      count: numberValue(recall, ["count"]),
-      items: asArray<ApiRecord>(recall.items).map((item, index) => ({
-        id: textValue(item, ["id"], `recall-${index}`),
-        source: titleValue(item, ["source"], "Memory"),
-        title: textValue(item, ["title"], "Memory"),
-        snippet: textValue(item, ["snippet"]),
-        score: numberValue(item, ["score"]),
-      })),
-    },
-    claims: {
-      canRecallUserContext: booleanValue(claims, ["can_recall_user_context", "canRecallUserContext"], false),
-      keepsContextAcrossModels: booleanValue(claims, ["keeps_context_across_models", "keepsContextAcrossModels"], false),
-      isKnowledgeStore: booleanValue(claims, ["is_knowledge_store", "isKnowledgeStore"], false),
-    },
-  };
-}
-
-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;
-  });
-}
-
-function fallbackBrainReadiness(memoryCount: number, conceptCount: number): BrainReadiness {
-  const score = Math.min(100, Math.round(memoryCount * 12 + conceptCount * 10));
-  if (memoryCount < 1) {
-    return {
-      score: Math.max(12, score),
-      state: "quiet",
-      depth: 2,
-      titleKey: "brain.readiness.quiet",
-      actionKey: "brain.readiness.start",
-      source: "frontend_fallback",
-      signals: { memoryCount, conceptCount, relationshipCount: 0, healthySources: 0 },
-    };
-  }
-  if (conceptCount < 3) {
-    return {
-      score: Math.max(38, score),
-      state: "forming",
-      depth: 3,
-      titleKey: "brain.readiness.forming",
-      actionKey: "brain.readiness.grow",
-      source: "frontend_fallback",
-      signals: { memoryCount, conceptCount, relationshipCount: 0, healthySources: 0 },
-    };
-  }
-  return {
-    score: Math.max(72, score),
-    state: "alive",
-    depth: 5,
-    titleKey: "brain.readiness.alive",
-    actionKey: "brain.readiness.map",
-    source: "frontend_fallback",
-    signals: { memoryCount, conceptCount, relationshipCount: 0, healthySources: 0 },
-  };
-}
-
-function readinessActionKey(state: "quiet" | "forming" | "alive") {
-  if (state === "quiet") return "brain.readiness.start";
-  if (state === "forming") return "brain.readiness.grow";
-  return "brain.readiness.map";
-}
-
-function isBrainDepth(value: number): value is BrainDepth {
-  return value >= 1 && value <= 5 && Number.isInteger(value);
-}
-
-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());
-}
-
-// Parse a created/added timestamp into unix epoch milliseconds. Accepts ISO 8601
-// strings, unix seconds, or unix milliseconds. Returns undefined when absent or
-// unparseable so the time-exploration UI can fall back gracefully.
-function timestampValue(record: ApiRecord, keys: string[]): number | undefined {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "number" && Number.isFinite(value)) {
-      // Heuristic: values below ~1e12 are seconds, otherwise milliseconds.
-      return value < 1e12 ? value * 1000 : value;
-    }
-    if (typeof value === "string" && value.trim()) {
-      const numeric = Number(value);
-      if (Number.isFinite(numeric) && /^\d+$/.test(value.trim())) {
-        return numeric < 1e12 ? numeric * 1000 : numeric;
-      }
-      const parsed = Date.parse(value);
-      if (Number.isFinite(parsed)) return parsed;
-    }
-  }
-  return undefined;
-}
-
-function numberValue(record: ApiRecord, keys: string[]) {
-  for (const key of keys) {
-    const value = Number(record[key]);
-    if (Number.isFinite(value)) return value;
-  }
-  return 0;
-}
-
-function booleanValue(record: ApiRecord, keys: string[], fallback: boolean) {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "boolean") return value;
-  }
-  return fallback;
-}

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

@@ -1,37 +0,0 @@
-import * as React from "react";
-import type { KnowledgeConcept, RelationshipThread } from "./types";
-
-// Return the set of node ids that share a direct (1-hop) edge with `nodeId`.
-// The focused node itself is not included.
-export function computeGraphNeighbors(nodeId: string, edges: RelationshipThread[]): Set<string> {
-  const neighbors = new Set<string>();
-  for (const edge of edges) {
-    if (edge.source === nodeId) neighbors.add(edge.target);
-    else if (edge.target === nodeId) neighbors.add(edge.source);
-  }
-  return neighbors;
-}
-
-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

@@ -1,150 +0,0 @@
-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;
-  proof?: MessageProof;
-};
-
-export type MessageProof = {
-  query: string;
-  model: string;
-  provenAcrossModels: boolean;
-  citations: Array<{
-    id: string;
-    source: string;
-    title: string;
-    snippet: string;
-  }>;
-};
-
-export type MemoryFragment = {
-  id: string;
-  title: string;
-  kind: string;
-};
-
-export type KnowledgeConcept = {
-  id: string;
-  label: string;
-  type: string;
-  summary: string;
-  importance: number;
-  // Optional unix epoch (ms) the concept was added to the graph. Enables
-  // time-based exploration; absent when the backend does not yet emit it.
-  createdAt?: number;
-};
-
-export type RelationshipThread = {
-  id: string;
-  source: string;
-  target: string;
-  label: string;
-  weight: number;
-};
-
-export type KnowledgeGraphModel = {
-  nodes: KnowledgeConcept[];
-  edges: RelationshipThread[];
-};
-
-export type BrainReadiness = {
-  score: number;
-  state: "quiet" | "forming" | "alive";
-  depth: BrainDepth;
-  titleKey: string;
-  actionKey: string;
-  source: "memory_service" | "frontend_fallback";
-  signals: {
-    memoryCount: number;
-    conceptCount: number;
-    relationshipCount: number;
-    healthySources: number;
-  };
-};
-
-export type BrainProof = {
-  status: "quiet" | "forming" | "alive" | string;
-  modelContinuity: {
-    activeModel: string;
-    brainOwner: string;
-    capability: boolean;
-    survivesModelSwitch: boolean;
-    proven: boolean;
-    contextStore: string;
-  };
-  proofs: {
-    durableItems: number;
-    hasDurableEvidence: boolean;
-    workspaceMemories: number;
-    conversations: number;
-    graphConcepts: number;
-    vectorItems: number;
-    healthySources: number;
-  };
-  recall: {
-    query: string;
-    count: number;
-    items: Array<{
-      id: string;
-      source: string;
-      title: string;
-      snippet: string;
-      score: number;
-    }>;
-  };
-  claims: {
-    canRecallUserContext: boolean;
-    keepsContextAcrossModels: boolean;
-    isKnowledgeStore: boolean;
-  };
-};
-
-export type IngestionSourceType = "file" | "folder" | "note" | "web";
-
-export type IngestionPipelineStage =
-  | "preparing"
-  | "parsing"
-  | "embedding"
-  | "indexing"
-  | "complete"
-  | "error";
-
-export type IngestionState = {
-  sourceType: IngestionSourceType;
-  label: string;
-  stage: IngestionPipelineStage;
-  startedAt: number;
-  completedAt: number | null;
-  newMemories: number;
-  newEntities: number;
-  error?: string;
-};
-
-export type EmergenceEvent = {
-  id: string;
-  sourceType: IngestionSourceType;
-  label: string;
-  newMemories: number;
-  newEntities: number;
-  at: number;
-};
-
-export const INGESTION_STAGE_ORDER: IngestionPipelineStage[] = [
-  "preparing",
-  "parsing",
-  "embedding",
-  "indexing",
-  "complete",
-];
-
-export const DEPTHS: Array<{ level: BrainDepth; labelKey: string; state: BrainState }> = [
-  { level: 1, labelKey: "brain.depthLabel.1", state: "idle" },
-  { level: 2, labelKey: "brain.depthLabel.2", state: "recalling" },
-  { level: 3, labelKey: "brain.depthLabel.3", state: "synthesizing" },
-  { level: 4, labelKey: "brain.depthLabel.4", state: "planning" },
-  { level: 5, labelKey: "brain.depthLabel.5", state: "synthesizing" },
-];