om-memory-system 4.19.1 → 4.22.0

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

@@ -0,0 +1,35 @@
+import type { ModelPort } from "../../core/profile-analysis.js";
+import type { UserProfileData } from "./types.js";
+import { type CleanupDiff, type IndexedProfile } from "./ai-cleanup.js";
+/** What one batch adds to the review: its changes, and the merged item of each merge. */
+export interface BatchCleanupResult {
+    diff: CleanupDiff;
+    mergedItems: Record<string, unknown>;
+}
+export interface BatchRunResult extends BatchCleanupResult {
+    failedBatches: number;
+    failedItems: number;
+}
+export interface RunInBatchesOptions {
+    callBatch?: (batch: IndexedProfile) => Promise<BatchCleanupResult>;
+    onProgress?: (done: number, total: number, failed: number) => void;
+    isStopped?: () => boolean;
+}
+/** Indexes the full profile once, so ids are profile positions, and keeps the selected items. */
+export declare function selectForCleanup(profileData: UserProfileData, includeIds: string[]): IndexedProfile;
+/**
+ * Packs each section on its own, sorted by category, so a category of up to `size` items
+ * stays in one batch. Likely duplicates share a category, and the model merges only
+ * inside a section.
+ */
+export declare function splitIntoBatches(indexed: IndexedProfile, size: number): IndexedProfile[];
+/** One model request for one batch. A caller with its own model passes it. */
+export declare function cleanupBatch(indexed: IndexedProfile, model?: ModelPort | null): Promise<BatchCleanupResult>;
+/**
+ * Runs the batches one after another and joins their results. A failed batch adds
+ * nothing, so its items stay as they are. Throws the first error when every batch
+ * fails. Returns null when stopped; the stop flag is read before and after each call.
+ */
+export declare function runInBatches(batches: IndexedProfile[], { callBatch, onProgress, isStopped }?: RunInBatchesOptions): Promise<BatchRunResult | null>;
+/** A fixed reason code for the log. Never the error text, which may quote the reply. */
+export declare function failureReason(error: unknown): string;

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

