cursor-history 0.15.0 → 0.16.0

package/dist/core/storage.js

@@ -4,10 +4,9 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import JSZip from 'jszip';
 import { openDatabase as openDatabaseAsync, openDatabaseReadWrite as openDatabaseReadWriteAsync, ensureDriver, } from './database/index.js';
-import { getCursorDataPath, contractPath, normalizePath, pathsEqual } from '../lib/platform.js';
+import { getCursorDataPath, getGlobalStoragePath, contractPath, normalizePath, pathsEqual, } from '../lib/platform.js';
 import { SessionNotFoundError } from '../lib/errors.js';
 import { parseChatData, getSearchSnippets } from './parser.js';
 import { openBackupDatabase, readBackupManifest } from './backup.js';
@@ -25,22 +24,6 @@ const CHAT_DATA_KEYS = [
  */
 const PROMPTS_KEY = 'aiService.prompts';
 const GENERATIONS_KEY = 'aiService.generations';
-/**
- * Get the global Cursor storage path
- */
-function getGlobalStoragePath() {
-    const platform = process.platform;
-    const home = homedir();
-    if (platform === 'win32') {
-        return join(process.env['APPDATA'] ?? join(home, 'AppData', 'Roaming'), 'Cursor', 'User', 'globalStorage');
-    }
-    else if (platform === 'darwin') {
-        return join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage');
-    }
-    else {
-        return join(home, '.config', 'Cursor', 'User', 'globalStorage');
-    }
-}
 /**
  * Open a SQLite database file (read-only)
  * @deprecated Use openDatabaseAsync for new code
@@ -76,6 +59,162 @@ function closeDatabase(db) {
 function getBubbleRowId(rowKey) {
     return rowKey.split(':').pop() ?? null;
 }
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * A composer entry carries real metadata when it has any field beyond `composerId`.
+ * Synthetic `{ composerId }` stubs (fabricated from `selectedComposerIds` by
+ * getComposerData) must never be persisted back into `allComposers`, or they would
+ * parse to phantom sessions with a null title and a "now" timestamp.
+ */
+function isHydratedComposer(composer) {
+    return Object.keys(composer).some((key) => key !== 'composerId');
+}
+function parseDateValue(value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        return null;
+    }
+    // Epoch-ms timestamps can arrive as numeric strings ("1778672423842"); new Date()
+    // treats those as invalid, so coerce all-digit strings to a number first.
+    const normalized = typeof value === 'string' && /^\d+$/.test(value.trim()) ? Number(value.trim()) : value;
+    const date = new Date(normalized);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function uriToPath(uri) {
+    try {
+        return decodeURIComponent(uri.replace(/^file:\/\//, ''));
+    }
+    catch {
+        return uri.replace(/^file:\/\//, '');
+    }
+}
+function workspacePathMatches(candidatePath, workspacePath) {
+    return typeof candidatePath === 'string' && pathsEqual(uriToPath(candidatePath), workspacePath);
+}
+function composerBelongsToWorkspace(composerData, workspace) {
+    const workspaceIdentifier = composerData['workspaceIdentifier'];
+    if (isRecord(workspaceIdentifier)) {
+        if (workspaceIdentifier['id'] === workspace.id) {
+            return true;
+        }
+        const uri = workspaceIdentifier['uri'];
+        if (isRecord(uri)) {
+            if (workspacePathMatches(uri['fsPath'], workspace.path) ||
+                workspacePathMatches(uri['path'], workspace.path) ||
+                workspacePathMatches(uri['external'], workspace.path)) {
+                return true;
+            }
+        }
+    }
+    return workspacePathMatches(composerData['workspaceUri'], workspace.path);
+}
+/** Whether a global composer record carries any explicit workspace attribution. */
+function composerHasWorkspaceStamp(composerData) {
+    if (isRecord(composerData['workspaceIdentifier'])) {
+        return true;
+    }
+    const workspaceUri = composerData['workspaceUri'];
+    return typeof workspaceUri === 'string' && workspaceUri.length > 0;
+}
+/**
+ * Best-effort workspace path for a global composer that is not attributed to any
+ * discovered workspace, derived from whatever workspace metadata the record does
+ * carry. Returns null when the record has no usable workspace hint.
+ */
+function workspacePathFromComposer(composerData) {
+    const workspaceIdentifier = composerData['workspaceIdentifier'];
+    if (isRecord(workspaceIdentifier) && isRecord(workspaceIdentifier['uri'])) {
+        const uri = workspaceIdentifier['uri'];
+        for (const field of ['fsPath', 'path', 'external']) {
+            const value = uri[field];
+            if (typeof value === 'string' && value.length > 0) {
+                return uriToPath(value);
+            }
+        }
+    }
+    const workspaceUri = composerData['workspaceUri'];
+    if (typeof workspaceUri === 'string' && workspaceUri.length > 0) {
+        return uriToPath(workspaceUri);
+    }
+    return null;
+}
+function extractComposerIdsFromData(dataText) {
+    if (!dataText) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(dataText);
+        const ids = new Map();
+        if (Array.isArray(parsed)) {
+            for (const entry of parsed) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const composerId = entry.composerId;
+                if (typeof composerId === 'string' && composerId.trim().length > 0) {
+                    ids.set(composerId, 'allComposers');
+                }
+            }
+        }
+        else if (parsed && typeof parsed === 'object') {
+            const allComposers = parsed.allComposers;
+            if (Array.isArray(allComposers)) {
+                for (const entry of allComposers) {
+                    if (!entry || typeof entry !== 'object')
+                        continue;
+                    const composerId = entry.composerId;
+                    if (typeof composerId === 'string' && composerId.trim().length > 0) {
+                        ids.set(composerId, 'allComposers');
+                    }
+                }
+            }
+            const selected = parsed.selectedComposerIds;
+            if (Array.isArray(selected)) {
+                for (const composerId of selected) {
+                    if (typeof composerId === 'string' && composerId.trim().length > 0 && !ids.has(composerId)) {
+                        ids.set(composerId, 'selectedComposerIds');
+                    }
+                }
+            }
+        }
+        return [...ids.entries()].map(([composerId, source]) => ({ composerId, source }));
+    }
+    catch {
+        return [];
+    }
+}
+const COMPOSER_GUID_RE = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/g;
+/**
+ * Modern Cursor links a workspace to its agent/composer sessions through
+ * per-workspace UI-state pointer keys (e.g. `workbench.panel.composerChatViewPane.<guid>`)
+ * rather than stamping the workspace into the global composer record. Extract the
+ * composer GUIDs referenced by those pointers so they can be resolved from global
+ * storage. GUIDs that are not real composers simply resolve to nothing downstream.
+ */
+function getWorkspaceComposerPointerIds(db) {
+    try {
+        const rows = db
+            .prepare("SELECT key, value FROM ItemTable WHERE key LIKE '%composerChatViewPane%'")
+            .all();
+        const ids = new Set();
+        for (const row of rows) {
+            for (const source of [row.key, row.value]) {
+                if (typeof source !== 'string')
+                    continue;
+                const matches = source.match(COMPOSER_GUID_RE);
+                if (matches) {
+                    for (const match of matches) {
+                        ids.add(match.toLowerCase());
+                    }
+                }
+            }
+        }
+        return [...ids];
+    }
+    catch {
+        return [];
+    }
+}
 function parseToolParams(paramsText, rawArgsText) {
     const rawText = paramsText ?? rawArgsText;
     if (typeof rawText !== 'string' || rawText.trim().length === 0) {
@@ -386,6 +525,14 @@ export async function findWorkspaces(customDataPath, backupPath) {
         return [];
     }
     const workspaces = [];
+    let globalDb = null;
+    let globalDbChecked = false;
+    let globalDbAvailable = false;
+    let globalComposerRecords = [];
+    let globalBubbleCounts = new Map();
+    // Run-level set so a global composer is counted for at most one workspace,
+    // keeping `list --workspaces` counts consistent with the deduped `list` output.
+    const attributedComposerIds = new Set();
     try {
         const entries = readdirSync(basePath, { withFileTypes: true });
         for (const entry of entries) {
@@ -395,24 +542,102 @@ export async function findWorkspaces(customDataPath, backupPath) {
             const dbPath = join(workspaceDir, 'state.vscdb');
             if (!existsSync(dbPath))
                 continue;
-            const workspacePath = readWorkspaceJson(workspaceDir);
-            if (!workspacePath)
-                continue;
+            const workspacePath = readWorkspaceJson(workspaceDir) ?? `(workspace: ${entry.name})`;
+            if (workspacePath.startsWith('(workspace:')) {
+                debugLogStorage(`Using workspace ID fallback path for ${entry.name} (workspace.json missing/unknown)`);
+            }
             // Count sessions in this workspace
             let sessionCount = 0;
+            const seenComposerIds = new Set();
+            const selectedIds = [];
+            const pointerIds = [];
             try {
                 const db = await openDatabase(dbPath);
                 const result = getChatDataFromDb(db);
                 if (result) {
                     const parsed = parseChatData(result.data, result.bundle);
                     sessionCount = parsed.length;
+                    for (const session of parsed) {
+                        seenComposerIds.add(session.id);
+                        attributedComposerIds.add(session.id);
+                    }
+                    const rawComposerData = result.bundle.composerData;
+                    const composerRefs = extractComposerIdsFromData(rawComposerData);
+                    selectedIds.push(...composerRefs
+                        .filter((ref) => ref.source === 'selectedComposerIds')
+                        .map((ref) => ref.composerId));
+                }
+                else {
+                    debugLogStorage(`No chat data keys found in workspace DB ${dbPath}`);
                 }
+                // Pointer keys live in ItemTable independently of composer.composerData.
+                pointerIds.push(...getWorkspaceComposerPointerIds(db));
                 db.close();
             }
-            catch {
+            catch (error) {
+                debugLogStorage(`Skipping unreadable workspace DB ${dbPath}: ${getErrorMessage(error)}`);
                 // Skip workspaces with unreadable databases
                 continue;
             }
+            if (!globalDbChecked) {
+                globalDbChecked = true;
+                const globalDbPath = join(getGlobalStoragePath(customDataPath), 'state.vscdb');
+                if (existsSync(globalDbPath)) {
+                    try {
+                        globalDb = await openDatabase(globalDbPath);
+                        const tableCheck = globalDb
+                            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='cursorDiskKV'")
+                            .get();
+                        globalDbAvailable = Boolean(tableCheck);
+                        if (globalDbAvailable) {
+                            globalComposerRecords = loadGlobalComposerRecords(globalDb);
+                            globalBubbleCounts = loadGlobalBubbleCounts(globalDb);
+                        }
+                    }
+                    catch {
+                        closeDatabase(globalDb);
+                        globalDb = null;
+                        globalDbAvailable = false;
+                    }
+                }
+            }
+            if (globalDb && globalDbAvailable) {
+                // Selected + pointer IDs are only counted when they resolve to a real
+                // global composer with bubbles, so non-composer GUIDs never inflate counts.
+                for (const composerId of [...selectedIds, ...pointerIds]) {
+                    if (seenComposerIds.has(composerId) || attributedComposerIds.has(composerId))
+                        continue;
+                    if ((globalBubbleCounts.get(composerId) ?? 0) > 0) {
+                        seenComposerIds.add(composerId);
+                        attributedComposerIds.add(composerId);
+                        sessionCount++;
+                    }
+                }
+                const workspaceForGlobalMatch = {
+                    id: entry.name,
+                    path: workspacePath,
+                    dbPath,
+                    sessionCount,
+                };
+                for (const summary of getGlobalComposerSummariesForWorkspace(globalDb, workspaceForGlobalMatch, globalComposerRecords, globalBubbleCounts)) {
+                    if (seenComposerIds.has(summary.id) || attributedComposerIds.has(summary.id))
+                        continue;
+                    seenComposerIds.add(summary.id);
+                    attributedComposerIds.add(summary.id);
+                    sessionCount++;
+                }
+            }
+            else {
+                // No global storage: pointer GUIDs cannot be confirmed as composers, so
+                // only count real selectedComposerIds (avoid phantom session counts).
+                for (const composerId of selectedIds) {
+                    if (seenComposerIds.has(composerId) || attributedComposerIds.has(composerId))
+                        continue;
+                    seenComposerIds.add(composerId);
+                    attributedComposerIds.add(composerId);
+                    sessionCount++;
+                }
+            }
             if (sessionCount > 0) {
                 workspaces.push({
                     id: entry.name,
@@ -426,6 +651,9 @@ export async function findWorkspaces(customDataPath, backupPath) {
     catch {
         return [];
     }
+    finally {
+        closeDatabase(globalDb);
+    }
     return workspaces;
 }
 /**
@@ -433,27 +661,40 @@ export async function findWorkspaces(customDataPath, backupPath) {
  * Returns both the main chat data and the bundle for new format
  */
 function getChatDataFromDb(db) {
-    let mainData = null;
-    const bundle = {};
-    // Try to get the main chat data
+    const candidates = [];
     for (const key of CHAT_DATA_KEYS) {
         try {
             const row = db.prepare('SELECT value FROM ItemTable WHERE key = ?').get(key);
             if (row?.value) {
-                mainData = row.value;
-                if (key === 'composer.composerData') {
-                    bundle.composerData = row.value;
-                }
-                break;
+                candidates.push({ key, value: row.value });
             }
         }
         catch {
             continue;
         }
     }
-    if (!mainData) {
+    if (candidates.length === 0) {
         return null;
     }
+    let selected = candidates[0];
+    let bestSessionCount = -1;
+    for (const candidate of candidates) {
+        const candidateBundle = {};
+        if (candidate.key === 'composer.composerData') {
+            candidateBundle.composerData = candidate.value;
+        }
+        const parsedCount = parseChatData(candidate.value, candidateBundle).length;
+        if (parsedCount > bestSessionCount) {
+            selected = candidate;
+            bestSessionCount = parsedCount;
+        }
+    }
+    const mainData = selected.value;
+    const bundle = {};
+    const composerCandidate = candidates.find((candidate) => candidate.key === 'composer.composerData');
+    if (composerCandidate) {
+        bundle.composerData = composerCandidate.value;
+    }
     // For new format, also get prompts and generations
     try {
         const promptsRow = db.prepare('SELECT value FROM ItemTable WHERE key = ?').get(PROMPTS_KEY);
@@ -475,6 +716,193 @@ function getChatDataFromDb(db) {
     }
     return { data: mainData, bundle };
 }
+/**
+ * Count bubbles per composer in a single pass over global storage, instead of one
+ * `COUNT(*) ... LIKE 'bubbleId:<id>:%'` full scan per composer. Reused across the
+ * recovery passes so listing stays roughly one bubble-table scan rather than O(C).
+ */
+function loadGlobalBubbleCounts(db) {
+    const counts = new Map();
+    try {
+        const rows = db
+            .prepare("SELECT key FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'")
+            .all();
+        for (const row of rows) {
+            // key form: bubbleId:<composerId>:<bubbleId>
+            const composerId = row.key.split(':')[1];
+            if (composerId) {
+                counts.set(composerId, (counts.get(composerId) ?? 0) + 1);
+            }
+        }
+    }
+    catch {
+        // Fall back to per-composer counting when the scan fails.
+    }
+    return counts;
+}
+function buildGlobalComposerSummary(db, composerId, composerData, options) {
+    const messageCount = options?.bubbleCount ??
+        (db
+            .prepare('SELECT COUNT(*) as count FROM cursorDiskKV WHERE key LIKE ?')
+            .get(`bubbleId:${composerId}:%`).count);
+    if (messageCount <= 0) {
+        return null;
+    }
+    let preview = '';
+    if (options?.includePreview !== false) {
+        const firstBubble = db
+            .prepare('SELECT value FROM cursorDiskKV WHERE key LIKE ? ORDER BY rowid ASC LIMIT 1')
+            .get(`bubbleId:${composerId}:%`);
+        if (firstBubble?.value) {
+            try {
+                const bubbleData = JSON.parse(firstBubble.value);
+                preview = extractBubbleText(bubbleData).slice(0, 100);
+            }
+            catch {
+                preview = '';
+            }
+        }
+    }
+    const createdAt = parseDateValue(composerData['createdAt']) ?? new Date();
+    const lastUpdatedAt = parseDateValue(composerData['lastUpdatedAt']) ??
+        parseDateValue(composerData['updatedAt']) ??
+        createdAt;
+    return {
+        id: composerId,
+        title: typeof composerData['name'] === 'string'
+            ? composerData['name']
+            : typeof composerData['title'] === 'string'
+                ? composerData['title']
+                : null,
+        createdAt,
+        lastUpdatedAt,
+        messageCount,
+        preview,
+    };
+}
+function getGlobalComposerSummary(db, composerId, bubbleCounts) {
+    try {
+        const composerRow = db.prepare('SELECT value FROM cursorDiskKV WHERE key = ?').get(`composerData:${composerId}`);
+        if (!composerRow?.value) {
+            return null;
+        }
+        const composerData = JSON.parse(composerRow.value);
+        if (!isRecord(composerData)) {
+            return null;
+        }
+        return buildGlobalComposerSummary(db, composerId, composerData, {
+            bubbleCount: bubbleCounts?.get(composerId),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load and parse every `composerData:%` row from global storage exactly once.
+ * Callers reuse the result across all workspaces instead of re-scanning and
+ * re-parsing the full composer table per workspace (which made `list` O(W×C)).
+ */
+function loadGlobalComposerRecords(db) {
+    try {
+        const rows = db
+            .prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'")
+            .all();
+        const records = [];
+        for (const row of rows) {
+            try {
+                const data = JSON.parse(row.value);
+                if (isRecord(data)) {
+                    records.push({ id: row.key.replace('composerData:', ''), data });
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return records;
+    }
+    catch {
+        return [];
+    }
+}
+function getGlobalComposerSummariesForWorkspace(db, workspace, records, bubbleCounts) {
+    const summaries = [];
+    for (const record of records) {
+        if (!composerBelongsToWorkspace(record.data, workspace)) {
+            continue;
+        }
+        const summary = buildGlobalComposerSummary(db, record.id, record.data, {
+            bubbleCount: bubbleCounts?.get(record.id),
+        });
+        if (summary) {
+            summaries.push(summary);
+        }
+    }
+    return summaries;
+}
+/**
+ * Return the composer IDs whose global-storage record is linked to `workspace`
+ * (via workspaceIdentifier or workspaceUri). Used by workspace migration so that
+ * sessions discoverable only through global storage are migrated too, matching
+ * what `list` surfaces for the workspace.
+ */
+export async function getWorkspaceLinkedComposerIds(workspace, customDataPath) {
+    const globalDbPath = join(getGlobalStoragePath(customDataPath), 'state.vscdb');
+    if (!existsSync(globalDbPath)) {
+        return [];
+    }
+    let db = null;
+    try {
+        db = await openDatabase(globalDbPath);
+        const tableCheck = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='cursorDiskKV'")
+            .get();
+        if (!tableCheck) {
+            return [];
+        }
+        const ids = new Set();
+        const records = loadGlobalComposerRecords(db);
+        const recordById = new Map(records.map((record) => [record.id, record.data]));
+        for (const record of records) {
+            if (composerBelongsToWorkspace(record.data, workspace)) {
+                ids.add(record.id);
+            }
+        }
+        // Also include composers referenced by this workspace's pointer keys (the
+        // modern linkage). Because migration is destructive, only include a pointer ID
+        // when its record is unstamped or already belongs to this workspace — never one
+        // explicitly stamped for a different workspace (which the user merely viewed).
+        if (existsSync(workspace.dbPath)) {
+            let wsDb = null;
+            try {
+                wsDb = await openDatabase(workspace.dbPath);
+                for (const pointerId of getWorkspaceComposerPointerIds(wsDb)) {
+                    const data = recordById.get(pointerId);
+                    if (!data)
+                        continue;
+                    if (!composerHasWorkspaceStamp(data) || composerBelongsToWorkspace(data, workspace)) {
+                        ids.add(pointerId);
+                    }
+                }
+            }
+            catch {
+                // Ignore unreadable workspace DB; global-linked IDs are still returned.
+            }
+            finally {
+                closeDatabase(wsDb);
+            }
+        }
+        return [...ids];
+    }
+    catch (error) {
+        debugLogStorage(`Failed to load workspace-linked composer IDs: ${getErrorMessage(error)}`);
+        return [];
+    }
+    finally {
+        closeDatabase(db);
+    }
+}
 /**
  * List chat sessions with optional filtering
  * Uses workspace storage for listing (has correct paths and complete list)
@@ -503,6 +931,7 @@ export async function listSessions(options, customDataPath, backupPath) {
     const allSessions = [];
     // When listing all workspaces (no filter), dedupe by session id; keep first occurrence (workspace order is already deterministic)
     const seenIds = options.workspacePath ? null : new Set();
+    const globalFallbackCandidates = [];
     for (const workspace of filteredWorkspaces) {
         try {
             // Open database from live or backup source
@@ -510,11 +939,26 @@ export async function listSessions(options, customDataPath, backupPath) {
                 ? await openBackupDatabase(backupPath, workspace.dbPath)
                 : await openDatabase(workspace.dbPath);
             const result = getChatDataFromDb(db);
+            // Pointer keys (e.g. composerChatViewPane.<guid>) live in ItemTable and link
+            // this workspace to its global composers even when no workspace stamp exists.
+            const pointerIds = backupPath ? [] : getWorkspaceComposerPointerIds(db);
             db.close();
-            if (!result)
-                continue;
-            const sessions = parseChatData(result.data, result.bundle);
+            const sessions = result ? parseChatData(result.data, result.bundle) : [];
+            const workspaceSeenIds = new Set();
+            const selectedIds = [];
+            if (result) {
+                const rawComposerData = result.bundle.composerData;
+                const composerRefs = extractComposerIdsFromData(rawComposerData);
+                selectedIds.push(...composerRefs
+                    .filter((ref) => ref.source === 'selectedComposerIds')
+                    .map((ref) => ref.composerId));
+            }
+            selectedIds.push(...pointerIds);
+            if (selectedIds.length > 0) {
+                debugLogStorage(`Workspace ${workspace.id} has ${selectedIds.length} global recovery candidate(s)`);
+            }
             for (const session of sessions) {
+                workspaceSeenIds.add(session.id);
                 if (seenIds?.has(session.id))
                     continue;
                 seenIds?.add(session.id);
@@ -530,11 +974,136 @@ export async function listSessions(options, customDataPath, backupPath) {
                     preview: session.messages[0]?.content.slice(0, 100) ?? '(Empty session)',
                 });
             }
+            if (!backupPath) {
+                globalFallbackCandidates.push({
+                    workspace,
+                    composerIds: selectedIds,
+                    existingIds: workspaceSeenIds,
+                    includeWorkspaceLinked: true,
+                });
+            }
         }
-        catch {
+        catch (error) {
+            debugLogStorage(`Skipping workspace ${workspace.id} while listing sessions: ${getErrorMessage(error)}`);
             continue;
         }
     }
+    if (!backupPath && (globalFallbackCandidates.length > 0 || !options.workspacePath)) {
+        const globalDbPath = join(getGlobalStoragePath(customDataPath), 'state.vscdb');
+        if (existsSync(globalDbPath)) {
+            let globalDb = null;
+            try {
+                globalDb = await openDatabase(globalDbPath);
+                const tableCheck = globalDb
+                    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='cursorDiskKV'")
+                    .get();
+                if (tableCheck) {
+                    const globalComposerRecords = loadGlobalComposerRecords(globalDb);
+                    // One pass over the bubble table instead of two LIKE scans per composer.
+                    const globalBubbleCounts = loadGlobalBubbleCounts(globalDb);
+                    const summaryCache = new Map();
+                    // Dedup recovered sessions across candidates even under `--workspace`
+                    // (where the shared `seenIds` is intentionally null), so a single global
+                    // composer matching multiple workspace dirs is listed at most once.
+                    const recoveredIds = new Set();
+                    for (const candidate of globalFallbackCandidates) {
+                        for (const composerId of candidate.composerIds) {
+                            if (candidate.existingIds.has(composerId))
+                                continue;
+                            if (seenIds?.has(composerId))
+                                continue;
+                            if (recoveredIds.has(composerId))
+                                continue;
+                            if (!summaryCache.has(composerId)) {
+                                summaryCache.set(composerId, getGlobalComposerSummary(globalDb, composerId, globalBubbleCounts));
+                            }
+                            const summary = summaryCache.get(composerId);
+                            if (!summary) {
+                                continue;
+                            }
+                            candidate.existingIds.add(summary.id);
+                            seenIds?.add(summary.id);
+                            recoveredIds.add(summary.id);
+                            allSessions.push({
+                                id: summary.id,
+                                index: 0,
+                                title: summary.title,
+                                createdAt: summary.createdAt,
+                                lastUpdatedAt: summary.lastUpdatedAt,
+                                messageCount: summary.messageCount,
+                                workspaceId: candidate.workspace.id,
+                                workspacePath: contractPath(candidate.workspace.path),
+                                preview: summary.preview || '(Empty session)',
+                            });
+                        }
+                        if (candidate.includeWorkspaceLinked) {
+                            for (const summary of getGlobalComposerSummariesForWorkspace(globalDb, candidate.workspace, globalComposerRecords, globalBubbleCounts)) {
+                                if (candidate.existingIds.has(summary.id))
+                                    continue;
+                                if (seenIds?.has(summary.id))
+                                    continue;
+                                if (recoveredIds.has(summary.id))
+                                    continue;
+                                candidate.existingIds.add(summary.id);
+                                seenIds?.add(summary.id);
+                                recoveredIds.add(summary.id);
+                                allSessions.push({
+                                    id: summary.id,
+                                    index: 0,
+                                    title: summary.title,
+                                    createdAt: summary.createdAt,
+                                    lastUpdatedAt: summary.lastUpdatedAt,
+                                    messageCount: summary.messageCount,
+                                    workspaceId: candidate.workspace.id,
+                                    workspacePath: contractPath(candidate.workspace.path),
+                                    preview: summary.preview || '(Empty session)',
+                                });
+                            }
+                        }
+                    }
+                    // Catch-all: surface global composers that could not be attributed to any
+                    // workspace (modern Cursor frequently stores no workspace stamp on the
+                    // global record). Only on the unfiltered listing, where `seenIds` tracks
+                    // everything already shown.
+                    if (seenIds && !options.workspacePath) {
+                        for (const record of globalComposerRecords) {
+                            if (seenIds.has(record.id) || recoveredIds.has(record.id))
+                                continue;
+                            // Use the precomputed bubble counts and skip the per-composer
+                            // first-bubble preview query so the catch-all stays ~one scan total
+                            // even when hundreds of composers are unattributed.
+                            const summary = buildGlobalComposerSummary(globalDb, record.id, record.data, {
+                                bubbleCount: globalBubbleCounts.get(record.id) ?? 0,
+                                includePreview: false,
+                            });
+                            if (!summary)
+                                continue;
+                            seenIds.add(summary.id);
+                            recoveredIds.add(summary.id);
+                            const derivedPath = workspacePathFromComposer(record.data);
+                            allSessions.push({
+                                id: summary.id,
+                                index: 0,
+                                title: summary.title,
+                                createdAt: summary.createdAt,
+                                lastUpdatedAt: summary.lastUpdatedAt,
+                                messageCount: summary.messageCount,
+                                workspaceId: 'global',
+                                workspacePath: derivedPath ? contractPath(derivedPath) : '(global)',
+                                preview: summary.preview || '(Empty session)',
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                debugLogStorage(`Failed to load global fallback sessions: ${getErrorMessage(error)}`);
+            }
+            finally {
+                closeDatabase(globalDb);
+            }
+        }
+    }
     // Sort by most recent first
     allSessions.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     // Assign indexes
@@ -583,7 +1152,7 @@ export async function getSession(identifier, customDataPath, backupPath) {
     // This works for both live data and backup (if backup includes globalStorage)
     let globalDb = null;
     let globalLoadFailed = false;
-    const globalDbPath = join(getGlobalStoragePath(), 'state.vscdb');
+    const globalDbPath = join(getGlobalStoragePath(customDataPath), 'state.vscdb');
     try {
         if (backupPath) {
             try {
@@ -741,8 +1310,8 @@ export async function searchSessions(query, options, customDataPath, backupPath)
  * List sessions from global Cursor storage (cursorDiskKV table)
  * This is where Cursor stores full conversation data including AI responses
  */
-export async function listGlobalSessions() {
-    const globalPath = getGlobalStoragePath();
+export async function listGlobalSessions(customDataPath) {
+    const globalPath = getGlobalStoragePath(customDataPath);
     const dbPath = join(globalPath, 'state.vscdb');
     if (!existsSync(dbPath)) {
         return [];
@@ -786,16 +1355,20 @@ export async function listGlobalSessions() {
                         // Ignore
                     }
                 }
-                const createdAt = data.createdAt ? new Date(data.createdAt) : new Date();
-                const workspacePath = data.workspaceUri
-                    ? data.workspaceUri.replace(/^file:\/\//, '').replace(/%20/g, ' ')
-                    : 'Global';
+                const createdAt = parseDateValue(data.createdAt) ?? new Date();
+                const workspacePath = data.workspaceIdentifier?.uri?.fsPath ??
+                    data.workspaceIdentifier?.uri?.path ??
+                    (data.workspaceIdentifier?.uri?.external
+                        ? uriToPath(data.workspaceIdentifier.uri.external)
+                        : data.workspaceUri
+                            ? uriToPath(data.workspaceUri)
+                            : 'Global');
                 sessions.push({
                     id: composerId,
                     index: 0,
                     title: data.name ?? data.title ?? null,
                     createdAt,
-                    lastUpdatedAt: data.updatedAt ? new Date(data.updatedAt) : createdAt,
+                    lastUpdatedAt: parseDateValue(data.lastUpdatedAt) ?? parseDateValue(data.updatedAt) ?? createdAt,
                     messageCount: bubbleCount.count,
                     workspaceId: 'global',
                     workspacePath: contractPath(workspacePath),
@@ -822,13 +1395,13 @@ export async function listGlobalSessions() {
 /**
  * Get a session from global storage by index
  */
-export async function getGlobalSession(index) {
-    const summaries = await listGlobalSessions();
+export async function getGlobalSession(index, customDataPath) {
+    const summaries = await listGlobalSessions(customDataPath);
     const summary = summaries.find((s) => s.index === index);
     if (!summary) {
         return null;
     }
-    const globalPath = getGlobalStoragePath();
+    const globalPath = getGlobalStoragePath(customDataPath);
     const dbPath = join(globalPath, 'state.vscdb');
     let db = null;
     try {
@@ -1605,19 +2178,8 @@ export async function findWorkspaceForSession(sessionId, customDataPath) {
             db.close();
             if (!result)
                 continue;
-            // Parse the composerData - could be new format with allComposers or legacy format
-            const parsed = JSON.parse(result.data);
-            // Handle new format with allComposers array
-            let composers;
-            if ('allComposers' in parsed && Array.isArray(parsed.allComposers)) {
-                composers = parsed.allComposers;
-            }
-            else if (Array.isArray(parsed)) {
-                composers = parsed;
-            }
-            else {
-                continue;
-            }
+            const composerRefs = extractComposerIdsFromData(result.bundle.composerData ?? result.data);
+            const composers = composerRefs.map((ref) => ({ composerId: ref.composerId }));
             const found = composers.some((session) => session.composerId === sessionId);
             if (found) {
                 return { workspace, dbPath: workspace.dbPath };
@@ -1642,6 +2204,39 @@ export async function findWorkspaceByPath(workspacePath, customDataPath) {
             return { workspace, dbPath: workspace.dbPath };
         }
     }
+    // Fallback: include workspaces with zero sessions so migrations can target empty destinations.
+    const basePath = getCursorDataPath(customDataPath);
+    if (!existsSync(basePath)) {
+        return null;
+    }
+    try {
+        const entries = readdirSync(basePath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const workspaceDir = join(basePath, entry.name);
+            const dbPath = join(workspaceDir, 'state.vscdb');
+            if (!existsSync(dbPath))
+                continue;
+            const workspacePathFromJson = readWorkspaceJson(workspaceDir);
+            if (!workspacePathFromJson)
+                continue;
+            if (pathsEqual(workspacePathFromJson, normalizedPath)) {
+                return {
+                    workspace: {
+                        id: entry.name,
+                        path: workspacePathFromJson,
+                        dbPath,
+                        sessionCount: 0,
+                    },
+                    dbPath,
+                };
+            }
+        }
+    }
+    catch {
+        return null;
+    }
     return null;
 }
 /**
@@ -1660,8 +2255,38 @@ export function getComposerData(db) {
         // Check if new format with allComposers
         if (rawData && typeof rawData === 'object' && 'allComposers' in rawData) {
             const data = rawData;
+            const selectedComposers = Array.isArray(data.selectedComposerIds)
+                ? data.selectedComposerIds
+                    .filter((id) => typeof id === 'string' && id.trim().length > 0)
+                    .map((id) => ({ composerId: id }))
+                : [];
+            const allComposers = Array.isArray(data.allComposers) ? data.allComposers : [];
+            const seenIds = new Set(allComposers
+                .map((composer) => composer.composerId)
+                .filter((id) => typeof id === 'string' && id.trim().length > 0));
+            const missingSelectedComposers = selectedComposers.filter((composer) => {
+                if (!composer.composerId || seenIds.has(composer.composerId)) {
+                    return false;
+                }
+                seenIds.add(composer.composerId);
+                return true;
+            });
             return {
-                composers: data.allComposers ?? [],
+                composers: [...allComposers, ...missingSelectedComposers],
+                rawData,
+                isNewFormat: true,
+            };
+        }
+        // Newer workspace shape: selectedComposerIds only (no allComposers list)
+        if (rawData &&
+            typeof rawData === 'object' &&
+            'selectedComposerIds' in rawData &&
+            Array.isArray(rawData.selectedComposerIds)) {
+            const selectedComposers = rawData.selectedComposerIds
+                .filter((id) => typeof id === 'string' && id.trim().length > 0)
+                .map((id) => ({ composerId: id }));
+            return {
+                composers: selectedComposers,
                 rawData,
                 isNewFormat: true,
             };
@@ -1689,10 +2314,53 @@ export function updateComposerData(db, composers, isNewFormat, originalRawData)
     if (isNewFormat) {
         // Preserve the original structure, just update allComposers
         if (originalRawData && typeof originalRawData === 'object') {
-            dataToWrite = { ...originalRawData, allComposers: composers };
+            const original = originalRawData;
+            const selectedOnly = Array.isArray(original['selectedComposerIds']) &&
+                (!Array.isArray(original['allComposers']) || original['allComposers'].length === 0);
+            // Only persist composers that carry real metadata. Synthetic `{ composerId }`
+            // stubs (surfaced by getComposerData's union of selectedComposerIds) would
+            // otherwise be written back and parse to phantom sessions on the next list.
+            const nextData = {
+                ...original,
+                allComposers: composers.filter(isHydratedComposer),
+            };
+            if (Array.isArray(original['selectedComposerIds'])) {
+                const composerIds = composers
+                    .map((composer) => composer.composerId)
+                    .filter((id) => typeof id === 'string' && id.trim().length > 0);
+                const composerIdSet = new Set(composerIds);
+                const originalSelected = original['selectedComposerIds'].filter((id) => typeof id === 'string' && id.trim().length > 0);
+                const selectedComposerIds = selectedOnly
+                    ? composerIds
+                    : originalSelected.filter((id) => composerIdSet.has(id));
+                nextData['selectedComposerIds'] = selectedComposerIds;
+                if (Array.isArray(original['lastFocusedComposerIds'])) {
+                    const originalFocused = original['lastFocusedComposerIds'].filter((id) => typeof id === 'string' && id.trim().length > 0);
+                    // Keep the previously focused tab whenever it survives the change;
+                    // only fall back to the first surviving composer when it does not.
+                    const survivingFocused = originalFocused.filter((id) => composerIdSet.has(id));
+                    const focusedComposerIds = survivingFocused.length > 0
+                        ? survivingFocused
+                        : selectedOnly
+                            ? selectedComposerIds.slice(0, 1)
+                            : [];
+                    nextData['lastFocusedComposerIds'] = focusedComposerIds;
+                }
+            }
+            dataToWrite = nextData;
         }
         else {
-            dataToWrite = { allComposers: composers };
+            // No original shape to preserve: write only real composers, but keep any
+            // id-only stubs referenced via selectedComposerIds so they remain listable.
+            const hydrated = composers.filter(isHydratedComposer);
+            const stubIds = composers
+                .filter((composer) => !isHydratedComposer(composer))
+                .map((composer) => composer.composerId)
+                .filter((id) => typeof id === 'string' && id.trim().length > 0);
+            dataToWrite =
+                stubIds.length > 0
+                    ? { allComposers: hydrated, selectedComposerIds: stubIds }
+                    : { allComposers: hydrated };
         }
     }
     else {