om-memory-system 4.19.1 → 4.22.0

package/dist/services/api-handlers.js

@@ -884,194 +884,6 @@ export async function handleRefreshProfile(userId) {
         return { success: false, error: String(error) };
     }
 }
-// Temporary storage for pending AI cleanup results (userId → result)
-const pendingCleanups = new Map();
-export async function handleAICleanup(userId, includeIds, profileVersion) {
-    try {
-        const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
-        const { aiCleanupProfile, aiCleanupProfileFromIndexed, filterProfileForCleanup } = await import("./user-profile/ai-cleanup.js");
-        let targetUserId = userId;
-        if (!targetUserId) {
-            targetUserId = (await resolveWebProfileUserId(CONFIG)) || "unknown";
-        }
-        const profile = await userProfileManager.getActiveProfile(targetUserId);
-        if (!profile) {
-            return { success: false, error: "No profile found to clean up" };
-        }
-        if (profileVersion !== undefined && profile.version !== profileVersion) {
-            return { success: false, error: "Profile changed. Reload it before running AI cleanup." };
-        }
-        const profileData = JSON.parse(profile.profileData);
-        profileData.preferences = sortProfileItems(profileData.preferences, "confidence");
-        profileData.patterns = sortProfileItems(profileData.patterns, "frequency");
-        profileData.workflows = sortProfileItems(profileData.workflows, "frequency");
-        let indexed;
-        let result;
-        const scopedIds = includeIds && includeIds.length > 0 ? includeIds : undefined;
-        if (scopedIds) {
-            indexed = filterProfileForCleanup(profileData, scopedIds);
-            result = await aiCleanupProfileFromIndexed(indexed);
-        }
-        else {
-            result = await aiCleanupProfile(profileData);
-        }
-        pendingCleanups.set(targetUserId, {
-            cleaned: result.cleaned,
-            oldProfileData: profileData,
-            diff: result.diff,
-            allMerged: result.diff?.merged || [],
-            allRemovedIds: (result.diff?.removed || []).map((r) => r.id),
-            includeIds: scopedIds,
-            profileVersion: profile.version,
-            expiresAt: Date.now() + 30 * 60 * 1000,
-        });
-        return {
-            success: true,
-            data: {
-                old: profileData,
-                new: result.cleaned,
-                changes: result.diff,
-            },
-        };
-    }
-    catch (error) {
-        log("handleAICleanup: error", { error: String(error) });
-        return { success: false, error: String(error) };
-    }
-}
-/**
- * Merge an AI-cleanup result into a full profile.
- * When includeIds is set, only scoped items are mutated; everything else is preserved.
- */
-export function mergeCleanupIntoProfile(args) {
-    const { currentProfile, oldProfileData, cleanedData, includeIds, acceptedMerged = [], acceptedRemoved = [], allMerged = [], allRemovedIds = [], explicitAcceptance = false, } = args;
-    // Start from cleaned data, then restore any rejected removals/merges.
-    const scopedResult = {
-        preferences: [...cleanedData.preferences],
-        patterns: [...cleanedData.patterns],
-        workflows: [...cleanedData.workflows],
-    };
-    if (explicitAcceptance) {
-        for (const id of acceptedRemoved) {
-            removeItemFromProfile(scopedResult, oldProfileData, id);
-        }
-        for (const ids of acceptedMerged) {
-            for (let i = 1; i < ids.length; i++) {
-                removeItemFromProfile(scopedResult, oldProfileData, ids[i] ?? "");
-            }
-        }
-        const acceptedTargetIds = new Set(acceptedMerged.map((g) => g[0]));
-        for (const merge of allMerged) {
-            const groupIds = merge.ids;
-            if (groupIds.length <= 1)
-                continue;
-            if (acceptedTargetIds.has(groupIds[0]))
-                continue;
-            removeOneByDescription(scopedResult, merge.result, itemTypeFromId(groupIds[0] ?? ""));
-            for (const id of groupIds) {
-                if (id)
-                    pushItemFromProfile(scopedResult, oldProfileData, id);
-            }
-        }
-        const acceptedRemovedSet = new Set(acceptedRemoved);
-        for (const removedId of allRemovedIds) {
-            if (acceptedRemovedSet.has(removedId))
-                continue;
-            pushItemFromProfile(scopedResult, oldProfileData, removedId);
-        }
-    }
-    // Full-profile cleanup: cleaned (+ acceptance) replaces the whole profile.
-    if (!includeIds || includeIds.length === 0) {
-        return scopedResult;
-    }
-    // Partial selection: mutate only the analyzed scope inside the current full profile.
-    const result = {
-        preferences: [...currentProfile.preferences],
-        patterns: [...currentProfile.patterns],
-        workflows: [...currentProfile.workflows],
-    };
-    for (const id of includeIds) {
-        removeItemFromProfile(result, oldProfileData, id);
-    }
-    result.preferences.push(...scopedResult.preferences);
-    result.patterns.push(...scopedResult.patterns);
-    result.workflows.push(...scopedResult.workflows);
-    return result;
-}
-function pushItemFromProfile(target, source, id) {
-    const srcItem = findItemById(source, id);
-    if (!srcItem)
-        return;
-    const { id: _id, ...rest } = srcItem;
-    if (id.startsWith("pref_"))
-        target.preferences.push(rest);
-    else if (id.startsWith("pat_"))
-        target.patterns.push(rest);
-    else if (id.startsWith("wf_"))
-        target.workflows.push(rest);
-}
-export async function handleApplyCleanup(userId, body) {
-    try {
-        const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
-        let targetUserId = userId;
-        if (!targetUserId) {
-            targetUserId = (await resolveWebProfileUserId(CONFIG)) || "unknown";
-        }
-        const pending = pendingCleanups.get(targetUserId);
-        if (!pending) {
-            return { success: false, error: "No pending cleanup found. Run AI cleanup first." };
-        }
-        if (Date.now() > pending.expiresAt) {
-            pendingCleanups.delete(targetUserId);
-            return { success: false, error: "Cleanup session expired. Run AI cleanup again." };
-        }
-        const profile = await userProfileManager.getActiveProfile(targetUserId);
-        if (!profile) {
-            return { success: false, error: "Profile not found" };
-        }
-        if (profile.version !== pending.profileVersion) {
-            pendingCleanups.delete(targetUserId);
-            return { success: false, error: "Profile changed. Run AI cleanup again." };
-        }
-        const cleanedData = body?.profile || pending.cleaned;
-        const acceptedMerged = Array.isArray(body?.acceptedMerged)
-            ? body.acceptedMerged
-            : [];
-        const acceptedRemoved = Array.isArray(body?.acceptedRemoved)
-            ? body.acceptedRemoved
-            : [];
-        const explicitAcceptance = Array.isArray(body?.acceptedMerged) || Array.isArray(body?.acceptedRemoved);
-        const existingData = JSON.parse(profile.profileData);
-        const result = mergeCleanupIntoProfile({
-            currentProfile: existingData,
-            oldProfileData: pending.oldProfileData,
-            cleanedData,
-            includeIds: pending.includeIds,
-            acceptedMerged,
-            acceptedRemoved,
-            allMerged: pending.allMerged,
-            allRemovedIds: pending.allRemovedIds,
-            explicitAcceptance,
-        });
-        const partial = (pending.includeIds && pending.includeIds.length > 0) || explicitAcceptance;
-        const success = await saveProfile(profile, result, partial ? "AI cleanup applied (partial)" : "AI cleanup applied");
-        if (!success) {
-            return { success: false, error: "Profile was modified by another session. Please retry." };
-        }
-        pendingCleanups.delete(targetUserId);
-        return {
-            success: true,
-            data: {
-                message: partial ? "Partial cleanup applied" : "Cleanup applied successfully",
-                version: profile.version + 1,
-            },
-        };
-    }
-    catch (error) {
-        log("handleApplyCleanup: error", { error: String(error) });
-        return { success: false, error: String(error) };
-    }
-}
 async function categoryCleanupUser(userId) {
     return userId || (await resolveWebProfileUserId(CONFIG)) || "unknown";
 }