@@ -0,0 +1,179 @@
+import { log } from "../logger.js";
+import { addIdsToProfile, buildAICleanupPrompt, buildItemIndex, callAICleanup, generateDiff, rebuildProfileUsing, } from "./ai-cleanup.js";
+/**
+ * A large selection sent in one model request runs past the request time limit. The web
+ * cleanup therefore sends the selection in batches, one request each, one after another.
+ */
+const SECTIONS = ["preferences", "patterns", "workflows"];
+/** Indexes the full profile once, so ids are profile positions, and keeps the selected items. */
+export function selectForCleanup(profileData, includeIds) {
+    const idSet = new Set(includeIds);
+    const indexed = addIdsToProfile(profileData);
+    return {
+        preferences: indexed.preferences.filter((p) => idSet.has(p.id)),
+        patterns: indexed.patterns.filter((p) => idSet.has(p.id)),
+        workflows: indexed.workflows.filter((p) => idSet.has(p.id)),
+    };
+}
+/**
+ * Packs each section on its own, sorted by category, so a category of up to `size` items
+ * stays in one batch. Likely duplicates share a category, and the model merges only
+ * inside a section.
+ */
+export function splitIntoBatches(indexed, size) {
+    const batches = [];
+    for (const section of SECTIONS) {
+        const flush = (items) => {
+            if (items.length > 0)
+                batches.push({ preferences: [], patterns: [], workflows: [], [section]: items });
+        };
+        let current = [];
+        for (const group of groupByCategory(indexed[section])) {
+            if (group.length > size) {
+                flush(current);
+                current = [];
+                for (let i = 0; i < group.length; i += size) {
+                    const chunk = group.slice(i, i + size);
+                    if (chunk.length === size)
+                        flush(chunk);
+                    else
+                        current = chunk;
+                }
+            }
+            else if (current.length + group.length > size) {
+                flush(current);
+                current = [...group];
+            }
+            else {
+                current.push(...group);
+            }
+        }
+        flush(current);
+    }
+    return batches;
+}
+function groupByCategory(items) {
+    const groups = new Map();
+    for (const item of items) {
+        const key = (item.category ?? "").toLowerCase();
+        const group = groups.get(key);
+        if (group)
+            group.push(item);
+        else
+            groups.set(key, [item]);
+    }
+    return [...groups.keys()].sort().map((key) => groups.get(key));
+}
+/** One model request for one batch. A caller with its own model passes it. */
+export async function cleanupBatch(indexed, model) {
+    const t0 = Date.now();
+    const prompt = buildAICleanupPrompt(indexed);
+    log("AI cleanup: batch prompt built", { items: countItems(indexed), promptLen: prompt.length });
+    const result = await callAICleanup(prompt, model);
+    log("AI cleanup: batch reply received", { callMs: Date.now() - t0 });
+    const cleanedById = buildItemIndex(result.profile);
+    const originalById = buildItemIndex(indexed);
+    const mapping = restrictToBatch(result.mapping, originalById);
+    return {
+        diff: generateDiff(indexed, mapping, cleanedById),
+        mergedItems: buildMergedItems(mapping, cleanedById, originalById),
+    };
+}
+// The model may return an id that is not in the batch. Apply looks ids up in the whole
+// profile, so such an id could change an item the user never selected.
+function restrictToBatch(mapping, originalById) {
+    const inBatch = (id) => originalById.has(id);
+    return {
+        kept: mapping.kept.filter(inBatch),
+        merged: mapping.merged.map((group) => group.filter(inBatch)).filter((g) => g.length > 1),
+        removed: mapping.removed.filter(inBatch),
+    };
+}
+// The merged item of each group, keyed by its target id, so Apply can put a ticked merge
+// into a newer profile without the rest of the cleaned batch.
+function buildMergedItems(mapping, cleanedById, originalById) {
+    const items = {};
+    for (const group of mapping.merged.filter((g) => g.length > 1)) {
+        const originals = new Map();
+        for (const id of group) {
+            const original = originalById.get(id);
+            if (original)
+                originals.set(id, original);
+        }
+        const one = rebuildProfileUsing({ kept: [], merged: [group], removed: [] }, cleanedById, originals);
+        const item = one.preferences[0] ?? one.patterns[0] ?? one.workflows[0];
+        if (item)
+            items[group[0]] = item;
+    }
+    return items;
+}
+/**
+ * Runs the batches one after another and joins their results. A failed batch adds
+ * nothing, so its items stay as they are. Throws the first error when every batch
+ * fails. Returns null when stopped; the stop flag is read before and after each call.
+ */
+export async function runInBatches(batches, { callBatch = cleanupBatch, onProgress, isStopped = () => false } = {}) {
+    const t0 = Date.now();
+    const joined = {
+        diff: { kept: [], merged: [], removed: [] },
+        mergedItems: {},
+        failedBatches: 0,
+        failedItems: 0,
+    };
+    let firstError;
+    for (const [index, batch] of batches.entries()) {
+        if (isStopped())
+            return null;
+        try {
+            const result = await callBatch(batch);
+            if (isStopped())
+                return null;
+            joined.diff.kept.push(...result.diff.kept);
+            joined.diff.merged.push(...result.diff.merged);
+            joined.diff.removed.push(...result.diff.removed);
+            Object.assign(joined.mergedItems, result.mergedItems);
+        }
+        catch (error) {
+            if (isStopped())
+                return null;
+            if (joined.failedBatches === 0)
+                firstError = error;
+            joined.failedBatches++;
+            joined.failedItems += countItems(batch);
+            log("AI cleanup: batch failed", {
+                batch: index + 1,
+                of: batches.length,
+                items: countItems(batch),
+                reason: failureReason(error),
+            });
+        }
+        onProgress?.(index + 1, batches.length, joined.failedBatches);
+    }
+    if (batches.length > 0 && joined.failedBatches === batches.length)
+        throw firstError;
+    log("AI cleanup: batches finished", {
+        batches: batches.length,
+        failedBatches: joined.failedBatches,
+        totalMs: Date.now() - t0,
+    });
+    return joined;
+}
+/** A fixed reason code for the log. Never the error text, which may quote the reply. */
+export function failureReason(error) {
+    if (error instanceof Error) {
+        if (error.name === "TimeoutError" || error.name === "AbortError")
+            return "timeout";
+        const status = /API request failed: (\d{3})/.exec(error.message)?.[1];
+        if (status)
+            return `http-${status}`;
+        if (error instanceof SyntaxError || /valid JSON|No content/.test(error.message)) {
+            return "invalid-reply";
+        }
+        if (/No AI provider configured/.test(error.message))
+            return "no-provider";
+    }
+    return "error";
+}
+function countItems(indexed) {
+    return indexed.preferences.length + indexed.patterns.length + indexed.workflows.length;
+}

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

