om-memory-system 4.14.1 → 4.16.1

package/dist/services/user-profile/category-groups.js

@@ -0,0 +1,171 @@
+import { createHash } from "node:crypto";
+import { canonicaliseCategories, categoryKey } from "./profile-category.js";
+/** Average cosine similarity at which two groups of category names count as one meaning. */
+export const CATEGORY_GROUP_THRESHOLD = 0.8;
+const RESERVED_EXPLICIT = "explicit";
+/** Distinct labels across preferences and patterns after the spelling rules, most used first. */
+export function collectCategoryLabels(profile) {
+    const canonical = canonicaliseCategories(profile);
+    const counts = new Map();
+    for (const item of [...canonical.preferences, ...canonical.patterns]) {
+        counts.set(item.category, (counts.get(item.category) ?? 0) + 1);
+    }
+    return [...counts]
+        .map(([label, count]) => ({ label, count }))
+        .sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+}
+function cosine(a, b) {
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return normA && normB ? dot / Math.sqrt(normA * normB) : 0;
+}
+export function groupId(labels) {
+    const keys = labels.map((entry) => categoryKey(entry.label)).sort();
+    return createHash("sha256").update(JSON.stringify(keys)).digest("hex").slice(0, 12);
+}
+/**
+ * Average-linkage clustering of one connected component. Two clusters merge while
+ * the mean similarity over all their member pairs reaches the threshold, so a
+ * chain A-B-C does not pull A and C together through B.
+ */
+function clusterComponent(members, sim, threshold) {
+    let clusters = members.map((member) => [member]);
+    const pairSim = new Map();
+    const key = (a, b) => (a < b ? `${a}:${b}` : `${b}:${a}`);
+    for (let a = 0; a < clusters.length; a++) {
+        for (let b = a + 1; b < clusters.length; b++) {
+            pairSim.set(key(a, b), sim(members[a], members[b]));
+        }
+    }
+    const ids = clusters.map((_, index) => index);
+    const byId = new Map(ids.map((id, index) => [id, clusters[index]]));
+    let nextId = ids.length;
+    for (;;) {
+        let best = -Infinity;
+        let pair = null;
+        const live = [...byId.keys()];
+        for (let i = 0; i < live.length; i++) {
+            for (let j = i + 1; j < live.length; j++) {
+                const value = pairSim.get(key(live[i], live[j]));
+                if (value > best) {
+                    best = value;
+                    pair = [live[i], live[j]];
+                }
+            }
+        }
+        if (!pair || best < threshold)
+            break;
+        const [a, b] = pair;
+        const sizeA = byId.get(a).length;
+        const sizeB = byId.get(b).length;
+        const merged = nextId++;
+        for (const other of live) {
+            if (other === a || other === b)
+                continue;
+            const value = (sizeA * pairSim.get(key(a, other)) + sizeB * pairSim.get(key(b, other))) /
+                (sizeA + sizeB);
+            pairSim.set(key(merged, other), value);
+        }
+        byId.set(merged, [...byId.get(a), ...byId.get(b)]);
+        byId.delete(a);
+        byId.delete(b);
+    }
+    clusters = [...byId.values()];
+    return clusters.filter((cluster) => cluster.length >= 2);
+}
+/**
+ * Groups category names that mean the same thing. Only labels joined by at least one
+ * pair at or above the threshold can share a group, so clustering runs per connected
+ * component of that graph. A group needs two labels; `explicit` never joins one.
+ */
+export function groupCategoryLabels(labels, threshold = CATEGORY_GROUP_THRESHOLD) {
+    const usable = labels.filter((entry) => categoryKey(entry.label) !== RESERVED_EXPLICIT);
+    const cache = new Map();
+    const sim = (i, j) => {
+        const cacheKey = i < j ? `${i}:${j}` : `${j}:${i}`;
+        let value = cache.get(cacheKey);
+        if (value === undefined) {
+            value = cosine(usable[i].vector, usable[j].vector);
+            cache.set(cacheKey, value);
+        }
+        return value;
+    };
+    const parent = usable.map((_, index) => index);
+    const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i])));
+    for (let i = 0; i < usable.length; i++) {
+        for (let j = i + 1; j < usable.length; j++) {
+            if (sim(i, j) >= threshold)
+                parent[find(i)] = find(j);
+        }
+    }
+    const components = new Map();
+    usable.forEach((_, index) => {
+        const root = find(index);
+        components.set(root, [...(components.get(root) ?? []), index]);
+    });
+    const groups = [];
+    for (const members of components.values()) {
+        if (members.length < 2)
+            continue;
+        for (const cluster of clusterComponent(members, sim, threshold)) {
+            const entries = cluster
+                .map((index) => ({ label: usable[index].label, count: usable[index].count }))
+                .sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+            groups.push({ id: groupId(entries), labels: entries });
+        }
+    }
+    const total = (group) => group.labels.reduce((sum, entry) => sum + entry.count, 0);
+    return groups.sort((a, b) => total(b) - total(a) || a.labels[0].label.localeCompare(b.labels[0].label));
+}
+const SECTIONS = ["preferences", "patterns"];
+export function descriptionHash(description) {
+    return createHash("sha256").update(description).digest("hex");
+}
+/** Renames between two versions of one profile whose items are in the same order. */
+export function recordRenames(before, after) {
+    const renames = [];
+    for (const section of SECTIONS) {
+        before[section].forEach((item, index) => {
+            const next = after[section][index];
+            if (next && next.category !== item.category) {
+                renames.push({
+                    section,
+                    descriptionSha256: descriptionHash(item.description),
+                    from: item.category,
+                    to: next.category,
+                });
+            }
+        });
+    }
+    return renames;
+}
+/**
+ * Puts the old category back on each renamed item that still exists with the
+ * category the cleanup gave it. Items added or merged later are left alone.
+ */
+export function restoreRenames(current, renames) {
+    const profile = {
+        ...current,
+        preferences: current.preferences.map((item) => ({ ...item })),
+        patterns: current.patterns.map((item) => ({ ...item })),
+    };
+    const used = new Set();
+    let restored = 0;
+    for (const rename of renames) {
+        const index = profile[rename.section].findIndex((item, position) => !used.has(`${rename.section}:${position}`) &&
+            item.category === rename.to &&
+            descriptionHash(item.description) === rename.descriptionSha256);
+        if (index < 0)
+            continue;
+        used.add(`${rename.section}:${index}`);
+        profile[rename.section][index].category = rename.from;
+        restored++;
+    }
+    return { profile, restored, notFound: renames.length - restored };
+}

