@manta-eu/react 0.11.0 → 0.13.0

package/src/routes/memories/hooks/useMemoryColumns.tsx

@@ -1,15 +1,21 @@
 import type { GQLMemoryKind } from "@manta-eu/client";
-import { type GQLConflictingMemory, type GQLMemory, type GQLMemorySchema } from "@manta-eu/client";
+import {
+  GQLMemorySchemaStatus,
+  type GQLConflictingMemory,
+  type GQLMemory,
+  type GQLMemorySchemaFieldsFragment,
+} from "@manta-eu/client";
 import { isTrustedUntilExpiringSoon } from "@manta-eu/client/shared/memory-preload-gate";
 import { formatEntityName } from "@manta-eu/client/shared/rdf-namespaces";
 import { isPresent } from "@manta-eu/lib/present";
 import type { ColumnDef } from "@tanstack/react-table";
 import { addDays, format, formatDistanceToNow, isBefore } from "date-fns";
-import { ChevronDown, Clock } from "lucide-react";
+import { Clock } from "lucide-react";
 import type { ReactNode } from "react";
 import { useMemo } from "react";
 import {
   AutoCapturedBadge,
+  autoAssignedNote,
   DuplicateBadge,
   KindBadge,
   MemoryAbout,
@@ -89,18 +95,31 @@ function MaybeTooltip(props: MaybeTooltipProps) {
 type UseMemoryColumnsArgs = {
   canManageSharedMemories?: boolean;
   userId: string;
-  schemas?: GQLMemorySchema[];
+  schemas?: GQLMemorySchemaFieldsFragment[];
   onEdit: (memory: GQLMemory) => void;
   onDelete: (iri: string) => void;
   onMove?: (memory: GQLMemory) => void;
   onRestore?: (iri: string) => void;
   onReconfirm?: (iri: string) => void;
+  onUndoSchemaAssignment?: (iri: string) => void;
+  onWriteRule?: (memory: GQLMemory) => void;
   duplicates?: Map<string, GQLConflictingMemory[]>;
 };
 
 export function useMemoryColumns(args: UseMemoryColumnsArgs): ColumnDef<GQLMemory>[] {
-  const { canManageSharedMemories, userId, schemas, onEdit, onDelete, onMove, onRestore, onReconfirm, duplicates } =
-    args;
+  const {
+    canManageSharedMemories,
+    userId,
+    schemas,
+    onEdit,
+    onDelete,
+    onMove,
+    onRestore,
+    onReconfirm,
+    onUndoSchemaAssignment,
+    onWriteRule,
+    duplicates,
+  } = args;
 
   return useMemo<ColumnDef<GQLMemory>[]>(() => {
     const schemaByIri = new Map(schemas?.map((s) => [s.iri, s]) ?? []);
@@ -163,43 +182,41 @@ export function useMemoryColumns(args: UseMemoryColumnsArgs): ColumnDef<GQLMemor
         filterFn: (row, _columnId, filterValue: GQLMemoryKind) =>
           row.original.memorySubclass === filterValue || row.original.kind === filterValue,
         cell: ({ row }) => {
-          const props = row.original.customProperties as Record<string, string> | null;
-          const filledEntries = props ? Object.entries(props).filter(([, v]) => isPresent(v)) : [];
+          const filledEntries = row.original.customPropertyValues.filter(({ values }) => isPresent(values));
           const schema = row.original.memorySubclass ? schemaByIri.get(row.original.memorySubclass) : undefined;
           const schemaLabel = row.original.memorySubclass
             ? (schema?.label ?? formatEntityName(row.original.memorySubclass))
             : null;
-          const badges = (
-            <>
-              <KindBadge kind={row.original.kind} />
-              <SchemaBadge label={schemaLabel} />
-            </>
+          const autoNote = autoAssignedNote(row.original);
+          const schemaBadge = (
+            <SchemaBadge label={schemaLabel} autoAssigned={autoNote !== null} filledCount={filledEntries.length} />
           );
 
-          if (!isPresent(filledEntries)) {
-            return <div className="flex min-w-36 flex-wrap items-center gap-1.5">{badges}</div>;
+          if (schemaLabel === null || (!isPresent(filledEntries) && autoNote === null)) {
+            return (
+              <div className="flex min-w-36 flex-wrap items-center gap-1.5">
+                <KindBadge kind={row.original.kind} />
+                {schemaBadge}
+              </div>
+            );
           }
           return (
             <div className="flex min-w-36 flex-wrap items-center gap-1.5">
+              <KindBadge kind={row.original.kind} />
               <Tooltip>
                 <TooltipTrigger asChild>
-                  <div className="inline-flex w-fit flex-wrap items-center gap-1.5">
-                    {badges}
-                    <span className="inline-flex items-center gap-0.5 rounded-full px-2 py-0.5 typography-tiny bg-faint border border-muted-border text-muted-foreground">
-                      {filledEntries.length}
-                      <ChevronDown className="size-3" />
-                    </span>
-                  </div>
+                  <span className="inline-flex min-w-0 max-w-full cursor-default">{schemaBadge}</span>
                 </TooltipTrigger>
                 <TooltipContent className="typography-small text-left max-w-sm">
                   <div className="flex flex-col gap-1">
-                    {filledEntries.map(([path, value]) => {
+                    {autoNote && <span className="text-muted-foreground">{autoNote}</span>}
+                    {filledEntries.map(({ path, values }) => {
                       const propDef = schema?.properties.find((p) => p.path === path);
                       const label = propDef?.label ?? formatEntityName(path);
                       return (
                         <div key={path} className="flex items-center gap-1.5">
                           <span className="text-muted-foreground shrink-0 whitespace-nowrap">{label}:</span>
-                          <span className="min-w-0 truncate">{value}</span>
+                          <span className="min-w-0 truncate">{values.join(", ")}</span>
                         </div>
                       );
                     })}
@@ -339,18 +356,35 @@ export function useMemoryColumns(args: UseMemoryColumnsArgs): ColumnDef<GQLMemor
         id: memoryColumnIds.actions,
         enableHiding: false,
         enableSorting: false,
-        cell: ({ row }) => (
-          <MemoryActions
-            memory={row.original}
-            canManageSharedMemories={canManageSharedMemories}
-            onEdit={onEdit}
-            onDelete={onDelete}
-            onMove={onMove}
-            onRestore={onRestore}
-            onReconfirm={onReconfirm}
-          />
-        ),
+        cell: ({ row }) => {
+          const schema = schemaByIri.get(row.original.memorySubclass ?? "");
+          return (
+            <MemoryActions
+              memory={row.original}
+              canManageSharedMemories={canManageSharedMemories}
+              onEdit={onEdit}
+              onDelete={onDelete}
+              onMove={onMove}
+              onRestore={onRestore}
+              onReconfirm={onReconfirm}
+              onUndoSchemaAssignment={onUndoSchemaAssignment}
+              onWriteRule={schema?.status === GQLMemorySchemaStatus.Active ? onWriteRule : undefined}
+            />
+          );
+        },
       },
     ];
-  }, [canManageSharedMemories, userId, schemas, onEdit, onDelete, onMove, onRestore, onReconfirm, duplicates]);
+  }, [
+    canManageSharedMemories,
+    userId,
+    schemas,
+    onEdit,
+    onDelete,
+    onMove,
+    onRestore,
+    onReconfirm,
+    onUndoSchemaAssignment,
+    onWriteRule,
+    duplicates,
+  ]);
 }

package/src/routes/memories/index.tsx

@@ -6,14 +6,16 @@ import {
   useConsolidateMemoriesMutation,
   useMemoriesQuery,
   useMemoryRedundancyReviewQuery,
-  useMemorySchemasQuery,
   useReconfirmMemoryMutation,
   useRestoreMemoryMutation,
+  useUndoMemorySchemaAssignmentMutation,
   useUpdateMemoryMutation,
   type GQLMemory,
-  type GQLMemorySchema,
+  type GQLMemorySchemaFieldsFragment,
+  useMemorySchemaRuleCountsQuery,
 } from "@manta-eu/client";
 import { parseError } from "@manta-eu/client/shared/error-utils";
+import { memoryPreloadConfidenceThreshold } from "@manta-eu/client/shared/memory-preload-gate";
 import { isPresent } from "@manta-eu/lib/present";
 import { useQueryClient } from "@tanstack/react-query";
 import { Archive, Brain, CalendarX, CopyCheck, EyeOff, Plus, RefreshCcw } from "lucide-react";
@@ -29,15 +31,22 @@ 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 { MemoryFormDialog, type MemorySaveResult } from "./components/MemoryFormDialog";
 import { MemoryOnboardingWizard } from "./components/MemoryOnboardingWizard";
 import { RestoreBlockedDialog } from "./components/RestoreBlockedDialog";
+import { RuleDraftDialog } from "./components/RuleDraftDialog";
 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 { MemorySchemaPage } from "./schemas/MemorySchemaPage";
+import { memoryRuleDraft, schemaRuleDraft, type RuleDraftRequest } from "./schemas/schema-rule-context";
+import { ruleCountsFrom } from "./schemas/schema-table";
+import { SchemaTemplatesDialog } from "./schemas/SchemaTemplatesDialog";
+import { useSchemaLifecycle } from "./schemas/useSchemaLifecycle";
+import { useSchemasTab } from "./schemas/useSchemasTab";
 import { Input } from "#components/input/index";
 import { PageHeader, PageHeaderActions, type PageHeaderAction } from "#components/layouts/page/index";
 import { RouteLayout } from "#components/layouts/RouteLayout";
@@ -71,7 +80,7 @@ type ScopeMemoriesTabProps = {
   tabs: ReactNode;
   isLoading: boolean;
   errorMessage: string | null;
-  schemas: GQLMemorySchema[];
+  schemas: GQLMemorySchemaFieldsFragment[];
   onRowClick: (memory: GQLMemory) => void;
   visibleStatusFilters?: StatusFilterKey[];
 };
@@ -155,8 +164,9 @@ export {
   type MemoriesEmptyStateProps,
 } from "./components/EmptyStates";
 export { LoadingSkeleton } from "./components/LoadingSkeleton";
-export { MemoryFormDialog, type MemoryFormDialogProps } from "./components/MemoryFormDialog";
+export { MemoryFormDialog, type MemoryFormDialogProps, type MemorySaveResult } from "./components/MemoryFormDialog";
 export type { MemoryFormState } from "./components/MemoryFields";
+export type { MemoryPropertyValues } from "./memory-property-values";
 
 const tableKeyPersonal = "memories-table-personal";
 const tableKeyCompany = "memories-table-company";
@@ -190,46 +200,52 @@ const tabLabels: Record<ActiveTab, string> = {
 type AddDialogState = { scope: GQLMemoryScope } | null;
 
 export function MemoriesRoute() {
-  const { datastore, datastores, user, logout, isOperator, canManageSharedMemories, canSwitchDatastore } =
-    useAuthContext();
+  const { user, canManageSharedMemories } = 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 schemaTab = useSchemasTab({ canManage: !!canManageSharedMemories });
+  const { schemas, view: schemaView } = schemaTab;
   const {
     data,
     isLoading,
     isFetching,
     refetch,
     error: queriedError,
-  } = useMemoriesQuery(mantaClient, {
-    includeArchived: showArchived,
-    includeOutOfWindow: showOutOfWindow,
-  });
-  const { data: schemasData } = useMemorySchemasQuery(mantaClient);
-  const schemas = schemasData?.memorySchemas.schemas ?? [];
+  } = useMemoriesQuery(
+    mantaClient,
+    { includeArchived: showArchived, includeOutOfWindow: showOutOfWindow },
+    { enabled: schemaView === null },
+  );
   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(
+  const autoCapturedPersonalMemories = useMemo(
     () => personalMemories.filter((m) => m.confidence != null && m.confidence < 1),
     [personalMemories],
   );
+  const needsReviewMemories = useMemo(
+    () => autoCapturedPersonalMemories.filter((m) => (m.confidence ?? 1) < memoryPreloadConfidenceThreshold),
+    [autoCapturedPersonalMemories],
+  );
   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 needsReviewCount = needsReviewMemories.length;
 
   const createMutation = useCreateMemoryMutation(mantaClient);
   const updateMutation = useUpdateMemoryMutation(mantaClient);
   const deleteMutation = useDeleteMemoryMutation(mantaClient);
   const restoreMutation = useRestoreMemoryMutation(mantaClient);
   const reconfirmMutation = useReconfirmMemoryMutation(mantaClient);
+  const undoAssignmentMutation = useUndoMemorySchemaAssignmentMutation(mantaClient);
   const { data: teamsData } = useAvailableTeamsQuery(mantaClient, undefined, { enabled: !!canManageSharedMemories });
   const hasTeams = isPresent(teamsData?.availableTeams.teams);
 
@@ -238,7 +254,7 @@ export function MemoriesRoute() {
       ...(canManageSharedMemories ? (["company"] as ActiveTab[]) : []),
       ...(canManageSharedMemories && hasTeams ? (["team"] as ActiveTab[]) : []),
       "personal",
-      ...(canManageSharedMemories ? (["schemas"] as ActiveTab[]) : []),
+      "schemas",
       "live-context",
     ],
     [canManageSharedMemories, hasTeams],
@@ -252,21 +268,26 @@ export function MemoriesRoute() {
     return availableTabs[0] ?? "personal";
   }, [tabParam, availableTabs]);
 
+  const { data: ruleCountsData } = useMemorySchemaRuleCountsQuery(mantaClient, undefined, {
+    enabled: !!canManageSharedMemories && activeTab === "schemas",
+  });
+  const ruleCounts = useMemo(() => ruleCountsFrom(ruleCountsData?.memorySchemaRuleCounts), [ruleCountsData]);
+
+  const onSchemaPage = schemaView !== null;
   useEffect(() => {
-    if (tabParam !== activeTab) {
+    if (!onSchemaPage && tabParam !== activeTab) {
       setSearchParams({ tab: activeTab }, { replace: true });
     }
-  }, [tabParam, activeTab, setSearchParams]);
+  }, [onSchemaPage, tabParam, activeTab, setSearchParams]);
 
   useEffect(() => {
-    if (unreviewedCount === 0) setUnreviewedOnly(false);
-  }, [unreviewedCount]);
+    if (needsReviewCount === 0) setNeedsReviewOnly(false);
+  }, [needsReviewCount]);
 
   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);
@@ -276,7 +297,7 @@ export function MemoriesRoute() {
     blockedByIri: string;
     blockedByLabel: string | null;
   } | null>(null);
-  const [unreviewedOnly, setUnreviewedOnly] = useState(false);
+  const [needsReviewOnly, setNeedsReviewOnly] = useState(false);
   const [showCompanyOnboarding, setShowOrgOnboarding] = useState(false);
   const invalidate = useCallback(() => {
     void refetch();
@@ -357,7 +378,7 @@ export function MemoriesRoute() {
   const kindFilterResetRef = useRef<((kind: KindFilter) => void) | null>(null);
 
   const handleCreate = useCallback(
-    async (form: MemoryFormState, supersedesMemoryIris?: string[]) => {
+    async (form: MemoryFormState, supersedesMemoryIris?: string[]): Promise<MemorySaveResult> => {
       if (!addDialog) return;
       if (!canManageSharedMemories && addDialog.scope !== GQLMemoryScope.User) return;
       try {
@@ -365,6 +386,8 @@ export function MemoriesRoute() {
           input: buildCreateMemoryInput(form, addDialog.scope, supersedesMemoryIris),
         });
 
+        if (isPresent(result.createMemory.propertyErrors))
+          return { propertyErrors: result.createMemory.propertyErrors };
         if (result.createMemory.error) throw new Error(result.createMemory.error);
 
         toast.success("Memory added");
@@ -379,7 +402,7 @@ export function MemoriesRoute() {
   );
 
   const handleUpdate = useCallback(
-    async (form: MemoryFormState, supersedesMemoryIris?: string[]) => {
+    async (form: MemoryFormState, supersedesMemoryIris?: string[]): Promise<MemorySaveResult> => {
       if (!editingMemory) return;
       if (!canManageSharedMemories && editingMemory.scope !== GQLMemoryScope.User) return;
       try {
@@ -387,6 +410,8 @@ export function MemoriesRoute() {
           input: buildUpdateMemoryInput(editingMemory.iri, form, editingMemory.scope, supersedesMemoryIris),
         });
 
+        if (isPresent(result.updateMemory.propertyErrors))
+          return { propertyErrors: result.updateMemory.propertyErrors };
         if (result.updateMemory.error) throw new Error(result.updateMemory.error);
 
         toast.success("Memory updated");
@@ -451,6 +476,20 @@ export function MemoriesRoute() {
     [reconfirmMutation, invalidate],
   );
 
+  const handleUndoSchemaAssignment = useCallback(
+    async (iri: string) => {
+      try {
+        const result = await undoAssignmentMutation.mutateAsync({ memoryIri: iri });
+        if (result.undoMemorySchemaAssignment.error) throw new Error(result.undoMemorySchemaAssignment.error);
+        toast.success("Schema removed", { description: "Manta won't assign one to this memory again." });
+        invalidate();
+      } catch (e) {
+        reportMutationError(e, "Failed to remove the schema");
+      }
+    },
+    [undoAssignmentMutation, invalidate],
+  );
+
   const handleConfirmRestoreBlocked = useCallback(() => {
     if (!restoreBlocked) return;
     const { iri, blockedByIri, blockedByLabel } = restoreBlocked;
@@ -502,23 +541,39 @@ export function MemoriesRoute() {
     [movingMemory, updateMutation, invalidate, canManageSharedMemories],
   );
 
-  const { duplicates } = useDuplicateDetection(unreviewedPersonalMemories, {
+  const { duplicates } = useDuplicateDetection(autoCapturedPersonalMemories, {
     enabled: activeTab === "personal",
   });
 
+  const [ruleDraft, setRuleDraft] = useState<RuleDraftRequest | null>(null);
+  const schemaLifecycle = useSchemaLifecycle();
+  const handleWriteRule = useCallback(
+    (memory: GQLMemory) => {
+      const schema = schemas.find((candidate) => candidate.iri === memory.memorySubclass);
+      if (schema) setRuleDraft(memoryRuleDraft(schema, memory));
+    },
+    [schemas],
+  );
+  const handleWriteSchemaRule = useCallback(
+    (schema: GQLMemorySchemaFieldsFragment) => setRuleDraft(schemaRuleDraft(schema)),
+    [],
+  );
+
   const columns = useMemoryColumns({
     canManageSharedMemories,
     userId: user.id,
     schemas,
+    onWriteRule: canManageSharedMemories ? handleWriteRule : undefined,
     onEdit: setEditingMemory,
     onDelete: handleDelete,
     onMove: canManageSharedMemories ? setMovingMemory : undefined,
     onRestore: handleRestore,
     onReconfirm: handleReconfirm,
+    onUndoSchemaAssignment: handleUndoSchemaAssignment,
     duplicates,
   });
 
-  const displayedPersonalMemories = unreviewedOnly ? unreviewedPersonalMemories : personalMemories;
+  const displayedPersonalMemories = needsReviewOnly ? needsReviewMemories : personalMemories;
 
   const personalTableState = useMemoryTable(
     tableKeyPersonal,
@@ -539,7 +594,7 @@ export function MemoriesRoute() {
   const tabCounts: Partial<Record<ActiveTab, { count?: number; secondaryCount?: number }>> = {
     company: { count: companyCount },
     team: { count: teamCount },
-    personal: { count: personalCount, secondaryCount: unreviewedCount },
+    personal: { count: personalCount },
   };
   const scopeTabs: ScopeTab<ActiveTab>[] = availableTabs.map((tab) => ({
     value: tab,
@@ -597,17 +652,19 @@ export function MemoriesRoute() {
           } satisfies PageHeaderAction,
         ]
       : []),
-    ...(activeTab === "personal" && unreviewedCount > 0
+    ...(activeTab === "personal" && needsReviewCount > 0
       ? [
           {
-            key: "unreviewed",
-            label: unreviewedOnly ? "All memories" : `Unreviewed (${unreviewedCount})`,
-            variant: unreviewedOnly ? "secondary" : "ghost",
-            active: unreviewedOnly,
-            onClick: () => setUnreviewedOnly((v) => !v),
+            key: "needs-review",
+            label: needsReviewOnly ? "All memories" : `Needs review (${needsReviewCount})`,
+            hint: "Memories Manta saved from chats but was unsure about. They are not used until you open one and save it.",
+            variant: needsReviewOnly ? "secondary" : "ghost",
+            active: needsReviewOnly,
+            onClick: () => setNeedsReviewOnly((v) => !v),
           } satisfies PageHeaderAction,
         ]
       : []),
+    ...(activeTab === "schemas" ? schemaTab.headerActions : []),
     ...(addMemoryButton
       ? [
           {
@@ -638,15 +695,22 @@ export function MemoriesRoute() {
         }
       : null;
 
+  if (schemaView) {
+    return (
+      <RouteLayout>
+        <MemorySchemaPage
+          view={schemaView}
+          schemas={schemas}
+          isLoading={schemaTab.isLoading}
+          errorMessage={schemaTab.errorMessage}
+          canManage={!!canManageSharedMemories}
+        />
+      </RouteLayout>
+    );
+  }
+
   return (
-    <RouteLayout
-      user={user}
-      datastore={datastore}
-      datastores={datastores}
-      isOperator={isOperator}
-      canSwitchDatastore={canSwitchDatastore}
-      logout={logout}
-    >
+    <RouteLayout>
       <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">
@@ -715,17 +779,23 @@ export function MemoriesRoute() {
           />
         )}
 
-        {canManageSharedMemories && (
-          <FilterableTabContent
-            value="schemas"
+        <TabsContent value="schemas" className="flex min-h-0 flex-1 flex-col overflow-hidden">
+          <SchemasTab
             tabs={tabsList}
-            placeholder="Filter schemas…"
-            query={schemasQuery}
-            onQueryChange={setSchemasQuery}
-          >
-            <SchemasTab query={schemasQuery} />
-          </FilterableTabContent>
-        )}
+            schemas={schemaTab.listedSchemas}
+            query={schemaTab.query}
+            onQueryChange={schemaTab.setQuery}
+            isLoading={schemaTab.isLoading}
+            errorMessage={schemaTab.errorMessage}
+            canManage={!!canManageSharedMemories}
+            ruleCounts={ruleCounts}
+            onCreate={schemaTab.openNew}
+            onWriteRule={handleWriteSchemaRule}
+            onArchive={schemaLifecycle.askToArchive}
+            onRestore={schemaLifecycle.restore}
+            onDelete={schemaLifecycle.askToDelete}
+          />
+        </TabsContent>
 
         <FilterableTabContent
           value="live-context"
@@ -738,6 +808,8 @@ export function MemoriesRoute() {
         </FilterableTabContent>
       </Tabs>
 
+      <RuleDraftDialog request={ruleDraft} onClose={() => setRuleDraft(null)} />
+      {schemaLifecycle.dialogs}
       {formDialogState && (
         <MemoryFormDialog
           open={true}
@@ -754,6 +826,8 @@ export function MemoriesRoute() {
         />
       )}
 
+      {canManageSharedMemories && <SchemaTemplatesDialog {...schemaTab.templatesDialog} />}
+
       {movingMemory && (
         <ChangeScopeDialog
           open={true}

package/src/routes/memories/memory-mutation-input.ts

@@ -1,6 +1,7 @@
 import { GQLMemoryScope, type GQLCreateMemoryInput, type GQLUpdateMemoryInput } from "@manta-eu/client";
 import { isPresent } from "@manta-eu/lib/present";
 import type { MemoryFormState } from "./components/MemoryFields";
+import { cleanPropertyValues } from "./memory-property-values";
 
 export function deriveLabel(description: string): string {
   const words = description.trim().split(/\s+/).filter(Boolean);
@@ -28,7 +29,9 @@ export function buildCreateMemoryInput(
     description: form.description ?? null,
     scope,
     ...(form.memorySubclass ? { memorySubclass: form.memorySubclass } : {}),
-    ...(isPresent(form.customProperties) ? { customProperties: form.customProperties } : {}),
+    ...(form.memorySubclass && isPresent(form.customProperties)
+      ? { customProperties: cleanPropertyValues(form.customProperties) }
+      : {}),
     ...(form.memoryValidUntil != null ? { memoryValidUntil: form.memoryValidUntil } : {}),
     ...(form.memoryTrustedUntil != null ? { memoryTrustedUntil: form.memoryTrustedUntil } : {}),
     ...(supersedesMemoryIris !== undefined ? { supersedesMemoryIris } : {}),
@@ -48,7 +51,7 @@ export function buildUpdateMemoryInput(
     description: form.description,
     memoryValidUntil: form.memoryValidUntil,
     memoryTrustedUntil: form.memoryTrustedUntil,
-    customProperties: form.customProperties,
+    customProperties: cleanPropertyValues(form.customProperties),
     ...(form.memorySubclass !== undefined ? { memorySubclass: form.memorySubclass } : {}),
     ...(isPresent(supersedesMemoryIris) ? { supersedesMemoryIris } : {}),
   };

package/src/routes/memories/memory-property-values.ts

@@ -0,0 +1,83 @@
+import type {
+  GQLMemory,
+  GQLMemoryPropertyProblem,
+  GQLMemorySchemaFieldsFragment,
+  GQLMemorySchemaPropertyFieldsFragment,
+} from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+
+export type MemoryPropertyValues = Record<string, string[]>;
+
+export type MemoryPropertyErrors = Record<string, string>;
+
+export function writableProperties(
+  schema: GQLMemorySchemaFieldsFragment | null | undefined,
+): GQLMemorySchemaPropertyFieldsFragment[] {
+  return [...(schema?.properties ?? [])].filter((property) => !property.computed).sort((a, b) => a.order - b.order);
+}
+
+export function propertyDefaults(schema: GQLMemorySchemaFieldsFragment): MemoryPropertyValues {
+  return Object.fromEntries(
+    writableProperties(schema).flatMap((property) =>
+      property.defaultValue != null ? [[property.path, [property.defaultValue]]] : [],
+    ),
+  );
+}
+
+export function computedProperties(
+  schema: GQLMemorySchemaFieldsFragment | null | undefined,
+): GQLMemorySchemaPropertyFieldsFragment[] {
+  return [...(schema?.properties ?? [])].filter((property) => property.computed).sort((a, b) => a.order - b.order);
+}
+
+export function propertyValuesFromMemory(memory: Pick<GQLMemory, "customPropertyValues">): MemoryPropertyValues {
+  return Object.fromEntries(memory.customPropertyValues.map(({ path, values }) => [path, [...values]]));
+}
+
+export function cleanPropertyValues(values: MemoryPropertyValues): MemoryPropertyValues {
+  return Object.fromEntries(
+    Object.entries(values).map(([path, given]) => [path, given.map((value) => value.trim()).filter(isPresent)]),
+  );
+}
+
+export function filledPropertyCount(
+  schema: GQLMemorySchemaFieldsFragment | null | undefined,
+  values: MemoryPropertyValues,
+): number {
+  const cleaned = cleanPropertyValues(values);
+  return writableProperties(schema).filter((property) => isPresent(cleaned[property.path] ?? [])).length;
+}
+
+export function missingRequiredProperties(
+  schema: GQLMemorySchemaFieldsFragment | null | undefined,
+  values: MemoryPropertyValues,
+): MemoryPropertyErrors {
+  const cleaned = cleanPropertyValues(values);
+  return Object.fromEntries(
+    writableProperties(schema)
+      .filter((property) => property.required && !isPresent(cleaned[property.path] ?? []))
+      .map((property) => [property.path, `${property.label} is required`]),
+  );
+}
+
+export function propertyErrorsByPath(problems: readonly GQLMemoryPropertyProblem[]): MemoryPropertyErrors {
+  const byPath: MemoryPropertyErrors = {};
+  for (const problem of problems) {
+    const message = `${problem.label ?? "This value"} ${problem.message}`;
+    byPath[problem.path] = byPath[problem.path] ? `${byPath[problem.path]}; ${problem.message}` : message;
+  }
+  return byPath;
+}
+
+// An edit sends only what it changed, so a stored value a later constraint would refuse does not block it.
+export function changedPropertyValues(
+  current: MemoryPropertyValues,
+  initial: MemoryPropertyValues,
+): MemoryPropertyValues {
+  const cleanedInitial = cleanPropertyValues(initial);
+  return Object.fromEntries(
+    Object.entries(cleanPropertyValues(current)).filter(
+      ([path, values]) => JSON.stringify(values) !== JSON.stringify(cleanedInitial[path] ?? []),
+    ),
+  );
+}