@manta-eu/react 0.1.0 → 0.1.1

package/dist/routes/memories/hooks/useMemoryTable.js

@@ -0,0 +1,121 @@
+import { isMemoryPreloaded, isNeverUsed, needsTrustReview, parseMemoryDate, } from "@manta-eu/client/shared/memory-preload-gate";
+import { useReactTable } from "@tanstack/react-table";
+import { differenceInCalendarDays } from "date-fns";
+import { useCallback, useMemo, useState } from "react";
+import { match } from "ts-pattern";
+import { useDebounceValue, useLocalStorage } from "usehooks-ts";
+import { isTrustExpired } from "../expiry-utils.js";
+import { memoryColumnIds } from "./useMemoryColumns.js";
+import { createTableConfig, useTableState } from "#components/table/index";
+const defaultStatusFilters = {
+    autoCaptured: false,
+    hideStale: false,
+    promotion: false,
+    deadWeight: false,
+    unused: false,
+    needsReview: false,
+};
+const noColumnVisibility = {};
+const isAutoCaptured = (memory) => memory.confidence != null && memory.confidence < 1;
+const deadWeightUntouchedDays = 90;
+const isDeadWeight = (memory, now) => {
+    const lastTouched = parseMemoryDate(memory.memoryLastUsedAt) ?? parseMemoryDate(memory.extractedAt);
+    return (isMemoryPreloaded(memory, now) &&
+        lastTouched != null &&
+        differenceInCalendarDays(now, lastTouched) >= deadWeightUntouchedDays);
+};
+export function filterMemories(data, criteria, now = new Date()) {
+    let result = data;
+    if (criteria.search.trim()) {
+        const q = criteria.search.toLowerCase();
+        result = result.filter((m) => m.label.toLowerCase().includes(q) || (m.description ?? "").toLowerCase().includes(q));
+    }
+    if (criteria.importance !== 0) {
+        result = result.filter((m) => m.importance === criteria.importance);
+    }
+    if (criteria.autoCaptured) {
+        result = result.filter(isAutoCaptured);
+    }
+    if (criteria.hideStale) {
+        result = result.filter((m) => !isTrustExpired(m.memoryTrustedUntil, now));
+    }
+    // Promoting a stale memory would push an unconfirmed fact onto everyone in the company.
+    if (criteria.promotion) {
+        result = result.filter((m) => isAutoCaptured(m) && !isTrustExpired(m.memoryTrustedUntil, now));
+    }
+    if (criteria.deadWeight) {
+        result = result.filter((m) => isDeadWeight(m, now));
+    }
+    if (criteria.unused) {
+        result = result.filter((m) => isNeverUsed(m, now));
+    }
+    if (criteria.needsReview) {
+        result = result.filter((m) => needsTrustReview(m, now));
+    }
+    return match(criteria.schema)
+        .with("ALL", () => result)
+        .with("NONE", () => result.filter((m) => m.memorySubclass == null))
+        .otherwise((iri) => result.filter((m) => m.memorySubclass === iri));
+}
+export function useMemoryTable(tableKey, data, columns, initialSorting = [], initialColumnVisibility) {
+    const [searchQuery, setSearchQuery] = useState("");
+    const [debouncedSearch] = useDebounceValue(searchQuery, 200);
+    const [importanceFilter, setImportanceFilter] = useState(0);
+    const [statusFilters, setStatusFilters] = useState(defaultStatusFilters);
+    const [schemaFilter, setSchemaFilter] = useState("ALL");
+    const onStatusFilterChange = useCallback((key, value) => {
+        setStatusFilters((prev) => ({ ...prev, [key]: value }));
+    }, []);
+    const filteredData = useMemo(() => filterMemories(data, {
+        search: debouncedSearch,
+        importance: importanceFilter,
+        autoCaptured: statusFilters.autoCaptured,
+        hideStale: statusFilters.hideStale,
+        promotion: statusFilters.promotion,
+        deadWeight: statusFilters.deadWeight,
+        unused: statusFilters.unused,
+        needsReview: statusFilters.needsReview,
+        schema: schemaFilter,
+    }), [data, debouncedSearch, importanceFilter, statusFilters, schemaFilter]);
+    const { sorting, setSorting, columnFilters, setColumnFilters, columnOrder, setColumnOrder, rowSelection, setRowSelection, pagination, setPagination, } = useTableState(tableKey, initialSorting, { useLocalState: true, defaultPageSize: 12 });
+    // Keyed distinctly from useTableState so they don't collide in localStorage.
+    const [storedVisibility, setColumnVisibility] = useLocalStorage(`${tableKey}-visibility`, initialColumnVisibility ?? noColumnVisibility);
+    const columnVisibility = useMemo(() => ({ ...initialColumnVisibility, ...storedVisibility }), [initialColumnVisibility, storedVisibility]);
+    const table = useReactTable(createTableConfig({
+        data: filteredData,
+        columns,
+        columnPinning: { left: [memoryColumnIds.label], right: [memoryColumnIds.actions] },
+        sorting,
+        setSorting,
+        columnFilters,
+        setColumnFilters,
+        columnVisibility,
+        setColumnVisibility,
+        columnOrder,
+        setColumnOrder,
+        rowSelection,
+        setRowSelection,
+        pagination,
+        setPagination,
+    }));
+    const kindFilter = columnFilters.find((f) => f.id === memoryColumnIds.kind)?.value ?? "ALL";
+    const handleKindFilterChange = useCallback((kind) => {
+        setColumnFilters((prev) => [
+            ...prev.filter((f) => f.id !== memoryColumnIds.kind),
+            ...(kind !== "ALL" ? [{ id: memoryColumnIds.kind, value: kind }] : []),
+        ]);
+    }, [setColumnFilters]);
+    return {
+        table,
+        kindFilter,
+        onKindFilterChange: handleKindFilterChange,
+        schemaFilter,
+        onSchemaFilterChange: setSchemaFilter,
+        searchQuery,
+        onSearchQueryChange: setSearchQuery,
+        importanceFilter,
+        onImportanceFilterChange: setImportanceFilter,
+        statusFilters,
+        onStatusFilterChange,
+    };
+}

