@manta-eu/react 0.1.0 → 0.1.1

package/dist/routes/memories/components/MemoryOnboardingWizard.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GQLMemoryKind, useCreateMemoryMutation, useMemoriesQuery } from "@manta-eu/client";
+import { parseError } from "@manta-eu/client/shared/error-utils";
+import { userManualMemorySource } from "@manta-eu/client/shared/memory-sources";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQueryClient } from "@tanstack/react-query";
+import { ArrowLeft, ArrowRight, Brain, Check } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+import { Button } from "#components/button/index";
+import { Textarea } from "#components/input/index";
+import { useMantaClient } from "#providers/index";
+const wizardSteps = [
+    {
+        id: "objectives",
+        kind: GQLMemoryKind.Objective,
+        label: "What are your primary objectives?",
+        hint: "Manta will keep these in mind when making recommendations and generating plans.",
+        placeholder: "e.g. Grow revenue by 30% this quarter, reduce customer acquisition cost below $50",
+        memoryLabel: "Primary objective",
+    },
+    {
+        id: "facts",
+        kind: GQLMemoryKind.Fact,
+        label: "What key facts should Manta always know?",
+        hint: "Background context that shapes every conversation - about you, your team, or your business.",
+        placeholder: "e.g. We sell premium skincare products, our main market is the US, average order value ~$80",
+        memoryLabel: "Key fact",
+    },
+    {
+        id: "preferences",
+        kind: GQLMemoryKind.Preference,
+        label: "How do you prefer Manta to communicate?",
+        hint: "This shapes the style and format of every response.",
+        placeholder: "e.g. Concise bullet points with key numbers upfront, avoid jargon, flag risks explicitly",
+        memoryLabel: "Communication preference",
+    },
+];
+export function MemoryOnboardingWizard(props) {
+    const { scope, onComplete, onSkip } = props;
+    const { mantaClient } = useMantaClient();
+    const queryClient = useQueryClient();
+    const createMutation = useCreateMemoryMutation(mantaClient);
+    const [currentStep, setCurrentStep] = useState(0);
+    const [answers, setAnswers] = useState({});
+    const [isSaving, setIsSaving] = useState(false);
+    const [isDone, setIsDone] = useState(false);
+    const textareaRef = useRef(null);
+    const step = wizardSteps[currentStep];
+    const currentAnswer = step ? (answers[step.id] ?? "") : "";
+    const isLast = currentStep === wizardSteps.length - 1;
+    const progress = ((currentStep + 1) / wizardSteps.length) * 100;
+    const handleAnswer = useCallback((value) => {
+        if (!step)
+            return;
+        setAnswers((prev) => ({ ...prev, [step.id]: value }));
+    }, [step]);
+    const handleNext = useCallback(() => {
+        if (!isLast)
+            setCurrentStep((s) => s + 1);
+    }, [isLast]);
+    const handleBack = useCallback(() => {
+        setCurrentStep((s) => Math.max(0, s - 1));
+    }, []);
+    useEffect(() => {
+        textareaRef.current?.focus();
+    }, [currentStep]);
+    const handleFinish = useCallback(async () => {
+        setIsSaving(true);
+        try {
+            const stepsWithAnswers = wizardSteps.filter((s) => isPresent(answers[s.id]));
+            await Promise.all(stepsWithAnswers.map((s) => createMutation.mutateAsync({
+                input: {
+                    label: s.memoryLabel,
+                    description: answers[s.id],
+                    kind: s.kind,
+                    memorySource: userManualMemorySource,
+                    ...(scope ? { scope } : {}),
+                },
+            })));
+            void queryClient.invalidateQueries({ queryKey: useMemoriesQuery.getKey() });
+            setIsDone(true);
+            toast.success(`${stepsWithAnswers.length} memories created`);
+        }
+        catch (e) {
+            const err = parseError(e, "Failed to save memories");
+            toast.error(err.message, { description: err.description });
+        }
+        finally {
+            setIsSaving(false);
+        }
+    }, [answers, createMutation, queryClient, scope]);
+    if (isDone) {
+        return (_jsxs("div", { className: "flex flex-col items-center gap-4 py-8 text-center", children: [_jsx("div", { className: "flex size-12 items-center justify-center rounded-full bg-success/10", children: _jsx(Check, { className: "size-6 text-success" }) }), _jsxs("div", { className: "space-y-1", children: [_jsx("p", { className: "typography-large-body-semibold", children: "Memories set up!" }), _jsx("p", { className: "typography-small text-muted-foreground", children: "Manta will now use these in every conversation." })] }), _jsx(Button, { onClick: onComplete, children: "View my memories" })] }));
+    }
+    if (!step)
+        return null;
+    return (_jsxs("div", { className: "flex flex-col gap-6 max-w-xl w-full", children: [_jsxs("div", { className: "flex items-center gap-3", children: [_jsx(Brain, { className: "size-5 text-muted-foreground shrink-0" }), _jsxs("div", { className: "flex-1", children: [_jsx("p", { className: "typography-caption-medium", children: "Set up Manta's memory" }), _jsxs("p", { className: "typography-tiny text-muted-foreground", children: ["Step ", currentStep + 1, " of ", wizardSteps.length] })] }), _jsx("button", { onClick: onSkip, className: "typography-small text-muted-foreground hover:text-default-foreground transition-colors", children: "Skip" })] }), _jsx("div", { className: "h-1 bg-muted rounded-full overflow-hidden", children: _jsx("div", { className: "h-full bg-primary rounded-full transition-all duration-300", style: { width: `${progress}%` } }) }), _jsxs("div", { className: "flex flex-col gap-2", children: [_jsx("label", { className: "typography-large-body-semibold", children: step.label }), _jsx("p", { className: "typography-small text-muted-foreground", children: step.hint }), _jsx(Textarea, { ref: textareaRef, id: "memory-onboarding-answer", label: step.label, hideLabel: true, placeholder: step.placeholder, value: currentAnswer, onChange: (e) => handleAnswer(e.target.value), minRows: 3 })] }), _jsxs("div", { className: "flex gap-2 justify-between", children: [_jsx(Button, { variant: "ghost", onClick: handleBack, disabled: currentStep === 0, icon: ArrowLeft, children: "Back" }), isLast ? (_jsx(Button, { onClick: handleFinish, disabled: isSaving, icon: Check, children: isSaving ? "Saving…" : "Save memories" })) : (_jsx(Button, { onClick: handleNext, icon: ArrowRight, children: "Next" }))] })] }));
+}

