om-memory-system 4.1.0-next.56 → 4.2.0-next.58

package/dist/importer/auto-backfill.js

@@ -1,7 +1,7 @@
 import { CONFIG, refreshConfigIfChanged } from "../config.js";
 import { log } from "../services/logger.js";
 import { tryAcquireBackfillLock } from "./backfill-lock.js";
-import { getBackfillCutoff, recordUnresolvedDirectories, unresolvedDirectoriesOf, updateBackfillStatus, } from "../services/backfill-state.js";
+import { getBackfillCutoff, recordUnresolvedDirectories, unresolvedDirectoriesOf, unresolvedSessionCount, updateBackfillStatus, } from "../services/backfill-state.js";
 import { runHistoryImport, } from "./run-import.js";
 import { isManualImportRunning } from "./manual-import-guard.js";
 import { isBackfillPaused } from "./import-runs.js";
@@ -13,7 +13,7 @@ function counts(report) {
         skipped: report.unitsSkipped,
         failed: report.unitsFailed,
         pending: report.unitsWouldImport,
-        unresolved: (report.unresolvedProjects?.length ?? 0) + report.unresolvableSessions.length,
+        unresolved: unresolvedSessionCount(report),
     };
 }
 const delay = (signal) => new Promise((resolve) => {

package/dist/importer/claude-import.js

@@ -56,6 +56,7 @@ export async function importClaudeHistory(deps, filters) {
             dryRun: Boolean(filters.dryRun),
             model: deps.profile.model,
             batchSize: deps.profile.batchSize,
+            ...(deps.profile.onProgress ? { onProgress: deps.profile.onProgress } : {}),
         });
     }
     return report;

package/dist/importer/import-readiness.js

