rterm-backend 3.8.2 → 3.8.4

package/bin/gybackend.cjs

@@ -258480,6 +258480,9 @@ var HistorySqliteStore_exports = {};
 __export(HistorySqliteStore_exports, {
   HistorySqliteStore: () => HistorySqliteStore
 });
+function digestFor(message) {
+  return `${message.type}\0${message.dataJson ?? ""}`;
+}
 var import_node_fs5, import_node_path8, HistorySqliteStore;
 var init_HistorySqliteStore = __esm({
   "../../packages/backend/src/services/history/HistorySqliteStore.ts"() {
@@ -258651,14 +258654,153 @@ var init_HistorySqliteStore = __esm({
           lastProfileMaxTokens: row.last_profile_max_tokens ?? void 0
         }));
       }
+      /**
+       * Every session WITH all messages.
+       *
+       * FREEZE WARNING (v3.8.4): this JSON.parses every message of every session
+       * in one synchronous burst — on this machine's 1.6 GB / multi-session store
+       * that is seconds of blocked event loop (so the UI freezes, because
+       * better-sqlite3 is synchronous and runs on the same thread).
+       *
+       * It is only acceptable for genuinely whole-store work. Callers that merely
+       * need session *lists* must use `listChatSessionSummaries()` (COUNT only, no
+       * message bodies) — see `searchChatHistoryBounded` in historySearch.ts,
+       * which replaced the old bridge call to this method.
+       */
       listChatSessions() {
         return this.listChatSessionSummaries().map((summary) => this.loadChatSession(summary.id)).filter(
           (session) => session !== null
         );
       }
+      /**
+       * Session meta WITHOUT messages.
+       *
+       * Two fixed-cost hot-path bugs this closes:
+       *
+       *  1. `ChatHistoryService.saveSession` called `loadChatSession()` purely to
+       *     learn `createdAt`. That JSON.parse'd the ENTIRE session — measured
+       *     ~117 MB / ~1.5 s of parse for a 6k-message session — and threw every
+       *     parsed message away, on every save.
+       *  2. `AgentService_v2.trySaveSessionFromCheckpoint` called `loadSession()`
+       *     for a default it never used, because `updateSessionFromMessages()`
+       *     rebuilds `session.messages` from scratch. Dropping that call outright
+       *     would have reset the session TITLE to "New Session" on every restore,
+       *     so the title is read here too.
+       */
+      getChatSessionMeta(sessionId) {
+        const row = this.db.prepare("SELECT created_at, title FROM chat_sessions WHERE id = ?").get(sessionId);
+        return row ? { createdAt: row.created_at, title: row.title } : null;
+      }
+      /** Created-at scalar only — a single indexed row, never a message parse. */
+      getChatSessionCreatedAt(sessionId) {
+        return this.getChatSessionMeta(sessionId)?.createdAt;
+      }
+      /**
+       * Existing message bodies as RAW TEXT, ordered by position, WITHOUT parsing.
+       *
+       * The raw `message_data_json` is needed for a byte-exact comparison against
+       * the newly serialized body. Deliberately NOT JSON.parse'd: the parse is the
+       * expensive half of the freeze (~1.5 s / 117 MB measured) and is unnecessary
+       * for an equality test.
+       *
+       * (An earlier revision compared only `substr(json, 1, 200)`. That was WRONG:
+       * a message whose content grows past the first 200 characters — exactly what
+       * streaming does to the last AI message — leaves the prefix untouched, so the
+       * row would be skipped and the persisted history would silently stay STALE.
+       * Full-text comparison is what makes "unchanged => skip" safe.)
+       */
+      loadSessionMessageState(sessionId) {
+        const rows = this.db.prepare(
+          `SELECT message_id, message_type, position, message_data_json
+         FROM chat_session_messages
+         WHERE session_id = ?
+         ORDER BY position ASC`
+        ).all(sessionId);
+        return rows.map((row) => ({
+          id: row.message_id,
+          type: row.message_type,
+          position: row.position,
+          jsonText: row.message_data_json ?? ""
+        }));
+      }
+      /**
+       * Incremental write: touch only the rows that actually moved.
+       *
+       * The old path ran `DELETE ALL` + `INSERT ALL` on every save, rewriting the
+       * whole session payload each time. Here, unchanged messages stay on disk
+       * untouched; messages that are genuinely absent (compaction, rollback) are
+       * removed individually.
+       */
+      applyChatSessionDelta(sessionId, desired, existingDigests, writeAll) {
+        const desiredIds = /* @__PURE__ */ new Set();
+        for (const m2 of desired) {
+          desiredIds.add(m2.id);
+        }
+        const changed = writeAll ? desired : desired.filter((m2) => existingDigests.get(m2.id) !== digestFor(m2));
+        const toRemove = [];
+        for (const id of existingDigests.keys()) {
+          if (!desiredIds.has(id)) {
+            toRemove.push(id);
+          }
+        }
+        if (changed.length === 0 && toRemove.length === 0) {
+          return;
+        }
+        const upsert = this.db.prepare(
+          `INSERT INTO chat_session_messages (
+         session_id, position, message_id, message_type, message_data_json
+       ) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(session_id, message_id) DO UPDATE SET
+         position = excluded.position,
+         message_type = excluded.message_type,
+         message_data_json = excluded.message_data_json`
+        );
+        const removeOne = this.db.prepare(
+          "DELETE FROM chat_session_messages WHERE session_id = ? AND message_id = ?"
+        );
+        this.db.transaction(() => {
+          for (const id of toRemove) {
+            removeOne.run(sessionId, id);
+          }
+          for (const m2 of changed) {
+            upsert.run(sessionId, m2.position, m2.id, m2.type, m2.dataJson);
+          }
+        })();
+      }
+      /**
+       * Full positional rewrite. Positions are `PRIMARY KEY (session_id,
+       * position)`, so an in-place UPDATE cannot express a reorder without a
+       * transient collision — the order guard in saveChatSession routes here when
+       * (and only when) the surviving ids changed relative order.
+       *
+       * Therefore this really does DELETE + INSERT rather than upsert. An
+       * `ON CONFLICT(session_id, message_id)` upsert looks like it would work but
+       * does NOT: reassigning `position` collides on the (session_id, position)
+       * PRIMARY KEY against a row that has not moved yet, and that conflict is not
+       * absorbed by an ON CONFLICT clause targeting a different key —
+       *   SqliteError: UNIQUE constraint failed:
+       *     chat_session_messages.session_id, chat_session_messages.position
+       * Clearing first (inside the same transaction) sidesteps the ordering
+       * problem entirely. This path is rare by design, so the rewrite is cheap
+       * enough, and it matches the old DELETE-ALL/INSERT-ALL semantics exactly.
+       */
+      replaceAllMessages(sessionId, desired) {
+        const removeAll = this.db.prepare(
+          "DELETE FROM chat_session_messages WHERE session_id = ?"
+        );
+        const insert = this.db.prepare(
+          `INSERT INTO chat_session_messages (
+         session_id, position, message_id, message_type, message_data_json
+       ) VALUES (?, ?, ?, ?, ?)`
+        );
+        this.db.transaction(() => {
+          removeAll.run(sessionId);
+          desired.forEach((m2, index2) => {
+            insert.run(sessionId, index2, m2.id, m2.type, m2.dataJson);
+          });
+        })();
+      }
       saveChatSession(session) {
-        const existingCreatedAt = this.db.prepare("SELECT created_at FROM chat_sessions WHERE id = ?").get(session.id);
-        const createdAt = existingCreatedAt?.created_at ?? session.createdAt;
         const upsertSession = this.db.prepare(
           `INSERT INTO chat_sessions (
          id, title, last_checkpoint_offset, last_profile_max_tokens, created_at, updated_at
@@ -258671,34 +258813,45 @@ var init_HistorySqliteStore = __esm({
          last_profile_max_tokens = excluded.last_profile_max_tokens,
          updated_at = excluded.updated_at`
         );
-        const deleteMessages = this.db.prepare(
-          "DELETE FROM chat_session_messages WHERE session_id = ?"
-        );
-        const insertMessage = this.db.prepare(
-          `INSERT INTO chat_session_messages (
-         session_id, position, message_id, message_type, message_data_json
-       ) VALUES (?, ?, ?, ?, ?)`
-        );
         this.db.transaction(() => {
           upsertSession.run({
             id: session.id,
             title: session.title,
             lastCheckpointOffset: session.lastCheckpointOffset,
             lastProfileMaxTokens: session.lastProfileMaxTokens ?? null,
-            createdAt,
+            createdAt: session.createdAt,
             updatedAt: session.updatedAt
           });
-          deleteMessages.run(session.id);
-          session.messages.forEach((message, index2) => {
-            insertMessage.run(
-              session.id,
-              index2,
-              message.id,
-              message.type,
-              JSON.stringify(message.data)
-            );
-          });
         })();
+        const desired = session.messages.map(
+          (message, index2) => ({
+            id: message.id,
+            type: message.type,
+            position: index2,
+            dataJson: JSON.stringify(message.data)
+          })
+        );
+        const existingState = this.loadSessionMessageState(session.id);
+        const existingDigests = /* @__PURE__ */ new Map();
+        for (const row of existingState) {
+          existingDigests.set(
+            row.id,
+            digestFor({ type: row.type, dataJson: row.jsonText })
+          );
+        }
+        const storedOrder = existingState.map((row) => row.id);
+        const desiredOrderOfStored = [];
+        for (const m2 of desired) {
+          if (existingDigests.has(m2.id)) {
+            desiredOrderOfStored.push(m2.id);
+          }
+        }
+        const reordered = storedOrder.length !== desiredOrderOfStored.length || storedOrder.some((id, i) => id !== desiredOrderOfStored[i]);
+        if (reordered) {
+          this.replaceAllMessages(session.id, desired);
+          return;
+        }
+        this.applyChatSessionDelta(session.id, desired, existingDigests, false);
       }
       deleteChatSessions(sessionIds) {
         const ids = Array.from(
@@ -262553,7 +262706,8 @@ __export(historySearch_exports, {
   extractMessageText: () => extractMessageText2,
   findMatches: () => findMatches,
   normalizeMessages: () => normalizeMessages,
-  searchChatHistory: () => searchChatHistory
+  searchChatHistory: () => searchChatHistory,
+  searchChatHistoryBounded: () => searchChatHistoryBounded
 });
 function extractMessageText2(data) {
   if (!data || typeof data !== "object") return "";
@@ -262615,6 +262769,39 @@ function normalizeMessages(messages) {
   if (typeof messages === "object") return Object.values(messages);
   return [];
 }
+async function searchChatHistoryBounded(loadSummaries, loadSession, query, options = {}) {
+  const trimmed = (query ?? "").trim();
+  if (!trimmed) {
+    return { query: trimmed, totalSessions: 0, totalMatches: 0, sessions: [], truncated: false };
+  }
+  const summaries = loadSummaries();
+  const results = [];
+  const yieldTick = () => new Promise((resolve2) => setTimeout(resolve2, 0));
+  for (const summary of summaries) {
+    const session = loadSession(summary.id);
+    if (session) {
+      const hit = searchChatHistory([session], trimmed, {
+        ...options,
+        // Per-session we want ALL snippets; the cap is applied per session by
+        // searchChatHistory, and truncated is recomputed globally below.
+        sessionLimit: 1
+      });
+      if (hit.sessions.length > 0) results.push(hit.sessions[0]);
+    }
+    await yieldTick();
+  }
+  results.sort((a, b) => b.matchCount - a.matchCount || b.updatedAt - a.updatedAt);
+  const sessionLimit = options.sessionLimit ?? DEFAULT_SESSION_LIMIT;
+  const totalMatches = results.reduce((sum, s) => sum + s.matchCount, 0);
+  const truncated = results.length > sessionLimit;
+  return {
+    query: trimmed,
+    totalSessions: results.length,
+    totalMatches,
+    sessions: results.slice(0, sessionLimit),
+    truncated
+  };
+}
 function searchChatHistory(sessions, query, options = {}) {
   const sessionLimit = options.sessionLimit ?? DEFAULT_SESSION_LIMIT;
   const snippetLimit = options.snippetLimit ?? DEFAULT_SNIPPET_LIMIT;
@@ -347336,19 +347523,19 @@ async function runFileMutationTool(args, context2, toolName, unavailableOperatio
   if (context2.signal?.aborted) throw new Error("AbortError");
   const resolved = resolveTerminalForTool(context2, tabIdOrName);
   if (!resolved.ok) {
-    const errorText = resolved.message;
+    const errorText2 = resolved.message;
     sendEvent(sessionId, {
       messageId,
       type: "tool_call",
       toolName,
       input: JSON.stringify(args),
-      output: errorText
+      output: errorText2
     });
-    return errorText;
+    return errorText2;
   }
   const bestMatch = resolved.terminal;
   if (!resolved.snapshot.canUseFilesystem) {
-    const errorText = bestMatch.capabilities?.supportsFilesystem !== true && resolved.snapshot.runtimeState === "ready" ? `Error: Terminal tab "${bestMatch.title || bestMatch.id}" (id=${bestMatch.id}, type=${bestMatch.type}) does not support filesystem operations.` : formatTerminalUnavailableForTool(
+    const errorText2 = bestMatch.capabilities?.supportsFilesystem !== true && resolved.snapshot.runtimeState === "ready" ? `Error: Terminal tab "${bestMatch.title || bestMatch.id}" (id=${bestMatch.id}, type=${bestMatch.type}) does not support filesystem operations.` : formatTerminalUnavailableForTool(
       resolved.snapshot,
       unavailableOperation
     );
@@ -347356,12 +347543,12 @@ async function runFileMutationTool(args, context2, toolName, unavailableOperatio
       messageId,
       type: "file_edit",
       toolName,
-      output: errorText,
+      output: errorText2,
       filePath: filePathInput,
       action: "error",
       diff: ""
     });
-    return errorText;
+    return errorText2;
   }
   let outputText = "";
   let diffText2 = "";
@@ -349537,15 +349724,15 @@ async function readCommandOutput(args, context2) {
   abortIfNeeded(context2.signal);
   const terminalResolution = resolveTerminalForTool(context2, tabIdOrName);
   if (!terminalResolution.ok) {
-    const errorText = terminalResolution.message;
+    const errorText2 = terminalResolution.message;
     sendEvent(sessionId, {
       messageId,
       type: "tool_call",
       toolName: "read_command_output",
       input: JSON.stringify(args ?? {}),
-      output: errorText
+      output: errorText2
     });
-    return errorText;
+    return errorText2;
   }
   const bestMatch = terminalResolution.terminal;
   const task2 = terminalService.getCommandTask(bestMatch.id, history_command_match_id);
@@ -349555,16 +349742,16 @@ async function readCommandOutput(args, context2) {
       const started = new Date(t.startTime).toISOString();
       return `- id: ${t.id}, status: ${t.status}, command: ${t.command}, started: ${started}`;
     }).join("\n") : "(No command history for this terminal)";
-    const errorText = `Error: history_command_match_id "${history_command_match_id}" not found in terminal "${bestMatch.title || bestMatch.id}".
+    const errorText2 = `Error: history_command_match_id "${history_command_match_id}" not found in terminal "${bestMatch.title || bestMatch.id}".
 ${history2}`;
     sendEvent(sessionId, {
       messageId,
       type: "tool_call",
       toolName: "read_command_output",
       input: JSON.stringify(args ?? {}),
-      output: errorText
+      output: errorText2
     });
-    return errorText;
+    return errorText2;
   }
   const output = task2.output || "";
   const isRunning = task2.status === "running";
@@ -349600,19 +349787,19 @@ async function writeStdin(args, context2) {
   abortIfNeeded(context2.signal);
   const terminalResolution = resolveTerminalForTool(context2, tabIdOrName);
   if (!terminalResolution.ok) {
-    const errorText = terminalResolution.message;
+    const errorText2 = terminalResolution.message;
     sendEvent(sessionId, {
       messageId,
       type: "tool_call",
       toolName: "write_stdin",
       input: JSON.stringify(sequence ?? []),
-      output: errorText
+      output: errorText2
     });
-    return errorText;
+    return errorText2;
   }
   const bestMatch = terminalResolution.terminal;
   if (!terminalResolution.snapshot.canWrite) {
-    const errorText = formatTerminalUnavailableForTool(
+    const errorText2 = formatTerminalUnavailableForTool(
       terminalResolution.snapshot,
       "send input to this terminal"
     );
@@ -349621,9 +349808,9 @@ async function writeStdin(args, context2) {
       type: "tool_call",
       toolName: "write_stdin",
       input: JSON.stringify(sequence ?? []),
-      output: errorText
+      output: errorText2
     });
-    return errorText;
+    return errorText2;
   }
   const commandText = (sequence ?? []).join("");
   const allowed = await checkCommandPolicy(commandText, "write_stdin", context2);
@@ -365917,6 +366104,9 @@ async function invokeWithRetry(fn, maxRetries = 4, delays = [1e3, 2e3, 4e3, 6e3]
       if (isAbortError3(error40)) {
         throw error40;
       }
+      if (!isRetryableError(error40)) {
+        throw error40;
+      }
       if (attempt < maxRetries - 1) {
         const delay = delays[attempt];
         console.warn(`[AgentService] Model invocation failed (Attempt ${attempt + 1}/${maxRetries}). Error: ${error40.message}. Retrying in ${delay}ms...`);
@@ -365935,8 +366125,80 @@ async function invokeWithRetry(fn, maxRetries = 4, delays = [1e3, 2e3, 4e3, 6e3]
   }
   throw lastError;
 }
+function errorText(error40) {
+  const parts = [];
+  if (typeof error40?.message === "string") parts.push(error40.message);
+  if (typeof error40?.error?.message === "string") parts.push(error40.error.message);
+  if (typeof error40?.code === "string") parts.push(error40.code);
+  if (typeof error40?.status === "number") parts.push(String(error40.status));
+  if (typeof error40?.statusCode === "number") parts.push(String(error40.statusCode));
+  if (typeof error40?.cause?.code === "string") parts.push(error40.cause.code);
+  return parts.join(" ").toLowerCase();
+}
 function isRetryableError(error40) {
-  return !isAbortError3(error40);
+  if (isAbortError3(error40)) return false;
+  const text = errorText(error40);
+  if (!text) return false;
+  const finishMatch = text.match(/finish_reason=([^.)]*)/);
+  if (finishMatch) {
+    const reasons = finishMatch[1].split(/[,\s]+/).filter(Boolean);
+    if (reasons.includes("error")) return true;
+    const deterministicReasons = /* @__PURE__ */ new Set(["length", "content_filter"]);
+    if (reasons.length > 0 && reasons.every((r) => deterministicReasons.has(r))) {
+      return false;
+    }
+  }
+  const deterministic = [
+    "empty unusable response",
+    "cannot read properties of undefined",
+    "cannot read properties of null",
+    "is not a function",
+    "bad request",
+    "invalid_request",
+    "validation",
+    "context_length",
+    "context length",
+    "maximum context",
+    "too many tokens",
+    "unsupported",
+    "malformed",
+    "unauthorized",
+    "forbidden",
+    "model_not_found",
+    "insufficient_quota",
+    "invalid api key",
+    "invalid_api_key"
+  ];
+  if (deterministic.some((needle) => text.includes(needle))) return false;
+  const transient = [
+    "econnreset",
+    "econnrefused",
+    "etimedout",
+    "esockettimedout",
+    "epipe",
+    "enotfound",
+    "eai_again",
+    "socket hang up",
+    "network",
+    "fetch failed",
+    "connection reset",
+    "connection error",
+    "premature close",
+    "timed out",
+    "timeout",
+    "terminated",
+    "502",
+    "503",
+    "504",
+    "429",
+    "rate limit",
+    "overloaded",
+    "server error",
+    "bad gateway",
+    "service unavailable",
+    "gateway timeout"
+  ];
+  return transient.some((needle) => text.includes(needle));
 }
 function extractErrorDetails(error40) {
   let details = "";
@@ -366141,6 +366403,28 @@ function getStreamedResponseModelName(response, rawChunks) {
     (candidate) => typeof candidate === "string" && candidate.trim().length > 0
   );
 }
+var KNOWN_FINISH_REASONS = [
+  "stop",
+  "length",
+  "tool_calls",
+  "content_filter",
+  "function_call",
+  "error"
+];
+function normalizeFinishReason(reason) {
+  if (typeof reason !== "string") return "";
+  const trimmed = reason.trim();
+  if (!trimmed) return "";
+  const lowered = trimmed.toLowerCase();
+  for (const known of KNOWN_FINISH_REASONS) {
+    for (let repeats = 5; repeats >= 2; repeats--) {
+      if (lowered === known.repeat(repeats)) {
+        return known;
+      }
+    }
+  }
+  return trimmed;
+}
 function isEmptyMalformedToolCallFinish(response, rawChunks) {
   if (!hasToolCallFinishReason(response, rawChunks)) return false;
   if (hasAnyToolCallPayload(response, rawChunks)) return false;
@@ -366198,7 +366482,7 @@ function extractRawResponseMetadata(rawChunk) {
 }
 function getRawFinishReason(rawChunk) {
   const choices = Array.isArray(rawChunk?.choices) ? rawChunk.choices : [];
-  return choices.map((choice) => choice?.finish_reason ?? choice?.finishReason).find((reason) => hasNonEmptyString(reason));
+  return choices.map((choice) => normalizeFinishReason(choice?.finish_reason ?? choice?.finishReason)).find((reason) => hasNonEmptyString(reason));
 }
 function getFinishReasons(response, rawChunks) {
   const candidates = [
@@ -366212,7 +366496,7 @@ function getFinishReasons(response, rawChunks) {
       ) : []
     )
   ];
-  return candidates.filter(hasNonEmptyString);
+  return candidates.map((c) => normalizeFinishReason(c)).filter(hasNonEmptyString);
 }
 function getMessageType(message) {
   const type2 = typeof message?._getType === "function" ? message._getType() : message?.type;
@@ -371635,9 +371919,11 @@ ${reminder}`;
         messages = [...messages, this.lastAbortedMessage];
         this.lastAbortedMessage = null;
       }
-      const session = this.chatHistoryService.loadSession(sessionId) || {
+      const sessionMeta = this.chatHistoryService.getSessionMeta(sessionId);
+      const session = {
         id: sessionId,
-        title: "New Session",
+        title: sessionMeta?.title || "New Session",
+        // Placeholder only — replaced by updateSessionFromMessages() below.
         messages: /* @__PURE__ */ new Map(),
         lastCheckpointOffset: 0,
         lastProfileMaxTokens: this.getEffectiveMaxTokensForSession(sessionId)
@@ -373138,7 +373424,7 @@ var ChatHistoryService = class {
     this.store = options?.store || new HistorySqliteStore();
   }
   saveSession(session) {
-    const existing = this.store.loadChatSession(session.id);
+    const createdAt = this.store.getChatSessionCreatedAt(session.id);
     const now = Date.now();
     this.store.saveChatSession({
       id: session.id,
@@ -373150,10 +373436,18 @@ var ChatHistoryService = class {
       })),
       lastCheckpointOffset: session.lastCheckpointOffset,
       lastProfileMaxTokens: session.lastProfileMaxTokens,
-      createdAt: existing?.createdAt || now,
+      createdAt: createdAt || now,
       updatedAt: now
     });
   }
+  /**
+   * Session row only (title/createdAt) — never parses stored messages.
+   * Used on the checkpoint save path, which previously paid a full session
+   * parse just to preserve the title.
+   */
+  getSessionMeta(sessionId) {
+    return this.store.getChatSessionMeta(sessionId);
+  }
   loadSession(sessionId) {
     const storedSession = this.store.loadChatSession(sessionId);
     if (!storedSession) {
@@ -374788,20 +375082,24 @@ var WebSocketGatewayAdapter = class {
       }
       case "history:search": {
         const bridge = this.options.historyBridge;
-        if (!bridge?.getAllSessions) {
+        if (!bridge?.searchBounded && !bridge?.getAllSessions) {
           throw new WebSocketRpcError(
             "METHOD_NOT_FOUND",
             "history:search is not available on this gateway (no history bridge)."
           );
         }
-        const { searchChatHistory: searchChatHistory2 } = await Promise.resolve().then(() => (init_historySearch(), historySearch_exports));
-        const sessions = await bridge.getAllSessions();
         const query = this.readStringParam(params, "query");
         const wholeWord = params?.wholeWord === true;
         const includeTitles = params?.includeTitles !== false;
         const sessionLimit = typeof params?.sessionLimit === "number" ? params.sessionLimit : void 0;
         const snippetLimit = typeof params?.snippetLimit === "number" ? params.snippetLimit : void 0;
-        return searchChatHistory2(sessions, query, { wholeWord, includeTitles, sessionLimit, snippetLimit });
+        const options = { wholeWord, includeTitles, sessionLimit, snippetLimit };
+        if (bridge.searchBounded) {
+          return await bridge.searchBounded(query, options);
+        }
+        const { searchChatHistory: searchChatHistory2 } = await Promise.resolve().then(() => (init_historySearch(), historySearch_exports));
+        const sessions = await bridge.getAllSessions();
+        return searchChatHistory2(sessions, query, options);
       }
       case "settings:listBackups": {
         const bridge = this.options.settingsBridge;
@@ -386881,6 +387179,7 @@ var HistoryStorageMigration = class {
 
 // ../../packages/backend/src/runtimes/gybackend/startGyBackend.ts
 init_HistorySqliteStore();
+init_historySearch();
 
 // ../../packages/backend/src/services/AgentSettingProfileService.ts
 var AgentSettingProfileService = class {
@@ -397894,7 +398193,18 @@ async function startGyBackend() {
               );
             }
             return agentService.getAllChatHistory() ?? [];
-          }
+          },
+          // v3.8.4 FREEZE FIX: the gateway's history:search called
+          // `getAllSessions()`, which JSON.parses EVERY message of EVERY
+          // session synchronously — seconds of blocked event loop on a large
+          // store, freezing the UI. This searches one session at a time and
+          // yields between them, so nothing blocks.
+          searchBounded: async (query, options) => searchChatHistoryBounded(
+            () => historyStore.listChatSessionSummaries(),
+            (id) => historyStore.loadChatSession(id),
+            query,
+            options ?? {}
+          )
         },
         commandPolicyBridge: {
           getLists: async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rterm-backend",
-  "version": "3.8.2",
+  "version": "3.8.4",
   "description": "AI-native terminal & agentic-AI operations platform for Forward Deployed Engineers & SREs: AIOps closed-loop remediation, AI SRE, self-healing infrastructure, runbook automation, ChatOps; executes over SSH/WinRM/serial under policy with tamper-evident audit.",
   "keywords": [
     "forward-deployed-engineer",