package/dist/routes/memories/components/RestoreBlockedDialog.d.ts

@@ -0,0 +1,8 @@
+export type RestoreBlockedDialogProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    blockedByLabel: string | null;
+    onConfirm: () => void;
+};
+export declare function RestoreBlockedDialog(props: RestoreBlockedDialogProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RestoreBlockedDialog.d.ts.map

package/dist/routes/memories/components/RestoreBlockedDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestoreBlockedDialog.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/components/RestoreBlockedDialog.tsx"],"names":[],"mappings":"AAWA,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,2CAsBpE"}

package/dist/routes/memories/components/RestoreBlockedDialog.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, } from "#components/alert-dialog/index";
+export function RestoreBlockedDialog(props) {
+    const { open, onOpenChange, blockedByLabel, onConfirm } = props;
+    const label = blockedByLabel ?? "the newer memory";
+    return (_jsx(AlertDialog, { open: open, onOpenChange: onOpenChange, children: _jsxs(AlertDialogContent, { children: [_jsxs(AlertDialogHeader, { children: [_jsx(AlertDialogTitle, { children: "Can't restore this memory" }), _jsxs(AlertDialogDescription, { children: ["It was replaced by \"", label, "\". Delete or edit that memory first, or delete it now to restore this one."] })] }), _jsxs(AlertDialogFooter, { children: [_jsx(AlertDialogCancel, { children: "Cancel" }), _jsxs(AlertDialogAction, { variant: "destructive", onClick: onConfirm, children: ["Delete \"", label, "\" & restore"] })] })] }) }));
+}

package/dist/routes/memories/components/SchemasTab.d.ts