@@ -28,9 +28,9 @@ export async function importReadiness(deps = {}) {
         (deps.listOpencodeModels ??
             // Imports run OpenCode models, so they need a session, not the standalone list.
             (async () => (await import("./settings-models.js")).listOpencodeSettingsModels(undefined, null)))(),
-        (deps.loadPiSdk ?? (() => import("@earendil-works/pi-coding-agent")))().then(() => ({ available: true }), () => ({
+        (deps.loadPiSdk ?? (async () => (await import("./pi-sdk.js")).loadPiSdk()))().then(() => ({ available: true }), () => ({
             available: false,
-            reason: "The Pi SDK (@earendil-works/pi-coding-agent) is not installed for OpenCode",
+            reason: "The Pi SDK (@earendil-works/pi-coding-agent) was not found. Install Pi on this computer.",
         })),
     ]);
     return {

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

@@ -2,6 +2,8 @@ import type { BackfillHost } from "./backfill-model.js";
 import { type ProgressEstimate } from "./import-progress.js";
 export type ImportSurface = "auto" | "web" | "cli" | "slash";
 export type ImportRunState = "running" | "paused" | "stopped" | "done" | "failed";
+/** A run imports exchanges first, then learns the profile from the imported prompts. */
+export type ImportRunPhase = "exchanges" | "profile";
 export interface ImportRunCounts {
     total: number;
     done: number;
@@ -19,6 +21,10 @@ export interface ImportRun extends ImportRunCounts, ProgressEstimate {
     error: string | null;
     /** The user paused this host's backfill; automatic runs wait for Resume. */
     paused: boolean;
+    phase: ImportRunPhase;
+    /** Profile batches done and planned, while `phase` is `profile`. */
+    profileDone: number;
+    profileTotal: number;
 }
 /** Read a host's run without creating the store; a running row whose process is gone reads as stopped. */
 export declare function readImportRun(host: BackfillHost): Promise<ImportRun | null>;
@@ -27,6 +33,8 @@ export declare function setBackfillPaused(host: BackfillHost, paused: boolean):
 export interface ImportRunRecorder {
     /** Feed from `onProgress`; writes at most once per interval and checks the paused flag. */
     progress(done: number, total: number): void;
+    /** Feed from the profile step: batches done and planned. Moves the run to the profile phase. */
+    profileProgress(done: number, total: number): void;
     /** True after a progress write saw the paused flag. */
     readonly pauseRequested: boolean;
     finish(state: Exclude<ImportRunState, "running">, counts: Partial<ImportRunCounts>, error?: unknown): Promise<void>;

package/dist/importer/import-runs.js

@@ -15,6 +15,19 @@ async function table(storagePath) {
     failed INTEGER NOT NULL DEFAULT 0, error TEXT, updated_at INTEGER,
     samples TEXT, paused INTEGER NOT NULL DEFAULT 0
   )`);
+    for (const column of [
+        "phase TEXT",
+        "profile_done INTEGER NOT NULL DEFAULT 0",
+        "profile_total INTEGER NOT NULL DEFAULT 0",
+    ]) {
+        try {
+            await db.run(`ALTER TABLE import_runs ADD COLUMN ${column}`);
+        }
+        catch (error) {
+            if (!String(error?.message ?? error).includes("duplicate column"))
+                throw error;
+        }
+    }
     // A row per host keeps every later statement a plain UPDATE.
     await db.run("INSERT OR IGNORE INTO import_runs (host) VALUES ('pi'), ('opencode'), ('claude-code')");
     return db;
@@ -54,6 +67,9 @@ export async function readImportRun(host) {
         failed: Number(row.failed),
         error: row.error === null ? null : String(row.error),
         paused: Number(row.paused) === 1,
+        phase: row.phase === "profile" ? "profile" : "exchanges",
+        profileDone: Number(row.profile_done ?? 0),
+        profileTotal: Number(row.profile_total ?? 0),
         ...(state === "running"
             ? estimateProgress(total, done, samples)
             : {
@@ -85,7 +101,8 @@ export async function startImportRun(host, surface, options = {}) {
     const db = await table();
     const startedAt = clock();
     await db.run(`UPDATE import_runs SET surface = ?, state = 'running', pid = ?, started_at = ?, total = 0,
-       done = 0, imported = 0, skipped = 0, failed = 0, error = NULL, updated_at = ?, samples = '[]'
+       done = 0, imported = 0, skipped = 0, failed = 0, error = NULL, updated_at = ?, samples = '[]',
+       phase = 'exchanges', profile_done = 0, profile_total = 0
      WHERE host = ?`, [surface, process.pid, startedAt, startedAt, host]);
     let samples = [];
     let lastWrite = Number.NEGATIVE_INFINITY;
@@ -119,6 +136,14 @@ export async function startImportRun(host, surface, options = {}) {
             if (clock() - lastWrite >= interval)
                 write();
         },
+        profileProgress(done, total) {
+            const now = clock();
+            writing = writing
+                .then(() => db.run(`UPDATE import_runs SET phase = 'profile', profile_done = ?, profile_total = ?,
+               updated_at = ? WHERE host = ?`, [count(done), count(total), now, host]))
+                .then(() => { })
+                .catch(() => { });
+        },
         get pauseRequested() {
             return pauseRequested;
         },

package/dist/importer/importer.d.ts

@@ -94,6 +94,7 @@ export interface ImporterDeps {
     profile?: {
         model?: ModelPort;
         batchSize?: number;
+        onProgress?: (done: number, total: number) => void;
     };
 }
 export interface ImportWindow extends CaptureConversation {

package/dist/importer/importer.js

@@ -390,6 +390,7 @@ export async function importPiHistory(deps, filters) {
             dryRun,
             model: deps.profile.model,
             batchSize: deps.profile.batchSize,
+            ...(deps.profile.onProgress ? { onProgress: deps.profile.onProgress } : {}),
         });
     }
     return report;

package/dist/importer/map-suggestions.js

@@ -80,7 +80,8 @@ export function suggestMapTargets(directories, context = {}) {
     const withCache = { ...context, cache: context.cache ?? new Map() };
     return directories.map((item) => ({
         ...item,
-        suggestion: suggestMapTarget(item.directory, withCache),
+        // Sessions with no recorded directory have nothing to map.
+        suggestion: item.directory ? suggestMapTarget(item.directory, withCache) : null,
     }));
 }
 /**

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

@@ -26,6 +26,8 @@ export interface OpencodeImportOptions {
     profileBatch?: number;
     provider?: CaptureSummaryProvider;
     profileModel?: ModelPort;
+    /** Profile batches done and planned, during the profile step. */
+    onProfileProgress?: (done: number, total: number) => void;
     /** `alreadyHandled`: units found already done so far, which need no model call. */
     onProgress?: (processed: number, total: number, promptPreview: string, alreadyHandled?: number) => void;
     signal?: AbortSignal;

package/dist/importer/opencode-import.js

@@ -141,6 +141,7 @@ export async function importOpencodeHistory(options) {
                 dryRun: options.dryRun,
                 batchSize: options.profileBatch,
                 model: options.profileModel,
+                ...(options.onProfileProgress ? { onProgress: options.onProfileProgress } : {}),
             });
         }
         return report;

package/dist/importer/pi-sdk.d.ts

@@ -0,0 +1,19 @@
+export type PiSdk = typeof import("@earendil-works/pi-coding-agent");
+export interface PiSdkLocations {
+    home: string;
+    path: string;
+    execPath: string;
+}
+/**
+ * Folders that may hold Pi's own SDK when OMMS runs outside Pi, for example in
+ * the login web app: Pi's managed install, then each `pi` on `PATH`, then the
+ * global `node_modules` of the running Node.
+ */
+export declare function piSdkCandidates(locations: PiSdkLocations): string[];
+/**
+ * Load Pi's SDK: from OMMS's own dependencies when Pi installed OMMS, otherwise
+ * from where Pi itself is installed.
+ */
+export declare function loadPiSdk(locations?: PiSdkLocations, importer?: (specifier: string) => Promise<unknown>): Promise<PiSdk>;
+/** Tests only: forget the loaded SDK. */
+export declare function resetPiSdkCache(): void;

package/dist/importer/pi-sdk.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, dirname, isAbsolute, join } from "node:path";
+import { pathToFileURL } from "node:url";
+const PACKAGE = "@earendil-works/pi-coding-agent";
+function packageEntry(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        if (pkg.name !== PACKAGE)
+            return null;
+        const root = pkg.exports?.["."];
+        const entry = (typeof root === "string" ? root : (root?.import ?? root?.default)) ?? pkg.main;
+        return entry ? join(dir, entry) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Folders that may hold Pi's own SDK when OMMS runs outside Pi, for example in
+ * the login web app: Pi's managed install, then each `pi` on `PATH`, then the
+ * global `node_modules` of the running Node.
+ */
+export function piSdkCandidates(locations) {
+    const dirs = [];
+    const agent = join(locations.home, ".pi", "agent");
+    try {
+        const version = readFileSync(join(agent, "install", "current-version"), "utf8").trim();
+        if (/^[\w.+-]+$/.test(version) && version !== "." && version !== "..") {
+            dirs.push(join(agent, "install", "releases", version, "node_modules", PACKAGE));
+        }
+    }
+    catch {
+        // No managed Pi install.
+    }
+    for (const entry of locations.path.split(delimiter)) {
+        if (!entry || !isAbsolute(entry))
+            continue;
+        const bin = join(entry, "pi");
+        if (!existsSync(bin))
+            continue;
+        // An npm install links `pi` to a file inside the package: walk up to it.
+        let dir;
+        try {
+            dir = dirname(realpathSync(bin));
+        }
+        catch {
+            continue;
+        }
+        for (let i = 0; i < 6 && dirname(dir) !== dir; i++, dir = dirname(dir)) {
+            if (existsSync(join(dir, "package.json"))) {
+                dirs.push(dir);
+                break;
+            }
+        }
+        dirs.push(join(dirname(entry), "lib", "node_modules", PACKAGE));
+    }
+    dirs.push(join(dirname(dirname(locations.execPath)), "lib", "node_modules", PACKAGE));
+    return [...new Set(dirs)];
+}
+let cached = null;
+/**
+ * Load Pi's SDK: from OMMS's own dependencies when Pi installed OMMS, otherwise
+ * from where Pi itself is installed.
+ */
+export function loadPiSdk(locations = {
+    home: homedir(),
+    path: process.env.PATH ?? "",
+    execPath: process.execPath,
+}, importer = (specifier) => import(specifier)) {
+    if (cached)
+        return cached;
+    const attempt = (async () => {
+        try {
+            return (await importer(PACKAGE));
+        }
+        catch (first) {
+            for (const dir of piSdkCandidates(locations)) {
+                const entry = packageEntry(dir);
+                if (entry && existsSync(entry))
+                    return (await importer(pathToFileURL(entry).href));
+            }
+            throw first;
+        }
+    })();
+    cached = attempt;
+    attempt.catch(() => {
+        if (cached === attempt)
+            cached = null;
+    });
+    return attempt;
+}
+/** Tests only: forget the loaded SDK. */
+export function resetPiSdkCache() {
+    cached = null;
+}

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

@@ -24,6 +24,8 @@ export interface ProfileImportOptions {
     ledger?: Ledger;
     promptStore?: PromptStore;
     profileStore?: ProfileStore;
+    /** Profile batches done and planned; called before the first batch and after each one. */
+    onProgress?: (done: number, total: number) => void;
 }
 /** Record historical prompts and build or update the user profile in batches. */
 export declare function importProfileFromHistory(source: AsyncIterable<ImportSourceSession> | Iterable<ImportSourceSession>, options: ProfileImportOptions): Promise<ProfileImportReport>;

package/dist/importer/profile-import.js

@@ -80,7 +80,14 @@ export async function importProfileFromHistory(source, options) {
         report.error = "Profile import needs a user email";
         return report;
     }
+    const planned = (waiting) => Math.ceil(waiting / batchSize);
+    options.onProgress?.(0, planned(await prompts.countUnanalyzedForUserLearning()));
     const drained = await drainProfileBacklog({
+        ...(options.onProgress
+            ? {
+                onProgress: ({ batchesBuilt, remaining }) => options.onProgress(batchesBuilt, batchesBuilt + planned(remaining)),
+            }
+            : {}),
         user: { ...user, userEmail: user.userEmail },
         model: options.model,
         batchSize,

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

@@ -16,6 +16,8 @@ export interface HistoryImportRun {
     /** `alreadyHandled`: units found already done so far, which need no model call. */
     onProgress?: (processed: number, total: number, promptPreview: string, alreadyHandled?: number) => void;
     signal?: AbortSignal;
+    /** Profile batches done and planned, during the profile step after the exchanges. */
+    onProfileProgress?: (done: number, total: number) => void;
     /** Record progress and take the host's lock for a run that calls models. */
     track?: {
         surface: ImportSurface;

package/dist/importer/run-import.js

@@ -49,6 +49,10 @@ export async function runHistoryImport(host, args, run) {
                     recorder.progress(work.done, work.total);
                     run.onProgress?.(processed, total, preview, alreadyHandled);
                 },
+                onProfileProgress: (done, total) => {
+                    recorder.profileProgress(done, total);
+                    run.onProfileProgress?.(done, total);
+                },
             });
             const handled = report.unitsImported + report.unitsSkipped + report.unitsFailed;
             await recorder.finish(recorder.pauseRequested ? "paused" : controller.signal.aborted ? "stopped" : "done", {
@@ -59,7 +63,9 @@ export async function runHistoryImport(host, args, run) {
                 skipped: report.unitsSkipped,
                 failed: report.unitsFailed,
             });
-            await recordUnresolved(host, report);
+            // Only a run over every project and every session sees the full list.
+            if (args.scope === "all-projects" && !run.selection)
+                await recordUnresolved(host, report);
             return report;
         }
         catch (error) {
@@ -119,6 +125,7 @@ async function runUntracked(host, args, run) {
             ...(run.onProgress ? { onProgress: run.onProgress } : {}),
             ...(run.models.capture ? { provider: capture } : {}),
             ...(run.models.profile ? { profileModel: run.models.profile } : {}),
+            ...(run.onProfileProgress ? { onProfileProgress: run.onProfileProgress } : {}),
         });
     }
     const deps = {
@@ -130,6 +137,7 @@ async function runUntracked(host, args, run) {
                 profile: {
                     ...(run.models.profile ? { model: run.models.profile } : {}),
                     ...(args.profileBatch ? { batchSize: args.profileBatch } : {}),
+                    ...(run.onProfileProgress ? { onProgress: run.onProfileProgress } : {}),
                 },
             }
             : {}),

package/dist/importer/session-loader.js

@@ -1,4 +1,6 @@
-import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { loadPiSdk } from "./pi-sdk.js";
+// Outside Pi (the login web app), the SDK is found where Pi is installed.
+const { SessionManager } = await loadPiSdk();
 export function loadPiSessionForImport(file) {
     const manager = SessionManager.open(file);
     const header = manager.getHeader();

package/dist/importer/settings-models.js

@@ -75,7 +75,7 @@ export async function listOpencodeSettingsModels(client, readStandalone = readSt
         return unavailable(OPENCODE_LIST_UNAVAILABLE);
     }
 }
-export async function listPiSettingsModels(loadSdk = () => import("@earendil-works/pi-coding-agent")) {
+export async function listPiSettingsModels(loadSdk = async () => (await import("./pi-sdk.js")).loadPiSdk()) {
     try {
         const { ModelRuntime } = await loadSdk();
         // Refresh local auth availability without fetching models or writing Pi credentials.

package/dist/services/api-handlers.js

@@ -8,7 +8,8 @@ import { extractScopeFromContainerTag, tryExtractScopeFromContainerTag } from ".
 import { log } from "./logger.js";
 import { CONFIG } from "../config.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
-import { sortProfileItems } from "../utils/profile.js";
+import { sortProfileItems, stripProfileVectors } from "../utils/profile.js";
+import { resolveWebProfileUserId } from "./profile-identity.js";
 async function getAllMemoryShards() {
     await ensureTursoReady();
     const projectShards = await tursoShardManager.getAllShards("project", "");
@@ -746,11 +747,9 @@ export async function handleBulkDeletePrompts(ids, cascade = false) {
 export async function handleGetUserProfile(userId) {
     try {
         const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
-        const { getTags } = await import("./tags.js");
         let targetUserId = userId;
         if (!targetUserId) {
-            const tags = getTags(process.cwd());
-            targetUserId = tags.user.userEmail || "unknown";
+            targetUserId = (await resolveWebProfileUserId(CONFIG)) || "unknown";
         }
         const profile = await userProfileManager.getActiveProfile(targetUserId);
         if (!profile)
@@ -779,7 +778,7 @@ export async function handleGetUserProfile(userId) {
                 createdAt: safeToISOString(profile.createdAt),
                 lastAnalyzedAt: safeToISOString(profile.lastAnalyzedAt),
                 totalPromptsAnalyzed: profile.totalPromptsAnalyzed,
-                profileData,
+                profileData: stripProfileVectors(profileData),
             },
         };
     }
@@ -817,7 +816,7 @@ export async function handleGetProfileSnapshot(changelogId) {
         const changelog = await userProfileManager.getChangelogById(changelogId);
         if (!changelog)
             return { success: false, error: "Changelog not found" };
-        const profileData = JSON.parse(changelog.profileDataSnapshot);
+        const profileData = stripProfileVectors(JSON.parse(changelog.profileDataSnapshot));
         return {
             success: true,
             data: {
@@ -834,13 +833,11 @@ export async function handleGetProfileSnapshot(changelogId) {
 }
 export async function handleRefreshProfile(userId) {
     try {
-        const { getTags } = await import("./tags.js");
         const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
         const { userPromptManager } = await import("./user-prompt/user-prompt-manager.js");
         let targetUserId = userId;
         if (!targetUserId) {
-            const tags = getTags(process.cwd());
-            targetUserId = tags.user.userEmail || "unknown";
+            targetUserId = (await resolveWebProfileUserId(CONFIG)) || "unknown";
         }
         const profile = await userProfileManager.getActiveProfile(targetUserId);
         let decayApplied = false;
@@ -874,12 +871,10 @@ const pendingCleanups = new Map();
 export async function handleAICleanup(userId, includeIds, profileVersion) {
     try {
         const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
-        const { getTags } = await import("./tags.js");
         const { aiCleanupProfile, aiCleanupProfileFromIndexed, filterProfileForCleanup } = await import("./user-profile/ai-cleanup.js");
         let targetUserId = userId;
         if (!targetUserId) {
-            const tags = getTags(process.cwd());
-            targetUserId = tags.user.userEmail || "unknown";
+            targetUserId = (await resolveWebProfileUserId(CONFIG)) || "unknown";
         }
         const profile = await userProfileManager.getActiveProfile(targetUserId);
         if (!profile) {
@@ -1000,11 +995,9 @@ function pushItemFromProfile(target, source, id) {
 export async function handleApplyCleanup(userId, body) {
     try {
         const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
-        const { getTags } = await import("./tags.js");
         let targetUserId = userId;
         if (!targetUserId) {
-            const tags = getTags(process.cwd());
-            targetUserId = tags.user.userEmail || "unknown";
+            targetUserId = (await resolveWebProfileUserId(CONFIG)) || "unknown";
         }
         const pending = pendingCleanups.get(targetUserId);
         if (!pending) {
@@ -1115,9 +1108,7 @@ function removeOneByDescription(profile, desc, itemType) {
 export async function handleUpdateProfileItem(body) {
     try {
         const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
-        const { getTags } = await import("./tags.js");
-        const tags = getTags(process.cwd());
-        const userId = tags.user.userEmail || "unknown";
+        const userId = (await resolveWebProfileUserId(CONFIG)) || "unknown";
         if (!userId)
             return { success: false, error: "Unable to resolve user identity" };
         const profile = await userProfileManager.getActiveProfile(userId);

package/dist/services/backfill-state.d.ts

@@ -19,13 +19,16 @@ export type UnresolvedDirectory = {
     sessions: number;
 };
 export declare const MAX_UNRESOLVED_DIRECTORIES = 200;
+/** The entry for sessions that recorded no directory. It cannot be mapped. */
+export declare const NO_DIRECTORY = "";
 /** Record a fixed per-host cutoff before the first import. */
 export declare function getBackfillCutoff(host: BackfillHost, now?: number): Promise<number>;
 /** Read progress without creating a store or a ledger table. */
 export declare function readBackfillStatus(host: BackfillHost): Promise<BackfillStatus | null>;
 /**
  * Group unresolved sessions by directory, most sessions first, capped so the
- * row stays small. Sessions with no recorded directory are left out.
+ * row stays small. Sessions with no recorded directory share the
+ * {@link NO_DIRECTORY} entry, so the counts add up to the host's total.
  */
 export declare function summarizeUnresolvedDirectories(sessions: ReadonlyArray<{
     directory: string | null;
@@ -41,8 +44,15 @@ export declare function unresolvedDirectoriesOf(report: {
         cwd: string | null;
     }>;
 }): UnresolvedDirectory[];
+/** Unresolved sessions of an import report, the same total the Directory maps list adds up to. */
+export declare function unresolvedSessionCount(report: {
+    unresolvedProjects?: ReadonlyArray<{
+        sessions: number;
+    }>;
+    unresolvableSessions: ReadonlyArray<unknown>;
+}): number;
 /**
- * Save the unresolved directories of a host's latest listing or run. They
+ * Save the unresolved directories of a host's latest full run or listing. They
  * live in their own table, so recording them never sets a backfill cutoff.
  */
 export declare function recordUnresolvedDirectories(host: BackfillHost, directories: UnresolvedDirectory[], now?: number): Promise<void>;

package/dist/services/backfill-state.js

@@ -5,6 +5,8 @@ import { tursoConnectionManager } from "./turso/connection-manager.js";
 import { safeHealthError } from "./safe-health-error.js";
 const importLedgerDbPath = () => join(CONFIG.storagePath, "import-ledger.db");
 export const MAX_UNRESOLVED_DIRECTORIES = 200;
+/** The entry for sessions that recorded no directory. It cannot be mapped. */
+export const NO_DIRECTORY = "";
 const emptyCounts = () => ({ imported: 0, skipped: 0, failed: 0, pending: 0, unresolved: 0 });
 async function table() {
     const db = await tursoConnectionManager.getConnection(importLedgerDbPath());
@@ -51,14 +53,14 @@ export async function readBackfillStatus(host) {
 }
 /**
  * Group unresolved sessions by directory, most sessions first, capped so the
- * row stays small. Sessions with no recorded directory are left out.
+ * row stays small. Sessions with no recorded directory share the
+ * {@link NO_DIRECTORY} entry, so the counts add up to the host's total.
  */
 export function summarizeUnresolvedDirectories(sessions) {
     const byDirectory = new Map();
     for (const item of sessions) {
-        if (!item.directory)
-            continue;
-        byDirectory.set(item.directory, (byDirectory.get(item.directory) ?? 0) + (item.sessions ?? 1));
+        const key = item.directory || NO_DIRECTORY;
+        byDirectory.set(key, (byDirectory.get(key) ?? 0) + (item.sessions ?? 1));
     }
     return [...byDirectory]
         .map(([directory, count]) => ({ directory, sessions: count }))
@@ -72,8 +74,13 @@ export function unresolvedDirectoriesOf(report) {
         ...report.unresolvableSessions.map((session) => ({ directory: session.cwd })),
     ]);
 }
+/** Unresolved sessions of an import report, the same total the Directory maps list adds up to. */
+export function unresolvedSessionCount(report) {
+    const mapped = (report.unresolvedProjects ?? []).reduce((sum, item) => sum + item.sessions, 0);
+    return mapped + report.unresolvableSessions.length;
+}
 /**
- * Save the unresolved directories of a host's latest listing or run. They
+ * Save the unresolved directories of a host's latest full run or listing. They
  * live in their own table, so recording them never sets a backfill cutoff.
  */
 export async function recordUnresolvedDirectories(host, directories, now = Date.now()) {

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

@@ -0,0 +1,30 @@
+import type { UserProfile, UserProfileData } from "./user-profile/types.js";
+/** The profile store operations the Profiles card needs. */
+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>;
+    deactivateProfile(profileId: string): Promise<boolean>;
+}
+export interface ProfileSummary {
+    id: string;
+    userId: string;
+    displayName: string;
+    preferences: number;
+    patterns: number;
+    workflows: number;
+    totalPromptsAnalyzed: number;
+    lastAnalyzedAt: number;
+    inUse: boolean;
+}
+export declare class ProfileAdminError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/** Every active profile with its item counts; `currentUserId` marks the one in use. */
+export declare function listProfiles(store: ProfileAdminStore, currentUserId: string | null): Promise<ProfileSummary[]>;
+/** Merge `sourceId` into `targetId` with profile learning's rules, then turn the source off. */
+export declare function mergeProfiles(store: ProfileAdminStore, sourceId: string, targetId: string): Promise<{
+    target: ProfileSummary;
+}>;

package/dist/services/profile-admin.js

@@ -0,0 +1,54 @@
+export class ProfileAdminError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+function count(data, field) {
+    const value = data?.[field];
+    return Array.isArray(value) ? value.length : 0;
+}
+function parse(profile) {
+    return JSON.parse(profile.profileData);
+}
+/** Every active profile with its item counts; `currentUserId` marks the one in use. */
+export async function listProfiles(store, currentUserId) {
+    const profiles = await store.getAllActiveProfiles();
+    return profiles
+        .map((profile) => {
+        const data = parse(profile);
+        return {
+            id: profile.id,
+            userId: profile.userId,
+            displayName: profile.displayName,
+            preferences: count(data, "preferences"),
+            patterns: count(data, "patterns"),
+            workflows: count(data, "workflows"),
+            totalPromptsAnalyzed: profile.totalPromptsAnalyzed,
+            lastAnalyzedAt: profile.lastAnalyzedAt,
+            inUse: profile.userId === currentUserId,
+        };
+    })
+        .sort((a, b) => b.lastAnalyzedAt - a.lastAnalyzedAt);
+}
+/** Merge `sourceId` into `targetId` with profile learning's rules, then turn the source off. */
+export async function mergeProfiles(store, sourceId, targetId) {
+    if (!sourceId || !targetId)
+        throw new ProfileAdminError("sourceId and targetId are required", 400);
+    if (sourceId === targetId)
+        throw new ProfileAdminError("A profile cannot merge into itself", 400);
+    const source = await store.getProfileById(sourceId);
+    const target = await store.getProfileById(targetId);
+    if (!source?.isActive || !target?.isActive) {
+        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}`);
+    if (!saved)
+        throw new ProfileAdminError("Profile was changed by another session. Retry.", 409);
+    await store.deactivateProfile(source.id);
+    const after = (await store.getProfileById(target.id)) ?? target;
+    const [summary] = await listProfiles({ ...store, getAllActiveProfiles: async () => [after] }, null);
+    return { target: summary };
+}