@@ -0,0 +1,52 @@
+import type { CleanupDiff } from "./ai-cleanup.js";
+import type { CleanupJobResult } from "./ai-cleanup-apply.js";
+import { type RunInBatchesOptions } from "./ai-cleanup-batches.js";
+import type { UserProfileData } from "./types.js";
+/**
+ * A large AI cleanup takes many minutes, longer than a web request may stay open. The web
+ * app therefore runs it as a background job per user, and the dialog polls its state.
+ * The job also holds the finished result until Apply. Jobs live in this process only; a
+ * restart drops them, and nothing is saved before Apply.
+ */
+export type AiCleanupJobStatus = {
+    state: "running";
+    done: number;
+    total: number;
+    failed: number;
+} | {
+    state: "done";
+    result: {
+        old: UserProfileData;
+        changes: CleanupDiff;
+        failedBatches: number;
+        failedItems: number;
+    };
+} | {
+    state: "failed";
+    error: string;
+};
+export interface AiCleanupJobView {
+    id: string;
+    startedAt: number;
+    selection: string[];
+    status: AiCleanupJobStatus;
+}
+export interface AiCleanupJobInput {
+    /** The profile as the dialog lists it, so item ids match. */
+    profileData: UserProfileData;
+    /** An empty or missing selection means every item. */
+    includeIds?: string[];
+}
+export interface AiCleanupJobDeps {
+    callBatch?: RunInBatchesOptions["callBatch"];
+    batchSize?: number;
+    now?: () => number;
+}
+/** Starts a cleanup job for the user, or returns the one already running. */
+export declare function startAiCleanupJob(userId: string, input: AiCleanupJobInput, deps?: AiCleanupJobDeps): AiCleanupJobView;
+/** The user's job, or null when none was started or a finished one expired. */
+export declare function getAiCleanupJob(userId: string, now?: number): AiCleanupJobView | null;
+/** The finished result that Apply needs, or null when the job is not done. */
+export declare function getAiCleanupResult(userId: string, now?: number): CleanupJobResult | null;
+/** Stops a running job, or discards a finished one. A stopped job writes nothing. */
+export declare function stopAiCleanupJob(userId: string): void;

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

