ltcai 6.1.0 → 6.3.0

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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -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; 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" },
+];

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

@@ -89,7 +89,9 @@ export function ReviewCard({ item, feedback, onAction }: ReviewCardProps) {
         </div>
       ) : null}
       {feedback ? (
-        <p className="mt-2 text-xs text-emerald-300">{feedback} - item stays open until you approve or dismiss.</p>
+        <p className={`mt-2 text-xs ${/fail|error|unavailable/i.test(feedback) ? "text-amber-300" : "text-emerald-300"}`}>
+          {feedback} - item stays open until you approve or dismiss.
+        </p>
       ) : null}
     </div>
   );

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

@@ -38,11 +38,21 @@ export function ReviewInbox() {
       action === "unsnooze" ? () => latticeApi.unsnoozeReviewItem(item.id) :
       () => latticeApi.runNowReviewItem(item.id);
     const result = await call();
+    if (!result.ok) {
+      setRunFeedback((prev) => ({
+        ...prev,
+        [item.id]: result.error || `${action} failed`,
+      }));
+      return result;
+    }
     if (result.ok) {
       if (action === "run_now") {
+        const payload = result.data.payload || {};
+        const provenance = result.data.provenance || {};
+        const runId = String(payload.last_run_id || provenance.run_id || "");
         setRunFeedback((prev) => ({
           ...prev,
-          [item.id]: hadRunBefore ? "Regenerated" : "Executed",
+          [item.id]: runId ? `${hadRunBefore ? "Regenerated" : "Executed"} · ${runId}` : hadRunBefore ? "Regenerated" : "Executed",
         }));
       } else {
         setRunFeedback((prev) => {