om-memory-system 4.20.0 → 4.22.0

package/dist/services/language-detector.js

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

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

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

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

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

package/dist/services/settings-snapshot.js

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

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

@@ -1,5 +1,6 @@
 import type { CleanupDiff } from "./ai-cleanup.js";
 import type { UserProfileData } from "./types.js";
+export type Section = "preferences" | "patterns" | "workflows";
 /** What a finished cleanup job keeps for Apply. Ids are positions in `old`. */
 export interface CleanupJobResult {
     old: UserProfileData;
@@ -10,10 +11,25 @@ export interface AcceptedCleanup {
     merged?: string[][];
     removed?: string[];
 }
+/**
+ * What one applied change replaced, as stored. Undo reverses it. A merge holds the original
+ * items and the merged item that was written. A removal holds the original item.
+ */
+export type RestoreEntry = {
+    kind: "merge";
+    section: Section;
+    originals: unknown[];
+    merged: unknown;
+} | {
+    kind: "remove";
+    section: Section;
+    original: unknown;
+};
 export interface AppliedCleanup {
     profile: UserProfileData;
     applied: number;
     skipped: number;
+    restore: RestoreEntry[];
 }
 /**
  * Puts the ticked changes of a job into `current`, which may be newer than the profile
@@ -23,5 +39,9 @@ export interface AppliedCleanup {
  * the job are ignored.
  */
 export declare function applyCleanupEdits(current: UserProfileData, job: CleanupJobResult, accepted: AcceptedCleanup): AppliedCleanup;
-/** The fields that identify a profile item. Counters and vectors are left out. */
+/**
+ * The fields that identify a profile item. Counters and vectors are left out. The category
+ * counts by its key, because every save keeps one visible spelling per category and may
+ * rewrite the spelling of a stored item.
+ */
 export declare function profileItemIdentityKey(item: any): string;

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

@@ -1,3 +1,4 @@
+import { categoryKey } from "./profile-category.js";
 const SECTION_BY_PREFIX = {
     pref: "preferences",
     pat: "patterns",
@@ -20,6 +21,7 @@ export function applyCleanupEdits(current, job, accepted) {
     const merges = new Map(job.changes.merged.map((m) => [m.ids.join(","), m.ids]));
     const removals = new Set(job.changes.removed.map((r) => r.id));
     const used = new Set();
+    const restore = [];
     let applied = 0;
     let skipped = 0;
     for (const ticked of accepted.merged ?? []) {
@@ -33,7 +35,14 @@ export function applyCleanupEdits(current, job, accepted) {
             continue;
         }
         const items = profile[found.section];
-        items[found.indices[0]] = { ...mergedItem };
+        const written = { ...mergedItem };
+        restore.push({
+            kind: "merge",
+            section: found.section,
+            originals: found.indices.map((index) => items[index]),
+            merged: written,
+        });
+        items[found.indices[0]] = written;
         for (const index of found.indices.slice(1).sort((a, b) => b - a))
             items.splice(index, 1);
         for (const id of ids)
@@ -48,11 +57,12 @@ export function applyCleanupEdits(current, job, accepted) {
             skipped++;
             continue;
         }
-        profile[found.section].splice(found.indices[0], 1);
+        const [removed] = profile[found.section].splice(found.indices[0], 1);
+        restore.push({ kind: "remove", section: found.section, original: removed });
         used.add(id);
         applied++;
     }
-    return { profile, applied, skipped };
+    return { profile, applied, skipped, restore };
 }
 /**
  * Finds each id's item from `old` in `profile`, at a distinct position, all in one
@@ -84,10 +94,14 @@ function sectionOf(id) {
 function positionOf(id) {
     return Number.parseInt(id.split("_")[1] ?? "", 10);
 }
-/** The fields that identify a profile item. Counters and vectors are left out. */
+/**
+ * The fields that identify a profile item. Counters and vectors are left out. The category
+ * counts by its key, because every save keeps one visible spelling per category and may
+ * rewrite the spelling of a stored item.
+ */
 export function profileItemIdentityKey(item) {
     return JSON.stringify({
-        category: item.category ?? null,
+        category: item.category == null ? null : categoryKey(String(item.category)),
         description: item.description ?? null,
         steps: Array.isArray(item.steps) ? item.steps : null,
     });

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

@@ -1,3 +1,4 @@
+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. */
@@ -22,8 +23,8 @@ export declare function selectForCleanup(profileData: UserProfileData, includeId
  * inside a section.
  */
 export declare function splitIntoBatches(indexed: IndexedProfile, size: number): IndexedProfile[];
-/** One model request for one batch. */
-export declare function cleanupBatch(indexed: IndexedProfile): Promise<BatchCleanupResult>;
+/** 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

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

@@ -64,12 +64,12 @@ function groupByCategory(items) {
     }
     return [...groups.keys()].sort().map((key) => groups.get(key));
 }
-/** One model request for one batch. */
-export async function cleanupBatch(indexed) {
+/** 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);
+    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);
@@ -169,6 +169,8 @@ export function failureReason(error) {
         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";
 }

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,7 +11,6 @@ export interface CleanupDiff {
         reason: string;
     }>;
 }
-export declare function aiCleanupProfile(profileData: UserProfileData): Promise<AICleanupResult>;
 export interface IndexedProfileItem {
     id: string;
     category?: string;
@@ -35,7 +31,7 @@ export interface AIMapping {
 }
 export declare function addIdsToProfile(profile: UserProfileData): IndexedProfile;
 export declare function buildAICleanupPrompt(profile: IndexedProfile): string;
-export declare function callAICleanup(prompt: string): Promise<{
+export declare function callAICleanup(prompt: string, model?: ModelPort | null): Promise<{
     profile: IndexedProfile;
     mapping: AIMapping;
 }>;

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

@@ -3,46 +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 };
-}
 // 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
@@ -112,10 +72,12 @@ function formatForAI(item) {
     const { id, category, description, frequency } = item;
     return { id, category, description, frequency };
 }
-export 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);

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>;

package/dist/services/user-profile/auto-cleanup-store.js

@@ -0,0 +1,97 @@
+import { join } from "node:path";
+import { CONFIG } from "../../config.js";
+import { tursoConnectionManager } from "../turso/connection-manager.js";
+import { USER_PROFILES_DB_NAME } from "./user-profile-manager.js";
+/** A record can be undone for this long, then it is deleted. */
+export const AUTO_CLEANUP_RECORD_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Restore records of automatic cleanups: the items a run merged or removed, as stored, and
+ * the merged item it wrote. The text is profile text and stays in the profile database. It
+ * is never logged.
+ */
+async function connection() {
+    const db = await tursoConnectionManager.getConnection(join(CONFIG.storagePath || "", USER_PROFILES_DB_NAME));
+    await db.execute(`CREATE TABLE IF NOT EXISTS profile_auto_cleanups (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    profile_id TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    prompts_analyzed INTEGER NOT NULL,
+    merged INTEGER NOT NULL,
+    removed INTEGER NOT NULL,
+    entries TEXT NOT NULL,
+    undone_at INTEGER
+  )`);
+    return db;
+}
+async function prune(db, now) {
+    await db.execute("DELETE FROM profile_auto_cleanups WHERE created_at < ?", [
+        now - AUTO_CLEANUP_RECORD_MAX_AGE_MS,
+    ]);
+}
+export async function insertAutoCleanupRecord(profileId, record, now = Date.now()) {
+    const db = await connection();
+    await prune(db, now);
+    // The id comes from this INSERT. A separate SELECT could return the row of another host
+    // that wrote for the same profile in between, and a failed save would delete that row.
+    const result = await db.execute("INSERT INTO profile_auto_cleanups (profile_id, created_at, prompts_analyzed, merged, removed, entries) VALUES (?, ?, ?, ?, ?, ?)", [
+        profileId,
+        now,
+        record.promptsAnalyzed,
+        record.merged,
+        record.removed,
+        JSON.stringify(record.entries),
+    ]);
+    if (result.lastInsertRowid === undefined)
+        throw new Error("Restore record id missing");
+    return Number(result.lastInsertRowid);
+}
+/**
+ * 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 async function pruneAutoCleanupRecords(now = Date.now()) {
+    const db = await connection();
+    const result = await db.execute("DELETE FROM profile_auto_cleanups WHERE created_at < ?", [
+        now - AUTO_CLEANUP_RECORD_MAX_AGE_MS,
+    ]);
+    return Number(result.rowsAffected ?? 0);
+}
+export async function deleteAutoCleanup(id) {
+    const db = await connection();
+    await db.execute("DELETE FROM profile_auto_cleanups WHERE id = ?", [id]);
+}
+/** The newest record of the profile that is not undone, without its items. */
+export async function latestOpenAutoCleanupSummary(profileId, now = Date.now()) {
+    const db = await connection();
+    await prune(db, now);
+    const row = await db.get("SELECT id, created_at, merged, removed FROM profile_auto_cleanups WHERE profile_id = ? AND undone_at IS NULL ORDER BY id DESC LIMIT 1", [profileId]);
+    if (!row)
+        return null;
+    return {
+        id: Number(row.id),
+        createdAt: Number(row.created_at),
+        merged: Number(row.merged),
+        removed: Number(row.removed),
+    };
+}
+/** The newest record of the profile that is not undone, with the items to restore. */
+export async function latestOpenAutoCleanup(profileId, now = Date.now()) {
+    const db = await connection();
+    await prune(db, now);
+    const row = await db.get("SELECT id, created_at, prompts_analyzed, merged, removed, entries FROM profile_auto_cleanups WHERE profile_id = ? AND undone_at IS NULL ORDER BY id DESC LIMIT 1", [profileId]);
+    if (!row)
+        return null;
+    return {
+        id: Number(row.id),
+        createdAt: Number(row.created_at),
+        promptsAnalyzed: Number(row.prompts_analyzed),
+        merged: Number(row.merged),
+        removed: Number(row.removed),
+        entries: JSON.parse(String(row.entries)),
+    };
+}
+export async function markAutoCleanupUndone(id, now = Date.now()) {
+    const db = await connection();
+    await db.execute("UPDATE profile_auto_cleanups SET undone_at = ? WHERE id = ?", [now, id]);
+}

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

@@ -0,0 +1,10 @@
+export interface AutoCleanupSettings {
+    enabled?: boolean;
+    interval?: number;
+}
+/**
+ * True when a learning pass that took the analysed-prompt count of the profile from
+ * `previous` to `previous + added` passed a multiple of the interval. The caller passes the
+ * two settings, so this module does not read the config.
+ */
+export declare function shouldStartAutoCleanup(previous: number, added: number, settings: AutoCleanupSettings): boolean;

package/dist/services/user-profile/auto-cleanup-trigger.js

@@ -0,0 +1,12 @@
+/**
+ * True when a learning pass that took the analysed-prompt count of the profile from
+ * `previous` to `previous + added` passed a multiple of the interval. The caller passes the
+ * two settings, so this module does not read the config.
+ */
+export function shouldStartAutoCleanup(previous, added, settings) {
+    const { interval } = settings;
+    if (!settings.enabled || !Number.isInteger(interval) || interval <= 0)
+        return false;
+    const every = interval;
+    return Math.floor(previous / every) < Math.floor((previous + added) / every);
+}

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

@@ -0,0 +1,32 @@
+import type { ModelPort } from "../../core/profile-analysis.js";
+import { type RunInBatchesOptions } from "./ai-cleanup-batches.js";
+import { type ProfileEditStore } from "./profile-edit-save.js";
+/** A run that would remove or merge away more than this share of its items applies nothing. */
+export declare const AUTO_CLEANUP_MAX_CHANGE_SHARE = 0.25;
+export type AutoCleanupOutcome = {
+    status: "applied";
+    applied: number;
+    skipped: number;
+} | {
+    status: "unchanged";
+    skipped: number;
+} | {
+    status: "already-running" | "no-profile" | "too-few-items" | "nothing-to-change" | "too-many-changes" | "conflict" | "failed";
+};
+export interface AutoCleanupOptions {
+    /** A host that has its own model for profile work (Pi) gives it here. */
+    resolveModel?: () => ModelPort | null;
+    /** Replaces the model call. Tests use this. */
+    callBatch?: RunInBatchesOptions["callBatch"];
+    batchSize?: number;
+    /** The profile store. It defaults to the shared profile manager. */
+    store?: ProfileEditStore;
+}
+/**
+ * Cleans up the whole profile in the background: duplicates are merged and useless items
+ * are removed, in batches, and every change is saved into the newest profile with no
+ * review. Before a save it stores a restore record, so the last run can be undone. The
+ * caller does not wait for it, and nothing here throws. The log holds counts and fixed
+ * codes only, never item text.
+ */
+export declare function startAutoProfileCleanup(userId: string, options?: AutoCleanupOptions): Promise<AutoCleanupOutcome>;