@@ -0,0 +1,6 @@
+type SchemasTabProps = {
+    query?: string;
+};
+export declare function SchemasTab(props: SchemasTabProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SchemasTab.d.ts.map

package/dist/routes/memories/components/SchemasTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemasTab.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/components/SchemasTab.tsx"],"names":[],"mappings":"AA4FA,KAAK,eAAe,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CA+ChD"}

package/dist/routes/memories/components/SchemasTab.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemorySchemasQuery } from "@manta-eu/client";
+import { formatEntityName } from "@manta-eu/client/shared/rdf-namespaces";
+import { humanPlural } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { ChevronRight, Layers } from "lucide-react";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "#components/collapsible/index";
+import { EmptyState } from "#components/empty-state/index";
+import { Skeleton } from "#components/skeleton/index";
+import { useMantaClient } from "#providers/index";
+function shortDatatype(iri) {
+    if (iri.endsWith("#string"))
+        return "text";
+    if (iri.endsWith("#decimal"))
+        return "decimal";
+    if (iri.endsWith("#integer"))
+        return "integer";
+    if (iri.endsWith("#boolean"))
+        return "boolean";
+    if (iri.endsWith("#anyURI"))
+        return "url";
+    return formatEntityName(iri);
+}
+function SchemaRow(props) {
+    const { schema } = props;
+    return (_jsxs(Collapsible, { children: [_jsxs(CollapsibleTrigger, { className: "group flex w-full items-center gap-2 px-4 py-3 text-left hover:bg-faint transition-colors", children: [_jsx(ChevronRight, { className: "size-3.5 shrink-0 text-muted-foreground transition-transform group-data-[state=open]:rotate-90" }), _jsx("span", { className: "typography-small-medium text-default-foreground truncate", children: schema.label }), _jsxs("span", { className: "ml-auto shrink-0 typography-tiny text-muted-foreground", children: [schema.properties.length, " ", humanPlural("property", schema.properties.length)] })] }), _jsx(CollapsibleContent, { children: _jsxs("div", { className: "border-t border-muted-border", children: [schema.description && (_jsx("p", { className: "px-4 py-3 typography-small text-muted-foreground border-b border-muted-border", children: schema.description })), isPresent(schema.properties) && (_jsxs("table", { className: "w-full table-fixed text-left", children: [_jsxs("colgroup", { children: [_jsx("col", { className: "w-48" }), _jsx("col", { className: "w-20" }), _jsx("col", { className: "w-24" }), _jsx("col", {})] }), _jsx("tbody", { children: schema.properties.map((prop) => (_jsxs("tr", { className: "border-b border-muted-border last:border-0", children: [_jsx("td", { className: "px-4 py-2.5 align-top", children: _jsxs("div", { className: "flex flex-col gap-0.5", children: [_jsx("span", { className: "typography-small-medium text-default-foreground", children: prop.label }), _jsx("span", { className: "typography-tiny font-mono text-muted-foreground break-all", children: prop.path })] }) }), _jsx("td", { className: "px-4 py-2.5 align-top", children: _jsx("span", { className: "typography-tiny text-muted-foreground", children: shortDatatype(prop.dataType) }) }), _jsx("td", { className: "px-4 py-2.5 align-top", children: prop.required ? (_jsx("span", { className: "typography-tiny rounded-full bg-accent px-2 py-0.5 text-muted-foreground", children: "required" })) : (_jsx("span", { className: "typography-tiny rounded-full bg-muted px-2 py-0.5 text-muted-foreground", children: "optional" })) }), _jsx("td", { className: "px-4 py-2.5 align-top", children: isPresent(prop.allowedValues) && (_jsx("div", { className: "flex flex-wrap gap-1", children: prop.allowedValues.map((val) => (_jsx("span", { className: "typography-tiny rounded-full bg-muted px-2 py-0.5", children: val }, val))) })) })] }, prop.path))) })] }))] }) })] }));
+}
+export function SchemasTab(props) {
+    const { query = "" } = props;
+    const { mantaClient } = useMantaClient();
+    const { data, isLoading } = useMemorySchemasQuery(mantaClient);
+    const schemas = data?.memorySchemas.schemas ?? [];
+    const filtered = query.trim() ? schemas.filter((s) => s.label.toLowerCase().includes(query.toLowerCase())) : schemas;
+    return (_jsxs("div", { className: "flex flex-col gap-3", children: [isLoading && (_jsx("div", { className: "flex flex-col w-full max-w-3xl mx-auto rounded-xl border border-muted-border overflow-hidden divide-y divide-muted-border", children: [0, 1, 2].map((i) => (_jsxs("div", { className: "flex items-center gap-2 px-4 py-3", children: [_jsx(Skeleton, { className: "size-3.5 rounded-sm" }), _jsx(Skeleton, { className: "h-4 w-40 rounded-md" }), _jsx(Skeleton, { className: "ml-auto h-4 w-16 rounded-md" })] }, i))) })), !isLoading && !isPresent(schemas) && (_jsx("div", { className: "flex flex-1 items-center justify-center", children: _jsx(EmptyState, { icon: Layers, title: "No schemas defined", description: "Memory schemas define structured properties for typed memories." }) })), !isLoading && isPresent(schemas) && !isPresent(filtered) && (_jsx("div", { className: "flex flex-1 items-center justify-center", children: _jsx(EmptyState, { icon: Layers, title: "No schemas match", description: `No schemas found for "${query}".` }) })), !isLoading && isPresent(filtered) && (_jsx("div", { className: "w-full max-w-3xl mx-auto rounded-xl border border-muted-border bg-card overflow-hidden divide-y divide-muted-border", children: filtered.map((schema) => (_jsx(SchemaRow, { schema: schema }, schema.iri))) }))] }));
+}

package/dist/routes/memories/components/SupersessionConflictDialog.d.ts

