@manta-eu/react 0.1.0 → 0.1.2

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();
+}

package/dist/routes/memories/hooks/useConflictCheck.d.ts

@@ -0,0 +1,18 @@
+import { GQLMemoryScope, type GQLConflictingMemory } from "@manta-eu/client";
+export type ConflictCheckInput = {
+    label: string;
+    description: string;
+    scope: GQLMemoryScope;
+    teams?: string[];
+    excludeIri?: string;
+};
+export type ConflictCheckResult = {
+    conflicts: GQLConflictingMemory[];
+    timedOut: boolean;
+};
+export type UseConflictCheckResult = {
+    check: (input: ConflictCheckInput) => Promise<ConflictCheckResult>;
+    isChecking: boolean;
+};
+export declare function useConflictCheck(): UseConflictCheckResult;
+//# sourceMappingURL=useConflictCheck.d.ts.map

package/dist/routes/memories/hooks/useConflictCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConflictCheck.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useConflictCheck.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EACd,KAAK,oBAAoB,EAG1B,MAAM,kBAAkB,CAAC;AAM1B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,oBAAoB,EAAE,CAAC;IAClC,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnE,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,wBAAgB,gBAAgB,IAAI,sBAAsB,CAmCzD"}

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

@@ -0,0 +1,35 @@
+import { DetectMemoryConflictsDocument, GQLMemoryScope, } from "@manta-eu/client";
+import { useCallback, useState } from "react";
+import { useMantaClient } from "#providers/index";
+const conflictCheckTimeoutMs = 15_000;
+export function useConflictCheck() {
+    const { mantaClient } = useMantaClient();
+    const [isChecking, setIsChecking] = useState(false);
+    const check = useCallback(async (input) => {
+        setIsChecking(true);
+        try {
+            const result = await mantaClient.request({
+                document: DetectMemoryConflictsDocument,
+                variables: {
+                    input: {
+                        label: input.label,
+                        description: input.description,
+                        scope: input.scope,
+                        teams: input.scope === GQLMemoryScope.Team ? (input.teams ?? []) : undefined,
+                        excludeIri: input.excludeIri ?? undefined,
+                        wantToStopAfterMs: conflictCheckTimeoutMs,
+                    },
+                },
+                signal: AbortSignal.timeout(conflictCheckTimeoutMs + 5_000),
+            });
+            return result.detectMemoryConflicts;
+        }
+        catch {
+            return { conflicts: [], timedOut: false };
+        }
+        finally {
+            setIsChecking(false);
+        }
+    }, [mantaClient]);
+    return { check, isChecking };
+}

package/dist/routes/memories/hooks/useDuplicateDetection.d.ts

@@ -0,0 +1,11 @@
+import type { GQLConflictingMemory, GQLMemory } from "@manta-eu/client";
+export type DuplicateMatches = Map<string, GQLConflictingMemory[]>;
+export declare function pickDuplicateTargets(memories: GQLMemory[], max?: number): GQLMemory[];
+export declare function useDuplicateDetection(memories: GQLMemory[], options?: {
+    enabled?: boolean;
+    max?: number;
+}): {
+    duplicates: DuplicateMatches;
+    isDetecting: boolean;
+};
+//# sourceMappingURL=useDuplicateDetection.d.ts.map

package/dist/routes/memories/hooks/useDuplicateDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDuplicateDetection.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useDuplicateDetection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKxE,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;AAOnE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,GAAG,GAAE,MAAyB,GAAG,SAAS,EAAE,CAEvG;AAeD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,SAAS,EAAE,EACrB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAChD;IAAE,UAAU,EAAE,gBAAgB,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAyDxD"}

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

