@manta-eu/react 0.1.9 → 0.1.10

package/src/routes/memories/index.tsx

@@ -0,0 +1,796 @@
+import {
+  GQLMemoryScope,
+  useAvailableTeamsQuery,
+  useCreateMemoryMutation,
+  useDeleteMemoryMutation,
+  useConsolidateMemoriesMutation,
+  useMemoriesQuery,
+  useMemoryRedundancyReviewQuery,
+  useMemorySchemasQuery,
+  useReconfirmMemoryMutation,
+  useRestoreMemoryMutation,
+  useUpdateMemoryMutation,
+  type GQLMemory,
+  type GQLMemorySchema,
+} from "@manta-eu/client";
+import { parseError } from "@manta-eu/client/shared/error-utils";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQueryClient } from "@tanstack/react-query";
+import { Archive, Brain, CalendarX, CopyCheck, EyeOff, Plus, RefreshCcw } from "lucide-react";
+import type { ReactNode } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useSearchParams } from "react-router";
+import { toast } from "sonner";
+import { match } from "ts-pattern";
+import { ChangeScopeDialog } from "./components/ChangeScopeDialog";
+import { ConsolidationReviewDialog, type ConsolidationDecision } from "./components/ConsolidationReviewDialog";
+import { GroupMemoriesEmptyState, MemoriesEmptyState, CompanyMemoriesEmptyState } from "./components/EmptyStates";
+import { LiveContextTab } from "./components/LiveContextTab";
+import type { KindFilter } from "./components/MemoriesFilters";
+import { MemoriesTabPanel } from "./components/MemoriesTabPanel";
+import type { MemoryFormState } from "./components/MemoryFields";
+import { MemoryFormDialog } from "./components/MemoryFormDialog";
+import { MemoryOnboardingWizard } from "./components/MemoryOnboardingWizard";
+import { RestoreBlockedDialog } from "./components/RestoreBlockedDialog";
+import { SchemasTab } from "./components/SchemasTab";
+import { useDuplicateDetection } from "./hooks/useDuplicateDetection";
+import { liveContextQueryKey } from "./hooks/useLiveContext";
+import { useMemoryColumns } from "./hooks/useMemoryColumns";
+import { useMemoryTable, type StatusFilterKey } from "./hooks/useMemoryTable";
+import { buildCreateMemoryInput, buildUpdateMemoryInput, deriveLabel } from "./memory-mutation-input";
+import { Input } from "#components/input/index";
+import { PageHeader, PageHeaderActions, type PageHeaderAction } from "#components/layouts/page/index";
+import { RouteLayout } from "#components/layouts/RouteLayout";
+import { ScopeTabs, type ScopeTab } from "#components/scope-tabs/index";
+import { Tabs, TabsContent } from "#components/tabs/index";
+import { useAuthContext } from "#providers/AuthContext";
+import { useMantaClient } from "#providers/index";
+
+function reportMutationError(e: unknown, fallbackMessage: string) {
+  const err = parseError(e, fallbackMessage);
+  toast.error(err.message, { description: err.description });
+}
+
+function addMemoryButtonConfig(tab: ActiveTab): { scope: GQLMemoryScope; label: string } | null {
+  return match(tab)
+    .with("personal", () => ({ scope: GQLMemoryScope.User, label: "Add memory" }))
+    .with("company", () => ({ scope: GQLMemoryScope.Company, label: "Add company memory" }))
+    .with("team", () => ({ scope: GQLMemoryScope.Team, label: "Add team memory" }))
+    .otherwise(() => null);
+}
+
+type ScopeTableState = ReturnType<typeof useMemoryTable>;
+
+const alwaysVisibleStatusFilters: StatusFilterKey[] = ["hideStale", "deadWeight", "unused", "needsReview"];
+
+type ScopeMemoriesTabProps = {
+  value: ActiveTab;
+  tableState: ScopeTableState;
+  memories: GQLMemory[];
+  emptyState: ReactNode;
+  tabs: ReactNode;
+  isLoading: boolean;
+  errorMessage: string | null;
+  schemas: GQLMemorySchema[];
+  onRowClick: (memory: GQLMemory) => void;
+  visibleStatusFilters?: StatusFilterKey[];
+};
+
+function ScopeMemoriesTab(props: ScopeMemoriesTabProps) {
+  const {
+    value,
+    tableState,
+    memories,
+    emptyState,
+    visibleStatusFilters = alwaysVisibleStatusFilters,
+    ...panelProps
+  } = props;
+
+  return (
+    <TabsContent value={value} className="flex flex-col flex-1 min-h-0 overflow-hidden">
+      <MemoriesTabPanel
+        {...panelProps}
+        {...tableState}
+        memories={memories}
+        emptyState={emptyState}
+        visibleStatusFilters={visibleStatusFilters}
+      />
+    </TabsContent>
+  );
+}
+
+type FilterableTabContentProps = {
+  value: ActiveTab;
+  tabs: ReactNode;
+  placeholder: string;
+  query: string;
+  onQueryChange: (query: string) => void;
+  children: ReactNode;
+};
+
+function FilterableTabContent(props: FilterableTabContentProps) {
+  const { value, tabs, placeholder, query, onQueryChange, children } = props;
+
+  return (
+    <TabsContent value={value} className="flex flex-col flex-1 min-h-0 overflow-hidden">
+      <div className="border-b border-muted-border px-5 py-3 shrink-0">
+        <div className="flex min-w-0 flex-col gap-3 2xl:flex-row 2xl:items-center">
+          <div className="min-w-0 2xl:shrink">{tabs}</div>
+          <Input
+            containerClassName="w-auto min-w-48 sm:w-64"
+            type="search"
+            variant="search"
+            placeholder={placeholder}
+            value={query}
+            onChange={(e) => onQueryChange(e.target.value)}
+          />
+        </div>
+      </div>
+      <div className="flex-1 overflow-auto p-5">{children}</div>
+    </TabsContent>
+  );
+}
+
+export { deriveLabel };
+export {
+  KindBadge,
+  ScopeBadge,
+  preloadBadgeContent,
+  type KindBadgeProps,
+  type PreloadBadgeContent,
+  type PreloadBadgeTone,
+  type ScopeBadgeProps,
+} from "./components/badges";
+export { formatHorizonDate, formatHorizonRelative, memoryHorizon, type MemoryHorizon } from "./expiry-utils";
+export {
+  filterMemories,
+  type ImportanceFilter,
+  type MemoryFilterCriteria,
+  type SchemaFilter,
+} from "./hooks/useMemoryTable";
+export {
+  GroupMemoriesEmptyState,
+  MemoriesEmptyState,
+  type GroupMemoriesEmptyStateProps,
+  type MemoriesEmptyStateProps,
+} from "./components/EmptyStates";
+export { LoadingSkeleton } from "./components/LoadingSkeleton";
+export { MemoryFormDialog, type MemoryFormDialogProps } from "./components/MemoryFormDialog";
+export type { MemoryFormState } from "./components/MemoryFields";
+
+const tableKeyPersonal = "memories-table-personal";
+const tableKeyCompany = "memories-table-company";
+const tableKeyGroup = "memories-table-group";
+
+const emptyMemories: GQLMemory[] = [];
+
+const personalColumnVisibility = { createdBy: false, teams: false };
+const companyColumnVisibility = { teams: false };
+const teamColumnVisibility = { teams: true };
+
+// Drops a whole group once any of its memories was merged, since the rest of it no longer describes what is stored.
+function unmergedGroups<T extends { memories: readonly { iri: string }[] }>(
+  groups: readonly T[],
+  merged: ReadonlySet<string>,
+): T[] {
+  if (merged.size === 0) return [...groups];
+  return groups.filter((group) => !group.memories.some((memory) => merged.has(memory.iri)));
+}
+
+type ActiveTab = "personal" | "company" | "team" | "live-context" | "schemas";
+
+const tabLabels: Record<ActiveTab, string> = {
+  company: "Company",
+  team: "Team",
+  personal: "Personal",
+  schemas: "Schemas",
+  "live-context": "Live Context",
+};
+
+type AddDialogState = { scope: GQLMemoryScope } | null;
+
+export function MemoriesRoute() {
+  const { datastore, datastores, user, logout, isOperator, canManageSharedMemories, canSwitchDatastore } =
+    useAuthContext();
+  const { mantaClient } = useMantaClient();
+  const queryClient = useQueryClient();
+
+  const [showArchived, setShowArchived] = useState(false);
+  // Server-side like showArchived — these rows are absent from the response unless requested.
+  const [showOutOfWindow, setShowOutOfWindow] = useState(false);
+  const {
+    data,
+    isLoading,
+    isFetching,
+    refetch,
+    error: queriedError,
+  } = useMemoriesQuery(mantaClient, {
+    includeArchived: showArchived,
+    includeOutOfWindow: showOutOfWindow,
+  });
+  const { data: schemasData } = useMemorySchemasQuery(mantaClient);
+  const schemas = schemasData?.memorySchemas.schemas ?? [];
+  const allMemories = data?.memories.memories ?? emptyMemories;
+  const personalMemories = useMemo(() => allMemories.filter((m) => m.scope === GQLMemoryScope.User), [allMemories]);
+  const companyMemories = useMemo(() => allMemories.filter((m) => m.scope === GQLMemoryScope.Company), [allMemories]);
+  const teamMemories = useMemo(() => allMemories.filter((m) => m.scope === GQLMemoryScope.Team), [allMemories]);
+  const unreviewedPersonalMemories = useMemo(
+    () => personalMemories.filter((m) => m.confidence != null && m.confidence < 1),
+    [personalMemories],
+  );
+  const errorMessage = queriedError ? parseError(queriedError, "Failed to load memories").message : null;
+
+  const personalCount = personalMemories.length;
+  const companyCount = companyMemories.length;
+  const teamCount = teamMemories.length;
+  const unreviewedCount = unreviewedPersonalMemories.length;
+
+  const createMutation = useCreateMemoryMutation(mantaClient);
+  const updateMutation = useUpdateMemoryMutation(mantaClient);
+  const deleteMutation = useDeleteMemoryMutation(mantaClient);
+  const restoreMutation = useRestoreMemoryMutation(mantaClient);
+  const reconfirmMutation = useReconfirmMemoryMutation(mantaClient);
+  const { data: teamsData } = useAvailableTeamsQuery(mantaClient, undefined, { enabled: !!canManageSharedMemories });
+  const hasTeams = isPresent(teamsData?.availableTeams.teams);
+
+  const availableTabs = useMemo(
+    (): ActiveTab[] => [
+      ...(canManageSharedMemories ? (["company"] as ActiveTab[]) : []),
+      ...(canManageSharedMemories && hasTeams ? (["team"] as ActiveTab[]) : []),
+      "personal",
+      ...(canManageSharedMemories ? (["schemas"] as ActiveTab[]) : []),
+      "live-context",
+    ],
+    [canManageSharedMemories, hasTeams],
+  );
+
+  const [searchParams, setSearchParams] = useSearchParams();
+  const tabParam = searchParams.get("tab") as ActiveTab | null;
+
+  const activeTab = useMemo((): ActiveTab => {
+    if (tabParam && availableTabs.includes(tabParam)) return tabParam;
+    return availableTabs[0] ?? "personal";
+  }, [tabParam, availableTabs]);
+
+  useEffect(() => {
+    if (tabParam !== activeTab) {
+      setSearchParams({ tab: activeTab }, { replace: true });
+    }
+  }, [tabParam, activeTab, setSearchParams]);
+
+  useEffect(() => {
+    if (unreviewedCount === 0) setUnreviewedOnly(false);
+  }, [unreviewedCount]);
+
+  function handleTabChange(tab: string) {
+    setSearchParams({ tab }, { replace: true });
+  }
+
+  const [schemasQuery, setSchemasQuery] = useState("");
+  const [liveContextQuery, setLiveContextQuery] = useState("");
+  const [addDialog, setAddDialog] = useState<AddDialogState>(null);
+  const [editingMemory, setEditingMemory] = useState<GQLMemory | null>(null);
+  const [movingMemory, setMovingMemory] = useState<GQLMemory | null>(null);
+  const [restoreBlocked, setRestoreBlocked] = useState<{
+    iri: string;
+    blockedByIri: string;
+    blockedByLabel: string | null;
+  } | null>(null);
+  const [unreviewedOnly, setUnreviewedOnly] = useState(false);
+  const [showCompanyOnboarding, setShowOrgOnboarding] = useState(false);
+  const invalidate = useCallback(() => {
+    void refetch();
+    void queryClient.invalidateQueries({ queryKey: liveContextQueryKey });
+  }, [refetch, queryClient]);
+
+  const handleRefresh = useCallback(() => {
+    void refetch();
+    void queryClient.refetchQueries({ queryKey: liveContextQueryKey });
+  }, [refetch, queryClient]);
+
+  const [consolidating, setConsolidating] = useState(false);
+  const consolidationScope = match(activeTab)
+    .with("company", () => GQLMemoryScope.Company)
+    .with("team", () => GQLMemoryScope.Team)
+    .otherwise(() => GQLMemoryScope.User);
+  const consolidationVariables = { input: { scope: consolidationScope, wantToStopAfterMs: 60_000 } };
+  const {
+    data: reviewData,
+    isFetching: isFindingRedundancy,
+    error: reviewError,
+  } = useMemoryRedundancyReviewQuery(mantaClient, consolidationVariables, { enabled: consolidating });
+  const consolidateMutation = useConsolidateMemoriesMutation(mantaClient);
+  const consolidationCandidates = match(consolidationScope)
+    .with(GQLMemoryScope.Company, () => companyMemories)
+    .with(GQLMemoryScope.Team, () => teamMemories)
+    .otherwise(() => personalMemories)
+    .filter((m) => !isPresent(m.supersededBy));
+
+  const [mergedIris, setMergedIris] = useState<ReadonlySet<string>>(() => new Set());
+
+  const applyMerge = useCallback(
+    async (decision: ConsolidationDecision) => {
+      const result = await consolidateMutation.mutateAsync({
+        input: {
+          memoryIris: decision.memoryIris,
+          label: decision.label,
+          description: decision.description,
+          scope: consolidationScope,
+          derived: decision.kind === "pattern",
+        },
+      });
+      if (result.consolidateMemories.error) throw new Error(result.consolidateMemories.error);
+      setMergedIris((seen) => new Set([...seen, ...decision.memoryIris]));
+      invalidate();
+    },
+    [consolidateMutation, consolidationScope, invalidate],
+  );
+
+  const reviewProposals = useMemo(() => {
+    const review = reviewData?.memoryRedundancyReview;
+    return [
+      ...(review?.clusters ?? []).map((c) => ({ ...c, kind: "duplicate" as const })),
+      ...(review?.abstractions ?? []).map((a) => ({ ...a, kind: "pattern" as const })),
+    ];
+  }, [reviewData]);
+
+  const reviewGroups = unmergedGroups(reviewProposals, mergedIris);
+
+  const handleConsolidate = useCallback(
+    async (decision: ConsolidationDecision) => {
+      const isPattern = decision.kind === "pattern";
+      try {
+        await applyMerge(decision);
+        toast.success(
+          isPattern
+            ? `Replaced ${decision.memoryIris.length} memories with one general memory`
+            : `Merged ${decision.memoryIris.length} memories`,
+        );
+        if (reviewGroups.length <= 1) setConsolidating(false);
+      } catch (e) {
+        reportMutationError(e, isPattern ? "Failed to generalize memories" : "Failed to merge memories");
+      }
+    },
+    [applyMerge, reviewGroups.length],
+  );
+
+  const kindFilterResetRef = useRef<((kind: KindFilter) => void) | null>(null);
+
+  const handleCreate = useCallback(
+    async (form: MemoryFormState, supersedesMemoryIris?: string[]) => {
+      if (!addDialog) return;
+      if (!canManageSharedMemories && addDialog.scope !== GQLMemoryScope.User) return;
+      try {
+        const result = await createMutation.mutateAsync({
+          input: buildCreateMemoryInput(form, addDialog.scope, supersedesMemoryIris),
+        });
+
+        if (result.createMemory.error) throw new Error(result.createMemory.error);
+
+        toast.success("Memory added");
+        setAddDialog(null);
+        kindFilterResetRef.current?.("ALL");
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to add memory");
+      }
+    },
+    [addDialog, createMutation, invalidate, canManageSharedMemories],
+  );
+
+  const handleUpdate = useCallback(
+    async (form: MemoryFormState, supersedesMemoryIris?: string[]) => {
+      if (!editingMemory) return;
+      if (!canManageSharedMemories && editingMemory.scope !== GQLMemoryScope.User) return;
+      try {
+        const result = await updateMutation.mutateAsync({
+          input: buildUpdateMemoryInput(editingMemory.iri, form, editingMemory.scope, supersedesMemoryIris),
+        });
+
+        if (result.updateMemory.error) throw new Error(result.updateMemory.error);
+
+        toast.success("Memory updated");
+        setEditingMemory(null);
+        kindFilterResetRef.current?.("ALL");
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to update memory");
+      }
+    },
+    [editingMemory, updateMutation, invalidate, canManageSharedMemories],
+  );
+
+  const handleDelete = useCallback(
+    async (iri: string) => {
+      const target = allMemories.find((m) => m.iri === iri);
+      if (!canManageSharedMemories && target && target.scope !== GQLMemoryScope.User) return;
+      try {
+        await deleteMutation.mutateAsync({ memoryIri: iri });
+        toast.success("Memory deleted");
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to delete memory");
+      }
+    },
+    [deleteMutation, invalidate, canManageSharedMemories, allMemories],
+  );
+
+  const handleRestore = useCallback(
+    async (iri: string) => {
+      try {
+        const result = await restoreMutation.mutateAsync({ memoryIri: iri });
+        const { error, blockedByIri, blockedByLabel } = result.restoreMemory;
+        if (error) {
+          // Restore is blocked while the superseding memory is still active.
+          if (blockedByIri) {
+            setRestoreBlocked({ iri, blockedByIri, blockedByLabel: blockedByLabel ?? null });
+            return;
+          }
+          throw new Error(error);
+        }
+        toast.success("Memory restored");
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to restore memory");
+      }
+    },
+    [restoreMutation, invalidate],
+  );
+
+  const handleReconfirm = useCallback(
+    async (iri: string) => {
+      try {
+        const result = await reconfirmMutation.mutateAsync({ memoryIri: iri });
+        if (result.reconfirmMemory.error) throw new Error(result.reconfirmMemory.error);
+        toast.success("Memory reconfirmed");
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to reconfirm memory");
+      }
+    },
+    [reconfirmMutation, invalidate],
+  );
+
+  const handleConfirmRestoreBlocked = useCallback(() => {
+    if (!restoreBlocked) return;
+    const { iri, blockedByIri, blockedByLabel } = restoreBlocked;
+    void (async () => {
+      try {
+        await deleteMutation.mutateAsync({ memoryIri: blockedByIri });
+        const retry = await restoreMutation.mutateAsync({ memoryIri: iri });
+        if (retry.restoreMemory.error) throw new Error(retry.restoreMemory.error);
+        toast.success(`Restored - replaced "${blockedByLabel ?? "the newer memory"}"`);
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to restore memory");
+      } finally {
+        setRestoreBlocked(null);
+      }
+    })();
+  }, [restoreBlocked, deleteMutation, restoreMutation, invalidate]);
+
+  const handleMove = useCallback(
+    async (newScope: GQLMemoryScope, newTeams: string[], supersedesMemoryIris: string[]) => {
+      if (!movingMemory) return;
+      if (!canManageSharedMemories) return;
+      try {
+        const result = await updateMutation.mutateAsync({
+          input: {
+            iri: movingMemory.iri,
+            label: movingMemory.label,
+            description: movingMemory.description,
+            importance: movingMemory.importance,
+            // updateMemoryRecord overwrites kind/confidence/memorySubclass; re-send them on move.
+            kind: movingMemory.kind,
+            confidence: movingMemory.confidence,
+            scope: newScope,
+            teams: newTeams,
+            ...(movingMemory.memorySubclass != null ? { memorySubclass: movingMemory.memorySubclass } : {}),
+            ...(isPresent(supersedesMemoryIris) ? { supersedesMemoryIris } : {}),
+          },
+        });
+
+        if (result.updateMemory.error) throw new Error(result.updateMemory.error);
+
+        toast.success("Memory moved");
+        setMovingMemory(null);
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to move memory");
+      }
+    },
+    [movingMemory, updateMutation, invalidate, canManageSharedMemories],
+  );
+
+  const { duplicates } = useDuplicateDetection(unreviewedPersonalMemories, {
+    enabled: activeTab === "personal",
+  });
+
+  const columns = useMemoryColumns({
+    canManageSharedMemories,
+    userId: user.id,
+    schemas,
+    onEdit: setEditingMemory,
+    onDelete: handleDelete,
+    onMove: canManageSharedMemories ? setMovingMemory : undefined,
+    onRestore: handleRestore,
+    onReconfirm: handleReconfirm,
+    duplicates,
+  });
+
+  const displayedPersonalMemories = unreviewedOnly ? unreviewedPersonalMemories : personalMemories;
+
+  const personalTableState = useMemoryTable(
+    tableKeyPersonal,
+    displayedPersonalMemories,
+    columns,
+    [],
+    personalColumnVisibility,
+  );
+  const companyTableState = useMemoryTable(tableKeyCompany, companyMemories, columns, [], companyColumnVisibility);
+  const teamTableState = useMemoryTable(tableKeyGroup, teamMemories, columns, [], teamColumnVisibility);
+
+  kindFilterResetRef.current = personalTableState.onKindFilterChange;
+
+  const handleRowClick = useCallback((m: GQLMemory) => {
+    if (m.supersededBy == null) setEditingMemory(m);
+  }, []);
+
+  const tabCounts: Partial<Record<ActiveTab, { count?: number; secondaryCount?: number }>> = {
+    company: { count: companyCount },
+    team: { count: teamCount },
+    personal: { count: personalCount, secondaryCount: unreviewedCount },
+  };
+  const scopeTabs: ScopeTab<ActiveTab>[] = availableTabs.map((tab) => ({
+    value: tab,
+    label: tabLabels[tab],
+    ...tabCounts[tab],
+  }));
+
+  const tabsList = <ScopeTabs tabs={scopeTabs} activeValue={activeTab} isLoading={isLoading} />;
+
+  const addMemoryButton = addMemoryButtonConfig(activeTab);
+  const canShowArchived =
+    activeTab === "personal" || (canManageSharedMemories && (activeTab === "company" || activeTab === "team"));
+
+  const headerActions: PageHeaderAction[] = [
+    {
+      key: "refresh",
+      label: "Refresh",
+      icon: RefreshCcw,
+      variant: "tertiary",
+      iconOnly: true,
+      disabled: isFetching,
+      onClick: handleRefresh,
+    },
+    ...(canShowArchived
+      ? [
+          {
+            key: "archived",
+            label: showArchived ? "Hide archived" : "Show archived",
+            icon: showArchived ? EyeOff : Archive,
+            variant: "secondary",
+            active: showArchived,
+            onClick: () => setShowArchived((v) => !v),
+          } satisfies PageHeaderAction,
+          {
+            key: "out-of-window",
+            label: showOutOfWindow ? "Hide expired" : "Show expired",
+            icon: showOutOfWindow ? EyeOff : CalendarX,
+            variant: "secondary",
+            active: showOutOfWindow,
+            onClick: () => setShowOutOfWindow((v) => !v),
+          } satisfies PageHeaderAction,
+        ]
+      : []),
+    ...(canShowArchived
+      ? [
+          {
+            key: "consolidate",
+            label: "Review redundancy",
+            icon: CopyCheck,
+            variant: "secondary",
+            onClick: () => {
+              setMergedIris(new Set());
+              setConsolidating(true);
+            },
+          } satisfies PageHeaderAction,
+        ]
+      : []),
+    ...(activeTab === "personal" && unreviewedCount > 0
+      ? [
+          {
+            key: "unreviewed",
+            label: unreviewedOnly ? "All memories" : `Unreviewed (${unreviewedCount})`,
+            variant: unreviewedOnly ? "secondary" : "ghost",
+            active: unreviewedOnly,
+            onClick: () => setUnreviewedOnly((v) => !v),
+          } satisfies PageHeaderAction,
+        ]
+      : []),
+    ...(addMemoryButton
+      ? [
+          {
+            key: "add",
+            label: addMemoryButton.label,
+            icon: Plus,
+            onClick: () => setAddDialog({ scope: addMemoryButton.scope }),
+          } satisfies PageHeaderAction,
+        ]
+      : []),
+  ];
+
+  const formDialogState = addDialog
+    ? {
+        scope: addDialog.scope,
+        initial: undefined,
+        onSave: handleCreate,
+        isSaving: createMutation.isPending,
+        onClose: () => setAddDialog(null),
+      }
+    : editingMemory
+      ? {
+          scope: editingMemory.scope,
+          initial: editingMemory,
+          onSave: handleUpdate,
+          isSaving: updateMutation.isPending,
+          onClose: () => setEditingMemory(null),
+        }
+      : null;
+
+  return (
+    <RouteLayout
+      user={user}
+      datastore={datastore}
+      datastores={datastores}
+      isOperator={isOperator}
+      canSwitchDatastore={canSwitchDatastore}
+      logout={logout}
+    >
+      <PageHeader title="Memories" icon={Brain} actions={<PageHeaderActions actions={headerActions} />} />
+
+      <Tabs value={activeTab} onValueChange={handleTabChange} className="flex flex-col flex-1 min-h-0 overflow-hidden">
+        <ScopeMemoriesTab
+          value="personal"
+          tableState={personalTableState}
+          memories={displayedPersonalMemories}
+          tabs={tabsList}
+          isLoading={isLoading}
+          errorMessage={errorMessage}
+          schemas={schemas}
+          onRowClick={handleRowClick}
+          visibleStatusFilters={[
+            ...alwaysVisibleStatusFilters,
+            "autoCaptured",
+            ...(canManageSharedMemories ? (["promotion"] as const) : []),
+          ]}
+          emptyState={<MemoriesEmptyState onAdd={() => setAddDialog({ scope: GQLMemoryScope.User })} />}
+        />
+
+        {canManageSharedMemories && (
+          <ScopeMemoriesTab
+            value="company"
+            tableState={companyTableState}
+            memories={companyMemories}
+            tabs={tabsList}
+            isLoading={isLoading}
+            errorMessage={errorMessage}
+            schemas={schemas}
+            onRowClick={handleRowClick}
+            emptyState={
+              showCompanyOnboarding ? (
+                <div className="flex items-center justify-center h-full min-h-64 p-5">
+                  <MemoryOnboardingWizard
+                    scope={GQLMemoryScope.Company}
+                    onComplete={() => setShowOrgOnboarding(false)}
+                    onSkip={() => setShowOrgOnboarding(false)}
+                  />
+                </div>
+              ) : (
+                <CompanyMemoriesEmptyState
+                  onAdd={() => setAddDialog({ scope: GQLMemoryScope.Company })}
+                  onSetUp={() => setShowOrgOnboarding(true)}
+                />
+              )
+            }
+          />
+        )}
+
+        {canManageSharedMemories && hasTeams && (
+          <ScopeMemoriesTab
+            value="team"
+            tableState={teamTableState}
+            memories={teamMemories}
+            tabs={tabsList}
+            isLoading={isLoading}
+            errorMessage={errorMessage}
+            schemas={schemas}
+            onRowClick={handleRowClick}
+            emptyState={
+              <GroupMemoriesEmptyState
+                canManageSharedMemories={true}
+                onAdd={() => setAddDialog({ scope: GQLMemoryScope.Team })}
+              />
+            }
+          />
+        )}
+
+        {canManageSharedMemories && (
+          <FilterableTabContent
+            value="schemas"
+            tabs={tabsList}
+            placeholder="Filter schemas…"
+            query={schemasQuery}
+            onQueryChange={setSchemasQuery}
+          >
+            <SchemasTab query={schemasQuery} />
+          </FilterableTabContent>
+        )}
+
+        <FilterableTabContent
+          value="live-context"
+          tabs={tabsList}
+          placeholder="Filter live context…"
+          query={liveContextQuery}
+          onQueryChange={setLiveContextQuery}
+        >
+          <LiveContextTab query={liveContextQuery} />
+        </FilterableTabContent>
+      </Tabs>
+
+      {formDialogState && (
+        <MemoryFormDialog
+          open={true}
+          onOpenChange={(open) => {
+            if (!open) formDialogState.onClose();
+          }}
+          scope={formDialogState.scope}
+          initial={formDialogState.initial}
+          onSave={formDialogState.onSave}
+          isSaving={formDialogState.isSaving}
+          canManageSharedMemories={canManageSharedMemories}
+          schemas={schemas}
+          currentUserId={user.id}
+        />
+      )}
+
+      {movingMemory && (
+        <ChangeScopeDialog
+          open={true}
+          onOpenChange={(open) => {
+            if (!open) setMovingMemory(null);
+          }}
+          memory={movingMemory}
+          canManageSharedMemories={canManageSharedMemories}
+          onSave={handleMove}
+          isSaving={updateMutation.isPending}
+          currentUserId={user.id}
+        />
+      )}
+
+      <RestoreBlockedDialog
+        open={restoreBlocked != null}
+        onOpenChange={(open) => {
+          if (!open) setRestoreBlocked(null);
+        }}
+        blockedByLabel={restoreBlocked?.blockedByLabel ?? null}
+        onConfirm={handleConfirmRestoreBlocked}
+      />
+
+      <ConsolidationReviewDialog
+        open={consolidating}
+        clusters={reviewGroups}
+        isLoading={isFindingRedundancy}
+        isSaving={consolidateMutation.isPending}
+        candidateCount={consolidationCandidates.length}
+        comparedCount={reviewData?.memoryRedundancyReview.comparedCount ?? null}
+        timedOut={reviewData?.memoryRedundancyReview.timedOut ?? false}
+        errorMessage={
+          reviewData?.memoryRedundancyReview.error ?? (reviewError instanceof Error ? reviewError.message : null)
+        }
+        onMerge={handleConsolidate}
+        onClose={() => setConsolidating(false)}
+      />
+    </RouteLayout>
+  );
+}