package/dist/services/user-profile/profile-candidate-matching.d.ts

@@ -0,0 +1,19 @@
+/** Rank embedding matches without changing profile items or applying merge actions. */
+export declare function rankProfileCandidates(existing: readonly {
+    category?: string;
+    centroid?: number[];
+}[], category: string | undefined, embedding: number[], isWorkflow: boolean, config: {
+    userProfileEmbeddingThresholdSameCat: number;
+    userProfileEmbeddingThresholdSameCatWeak: number;
+    userProfileEmbeddingThresholdCrossCat: number;
+    userProfileEmbeddingThresholdCrossCatWeak: number;
+}): {
+    top1Score: number;
+    top1Idx: number;
+    top1SameCat: boolean;
+    top1Band: "strong" | "weak" | null;
+    top2Score: number;
+    top2Idx: number;
+    top2SameCat: boolean;
+    top2Band: "strong" | "weak" | null;
+};

package/dist/services/user-profile/profile-candidate-matching.js

@@ -0,0 +1,67 @@
+import { cosineSimilarityNumbers } from "../../utils/math.js";
+import { categoryKey } from "./profile-category.js";
+/** Rank embedding matches without changing profile items or applying merge actions. */
+export function rankProfileCandidates(existing, category, embedding, isWorkflow, config) {
+    let top1Score = 0;
+    let top1Idx = -1;
+    let top1SameCat = false;
+    let top1Band = null;
+    let top2Score = 0;
+    let top2Idx = -1;
+    let top2SameCat = false;
+    let top2Band = null;
+    for (let i = 0; i < existing.length; i++) {
+        const existingItem = existing[i];
+        if (!existingItem)
+            continue;
+        const centroid = existingItem.centroid;
+        if (!centroid)
+            continue;
+        const score = cosineSimilarityNumbers(embedding, centroid);
+        const sameCat = isWorkflow
+            ? existingItem.category === category
+            : categoryKey(existingItem.category ?? "") === categoryKey(category ?? "");
+        const strongThreshold = sameCat
+            ? config.userProfileEmbeddingThresholdSameCat
+            : config.userProfileEmbeddingThresholdCrossCat;
+        const weakThreshold = sameCat
+            ? config.userProfileEmbeddingThresholdSameCatWeak
+            : config.userProfileEmbeddingThresholdCrossCatWeak;
+        let band;
+        if (score >= strongThreshold) {
+            band = "strong";
+        }
+        else if (score >= weakThreshold && !isWorkflow) {
+            band = "weak";
+        }
+        else {
+            continue;
+        }
+        if (score > top1Score) {
+            top2Score = top1Score;
+            top2Idx = top1Idx;
+            top2SameCat = top1SameCat;
+            top2Band = top1Band;
+            top1Score = score;
+            top1Idx = i;
+            top1SameCat = sameCat;
+            top1Band = band;
+        }
+        else if (score > top2Score) {
+            top2Score = score;
+            top2Idx = i;
+            top2SameCat = sameCat;
+            top2Band = band;
+        }
+    }
+    return {
+        top1Score,
+        top1Idx,
+        top1SameCat,
+        top1Band,
+        top2Score,
+        top2Idx,
+        top2SameCat,
+        top2Band,
+    };
+}

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