@@ -1144,57 +956,6 @@ export async function handleCategoryCleanupUndo(userId, deps) {
         return categoryCleanupError("undo", error);
     }
 }
-function itemTypeFromId(id) {
-    if (id.startsWith("pref_"))
-        return "preferences";
-    if (id.startsWith("pat_"))
-        return "patterns";
-    return "workflows";
-}
-function findItemById(profile, id) {
-    if (typeof id !== "string" || !id.includes("_"))
-        return null;
-    const parts = id.split("_");
-    const prefix = parts[0];
-    const idx = parseInt(parts[1] || "", 10);
-    if (isNaN(idx))
-        return null;
-    if (prefix === "pref")
-        return profile.preferences[idx] || null;
-    if (prefix === "pat")
-        return profile.patterns[idx] || null;
-    if (prefix === "wf")
-        return profile.workflows[idx] || null;
-    return null;
-}
-function removeItemFromProfile(target, source, id) {
-    const sourceItem = findItemById(source, id);
-    if (!sourceItem)
-        return false;
-    const itemType = itemTypeFromId(id);
-    const items = target[itemType];
-    const sourceKey = profileItemIdentityKey(sourceItem);
-    const index = items.findIndex((item) => profileItemIdentityKey(item) === sourceKey);
-    if (index < 0)
-        return false;
-    items.splice(index, 1);
-    return true;
-}
-function profileItemIdentityKey(item) {
-    return JSON.stringify({
-        category: item.category ?? null,
-        description: item.description ?? null,
-        steps: Array.isArray(item.steps) ? item.steps : null,
-    });
-}
-function removeOneByDescription(profile, desc, itemType) {
-    const items = profile[itemType];
-    const index = items.findIndex((item) => item.description === desc);
-    if (index < 0)
-        return false;
-    items.splice(index, 1);
-    return true;
-}
 export async function handleUpdateProfileItem(body) {
     try {
         const { userProfileManager } = await import("./user-profile/user-profile-manager.js");

package/dist/services/auto-cleanup-handlers.d.ts

@@ -0,0 +1,22 @@
+import type { UserProfileManager } from "./user-profile/user-profile-manager.js";
+import type { AutoCleanupSummary } from "./user-profile/auto-cleanup-store.js";
+interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export interface AutoCleanupHandlerDeps {
+    manager?: Pick<UserProfileManager, "getActiveProfile" | "updateProfile">;
+}
+/** The newest automatic cleanup that can still be undone, without its items. */
+export declare function handleAutoCleanupStatus(userId?: string, deps?: AutoCleanupHandlerDeps): Promise<ApiResponse<AutoCleanupSummary | null>>;
+/**
+ * Undoes the newest automatic cleanup that is not undone, in the newest profile, with the
+ * version check. A save conflict is tried again at most three times; after that the profile
+ * and the record stay as they were.
+ */
+export declare function handleAutoCleanupUndo(userId?: string, deps?: AutoCleanupHandlerDeps): Promise<ApiResponse<{
+    restored: number;
+    notFound: number;
+}>>;
+export {};

package/dist/services/auto-cleanup-handlers.js

@@ -0,0 +1,71 @@
+import { log } from "./logger.js";
+async function cleanupUser(userId) {
+    if (userId)
+        return userId;
+    const { CONFIG } = await import("../config.js");
+    const { resolveWebProfileUserId } = await import("./profile-identity.js");
+    return (await resolveWebProfileUserId(CONFIG)) || "unknown";
+}
+async function managerOf(deps) {
+    return (deps.manager ?? (await import("./user-profile/user-profile-manager.js")).userProfileManager);
+}
+function handlerError(step, error) {
+    // The log never holds profile text, so only the error's kind is kept.
+    log(`Automatic cleanup ${step}: error`, {
+        code: error instanceof Error ? error.name : "unknown",
+    });
+    return { success: false, error: String(error) };
+}
+/** The newest automatic cleanup that can still be undone, without its items. */
+export async function handleAutoCleanupStatus(userId, deps = {}) {
+    try {
+        const { latestOpenAutoCleanupSummary } = await import("./user-profile/auto-cleanup-store.js");
+        const profile = await (await managerOf(deps)).getActiveProfile(await cleanupUser(userId));
+        if (!profile)
+            return { success: true, data: null };
+        return { success: true, data: await latestOpenAutoCleanupSummary(profile.id) };
+    }
+    catch (error) {
+        return handlerError("status", error);
+    }
+}
+/**
+ * Undoes the newest automatic cleanup that is not undone, in the newest profile, with the
+ * version check. A save conflict is tried again at most three times; after that the profile
+ * and the record stay as they were.
+ */
+export async function handleAutoCleanupUndo(userId, deps = {}) {
+    try {
+        const { latestOpenAutoCleanup, markAutoCleanupUndone } = await import("./user-profile/auto-cleanup-store.js");
+        const { undoCleanupEdits } = await import("./user-profile/ai-cleanup-undo.js");
+        const { applyToNewestProfile } = await import("./user-profile/profile-edit-save.js");
+        const user = await cleanupUser(userId);
+        const manager = await managerOf(deps);
+        const profile = await manager.getActiveProfile(user);
+        const record = profile ? await latestOpenAutoCleanup(profile.id) : null;
+        if (!record)
+            return { success: false, error: "Nothing to undo." };
+        const outcome = await applyToNewestProfile(user, (data) => {
+            const undone = undoCleanupEdits(data, record.entries);
+            return {
+                profile: undone.profile,
+                changed: undone.restored > 0,
+                result: { restored: undone.restored, notFound: undone.notFound },
+            };
+        }, { summary: "Automatic cleanup undone", store: manager });
+        if (outcome.status === "no-profile")
+            return { success: false, error: "Nothing to undo." };
+        if (outcome.status === "conflict") {
+            return { success: false, error: "Profile saved at the same moment. Try Undo again." };
+        }
+        await markAutoCleanupUndone(record.id);
+        log("Automatic cleanup undone", {
+            restored: outcome.result.restored,
+            notFound: outcome.result.notFound,
+        });
+        return { success: true, data: outcome.result };
+    }
+    catch (error) {
+        return handlerError("undo", error);
+    }
+}

package/dist/services/cleanup-service.js

@@ -95,6 +95,15 @@ export class CleanupService {
                     code: error instanceof Error ? error.name : "unknown",
                 });
             }
