@cloudcli-ai/cloudcli 1.37.1 → 1.37.2

package/server/modules/providers/list/claude/claude-runtime.provider.js

@@ -28,6 +28,7 @@ import { CLAUDE_PREDEFINED_MODELS } from '@/modules/providers/list/claude/claude
 import { resolveClaudeCodeExecutablePath } from '@/shared/claude-cli-path.js';
 import {
   createNotificationEvent,
+  notifyBackgroundWorkCompleted,
   notifyRunFailed,
   notifyRunStopped,
   notifyUserIfEnabled
@@ -40,9 +41,32 @@ const pendingToolApprovals = new Map();
 // terminal `complete` (aborted: true) to the client, so the run loop must not
 // emit a second one when its generator winds down.
 const abortedSessionIds = new Set();
+// Query instances interrupted because a newer run took over their session id
+// (see addSession). Their run loops must stay silent on wind-down: the map
+// entry, the abort flag, and all client-facing events belong to the new run.
+const supersededInstances = new WeakSet();
 
 const TOOL_APPROVAL_TIMEOUT_MS = parseInt(process.env.CLAUDE_TOOL_APPROVAL_TIMEOUT_MS, 10) || 55000;
 
+// How long background work is allowed to keep running after a turn ends. This drives
+// two halves of the same behaviour:
+//
+//  1. Passed to the spawned CLI as CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS, which is how
+//     long it waits for still-running background *agents* before killing them.
+//  2. A backstop on how long we hold the SDK's stdin open after a turn's `result`.
+//     The SDK closes stdin as soon as a turn ends, and the CLI reads that EOF as
+//     "print wind-down" — killing background *shells* after a short grace period,
+//     which the ceiling above does not cover. Holding stdin open also lets the CLI
+//     push follow-up turns (background-task completions, Monitor notifications,
+//     scheduled wake-ups).
+//
+// The hold normally ends long before this: a turn with nothing outstanding closes
+// stdin immediately, background work releases it as soon as it reports back, and a
+// new turn supersedes the previous hold. This ceiling only catches background work
+// that never reports at all, so an abandoned session cannot leak a CLI process
+// forever. The timer resets on every message, so it measures silence, not total time.
+const BG_WAIT_CEILING_MS = 30 * 60 * 1000;
+
 const TOOLS_REQUIRING_INTERACTION = new Set(['AskUserQuestion', 'ExitPlanMode']);
 
 function resolveClaudeEffort(model, effort, modelsDefinition = CLAUDE_PREDEFINED_MODELS) {
@@ -165,10 +189,7 @@ function mapCliOptionsToSDK(options = {}) {
 
   // Forward all host env vars (e.g. ANTHROPIC_BASE_URL) to the subprocess.
   // Since SDK 0.2.113, options.env replaces process.env instead of overlaying it.
-  // This snapshot is also how CLI-side knobs reach the child: e.g. how long the CLI waits for
-  // still-running background agents after a turn ends is set by CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS
-  // (default 600000 ms; 0 = wait indefinitely) on this server's own environment.
-  sdkOptions.env = { ...process.env };
+  sdkOptions.env = { ...process.env, CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: String(BG_WAIT_CEILING_MS) };
 
   // Resolve the executable eagerly on Windows because the SDK uses raw child_process.spawn,
   // which does not reliably follow npm's shell wrappers like cross-spawn does.
@@ -243,13 +264,37 @@ function mapCliOptionsToSDK(options = {}) {
  * @param {string} sessionId - Session identifier
  * @param {Object} queryInstance - SDK query instance
  * @param {Object} writer - WebSocket writer for reconnect support
+ * @param {Function} releaseInput - Closes the held stdin stream so the CLI can exit
  */
-function addSession(sessionId, queryInstance, writer = null) {
+function addSession(sessionId, queryInstance, writer = null, releaseInput = null) {
+  const existing = activeSessions.get(sessionId);
+  // A different live instance under the same key means an earlier run was
+  // superseded without being stopped (e.g. an abort that raced run setup and
+  // found nothing to interrupt). Overwriting it here would strand its
+  // generator forever — this map entry is the only handle for interrupting
+  // it. Stop it directly rather than via abortClaudeSDKSession, whose
+  // session-keyed abortedSessionIds flag would be consumed by the new run
+  // and suppress its terminal `complete`.
+  const superseding = Boolean(
+    existing && existing.status === 'active' && existing.instance && existing.instance !== queryInstance
+  );
+  if (superseding) {
+    supersededInstances.add(existing.instance);
+    Promise.resolve()
+      .then(() => existing.instance.interrupt())
+      .catch((error) => {
+        console.error(`Error interrupting superseded run for session ${sessionId}:`, error?.message || error);
+      });
+    existing.releaseInput?.();
+  }
+  const carried = superseding ? null : existing;
   activeSessions.set(sessionId, {
     instance: queryInstance,
-    startTime: Date.now(),
+    startTime: carried?.startTime || Date.now(),
     status: 'active',
-    writer
+    writer,
+    // Re-registered mid-run once the provider session id lands; keep the closer.
+    releaseInput: releaseInput || carried?.releaseInput || null
   });
 }
 
@@ -366,38 +411,93 @@ function extractTokenBudget(sdkMessage) {
   };
 }
 
+// Tool calls that leave work running past the end of a turn. Bash only counts
+// when it is explicitly backgrounded; the rest defer or watch work by nature.
+const DEFERRED_WORK_TOOLS = new Set(['Monitor', 'ScheduleWakeup', 'CronCreate', 'TaskCreate']);
+
 /**
- * Builds the SDK `prompt` payload for one turn.
+ * Detects tool calls that keep working after the turn's `result` arrives.
  *
- * Plain text turns pass the string through unchanged. Turns with image
- * attachments use the SDK's streaming-input mode: a single SDKUserMessage
- * whose content carries the prompt text plus one base64 `image` block per
- * attachment (read from the global `~/.cloudcli/assets` folder).
+ * Only turns that start background work need their CLI process held open; every
+ * other turn can let it exit immediately, as it did before the hold existed.
+ *
+ * @param {Object} sdkMessage - SDK stream message
+ * @returns {boolean} True when the message launches work that outlives the turn
+ */
+function startsBackgroundWork(sdkMessage) {
+  const content = sdkMessage?.message?.content;
+  if (!Array.isArray(content)) {
+    return false;
+  }
+
+  return content.some((block) => {
+    if (block?.type !== 'tool_use') {
+      return false;
+    }
+    if (block.name === 'Bash') {
+      return block.input?.run_in_background === true;
+    }
+    return DEFERRED_WORK_TOOLS.has(block.name);
+  });
+}
+
+/**
+ * Builds the SDK user messages for one turn.
+ *
+ * Always returns SDKUserMessage records rather than a bare string: a string
+ * prompt makes the SDK flag the query as single-turn and close stdin the moment
+ * the turn's `result` arrives, which kills the CLI's background tasks. Plain
+ * text turns carry string content; turns with image attachments carry the
+ * prompt text plus one base64 `image` block per attachment (read from the
+ * global `~/.cloudcli/assets` folder).
  *
  * @param {string} command - User prompt
  * @param {Array} images - Image descriptors ({ path, name?, mimeType? })
  * @param {Array} files - Non-image attachment descriptors
  * @param {string} cwd - Project working directory attachment paths resolve against
- * @returns {Promise<string|AsyncIterable>} SDK prompt payload
+ * @returns {Promise<Array<Object>>} SDKUserMessage records for the turn
  */
-async function buildPromptPayload(command, images, files, cwd) {
+async function buildPromptMessages(command, images, files, cwd) {
   const promptWithFiles = appendFilesInputTag(command, files);
-  if (normalizeImageDescriptors(images).length === 0) {
-    return promptWithFiles;
-  }
+  const content = normalizeImageDescriptors(images).length === 0
+    ? promptWithFiles
+    : await buildClaudeUserContent(promptWithFiles, images, cwd);
+
+  return [{
+    type: 'user',
+    message: {
+      role: 'user',
+      content
+    },
+    parent_tool_use_id: null,
+    timestamp: new Date().toISOString()
+  }];
+}
 
-  const content = await buildClaudeUserContent(promptWithFiles, images, cwd);
-  return (async function* () {
-    yield {
-      type: 'user',
-      message: {
-        role: 'user',
-        content
-      },
-      parent_tool_use_id: null,
-      timestamp: new Date().toISOString()
-    };
+/**
+ * Wraps prompt messages in an async iterable that yields them and then parks.
+ *
+ * The SDK closes the CLI's stdin as soon as its input iterable is exhausted (and
+ * immediately on `result` for string prompts). The CLI reads that EOF as the end
+ * of the run and kills anything still going in the background, so the iterable
+ * has to stay pending until we actually want the process gone.
+ *
+ * @param {Array<Object>} messages - SDKUserMessage records to send
+ * @returns {{ stream: AsyncIterable, release: () => void }} Stream plus its closer
+ */
+function createHeldPromptStream(messages) {
+  let release;
+  const held = new Promise((resolve) => { release = resolve; });
+
+  const stream = (async function* () {
+    for (const message of messages) {
+      yield message;
+    }
+    // Keeps stdin open — the CLI stays alive until release() is called.
+    await held;
   })();
+
+  return { stream, release };
 }
 
 /**
@@ -486,6 +586,44 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
     });
   };
 
+  // Closes the held stdin stream so the CLI can wind down. Replaced once the
+  // stream exists; the finally block calls it no matter how the run ends.
+  let releasePromptStream = () => {};
+  let idleReleaseTimer = null;
+  // The client is told the turn is over as soon as `result` lands, even though
+  // the process lingers, so the UI never waits out the idle hold.
+  let turnCompleteSent = false;
+  // Set when a turn starts background work, cleared when the next `result`
+  // arrives — only turns with work still outstanding hold their process open.
+  let backgroundWorkPending = false;
+  // True while the process is being held open for background work, so a later
+  // `result` can be recognised as that work reporting back.
+  let heldForBackgroundWork = false;
+
+  // A new turn supersedes any earlier one still holding this session's process
+  // open, so held runs cannot stack up across a conversation.
+  if (sessionKey()) {
+    getSession(sessionKey())?.releaseInput?.();
+  }
+
+  // Arms (or re-arms) the idle countdown that eventually closes stdin.
+  const scheduleRelease = () => {
+    if (idleReleaseTimer) {
+      clearTimeout(idleReleaseTimer);
+      idleReleaseTimer = null;
+    }
+    idleReleaseTimer = setTimeout(() => {
+      idleReleaseTimer = null;
+      releasePromptStream();
+    }, BG_WAIT_CEILING_MS);
+    // Never let the hold keep the server process alive on its own.
+    idleReleaseTimer.unref?.();
+  };
+
+  // Hoisted above the try so the catch's cleanup can tell whether this run
+  // still owns the activeSessions entry (or was superseded by a newer run).
+  let queryInstance = null;
+
   try {
     const resolvedModel = await context.resolveResumeModel(sessionId, options.model);
     let effortModels = CLAUDE_PREDEFINED_MODELS;
@@ -507,10 +645,10 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
       sdkOptions.mcpServers = mcpServers;
     }
 
-    // Turns with image attachments switch to streaming input so the images
-    // ride along as real content blocks. Built per query attempt because an
-    // async generator cannot be replayed once consumed.
-    const createPrompt = () => buildPromptPayload(command, options.images, options.files, options.cwd);
+    // Every turn uses streaming input so stdin stays open past the turn's
+    // `result`. The message list is reusable, but each query attempt needs its
+    // own stream because an async generator cannot be replayed once consumed.
+    const promptMessages = await buildPromptMessages(command, options.images, options.files, options.cwd);
 
     sdkOptions.hooks = {
       Notification: [{
@@ -613,10 +751,11 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
       return { behavior: 'deny', message: decision.message ?? 'User denied tool use' };
     };
 
-    let queryInstance;
+    let heldPrompt = createHeldPromptStream(promptMessages);
+    releasePromptStream = heldPrompt.release;
     try {
       queryInstance = query({
-        prompt: await createPrompt(),
+        prompt: heldPrompt.stream,
         options: sdkOptions
       });
     } catch (hookError) {
@@ -624,15 +763,19 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
       // Keep notification behavior operational via runtime events even if hook registration fails.
       console.warn('Failed to initialize Claude query with hooks, retrying without hooks:', hookError?.message || hookError);
       delete sdkOptions.hooks;
+      // Discard the abandoned stream and build a fresh one for the retry.
+      heldPrompt.release();
+      heldPrompt = createHeldPromptStream(promptMessages);
+      releasePromptStream = heldPrompt.release;
       queryInstance = query({
-        prompt: await createPrompt(),
+        prompt: heldPrompt.stream,
         options: sdkOptions
       });
     }
 
     // Track the query instance for abort capability
     if (sessionKey()) {
-      addSession(sessionKey(), queryInstance, ws);
+      addSession(sessionKey(), queryInstance, ws, releasePromptStream);
     }
 
     // Process streaming messages
@@ -642,7 +785,7 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
       if (message.session_id && !capturedSessionId) {
 
         capturedSessionId = message.session_id;
-        addSession(sessionKey(), queryInstance, ws);
+        addSession(sessionKey(), queryInstance, ws, releasePromptStream);
 
         // Set session ID on writer
         if (ws.setSessionId && typeof ws.setSessionId === 'function') {
@@ -677,36 +820,98 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
       if (tokenBudgetData) {
         ws.send(createNormalizedMessage({ kind: 'status', text: 'token_budget', tokenBudget: tokenBudgetData, sessionId: capturedSessionId || sessionId || null, provider: 'claude' }));
       }
+
+      if (startsBackgroundWork(message)) {
+        backgroundWorkPending = true;
+      }
+
+      if (message.type === 'result') {
+        // The turn is done as far as the client is concerned.
+        const abortPending = sessionKey() ? abortedSessionIds.has(sessionKey()) : false;
+        if (!turnCompleteSent && !abortPending) {
+          turnCompleteSent = true;
+          ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 0 }));
+          notifyRunStopped({
+            userId: ws?.userId || null,
+            provider: 'claude',
+            sessionId: sessionId || capturedSessionId || null,
+            sessionName: sessionSummary,
+            stopReason: 'completed'
+          });
+        } else if (heldForBackgroundWork && !abortPending) {
+          // A result after the turn already reported complete means the work we
+          // held the process open for has finished and pushed a follow-up turn.
+          notifyBackgroundWorkCompleted({
+            userId: ws?.userId || null,
+            provider: 'claude',
+            sessionId: sessionId || capturedSessionId || null,
+            sessionName: sessionSummary
+          });
+        }
+        if (backgroundWorkPending) {
+          // Work started during this turn is still running. Hold the process
+          // open so it can finish and report back in a follow-up turn; the
+          // ceiling is only a backstop for work that never reports.
+          backgroundWorkPending = false;
+          heldForBackgroundWork = true;
+          scheduleRelease();
+        } else {
+          // Either nothing was backgrounded, or the background work just
+          // reported in — let the CLI exit now, as it always has.
+          heldForBackgroundWork = false;
+          releasePromptStream();
+        }
+      } else if (idleReleaseTimer) {
+        // Background activity after the turn — push the countdown back out.
+        scheduleRelease();
+      }
     }
 
-    // Clean up session on completion
-    if (sessionKey()) {
+    // Clean up session on completion — only while this run still owns the map
+    // entry. A superseding run may have replaced it, and deleting here would
+    // strand that run.
+    if (sessionKey() && getSession(sessionKey())?.instance === queryInstance) {
       removeSession(sessionKey());
     }
 
+    // A superseded run winds down silently: the map entry, the abort flag,
+    // and all client-facing events belong to the run that replaced it.
+    const superseded = supersededInstances.has(queryInstance);
+
     // Send the terminal completion event — skipped for aborted runs, whose
-    // terminal `complete` (aborted: true) was already sent by abort-session.
-    const wasAborted = sessionKey() ? abortedSessionIds.delete(sessionKey()) : false;
-    if (!wasAborted) {
-      ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 0 }));
+    // terminal `complete` (aborted: true) was already sent by abort-session, and
+    // for runs that already reported completion when their `result` arrived.
+    const wasAborted = !superseded && sessionKey() ? abortedSessionIds.delete(sessionKey()) : false;
+    if (!turnCompleteSent && !superseded) {
+      turnCompleteSent = true;
+      if (!wasAborted) {
+        ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 0 }));
+      }
+      notifyRunStopped({
+        userId: ws?.userId || null,
+        provider: 'claude',
+        sessionId: sessionId || capturedSessionId || null,
+        sessionName: sessionSummary,
+        stopReason: wasAborted ? 'aborted' : 'completed'
+      });
     }
-    notifyRunStopped({
-      userId: ws?.userId || null,
-      provider: 'claude',
-      sessionId: sessionId || capturedSessionId || null,
-      sessionName: sessionSummary,
-      stopReason: wasAborted ? 'aborted' : 'completed'
-    });
     // Complete
 
   } catch (error) {
     console.error('SDK query error:', error);
 
-    // Clean up session on error
-    if (sessionKey()) {
+    // Clean up session on error — only while this run still owns the map entry
+    // (a superseding run may have replaced it).
+    if (sessionKey() && getSession(sessionKey())?.instance === queryInstance) {
       removeSession(sessionKey());
     }
 
+    if (supersededInstances.has(queryInstance)) {
+      // Interrupted because a newer run took over this session id; that run
+      // owns the abort flag and all further client-facing events.
+      return;
+    }
+
     const wasAborted = sessionKey() ? abortedSessionIds.delete(sessionKey()) : false;
     if (wasAborted) {
       // The abort already produced the terminal complete; a generator throw
@@ -720,9 +925,13 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
       ? 'Claude Code is not installed. Please install it first: https://docs.anthropic.com/en/docs/claude-code'
       : error.message;
 
-    // Send error to WebSocket, then the terminal complete
+    // Send error to WebSocket, then the terminal complete. A run that already
+    // reported completion and then failed during its post-turn hold still
+    // surfaces the error, but must not emit a second terminal complete.
     ws.send(createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'claude' }));
-    ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 1 }));
+    if (!turnCompleteSent) {
+      ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 1 }));
+    }
     notifyRunFailed({
       userId: ws?.userId || null,
       provider: 'claude',
@@ -730,6 +939,14 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
       sessionName: sessionSummary,
       error
     });
+  } finally {
+    // Always close stdin — otherwise an aborted or failed run leaves the CLI
+    // process (and its MCP servers) alive until the server exits.
+    if (idleReleaseTimer) {
+      clearTimeout(idleReleaseTimer);
+      idleReleaseTimer = null;
+    }
+    releasePromptStream();
   }
 }
 
@@ -756,6 +973,10 @@ async function abortClaudeSDKSession(sessionId) {
     // Call interrupt() on the query instance
     await session.instance.interrupt();
 
+    // Release the held stdin stream; without this the CLI stays up for the rest
+    // of the post-turn hold even though the user cancelled.
+    session.releaseInput?.();
+
     // Update session status
     session.status = 'aborted';
 

package/server/modules/providers/provider.routes.ts

@@ -840,6 +840,11 @@ router.get('/search/sessions', asyncHandler(async (req: Request, res: Response)
       query,
       limit,
       signal: abortController.signal,
+      onTitleResults: (titleResults) => {
+        if (!closed) {
+          res.write(`event: title-results\ndata: ${JSON.stringify({ titleResults })}\n\n`);
+        }
+      },
       onProgress: ({ projectResult, totalMatches, scannedProjects, totalProjects }) => {
         if (closed) {
           return;

package/server/modules/providers/services/session-conversations-search.service.ts

@@ -1,4 +1,4 @@
-import fsSync, { promises as fs } from 'node:fs';
+import fsSync from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline';
 
@@ -38,6 +38,15 @@ type ProjectConversationResult = {
   sessions: SessionConversationResult[];
 };
 
+type SessionTitleSearchResult = {
+  sessionId: string;
+  provider: string;
+  projectId: string | null;
+  projectDisplayName: string;
+  sessionTitle: string;
+  lastActivity: string | null;
+};
+
 export type SessionConversationSearchProgressUpdate = {
   projectResult: ProjectConversationResult | null;
   totalMatches: number;
@@ -49,6 +58,7 @@ type SearchSessionConversationsInput = {
   query: string;
   limit: number;
   signal?: AbortSignal;
+  onTitleResults?: (results: SessionTitleSearchResult[]) => void;
   onProgress?: (update: SessionConversationSearchProgressUpdate) => void;
 };
 
@@ -156,6 +166,67 @@ function toSummaryText(customName: string | null, fallback: string | null | unde
   return trimmedFallback.length > 50 ? `${trimmedFallback.slice(0, 50)}...` : trimmedFallback;
 }
 
+/**
+ * Finds visible sessions whose displayed title contains the query. Title
+ * matches are resolved from the database before transcript scanning so the UI
+ * can always present them first, including sessions without a transcript yet.
+ */
+function findSessionTitleResults(
+  sessions: SessionRepositoryRow[],
+  query: string,
+  limit: number,
+): SessionTitleSearchResult[] {
+  const normalizedQuery = query.toLocaleLowerCase().replace(/\s+/g, ' ');
+  const projectCache = new Map<string, ReturnType<typeof projectsDb.getProjectPath>>();
+
+  return sessions
+    .flatMap((session) => {
+      const sessionTitle = toSummaryText(session.custom_name, session.session_id, session.session_id);
+      const normalizedTitle = sessionTitle.toLocaleLowerCase().replace(/\s+/g, ' ');
+      const matchIndex = normalizedTitle.indexOf(normalizedQuery);
+      if (matchIndex === -1) {
+        return [];
+      }
+
+      const projectPath = typeof session.project_path === 'string' && session.project_path.trim()
+        ? session.project_path.trim()
+        : null;
+      const projectKey = projectPath ?? UNKNOWN_PROJECT_KEY;
+      if (!projectCache.has(projectKey)) {
+        projectCache.set(
+          projectKey,
+          projectPath ? projectsDb.getProjectPath(projectPath) : null,
+        );
+      }
+
+      const project = projectCache.get(projectKey) ?? null;
+      if (project?.isArchived) {
+        return [];
+      }
+
+      return [{
+        sessionId: session.session_id,
+        provider: session.provider,
+        projectId: project?.project_id ?? null,
+        projectDisplayName: projectPath
+          ? (project?.custom_project_name?.trim() || path.basename(projectPath) || projectPath)
+          : 'Unknown Project',
+        sessionTitle,
+        lastActivity: session.updated_at || session.created_at || null,
+        matchIndex,
+      }];
+    })
+    .sort((left, right) => {
+      if (left.matchIndex !== right.matchIndex) {
+        return left.matchIndex - right.matchIndex;
+      }
+
+      return new Date(right.lastActivity ?? 0).getTime() - new Date(left.lastActivity ?? 0).getTime();
+    })
+    .slice(0, limit)
+    .map(({ matchIndex: _matchIndex, ...result }) => result);
+}
+
 function isInternalContent(content: string): boolean {
   return INTERNAL_CONTENT_PREFIXES.some((prefix) => content.startsWith(prefix));
 }
@@ -1071,28 +1142,42 @@ async function parseSessionMatches(
   return null;
 }
 
+/**
+ * Searches session titles and provider transcripts for the provider search
+ * service and its route-level integration tests.
+ */
 export async function searchConversations(
   query: string,
   limit = 50,
   onProjectResult: ((update: SessionConversationSearchProgressUpdate) => void) | null = null,
   signal: AbortSignal | null = null,
-): Promise<{ results: ProjectConversationResult[]; totalMatches: number; query: string }> {
+  onTitleResults: ((results: SessionTitleSearchResult[]) => void) | null = null,
+): Promise<{
+  results: ProjectConversationResult[];
+  titleResults: SessionTitleSearchResult[];
+  totalMatches: number;
+  query: string;
+}> {
   const safeQuery = typeof query === 'string' ? query.trim() : '';
   const safeLimit = Math.max(1, Math.min(Number.isFinite(limit) ? limit : 50, 200));
   const words = safeQuery.toLowerCase().split(/\s+/).filter((word) => word.length > 0);
 
   if (words.length === 0) {
-    return { results: [], totalMatches: 0, query: safeQuery };
+    return { results: [], titleResults: [], totalMatches: 0, query: safeQuery };
   }
 
   const isAborted = () => signal?.aborted === true;
   if (isAborted()) {
-    return { results: [], totalMatches: 0, query: safeQuery };
+    return { results: [], titleResults: [], totalMatches: 0, query: safeQuery };
   }
 
-  const searchableSessions = normalizeSearchableSessions(sessionsDb.getAllSessions());
+  const activeSessions = sessionsDb.getAllSessions();
+  const titleResults = findSessionTitleResults(activeSessions, safeQuery, safeLimit);
+  onTitleResults?.(titleResults);
+
+  const searchableSessions = normalizeSearchableSessions(activeSessions);
   if (searchableSessions.length === 0) {
-    return { results: [], totalMatches: 0, query: safeQuery };
+    return { results: [], titleResults, totalMatches: 0, query: safeQuery };
   }
 
   const sessionsByPathKey = new Map<string, SearchableSessionRow[]>();
@@ -1123,7 +1208,7 @@ export async function searchConversations(
     signal ?? undefined,
   );
   if (isAborted() || matchedFileKeys.size === 0) {
-    return { results: [], totalMatches: 0, query: safeQuery };
+    return { results: [], titleResults, totalMatches: 0, query: safeQuery };
   }
 
   const matchedSessionKeys = new Set<string>();
@@ -1207,6 +1292,7 @@ export async function searchConversations(
 
   return {
     results,
+    titleResults,
     totalMatches: runtime.totalMatches,
     query: safeQuery,
   };
@@ -1229,6 +1315,7 @@ export const sessionConversationsSearchService = {
       input.limit,
       input.onProgress ?? null,
       input.signal ?? null,
+      input.onTitleResults ?? null,
     );
   },
 };