@@ -0,0 +1,18 @@
+import type { GQLConflictingMemory } from "@manta-eu/client";
+import { GQLMemoryScope } from "@manta-eu/client";
+export type ConflictResolution = {
+    supersedesIris: string[];
+    mergedTeams?: string[];
+};
+export type SupersessionConflictDialogProps = {
+    open: boolean;
+    conflicts: GQLConflictingMemory[];
+    scope: GQLMemoryScope;
+    newTeams: string[];
+    currentUserId?: string;
+    onConfirm: (resolution: ConflictResolution) => void;
+    onSaveWithout: () => void;
+    onCancel: () => void;
+};
+export declare function SupersessionConflictDialog(props: SupersessionConflictDialogProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SupersessionConflictDialog.d.ts.map

package/dist/routes/memories/components/SupersessionConflictDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SupersessionConflictDialog.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/components/SupersessionConflictDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAelD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,oBAAoB,EAAE,CAAC;IAClC,KAAK,EAAE,cAAc,CAAC;IACtB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,CAAC,UAAU,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACpD,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,+BAA+B,2CA8HhF"}

package/dist/routes/memories/components/SupersessionConflictDialog.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GQLMemoryScope } from "@manta-eu/client";
+import { humanCount } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { useCallback, useEffect, useState } from "react";
+import { ConflictMemoryCard } from "./ConflictMemoryCard.js";
+import { Button } from "#components/button/index";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "#components/modal/index";
+export function SupersessionConflictDialog(props) {
+    const { open, conflicts, scope, newTeams, currentUserId, onConfirm, onSaveWithout, onCancel } = props;
+    const isTeam = scope === GQLMemoryScope.Team;
+    const [checked, setChecked] = useState(new Set());
+    const [merging, setMerging] = useState(new Set());
+    useEffect(() => {
+        if (open) {
+            setChecked(new Set(conflicts.map((c) => c.iri)));
+            setMerging(new Set());
+        }
+    }, [open, conflicts]);
+    const toggleChecked = useCallback((iri) => {
+        setChecked((prev) => {
+            const next = new Set(prev);
+            if (next.has(iri)) {
+                next.delete(iri);
+                // Unchecking stops superseding it, so it must also stop contributing its teams.
+                setMerging((m) => {
+                    if (!m.has(iri))
+                        return m;
+                    const nm = new Set(m);
+                    nm.delete(iri);
+                    return nm;
+                });
+            }
+            else {
+                next.add(iri);
+            }
+            return next;
+        });
+    }, []);
+    const toggleMerge = useCallback((iri) => {
+        setMerging((prev) => {
+            const next = new Set(prev);
+            if (next.has(iri)) {
+                next.delete(iri);
+            }
+            else {
+                next.add(iri);
+                // Merge implies supersession - ensure checked
+                setChecked((c) => new Set([...c, iri]));
+            }
+            return next;
+        });
+    }, []);
+    const allChecked = isPresent(conflicts) && conflicts.every((c) => checked.has(c.iri));
+    const toggleAll = useCallback(() => {
+        if (allChecked) {
+            setChecked(new Set());
+            setMerging(new Set());
+        }
+        else {
+            setChecked(new Set(conflicts.map((c) => c.iri)));
+        }
+    }, [allChecked, conflicts]);
+    const handleConfirm = useCallback(() => {
+        const supersedesIris = [...checked];
+        let mergedTeams;
+        if (isTeam && merging.size > 0) {
+            const allOldTeams = conflicts.filter((c) => merging.has(c.iri)).flatMap((c) => c.currentTeams);
+            mergedTeams = [...new Set([...newTeams, ...allOldTeams])];
+        }
+        onConfirm({ supersedesIris, mergedTeams });
+    }, [checked, merging, isTeam, conflicts, newTeams, onConfirm]);
+    const checkedCount = checked.size;
+    return (_jsx(Dialog, { open: open, onOpenChange: (o) => {
+            if (!o)
+                onCancel();
+        }, children: _jsxs(DialogContent, { className: "max-w-2xl", children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { text: "Similar memories already exist" }), _jsx(DialogDescription, { children: "The memory you're saving may replace the following existing memories. Select which ones to replace and they will be hidden and superseded by the new memory." })] }), _jsxs("div", { className: "flex flex-col gap-3 max-h-72 overflow-y-auto py-1", children: [_jsx("button", { type: "button", className: "text-left typography-small text-accent-foreground hover:underline w-fit", onClick: toggleAll, children: allChecked ? "Select none" : "Select all" }), conflicts.map((conflict) => (_jsx(ConflictMemoryCard, { conflict: conflict, scope: scope, checked: checked.has(conflict.iri), onToggleChecked: () => toggleChecked(conflict.iri), showMerge: isTeam, merging: merging.has(conflict.iri), onToggleMerge: () => toggleMerge(conflict.iri), currentUserId: currentUserId }, conflict.iri)))] }), _jsxs(DialogFooter, { className: "flex-col sm:flex-row gap-2", children: [_jsx(Button, { variant: "tertiary", onClick: onCancel, className: "sm:mr-auto", children: "Cancel" }), _jsx(Button, { variant: "secondary", onClick: onSaveWithout, children: "Save & keep both" }), _jsx(Button, { onClick: handleConfirm, disabled: checkedCount === 0, children: checkedCount > 0 ? `Save & replace ${humanCount(checkedCount, "memory")}` : "Save & replace selected" })] })] }) }));
+}

package/dist/routes/memories/components/TeamPicker.d.ts