@@ -0,0 +1,73 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useConflictCheck } from "./useConflictCheck.js";
+// Caps how many memories run semantic detection in one pass, so a large unreviewed queue
+// cannot fan out into an unbounded number of detection calls.
+const defaultMaxChecks = 25;
+// Only memories with a description carry enough signal for semantic comparison.
+export function pickDuplicateTargets(memories, max = defaultMaxChecks) {
+    return memories.filter((m) => isPresent(m.description)).slice(0, max);
+}
+function buildMemoryKey(memory) {
+    return `${memory.iri}:${memory.scope}:${memory.label}:${memory.description ?? ""}`;
+}
+function targetSignature(memories) {
+    return memories.map(buildMemoryKey).join("|");
+}
+// Runs the existing semantic conflict check (SEMSIM recall pre-filter + LLM precision judge)
+// across a set of memories and returns, per memory IRI, the existing memories it likely
+// duplicates. Results are cached by IRI+label+description so re-renders and tab switches do
+// not re-issue detection for unchanged memories. Nothing is mutated — this only surfaces
+// candidates; the user still confirms any supersession in the review dialog.
+export function useDuplicateDetection(memories, options = {}) {
+    const { enabled = true, max = defaultMaxChecks } = options;
+    const { check } = useConflictCheck();
+    const targets = useMemo(() => (enabled ? pickDuplicateTargets(memories, max) : []), [memories, enabled, max]);
+    const signature = useMemo(() => targetSignature(targets), [targets]);
+    const [duplicates, setDuplicates] = useState(new Map());
+    const [isDetecting, setIsDetecting] = useState(false);
+    const cacheRef = useRef(new Map());
+    const checkRef = useRef(check);
+    checkRef.current = check;
+    const targetsRef = useRef(targets);
+    targetsRef.current = targets;
+    useEffect(() => {
+        const current = targetsRef.current;
+        if (!isPresent(current)) {
+            setDuplicates(new Map());
+            setIsDetecting(false);
+            return;
+        }
+        let cancelled = false;
+        setIsDetecting(true);
+        void (async () => {
+            const next = new Map();
+            for (const memory of current) {
+                const key = buildMemoryKey(memory);
+                let conflicts = cacheRef.current.get(key);
+                if (conflicts == null) {
+                    const result = await checkRef.current({
+                        label: memory.label,
+                        description: memory.description ?? "",
+                        scope: memory.scope,
+                        excludeIri: memory.iri,
+                    });
+                    if (cancelled)
+                        return;
+                    conflicts = result.conflicts;
+                    cacheRef.current.set(key, conflicts);
+                }
+                if (isPresent(conflicts))
+                    next.set(memory.iri, conflicts);
+            }
+            if (!cancelled) {
+                setDuplicates(next);
+                setIsDetecting(false);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [signature]);
+    return { duplicates, isDetecting };
+}

package/dist/routes/memories/hooks/useLiveContext.d.ts

@@ -0,0 +1,23 @@
+import { type SparqlJsonResults } from "@manta-eu/client/types/sparql-types";
+export declare const liveContextSelectQuery = "SELECT ?entity ?property ?value WHERE {\n  :LiveContext_Chat :includes ?entity .\n  ?entity ?property ?value .\n  FILTER NOT EXISTS {\n        ?entity a :Memory .\n        {\n          ?entity :memoryTrustedUntil ?horizon .\n          FILTER(?horizon <= NOW())\n        } UNION {\n          ?entity :memoryValidUntil ?expiry .\n          FILTER(?expiry <= NOW())\n        } UNION {\n          ?entity :memoryValidFrom ?validFrom .\n          FILTER(?validFrom > NOW())\n        }\n      }\n}";
+export type EntityProperty = {
+    predicate: string;
+    value: string;
+    isUri: boolean;
+    datatype?: string;
+};
+export type LiveContextEntity = {
+    iri: string;
+    compactedIri: string;
+    types: string[];
+    properties: EntityProperty[];
+};
+export type LiveContextGroup = {
+    type: string;
+    typeLabel: string;
+    entities: LiveContextEntity[];
+};
+export declare function parseLiveContext(data: SparqlJsonResults): LiveContextGroup[];
+export declare const liveContextQueryKey: readonly ["live-context"];
+export declare function useLiveContext(): import("@tanstack/react-query").UseQueryResult<LiveContextGroup[], Error>;
+//# sourceMappingURL=useLiveContext.d.ts.map

package/dist/routes/memories/hooks/useLiveContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLiveContext.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useLiveContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2C,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAOtH,eAAO,MAAM,sBAAsB,gfAIjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,EAAE,cAAc,EAAE,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B,CAAC;AAkBF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,EAAE,CA+D5E;AAED,eAAO,MAAM,mBAAmB,2BAA4B,CAAC;AAE7D,wBAAgB,cAAc,8EAwB7B"}

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

@@ -0,0 +1,102 @@
+import { liveContextMemoryDateFilter } from "@manta-eu/client/shared/live-context";
+import { compactUri, prependMissingSparqlPrefixes } from "@manta-eu/client/shared/rdf-namespaces";
+import { isSparqlJsonResults } from "@manta-eu/client/types/sparql-types";
+import { useQuery } from "@tanstack/react-query";
+import { useMantaClient } from "#providers/index";
+const rdfTypeIri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const trivialTypePrefixes = ["rdf:", "rdfs:", "owl:", "xsd:"];
+export const liveContextSelectQuery = `SELECT ?entity ?property ?value WHERE {
+  :LiveContext_Chat :includes ?entity .
+  ?entity ?property ?value .
+  ${liveContextMemoryDateFilter}
+}`;
+function formatTypeLabel(compacted) {
+    const localName = compacted.includes(":") ? (compacted.split(":")[1] ?? compacted) : compacted;
+    return localName.replace(/([A-Z])/g, " $1").trim();
+}
+function sparqlValueIsUri(node) {
+    return node.type === "uri";
+}
+function sparqlValueDatatype(node) {
+    if ("datatype" in node && typeof node.datatype === "string") {
+        return node.datatype;
+    }
+    return undefined;
+}
+export function parseLiveContext(data) {
+    const entityMap = new Map();
+    for (const binding of data.results.bindings) {
+        const entityNode = binding["entity"];
+        const propertyNode = binding["property"];
+        const valueNode = binding["value"];
+        if (!entityNode || !propertyNode || !valueNode)
+            continue;
+        const entityIri = entityNode.value;
+        const propertyIri = propertyNode.value;
+        if (!entityMap.has(entityIri)) {
+            entityMap.set(entityIri, { types: [], properties: [] });
+        }
+        const entry = entityMap.get(entityIri);
+        if (!entry)
+            continue;
+        if (propertyIri === rdfTypeIri) {
+            const compacted = compactUri(valueNode.value);
+            if (!trivialTypePrefixes.some((p) => compacted.startsWith(p))) {
+                if (!entry.types.includes(compacted)) {
+                    entry.types.push(compacted);
+                }
+            }
+        }
+        else {
+            const isUri = sparqlValueIsUri(valueNode);
+            entry.properties.push({
+                predicate: compactUri(propertyIri),
+                value: isUri ? compactUri(valueNode.value) : valueNode.value,
+                isUri,
+                datatype: sparqlValueDatatype(valueNode),
+            });
+        }
+    }
+    const groupMap = new Map();
+    for (const [iri, { types, properties }] of entityMap) {
+        const primaryType = types[0] ?? "Unknown";
+        if (!groupMap.has(primaryType)) {
+            groupMap.set(primaryType, {
+                type: primaryType,
+                typeLabel: formatTypeLabel(primaryType),
+                entities: [],
+            });
+        }
+        const group = groupMap.get(primaryType);
+        if (!group)
+            continue;
+        group.entities.push({
+            iri,
+            compactedIri: compactUri(iri),
+            types,
+            properties: [...properties].sort((a, b) => a.predicate.localeCompare(b.predicate)),
+        });
+    }
+    return [...groupMap.values()].sort((a, b) => a.typeLabel.localeCompare(b.typeLabel));
+}
+export const liveContextQueryKey = ["live-context"];
+export function useLiveContext() {
+    const { sparqlFetch, onUnauthorized } = useMantaClient();
+    return useQuery({
+        queryKey: liveContextQueryKey,
+        queryFn: async () => {
+            const response = await sparqlFetch(prependMissingSparqlPrefixes(liveContextSelectQuery));
+            if (!response.ok) {
+                if (response.status === 401) {
+                    onUnauthorized();
+                }
+                throw new Error(`SPARQL query failed: ${response.status}`);
+            }
+            const raw = await response.json();
+            if (!isSparqlJsonResults(raw)) {
+                throw new Error("Invalid SPARQL results format");
+            }
+            return parseLiveContext(raw);
+        },
+    });
+}

package/dist/routes/memories/hooks/useMemoryColumns.d.ts

@@ -0,0 +1,33 @@
+import { type GQLConflictingMemory, type GQLMemory, type GQLMemorySchema } from "@manta-eu/client";
+import type { ColumnDef } from "@tanstack/react-table";
+export declare const memoryColumnIds: {
+    readonly label: "label";
+    readonly description: "description";
+    readonly kind: "kind";
+    readonly teams: "teams";
+    readonly used: "used";
+    readonly actions: "actions";
+};
+export type MemoryColumnId = (typeof memoryColumnIds)[keyof typeof memoryColumnIds];
+export declare const memoryColumnLabels: {
+    label: string;
+    description: string;
+    kind: string;
+    teams: string;
+    used: string;
+};
+export declare const defaultColumnOrder: string[];
+type UseMemoryColumnsArgs = {
+    isOperator?: boolean;
+    userId: string;
+    schemas?: GQLMemorySchema[];
+    onEdit: (memory: GQLMemory) => void;
+    onDelete: (iri: string) => void;
+    onMove?: (memory: GQLMemory) => void;
+    onRestore?: (iri: string) => void;
+    onReconfirm?: (iri: string) => void;
+    duplicates?: Map<string, GQLConflictingMemory[]>;
+};
+export declare function useMemoryColumns(args: UseMemoryColumnsArgs): ColumnDef<GQLMemory>[];
+export {};
+//# sourceMappingURL=useMemoryColumns.d.ts.map

package/dist/routes/memories/hooks/useMemoryColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemoryColumns.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useMemoryColumns.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAInG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AA2BvD,eAAO,MAAM,eAAe;;;;;;;CAOlB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAGpF,eAAO,MAAM,kBAAkB;;;;;;CAMkB,CAAC;AAElD,eAAO,MAAM,kBAAkB,UAW9B,CAAC;AAyBF,KAAK,oBAAoB,GAAG;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IACpC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;CAClD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,CAAC,SAAS,CAAC,EAAE,CA8PnF"}