package/dist/routes/memories/index.d.ts

@@ -0,0 +1,11 @@
+import { deriveLabel } from "./memory-mutation-input.js";
+export { deriveLabel };
+export { KindBadge, ScopeBadge, preloadBadgeContent, type KindBadgeProps, type PreloadBadgeContent, type PreloadBadgeTone, type ScopeBadgeProps, } from "./components/badges.js";
+export { formatHorizonDate, formatHorizonRelative, memoryHorizon, type MemoryHorizon } from "./expiry-utils.js";
+export { filterMemories, type ImportanceFilter, type MemoryFilterCriteria, type SchemaFilter, } from "./hooks/useMemoryTable.js";
+export { GroupMemoriesEmptyState, MemoriesEmptyState, type GroupMemoriesEmptyStateProps, type MemoriesEmptyStateProps, } from "./components/EmptyStates.js";
+export { LoadingSkeleton } from "./components/LoadingSkeleton.js";
+export { MemoryFormDialog, type MemoryFormDialogProps } from "./components/MemoryFormDialog.js";
+export type { MemoryFormState } from "./components/MemoryFields.js";
+export declare function MemoriesRoute(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/routes/memories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routes/memories/index.tsx"],"names":[],"mappings":"AAuCA,OAAO,EAAkD,WAAW,EAAE,MAAM,yBAAyB,CAAC;AA8FtG,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EACL,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EACL,cAAc,EACd,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,GAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAC7F,YAAY,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAiCjE,wBAAgB,aAAa,4CAylB5B"}

package/dist/routes/memories/index.js

@@ -0,0 +1,472 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GQLMemoryScope, useAvailableTeamsQuery, useCreateMemoryMutation, useDeleteMemoryMutation, useConsolidateMemoriesMutation, useMemoriesQuery, useMemoryRedundancyReviewQuery, useMemorySchemasQuery, useReconfirmMemoryMutation, useRestoreMemoryMutation, useUpdateMemoryMutation, } 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 { 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.js";
+import { ConsolidationReviewDialog } from "./components/ConsolidationReviewDialog.js";
+import { GroupMemoriesEmptyState, MemoriesEmptyState, CompanyMemoriesEmptyState } from "./components/EmptyStates.js";
+import { LiveContextTab } from "./components/LiveContextTab.js";
+import { MemoriesTabPanel } from "./components/MemoriesTabPanel.js";
+import { MemoryFormDialog } from "./components/MemoryFormDialog.js";
+import { MemoryOnboardingWizard } from "./components/MemoryOnboardingWizard.js";
+import { RestoreBlockedDialog } from "./components/RestoreBlockedDialog.js";
+import { SchemasTab } from "./components/SchemasTab.js";
+import { useDuplicateDetection } from "./hooks/useDuplicateDetection.js";
+import { liveContextQueryKey } from "./hooks/useLiveContext.js";
+import { useMemoryColumns } from "./hooks/useMemoryColumns.js";
+import { useMemoryTable } from "./hooks/useMemoryTable.js";
+import { buildCreateMemoryInput, buildUpdateMemoryInput, deriveLabel } from "./memory-mutation-input.js";
+import { Input } from "#components/input/index";
+import { PageHeader, PageHeaderActions } from "#components/layouts/page/index";
+import { RouteLayout } from "#components/layouts/RouteLayout";
+import { ScopeTabs } 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, fallbackMessage) {
+    const err = parseError(e, fallbackMessage);
+    toast.error(err.message, { description: err.description });
+}
+function addMemoryButtonConfig(tab) {
+    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);
+}
+const alwaysVisibleStatusFilters = ["hideStale", "deadWeight", "unused", "needsReview"];
+function ScopeMemoriesTab(props) {
+    const { value, tableState, memories, emptyState, visibleStatusFilters = alwaysVisibleStatusFilters, ...panelProps } = props;
+    return (_jsx(TabsContent, { value: value, className: "flex flex-col flex-1 min-h-0 overflow-hidden", children: _jsx(MemoriesTabPanel, { ...panelProps, ...tableState, memories: memories, emptyState: emptyState, visibleStatusFilters: visibleStatusFilters }) }));
+}
+function FilterableTabContent(props) {
+    const { value, tabs, placeholder, query, onQueryChange, children } = props;
+    return (_jsxs(TabsContent, { value: value, className: "flex flex-col flex-1 min-h-0 overflow-hidden", children: [_jsx("div", { className: "border-b border-muted-border px-5 py-3 shrink-0", children: _jsxs("div", { className: "flex min-w-0 flex-col gap-3 2xl:flex-row 2xl:items-center", children: [_jsx("div", { className: "min-w-0 2xl:shrink", children: tabs }), _jsx(Input, { containerClassName: "w-auto min-w-48 sm:w-64", type: "search", variant: "search", placeholder: placeholder, value: query, onChange: (e) => onQueryChange(e.target.value) })] }) }), _jsx("div", { className: "flex-1 overflow-auto p-5", children: children })] }));
+}
+export { deriveLabel };
+export { KindBadge, ScopeBadge, preloadBadgeContent, } from "./components/badges.js";
+export { formatHorizonDate, formatHorizonRelative, memoryHorizon } from "./expiry-utils.js";
+export { filterMemories, } from "./hooks/useMemoryTable.js";
+export { GroupMemoriesEmptyState, MemoriesEmptyState, } from "./components/EmptyStates.js";
+export { LoadingSkeleton } from "./components/LoadingSkeleton.js";
+export { MemoryFormDialog } from "./components/MemoryFormDialog.js";
+const tableKeyPersonal = "memories-table-personal";
+const tableKeyCompany = "memories-table-company";
+const tableKeyGroup = "memories-table-group";
+const emptyMemories = [];
+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(groups, merged) {
+    if (merged.size === 0)
+        return [...groups];
+    return groups.filter((group) => !group.memories.some((memory) => merged.has(memory.iri)));
+}
+const tabLabels = {
+    company: "Company",
+    team: "Team",
+    personal: "Personal",
+    schemas: "Schemas",
+    "live-context": "Live Context",
+};
+export function MemoriesRoute() {
+    const { datastore, datastores, user, logout, isOperator, 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: !!isOperator });
+    const hasTeams = isPresent(teamsData?.availableTeams.teams);
+    const availableTabs = useMemo(() => [
+        ...(isOperator ? ["company"] : []),
+        ...(isOperator && hasTeams ? ["team"] : []),
+        "personal",
+        ...(isOperator ? ["schemas"] : []),
+        "live-context",
+    ], [isOperator, hasTeams]);
+    const [searchParams, setSearchParams] = useSearchParams();
+    const tabParam = searchParams.get("tab");
+    const activeTab = useMemo(() => {
+        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) {
+        setSearchParams({ tab }, { replace: true });
+    }
+    const [schemasQuery, setSchemasQuery] = useState("");
+    const [liveContextQuery, setLiveContextQuery] = useState("");
+    const [addDialog, setAddDialog] = useState(null);
+    const [editingMemory, setEditingMemory] = useState(null);
+    const [movingMemory, setMovingMemory] = useState(null);
+    const [restoreBlocked, setRestoreBlocked] = useState(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(() => new Set());
+    const applyMerge = useCallback(async (decision) => {
+        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" })),
+            ...(review?.abstractions ?? []).map((a) => ({ ...a, kind: "pattern" })),
+        ];
+    }, [reviewData]);
+    const reviewGroups = unmergedGroups(reviewProposals, mergedIris);
+    const handleConsolidate = useCallback(async (decision) => {
+        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(null);
+    const handleCreate = useCallback(async (form, supersedesMemoryIris) => {
+        if (!addDialog)
+            return;
+        if (!isOperator && 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, isOperator]);
+    const handleUpdate = useCallback(async (form, supersedesMemoryIris) => {
+        if (!editingMemory)
+            return;
+        if (!isOperator && 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, isOperator]);
+    const handleDelete = useCallback(async (iri) => {
+        const target = allMemories.find((m) => m.iri === iri);
+        if (!isOperator && 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, isOperator, allMemories]);
+    const handleRestore = useCallback(async (iri) => {
+        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) => {
+        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, newTeams, supersedesMemoryIris) => {
+        if (!movingMemory)
+            return;
+        if (!isOperator)
+            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, isOperator]);
+    const { duplicates } = useDuplicateDetection(unreviewedPersonalMemories, {
+        enabled: activeTab === "personal",
+    });
+    const columns = useMemoryColumns({
+        isOperator,
+        userId: user.id,
+        schemas,
+        onEdit: setEditingMemory,
+        onDelete: handleDelete,
+        onMove: isOperator ? 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) => {
+        if (m.supersededBy == null)
+            setEditingMemory(m);
+    }, []);
+    const tabCounts = {
+        company: { count: companyCount },
+        team: { count: teamCount },
+        personal: { count: personalCount, secondaryCount: unreviewedCount },
+    };
+    const scopeTabs = availableTabs.map((tab) => ({
+        value: tab,
+        label: tabLabels[tab],
+        ...tabCounts[tab],
+    }));
+    const tabsList = _jsx(ScopeTabs, { tabs: scopeTabs, activeValue: activeTab, isLoading: isLoading });
+    const addMemoryButton = addMemoryButtonConfig(activeTab);
+    const canShowArchived = activeTab === "personal" || (isOperator && (activeTab === "company" || activeTab === "team"));
+    const headerActions = [
+        {
+            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),
+                },
+                {
+                    key: "out-of-window",
+                    label: showOutOfWindow ? "Hide expired" : "Show expired",
+                    icon: showOutOfWindow ? EyeOff : CalendarX,
+                    variant: "secondary",
+                    active: showOutOfWindow,
+                    onClick: () => setShowOutOfWindow((v) => !v),
+                },
+            ]
+            : []),
+        ...(canShowArchived
+            ? [
+                {
+                    key: "consolidate",
+                    label: "Review redundancy",
+                    icon: CopyCheck,
+                    variant: "secondary",
+                    onClick: () => {
+                        setMergedIris(new Set());
+                        setConsolidating(true);
+                    },
+                },
+            ]
+            : []),
+        ...(activeTab === "personal" && unreviewedCount > 0
+            ? [
+                {
+                    key: "unreviewed",
+                    label: unreviewedOnly ? "All memories" : `Unreviewed (${unreviewedCount})`,
+                    variant: unreviewedOnly ? "secondary" : "ghost",
+                    active: unreviewedOnly,
+                    onClick: () => setUnreviewedOnly((v) => !v),
+                },
+            ]
+            : []),
+        ...(addMemoryButton
+            ? [
+                {
+                    key: "add",
+                    label: addMemoryButton.label,
+                    icon: Plus,
+                    onClick: () => setAddDialog({ scope: addMemoryButton.scope }),
+                },
+            ]
+            : []),
+    ];
+    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 (_jsxs(RouteLayout, { user: user, datastore: datastore, datastores: datastores, isOperator: isOperator, canSwitchDatastore: canSwitchDatastore, logout: logout, children: [_jsx(PageHeader, { title: "Memories", icon: Brain, actions: _jsx(PageHeaderActions, { actions: headerActions }) }), _jsxs(Tabs, { value: activeTab, onValueChange: handleTabChange, className: "flex flex-col flex-1 min-h-0 overflow-hidden", children: [_jsx(ScopeMemoriesTab, { value: "personal", tableState: personalTableState, memories: displayedPersonalMemories, tabs: tabsList, isLoading: isLoading, errorMessage: errorMessage, schemas: schemas, onRowClick: handleRowClick, visibleStatusFilters: [
+                            ...alwaysVisibleStatusFilters,
+                            "autoCaptured",
+                            ...(isOperator ? ["promotion"] : []),
+                        ], emptyState: _jsx(MemoriesEmptyState, { isOperator: isOperator, onAdd: () => setAddDialog({ scope: GQLMemoryScope.User }) }) }), isOperator && (_jsx(ScopeMemoriesTab, { value: "company", tableState: companyTableState, memories: companyMemories, tabs: tabsList, isLoading: isLoading, errorMessage: errorMessage, schemas: schemas, onRowClick: handleRowClick, emptyState: showCompanyOnboarding ? (_jsx("div", { className: "flex items-center justify-center h-full min-h-64 p-5", children: _jsx(MemoryOnboardingWizard, { scope: GQLMemoryScope.Company, onComplete: () => setShowOrgOnboarding(false), onSkip: () => setShowOrgOnboarding(false) }) })) : (_jsx(CompanyMemoriesEmptyState, { onAdd: () => setAddDialog({ scope: GQLMemoryScope.Company }), onSetUp: () => setShowOrgOnboarding(true) })) })), isOperator && hasTeams && (_jsx(ScopeMemoriesTab, { value: "team", tableState: teamTableState, memories: teamMemories, tabs: tabsList, isLoading: isLoading, errorMessage: errorMessage, schemas: schemas, onRowClick: handleRowClick, emptyState: _jsx(GroupMemoriesEmptyState, { isOperator: true, onAdd: () => setAddDialog({ scope: GQLMemoryScope.Team }) }) })), isOperator && (_jsx(FilterableTabContent, { value: "schemas", tabs: tabsList, placeholder: "Filter schemas\u2026", query: schemasQuery, onQueryChange: setSchemasQuery, children: _jsx(SchemasTab, { query: schemasQuery }) })), _jsx(FilterableTabContent, { value: "live-context", tabs: tabsList, placeholder: "Filter live context\u2026", query: liveContextQuery, onQueryChange: setLiveContextQuery, children: _jsx(LiveContextTab, { query: liveContextQuery }) })] }), formDialogState && (_jsx(MemoryFormDialog, { open: true, onOpenChange: (open) => {
+                    if (!open)
+                        formDialogState.onClose();
+                }, scope: formDialogState.scope, initial: formDialogState.initial, onSave: formDialogState.onSave, isSaving: formDialogState.isSaving, isOperator: isOperator, schemas: schemas, currentUserId: user.id })), movingMemory && (_jsx(ChangeScopeDialog, { open: true, onOpenChange: (open) => {
+                    if (!open)
+                        setMovingMemory(null);
+                }, memory: movingMemory, isOperator: isOperator, onSave: handleMove, isSaving: updateMutation.isPending, currentUserId: user.id })), _jsx(RestoreBlockedDialog, { open: restoreBlocked != null, onOpenChange: (open) => {
+                    if (!open)
+                        setRestoreBlocked(null);
+                }, blockedByLabel: restoreBlocked?.blockedByLabel ?? null, onConfirm: handleConfirmRestoreBlocked }), _jsx(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) })] }));
+}

