om-memory-system 4.18.0 → 4.20.0

package/dist/adapters/opencode/profile-learning.js

@@ -5,6 +5,7 @@ import { CONFIG, refreshConfigIfChanged } from "../../config.js";
 import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js";
 import { userPromptManager } from "../../services/user-prompt/user-prompt-manager.js";
 import { userProfileManager } from "../../services/user-profile/user-profile-manager.js";
+import { saveProfile } from "../../services/user-profile/merge-and-save.js";
 import { sortProfileItems } from "../../utils/profile.js";
 import { truncateToMaxBytes } from "../../utils/context-limit.js";
 import { loadOpencodeProvider } from "./opencode-provider-loader.js";
@@ -29,7 +30,8 @@ async function runAutomaticProfileCleanup(userId) {
         const result = await aiCleanupProfile(profileData);
         if (result.diff.merged.length === 0 && result.diff.removed.length === 0)
             return;
-        const updated = await userProfileManager.updateProfile(profile.id, result.cleaned, 0, `Automatic AI cleanup: ${result.diff.merged.length} merged, ${result.diff.removed.length} removed`);
+        const summary = `Automatic AI cleanup: ${result.diff.merged.length} merged, ${result.diff.removed.length} removed`;
+        const updated = await saveProfile(profile, result.cleaned, summary);
         log("user-profile-learning: automatic cleanup complete", {
             userId,
             updated,
@@ -177,7 +179,7 @@ Rules:
                 if (validationSummary) {
                     changeSummary = changeSummary + "; " + validationSummary;
                 }
-                success = await userProfileManager.updateProfile(existingProfile.id, updatedProfileData, prompts.length, changeSummary);
+                success = await saveProfile(existingProfile, updatedProfileData, changeSummary, prompts.length);
                 if (!success) {
                     log("User profile update conflict, retrying", {
                         profileId: existingProfile.id,
@@ -188,13 +190,12 @@ Rules:
                 retries++;
             }
             if (!success) {
-                // Mark the batch anyway so the same prompts are not retried forever
-                // (token burn + repeated toasts on every subsequent idle).
+                // Keep the prompts for a later run; the backoff stops a retry on every idle.
                 log("User profile update conflict: exhausted retries", {
                     profileId: existingProfile?.id,
                     userId,
                 });
-                await userPromptManager.markMultipleAsUserLearningCaptured(prompts.map((p) => p.id));
+                recordProfileFailure("opencode", "user-profile-learning: conflict", new Error("conflict"));
                 return;
             }
             await userPromptManager.markMultipleAsUserLearningCaptured(prompts.map((p) => p.id));
@@ -664,5 +665,5 @@ If no clear chains, return { "paths": [] }.`;
         return;
     const data = JSON.parse(profile.profileData);
     data.learning_paths = result.paths;
-    await userProfileManager.updateProfile(profileId, data, 0, `Updated learning paths: ${result.paths.map((p) => p.topic).join(", ")}`);
+    await saveProfile(profile, data, `Updated learning paths: ${result.paths.map((p) => p.topic).join(", ")}`);
 }

package/dist/adapters/pi/profile.js

@@ -62,6 +62,7 @@ export async function performPiProfileLearning(input) {
         }
         const userId = tags.user.userEmail;
         const { userProfileManager } = await import("../../services/user-profile/user-profile-manager.js");
+        const { saveMergedProfile } = await import("../../services/user-profile/merge-and-save.js");
         const existing = await userProfileManager.getActiveProfile(userId);
         const resolveProfileModel = input.resolveProfileModel;
         const analyzer = resolveProfileModel
@@ -79,7 +80,7 @@ export async function performPiProfileLearning(input) {
             return;
         }
         if (existing && analysis.merged) {
-            const updated = await userProfileManager.updateProfile(existing.id, analysis.merged, input.prompts.length, `Pi analysis of ${input.prompts.length} prompts`);
+            const updated = await saveMergedProfile(userProfileManager, existing, analysis, input.prompts.length, `Pi analysis of ${input.prompts.length} prompts`);
             if (!updated) {
                 log("pi profile learning: update conflict", { profileId: existing.id });
                 return;

package/dist/cli/profile-normalise-categories-command.js

@@ -69,7 +69,7 @@ export async function runProfileNormaliseCategoriesCommand(argv, print = console
             print("Preview only. Run again with --yes to save.");
             return 0;
         }
-        const saved = await userProfileManager.updateProfile(profile.id, after, 0, `Normalised profile categories: ${changes} items renamed`);
+        const saved = await userProfileManager.updateProfile(profile.id, after, 0, `Normalised profile categories: ${changes} items renamed`, profile.version);
         if (!saved)
             throw new Error("Profile was modified by another session. Please retry.");
         print("Category renames saved. The previous snapshot remains in the profile changelog.");

package/dist/core/memory-operations.js

@@ -145,6 +145,7 @@ export async function executeMemoryOperation(args, context) {
                     };
                 }
                 const { userProfileManager } = await import("../services/user-profile/user-profile-manager.js");
+                const { saveMergedProfile } = await import("../services/user-profile/merge-and-save.js");
                 const userId = tags.user.userEmail || "unknown";
                 if (args.content !== undefined) {
                     const trimmed = args.content.trim();
@@ -172,8 +173,15 @@ export async function executeMemoryOperation(args, context) {
                     const existingProfile = await userProfileManager.getActiveProfile(userId);
                     if (existingProfile) {
                         const existingData = JSON.parse(existingProfile.profileData);
-                        const mergedData = await userProfileManager.mergeProfileData(existingData, { preferences: [newPreference] }, undefined, existingProfile.id);
-                        await userProfileManager.updateProfile(existingProfile.id, mergedData, 0, `Explicit preference added: ${sanitizedContent.slice(0, 80)}`);
+                        const raw = { preferences: [newPreference] };
+                        const mergedData = await userProfileManager.mergeProfileData(existingData, raw, undefined, existingProfile.id);
+                        const saved = await saveMergedProfile(userProfileManager, existingProfile, { raw, merged: mergedData }, 0, `Explicit preference added: ${sanitizedContent.slice(0, 80)}`);
+                        if (!saved) {
+                            return {
+                                success: false,
+                                error: "The profile changed while saving. Try again.",
+                            };
+                        }
                         return { success: true, message: "Preference saved to profile" };
                     }
                     await userProfileManager.createProfile(userId, tags.user.displayName || userId, tags.user.userName || userId, tags.user.userEmail || userId, { preferences: [newPreference], patterns: [], workflows: [] }, 0);

package/dist/importer/claude-hook-api.js

@@ -449,8 +449,8 @@ async function learnProfile(directory, deps) {
         const context = batch.map((prompt, index) => `${index + 1}. ${prompt.content}`).join("\n");
         const analysis = await analyzeProfile(model, context, existing ? { id: existing.id, profileData: existing.profileData } : null);
         if (existing) {
-            const updated = analysis.merged &&
-                (await userProfileManager.updateProfile(existing.id, analysis.merged, batch.length, `Claude Code analysis of ${batch.length} prompts`));
+            const { saveMergedProfile } = await import("../services/user-profile/merge-and-save.js");
+            const updated = await saveMergedProfile(userProfileManager, existing, analysis, batch.length, `Claude Code analysis of ${batch.length} prompts`);
             if (!updated)
                 throw new Error("Profile update conflict");
         }

package/dist/importer/profile-backlog.d.ts

@@ -3,7 +3,7 @@ import { type ProfileFailureCode } from "../core/profile-failure.js";
 import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
 import { userPromptManager } from "../services/user-prompt/user-prompt-manager.js";
 export type BacklogPromptStore = Pick<typeof userPromptManager, "countUnanalyzedForUserLearning" | "getPromptsForUserLearning" | "markMultipleAsUserLearningCaptured"> & Partial<Pick<typeof userPromptManager, "skipTrivialPromptsForLearning">>;
-export type BacklogProfileStore = Pick<typeof userProfileManager, "getActiveProfile" | "createProfile" | "updateProfile">;
+export type BacklogProfileStore = Pick<typeof userProfileManager, "getActiveProfile" | "getProfileById" | "createProfile" | "mergeProfileData" | "updateProfile">;
 export interface DrainProfileBacklogOptions {
     user: {
         userEmail: string;

package/dist/importer/profile-backlog.js

@@ -1,5 +1,6 @@
 import { analyzeProfile } from "../core/profile-analysis.js";
 import { profileFailureCode } from "../core/profile-failure.js";
+import { saveMergedProfile } from "../services/user-profile/merge-and-save.js";
 import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
 import { userPromptManager } from "../services/user-prompt/user-prompt-manager.js";
 /**
@@ -54,8 +55,8 @@ export async function drainProfileBacklog(options) {
                 const context = batch.map((item, index) => `${index + 1}. ${item.content}`).join("\n");
                 const analysis = await analyzeProfile(model, context, existing ? { id: existing.id, profileData: existing.profileData } : null);
                 if (existing) {
-                    if (!analysis.merged ||
-                        !(await profiles.updateProfile(existing.id, analysis.merged, batch.length, `${label} of ${batch.length} prompts`)))
+                    const summary = `${label} of ${batch.length} prompts`;
+                    if (!(await saveMergedProfile(profiles, existing, analysis, batch.length, summary)))
                         throw new Error("Profile update conflict");
                 }
                 else {

package/dist/importer/profile-import.d.ts

@@ -13,7 +13,7 @@ export interface ProfileImportReport {
     error?: string;
 }
 type PromptStore = Pick<typeof userPromptManager, "savePrompt" | "markAsCaptured" | "countUnanalyzedForUserLearning" | "getPromptsForUserLearning" | "markMultipleAsUserLearningCaptured" | "markForUserLearning">;
-type ProfileStore = Pick<typeof userProfileManager, "getActiveProfile" | "createProfile" | "updateProfile">;
+type ProfileStore = Pick<typeof userProfileManager, "getActiveProfile" | "getProfileById" | "createProfile" | "mergeProfileData" | "updateProfile">;
 type Ledger = Pick<ImportLedger, "get" | "begin" | "complete"> & Partial<Pick<ImportLedger, "peek">>;
 export interface ProfileImportOptions {
     host: MemoryHost;

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

@@ -0,0 +1,31 @@
+import type { UserProfileManager } from "./user-profile/user-profile-manager.js";
+import type { AiCleanupJobDeps, AiCleanupJobView } from "./user-profile/ai-cleanup-job.js";
+interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export interface AiCleanupHandlerDeps extends AiCleanupJobDeps {
+    manager?: UserProfileManager;
+}
+/**
+ * Starts a background cleanup of the selected items, or returns the job already running.
+ * A stale `profileVersion` fails at once, because the dialog's item ids are positions in
+ * the profile it read.
+ */
+export declare function handleAiCleanupStart(userId?: string, body?: any, deps?: AiCleanupHandlerDeps): Promise<ApiResponse<AiCleanupJobView | null>>;
+/** The state of the user's job, or null when there is none. */
+export declare function handleAiCleanupStatus(userId?: string): Promise<ApiResponse<AiCleanupJobView | null>>;
+/** Stops a running job, or discards a finished one. */
+export declare function handleAiCleanupStop(userId?: string): Promise<ApiResponse<null>>;
+/**
+ * Puts the ticked changes of the finished job into the newest profile and saves it with
+ * the version check. When another save lands first, it loads the profile and tries
+ * again, at most MAX_PROFILE_SAVE_ATTEMPTS times. The request's `profile` field is
+ * ignored; the job holds the result.
+ */
+export declare function handleAiCleanupApply(userId?: string, body?: any, deps?: AiCleanupHandlerDeps): Promise<ApiResponse<{
+    applied: number;
+    skipped: number;
+}>>;
+export {};

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

@@ -0,0 +1,126 @@
+import { log } from "./logger.js";
+import { sortProfileItems, stripProfileVectors } from "../utils/profile.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(`AI cleanup ${step}: error`, { code: error instanceof Error ? error.name : "unknown" });
+    return { success: false, error: String(error) };
+}
+/** The profile in the order the dialog lists it, so item ids match its positions. */
+function sortedProfile(profileData) {
+    const data = JSON.parse(profileData);
+    data.preferences = sortProfileItems(data.preferences, "confidence");
+    data.patterns = sortProfileItems(data.patterns, "frequency");
+    data.workflows = sortProfileItems(data.workflows, "frequency");
+    return data;
+}
+/** The job as the dialog sees it: no vectors, and no API key in an error. */
+async function clientView(job) {
+    if (job?.status.state === "done") {
+        const result = { ...job.status.result, old: stripProfileVectors(job.status.result.old) };
+        return { ...job, status: { ...job.status, result } };
+    }
+    if (job?.status.state === "failed") {
+        const { CONFIG } = await import("../config.js");
+        const { redactTraceText } = await import("./capture-diagnostics.js");
+        return { ...job, status: { ...job.status, error: redactTraceText(job.status.error, CONFIG) } };
+    }
+    return job;
+}
+/**
+ * Starts a background cleanup of the selected items, or returns the job already running.
+ * A stale `profileVersion` fails at once, because the dialog's item ids are positions in
+ * the profile it read.
+ */
+export async function handleAiCleanupStart(userId, body, deps = {}) {
+    try {
+        const { getAiCleanupJob, startAiCleanupJob } = await import("./user-profile/ai-cleanup-job.js");
+        const user = await cleanupUser(userId);
+        const current = getAiCleanupJob(user);
+        if (current?.status.state === "running")
+            return { success: true, data: current };
+        const profile = await (await managerOf(deps)).getActiveProfile(user);
+        if (!profile)
+            return { success: false, error: "No profile found to clean up" };
+        if (typeof body?.profileVersion === "number" && profile.version !== body.profileVersion) {
+            return { success: false, error: "Profile changed. Reload it before running AI cleanup." };
+        }
+        const includeIds = Array.isArray(body?.includeIds)
+            ? body.includeIds.filter((id) => typeof id === "string")
+            : undefined;
+        const job = startAiCleanupJob(user, { profileData: sortedProfile(profile.profileData), includeIds }, deps);
+        return { success: true, data: await clientView(job) };
+    }
+    catch (error) {
+        return handlerError("start", error);
+    }
+}
+/** The state of the user's job, or null when there is none. */
+export async function handleAiCleanupStatus(userId) {
+    try {
+        const { getAiCleanupJob } = await import("./user-profile/ai-cleanup-job.js");
+        return { success: true, data: await clientView(getAiCleanupJob(await cleanupUser(userId))) };
+    }
+    catch (error) {
+        return handlerError("status", error);
+    }
+}
+/** Stops a running job, or discards a finished one. */
+export async function handleAiCleanupStop(userId) {
+    try {
+        const { stopAiCleanupJob } = await import("./user-profile/ai-cleanup-job.js");
+        stopAiCleanupJob(await cleanupUser(userId));
+        return { success: true, data: null };
+    }
+    catch (error) {
+        return handlerError("stop", error);
+    }
+}
+/**
+ * Puts the ticked changes of the finished job into the newest profile and saves it with
+ * the version check. When another save lands first, it loads the profile and tries
+ * again, at most MAX_PROFILE_SAVE_ATTEMPTS times. The request's `profile` field is
+ * ignored; the job holds the result.
+ */
+export async function handleAiCleanupApply(userId, body, deps = {}) {
+    try {
+        const { getAiCleanupResult, stopAiCleanupJob } = await import("./user-profile/ai-cleanup-job.js");
+        const { applyCleanupEdits } = await import("./user-profile/ai-cleanup-apply.js");
+        const { MAX_PROFILE_SAVE_ATTEMPTS, saveProfile } = await import("./user-profile/merge-and-save.js");
+        const user = await cleanupUser(userId);
+        const job = getAiCleanupResult(user);
+        if (!job)
+            return { success: false, error: "No finished cleanup found. Run AI cleanup again." };
+        const accepted = {
+            merged: Array.isArray(body?.acceptedMerged) ? body.acceptedMerged : [],
+            removed: Array.isArray(body?.acceptedRemoved) ? body.acceptedRemoved : [],
+        };
+        const manager = await managerOf(deps);
+        for (let attempt = 1; attempt <= MAX_PROFILE_SAVE_ATTEMPTS; attempt++) {
+            const profile = await manager.getActiveProfile(user);
+            if (!profile)
+                return { success: false, error: "Profile not found" };
+            const result = applyCleanupEdits(JSON.parse(profile.profileData), job, accepted);
+            const saved = result.applied === 0 ||
+                (await saveProfile(profile, result.profile, "AI cleanup applied", 0, manager));
+            if (saved) {
+                stopAiCleanupJob(user);
+                return { success: true, data: { applied: result.applied, skipped: result.skipped } };
+            }
+            log("AI cleanup apply: save conflict", { attempt, of: MAX_PROFILE_SAVE_ATTEMPTS });
+        }
+        return { success: false, error: "Profile saved at the same moment. Try Apply again." };
+    }
+    catch (error) {
+        return handlerError("apply", error);
+    }
+}

package/dist/services/api-handlers.d.ts

@@ -1,6 +1,5 @@
 import { type KeywordCount } from "./keyword-counts.js";
 import type { MemoryType } from "../types/index.js";
-import type { UserProfileData } from "./user-profile/types.js";
 interface ApiResponse<T = any> {
     success: boolean;
     data?: T;
@@ -148,27 +147,6 @@ export declare function handleGetUserProfile(userId?: string): Promise<ApiRespon
 export declare function handleGetProfileChangelog(profileId: string, limit?: number): Promise<ApiResponse<any[]>>;
 export declare function handleGetProfileSnapshot(changelogId: string): Promise<ApiResponse<any>>;
 export declare function handleRefreshProfile(userId?: string): Promise<ApiResponse<any>>;
-export declare function handleAICleanup(userId?: string, includeIds?: string[], profileVersion?: number): Promise<ApiResponse<any>>;
-/**
- * Merge an AI-cleanup result into a full profile.
- * When includeIds is set, only scoped items are mutated; everything else is preserved.
- */
-export declare function mergeCleanupIntoProfile(args: {
-    currentProfile: UserProfileData;
-    oldProfileData: UserProfileData;
-    cleanedData: UserProfileData;
-    includeIds?: string[];
-    acceptedMerged?: string[][];
-    acceptedRemoved?: string[];
-    allMerged?: Array<{
-        ids: string[];
-        result: string;
-    }>;
-    allRemovedIds?: string[];
-    /** True when the client sent acceptance arrays (even if empty = reject all). */
-    explicitAcceptance?: boolean;
-}): UserProfileData;
-export declare function handleApplyCleanup(userId?: string, body?: any): Promise<ApiResponse<any>>;
 type CategoryCleanupDeps = import("./user-profile/category-cleanup.js").CleanupDeps;
 /** Starts a background preview job, or returns the one already running. Changes nothing in the profile. */
 export declare function handleCategoryCleanupStart(userId?: string, deps?: CategoryCleanupDeps): Promise<ApiResponse<any>>;

package/dist/services/api-handlers.js

@@ -9,6 +9,7 @@ import { log } from "./logger.js";
 import { countKeywords } from "./keyword-counts.js";
 import { CONFIG } from "../config.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
+import { saveProfile } from "./user-profile/merge-and-save.js";
 import { sortProfileItems, stripProfileVectors } from "../utils/profile.js";
 import { resolveWebProfileUserId } from "./profile-identity.js";
 async function getAllMemoryShards() {
@@ -863,8 +864,7 @@ export async function handleRefreshProfile(userId) {
             const pData = JSON.parse(profile.profileData);
             const { data: decayed, hasChanges } = userProfileManager.decayInMemory(pData);
             if (hasChanges) {
-                await userProfileManager.updateProfile(profile.id, decayed, 0, "Applied confidence decay");
-                decayApplied = true;
+                decayApplied = await saveProfile(profile, decayed, "Applied confidence decay");
             }
         }
         const unanalyzedCount = await userPromptManager.countUnanalyzedForUserLearning();
@@ -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 userProfileManager.updateProfile(profile.id, result, 0, 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");
@@ -1243,7 +1004,7 @@ export async function handleUpdateProfileItem(body) {
         const changeSummary = action === "delete"
             ? `Deleted ${type.slice(0, -1)} at index ${index}`
             : `Edited ${type.slice(0, -1)} at index ${index}`;
-        const success = await userProfileManager.updateProfile(profile.id, profileData, 0, changeSummary);
+        const success = await saveProfile(profile, profileData, changeSummary);
         if (!success)
             return { success: false, error: "Profile was modified by another session. Please retry." };
         return {

package/dist/services/profile-admin.d.ts

@@ -4,7 +4,7 @@ export interface ProfileAdminStore {
     getAllActiveProfiles(): Promise<UserProfile[]>;
     getProfileById(id: string): Promise<UserProfile | null>;
     mergeProfileData(existing: UserProfileData, updates: Partial<UserProfileData>, embedService?: undefined, profileId?: string): Promise<UserProfileData>;
-    updateProfile(profileId: string, profileData: UserProfileData, additionalPromptsAnalyzed: number, changeSummary: string): Promise<boolean>;
+    updateProfile(profileId: string, profileData: UserProfileData, additionalPromptsAnalyzed: number, changeSummary: string, expectedVersion: number): Promise<boolean>;
     deactivateProfile(profileId: string): Promise<boolean>;
 }
 export interface ProfileSummary {

package/dist/services/profile-admin.js

@@ -44,7 +44,7 @@ export async function mergeProfiles(store, sourceId, targetId) {
         throw new ProfileAdminError("Both profiles must exist and be active", 404);
     }
     const merged = await store.mergeProfileData(parse(target), parse(source), undefined, target.id);
-    const saved = await store.updateProfile(target.id, merged, source.totalPromptsAnalyzed, `Merged profile ${source.userId}`);
+    const saved = await store.updateProfile(target.id, merged, source.totalPromptsAnalyzed, `Merged profile ${source.userId}`, target.version);
     if (!saved)
         throw new ProfileAdminError("Profile was changed by another session. Retry.", 409);
     await store.deactivateProfile(source.id);