create-walle 0.9.28 → 0.9.30

package/template/claude-task-manager/api-prompts.js

@@ -13,6 +13,7 @@ const permissionMatch = require('./lib/permission-match');
 // CTM permissions are a standalone global config in the CTM DB.
 const walleClient = require('./lib/walle-client');
 const claudeDesktopSessions = require('./lib/claude-desktop-sessions');
+const desktopFork = require('./lib/desktop-fork');
 const skillAutocomplete = require('./lib/skill-autocomplete');
 const skillIntentResolver = require('./lib/skill-intent-resolver');
 const resourceLinks = require('./lib/resource-links');
@@ -48,6 +49,26 @@ const CONVERSATION_IMPORT_MIN_INTERVAL_MS = Math.max(0, Number(process.env.CTM_C
 const CONVERSATION_IMPORT_FORCE_BYTES = Math.max(0, Number(process.env.CTM_CONVERSATION_IMPORT_FORCE_BYTES ?? 256 * 1024));
 const _lastConversationImportAt = new Map(); // sessionId → Date.now() of last completed import
 
+// Event-driven (near-real-time) durable import. The 8s floor above exists to stop a hot session's
+// rapid small appends from re-processing the WHOLE conversation each tick (the giant-transcript
+// write-lock thrash). With blob retirement the common case is now an O(Δ) append (a tiny write on
+// the low-priority lane), so when this is on we track the live tail at a short coalescing window —
+// but ONLY for the cheap append path. A session that recently fell back to a FULL rebuild keeps the
+// long floor so a rewrite-in-progress session can't thrash. Off → exact 8s/batch behavior.
+const CONVERSATION_IMPORT_EVENT_DRIVEN = process.env.CTM_CONVERSATION_IMPORT_EVENT_DRIVEN === '1';
+const CONVERSATION_IMPORT_EVENT_DRIVEN_MIN_INTERVAL_MS = Math.max(0, Number(
+  process.env.CTM_CONVERSATION_IMPORT_EVENT_DRIVEN_MIN_INTERVAL_MS ?? 250));
+const _lastConversationFullRebuildAt = new Map(); // sessionId → Date.now() of last FULL rebuild
+
+// Pure decision: the debounce floor for a hot session's small-growth (append-eligible) re-import.
+// Extracted so the rebuild-thrash guard is unit-testable without the import machinery.
+function _conversationImportFloorMs({ eventDriven, baseFloorMs, eventFloorMs, lastRebuildAt, now }) {
+  if (!eventDriven) return baseFloorMs;
+  // Held back to the long floor only while a recent full rebuild is still "warm".
+  const rebuiltRecently = lastRebuildAt > 0 && (now - lastRebuildAt) < baseFloorMs;
+  return rebuiltRecently ? baseFloorMs : eventFloorMs;
+}
+
 function setDbMaintenanceRunner(fn) {
   dbMaintenanceRunner = typeof fn === 'function' ? fn : null;
 }
@@ -192,6 +213,10 @@ function handlePromptApi(req, res, url) {
   const p = url.pathname;
   const m = req.method;
 
+  // --- Claude Desktop → Code conversion (snapshot-and-fork) ---
+  if (p === '/api/claude-desktop/forks' && m === 'GET') return handleListDesktopForks(req, res);
+  if (p === '/api/claude-desktop/convert' && m === 'POST') return handleConvertDesktopSession(req, res);
+
   // --- Prompts ---
   if (p === '/api/prompts' && m === 'GET') return handleListPrompts(req, res, url);
   if (p === '/api/prompts' && m === 'POST') return handleCreatePrompt(req, res);
@@ -392,6 +417,70 @@ function handleListPrompts(req, res, url) {
   jsonResponse(res, 200, db.listPrompts(opts));
 }
 
+// Convert a read-only Claude Desktop conversation into a resumable Claude Code session.
+// Thin HTTP wrapper around lib/desktop-fork.convertDesktopConversation; `deps` is injectable
+// for unit tests (defaults to the real Desktop cache + fork orchestrator).
+const DESKTOP_CACHE_ONLY_MESSAGE =
+  'Claude Desktop has only cached this conversation in the recent list — the full transcript ' +
+  'is not in the local cache yet. Open the conversation in Claude Desktop once, then rescan, ' +
+  'before converting it to a Claude Code session.';
+
+// List Desktop conversations that already have a live Claude Code fork, so the client can
+// flip "Convert" → "Resume fork" per conversation. Excludes forks whose transcript was
+// deleted (those should re-offer conversion). `deps` injectable for tests.
+function handleListDesktopForks(req, res, deps = {}) {
+  const dbm = deps.db || db;
+  const fsx = deps.fs || fs;
+  let rows;
+  try {
+    rows = dbm.listDesktopForks() || [];
+  } catch (e) {
+    return jsonResponse(res, 500, { error: 'list_failed', message: e && e.message || 'failed' });
+  }
+  const forks = rows
+    .filter((f) => f.jsonlPath && fsx.existsSync(f.jsonlPath))
+    .map((f) => ({ desktopUuid: f.desktopUuid, forkSessionId: f.forkSessionId, cwd: f.projectPath || '' }));
+  return jsonResponse(res, 200, { forks });
+}
+
+async function handleConvertDesktopSession(req, res, deps = {}) {
+  const desktop = deps.desktop || claudeDesktopSessions;
+  const fork = deps.fork || desktopFork;
+
+  let body;
+  try {
+    body = await readBody(req);
+  } catch {
+    return jsonResponse(res, 400, { error: 'invalid_body' });
+  }
+
+  const desktopUuid = String((body && body.desktopUuid) || '').trim();
+  const cwd = String((body && body.cwd) || '').trim();
+  if (!desktopUuid || !cwd) {
+    return jsonResponse(res, 400, { error: 'desktopUuid and cwd are required' });
+  }
+
+  const session = desktop.getSession(desktopUuid);
+  if (!session) {
+    return jsonResponse(res, 404, { error: 'Claude Desktop conversation not found' });
+  }
+
+  const messages = desktop.getMessages(desktopUuid) || [];
+  if (messages.length === 0) {
+    return jsonResponse(res, 409, { error: 'cache_only', message: DESKTOP_CACHE_ONLY_MESSAGE });
+  }
+
+  try {
+    const result = fork.convertDesktopConversation({ session, cwd });
+    return jsonResponse(res, 200, { ok: true, ...result });
+  } catch (e) {
+    if (/no .*message/i.test(e && e.message || '')) {
+      return jsonResponse(res, 409, { error: 'cache_only', message: DESKTOP_CACHE_ONLY_MESSAGE });
+    }
+    return jsonResponse(res, 500, { error: 'convert_failed', message: e && e.message || 'conversion failed' });
+  }
+}
+
 async function handleCreatePrompt(req, res) {
   try {
     const data = await readBody(req);
@@ -1053,7 +1142,6 @@ const {
   createCodexUserDeduper,
   parseCodexJsonlFileIntoMessagesAsync,
   parseCodexJsonlFileIntoMessages,
-  parseCodexJsonlIntoMessages,
   readCodexRolloutMetadata,
 } = require('./lib/session-history');
 const fsp = require('fs').promises;
@@ -1556,6 +1644,8 @@ async function _importCompactPair(parsed, jsonlPath, bakPath, jsonlSize, bakSize
     model_provider: parsed.modelProvider || (existing && existing.model_provider) || CLAUDE_MODEL_PROVIDER,
     model_id: parsed.modelId || (existing && existing.model_id) || '',
     import_parser_version: DEFAULT_CONVERSATION_IMPORT_PARSER_VERSION,
+    // Chunked-import route (cold/large): defer rows to content-rows-backfill, keep the real blob.
+    ..._chunkedImportFlags(parsed.sessionId, allMessages, totalSize, 'compact-pair'),
   });
   return true;
 }
@@ -1592,17 +1682,6 @@ function _codexUserDeduperFromMessages(messages) {
   return createCodexUserDeduper((Array.isArray(messages) ? messages : []).filter(msg => msg && msg.role === 'user'));
 }
 
-async function _readFileRange(filePath, start, length) {
-  const fh = await fsp.open(filePath, 'r');
-  try {
-    const buf = Buffer.alloc(length);
-    const { bytesRead } = await fh.read(buf, 0, length, start);
-    return buf.subarray(0, bytesRead).toString('utf8');
-  } finally {
-    await fh.close();
-  }
-}
-
 function _conversationImportIndexRows() {
   // Attribution: two full-table index scans built on every conversation-import
   // tick. They run as the sync prefix of _conversationImportCandidates, which is
@@ -1695,7 +1774,15 @@ async function _conversationImportCandidates(allFiles, lastScanAt) {
         const lastAt = _lastConversationImportAt.get(sessionId) || 0;
         const sinceLast = Date.now() - lastAt;
         const grewBytes = Math.max(0, effectiveSize - existingSize);
-        if (lastAt > 0 && sinceLast < CONVERSATION_IMPORT_MIN_INTERVAL_MS && grewBytes < CONVERSATION_IMPORT_FORCE_BYTES) {
+        // Near-real-time floor for the cheap append path; long floor right after a full rebuild.
+        const floorMs = _conversationImportFloorMs({
+          eventDriven: CONVERSATION_IMPORT_EVENT_DRIVEN,
+          baseFloorMs: CONVERSATION_IMPORT_MIN_INTERVAL_MS,
+          eventFloorMs: CONVERSATION_IMPORT_EVENT_DRIVEN_MIN_INTERVAL_MS,
+          lastRebuildAt: _lastConversationFullRebuildAt.get(sessionId) || 0,
+          now: Date.now(),
+        });
+        if (lastAt > 0 && sinceLast < floorMs && grewBytes < CONVERSATION_IMPORT_FORCE_BYTES) {
           continue; // imported very recently and only a little new data — let appends coalesce
         }
       }
@@ -1746,6 +1833,46 @@ function _backgroundTranscriptImportMaxBytes() {
   return Math.max(256 * 1024, Number.isFinite(raw) ? raw : BACKGROUND_TRANSCRIPT_IMPORT_DEFAULT_BYTES);
 }
 
+// Phase 1.5: a cold/large full-rebuild's inline session_message_rows write (delete-all + insert-all)
+// can block the db-owner worker for seconds — over the coop slice budget. Above a message-count
+// threshold, route the import through the CHUNKED path: importSessionConversation writes the blob +
+// stamps the source-len HWM now (forceBlobWrite + skipMessageRows), then content-rows-backfill fills
+// rows in windows across slices. Returns the two flags to spread into the importSessionConversation
+// options. Applied at every large cold-import call site (codex / claude-desktop / generic claude).
+// Over-cap sessions ignore forceBlobWrite downstream (empty blob, transcript-store source of truth).
+// Routing counters (per import run) — surfaced in the always-on [auto-import] summary so the
+// chunked-vs-inline distribution is visible WITHOUT depending on CTM_COOP_LOG reaching the worker
+// thread. Reset by runIncrementalConversationImport after it logs them.
+const _chunkedRouteStats = { chunked: 0, inline: 0 };
+function _readResetChunkedRouteStats() {
+  const s = { ..._chunkedRouteStats };
+  _chunkedRouteStats.chunked = 0; _chunkedRouteStats.inline = 0;
+  return s;
+}
+
+function _chunkedImportFlags(sessionId, messages, fileSize, reason) {
+  // Gated on the coop scheduler: deferring rows only helps when the cooperative scheduler is driving
+  // bounded slices (and the content-rows-backfill coop/legacy job fills the deferred rows). With the
+  // flag OFF the import behaves byte-for-byte as legacy (rows written inline) — so merging this branch
+  // is a true no-op on the primary until CTM_COOP_SCHEDULER=1 is set.
+  if (process.env.CTM_COOP_SCHEDULER !== '1') return { skipMessageRows: false, forceBlobWrite: false };
+  const minMsgs = Math.max(1, Number(process.env.CTM_IMPORT_CHUNK_MIN_MSGS || 1000));
+  // ALSO trigger on file size: a giant rollout is tail-bounded at parse time (transcriptMaxBytes),
+  // so `messages.length` here can be small even though the session is huge and its inline row write
+  // would block the worker. Keying on the JSONL byte high-water-mark catches those. Default 2MB.
+  const minBytes = Math.max(1, Number(process.env.CTM_IMPORT_CHUNK_MIN_BYTES || 2 * 1024 * 1024));
+  const n = Array.isArray(messages) ? messages.length : 0;
+  const bytes = Number(fileSize || 0);
+  const useChunked = n > minMsgs || bytes > minBytes;
+  _chunkedRouteStats[useChunked ? 'chunked' : 'inline'] += 1;
+  if (process.env.CTM_COOP_LOG === '1') {
+    const fileMB = (bytes / (1024 * 1024)).toFixed(1);
+    const trig = useChunked ? (n > minMsgs ? 'msgs' : 'bytes') : 'none';
+    console.log(`[coop-import] sid=${String(sessionId || '').slice(0, 8)} msgs=${n} fileMB=${fileMB} path=${useChunked ? 'chunked' : 'inline'} trigger=${trig} reason=${reason}`);
+  }
+  return { skipMessageRows: useChunked, forceBlobWrite: useChunked };
+}
+
 function _codexImportedFileSize(parsedFileSize, prevFileSize, parsedTail) {
   const fileSize = Math.max(0, Number(parsedFileSize || 0));
   const prev = Math.max(0, Number(prevFileSize || 0));
@@ -1794,8 +1921,15 @@ async function _importCodexSessionFile(parsed, filePath, options = {}) {
   const newMessages = [];
   let parsedTail;
   if (prevFileSize > 0 && parsed.fileSize > prevFileSize) {
-    const content = await _readFileRange(filePath, prevFileSize, parsed.fileSize - prevFileSize);
-    parsedTail = parseCodexJsonlIntoMessages(content, newMessages, { codexUserDeduper });
+    // Stream the new tail [prevFileSize, EOF) in bounded 1 MiB chunks, line-by-line. Reading the
+    // whole delta in one fs.read (the old _readFileRange path) passed a >2 GiB `length` for a
+    // session that grew >2 GiB since the last import, tripping V8's Int32 assertion in node::fs::Read
+    // and ABORTING the process (uncatchable) → launchd respawn loop → all Codex sessions unusable.
+    parsedTail = await parseCodexJsonlFileIntoMessagesAsync(filePath, newMessages, {
+      codexUserDeduper,
+      startOffset: prevFileSize,
+      yieldAfterMs: options.yieldAfterMs || 25,
+    });
   } else if (options.cooperative) {
     parsedTail = await parseCodexJsonlFileIntoMessagesAsync(filePath, newMessages, {
       codexUserDeduper,
@@ -1857,6 +1991,9 @@ async function _importCodexSessionFile(parsed, filePath, options = {}) {
     model_provider: modelProvider,
     model_id: model || (existing && existing.model_id) || '',
     import_parser_version: parserVersion,
+    // Chunked-import route (cold/large codex rollout — the giant-session case): defer rows to
+    // content-rows-backfill, keep the real blob. Over-cap rollouts ignore forceBlobWrite downstream.
+    ..._chunkedImportFlags(sessionId, allMessages, importedFileSize, 'codex'),
   });
 
   try {
@@ -2055,6 +2192,8 @@ async function importSessionFile(filePath, projectPath, projectEntry, options =
       model_provider: parsed.modelProvider || (existing && existing.model_provider) || CLAUDE_MODEL_PROVIDER,
       model_id: parsed.modelId || (existing && existing.model_id) || '',
       import_parser_version: DEFAULT_CONVERSATION_IMPORT_PARSER_VERSION,
+      // Chunked-import route (cold/large): defer rows to content-rows-backfill, keep the real blob.
+      ..._chunkedImportFlags(parsed.sessionId, messages, parsed.fileSize, 'claude-desktop'),
     });
     return true;
   }
@@ -2136,7 +2275,12 @@ async function importSessionFile(filePath, projectPath, projectEntry, options =
       rename_name: parsedRename || parsed.renameName || '',
       import_parser_version: DEFAULT_CONVERSATION_IMPORT_PARSER_VERSION,
     });
-    if (appended && appended.ok) return true;
+    if (appended && appended.ok) {
+      // Cheap O(Δ) append succeeded — clear any rebuild backoff so event-driven mode
+      // tracks this session's live tail at the fast cadence.
+      _lastConversationFullRebuildAt.delete(parsed.sessionId);
+      return true;
+    }
   }
 
   // Full rebuild: cold import, file shrank/rotated, or the append guard refused. Load the base
@@ -2178,6 +2322,11 @@ async function importSessionFile(filePath, projectPath, projectEntry, options =
   // but an empty new parse must not wipe an existing rename.
   const mergedRename = signals.renameName || parsedRename || parsed.renameName || (existing && existing.rename_name) || '';
 
+  // This is the expensive full-rebuild path (cold import, file shrank/rotated, or the append
+  // guard refused a non-clean-prefix). Stamp the rebuild clock so event-driven mode keeps the
+  // long debounce floor for this session until a cheap append succeeds again (no rebuild thrash).
+  try { _lastConversationFullRebuildAt.set(parsed.sessionId, Date.now()); } catch {}
+
   db.importSessionConversation({
     session_id: parsed.sessionId,
     project_path: parsed.cwd || parsed.project,
@@ -2197,6 +2346,8 @@ async function importSessionFile(filePath, projectPath, projectEntry, options =
     model_provider: parsed.modelProvider || (existing && existing.model_provider) || CLAUDE_MODEL_PROVIDER,
     model_id: parsed.modelId || (existing && existing.model_id) || '',
     import_parser_version: DEFAULT_CONVERSATION_IMPORT_PARSER_VERSION,
+    // Chunked-import route (cold/large): defer rows to content-rows-backfill, keep the real blob.
+    ..._chunkedImportFlags(parsed.sessionId, allMessages, parsed.fileSize, 'full-rebuild'),
   });
   return true;
 }
@@ -2214,19 +2365,27 @@ async function handleImportConversations(req, res) {
 // Incremental auto-import: only processes files modified since last scan
 // Uses async filesystem operations to avoid blocking the event loop
 // (critical when ~/.claude/projects is on Dropbox/network-synced FS)
-async function runIncrementalConversationImport() {
+async function runIncrementalConversationImport(opts = {}) {
+  const _now = typeof opts.now === 'function' ? opts.now : () => Date.now();
   // Capture scanStart BEFORE anything else — we advance lastScanAt even on
   // partial failure so a single bad file doesn't stall the whole job forever.
   // Previously, a top-level failure kept lastScanAt frozen, causing repeated
   // full rescans + repeated failures (stall bug observed in production).
-  const scanStart = Date.now();
+  const scanStart = _now();
   let imported = 0;
   let scanned = 0;
   let total = 0;
   let failed = 0;
   let hitLimit = false;
   let hitLimitLabel = '';
-  const maxImportedPerRun = Math.max(1, Number(process.env.CTM_CONVERSATION_IMPORT_MAX_PER_RUN || 12));
+  // Wall-clock slice budget: a single giant/cold full-rebuild can overrun the COUNT cap on TIME, so
+  // also stop between files once the budget is spent. 0/absent = no time cap (legacy behavior).
+  const budgetMs = Math.max(0, Number(opts.budgetMs ?? process.env.CTM_CONVERSATION_IMPORT_BUDGET_MS ?? 0));
+  const deadline = budgetMs > 0 ? scanStart + budgetMs : Infinity;
+  // Smaller cap (4) applies only when a slice budget is active (coop driver re-wakes immediately on
+  // hasMore, so smaller slices drain just as fast while keeping each worker op short). Legacy path
+  // (no budget) keeps the original default of 12 so flag-OFF import drain is unchanged.
+  const maxImportedPerRun = Math.max(1, Number(process.env.CTM_CONVERSATION_IMPORT_MAX_PER_RUN || (budgetMs > 0 ? 4 : 12)));
   const maxProcessedPerRun = Math.max(1, Number(process.env.CTM_CONVERSATION_IMPORT_MAX_PROCESSED_PER_RUN || maxImportedPerRun));
   const retryAfterMsRaw = Number(process.env.CTM_CONVERSATION_IMPORT_RETRY_AFTER_MS || CONVERSATION_IMPORT_RETRY_AFTER_MS);
   const retryAfterMs = Number.isFinite(retryAfterMsRaw) && retryAfterMsRaw >= 1000
@@ -2267,6 +2426,11 @@ async function runIncrementalConversationImport() {
           hitLimitLabel = importLimited ? `${maxImportedPerRun} imports` : `${maxProcessedPerRun} files`;
           break;
         }
+        if (_now() >= deadline && scanned < candidates.length) {
+          hitLimit = true;
+          hitLimitLabel = `${budgetMs}ms budget`;
+          break;
+        }
         await new Promise((resolve) => setImmediate(resolve));
       } catch (e) {
         failed++;
@@ -2276,9 +2440,11 @@ async function runIncrementalConversationImport() {
       }
     }
 
+    const _rt = _readResetChunkedRouteStats();
     if (imported > 0 || failed > 0) {
       const suffix = hitLimit ? `, paused after ${hitLimitLabel}` : '';
-      console.log(`[auto-import] Imported ${imported}, failed ${failed} (scanned ${scanned}/${total}${suffix})`);
+      const route = (_rt.chunked || _rt.inline) ? ` route=chunked:${_rt.chunked}/inline:${_rt.inline}` : '';
+      console.log(`[auto-import] Imported ${imported}, failed ${failed} (scanned ${scanned}/${total}${suffix})${route}`);
     }
     return {
       imported,
@@ -2287,11 +2453,12 @@ async function runIncrementalConversationImport() {
       candidates: candidates.length,
       failed,
       remaining: hitLimit,
+      hasMore: hitLimit,
       retry_after_ms: hitLimit ? retryAfterMs : undefined,
     };
   } catch (e) {
     console.error('[auto-import] Top-level error:', e.message);
-    return { imported, scanned, total, failed, error: e.message };
+    return { imported, scanned, total, failed, error: e.message, hasMore: false };
   } finally {
     // Always advance the timestamp — even on error — so we don't re-scan the
     // same problematic files forever on every tick.
@@ -2384,6 +2551,8 @@ async function runCursorConversationImport({ cursorHome } = {}) {
           hostname: '',
           import_parser_version: CURSOR_IMPORT_PARSER_VERSION,
           rename_name: '',
+          // Chunked-import route (cold/large cursor session): defer rows to content-rows-backfill.
+          ..._chunkedImportFlags(ctmId, fields.messages, 0, 'cursor'),
         });
         if (sig) _cursorImportSignatures.set(ctmId, sig);
         imported += 1;
@@ -2407,6 +2576,16 @@ function handleGetConversation(req, res, url) {
   const sessionId = url.pathname.split('/').pop();
   const conv = db.getSessionConversation(sessionId);
   if (!conv) return jsonResponse(res, 404, { error: 'Not found' });
+  // The stored `messages` blob is retired ('[]') by default — the conversation lives in the
+  // faithful session_message_rows. Hydrate the blob from rows for this cold API read so callers
+  // still receive the turns. O(N) reconstruction, paid only on this rare endpoint (the hot UI
+  // paths page rows directly and never hit this).
+  if ((!conv.messages || conv.messages === '[]') && typeof db.getSessionMessagesArray === 'function') {
+    try {
+      const rows = db.getSessionMessagesArray(sessionId, { fallbackToBlob: false });
+      if (Array.isArray(rows) && rows.length) conv.messages = JSON.stringify(rows);
+    } catch { /* fall through with the empty blob */ }
+  }
   jsonResponse(res, 200, conv);
 }
 
@@ -2926,10 +3105,22 @@ function screenshotResponsibleContext() {
   try { nodeIsBundle = require('./lib/real-node').isBundleExec(node); } catch {}
   const useBridge = disclaimOk && !!node && !nodeIsBundle;
   const responsiblePath = useBridge ? node : process.execPath;
-  const responsibleName = responsiblePath ? path.basename(responsiblePath) : 'CTM';
+  const responsibleName = screenshotResponsibleDisplayName(responsiblePath);
   return { realNode: node, disclaim, useBridge, responsiblePath, responsibleName, granted };
 }
 
+// macOS attributes the Screen Recording grant to the responsible binary's code SIGNATURE, and shows
+// the enclosing .app's CFBundleName. The adopted Developer-ID-notarized app's vendored node
+// (~/.walle/notarized-app/Wall-E.app/Contents/Resources/node, create-walle ensureNotarizedBrandedApp)
+// and the branded daemon bundles list as "Wall-E"/"Coding Task Manager", not the basename "node" —
+// so the guidance must name the entry the user will actually see, else they grant the wrong thing.
+function screenshotResponsibleDisplayName(responsiblePath) {
+  if (!responsiblePath) return 'CTM';
+  if (/(?:^|\/)Wall-E\.app\//.test(responsiblePath) || responsiblePath.includes('/.walle/notarized-app/')) return 'Wall-E';
+  if (/(?:^|\/)Coding Task Manager\.app\//.test(responsiblePath)) return 'Coding Task Manager';
+  return path.basename(responsiblePath);
+}
+
 function screenshotCaptureCommand(tmpFile, context = {}) {
   if (context.useBridge) {
     return {
@@ -5132,4 +5323,4 @@ function safeParse(json, fallback) {
   try { return JSON.parse(json); } catch { return fallback; }
 }
 
-module.exports = { handlePromptApi, queueEngine, runIncrementalConversationImport, runCursorConversationImport, importSessionFile, setUiPrefsBroadcaster, setPromptExecutionsOffThread, setDbMaintenanceRunner, setImageSaveRunner, ensureHotkeyDaemon, hotkeyEnsureAction, screenshotResponsibleContext, screenshotNodeCandidates, probeScreenshotNodeGranted, _ingestPathFromInput, _ingestSourceAllowed, _conversationImportCandidates, _ingestTranscriptStoreForParsedFile, _learnSignatureRules, _appendBlocklistExceptions, _finalizePermIntent, _denyHinted, _lastConversationImportAt };
+module.exports = { handlePromptApi, handleConvertDesktopSession, handleListDesktopForks, queueEngine, runIncrementalConversationImport, runCursorConversationImport, importSessionFile, _chunkedImportFlags, setUiPrefsBroadcaster, setPromptExecutionsOffThread, setDbMaintenanceRunner, setImageSaveRunner, ensureHotkeyDaemon, hotkeyEnsureAction, screenshotResponsibleContext, screenshotNodeCandidates, probeScreenshotNodeGranted, _ingestPathFromInput, _ingestSourceAllowed, _conversationImportCandidates, _ingestTranscriptStoreForParsedFile, _learnSignatureRules, _appendBlocklistExceptions, _finalizePermIntent, _denyHinted, _lastConversationImportAt, _conversationImportFloorMs, _lastConversationFullRebuildAt };