@@ -0,0 +1,8 @@
+export type TeamPickerProps = {
+    selected: string[];
+    onChange: (teams: string[]) => void;
+    isOperator: boolean;
+    error?: string;
+};
+export declare function TeamPicker(props: TeamPickerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=TeamPicker.d.ts.map

package/dist/routes/memories/components/TeamPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TeamPicker.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/components/TeamPicker.tsx"],"names":[],"mappings":"AAeA,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACpC,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAMF,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAoEhD"}

package/dist/routes/memories/components/TeamPicker.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useAvailableTeamsQuery } from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+import { ChevronDown, Users, X } from "lucide-react";
+import { Button } from "#components/button/index";
+import { Combobox, ComboboxContent, ComboboxEmpty, ComboboxInput, ComboboxItem, ComboboxList, ComboboxTrigger, } from "#components/combobox/index";
+import { useMantaClient } from "#providers/index";
+function getTeamName(path) {
+    return path.split("/").filter(Boolean).pop() ?? path;
+}
+export function TeamPicker(props) {
+    const { selected, onChange, isOperator, error } = props;
+    const { mantaClient } = useMantaClient();
+    const { data } = useAvailableTeamsQuery(mantaClient, undefined, { enabled: isOperator });
+    const availableTeams = data?.availableTeams.teams.map((g) => g.name) ?? [];
+    function toggle(path) {
+        onChange(selected.includes(path) ? selected.filter((t) => t !== path) : [...selected, path]);
+    }
+    const triggerLabel = !isPresent(selected)
+        ? "Select teams…"
+        : selected.length === 1
+            ? getTeamName(selected[0] ?? "")
+            : `${selected.length} teams selected`;
+    return (_jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx("label", { className: "typography-small text-default-foreground", children: "Target Teams" }), _jsxs(Combobox, { children: [_jsx(ComboboxTrigger, { asChild: true, children: _jsxs(Button, { variant: "tertiary", size: "base", rounded: "lg", className: "w-full justify-start", children: [_jsx(Users, { className: "size-4 shrink-0 text-muted-foreground" }), _jsx("span", { className: "flex-1 text-left truncate", children: triggerLabel }), _jsx(ChevronDown, { className: "size-4 shrink-0 text-muted-foreground" })] }) }), _jsxs(ComboboxContent, { align: "start", className: "w-full", children: [_jsx(ComboboxInput, { placeholder: "Search teams\u2026" }), _jsxs(ComboboxList, { children: [_jsx(ComboboxEmpty, { children: "No teams found" }), availableTeams.map((path) => (_jsx(ComboboxItem, { value: path, selected: selected.includes(path), closeOnSelect: false, onSelect: () => toggle(path), children: getTeamName(path) }, path)))] })] })] }), isPresent(selected) && (_jsx("div", { className: "flex flex-wrap gap-1.5 mt-1", children: selected.map((path) => (_jsxs("span", { className: "inline-flex items-center gap-1 rounded-full px-2 py-0.5 typography-tiny bg-accent/10 text-accent-foreground", children: [getTeamName(path), _jsx("button", { type: "button", onClick: () => toggle(path), className: "size-3 flex items-center justify-center hover:opacity-70", "aria-label": `Remove ${path}`, children: _jsx(X, { className: "size-2.5" }) })] }, path))) })), error && _jsx("p", { className: "typography-small text-error-foreground", children: error })] }));
+}

package/dist/routes/memories/components/badges.d.ts