@@ -0,0 +1,112 @@
+import { log } from "../logger.js";
+import { AI_CLEANUP_BATCH_SIZE } from "../request-timeouts.js";
+import { failureReason, runInBatches, selectForCleanup, splitIntoBatches, } from "./ai-cleanup-batches.js";
+/** A finished job is forgotten this long after it finished, as the old pending result was. */
+const FINISHED_JOB_TTL_MS = 30 * 60 * 1000;
+const jobs = new Map();
+let nextId = 1;
+/** Starts a cleanup job for the user, or returns the one already running. */
+export function startAiCleanupJob(userId, input, deps = {}) {
+    const current = jobs.get(userId);
+    if (current?.status.state === "running")
+        return view(current);
+    const now = deps.now ?? Date.now;
+    const selection = input.includeIds?.length ? input.includeIds : allIds(input.profileData);
+    const batches = splitIntoBatches(selectForCleanup(input.profileData, selection), deps.batchSize ?? AI_CLEANUP_BATCH_SIZE);
+    const job = {
+        id: String(nextId++),
+        startedAt: now(),
+        selection,
+        status: { state: "running", done: 0, total: batches.length, failed: 0 },
+        stopped: false,
+        mergedItems: {},
+    };
+    jobs.set(userId, job);
+    void (async () => {
+        try {
+            const result = await runInBatches(batches, {
+                callBatch: deps.callBatch,
+                isStopped: () => job.stopped,
+                onProgress: (done, total, failed) => {
+                    job.status = { state: "running", done, total, failed };
+                },
+            });
+            if (!result)
+                return;
+            job.mergedItems = result.mergedItems;
+            job.status = {
+                state: "done",
+                result: {
+                    old: input.profileData,
+                    changes: result.diff,
+                    failedBatches: result.failedBatches,
+                    failedItems: result.failedItems,
+                },
+            };
+        }
+        catch (error) {
+            if (job.stopped)
+                return;
+            const reason = failureReason(error);
+            log("AI cleanup job: failed", { reason });
+            job.status = {
+                state: "failed",
+                error: reason === "timeout"
+                    ? "The model did not answer in time."
+                    : error instanceof Error
+                        ? error.message
+                        : String(error),
+            };
+        }
+        finally {
+            job.finishedAt = now();
+        }
+    })();
+    return view(job);
+}
+/** The user's job, or null when none was started or a finished one expired. */
+export function getAiCleanupJob(userId, now = Date.now()) {
+    const job = liveJob(userId, now);
+    return job ? view(job) : null;
+}
+/** The finished result that Apply needs, or null when the job is not done. */
+export function getAiCleanupResult(userId, now = Date.now()) {
+    const job = liveJob(userId, now);
+    if (job?.status.state !== "done")
+        return null;
+    return {
+        old: job.status.result.old,
+        changes: job.status.result.changes,
+        mergedItems: job.mergedItems,
+    };
+}
+/** Stops a running job, or discards a finished one. A stopped job writes nothing. */
+export function stopAiCleanupJob(userId) {
+    const job = jobs.get(userId);
+    if (!job)
+        return;
+    job.stopped = true;
+    jobs.delete(userId);
+}
+function liveJob(userId, now) {
+    const job = jobs.get(userId);
+    if (!job)
+        return null;
+    if (job.status.state !== "running" && job.finishedAt !== undefined) {
+        if (now - job.finishedAt > FINISHED_JOB_TTL_MS) {
+            jobs.delete(userId);
+            return null;
+        }
+    }
+    return job;
+}
+function view(job) {
+    return { id: job.id, startedAt: job.startedAt, selection: job.selection, status: job.status };
+}
+function allIds(profile) {
+    return [
+        ...profile.preferences.map((_, i) => `pref_${i}`),
+        ...profile.patterns.map((_, i) => `pat_${i}`),
+        ...profile.workflows.map((_, i) => `wf_${i}`),
+    ];
+}

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

@@ -0,0 +1,15 @@
+import type { RestoreEntry } from "./ai-cleanup-apply.js";
+import type { UserProfileData } from "./types.js";
+export interface UndoResult {
+    profile: UserProfileData;
+    restored: number;
+    notFound: number;
+}
+/**
+ * Reverses the changes of one automatic cleanup in `current`, which may be newer than the
+ * profile the run saved. A merge is undone by taking out the merged item and putting its
+ * originals back. A removal is undone by putting the original back. A change counts as
+ * not found, and is left alone, when the merged item is gone or was reworded, or when an
+ * original is already in the profile. Every other item stays as stored.
+ */
+export declare function undoCleanupEdits(current: UserProfileData, entries: RestoreEntry[]): UndoResult;

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