+            try {
+                const { pruneAutoCleanupRecords } = await import("./user-profile/auto-cleanup-store.js");
+                await pruneAutoCleanupRecords();
+            }
+            catch (error) {
+                log("Automatic cleanup record cleanup failed", {
+                    code: error instanceof Error ? error.name : "unknown",
+                });
+            }
             try {
                 await userPromptManager.vacuum();
                 log("Cleanup: VACUUM done", { db: "user-prompts.db" });

package/dist/services/global-config-writer.js

@@ -18,6 +18,8 @@ const keys = new Set([
     "opencodeBackfillModel",
     "piBackfillModel",
     "webServerAutoStart",
+    "userProfileAutoCleanupEnabled",
+    "userProfileAutoCleanupInterval",
     "memoryProvider",
     "memoryApiUrl",
     "memoryModel",
@@ -25,6 +27,7 @@ const keys = new Set([
     "importPathMaps",
     "importIgnoredDirectories",
     "claudeConfigDir",
+    "autoCaptureLanguage",
     "maxMemories",
     "chatMessage.maxMemories",
     "autoCaptureMaxContextBytes",
@@ -69,9 +72,17 @@ function isValidEdit(key, value) {
     if (key === "embeddingDimensions") {
         return Number.isInteger(value) && value > 0 && value <= 65536;
     }
-    if (key === "captureTrace" || key === "autoBackfill" || key === "webServerAutoStart") {
+    if (key === "captureTrace" ||
+        key === "autoBackfill" ||
+        key === "webServerAutoStart" ||
+        key === "userProfileAutoCleanupEnabled") {
         return typeof value === "boolean";
     }
+    // Each automatic cleanup is paid for, so the page refuses an interval that would run one
+    // after almost every learning pass. A hand edit of the file has no floor.
+    if (key === "userProfileAutoCleanupInterval") {
+        return Number.isSafeInteger(value) && value >= 50 && value <= 100000;
+    }
     if (key.endsWith("RetentionDays"))
         return Number.isSafeInteger(value) && value >= 1;
     if (key === "captureRetryRetentionHours") {
@@ -81,6 +92,9 @@ function isValidEdit(key, value) {
         return isSecretReference(value);
     if (key === "memoryProvider")
         return MEMORY_PROVIDERS.includes(value);
+    // "auto", or an ISO 639 code (en, id, zh, fil).
+    if (key === "autoCaptureLanguage")
+        return typeof value === "string" && /^(auto|[a-z]{2,3})$/.test(value);
     // Entries are checked by the startup validation below.
     if (key === "importPathMaps" || key === "importIgnoredDirectories")
         return Array.isArray(value);

package/dist/services/language-detector.js

@@ -7,10 +7,24 @@ const FALLBACK_MAP = {
     arz: "ar", // Egyptian Arabic
     hbs: "sr", // Serbo-Croatian
 };
+// franc guesses wrongly on short Latin-script text (for example "ok go ahead" as Somali),
+// and the capture prompt then asks the model to write the memory in that language.
+// Below this length, Latin-script text counts as English. Non-Latin scripts stay reliable.
+const MIN_LATIN_DETECT_LENGTH = 100;
+function isMostlyLatin(text) {
+    const letters = text.match(/\p{L}/gu) ?? [];
+    if (letters.length === 0)
+        return true;
+    const latin = letters.filter((char) => /\p{Script=Latin}/u.test(char)).length;
+    return latin / letters.length >= 0.5;
+}
 export function detectLanguage(text) {
     if (!text || text.trim().length === 0) {
         return "en";
     }
+    if (text.trim().length < MIN_LATIN_DETECT_LENGTH && isMostlyLatin(text)) {
+        return "en";
+    }
     const detected = franc(text, { minLength: 5 });
     if (detected === "und") {
         return "en";

package/dist/services/profile-cleanup-routes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The profile cleanup routes: AI Cleanup (start, status, stop, apply) and the undo of the
+ * last automatic cleanup. Returns the JSON body, or undefined when the path and method are
+ * not a cleanup route. The body is read only for the routes that need it.
+ */
+export declare function routeProfileCleanup(path: string, method: string, url: URL, readBody: () => Promise<any>): Promise<unknown | undefined>;

package/dist/services/profile-cleanup-routes.js

@@ -0,0 +1,32 @@
+import * as aiCleanup from "./ai-cleanup-handlers.js";
+import * as autoCleanup from "./auto-cleanup-handlers.js";
+/**
+ * The profile cleanup routes: AI Cleanup (start, status, stop, apply) and the undo of the
+ * last automatic cleanup. Returns the JSON body, or undefined when the path and method are
+ * not a cleanup route. The body is read only for the routes that need it.
+ */
+export async function routeProfileCleanup(path, method, url, readBody) {
+    const queryUser = url.searchParams.get("userId") || undefined;
+    if (path === "/api/user-profile/ai-cleanup") {
+        if (method === "POST") {
+            const body = await readBody();
+            return aiCleanup.handleAiCleanupStart(body.userId, body);
+        }
+        if (method === "GET")
+            return aiCleanup.handleAiCleanupStatus(queryUser);
+        if (method === "DELETE")
+            return aiCleanup.handleAiCleanupStop(queryUser);
+    }
+    if (path === "/api/user-profile/ai-cleanup/apply" && method === "POST") {
+        const body = await readBody();
+        return aiCleanup.handleAiCleanupApply(body.userId, body);
+    }
+    if (path === "/api/user-profile/auto-cleanup" && method === "GET") {
+        return autoCleanup.handleAutoCleanupStatus(queryUser);
+    }
+    if (path === "/api/user-profile/auto-cleanup/undo" && method === "POST") {
+        const body = await readBody();
+        return autoCleanup.handleAutoCleanupUndo(body.userId || undefined);
+    }
+    return undefined;
+}

package/dist/services/request-timeouts.d.ts

@@ -1,5 +1,7 @@
 export declare const EXTERNAL_PROFILE_CLEANUP_TIMEOUT_MS = 60000;
 export declare const OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS = 300000;
+/** The most items one web AI cleanup request sends, so each request ends inside its time limit. */
+export declare const AI_CLEANUP_BATCH_SIZE = 100;
 export declare const NODE_HTTP_IDLE_TIMEOUT_MS: number;
 /**
  * Upper bound an OpenCode v2 model request waits for the per-prompt memory

package/dist/services/request-timeouts.js

@@ -1,5 +1,7 @@
 export const EXTERNAL_PROFILE_CLEANUP_TIMEOUT_MS = 60_000;
 export const OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS = 300_000;
+/** The most items one web AI cleanup request sends, so each request ends inside its time limit. */
+export const AI_CLEANUP_BATCH_SIZE = 100;
 const HTTP_TIMEOUT_GRACE_MS = 30_000;
 export const NODE_HTTP_IDLE_TIMEOUT_MS = Math.max(EXTERNAL_PROFILE_CLEANUP_TIMEOUT_MS, OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS) +
     HTTP_TIMEOUT_GRACE_MS;

package/dist/services/settings-snapshot.js

@@ -20,12 +20,15 @@ const editable = [
     "opencodeBackfillModel",
     "piBackfillModel",
     "webServerAutoStart",
+    "userProfileAutoCleanupEnabled",
+    "userProfileAutoCleanupInterval",
     "memoryProvider",
     "memoryApiUrl",
     "memoryModel",
     "importPathMaps",
     "importIgnoredDirectories",
     "claudeConfigDir",
+    "autoCaptureLanguage",
     ...MEMORY_LIMIT_SETTINGS,
 ];
 /** Keys a project config cannot override, so the page always shows the global value. */
@@ -35,6 +38,8 @@ const globalOnly = [
     "opencodeBackfillModel",
     "piBackfillModel",
     "webServerAutoStart",
+    "userProfileAutoCleanupEnabled",
+    "userProfileAutoCleanupInterval",
     "memoryProvider",
     "memoryApiUrl",
     "importPathMaps",

package/dist/services/user-profile/ai-cleanup-apply.d.ts

@@ -0,0 +1,47 @@
+import type { CleanupDiff } from "./ai-cleanup.js";
+import type { UserProfileData } from "./types.js";
+export type Section = "preferences" | "patterns" | "workflows";
+/** What a finished cleanup job keeps for Apply. Ids are positions in `old`. */
+export interface CleanupJobResult {
+    old: UserProfileData;
+    changes: CleanupDiff;
+    mergedItems: Record<string, unknown>;
+}
+export interface AcceptedCleanup {
+    merged?: string[][];
+    removed?: string[];
+}
+/**
+ * What one applied change replaced, as stored. Undo reverses it. A merge holds the original
+ * items and the merged item that was written. A removal holds the original item.
+ */
+export type RestoreEntry = {
+    kind: "merge";
+    section: Section;
+    originals: unknown[];
+    merged: unknown;
+} | {
+    kind: "remove";
+    section: Section;
+    original: unknown;
+};
+export interface AppliedCleanup {
+    profile: UserProfileData;
+    applied: number;
+    skipped: number;
+    restore: RestoreEntry[];
+}
+/**
+ * Puts the ticked changes of a job into `current`, which may be newer than the profile
+ * the job read. Each item is found by section, category, description and steps, so
+ * learning's counters do not break a match. A change is skipped when one of its items is
+ * gone. Every other item stays exactly as stored. Ticked ids that are not changes of
+ * the job are ignored.
+ */
+export declare function applyCleanupEdits(current: UserProfileData, job: CleanupJobResult, accepted: AcceptedCleanup): AppliedCleanup;
+/**
+ * The fields that identify a profile item. Counters and vectors are left out. The category
+ * counts by its key, because every save keeps one visible spelling per category and may
+ * rewrite the spelling of a stored item.
+ */
+export declare function profileItemIdentityKey(item: any): string;

package/dist/services/user-profile/ai-cleanup-apply.js

@@ -0,0 +1,108 @@
+import { categoryKey } from "./profile-category.js";
+const SECTION_BY_PREFIX = {
+    pref: "preferences",
+    pat: "patterns",
+    wf: "workflows",
+};
+/**
+ * Puts the ticked changes of a job into `current`, which may be newer than the profile
+ * the job read. Each item is found by section, category, description and steps, so
+ * learning's counters do not break a match. A change is skipped when one of its items is
+ * gone. Every other item stays exactly as stored. Ticked ids that are not changes of
+ * the job are ignored.
+ */
+export function applyCleanupEdits(current, job, accepted) {
+    const profile = {
+        ...current,
+        preferences: [...current.preferences],
+        patterns: [...current.patterns],
+        workflows: [...current.workflows],
+    };
+    const merges = new Map(job.changes.merged.map((m) => [m.ids.join(","), m.ids]));
+    const removals = new Set(job.changes.removed.map((r) => r.id));
+    const used = new Set();
+    const restore = [];
+    let applied = 0;
+    let skipped = 0;
+    for (const ticked of accepted.merged ?? []) {
+        const ids = Array.isArray(ticked) ? merges.get(ticked.join(",")) : undefined;
+        if (!ids || ids.length < 2)
+            continue;
+        const mergedItem = job.mergedItems[ids[0]];
+        const found = mergedItem ? locate(profile, job.old, ids, used) : null;
+        if (!found) {
+            skipped++;
+            continue;
+        }
+        const items = profile[found.section];
+        const written = { ...mergedItem };
+        restore.push({
+            kind: "merge",
+            section: found.section,
+            originals: found.indices.map((index) => items[index]),
+            merged: written,
+        });
+        items[found.indices[0]] = written;
+        for (const index of found.indices.slice(1).sort((a, b) => b - a))
+            items.splice(index, 1);
+        for (const id of ids)
+            used.add(id);
+        applied++;
+    }
+    for (const id of accepted.removed ?? []) {
+        if (typeof id !== "string" || !removals.has(id))
+            continue;
+        const found = locate(profile, job.old, [id], used);
+        if (!found) {
+            skipped++;
+            continue;
+        }
+        const [removed] = profile[found.section].splice(found.indices[0], 1);
+        restore.push({ kind: "remove", section: found.section, original: removed });
+        used.add(id);
+        applied++;
+    }
+    return { profile, applied, skipped, restore };
+}
+/**
+ * Finds each id's item from `old` in `profile`, at a distinct position, all in one
+ * section. Returns null when an item is gone or an earlier change already used it.
+ */
+function locate(profile, old, ids, used) {
+    const section = sectionOf(ids[0]);
+    if (!section)
+        return null;
+    const items = profile[section];
+    const indices = [];
+    for (const id of ids) {
+        if (used.has(id) || sectionOf(id) !== section)
+            return null;
+        const source = old[section][positionOf(id)];
+        if (!source)
+            return null;
+        const key = profileItemIdentityKey(source);
+        const index = items.findIndex((item, i) => !indices.includes(i) && profileItemIdentityKey(item) === key);
+        if (index < 0)
+            return null;
+        indices.push(index);
+    }
+    return { section, indices };
+}
+function sectionOf(id) {
+    return SECTION_BY_PREFIX[id.split("_")[0] ?? ""];
+}
+function positionOf(id) {
+    return Number.parseInt(id.split("_")[1] ?? "", 10);
+}
+/**
+ * The fields that identify a profile item. Counters and vectors are left out. The category
+ * counts by its key, because every save keeps one visible spelling per category and may
+ * rewrite the spelling of a stored item.
+ */
+export function profileItemIdentityKey(item) {
+    return JSON.stringify({
+        category: item.category == null ? null : categoryKey(String(item.category)),
+        description: item.description ?? null,
+        steps: Array.isArray(item.steps) ? item.steps : null,
+    });
+}