@@ -0,0 +1,50 @@
+import { GQLMemoryScope, type GQLMemoryKind } from "@manta-eu/client";
+import { type MemoryPreloadCandidate } from "@manta-eu/client/shared/memory-preload-gate";
+import { type MemoryWindowState } from "../expiry-utils.js";
+export type ScopeBadgeProps = {
+    scope: GQLMemoryScope;
+};
+export declare function ScopeBadge(props: ScopeBadgeProps): import("react/jsx-runtime").JSX.Element;
+export declare function AutoCapturedBadge(props: {
+    confidence: number;
+}): import("react/jsx-runtime").JSX.Element;
+export type DuplicateMatch = {
+    label: string;
+    reason: string;
+};
+export declare function DuplicateBadge(props: {
+    matches: DuplicateMatch[];
+}): import("react/jsx-runtime").JSX.Element | null;
+export type KindBadgeProps = {
+    kind: GQLMemoryKind;
+};
+export declare function KindBadge(props: KindBadgeProps): import("react/jsx-runtime").JSX.Element;
+export type SchemaBadgeProps = {
+    label?: string | null;
+};
+export declare function SchemaBadge(props: SchemaBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+export type OutOfWindowBadgeProps = {
+    state: Exclude<MemoryWindowState, "active">;
+};
+export declare function OutOfWindowBadge(props: OutOfWindowBadgeProps): import("react/jsx-runtime").JSX.Element;
+export type PreloadedBadgeProps = {
+    memory: MemoryPreloadCandidate;
+};
+export type PreloadBadgeTone = "pinned" | "heldOut" | "unreachable";
+export type PreloadBadgeContent = {
+    label: "Pinned" | "Unconfirmed" | "Unreachable" | "Cold";
+    preloaded: boolean;
+    tone: PreloadBadgeTone;
+    why: string;
+};
+export declare function preloadBadgeContent(memory: MemoryPreloadCandidate, now?: Date): PreloadBadgeContent | null;
+export declare function PreloadedBadge(props: PreloadedBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+export type MemoryEvidenceProps = {
+    evidence?: string | null;
+};
+export declare function MemoryEvidence(props: MemoryEvidenceProps): import("react/jsx-runtime").JSX.Element | null;
+export type MemoryAboutProps = {
+    aboutEntityIris?: string[] | null;
+};
+export declare function MemoryAbout(props: MemoryAboutProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=badges.d.ts.map

package/dist/routes/memories/components/badges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"badges.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/components/badges.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAKL,KAAK,sBAAsB,EAC5B,MAAM,6CAA6C,CAAC;AAKrD,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAKlF,MAAM,MAAM,eAAe,GAAG;IAAE,KAAK,EAAE,cAAc,CAAA;CAAE,CAAC;AAExD,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAahD;AAeD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,2CAa9D;AAED,MAAM,MAAM,cAAc,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,OAAO,EAAE,cAAc,EAAE,CAAA;CAAE,kDAwBlE;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,aAAa,CAAC;CACrB,CAAC;AAEF,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,2CAQ9C;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,kDASlD;AAaD,MAAM,MAAM,qBAAqB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAA;CAAE,CAAC;AAEpF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,2CAa5D;AAED,MAAM,MAAM,mBAAmB,GAAG;IAAE,MAAM,EAAE,sBAAsB,CAAA;CAAE,CAAC;AAErE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,SAAS,GAAG,aAAa,CAAC;AAEpE,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,QAAQ,GAAG,aAAa,GAAG,aAAa,GAAG,MAAM,CAAC;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,gBAAgB,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,EAAE,GAAG,CAAC,EAAE,IAAI,GAAG,mBAAmB,GAAG,IAAI,CAc1G;AAQD,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,kDAcxD;AAED,MAAM,MAAM,mBAAmB,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE/D,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,kDAkBxD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAAE,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CAAE,CAAC;AAErE,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,kDAclD"}

package/dist/routes/memories/components/badges.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GQLMemoryScope } from "@manta-eu/client";
+import { describeMemoryPreloadExclusions, isMemoryArchived, isMemorySearchable, memoryPreloadExclusions, } 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 { CopyCheck, Link2, Quote } from "lucide-react";
+import { match, P } from "ts-pattern";
+import { unconfirmedHorizonLabel } from "../expiry-utils.js";
+import { Badge } from "#components/badge/index";
+import { Tooltip, TooltipContent, TooltipTrigger } from "#components/tooltip/index";
+import { cn } from "#lib/utils";
+export function ScopeBadge(props) {
+    const { scope } = props;
+    const { className, label } = match(scope)
+        .with(GQLMemoryScope.Company, () => ({ className: "bg-accent/10 text-accent-foreground", label: "Company" }))
+        .with(GQLMemoryScope.Team, () => ({ className: "bg-warning/10 text-warning-foreground", label: "Team" }))
+        .with(GQLMemoryScope.User, () => ({ className: "bg-muted-foreground/10 text-muted-foreground", label: "Personal" }))
+        .exhaustive();
+    return (_jsx(Badge, { size: "sm", className: className, children: label }));
+}
+function autoCapturedTooltip(confidence) {
+    const pct = Math.round(confidence * 100);
+    const prefix = `Auto-captured from chat history (${pct}% confidence).`;
+    // TODO: revisit these confidence tiers/copy - refine until good enough or drop entirely.
+    const note = match(confidence)
+        .with(P.number.gte(0.9), () => "Likely accurate, but worth a quick glance.")
+        .with(P.number.gte(0.7), () => "Decent signal - review before relying on it.")
+        .with(P.number.gte(0.5), () => "Moderate confidence - verify this.")
+        .otherwise(() => "Low confidence - treat with caution.");
+    return `${prefix} ${note}`;
+}
+export function AutoCapturedBadge(props) {
+    const { confidence } = props;
+    const pct = Math.round(confidence * 100);
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs(Badge, { size: "sm", className: "bg-faint border border-muted-border text-muted-foreground cursor-default", children: ["Captured \u00B7 ", pct, "%"] }) }), _jsx(TooltipContent, { className: "max-w-xs typography-small", children: autoCapturedTooltip(confidence) })] }));
+}
+export function DuplicateBadge(props) {
+    const { matches } = props;
+    if (!isPresent(matches))
+        return null;
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs(Badge, { size: "sm", className: "bg-warning/10 text-warning-foreground border border-warning/30 cursor-default", children: [_jsx(CopyCheck, { className: "size-3" }), "Possible duplicate"] }) }), _jsx(TooltipContent, { className: "max-w-xs typography-small text-left", children: _jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("span", { className: "text-muted-foreground", children: "Looks like it duplicates:" }), matches.map((match) => (_jsxs("div", { children: [_jsx("span", { className: "typography-small-medium", children: match.label }), match.reason ? ` - ${match.reason}` : ""] }, match.label)))] }) })] }));
+}
+export function KindBadge(props) {
+    const { kind } = props;
+    return (_jsx(Badge, { size: "sm", variant: "secondary", className: "capitalize", children: kind }));
+}
+export function SchemaBadge(props) {
+    const { label } = props;
+    if (!label)
+        return null;
+    return (_jsx(Badge, { size: "sm", variant: "secondary", className: "max-w-[28ch] truncate", title: label, children: label }));
+}
+const outOfWindowCopy = {
+    expired: {
+        label: "Expired",
+        why: "Its expiry date has passed, so the agent can neither pre-load nor search it. Nothing was deleted — edit the expiry date to bring it back.",
+    },
+    scheduled: {
+        label: "Scheduled",
+        why: "Its start date is in the future, so the agent cannot use it yet. Edit the start date to bring it forward.",
+    },
+};
+export function OutOfWindowBadge(props) {
+    const { label, why } = outOfWindowCopy[props.state];
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx(Badge, { size: "sm", className: "bg-warning/10 text-warning-foreground border border-warning/30 cursor-default", children: label }) }), _jsx(TooltipContent, { className: "max-w-xs typography-small", children: why })] }));
+}
+export function preloadBadgeContent(memory, now) {
+    if (isMemoryArchived(memory))
+        return null;
+    const exclusions = memoryPreloadExclusions(memory, now);
+    const preloaded = !isPresent(exclusions);
+    const why = describeMemoryPreloadExclusions(memory, exclusions);
+    if (preloaded)
+        return { label: "Pinned", preloaded, tone: "pinned", why };
+    if (!isMemorySearchable(memory))
+        return { label: "Unreachable", preloaded, tone: "unreachable", why };
+    if (exclusions.includes("importance"))
+        return null;
+    if (exclusions.length === 1 && exclusions[0] === "cold") {
+        return { label: "Cold", preloaded, tone: "heldOut", why };
+    }
+    return { label: unconfirmedHorizonLabel, preloaded, tone: "heldOut", why };
+}
+const preloadBadgeToneClass = {
+    pinned: "bg-faint border-muted-border text-default-foreground",
+    heldOut: "bg-muted-foreground/10 border-muted-border text-muted-foreground",
+    unreachable: "bg-warning/10 border-warning/30 text-warning-foreground",
+};
+export function PreloadedBadge(props) {
+    const content = preloadBadgeContent(props.memory);
+    if (!content)
+        return null;
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx(Badge, { size: "sm", className: cn("border cursor-default", preloadBadgeToneClass[content.tone]), children: content.label }) }), _jsx(TooltipContent, { className: "max-w-xs typography-small", children: content.why })] }));
+}
+export function MemoryEvidence(props) {
+    const { evidence } = props;
+    if (!isPresent(evidence))
+        return null;
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs("span", { className: "mt-1 flex cursor-default items-start gap-1.5 border-l-2 border-muted-border pl-2 typography-tiny italic text-muted-foreground", children: [_jsx(Quote, { className: "mt-0.5 size-3 shrink-0" }), _jsx("span", { className: "line-clamp-2 break-words", children: evidence })] }) }), _jsx(TooltipContent, { className: "max-w-xs typography-small text-left", children: "What the user said that this memory was extracted from. Chat history is deleted after 30 days, so this quote stays as the record of where the memory came from." })] }));
+}
+export function MemoryAbout(props) {
+    const { aboutEntityIris } = props;
+    if (!isPresent(aboutEntityIris))
+        return null;
+    return (_jsxs("span", { className: "mt-1 flex flex-wrap items-center gap-1", children: [_jsx(Link2, { className: "size-3 shrink-0 text-muted-foreground" }), aboutEntityIris.map((iri) => (_jsx(Badge, { size: "sm", variant: "secondary", className: "max-w-[24ch] truncate", title: iri, children: formatEntityName(iri) }, iri)))] }));
+}