@@ -0,0 +1,63 @@
+import { profileItemIdentityKey } from "./ai-cleanup-apply.js";
+const SECTIONS = ["preferences", "patterns", "workflows"];
+function keyOf(section, item) {
+    return `${section}|${profileItemIdentityKey(item)}`;
+}
+/**
+ * Reverses the changes of one automatic cleanup in `current`, which may be newer than the
+ * profile the run saved. A merge is undone by taking out the merged item and putting its
+ * originals back. A removal is undone by putting the original back. A change counts as
+ * not found, and is left alone, when the merged item is gone or was reworded, or when an
+ * original is already in the profile. Every other item stays as stored.
+ */
+export function undoCleanupEdits(current, entries) {
+    const profile = {
+        ...current,
+        preferences: [...current.preferences],
+        patterns: [...current.patterns],
+        workflows: [...current.workflows],
+    };
+    // How many items of each identity the profile holds now. A restored item is not added,
+    // so two identical originals of the record both come back.
+    const present = new Map();
+    for (const section of SECTIONS) {
+        for (const item of profile[section]) {
+            const key = keyOf(section, item);
+            present.set(key, (present.get(key) ?? 0) + 1);
+        }
+    }
+    const claimed = new Set();
+    let restored = 0;
+    let notFound = 0;
+    for (const entry of entries) {
+        const items = profile[entry.section];
+        if (entry.kind === "remove") {
+            if ((present.get(keyOf(entry.section, entry.original)) ?? 0) > 0) {
+                notFound++;
+                continue;
+            }
+            const back = { ...entry.original };
+            items.push(back);
+            claimed.add(back);
+            restored++;
+            continue;
+        }
+        const mergedKey = keyOf(entry.section, entry.merged);
+        const index = items.findIndex((item) => !claimed.has(item) && keyOf(entry.section, item) === mergedKey);
+        const blocked = entry.originals.some((original) => {
+            const key = keyOf(entry.section, original);
+            return (present.get(key) ?? 0) - (key === mergedKey ? 1 : 0) > 0;
+        });
+        if (index < 0 || blocked) {
+            notFound++;
+            continue;
+        }
+        const back = entry.originals.map((original) => ({ ...original }));
+        items.splice(index, 1, ...back);
+        for (const item of back)
+            claimed.add(item);
+        present.set(mergedKey, (present.get(mergedKey) ?? 1) - 1);
+        restored++;
+    }
+    return { profile, restored, notFound };
+}

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

@@ -1,8 +1,5 @@
 import type { UserProfileData } from "./types.js";
