ltcai 6.2.0 → 6.3.1

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

@@ -0,0 +1,38 @@
+import type { BrainDepth, MemoryFragment } from "./types";
+import { t } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import { layerStyle, polarPoint } from "./graphLayout";
+
+export function BrainMemoryLayer({
+  memories,
+  depth,
+  onRecallMemory,
+}: {
+  memories: MemoryFragment[];
+  depth: BrainDepth;
+  onRecallMemory: (fragment: MemoryFragment) => void;
+}) {
+  const language = useAppStore((state) => state.language);
+  const visible = memories.slice(0, depth >= 3 ? 8 : 6);
+  if (!visible.length) return <div className="memory-fragment is-empty">{t(language, "brain.memory.empty")}</div>;
+
+  return (
+    <>
+      {visible.map((memory, index) => {
+        const point = polarPoint(index, visible.length, depth >= 3 ? 39 : 31, depth >= 3 ? 24 : 18, -112);
+        return (
+          <button
+            key={memory.id}
+            type="button"
+            className="memory-fragment"
+            style={layerStyle({ "--x": `${point.x}%`, "--y": `${point.y}%`, "--delay": `${index * 55}ms` })}
+            onClick={() => onRecallMemory(memory)}
+          >
+            <span>{memory.kind}</span>
+            <strong>{memory.title}</strong>
+          </button>
+        );
+      })}
+    </>
+  );
+}

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

@@ -0,0 +1,74 @@
+import * as React from "react";
+import { t } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import type { BrainDepth, KnowledgeConcept, MemoryFragment } from "./types";
+
+export function BrainOverviewPanel({
+  memories,
+  concepts,
+  onOpenDepth,
+}: {
+  memories: MemoryFragment[];
+  concepts: KnowledgeConcept[];
+  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);
+
+  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>
+    </section>
+  );
+}
+
+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

@@ -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/types.ts

