Precompute normalized search index for sessions

Build a per-session normalized index (nameNorm/bodyNorm) once per
sessions change, then filter by includes against this index on
keystrokes. This shifts costly normalization away from the hot
path to updates, reducing per-keystroke churn for large histories.
Preserves current search semantics with a clear separator between
records to avoid odd cross-boundary matches.

Author: PeterDaveHello

src/pages/IndependentPanel/App.jsx

@@ -191,7 +191,7 @@ function App() {
   const toSafeString = (value) =>
     typeof value === 'string' ? value : value == null ? '' : String(value)
 
-  // Filter sessions based on search query (memoized for performance)
+  // Normalization utility for search
   const normalizeForSearch = (value) =>
     toSafeString(value)
       .toLowerCase()
@@ -200,34 +200,32 @@ function App() {
       .replace(/\s+/g, ' ')
       .trim()
 
-  const filteredSessions = useMemo(() => {
-    const query = normalizeForSearch(debouncedQuery).trim()
-    // Always exclude items without a valid sessionId first
-    const validSessions = Array.isArray(sessions)
-      ? sessions.filter((s) => Boolean(s?.sessionId))
-      : []
-
-    if (!query) return validSessions
-
-    return validSessions.filter((session) => {
-      // Search in session name
-      const sessionName = normalizeForSearch(session.sessionName)
-      if (sessionName.includes(query)) {
-        return true
-      }
+  // Precompute a normalized index for sessions to reduce per-keystroke work
+  const normalizedIndex = useMemo(() => {
+    if (!Array.isArray(sessions)) return []
+    const SEP = '\n—\n'
+    return sessions
+      .filter((s) => Boolean(s?.sessionId))
+      .map((s) => {
+        const nameNorm = normalizeForSearch(s.sessionName)
+        let bodyNorm = ''
+        if (Array.isArray(s.conversationRecords)) {
+          bodyNorm = s.conversationRecords
+            .map((r) => `${normalizeForSearch(r?.question)} ${normalizeForSearch(r?.answer)}`)
+            .join(SEP)
+        }
+        return { session: s, nameNorm, bodyNorm }
+      })
+  }, [sessions])
 
-      // Search in conversation records
-      if (Array.isArray(session.conversationRecords)) {
-        return session.conversationRecords.some((record) => {
-          const question = normalizeForSearch(record?.question)
-          const answer = normalizeForSearch(record?.answer)
-          return question.includes(query) || answer.includes(query)
-        })
-      }
-
-      return false
-    })
-  }, [sessions, debouncedQuery])
+  // Filter sessions based on search query using the precomputed index
+  const filteredSessions = useMemo(() => {
+    const q = normalizeForSearch(debouncedQuery).trim()
+    if (!q) return normalizedIndex.map((i) => i.session)
+    return normalizedIndex
+      .filter((i) => i.nameNorm.includes(q) || i.bodyNorm.includes(q))
+      .map((i) => i.session)
+  }, [normalizedIndex, debouncedQuery])
 
   return (
     <div className="IndependentPanel">