package/dist/routes/memories/memory-form-validation.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { FormErrors, MemoryFormState } from "./components/MemoryFields.js";
+export declare const descriptionSchema: z.ZodString;
+export declare const labelRequiredSchema: z.ZodString;
+export declare const labelOptionalSchema: z.ZodString;
+export declare const teamsRequiredSchema: z.ZodArray<z.ZodString>;
+export declare function validateMemoryForm(form: MemoryFormState, isEdit: boolean, isTeam: boolean): FormErrors;
+//# sourceMappingURL=memory-form-validation.d.ts.map

package/dist/routes/memories/memory-form-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-form-validation.d.ts","sourceRoot":"","sources":["../../../src/routes/memories/memory-form-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE7E,eAAO,MAAM,iBAAiB,aAO3B,CAAC;AACJ,eAAO,MAAM,mBAAmB,aAIoB,CAAC;AACrD,eAAO,MAAM,mBAAmB,aAA+D,CAAC;AAChG,eAAO,MAAM,mBAAmB,yBAAyD,CAAC;AAE1F,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,UAAU,CAuBtG"}

package/dist/routes/memories/memory-form-validation.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export const descriptionSchema = z
+    .string()
+    .trim()
+    .min(1, "Description is required")
+    .max(1000, "Description must be 1000 characters or fewer - memories load into every conversation, so keep them focused. Split longer context into separate memories.");
+export const labelRequiredSchema = z
+    .string()
+    .trim()
+    .min(1, "Label is required")
+    .max(100, "Label must be 100 characters or fewer");
+export const labelOptionalSchema = z.string().max(100, "Label must be 100 characters or fewer");
+export const teamsRequiredSchema = z.array(z.string()).min(1, "Select at least one team");
+export function validateMemoryForm(form, isEdit, isTeam) {
+    const errors = {};
+    const descResult = descriptionSchema.safeParse(form.description ?? "");
+    if (!descResult.success)
+        errors.description = descResult.error.issues[0]?.message;
+    const labelResult = (isEdit ? labelRequiredSchema : labelOptionalSchema).safeParse(form.label);
+    if (!labelResult.success)
+        errors.label = labelResult.error.issues[0]?.message;
+    if (isTeam) {
+        const teamsResult = teamsRequiredSchema.safeParse(form.teams);
+        if (!teamsResult.success)
+            errors.teams = teamsResult.error.issues[0]?.message;
+    }
+    if (form.memoryTrustedUntil != null &&
+        form.memoryValidUntil != null &&
+        new Date(form.memoryTrustedUntil) > new Date(form.memoryValidUntil)) {
+        errors.memoryTrustedUntil = "Trusted until cannot be later than Valid until.";
+    }
+    return errors;
+}