@@ -35,10 +35,10 @@ export type KnowledgeGraphModel = {
   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" },
+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

@@ -3,6 +3,7 @@ import type { ApiResult, ReviewItem } from "@/api/client";
 import { ActionButton, KeyValueList } from "@/components/primitives";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
+import { t } from "@/i18n";
 import { useAppStore } from "@/store/appStore";
 import {
   formatSnoozedUntil,
@@ -22,6 +23,7 @@ type ReviewCardProps = {
 
 export function ReviewCard({ item, feedback, onAction }: ReviewCardProps) {
   const mode = useAppStore((state) => state.mode);
+  const language = useAppStore((state) => state.language);
   const provenance = item.provenance || {};
   const payload = item.payload || {};
   const hadRun = hasRunBefore(item);
@@ -45,10 +47,10 @@ export function ReviewCard({ item, feedback, onAction }: ReviewCardProps) {
         <div className="mt-3 flex flex-wrap items-center justify-between gap-3 rounded-md border border-border bg-muted/24 p-3 text-sm">
           <div>
             <div className="font-medium">{formatSnoozedUntil(item.snoozed_until)}</div>
-            <p className="mt-1 text-muted-foreground">This stays out of the pending queue until then. Unsnooze brings it back immediately.</p>
+            <p className="mt-1 text-muted-foreground">{t(language, "review.snoozed.detail")}</p>
           </div>
           <Button size="sm" variant="outline" onClick={() => onAction(item, "unsnooze")} disabled={!actionable}>
-            <RotateCcw className="h-3.5 w-3.5" /> Unsnooze
+            <RotateCcw className="h-3.5 w-3.5" /> {t(language, "review.unsnooze")}
           </Button>
         </div>
       ) : null}
@@ -73,23 +75,25 @@ export function ReviewCard({ item, feedback, onAction }: ReviewCardProps) {
       {actionable ? (
         <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.
+            {t(language, "review.runNow.detail")}
           </p>
-          <div className="flex flex-wrap gap-2" aria-label="Review actions">
+          <div className="flex flex-wrap gap-2" aria-label={t(language, "review.actions.aria")}>
             <ActionButton
-              label="Run now"
-              successLabel={hadRun ? "Regenerated" : "Executed"}
+              label={t(language, "review.runNow")}
+              successLabel={hadRun ? t(language, "review.regenerated") : t(language, "review.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" />
+            <ActionButton label={t(language, "review.approve")} action={() => onAction(item, "approve")} invalidate={[]} />
+            {!snoozed ? <ActionButton label={t(language, "review.snoozeDay")} action={() => onAction(item, "snooze")} invalidate={[]} /> : null}
+            <ActionButton label={t(language, "review.dismiss")} action={() => onAction(item, "dismiss")} invalidate={[]} variant="destructive" />
           </div>
         </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} - {t(language, "review.feedback.open")}
+        </p>
       ) : null}
     </div>
   );

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

@@ -4,6 +4,8 @@ import { latticeApi, type ReviewItem, type ReviewSourceFilter, type ReviewStatus
 import { EmptyState, LoadingPanel, Tabs } from "@/components/primitives";
 import { Badge } from "@/components/ui/badge";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { t } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
 import { ReviewCard } from "./ReviewCard";
 import {
   defaultSnoozeUntil,
@@ -13,6 +15,7 @@ import {
 } from "./reviewHelpers";
 
 export function ReviewInbox() {
+  const language = useAppStore((state) => state.language);
   const qc = useQueryClient();
   const [statusFilter, setStatusFilter] = React.useState<ReviewStatusFilter>("pending");
   const [sourceFilter, setSourceFilter] = React.useState<ReviewSourceFilter>("all");
@@ -38,11 +41,23 @@ 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 || t(language, "review.action.failed", { action }),
+      }));
+      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 ? t(language, "review.regenerated") : t(language, "review.executed")} · ${runId}`
+            : hadRunBefore ? t(language, "review.regenerated") : t(language, "review.executed"),
         }));
       } else {
         setRunFeedback((prev) => {
@@ -56,18 +71,18 @@ export function ReviewInbox() {
     return result;
   };
 
-  if (reviews.isLoading) return <LoadingPanel title="Review inbox" />;
+  if (reviews.isLoading) return <LoadingPanel title={t(language, "review.inbox.title")} />;
 
   return (
     <Card>
       <CardHeader className="gap-3">
         <div className="flex flex-wrap items-start justify-between gap-3">
           <div>
-            <CardTitle>Review inbox</CardTitle>
-            <CardDescription>Automation suggestions waiting for your decision. Run now executes without approving.</CardDescription>
+            <CardTitle>{t(language, "review.inbox.title")}</CardTitle>
+            <CardDescription>{t(language, "review.inbox.description")}</CardDescription>
           </div>
           {reviews.data ? (
-            <Badge variant={reviews.data.ok ? "success" : "warning"}>{reviews.data.ok ? "connected" : "unavailable"}</Badge>
+            <Badge variant={reviews.data.ok ? "success" : "warning"}>{reviews.data.ok ? t(language, "review.status.connected") : t(language, "review.status.unavailable")}</Badge>
           ) : null}
         </div>
         <div className="grid gap-2">
@@ -86,13 +101,13 @@ export function ReviewInbox() {
       <CardContent>
         {reviews.isError || (reviews.data && !reviews.data.ok) ? (
           <EmptyState
-            title="Could not load review inbox"
-            detail={reviews.data?.error || "The review queue is not available right now."}
+            title={t(language, "review.inbox.loadError")}
+            detail={reviews.data?.error || t(language, "review.inbox.unavailable")}
           />
         ) : !items.length ? (
           <EmptyState
-            title="Nothing to review"
-            detail={statusFilter === "snoozed" ? "Snoozed items will appear here until they are unsnoozed or become pending again." : "When automations opt into the review queue, new suggestions will appear here."}
+            title={t(language, "review.inbox.empty")}
+            detail={statusFilter === "snoozed" ? t(language, "review.inbox.emptySnoozed") : t(language, "review.inbox.emptyPending")}
           />
         ) : (
           <div className="grid gap-3">