om-memory-system 4.18.0 → 4.19.1

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/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();
@@ -1054,7 +1054,7 @@ export async function handleApplyCleanup(userId, body) {
             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");
+        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." };
         }
@@ -1243,7 +1243,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);

package/dist/services/user-profile/merge-and-save.d.ts

@@ -0,0 +1,25 @@
+import type { UserProfile, UserProfileData } from "./types.js";
+/** Learning makes this many save attempts before it leaves the prompts for a later run. */
+export declare const MAX_PROFILE_SAVE_ATTEMPTS = 3;
+/** The profile store operations that a save needs. */
+export interface ProfileSaveStore {
+    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, expectedVersion: number): Promise<boolean>;
+}
+type ReadProfile = Pick<UserProfile, "id" | "version">;
+/**
+ * Saves `data` over the profile as the caller read it. Returns false, and changes nothing,
+ * when another save landed since. The log holds a code only, never profile content.
+ */
+export declare function saveProfile(profile: ReadProfile, data: UserProfileData, summary: string, promptsAnalyzed?: number, store?: Pick<ProfileSaveStore, "updateProfile">): Promise<boolean>;
+/**
+ * Saves the merged result of a profile analysis. When another save landed first, it loads
+ * the newer profile, merges the same model result into it, and saves again. It never calls
+ * the model. Returns false when there is nothing to save or every attempt met a newer version.
+ */
+export declare function saveMergedProfile(store: ProfileSaveStore, profile: ReadProfile, analysis: {
+    raw: Partial<UserProfileData>;
+    merged: UserProfileData | null;
+}, promptsAnalyzed: number, summary: string): Promise<boolean>;
+export {};

package/dist/services/user-profile/merge-and-save.js

@@ -0,0 +1,38 @@
+import { log } from "../logger.js";
+/** Learning makes this many save attempts before it leaves the prompts for a later run. */
+export const MAX_PROFILE_SAVE_ATTEMPTS = 3;
+/**
+ * Saves `data` over the profile as the caller read it. Returns false, and changes nothing,
+ * when another save landed since. The log holds a code only, never profile content.
+ */
+export async function saveProfile(profile, data, summary, promptsAnalyzed = 0, store) {
+    const target = store ?? (await import("./user-profile-manager.js")).userProfileManager;
+    const saved = await target.updateProfile(profile.id, data, promptsAnalyzed, summary, profile.version);
+    if (!saved)
+        log("profile save skipped", { code: "version-changed" });
+    return saved;
+}
+/**
+ * Saves the merged result of a profile analysis. When another save landed first, it loads
+ * the newer profile, merges the same model result into it, and saves again. It never calls
+ * the model. Returns false when there is nothing to save or every attempt met a newer version.
+ */
+export async function saveMergedProfile(store, profile, analysis, promptsAnalyzed, summary) {
+    let merged = analysis.merged;
+    let version = profile.version;
+    for (let attempt = 1; merged && attempt <= MAX_PROFILE_SAVE_ATTEMPTS; attempt++) {
+        if (await store.updateProfile(profile.id, merged, promptsAnalyzed, summary, version)) {
+            return true;
+        }
+        log("profile save conflict", { attempt, of: MAX_PROFILE_SAVE_ATTEMPTS });
+        if (attempt === MAX_PROFILE_SAVE_ATTEMPTS)
+            break;
+        const fresh = await store.getProfileById(profile.id);
+        if (!fresh)
+            return false;
+        const current = JSON.parse(fresh.profileData);
+        merged = await store.mergeProfileData(current, analysis.raw, undefined, fresh.id);
+        version = fresh.version;
+    }
+    return false;
+}

package/dist/services/user-profile/user-profile-manager.d.ts

@@ -20,8 +20,8 @@ export declare class UserProfileManager {
     getActiveProfile(userId: string): Promise<UserProfile | null>;
     createProfile(userId: string, displayName: string, userName: string, userEmail: string, profileData: UserProfileData, promptsAnalyzed: number): Promise<string>;
     updateProfile(profileId: string, profileData: UserProfileData, additionalPromptsAnalyzed: number, changeSummary: string, 
-    /** When given, refuse the save unless the stored version still equals it. */
-    expectedVersion?: number): Promise<boolean>;
+    /** The version the caller read. The save is refused when the stored version differs. */
+    expectedVersion: number): Promise<boolean>;
     private addChangelog;
     private cleanupOldChangelogs;
     getProfileChangelogs(profileId: string, limit?: number): Promise<UserProfileChangelog[]>;

package/dist/services/user-profile/user-profile-manager.js

@@ -274,7 +274,7 @@ export class UserProfileManager {
         return id;
     }
     async updateProfile(profileId, profileData, additionalPromptsAnalyzed, changeSummary, 
-    /** When given, refuse the save unless the stored version still equals it. */
+    /** The version the caller read. The save is refused when the stored version differs. */
     expectedVersion) {
         const db = await this.ready();
         const now = Date.now();
@@ -286,7 +286,7 @@ export class UserProfileManager {
         });
         const versionRow = await db.get(`SELECT version FROM user_profiles WHERE id = ?`, [profileId]);
         const currentVersion = Number(versionRow?.version ?? 0);
-        if (expectedVersion !== undefined && currentVersion !== expectedVersion)
+        if (currentVersion !== expectedVersion)
             return false;
         const newVersion = currentVersion + 1;
         const changes = await db.run(`