package/dist/routes/memories/expiry-utils.d.ts

@@ -0,0 +1,23 @@
+export declare function formatExpiryRelative(expiresAt: Date | string | null | undefined, now?: Date): string;
+export declare function formatExpiryDate(expiresAt: Date | string | null | undefined, now?: Date): string;
+export type MemoryHorizon = {
+    kind: "none";
+    at: null;
+} | {
+    kind: "expiry";
+    at: Date | string;
+} | {
+    kind: "trust";
+    at: Date | string;
+};
+export declare function memoryHorizon(memoryValidUntil: Date | string | null | undefined, memoryTrustedUntil: Date | string | null | undefined): MemoryHorizon;
+export type MemoryWindowState = "active" | "expired" | "scheduled";
+export declare function memoryWindowState(memoryValidFrom: Date | string | null | undefined, memoryValidUntil: Date | string | null | undefined, now?: Date): MemoryWindowState;
+export declare function isTrustExpired(memoryTrustedUntil: Date | string | null | undefined, now?: Date): boolean;
+export declare const unconfirmedHorizonLabel = "Unconfirmed";
+export declare function formatHorizonDate(horizon: MemoryHorizon, now?: Date): string;
+export declare function formatHorizonRelative(horizon: MemoryHorizon, now?: Date): string;
+export declare function compareMemoryHorizons(a: MemoryHorizon, b: MemoryHorizon): number;
+export declare function shouldShowValidFrom(updatedAt: Date | string | null | undefined, memoryValidFrom: Date | string | null | undefined): boolean;
+export declare function formatHorizonTooltip(horizon: MemoryHorizon, now?: Date): string;
+//# sourceMappingURL=expiry-utils.d.ts.map

package/dist/routes/memories/expiry-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry-utils.d.ts","sourceRoot":"","sources":["../../../src/routes/memories/expiry-utils.ts"],"names":[],"mappings":"AASA,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,GAAE,IAAiB,GAAG,MAAM,CAQhH;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,GAAE,IAAiB,GAAG,MAAM,CAK5G;AAED,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAAE,GAC1B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAAA;CAAE,CAAC;AAEzC,wBAAgB,aAAa,CAC3B,gBAAgB,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAClD,kBAAkB,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GACnD,aAAa,CAIf;AAED,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;AAEnE,wBAAgB,iBAAiB,CAC/B,eAAe,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,gBAAgB,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAClD,GAAG,GAAE,IAAiB,GACrB,iBAAiB,CAMnB;AAGD,wBAAgB,cAAc,CAAC,kBAAkB,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,GAAE,IAAiB,GAAG,OAAO,CAEpH;AAED,eAAO,MAAM,uBAAuB,gBAAgB,CAAC;AAErD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,GAAE,IAAiB,GAAG,MAAM,CAUxF;AAUD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,GAAE,IAAiB,GAAG,MAAM,CAM5F;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,MAAM,CAKhF;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAC3C,eAAe,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAChD,OAAO,CAKT;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,GAAE,IAAiB,GAAG,MAAM,CAU3F"}