@@ -0,0 +1,13 @@
+/** Hidden identity for category spellings; never used as a visible label. */
+export declare function categoryKey(label: string): string;
+/** Tidy spacing without losing capitals in acronyms or proper names. */
+export declare function tidyCategory(label: string): string;
+/** Choose one label per key across preferences and patterns, keeping all other data. */
+export declare function canonicaliseCategories<T extends {
+    preferences: {
+        category: string;
+    }[];
+    patterns: {
+        category: string;
+    }[];
+}>(profile: T): T;

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

@@ -0,0 +1,43 @@
+const RESERVED_EXPLICIT = "explicit";
+/** Hidden identity for category spellings; never used as a visible label. */
+export function categoryKey(label) {
+    return label.replace(/[_-]/g, " ").replace(/\s+/g, " ").trim().toLowerCase() || "general";
+}
+/** Tidy spacing without losing capitals in acronyms or proper names. */
+export function tidyCategory(label) {
+    const tidy = label.replace(/_/g, " ").replace(/\s+/g, " ").trim();
+    if (!tidy)
+        return "General";
+    if (tidy === "explicit" || /\p{Lu}/u.test(tidy))
+        return tidy;
+    return tidy.charAt(0).toUpperCase() + tidy.slice(1);
+}
+/** Choose one label per key across preferences and patterns, keeping all other data. */
+export function canonicaliseCategories(profile) {
+    const spellings = new Map();
+    for (const item of [...profile.preferences, ...profile.patterns]) {
+        const key = categoryKey(item.category);
+        const counts = spellings.get(key) ?? new Map();
+        counts.set(item.category, (counts.get(item.category) ?? 0) + 1);
+        spellings.set(key, counts);
+    }
+    const labels = new Map();
+    for (const [key, counts] of spellings) {
+        // "explicit" is a reserved discriminator in mergeItems; no spelling may displace it.
+        if (key === RESERVED_EXPLICIT) {
+            labels.set(key, RESERVED_EXPLICIT);
+            continue;
+        }
+        // Stable sorting keeps the first seen spelling when all tie-breaks are equal.
+        const ranked = [...counts].sort(([a, aCount], [b, bCount]) => Number(/[_-]/.test(a)) - Number(/[_-]/.test(b)) ||
+            bCount - aCount ||
+            Number(/^\p{Lu}/u.test(b)) - Number(/^\p{Lu}/u.test(a)));
+        labels.set(key, tidyCategory(ranked[0][0]));
+    }
+    const rewrite = (items) => items.map((item) => ({ ...item, category: labels.get(categoryKey(item.category)) }));
+    return {
+        ...profile,
+        preferences: rewrite(profile.preferences),
+        patterns: rewrite(profile.patterns),
+    };
+}

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

