@bojackduy/opencode-telescope 0.1.32 → 0.1.33

package/components/result-list.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import type { TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import { Show } from "solid-js"
-import type { SearchResult } from "../search.ts"
+import type { KeywordIndexState, SearchResult } from "../search.ts"
 import { compactTime, roleColor, roleLabel, truncate } from "../ui/format.ts"
 
 export const ResultRow = (props: {
@@ -59,12 +59,19 @@ export const ResultRow = (props: {
   </box>
 )
 
-export const EmptyState = (props: { query: string; owner: string; theme: TuiThemeCurrent }) => (
+export const EmptyState = (props: { query: string; owner: string; theme: TuiThemeCurrent; keywordIndexState?: KeywordIndexState }) => (
   <box paddingLeft={1} paddingTop={1}>
-    <text fg={props.theme.textMuted}>{props.query.trim() ? `No matching ${props.owner} conversation text.` : `No recent ${props.owner} conversation text found.`}</text>
+    <text fg={props.theme.textMuted}>{emptyMessage(props.query, props.owner, props.keywordIndexState)}</text>
   </box>
 )
 
+function emptyMessage(query: string, owner: string, keywordIndexState?: KeywordIndexState) {
+  if (keywordIndexState === "indexing" || keywordIndexState === "missing" || keywordIndexState === "empty") return "Indexing conversations in background..."
+  if (keywordIndexState === "stale") return "Updating conversation index..."
+  if (keywordIndexState === "error") return "Conversation index is unavailable. Try reopening Telescope."
+  return query.trim() ? `No matching ${owner} conversation text.` : `No recent ${owner} conversation text found.`
+}
+
 export const SkeletonRow = (props: { theme: TuiThemeCurrent }) => (
   <box
     flexDirection="column"

package/index-worker.ts

@@ -0,0 +1,19 @@
+import { rebuildKeywordIndexForDbPath } from "./search"
+
+self.onmessage = (event: MessageEvent) => {
+  const msg = event.data
+  if (msg.type !== "rebuild-index") return
+
+  try {
+    self.postMessage({ type: "index-started", id: msg.id, dbPath: msg.dbPath })
+    rebuildKeywordIndexForDbPath(msg.dbPath)
+    self.postMessage({ type: "index-done", id: msg.id, dbPath: msg.dbPath })
+  } catch (err) {
+    self.postMessage({
+      type: "index-error",
+      id: msg.id,
+      dbPath: msg.dbPath,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-telescope",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "description": "OpenCode TUI plugin for fuzzy and semantic search across local conversation history, session transcripts, and AI coding chats",
   "type": "module",
   "license": "MIT",
@@ -55,6 +55,7 @@
     "telescope.tsx",
     "search.ts",
     "search-worker.ts",
+    "index-worker.ts",
     "search",
     "components",
     "ui",

package/search/queries.ts

@@ -13,19 +13,20 @@ import type {
   IndexSourceRow,
   Row,
   SemanticConfig,
+  KeywordIndexState,
+  SearchResponse,
+  VectorState,
 } from "./types.ts"
 import { rowToSearchResult, rowToVectorResult, indexSourceRowToRows, ftsQuery, expandQuery } from "./text.ts"
 import { resolveDatabasePath, searchIndexPath } from "./db-path.ts"
 import { LlamaEmbeddingClient } from "./embedding.ts"
 import { migrateSearchIndex, getMeta, setMeta, SEARCH_INDEX_VERSION, DOCUMENT_EXTRACTOR_VERSION } from "./schema.ts"
-import { hybridBlend, searchVector, setupVectorTable, configureCustomSQLite, loadVecExtension } from "./vector.ts"
+import { hybridBlend, searchVector, configureCustomSQLite, loadVecExtension, isVectorReady } from "./vector.ts"
 
 // Load custom SQLite before any Database() constructor runs,
 // otherwise Database.setCustomSQLite() fails with "SQLite already loaded"
 configureCustomSQLite()
 
-const backgroundIndexRebuilds = new Set<string>()
-const lastVectorRebuildAttempt = new Map<string, number>()
 const vecExtensionLoading = new Map<string, Promise<void>>()
 
 let _db: Database | undefined
@@ -39,33 +40,42 @@ function getDb(dbPath?: string): Database {
     _db?.close()
     _db = new Database(resolved, { readonly: true })
     _dbPath = resolved
-    tableCache.clear()
   }
   return _db
 }
 
 export function searchSessionMessages(query: string, options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }) {
+  return searchSessionMessagesWithStatus(query, options).results
+}
+
+export function searchSessionMessagesWithStatus(query: string, options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }): SearchResponse {
   const term = query.trim()
-  if (!term) return []
-  if (options?.dbPath === ":memory:") return []
+  if (!term) return searchResponse([], "ready")
+  if (options?.dbPath === ":memory:") return searchResponse([], "missing")
   const dbPath = options?.dbPath ?? resolveDatabasePath()
   const db = getDb(dbPath)
-  return searchRows(db, dbPath, term, options?.limit ?? 80, options?.directory, options?.offset, options?.role)
+  const index = openSearchIndex(dbPath)
+  const status = readKeywordIndexState(db, index, dbPath)
+  const rows = canQueryKeywordIndex(status.state) ? queryFtsRows(index, term, options?.limit ?? 80, options?.directory, options?.offset, options?.role) : []
+  return searchResponse(rows.flatMap((row) => rowToSearchResult(row, term) ?? []), status.state, getVectorState(index))
 }
 
 export function recentSessionMessages(options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }) {
+  return recentSessionMessagesWithStatus(options).results
+}
+
+export function recentSessionMessagesWithStatus(options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }): SearchResponse {
   const dbPath = options?.dbPath ?? resolveDatabasePath()
+  if (dbPath === ":memory:") return searchResponse([], "missing")
   const db = getDb(dbPath)
   const limit = options?.limit ?? 40
-  const indexed = dbPath === ":memory:" ? undefined : indexedRecentRows(db, dbPath, limit, options?.directory, options?.offset, options?.role)
-  if (indexed && !indexed.stale && indexed.rows.length > 0) return indexed.rows.flatMap((row) => rowToSearchResult(row, "") ?? [])
-
-  if (dbPath !== ":memory:") scheduleBackgroundIndexRebuild(dbPath)
-  if (!indexed) debug.log("query:recent:index-pending", { limit, offset: options?.offset ?? 0, directory: options?.directory, role: options?.role })
-
-  const sourceRows = sourceRecentRows(db, limit, options?.directory, options?.offset, options?.role)
-  if (sourceRows) return sourceRows.flatMap((row) => rowToSearchResult(row, "") ?? [])
-  return indexed?.rows.flatMap((row) => rowToSearchResult(row, "") ?? []) ?? []
+  const index = openSearchIndex(dbPath)
+  const status = readKeywordIndexState(db, index, dbPath)
+  const rows = canQueryKeywordIndex(status.state) ? queryRecentRows(index, limit, options?.directory, options?.offset, options?.role) : []
+  if (!rows.length && (status.state === "missing" || status.state === "empty" || status.state === "indexing")) {
+    debug.log("query:recent:index-pending", { state: status.state, limit, offset: options?.offset ?? 0, directory: options?.directory, role: options?.role })
+  }
+  return searchResponse(rows.flatMap((row) => rowToSearchResult(row, "") ?? []), status.state, getVectorState(index))
 }
 
 export function loadConversationAround(result: SearchResult, options?: { before?: number; after?: number; dbPath?: string }): ConversationPreviewPage {
@@ -238,77 +248,55 @@ export function loadConversationAfter(result: SearchResult, cursor: Conversation
 }
 
 export async function performSearch(query: string, options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }): Promise<SearchResult[]> {
-  if (!query.trim()) return searchSessionMessages(query, options)
+  return (await performSearchWithStatus(query, options)).results
+}
+
+export async function performSearchWithStatus(query: string, options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }): Promise<SearchResponse> {
+  if (!query.trim()) return searchSessionMessagesWithStatus(query, options)
   const config = parseSemanticConfig()
   if (!config.disableVector) {
     try {
-      return await semanticSearchSessionMessages(query, options)
+      return await semanticSearchSessionMessagesWithStatus(query, options)
     } catch {
       debug.log("query:hybrid:fallback", { message: "hybrid search failed, falling back to keyword" })
     }
   }
-  return searchSessionMessages(query, options)
+  return searchSessionMessagesWithStatus(query, options)
 }
 
 export async function semanticSearchSessionMessages(query: string, options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }): Promise<SearchResult[]> {
+  return (await semanticSearchSessionMessagesWithStatus(query, options)).results
+}
+
+export async function semanticSearchSessionMessagesWithStatus(query: string, options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }): Promise<SearchResponse> {
   const term = query.trim()
-  if (!term) return []
-  if (options?.dbPath === ":memory:") return []
+  if (!term) return searchResponse([], "ready")
+  if (options?.dbPath === ":memory:") return searchResponse([], "missing")
   const dbPath = options?.dbPath ?? resolveDatabasePath()
   const db = getDb(dbPath)
   const limit = options?.limit ?? 80
   const dir = options?.directory
   const role = options?.role
 
-  const index = ensureSearchIndex(db, dbPath)
-  if (!index) return []
-
-  const keyword = indexedTextRows(db, dbPath, limit, term, dir, options?.offset, role) ?? []
+  const index = openSearchIndex(dbPath)
+  const status = readKeywordIndexState(db, index, dbPath)
+  const keyword = canQueryKeywordIndex(status.state) ? queryFtsRows(index, term, limit, dir, options?.offset, role) : []
   const config = parseSemanticConfig()
+  let vectorState = getVectorState(index)
 
   let vector: Row[] = []
-  if (!config.disableVector) {
-    let vecState = getMeta(index, "vector_state")
-    if (vecState !== "enabled" && vecState !== "disabled" && vecState !== "stale") {
-      const indexPath = searchIndexPath(dbPath)
-      const lastAttempt = lastVectorRebuildAttempt.get(indexPath)
-      if (!lastAttempt || Date.now() - lastAttempt > 30_000) {
-        setupVectorTable(index, config, indexPath)
-        lastVectorRebuildAttempt.set(indexPath, Date.now())
-        vecState = getMeta(index, "vector_state") ?? "stale"
-      }
-    }
-    if (vecState === "stale" && getMeta(index, "embedding_dimensions")) {
+  if (!config.disableVector && isVectorReady(index)) {
       try {
         const indexPath = searchIndexPath(dbPath)
-        await vecExtensionLoading.get(indexPath)
-        const test = index.query("SELECT COUNT(*) as count FROM document_vec").get() as { count: number } | undefined
-        if (test && test.count > 0) {
-          setMeta(index, "vector_state", "enabled")
-          vecState = "enabled"
-        }
-      } catch {
-        debug.log("vector:stale:recovery-failed")
-      }
-    }
-    if (vecState === "enabled") {
-      try {
-        const indexPath = searchIndexPath(dbPath)
-        await vecExtensionLoading.get(indexPath)
-        const client = new LlamaEmbeddingClient({
-          baseUrl: config.embedBaseUrl,
-          model: config.embedModel,
-          documentPrefix: config.documentPrefix,
-          queryPrefix: config.queryPrefix,
-        })
+        await withDeadline(vecExtensionLoading.get(indexPath) ?? Promise.resolve(), 250)
         const embedTerm = expandQuery(term)
-        const embedding = await client.embedQuery(embedTerm)
+        const embedding = await withDeadline(embedQuery(config, embedTerm), 1200)
         vector = searchVector(index, embedding, limit)
         debug.log("query:vector:results", { count: vector.length, embedTerm: embedTerm !== term ? embedTerm : undefined })
       } catch (err) {
         debug.log("query:vector:error", err instanceof Error ? err.message : String(err))
+        vectorState = getVectorState(index)
       }
-    }
   }
 
   const merged = keyword.length || vector.length
@@ -332,218 +320,155 @@ export async function semanticSearchSessionMessages(query: string, options?: { l
     }
   }
 
-  return results.slice(0, limit)
+  return searchResponse(results.slice(0, limit), status.state, vectorState)
 }
 
-function searchRows(db: Database, dbPath: string, query: string, limit: number, directory?: string, offset?: number, role?: SearchRole) {
-  if (!tableExists(db, "part") || !tableExists(db, "message")) return []
-  debug.time("query:sql")
-  const rows = indexedTextRows(db, dbPath, limit, query, directory, offset, role) ?? visibleTextRows(db, limit, query, directory, offset, role)
-  debug.timeEnd("query:sql")
-  debug.time("query:map")
-  const results = rows.flatMap((row) => rowToSearchResult(row, query) ?? [])
-  debug.timeEnd("query:map")
-  return results
+function searchResponse(results: SearchResult[], keywordState: KeywordIndexState, vectorState?: VectorState): SearchResponse {
+  return {
+    results,
+    keywordState,
+    vectorState,
+    stale: keywordState === "stale",
+  }
 }
 
-function indexedTextRows(db: Database, dbPath: string, limit: number, query: string, directory?: string, offset?: number, role?: SearchRole) {
-  const match = ftsQuery(query)
-  if (!match) return []
+function canQueryKeywordIndex(state: KeywordIndexState) {
+  return state === "ready" || state === "stale"
+}
+
+function getVectorState(index: Database): VectorState {
+  const state = getMeta(index, "vector_state")
+  if (state === "enabled" || state === "disabled" || state === "unavailable" || state === "stale" || state === "indexing") return state
+  return "unavailable"
+}
+
+async function embedQuery(config: SemanticConfig, query: string) {
+  const client = new LlamaEmbeddingClient({
+    baseUrl: config.embedBaseUrl,
+    model: config.embedModel,
+    documentPrefix: config.documentPrefix,
+    queryPrefix: config.queryPrefix,
+  })
+  return client.embedQuery(query)
+}
+
+async function withDeadline<T>(promise: Promise<T>, ms: number): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined
   try {
-    const index = ensureSearchIndex(db, dbPath)
-    if (!index) return []
-    const conditions = ["document_fts MATCH ?"]
-    const params: (string | number)[] = [match]
-    if (role) {
-      conditions.push("role = ?")
-      params.push(role)
-    }
-    if (directory) {
-      conditions.push("directory = ?")
-      params.push(directory)
-    }
-    params.push(limit)
-    if (offset) params.push(offset)
-    const offsetClause = offset ? "OFFSET ?" : ""
-    debug.time("query:fts:exec")
-    const rows = index.query<Row, (string | number)[]>(`
-      SELECT id, message_id, session_id, session_title, directory, role, part_type, tool,
-             CAST(time_created AS INTEGER) AS time_created, text
-      FROM document_fts
-      WHERE ${conditions.join(" AND ")}
-      ORDER BY bm25(document_fts), CAST(time_created AS INTEGER) DESC
-      LIMIT ? ${offsetClause}
-    `).all(...params as any[])
-    debug.timeEnd("query:fts:exec")
-    return rows
-  } catch (err) {
-    debug.log("fts:fallback", err instanceof Error ? err.message : String(err))
-    return
+    return await Promise.race([
+      promise,
+      new Promise<T>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`Timed out after ${ms}ms`)), ms)
+        ;(timer as { unref?: () => void }).unref?.()
+      }),
+    ])
+  } finally {
+    if (timer) clearTimeout(timer)
   }
 }
 