package/dist/routes/memories/expiry-utils.js

@@ -0,0 +1,97 @@
+import { isPastTrustedUntilAt, parseMemoryDate, validFromWorthShowingDays, } from "@manta-eu/client/shared/memory-preload-gate";
+import { differenceInCalendarDays, format } from "date-fns";
+import { match } from "ts-pattern";
+// Compares by timestamp, not calendar day, so a memory expiring tonight is not expired yet.
+export function formatExpiryRelative(expiresAt, now = new Date()) {
+    const at = parseMemoryDate(expiresAt);
+    if (!at)
+        return "Never expires";
+    if (at.getTime() <= now.getTime())
+        return "Expired";
+    const days = differenceInCalendarDays(at, now);
+    if (days <= 0)
+        return "Expires today";
+    if (days === 1)
+        return "Expires tomorrow";
+    return `Expires in ${days}d`;
+}
+export function formatExpiryDate(expiresAt, now = new Date()) {
+    const at = parseMemoryDate(expiresAt);
+    if (!at)
+        return "Never";
+    if (at.getTime() <= now.getTime())
+        return "Expired";
+    return format(at, "MMM d, yyyy");
+}
+export function memoryHorizon(memoryValidUntil, memoryTrustedUntil) {
+    if (memoryValidUntil)
+        return { kind: "expiry", at: memoryValidUntil };
+    if (memoryTrustedUntil)
+        return { kind: "trust", at: memoryTrustedUntil };
+    return { kind: "none", at: null };
+}
+export function memoryWindowState(memoryValidFrom, memoryValidUntil, now = new Date()) {
+    const until = parseMemoryDate(memoryValidUntil);
+    if (until && until.getTime() <= now.getTime())
+        return "expired";
+    const from = parseMemoryDate(memoryValidFrom);
+    if (from && from.getTime() > now.getTime())
+        return "scheduled";
+    return "active";
+}
+// Past horizon means the data is still valid and never deleted, just no longer relied on.
+export function isTrustExpired(memoryTrustedUntil, now = new Date()) {
+    return isPastTrustedUntilAt(memoryTrustedUntil, now);
+}
+export const unconfirmedHorizonLabel = "Unconfirmed";
+export function formatHorizonDate(horizon, now = new Date()) {
+    return match(horizon)
+        .with({ kind: "none" }, () => "Never")
+        .with({ kind: "expiry" }, ({ at }) => formatExpiryDate(at, now))
+        .with({ kind: "trust" }, ({ at }) => {
+        const parsed = parseMemoryDate(at);
+        if (!parsed)
+            return "Never";
+        return isTrustExpired(at, now) ? unconfirmedHorizonLabel : `~${format(parsed, "MMM d, yyyy")}`;
+    })
+        .exhaustive();
+}
+function trustedForLabel(at, now) {
+    const parsed = parseMemoryDate(at);
+    if (!parsed)
+        return "Never expires";
+    const days = differenceInCalendarDays(parsed, now);
+    if (days <= 0)
+        return "Trusted until today";
+    return days === 1 ? "Trusted until tomorrow" : `Trusted for ${days}d`;
+}
+export function formatHorizonRelative(horizon, now = new Date()) {
+    return match(horizon)
+        .with({ kind: "none" }, () => "Never expires")
+        .with({ kind: "expiry" }, ({ at }) => formatExpiryRelative(at, now))
+        .with({ kind: "trust" }, ({ at }) => (isTrustExpired(at, now) ? unconfirmedHorizonLabel : trustedForLabel(at, now)))
+        .exhaustive();
+}
+export function compareMemoryHorizons(a, b) {
+    const left = parseMemoryDate(a.at);
+    const right = parseMemoryDate(b.at);
+    if (!left || !right)
+        return left ? -1 : right ? 1 : 0;
+    return left.getTime() - right.getTime();
+}
+export function shouldShowValidFrom(updatedAt, memoryValidFrom) {
+    const since = parseMemoryDate(memoryValidFrom);
+    const recorded = parseMemoryDate(updatedAt);
+    if (!since || !recorded)
+        return false;
+    return differenceInCalendarDays(recorded, since) >= validFromWorthShowingDays;
+}
+export function formatHorizonTooltip(horizon, now = new Date()) {
+    return match(horizon)
+        .with({ kind: "none" }, () => "Never expires")
+        .with({ kind: "expiry" }, ({ at }) => `No longer true after this date. ${formatExpiryRelative(at, now)}`)
+        .with({ kind: "trust" }, (trust) => isTrustExpired(trust.at, now)
+        ? "Past the date it was trusted until, so it no longer pre-loads into conversations. Still true, still searchable, and never deleted."
+        : `Stops pre-loading into conversations after this date, but stays searchable. ${formatHorizonRelative(trust, now)}`)
+        .exhaustive();
+}