@@ -1,5 +1,6 @@
 import type { UserProfile, UserProfileChangelog, UserProfileData } from "./types.js";
 import { EmbeddingService } from "../embedding.js";
+export declare const USER_PROFILES_DB_NAME = "user-profiles.db";
 export declare class UserProfileManager {
     private db;
     private dbPath;
@@ -18,7 +19,9 @@ export declare class UserProfileManager {
     private initDatabase;
     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): Promise<boolean>;
+    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>;
     private addChangelog;
     private cleanupOldChangelogs;
     getProfileChangelogs(profileId: string, limit?: number): Promise<UserProfileChangelog[]>;
@@ -43,6 +46,11 @@ export declare class UserProfileManager {
      * Do NOT call for forced merge or cross-validation — those handle fields directly.
      */
     private mergeConfirmedMatch;
+    /**
+     * A match keeps the fullest known step list: the new steps win only when they hold more
+     * concrete (non-blank) steps. Blank entries never count, and a winning list drops them.
+     */
+    private longerSteps;
     private initItem;
     /**
      * Three-way merge: item1 + item2 + newItem → single combined entry.

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

@@ -2,8 +2,11 @@ import { join } from "node:path";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { tursoConnectionManager } from "../turso/connection-manager.js";
 import { CONFIG } from "../../config.js";
+import { hasEnoughWorkflowSteps } from "../../core/extraction.js";
 import { completeStructured, resolveHostProfileModel } from "./profile-model.js";
 import { safeArray } from "./profile-utils.js";
+import { rankProfileCandidates } from "./profile-candidate-matching.js";
+import { canonicaliseCategories, categoryKey } from "./profile-category.js";
 import { EmbeddingService } from "../embedding.js";
 import { log } from "../logger.js";
 import { cosineSimilarityNumbers, l2Normalize } from "../../utils/math.js";
@@ -63,7 +66,7 @@ function normalizeDescription(text) {
         .replace(/\s+/g, " ")
         .trim();
 }
-const USER_PROFILES_DB_NAME = "user-profiles.db";
+export const USER_PROFILES_DB_NAME = "user-profiles.db";
 const COLD_BUFFER_DEFAULT_KEY = "__unattributed__";
 export class UserProfileManager {
     db = null;
@@ -242,12 +245,13 @@ export class UserProfileManager {
         const db = await this.ready();
         const id = `profile_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
         const now = Date.now();
-        const cleanedData = {
+        // A first profile skips mergeProfileData, so the step minimum is applied here.
+        const cleanedData = canonicaliseCategories({
             preferences: safeArray(profileData.preferences),
             patterns: safeArray(profileData.patterns),
-            workflows: safeArray(profileData.workflows),
+            workflows: safeArray(profileData.workflows).filter(hasEnoughWorkflowSteps),
             ...(profileData.learning_paths ? { learning_paths: profileData.learning_paths } : {}),
-        };
+        });
         await db.run(`
       INSERT INTO user_profiles (
         id, user_id, display_name, user_name, user_email,
@@ -269,17 +273,21 @@ export class UserProfileManager {
         await this.addChangelog(id, 1, "create", "Initial profile creation", cleanedData);
         return id;
     }
-    async updateProfile(profileId, profileData, additionalPromptsAnalyzed, changeSummary) {
+    async updateProfile(profileId, profileData, additionalPromptsAnalyzed, changeSummary, 
+    /** When given, refuse the save unless the stored version still equals it. */
+    expectedVersion) {
         const db = await this.ready();
         const now = Date.now();
-        const cleanedData = {
+        const cleanedData = canonicaliseCategories({
             preferences: safeArray(profileData.preferences),
             patterns: safeArray(profileData.patterns),
             workflows: safeArray(profileData.workflows),
             ...(profileData.learning_paths ? { learning_paths: profileData.learning_paths } : {}),
-        };
+        });
         const versionRow = await db.get(`SELECT version FROM user_profiles WHERE id = ?`, [profileId]);
         const currentVersion = Number(versionRow?.version ?? 0);
+        if (expectedVersion !== undefined && currentVersion !== expectedVersion)
+            return false;
         const newVersion = currentVersion + 1;
         const changes = await db.run(`
       UPDATE user_profiles
@@ -472,7 +480,7 @@ export class UserProfileManager {
             merged.patterns = await this.mergeItems(merged.patterns, this.ensureArray(updates.patterns), "pattern", embedService, profileId);
         }
         if (updates.workflows) {
-            merged.workflows = await this.mergeItems(merged.workflows, this.ensureArray(updates.workflows), "workflow", embedService, profileId);
+            merged.workflows = await this.mergeItems(merged.workflows, this.ensureArray(updates.workflows).filter(hasEnoughWorkflowSteps), "workflow", embedService, profileId);
         }
         if (profileId) {
             if (merged.preferences.length >= 2) {
@@ -495,10 +503,10 @@ export class UserProfileManager {
         const useEmbedding = embed.isWarmedUp;
         const minDescLen = CONFIG.userProfileEmbeddingMinDescriptionLength;
         const sameCatStrong = CONFIG.userProfileEmbeddingThresholdSameCat;
-        const sameCatWeak = CONFIG.userProfileEmbeddingThresholdSameCatWeak;
-        const crossCatStrong = CONFIG.userProfileEmbeddingThresholdCrossCat;
-        const crossCatWeak = CONFIG.userProfileEmbeddingThresholdCrossCatWeak;
         const driftThreshold = CONFIG.userProfileCentroidDriftThreshold;
+        // Workflows have no category, so the same-category rules below would apply to every
+        // pair. They match only in the strong band and never absorb other workflows.
+        const isWorkflow = itemType === "workflow";
         if (!useEmbedding) {
             log("profile embedding skipped: model not warmed up");
         }
@@ -549,7 +557,10 @@ export class UserProfileManager {
             embeddingReady: useEmbedding,
         });
         for (const newItem of incoming) {
-            const exactIdx = existing.findIndex((e) => e.category === newItem.category && e.description === newItem.description);
+            const exactIdx = existing.findIndex((e) => (isWorkflow
+                ? e.category === newItem.category
+                : categoryKey(e.category ?? "") === categoryKey(newItem.category ?? "")) &&
+                e.description === newItem.description);
             if (exactIdx >= 0) {
                 const oldFreq = existing[exactIdx].frequency || 1;
                 existing[exactIdx] = this.mergeConfirmedMatch(existing[exactIdx], newItem, itemType, true);
@@ -563,61 +574,17 @@ export class UserProfileManager {
                 continue;
             }
             if (useEmbedding && newItem.description.length >= minDescLen) {
-                let top1Score = 0;
-                let top1Idx = -1;
-                let top1SameCat = false;
-                let top1Band = null;
-                let top2Score = 0;
-                let top2Idx = -1;
-                let top2SameCat = false;
-                let top2Band = null;
                 const newEmb = await embed.embed(normalizeDescription(newItem.description), {
                     task: "document",
                 });
-                for (let i = 0; i < existing.length; i++) {
-                    const existingItem = existing[i];
-                    if (!existingItem)
-                        continue;
-                    const centroid = existingItem.centroid;
-                    if (!centroid)
-                        continue;
-                    const score = cosineSimilarityNumbers(Array.from(newEmb), centroid);
-                    const sameCat = existingItem.category === newItem.category;
-                    const strongThreshold = sameCat ? sameCatStrong : crossCatStrong;
-                    const weakThreshold = sameCat ? sameCatWeak : crossCatWeak;
-                    let band;
-                    if (score >= strongThreshold) {
-                        band = "strong";
-                    }
-                    else if (score >= weakThreshold) {
-                        band = "weak";
-                    }
-                    else {
-                        continue;
-                    }
-                    if (score > top1Score) {
-                        top2Score = top1Score;
-                        top2Idx = top1Idx;
-                        top2SameCat = top1SameCat;
-                        top2Band = top1Band;
-                        top1Score = score;
-                        top1Idx = i;
-                        top1SameCat = sameCat;
-                        top1Band = band;
-                    }
-                    else if (score > top2Score) {
-                        top2Score = score;
-                        top2Idx = i;
-                        top2SameCat = sameCat;
-                        top2Band = band;
-                    }
-                }
+                const { top1Score, top1Idx, top1SameCat, top1Band, top2Score, top2Idx, top2SameCat, top2Band, } = rankProfileCandidates(existing, newItem.category, Array.from(newEmb), isWorkflow, CONFIG);
                 if (top1Idx >= 0 &&
                     top1Band === "strong" &&
                     top2Idx >= 0 &&
                     top2Band === "strong" &&
                     top1SameCat &&
-                    top2SameCat) {
+                    top2SameCat &&
+                    !isWorkflow) {
                     const item1 = existing[top1Idx];
                     const item2 = existing[top2Idx];
                     const newEmbArr = Array.from(newEmb);
@@ -692,13 +659,14 @@ export class UserProfileManager {
                     }
                     existing[top1Idx] = combined;
                     matchCount++;
-                    if (top1SameCat) {
+                    if (top1SameCat && !isWorkflow) {
                         const mergeIndices = [];
                         for (let j = 0; j < existing.length; j++) {
                             if (j === top1Idx)
                                 continue;
                             const other = existing[j];
-                            if (!other || other.category !== existingItem.category)
+                            if (!other ||
+                                categoryKey(other.category ?? "") !== categoryKey(existingItem.category ?? ""))
                                 continue;
                             const otherCentroid = other.centroid;
                             if (!otherCentroid)
@@ -980,7 +948,7 @@ export class UserProfileManager {
                 evidence,
                 lastSeen: Date.now(),
                 lastMatchTime: Date.now(),
-                ...(itemType === "workflow" && newItem.steps?.length ? { steps: newItem.steps } : {}),
+                ...(itemType === "workflow" ? this.longerSteps(existing, newItem) : {}),
             };
             this.syncConfidence(result);
             return result;
@@ -994,11 +962,23 @@ export class UserProfileManager {
             evidence,
             lastSeen: Date.now(),
             lastMatchTime: Date.now(),
-            ...(itemType === "workflow" && newItem.steps?.length ? { steps: newItem.steps } : {}),
+            ...(itemType === "workflow" ? this.longerSteps(existing, newItem) : {}),
         };
         this.syncConfidence(result);
         return result;
     }
+    /**
+     * A match keeps the fullest known step list: the new steps win only when they hold more
+     * concrete (non-blank) steps. Blank entries never count, and a winning list drops them.
+     */
+    longerSteps(existing, newItem) {
+        const concrete = (steps) => Array.isArray(steps)
+            ? steps.filter((step) => typeof step === "string" && step.trim().length > 0)
+            : [];
+        const known = concrete(existing.steps).length;
+        const incoming = concrete(newItem.steps);
+        return incoming.length > known ? { steps: incoming } : {};
+    }
     initItem(newItem, itemType, centroid, anchor) {
         const hasEvidence = Array.isArray(newItem.evidence) && newItem.evidence.length > 0;
         const item = {
@@ -1152,9 +1132,9 @@ export class UserProfileManager {
                 break;
             if (removeIndices.includes(items.indexOf(a)) || removeIndices.includes(items.indexOf(b)))
                 continue;
+            checked++;
             const conflict = await this.checkConflict(a.description, b.description);
             if (conflict) {
-                checked++;
                 const keeper = (a.frequency || 0) >= (b.frequency || 0) ? a : b;
                 const removed = keeper === a ? b : a;
                 this.lazyMigrateAlpha(keeper);
@@ -1496,7 +1476,8 @@ Generate a concise, abstract description of the user's general behavioral tenden
         return newDescription;
     }
     async evolveAndUpdate(item, itemType, profileId) {
-        if (!profileId)
+        // The rewrite describes a general tendency, which turns a workflow into a persona summary.
+        if (!profileId || itemType === "workflow")
             return;
         try {
             const evolved = await this.evolveDescription(item, itemType, profileId);

package/dist/services/web-server.js

@@ -12,7 +12,7 @@ import { isOlderVersion } from "./version-compare.js";
 import { AUTH_HEADER, getOrCreateAuthToken, isAuthorizedApiRequest } from "./auth-token.js";
 import { WebAuth } from "./web-auth.js";
 import { NODE_HTTP_IDLE_TIMEOUT_MS } from "./request-timeouts.js";
-import { handleListTags, handleListKeywords, handleListMemories, handleAddMemory, handleDeleteMemory, handleBulkDelete, handleUpdateMemory, handleSearch, handleStats, handlePinMemory, handleUnpinMemory, handleRunCleanup, handleRunDeduplication, handleDetectMigration, handleRunMigration, handleDetectTagMigration, handleRunTagMigrationBatch, handleGetTagMigrationProgress, handleDeletePrompt, handleBulkDeletePrompts, handleGetUserProfile, handleGetProfileChangelog, handleGetProfileSnapshot, handleRefreshProfile, handleAICleanup, handleApplyCleanup, handleUpdateProfileItem, } from "./api-handlers.js";
+import { handleListTags, handleListKeywords, handleListMemories, handleAddMemory, handleDeleteMemory, handleBulkDelete, handleUpdateMemory, handleSearch, handleStats, handlePinMemory, handleUnpinMemory, handleRunCleanup, handleRunDeduplication, handleDetectMigration, handleRunMigration, handleDetectTagMigration, handleRunTagMigrationBatch, handleGetTagMigrationProgress, handleDeletePrompt, handleBulkDeletePrompts, handleGetUserProfile, handleGetProfileChangelog, handleGetProfileSnapshot, handleRefreshProfile, handleAICleanup, handleApplyCleanup, handleCategoryCleanupApply, handleCategoryCleanupStart, handleCategoryCleanupStatus, handleCategoryCleanupUndo, handleUpdateProfileItem, } from "./api-handlers.js";
 const isBun = typeof globalThis.Bun !== "undefined";
 const MIN_FAILED_TAKEOVERS = 3;
 export function attachNodeDisconnectHandlers(req, res, onDisconnect) {
@@ -1357,6 +1357,21 @@ export class WebServer {
                 const result = await handleApplyCleanup(userId, body);
                 return this.jsonResponse(result);
             }
+            if (path === "/api/user-profile/category-cleanup" && method === "POST") {
+                const body = (await req.json().catch(() => ({})));
+                return this.jsonResponse(await handleCategoryCleanupStart(body.userId || undefined));
+            }
+            if (path === "/api/user-profile/category-cleanup" && method === "GET") {
+                return this.jsonResponse(await handleCategoryCleanupStatus(url.searchParams.get("userId") || undefined));
+            }
+            if (path === "/api/user-profile/category-cleanup/apply" && method === "POST") {
+                const body = (await req.json().catch(() => ({})));
+                return this.jsonResponse(await handleCategoryCleanupApply(body.userId || undefined, body));
+            }
+            if (path === "/api/user-profile/category-cleanup/undo" && method === "POST") {
+                const body = (await req.json().catch(() => ({})));
+                return this.jsonResponse(await handleCategoryCleanupUndo(body.userId || undefined));
+            }
             if (path === "/api/user-profile/item" && method === "PATCH") {
                 const body = (await req.json().catch(() => ({})));
                 const result = await handleUpdateProfileItem(body);