-export interface AICleanupResult {
-    cleaned: UserProfileData;
-    diff: CleanupDiff;
-}
+import type { ModelPort } from "../../core/profile-analysis.js";
 export interface CleanupDiff {
     kept: string[];
     merged: Array<{
@@ -14,10 +11,7 @@ export interface CleanupDiff {
         reason: string;
     }>;
 }
-export declare function aiCleanupProfile(profileData: UserProfileData): Promise<AICleanupResult>;
-export declare function aiCleanupProfileFromIndexed(indexed: IndexedProfile): Promise<AICleanupResult>;
-export declare function filterProfileForCleanup(profileData: UserProfileData, includeIds: string[]): IndexedProfile;
-interface IndexedProfileItem {
+export interface IndexedProfileItem {
     id: string;
     category?: string;
     description: string;
@@ -25,18 +19,25 @@ interface IndexedProfileItem {
     frequency?: number;
     [key: string]: unknown;
 }
-interface IndexedProfile {
+export interface IndexedProfile {
     preferences: IndexedProfileItem[];
     patterns: IndexedProfileItem[];
     workflows: IndexedProfileItem[];
 }
-interface AIMapping {
+export interface AIMapping {
     kept: string[];
     merged: string[][];
     removed: string[];
 }
+export declare function addIdsToProfile(profile: UserProfileData): IndexedProfile;
+export declare function buildAICleanupPrompt(profile: IndexedProfile): string;
+export declare function callAICleanup(prompt: string, model?: ModelPort | null): Promise<{
+    profile: IndexedProfile;
+    mapping: AIMapping;
+}>;
+export declare function buildItemIndex(profile: IndexedProfile): Map<string, IndexedProfileItem>;
 export declare function rebuildProfileUsing(mapping: AIMapping, cleanedById: Map<string, IndexedProfileItem>, originalById: Map<string, IndexedProfileItem>, counters?: {
     cleaned: number;
     original: number;
 }): UserProfileData;
-export {};
+export declare function generateDiff(original: IndexedProfile, mapping: AIMapping, cleanedById: Map<string, IndexedProfileItem>): CleanupDiff;

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

@@ -3,81 +3,6 @@ import { log } from "../logger.js";
 import { resolveHostProfileModel } from "./profile-model.js";
 import { EXTERNAL_PROFILE_CLEANUP_TIMEOUT_MS } from "../request-timeouts.js";
 import { applySafeExtraParams } from "../ai/providers/base-provider.js";
-export async function aiCleanupProfile(profileData) {
-    const t0 = Date.now();
-    const indexed = addIdsToProfile(profileData);
-    const prompt = buildAICleanupPrompt(indexed);
-    log("AI cleanup: prompt built", {
-        prefCount: indexed.preferences.length,
-        patCount: indexed.patterns.length,
-        wfCount: indexed.workflows.length,
-        promptLen: prompt.length,
-        buildMs: Date.now() - t0,
-    });
-    const aiStart = Date.now();
-    const result = await callAICleanup(prompt);
-    log("AI cleanup: AI response received", { callMs: Date.now() - aiStart });
-    const cleanedById = buildItemIndex(result.profile);
-    const originalById = buildItemIndex(indexed);
-    const counters = { cleaned: 0, original: 0 };
-    const cleaned = rebuildProfileUsing(result.mapping, cleanedById, originalById, counters);
-    const diff = generateDiff(indexed, result.mapping, cleanedById);
-    const sampleCleaned = result.profile.preferences[0];
-    log("AI cleanup: rebuild done", {
-        cleanedPrefCount: result.profile.preferences.length,
-        cleanedPatCount: result.profile.patterns.length,
-        cleanedWfCount: result.profile.workflows.length,
-        sampleId: sampleCleaned?.id,
-        sampleDescLen: sampleCleaned?.description?.length,
-        cleanedItemDescLen: cleanedById.get("pref_0")?.description?.length,
-        originalItemDescLen: originalById.get("pref_0")?.description?.length,
-        keptById: cleaned.preferences.length,
-        usedCleaned: counters.cleaned,
-        usedOriginal: counters.original,
-    });
-    log("AI cleanup: complete", {
-        totalMs: Date.now() - t0,
-        kept: diff.kept.length,
-        merged: diff.merged.length,
-        removed: diff.removed.length,
-    });
-    return { cleaned, diff };
-}
-export async function aiCleanupProfileFromIndexed(indexed) {
-    const t0 = Date.now();
-    const prompt = buildAICleanupPrompt(indexed);
-    log("AI cleanup: prompt built (filtered)", {
-        prefCount: indexed.preferences.length,
-        patCount: indexed.patterns.length,
-        wfCount: indexed.workflows.length,
-        promptLen: prompt.length,
-        buildMs: Date.now() - t0,
-    });
-    const aiStart = Date.now();
-    const result = await callAICleanup(prompt);
-    log("AI cleanup: AI response received (filtered)", { callMs: Date.now() - aiStart });
-    const cleanedById = buildItemIndex(result.profile);
-    const originalById = buildItemIndex(indexed);
-    const counters = { cleaned: 0, original: 0 };
-    const cleaned = rebuildProfileUsing(result.mapping, cleanedById, originalById, counters);
-    const diff = generateDiff(indexed, result.mapping, cleanedById);
-    log("AI cleanup: complete (filtered)", {
-        totalMs: Date.now() - t0,
-        kept: diff.kept.length,
-        merged: diff.merged.length,
-        removed: diff.removed.length,
-    });
-    return { cleaned, diff };
-}
-export function filterProfileForCleanup(profileData, includeIds) {
-    const idSet = new Set(includeIds);
-    const indexed = addIdsToProfile(profileData);
-    return {
-        preferences: indexed.preferences.filter((p) => idSet.has(p.id)),
-        patterns: indexed.patterns.filter((p) => idSet.has(p.id)),
-        workflows: indexed.workflows.filter((p) => idSet.has(p.id)),
-    };
-}
 // The model controls this JSON; it may omit fields or return wrong types. Coerce to a
 // well-formed AIMapping so rebuildProfileUsing/generateDiff never call .map/.filter/.includes
 // on undefined. A missing or malformed mapping degrades to a no-op cleanup (all originals are
@@ -100,7 +25,7 @@ function normalizeAIMapping(raw) {
     const removed = Array.isArray(raw.removed) ? raw.removed.filter(isStr) : [];
     return { kept, merged, removed };
 }
-function addIdsToProfile(profile) {
+export function addIdsToProfile(profile) {
     const items = {
         preferences: profile.preferences.map((p, i) => ({ ...p, id: `pref_${i}` })),
         patterns: profile.patterns.map((p, i) => ({ ...p, id: `pat_${i}` })),
@@ -108,7 +33,7 @@ function addIdsToProfile(profile) {
     };
     return items;
 }
-function buildAICleanupPrompt(profile) {
+export function buildAICleanupPrompt(profile) {
     const profileJSON = JSON.stringify({
         preferences: profile.preferences.map(formatForAI),
         patterns: profile.patterns.map(formatForAI),
@@ -147,10 +72,12 @@ function formatForAI(item) {
     const { id, category, description, frequency } = item;
     return { id, category, description, frequency };
 }
-async function callAICleanup(prompt) {
-    // Use the host model when the host registered one (same pattern as auto-capture).
-    // When it is available, surface its errors instead of masking them as
-    // "No AI provider configured" via a silent fallback (#177).
+export async function callAICleanup(prompt, model) {
+    // A caller that has its own model (Pi) passes it. Otherwise use the host model when the
+    // host registered one (same pattern as auto-capture). When it is available, surface its
+    // errors instead of masking them as "No AI provider configured" via a silent fallback (#177).
+    if (model)
+        return callViaHostModel(model, prompt);
     const hostModel = await resolveHostProfileModel();
     if (hostModel) {
         return callViaHostModel(hostModel, prompt);
@@ -215,7 +142,7 @@ async function callViaHostModel(model, prompt) {
         mapping: normalizeAIMapping(parsed.mapping),
     };
 }
-function buildItemIndex(profile) {
+export function buildItemIndex(profile) {
     const map = new Map();
     for (const item of profile.preferences)
         map.set(item.id, item);
@@ -393,7 +320,7 @@ export function rebuildProfileUsing(mapping, cleanedById, originalById, counters
     }
     return result;
 }
-function generateDiff(original, mapping, cleanedById) {
+export function generateDiff(original, mapping, cleanedById) {
     const index = buildItemIndex(original);
     const diff = {
         kept: mapping.kept.map((id) => index.get(id)?.description || id),

package/dist/services/user-profile/auto-cleanup-store.d.ts

@@ -0,0 +1,32 @@
+import type { RestoreEntry } from "./ai-cleanup-apply.js";
+/** A record can be undone for this long, then it is deleted. */
+export declare const AUTO_CLEANUP_RECORD_MAX_AGE_MS: number;
+export interface AutoCleanupRecordInput {
+    promptsAnalyzed: number;
+    merged: number;
+    removed: number;
+    entries: RestoreEntry[];
+}
+export interface AutoCleanupSummary {
+    id: number;
+    createdAt: number;
+    merged: number;
+    removed: number;
+}
+export interface AutoCleanupRecord extends AutoCleanupSummary {
+    promptsAnalyzed: number;
+    entries: RestoreEntry[];
+}
+export declare function insertAutoCleanupRecord(profileId: string, record: AutoCleanupRecordInput, now?: number): Promise<number>;
+/**
+ * Deletes every record older than 30 days, for all profiles. The daily cleanup and the web
+ * app start call it, so a record does not outlive its limit when nothing else touches the
+ * table. Returns how many rows it deleted.
+ */
+export declare function pruneAutoCleanupRecords(now?: number): Promise<number>;
+export declare function deleteAutoCleanup(id: number): Promise<void>;
+/** The newest record of the profile that is not undone, without its items. */
+export declare function latestOpenAutoCleanupSummary(profileId: string, now?: number): Promise<AutoCleanupSummary | null>;
+/** The newest record of the profile that is not undone, with the items to restore. */
+export declare function latestOpenAutoCleanup(profileId: string, now?: number): Promise<AutoCleanupRecord | null>;
+export declare function markAutoCleanupUndone(id: number, now?: number): Promise<void>;