-type IndexedRecentRows = {
-  rows: Row[]
-  stale: boolean
+type KeywordIndexStatus = {
+  state: KeywordIndexState
+  rowCount: number
 }
 
-function indexedRecentRows(db: Database, dbPath: string, limit: number, directory?: string, offset?: number, role?: SearchRole): IndexedRecentRows | undefined {
-  try {
-    const index = ensureSearchIndex(db, dbPath, { rebuild: false, useStale: true })
-    if (!index) {
-      debug.log("query:recent:index:missing", { dbPath })
-      return
-    }
+export function openSearchIndex(sourcePath: string) {
+  const indexPath = searchIndexPath(sourcePath)
+  if (!_indexDb || _indexDbPath !== indexPath) {
+    _indexDb?.close()
+    configureCustomSQLite()
+    _indexDb = new Database(indexPath)
+    _indexDbPath = indexPath
+    migrateSearchIndex(_indexDb)
+    vecExtensionLoading.set(indexPath, loadVecExtension(_indexDb).then(() => {}).catch(() => {}))
+  }
+  return _indexDb
+}
 
+export function readKeywordIndexState(source: Database, index: Database, sourcePath: string): KeywordIndexStatus {
+  try {
     const rowCount = index.query<{ count: number }, []>("SELECT COUNT(*) as count FROM document_index").get()?.count ?? 0
-    if (rowCount === 0) {
-      debug.log("query:recent:index:empty", { dbPath })
-      return { rows: [], stale: true }
-    }
+    const storedState = getMeta(index, "keyword_index_state")
+    if (storedState === "indexing" && rowCount === 0) return { state: "indexing", rowCount }
+    if (storedState === "error" && rowCount === 0) return { state: "error", rowCount }
+    if (rowCount === 0) return { state: "empty", rowCount }
 
-    const state = sourceState(db, dbPath)
+    const state = sourceState(source, sourcePath)
     const currentDataVersion = getMeta(index, "source_data_version")
     const currentMtimeMs = getMeta(index, "source_mtime_ms")
     const currentPath = getMeta(index, "source_path")
     const currentIndexVersion = getMeta(index, "index_version")
-    const stale = currentPath !== dbPath || currentDataVersion !== String(state.dataVersion) || currentMtimeMs !== String(state.mtimeMs) || currentIndexVersion !== SEARCH_INDEX_VERSION
-    if (stale) {
-      debug.log("query:recent:index:stale", {
-        dbPath,
-        expectedDataVersion: state.dataVersion,
-        actualDataVersion: currentDataVersion,
-      })
-      scheduleBackgroundIndexRebuild(dbPath)
-    }
-
-    const conditions: string[] = ["part_type = 'text'"]
-    const params: (string | number)[] = []
-    if (role) {
-      conditions.push("role = ?")
-      params.push(role)
-    }
-    if (directory) {
-      conditions.push("directory = ?")
-      params.push(directory)
-    }
-    params.push(limit)
-    if (offset) params.push(offset)
-
-    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
-    const offsetClause = offset ? "OFFSET ?" : ""
-    debug.time("query:recent:index:exec")
-    const rows = index.query<Row, (string | number)[]>(`
-      SELECT id, message_id, session_id, session_title, directory, role, part_type, tool,
-             CAST(time_created AS INTEGER) AS time_created, text
-      FROM document_index
-      ${where}
-      ORDER BY CAST(time_created AS INTEGER) DESC
-      LIMIT ? ${offsetClause}
-    `).all(...params as any[])
-    debug.timeEnd("query:recent:index:exec")
-    return { rows, stale }
+    const stale = currentPath !== sourcePath || currentDataVersion !== String(state.dataVersion) || currentMtimeMs !== String(state.mtimeMs) || currentIndexVersion !== SEARCH_INDEX_VERSION
+    return { state: stale ? "stale" : "ready", rowCount }
   } catch (err) {
-    debug.log("recent:index:fallback", err instanceof Error ? err.message : String(err))
-    return
+    debug.log("keyword:index:state-error", err instanceof Error ? err.message : String(err))
+    return { state: "error", rowCount: 0 }
   }
 }
 
-function sourceRecentRows(db: Database, limit: number, directory?: string, offset?: number, role?: SearchRole) {
-  try {
-    if (!tableExists(db, "part") || !tableExists(db, "message") || !tableExists(db, "session")) return []
-    debug.log("query:recent:source-fallback", { limit, offset: offset ?? 0, directory, role })
-    return visibleTextRows(db, limit, undefined, directory, offset, role)
-  } catch (err) {
-    debug.log("query:recent:source-fallback:error", err instanceof Error ? err.message : String(err))
-    return
+function queryFtsRows(index: Database, query: string, limit: number, directory?: string, offset?: number, role?: SearchRole) {
+  const match = ftsQuery(query)
+  if (!match) return []
+  const conditions = ["document_fts MATCH ?"]
+  const params: (string | number)[] = [match]
+  if (role) {
+    conditions.push("role = ?")
+    params.push(role)
   }
-}
-
-function visibleTextRows(db: Database, limit: number, query?: string, directory?: string, offset?: number, role?: SearchRole) {
-  const offsetClause = offset ? "OFFSET ?" : ""
-  const conditions: string[] = [
-    "json_extract(p.data, '$.type') = 'text'",
-    role ? "json_extract(m.data, '$.role') = ?" : "json_extract(m.data, '$.role') IN ('user', 'assistant')",
-  ]
-  const params: (string | number)[] = []
-
-  if (role) params.push(role)
-
   if (directory) {
-    conditions.push("s.directory = ?")
+    conditions.push("directory = ?")
     params.push(directory)
   }
-
-  const tokens = query ? query.trim().split(/\s+/).filter(Boolean) : []
-  for (const token of tokens) {
-    conditions.push("json_extract(p.data, '$.text') LIKE ?")
-    params.push(`%${token}%`)
-  }
-
   params.push(limit)
   if (offset) params.push(offset)
-
-  const sql = `
-    SELECT p.id, p.message_id, p.session_id, s.title AS session_title, s.directory,
-           json_extract(m.data, '$.role') AS role,
-           p.time_created,
-           json_extract(p.data, '$.text') AS text
-    FROM part p
-    JOIN message m ON m.id = p.message_id
-    JOIN session s ON s.id = p.session_id
+  const offsetClause = offset ? "OFFSET ?" : ""
+  debug.time("query:fts:exec")
+  const rows = index.query<Row, (string | number)[]>(`
+    SELECT id, message_id, session_id, session_title, directory, role, part_type, tool,
+           CAST(time_created AS INTEGER) AS time_created, text
+    FROM document_fts
     WHERE ${conditions.join(" AND ")}
-    ORDER BY p.time_created DESC
+    ORDER BY bm25(document_fts), CAST(time_created AS INTEGER) DESC
     LIMIT ? ${offsetClause}
-  `
-  debug.time("query:sql:exec")
-  const rows = db.query<Row, (string | number)[]>(sql).all(...params as any[])
-  debug.timeEnd("query:sql:exec")
+  `).all(...params as any[])
+  debug.timeEnd("query:fts:exec")
   return rows
 }
 
-function ensureSearchIndex(source: Database, sourcePath: string, options?: { rebuild?: boolean; useStale?: boolean }) {
-  const indexPath = searchIndexPath(sourcePath)
-  if (!_indexDb || _indexDbPath !== indexPath) {
-    _indexDb?.close()
-    configureCustomSQLite()
-    _indexDb = new Database(indexPath)
-    _indexDbPath = indexPath
-    migrateSearchIndex(_indexDb)
-    vecExtensionLoading.set(indexPath, loadVecExtension(_indexDb).then(() => {}).catch(() => {}))
+function queryRecentRows(index: Database, limit: number, directory?: string, offset?: number, role?: SearchRole) {
+  const conditions: string[] = ["part_type = 'text'"]
+  const params: (string | number)[] = []
+  if (role) {
+    conditions.push("role = ?")
+    params.push(role)
   }
-
-  const state = sourceState(source, sourcePath)
-  const currentDataVersion = getMeta(_indexDb, "source_data_version")
-  const currentMtimeMs = getMeta(_indexDb, "source_mtime_ms")
-  const currentPath = getMeta(_indexDb, "source_path")
-  const currentIndexVersion = getMeta(_indexDb, "index_version")
-  if (currentPath !== sourcePath || currentDataVersion !== String(state.dataVersion) || currentMtimeMs !== String(state.mtimeMs) || currentIndexVersion !== SEARCH_INDEX_VERSION) {
-    if (options?.rebuild === false) {
-      if (options?.useStale) return _indexDb
-      return
-    }
-    rebuildSearchIndex(source, _indexDb, sourcePath, state)
+  if (directory) {
+    conditions.push("directory = ?")
+    params.push(directory)
   }
-  return _indexDb
+  params.push(limit)
+  if (offset) params.push(offset)
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
+  const offsetClause = offset ? "OFFSET ?" : ""
+  debug.time("query:recent:index:exec")
+  const rows = index.query<Row, (string | number)[]>(`
+    SELECT id, message_id, session_id, session_title, directory, role, part_type, tool,
+           CAST(time_created AS INTEGER) AS time_created, text
+    FROM document_index
+    ${where}
+    ORDER BY CAST(time_created AS INTEGER) DESC
+    LIMIT ? ${offsetClause}
+  `).all(...params as any[])
+  debug.timeEnd("query:recent:index:exec")
+  return rows
 }
 
-function scheduleBackgroundIndexRebuild(dbPath: string) {
-  if (backgroundIndexRebuilds.has(dbPath)) return
-  backgroundIndexRebuilds.add(dbPath)
-  debug.log("fts:rebuild:background-scheduled", { dbPath })
-  const timer = setTimeout(() => {
-    debug.time("fts:rebuild:background")
-    try {
-      const db = getDb(dbPath)
-      ensureSearchIndex(db, dbPath)
-    } catch (err) {
-      debug.log("fts:rebuild:background:error", err instanceof Error ? err.message : String(err))
-    } finally {
-      backgroundIndexRebuilds.delete(dbPath)
-      debug.timeEnd("fts:rebuild:background")
-    }
-  }, 250)
-  ;(timer as { unref?: () => void }).unref?.()
+export function rebuildKeywordIndexForDbPath(dbPath: string) {
+  const source = getDb(dbPath)
+  const index = openSearchIndex(dbPath)
+  const state = sourceState(source, dbPath)
+  rebuildKeywordIndex(source, index, dbPath, state)
 }
 
 function sourceState(db: Database, sourcePath: string) {
@@ -556,7 +481,7 @@ function hashPartData(value: { session_id: string; message_id: string; part_id:
   return createHash("sha256").update(`${value.session_id}:${value.message_id}:${value.part_id}`).digest("hex")
 }
 
-function rebuildSearchIndex(source: Database, index: Database, sourcePath: string, state: { dataVersion: number; mtimeMs: number }) {
+export function rebuildKeywordIndex(source: Database, index: Database, sourcePath: string, state: { dataVersion: number; mtimeMs: number }) {
   debug.time("fts:rebuild")
   const rows = source.query<IndexSourceRow, []>(`
     SELECT p.id, p.message_id, p.session_id, s.title AS session_title, s.directory,
@@ -594,6 +519,7 @@ function rebuildSearchIndex(source: Database, index: Database, sourcePath: strin
   `)
   index.exec("BEGIN IMMEDIATE")
   try {
+    setMeta(index, "keyword_index_state", "indexing")
     index.exec("DELETE FROM document")
     index.exec("DELETE FROM document_fts")
     index.exec("DELETE FROM document_index")
@@ -649,6 +575,7 @@ function rebuildSearchIndex(source: Database, index: Database, sourcePath: strin
     setMeta(index, "schema_version", "2")
     setMeta(index, "extractor_version", DOCUMENT_EXTRACTOR_VERSION)
     setMeta(index, "ranking_version", "1")
+    setMeta(index, "keyword_index_state", "ready")
     setMeta(index, "embedding_base_url", config.embedBaseUrl)
     setMeta(index, "document_prefix", config.documentPrefix)
     setMeta(index, "query_prefix", config.queryPrefix)
@@ -656,6 +583,7 @@ function rebuildSearchIndex(source: Database, index: Database, sourcePath: strin
     index.exec("COMMIT")
   } catch (err) {
     index.exec("ROLLBACK")
+    setMeta(index, "keyword_index_state", "error")
     throw err
   } finally {
     debug.timeEnd("fts:rebuild")
@@ -784,14 +712,6 @@ function stringValue(value: unknown) {
   return typeof value === "string" ? value : undefined
 }
 
-const tableCache = new Map<string, boolean>()
-function tableExists(db: Database, name: string) {
-  if (tableCache.has(name)) return tableCache.get(name)!
-  const exists = Boolean(db.query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name))
-  tableCache.set(name, exists)
-  return exists
-}
-
 function countBy<T>(items: T[], key: (item: T) => string) {
   const counts: Record<string, number> = {}
   for (const item of items) counts[key(item)] = (counts[key(item)] ?? 0) + 1

package/search/schema.ts

@@ -5,6 +5,8 @@ export const DOCUMENT_EXTRACTOR_VERSION = "1"
 
 export function migrateSearchIndex(db: Database) {
   db.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA busy_timeout = 1000;
     CREATE TABLE IF NOT EXISTS index_meta(
       key TEXT PRIMARY KEY,
       value TEXT NOT NULL

package/search/types.ts

@@ -70,7 +70,16 @@ export type SemanticConfig = {
   queryPrefix: string
 }
 
-export type VectorState = "enabled" | "disabled" | "unavailable" | "stale"
+export type KeywordIndexState = "ready" | "stale" | "missing" | "empty" | "indexing" | "error"
+
+export type VectorState = "enabled" | "disabled" | "unavailable" | "stale" | "indexing"
+
+export type SearchResponse = {
+  results: SearchResult[]
+  keywordState: KeywordIndexState
+  vectorState?: VectorState
+  stale: boolean
+}
 
 export type ScoredRow = Row & {
   score: number

package/search/vector.ts

@@ -68,6 +68,17 @@ export function searchVector(index: Database, embedding: Float32Array, limit: nu
   `).all(embedding, k)
 }
 
+export function isVectorReady(index: Database) {
+  if (getMeta(index, "vector_state") !== "enabled") return false
+  if (!getMeta(index, "embedding_dimensions")) return false
+  try {
+    index.query("SELECT 1 FROM document_vec LIMIT 1").get()
+    return true
+  } catch {
+    return false
+  }
+}
+
 const vectorRebuilds = new Map<string, Promise<void>>()
 
 export function setupVectorTable(index: Database, config: SemanticConfig, indexPath: string): void {

package/search-worker.ts

@@ -1,4 +1,4 @@
-import { performSearch, recentSessionMessages } from "./search"
+import { performSearchWithStatus, recentSessionMessagesWithStatus } from "./search"
 
 let activeId = -1
 
@@ -7,15 +7,15 @@ self.onmessage = async (event: MessageEvent) => {
   if (msg.type === "search" || msg.type === "recent") {
     activeId = msg.id
     try {
-      const batch = msg.type === "search"
-        ? await performSearch(msg.query, {
+      const response = msg.type === "search"
+        ? await performSearchWithStatus(msg.query, {
             limit: msg.limit,
             offset: msg.offset ?? 0,
             dbPath: msg.dbPath,
             directory: msg.directory,
             role: msg.role,
           })
-        : recentSessionMessages({
+        : recentSessionMessagesWithStatus({
             limit: msg.limit,
             offset: msg.offset ?? 0,
             dbPath: msg.dbPath,
@@ -23,7 +23,7 @@ self.onmessage = async (event: MessageEvent) => {
             role: msg.role,
           })
       if (msg.id === activeId) {
-        self.postMessage({ type: "search-result", id: msg.id, result: batch, limit: msg.limit })
+        self.postMessage({ type: "search-result", id: msg.id, result: response.results, limit: msg.limit, keywordState: response.keywordState, vectorState: response.vectorState, stale: response.stale })
       }
     } catch (err) {
       if (msg.id === activeId) {

package/search.ts

@@ -7,7 +7,9 @@ export type {
   ConversationPreviewCursor,
   ToolState,
   SemanticConfig,
+  KeywordIndexState,
   VectorState,
+  SearchResponse,
   DocumentRow,
   ScoredRow,
   HybridSearchOptions,
@@ -16,13 +18,21 @@ export type {
 // Re-exported query functions
 export {
   searchSessionMessages,
+  searchSessionMessagesWithStatus,
   recentSessionMessages,
+  recentSessionMessagesWithStatus,
   loadConversationAround,
   loadConversationBefore,
   loadConversationAfter,
   performSearch,
+  performSearchWithStatus,
   semanticSearchSessionMessages,
+  semanticSearchSessionMessagesWithStatus,
   parseSemanticConfig,
+  openSearchIndex,
+  readKeywordIndexState,
+  rebuildKeywordIndex,
+  rebuildKeywordIndexForDbPath,
 } from "./search/queries.ts"
 
 // Re-exported text/snippet functions

package/telescope.tsx

@@ -12,11 +12,15 @@ import {
   parseSemanticConfig,
   performSearch,
   recentSessionMessages,
+  recentSessionMessagesWithStatus,
   resolveDatabasePath,
   searchSessionMessages,
+  searchSessionMessagesWithStatus,
   type ConversationPreviewPart,
+  type KeywordIndexState,
   type SearchResult,
   type SearchRole,
+  type VectorState,
 } from "./search.ts"
 import { debug } from "./ui/debug.ts"
 import { syntaxStyle } from "./ui/format.ts"
@@ -38,6 +42,8 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
   const [busy, setBusy] = createSignal(false)
   const [error, setError] = createSignal("")
   const [searchMode, setSearchMode] = createSignal<"keyword" | "hybrid">("keyword")
+  const [keywordIndexState, setKeywordIndexState] = createSignal<KeywordIndexState>("missing")
+  const [vectorState, setVectorState] = createSignal<VectorState | undefined>()
   const [mode, setMode] = createSignal<"normal" | "insert">("normal")
   const [loading, setLoading] = createSignal(true)
   const [hasMore, setHasMore] = createSignal(true)
@@ -102,6 +108,9 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
   let searchRequestId = 0
   let fallbackSearchRequestId: number | undefined
   let searchWorker: Worker | undefined
+  let indexWorker: Worker | undefined
+  let indexJobId = 0
+  const activeIndexJobs = new Set<string>()
   const SEARCH_DEBOUNCE_MS = 200
   const SEARCH_WORKER_TIMEOUT_MS = 3000
   type SearchRequest = {
@@ -184,6 +193,17 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
     setLoading(false)
     debug.timeEnd("query:search")
   }
+  const settleSearchAsIndexing = (request: SearchRequest, reason: string) => {
+    if (request.id !== searchRequestId) return
+    clearSearchWatchdog()
+    pendingSearchRequest = undefined
+    debug.log("bootstrap:search:indexing", { reason, query: request.q || "(all recent)", limit: request.limit })
+    setKeywordIndexState("indexing")
+    requestIndexRebuild(request.db, "stale")
+    setBusy(false)
+    setLoading(false)
+    debug.timeEnd("query:search")
+  }
   const runSearchFallback = async (request: SearchRequest, reason: string) => {
     if (request.id !== searchRequestId) return
     if (fallbackSearchRequestId === request.id) return
@@ -191,14 +211,67 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
     clearSearchWatchdog()
     debug.log("bootstrap:search:fallback", { reason, query: request.q || "(all recent)", limit: request.limit })
     try {
-      const batch = request.q
-        ? searchSessionMessages(request.q, { limit: request.limit, offset: 0, dbPath: request.db, directory: request.dir, role: request.role })
-        : recentSessionMessages({ limit: request.limit, offset: 0, dbPath: request.db, directory: request.dir, role: request.role })
-      commitSearchBatch(request, batch, `fallback:${reason}`)
+      const response = request.q
+        ? searchSessionMessagesWithStatus(request.q, { limit: request.limit, offset: 0, dbPath: request.db, directory: request.dir, role: request.role })
+        : recentSessionMessagesWithStatus({ limit: request.limit, offset: 0, dbPath: request.db, directory: request.dir, role: request.role })
+      setKeywordIndexState(response.keywordState)
+      setVectorState(response.vectorState)
+      requestIndexRebuild(request.db, response.keywordState)
+      commitSearchBatch(request, response.results, `fallback:${reason}`)
     } catch (err) {
       failSearch(request, err instanceof Error ? err.message : String(err))
     }
   }
+  const shouldRebuildIndex = (state: KeywordIndexState) => state === "missing" || state === "empty" || state === "stale" || state === "error"
+  const ensureIndexWorker = () => {
+    if (indexWorker) return true
+    try {
+      indexWorker = new Worker(new URL("./index-worker.ts", import.meta.url))
+      indexWorker.onmessage = (event: MessageEvent) => {
+        const msg = event.data
+        if (msg.type === "index-started") {
+          debug.log("index-worker:started", { dbPath: msg.dbPath })
+          setKeywordIndexState("indexing")
+          return
+        }
+        if (msg.type === "index-done") {
+          debug.log("index-worker:done", { dbPath: msg.dbPath })
+          activeIndexJobs.delete(msg.dbPath)
+          setKeywordIndexState("ready")
+          if (msg.dbPath === dbPath()) {
+            lastFiredSearchKey = ""
+            scheduleSearch(query().trim(), ownerRole(), dbPath(), directory)
+          }
+          return
+        }
+        if (msg.type === "index-error") {
+          debug.log("index-worker:error", { dbPath: msg.dbPath, error: msg.error })
+          activeIndexJobs.delete(msg.dbPath)
+          setKeywordIndexState("error")
+        }
+      }
+      indexWorker.onerror = (err) => {
+        debug.log("index-worker:error", err.message)
+        activeIndexJobs.clear()
+        setKeywordIndexState("error")
+        indexWorker?.terminate()
+        indexWorker = undefined
+      }
+      return true
+    } catch (err) {
+      debug.log("index-worker:create-error", err instanceof Error ? err.message : String(err))
+      setKeywordIndexState("error")
+      return false
+    }
+  }
+  const requestIndexRebuild = (db: string, state: KeywordIndexState) => {
+    if (!shouldRebuildIndex(state)) return
+    if (activeIndexJobs.has(db)) return
+    if (!ensureIndexWorker()) return
+    activeIndexJobs.add(db)
+    setKeywordIndexState("indexing")
+    indexWorker!.postMessage({ type: "rebuild-index", id: ++indexJobId, dbPath: db })
+  }
   const ensureSearchWorker = () => {
     if (searchWorker) return true
     try {
@@ -209,6 +282,9 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
           if (msg.id !== searchRequestId) return
           const request = pendingSearchRequest
           if (!request || request.id !== msg.id) return
+          setKeywordIndexState(msg.keywordState ?? "ready")
+          setVectorState(msg.vectorState)
+          requestIndexRebuild(request.db, msg.keywordState ?? "ready")
           commitSearchBatch(request, msg.result, "worker")
         }
         if (msg.type === "error") {
@@ -239,6 +315,9 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
     cancelPreviewPrefetch()
     searchWorker?.terminate()
     searchWorker = undefined
+    indexWorker?.terminate()
+    indexWorker = undefined
+    activeIndexJobs.clear()
   })
 
   const resultRowHeight = createMemo(() => leftWidth() >= 48 ? 3 : 4)
@@ -345,7 +424,7 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
       debug.log("worker:timeout", { id: request.id, ms: SEARCH_WORKER_TIMEOUT_MS })
       searchWorker?.terminate()
       searchWorker = undefined
-      failSearch(request, "Search worker timed out. The conversation index may still be building; try again shortly.")
+      settleSearchAsIndexing(request, "worker-timeout")
     }, SEARCH_WORKER_TIMEOUT_MS)
     ;(searchWatchdogTimer as { unref?: () => void }).unref?.()
     searchWorker!.postMessage(msg)
@@ -1371,7 +1450,7 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
                     }
                   >
                     <Show when={!loading()}>
-                      <Show when={results().length > 0} fallback={<EmptyState query={query()} owner={ownerLabel()} theme={theme()} />}>
+                      <Show when={results().length > 0} fallback={<EmptyState query={query()} owner={ownerLabel()} theme={theme()} keywordIndexState={keywordIndexState()} />}>
                         <box height={resultTopSpacerHeight()} flexShrink={0} />
                         <For each={resultRenderWindow().items}>
                           {(item, index) => {