opencode-sesh 2.1.4 → 2.1.6

package/AGENTS.md

@@ -31,6 +31,7 @@ bun run test           # build + fixture-DB regression suite — must stay green
 bun run test:changelog # release-tooling regressions (scripts/changelog.sh)
 bun run test:picker    # PTY picker suite
 bun run test:tui-home  # real OpenTUI home layout regressions (also in bun run test)
+bun run test:tui-worker # real blob Worker + bun:sqlite regressions (also in bun run test)
 bun run typecheck      # tsc over tui-plugins/ and plugins/
 bun run lint:sh        # bash -n on every script
 HOME=/tmp/fakehome bash install.sh   # installer smoke test (never touches ~/.config)
@@ -181,10 +182,11 @@ when opencode exits, the picker reopens with the query preserved.
   scrolling inside; the picker remains the place for transcript search.
   Sessions waiting on the user (unanswered questions, stuck runs) pin a
   **Needs input** group above the directories, with the count in the heading —
-  same `NEEDS_INPUT_SQL` heuristic as `bin/sesh-waiting.sh`. The query is
-  synchronous on the TUI thread, so the shared poll runs it only while the
-  sidebar is subscribed (`poll(listener, { waiting: true })`); the home list
-  never triggers it.
+  same `NEEDS_INPUT_SQL` heuristic as `bin/sesh-waiting.sh`. The query runs in
+  a blob Worker (`createDbClient`; failure means "local store unavailable"),
+  off the TUI thread but still costing worker CPU every poll, so the shared
+  poll runs it only while the sidebar is subscribed
+  (`poll(listener, { waiting: true })`); the home list never triggers it.
 - **Picker:** a custom dialog (not `DialogSelect`) grouped by
   project/directory, recency-ordered, resume via
   `api.route.navigate("session", …)`. `option+o` and the command palette open it;
@@ -196,7 +198,10 @@ when opencode exits, the picker reopens with the query preserved.
   at `SESSION_MAX` and reported when truncated) rather than a fixed-size
   window, then indexes transcript text for **every** session in batches
   (`TRANSCRIPT_BATCH`) with bounded remote concurrency (`REMOTE_CONCURRENCY`).
-  The header shows indexing progress/coverage. Visible transcript hits get
+  Local extraction is one SQL statement per batch in the DB worker
+  (`transcriptTextQuery`, JSON-guarded) that returns only `{sid, text}` rows,
+  so tool payloads never reach the UI thread; if the worker rejects, sessions
+  not yet indexed fall back to the remote path. The header shows indexing progress/coverage. Visible transcript hits get
   short excerpts from the text-only index (never tool or reasoning payloads).
   Project, needs-input (Option-W), and pinned-session (Option-S) filters compose
   with the query; the picker remembers query/scope/filters until plugin restart.
@@ -269,6 +274,10 @@ when opencode exits, the picker reopens with the query preserved.
   and Python 3).
 - `bun run test:tui-home` — real OpenTUI render regressions for the home list
   (also run by `bun run test`).
+- `bun run test:tui-worker` — starts the real blob Worker against a bun:sqlite
+  fixture; asserts results round-trip and the main thread keeps ticking during
+  a slow query and during transcript indexing of large tool payloads (also run
+  by `bun run test`).
 - `bun run typecheck` — `tsc` over `tui-plugins/` and `plugins/`.
 - `bun run lint:sh` — `bash -n` on every script.
 - `HOME=/tmp/fakehome bash install.sh` — installer smoke test.

package/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.6] - 2026-11-02
+
+### Changed
+
+- **tui:** Extract transcript text in the DB worker (#35)
+
+## [2.1.5] - 2026-11-02
+
+### Fixed
+
+- **tui:** Run needs-input SQLite reads in a worker (#34)
+
 ## [2.1.4] - 2026-11-02
 
 ### Fixed
@@ -536,6 +548,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixture-database regression suite, TypeScript typechecking, and ShellCheck in
   CI.
 
+[2.1.6]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.5...v2.1.6
+[2.1.5]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.4...v2.1.5
 [2.1.4]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.3...v2.1.4
 [2.1.3]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.2...v2.1.3
 [2.1.2]: https://github.com/ozandogrultan/opencode-sesh/compare/v2.1.1...v2.1.2

package/dist/tui.js

@@ -636,9 +636,106 @@ async function openTranscriptDb() {
     return undefined;
   }
 }
+
+// Runs in a blob Worker so slow queries never block the TUI thread. The
+// connection opens on the first request and stays open; `loadSqlite` is
+// injected only by tests.
+const DB_WORKER_SOURCE = `
+let opening
+const load = typeof loadSqlite === "function" ? loadSqlite : () => import("bun:sqlite")
+const open = (path) => opening ??= load().then((sqlite) => new sqlite.Database(path, { readonly: true }), (error) => { opening = undefined; throw error })
+self.onmessage = async (event) => {
+  const { id, path, sql, params } = event.data
+  try {
+    const db = await open(path)
+    self.postMessage({ id, rows: db.query(sql).all(...(params ?? [])) })
+  } catch (error) {
+    self.postMessage({ id, error: String(error?.message ?? error) })
+  }
+}`;
+const DB_QUERY_TIMEOUT_MS = 30000;
+function createDbWorker() {
+  return new globalThis.Worker(URL.createObjectURL(new Blob([DB_WORKER_SOURCE], {
+    type: "text/javascript"
+  })));
+}
+
+// Read-only queries against the local store, served by one lazily started
+// worker. Any failure (no worker, no bun:sqlite, query error, timeout) rejects;
+// a timeout or worker error discards the worker so the next call starts afresh.
+function createDbClient(createWorker = createDbWorker, timeoutMs = DB_QUERY_TIMEOUT_MS) {
+  let worker;
+  let nextId = 0;
+  const pending = new Map();
+  const reset = error => {
+    const dead = worker;
+    worker = undefined;
+    try {
+      dead?.terminate();
+    } catch {}
+    const requests = [...pending.values()];
+    pending.clear();
+    for (const request of requests) {
+      clearTimeout(request.timer);
+      request.reject(error);
+    }
+  };
+  const start = () => {
+    const created = createWorker();
+    created.onmessage = event => {
+      const {
+        id,
+        rows,
+        error
+      } = event?.data ?? {};
+      const request = pending.get(id);
+      if (!request) return;
+      pending.delete(id);
+      clearTimeout(request.timer);
+      if (typeof error === "string") request.reject(new Error(error));else request.resolve(Array.isArray(rows) ? rows : []);
+    };
+    created.onerror = event => {
+      event?.preventDefault?.();
+      if (worker === created) reset(new Error(String(event?.message ?? "local store worker failed")));
+    };
+    created.unref?.();
+    return created;
+  };
+  const run = (sql, params = []) => new Promise((resolve, reject) => {
+    try {
+      worker ??= start();
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const id = ++nextId;
+    const timer = setTimeout(() => reset(new Error("local store query timed out")), timeoutMs);
+    timer.unref?.();
+    pending.set(id, {
+      resolve,
+      reject,
+      timer
+    });
+    try {
+      worker.postMessage({
+        id,
+        path: resolveDbPath(),
+        sql,
+        params
+      });
+    } catch (error) {
+      reset(error);
+    }
+  });
+  return {
+    run,
+    close: () => reset(new Error("local store closed"))
+  };
+}
+const dbClient = createDbClient();
 function createSessionPoll(api, refreshPins) {
-  // Listener -> whether it reads `snapshot.waiting`. The needs-input query is
-  // synchronous on the TUI thread, so it only runs while such a listener exists.
+  // Listener -> whether it reads `snapshot.waiting`. The needs-input query
+  // costs worker CPU on every poll, so it only runs while such a listener exists.
   const listeners = new Map();
   let snapshot = {
     entries: [],
@@ -677,20 +774,18 @@ function createSessionPoll(api, refreshPins) {
         };
       }
       if (!active()) return;
-      const db = wantsWaiting() ? await openTranscriptDb() : undefined;
-      if (db) {
+      if (wantsWaiting()) {
         try {
+          const waiting = await queryWaitingIds(dbClient.run);
           if (wantsWaiting()) {
             snapshot = {
               ...snapshot,
-              waiting: await queryWaitingIds(db)
+              waiting
             };
             waitingLoaded = true;
           }
         } catch {
           // Keep the previous waiting set when the local store is unavailable.
-        } finally {
-          db.close();
         }
       } else if (!wantsWaiting()) {
         snapshot = {
@@ -788,8 +883,8 @@ WHERE COALESCE(s.time_archived, 0) = 0
       WHERE live.session_id = s.id AND live.status = 'running' AND live.created < ${stuckBefore})
       AND ${NO_RECENT_ACTIVITY("s.id", stuckBefore)}))
 ORDER BY s.time_updated DESC`;
-async function queryWaitingIds(db) {
-  const rows = db.query(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS)).all() ?? [];
+async function queryWaitingIds(run) {
+  const rows = await run(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS));
   const out = new Map();
   for (const row of rows) {
     if (typeof row?.id === "string" && SESSION_ID_PATTERN.test(row.id) && (row.reason === "question" || row.reason === "stuck")) {
@@ -801,8 +896,8 @@ async function queryWaitingIds(db) {
 // The shared needs-input query decides *which* sessions are waiting. Read the
 // oldest still-unanswered question or stuck tool for each result so triage can
 // show how long it has waited, rather than its last (unrelated) update time.
-async function queryWaitingDetails(db) {
-  const reasons = await queryWaitingIds(db);
+async function queryWaitingDetails(run) {
+  const reasons = await queryWaitingIds(run);
   const details = new Map([...reasons].map(([id, reason]) => [id, {
     reason: reason
   }]));
@@ -810,12 +905,12 @@ async function queryWaitingDetails(db) {
   const cutoff = Date.now() - STUCK_AFTER_MS;
   for (let i = 0; i < ids.length; i += 200) {
     const batch = ids.slice(i, i + 200);
-    const rows = db.query(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
+    const rows = await run(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
 SELECT live.session_id AS id,
   MIN(CASE WHEN ${QUESTION_OPEN} THEN live.created END) AS question_since,
   MIN(CASE WHEN live.status = 'running' AND live.created < ${cutoff} THEN live.created END) AS stuck_since
 FROM live
-GROUP BY live.session_id`).all(...batch) ?? [];
+GROUP BY live.session_id`, batch);
     for (const row of rows) {
       const detail = details.get(row.id);
       if (!detail) continue;
@@ -825,29 +920,39 @@ GROUP BY live.session_id`).all(...batch) ?? [];
   }
   return details;
 }
-function addTranscript(index, sid, data) {
-  try {
-    const message = JSON.parse(data);
-    const texts = [];
-    if (typeof message?.text === "string") texts.push(message.text);
-    if (Array.isArray(message?.content)) {
-      for (const part of message.content) {
-        if (part?.type === "text" && typeof part.text === "string") texts.push(part.text);
-      }
-    }
-    for (const text of texts) {
-      const base = index.get(sid) ?? "";
-      index.set(sid, `${base} ${text}`.trim());
-    }
-  } catch {
-    // ignore malformed messages
-  }
+
+// Text parts only, extracted inside SQLite so tool and reasoning payloads never
+// reach the caller. The CASE guards keep json_extract away from malformed rows
+// and non-object parts, which SQL AND ordering alone would not.
+function transcriptTextQuery(count) {
+  const placeholders = Array.from({
+    length: count
+  }, () => "?").join(",");
+  return `WITH msg AS (
+  SELECT session_id AS sid, seq, rowid AS rid, CASE WHEN json_valid(data) THEN data END AS doc
+  FROM session_message
+  WHERE session_id IN (${placeholders}) AND type IN ('user', 'assistant')
+), parts AS (
+  SELECT sid, seq, rid, 0 AS part,
+    CASE WHEN json_type(doc, '$.text') = 'text' THEN json_extract(doc, '$.text') END AS text
+  FROM msg
+  UNION ALL
+  SELECT msg.sid, msg.seq, msg.rid, 1 + item.key AS part,
+    CASE WHEN item.type = 'object' THEN
+      CASE WHEN json_extract(item.value, '$.type') = 'text' AND json_type(item.value, '$.text') = 'text'
+        THEN json_extract(item.value, '$.text') END
+    END AS text
+  FROM msg, json_each(msg.doc, '$.content') AS item
+  WHERE json_type(msg.doc, '$.content') = 'array'
+)
+SELECT sid, text FROM parts WHERE text IS NOT NULL AND text <> '' ORDER BY sid, seq, rid, part`;
 }
 
 // Index titles/directories immediately, then add transcript text progressively
 // in batches so the render thread can breathe. Covers every entry, not a fixed
-// newest window; `onProgress` lets the picker show coverage.
-async function buildSearchIndex(api, entries, onProgress, active = () => true) {
+// newest window; `onProgress` lets the picker show coverage. Local extraction
+// runs through `run` (the worker client) and returns text only.
+async function buildSearchIndex(api, entries, onProgress, active = () => true, run = dbClient.run) {
   const index = new Map();
   for (const entry of entries) {
     index.set(entry.id, `${entry.title} ${entry.dir}`);
@@ -865,25 +970,25 @@ async function buildSearchIndex(api, entries, onProgress, active = () => true) {
   };
   report(false);
   if (!active()) return index;
-  const db = await openTranscriptDb();
-  if (db) {
-    try {
-      for (let i = 0; i < ids.length; i += TRANSCRIPT_BATCH) {
-        if (!active()) break;
-        const batch = ids.slice(i, i + TRANSCRIPT_BATCH);
-        const placeholders = batch.map(() => "?").join(",");
-        const rows = db.query(`SELECT session_id AS sid, data FROM session_message WHERE session_id IN (${placeholders}) AND type IN ('user', 'assistant') ORDER BY seq`).all(...batch) ?? [];
-        for (const row of rows) addTranscript(index, row.sid, row.data);
-        for (const id of batch) remaining.delete(id);
-        indexed += batch.length;
-        report(false);
-        await nextTick();
+  try {
+    for (let i = 0; i < ids.length; i += TRANSCRIPT_BATCH) {
+      if (!active()) break;
+      const batch = ids.slice(i, i + TRANSCRIPT_BATCH);
+      const rows = await run(transcriptTextQuery(batch.length), batch);
+      if (!active()) break;
+      const texts = new Map();
+      for (const row of rows) {
+        const list = texts.get(row.sid);
+        if (list) list.push(row.text);else texts.set(row.sid, [row.text]);
       }
-    } catch {
-      // local store unavailable mid-walk; fall back to the remote path below
-    } finally {
-      db.close();
+      for (const [sid, list] of texts) index.set(sid, [index.get(sid) ?? "", ...list].join(" ").trim());
+      for (const id of batch) remaining.delete(id);
+      indexed += batch.length;
+      report(false);
+      await nextTick();
     }
+  } catch {
+    // local store unavailable mid-walk; fall back to the remote path below
   }
   if (active() && remaining.size > 0) {
     await buildSearchIndexRemote(api, [...remaining], index, () => {
@@ -2749,21 +2854,14 @@ const tui = async api => {
     const [waitingCoverage, setWaitingCoverage] = createSignal("loading");
     let alive = true;
     void (async () => {
-      const db = await openTranscriptDb();
-      if (!db) {
-        if (alive) setWaitingCoverage("unavailable");
-        return;
-      }
       try {
-        const ids = await queryWaitingIds(db);
+        const ids = await queryWaitingIds(dbClient.run);
         if (alive) {
           setWaitingIds(new Set(ids.keys()));
           setWaitingCoverage("ready");
         }
       } catch {
         if (alive) setWaitingCoverage("unavailable");
-      } finally {
-        db.close();
       }
     })();
     const [pendingDelete, setPendingDelete] = createSignal();
@@ -3924,20 +4022,16 @@ const tui = async api => {
       const {
         entries
       } = await fetchEntries(api);
-      const db = await openTranscriptDb();
-      if (!db) {
+      let waiting;
+      try {
+        waiting = await queryWaitingDetails(dbClient.run);
+      } catch {
         api.ui.toast({
           message: "Needs-input data unavailable",
           variant: "error"
         });
         return;
       }
-      let waiting;
-      try {
-        waiting = await queryWaitingDetails(db);
-      } finally {
-        db.close();
-      }
       items = entries.filter(entry => waiting.has(entry.id)).map(entry => ({
         entry,
         reason: waiting.get(entry.id)?.reason === "question" ? "awaiting answer" : "run stuck",
@@ -4491,6 +4585,7 @@ export default Plugin.define({
       if (api.ui.dialog.open) api.ui.dialog.clear();
       disposeSlot();
       removeRootMouse?.();
+      dbClient.close();
     };
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sesh",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "description": "OpenCode session browser: search, preview, and resume every session across every project from the terminal or TUI.",
   "type": "module",
   "license": "MIT",
@@ -57,8 +57,9 @@
     "build": "node scripts/build-tui.mjs",
     "prepack": "node scripts/build-tui.mjs",
     "test": "bun run test:unit && bash tests/changelog.sh",
-    "test:unit": "node scripts/build-tui.mjs && bun run test:tui-home && bash tests/sesh.sh && bash tests/install.sh",
+    "test:unit": "node scripts/build-tui.mjs && bun run test:tui-home && bun run test:tui-worker && bash tests/sesh.sh && bash tests/install.sh",
     "test:tui-home": "bun --conditions=browser tests/tui-home.mjs",
+    "test:tui-worker": "bun tests/tui-worker.mjs",
     "test:changelog": "bash tests/changelog.sh",
     "test:picker": "python3 tests/picker.py",
     "typecheck": "tsc --noEmit",

package/tui-plugins/sesh-panel/tui.tsx

@@ -537,11 +537,96 @@ async function openTranscriptDb(): Promise<any | undefined> {
   }
 }
 
+// Runs in a blob Worker so slow queries never block the TUI thread. The
+// connection opens on the first request and stays open; `loadSqlite` is
+// injected only by tests.
+const DB_WORKER_SOURCE = `
+let opening
+const load = typeof loadSqlite === "function" ? loadSqlite : () => import("bun:sqlite")
+const open = (path) => opening ??= load().then((sqlite) => new sqlite.Database(path, { readonly: true }), (error) => { opening = undefined; throw error })
+self.onmessage = async (event) => {
+  const { id, path, sql, params } = event.data
+  try {
+    const db = await open(path)
+    self.postMessage({ id, rows: db.query(sql).all(...(params ?? [])) })
+  } catch (error) {
+    self.postMessage({ id, error: String(error?.message ?? error) })
+  }
+}`
+
+const DB_QUERY_TIMEOUT_MS = 30000
+
+type DbRun = (sql: string, params?: unknown[]) => Promise<unknown[]>
+
+function createDbWorker(): any {
+  return new (globalThis as any).Worker(URL.createObjectURL(new Blob([DB_WORKER_SOURCE], { type: "text/javascript" })))
+}
+
+// Read-only queries against the local store, served by one lazily started
+// worker. Any failure (no worker, no bun:sqlite, query error, timeout) rejects;
+// a timeout or worker error discards the worker so the next call starts afresh.
+function createDbClient(createWorker: () => any = createDbWorker, timeoutMs = DB_QUERY_TIMEOUT_MS) {
+  type Pending = { resolve: (rows: unknown[]) => void; reject: (error: Error) => void; timer: ReturnType<typeof setTimeout> }
+  let worker: any
+  let nextId = 0
+  const pending = new Map<number, Pending>()
+  const reset = (error: Error) => {
+    const dead = worker
+    worker = undefined
+    try { dead?.terminate() } catch {}
+    const requests = [...pending.values()]
+    pending.clear()
+    for (const request of requests) {
+      clearTimeout(request.timer)
+      request.reject(error)
+    }
+  }
+  const start = () => {
+    const created = createWorker()
+    created.onmessage = (event: any) => {
+      const { id, rows, error } = event?.data ?? {}
+      const request = pending.get(id)
+      if (!request) return
+      pending.delete(id)
+      clearTimeout(request.timer)
+      if (typeof error === "string") request.reject(new Error(error))
+      else request.resolve(Array.isArray(rows) ? rows : [])
+    }
+    created.onerror = (event: any) => {
+      event?.preventDefault?.()
+      if (worker === created) reset(new Error(String(event?.message ?? "local store worker failed")))
+    }
+    created.unref?.()
+    return created
+  }
+  const run: DbRun = (sql, params = []) =>
+    new Promise((resolve, reject) => {
+      try {
+        worker ??= start()
+      } catch (error) {
+        reject(error)
+        return
+      }
+      const id = ++nextId
+      const timer = setTimeout(() => reset(new Error("local store query timed out")), timeoutMs)
+      ;(timer as any).unref?.()
+      pending.set(id, { resolve, reject, timer })
+      try {
+        worker.postMessage({ id, path: resolveDbPath(), sql, params })
+      } catch (error) {
+        reset(error as Error)
+      }
+    })
+  return { run, close: () => reset(new Error("local store closed")) }
+}
+
+const dbClient = createDbClient()
+
 type SessionSnapshot = { entries: Entry[]; waiting: Map<string, string>; failed: boolean }
 
 function createSessionPoll(api: TuiPluginApi, refreshPins: () => void) {
-  // Listener -> whether it reads `snapshot.waiting`. The needs-input query is
-  // synchronous on the TUI thread, so it only runs while such a listener exists.
+  // Listener -> whether it reads `snapshot.waiting`. The needs-input query
+  // costs worker CPU on every poll, so it only runs while such a listener exists.
   const listeners = new Map<(snapshot: SessionSnapshot) => void, boolean>()
   let snapshot: SessionSnapshot = { entries: [], waiting: new Map(), failed: false }
   let clock: ReturnType<typeof setInterval> | undefined
@@ -569,17 +654,15 @@ function createSessionPoll(api: TuiPluginApi, refreshPins: () => void) {
         snapshot = { ...snapshot, failed: true }
       }
       if (!active()) return
-      const db = wantsWaiting() ? await openTranscriptDb() : undefined
-      if (db) {
+      if (wantsWaiting()) {
         try {
+          const waiting = await queryWaitingIds(dbClient.run)
           if (wantsWaiting()) {
-            snapshot = { ...snapshot, waiting: await queryWaitingIds(db) }
+            snapshot = { ...snapshot, waiting }
             waitingLoaded = true
           }
         } catch {
           // Keep the previous waiting set when the local store is unavailable.
-        } finally {
-          db.close()
         }
       } else if (!wantsWaiting()) {
         snapshot = { ...snapshot, waiting: new Map() }
@@ -674,8 +757,8 @@ WHERE COALESCE(s.time_archived, 0) = 0
       AND ${NO_RECENT_ACTIVITY("s.id", stuckBefore)}))
 ORDER BY s.time_updated DESC`
 
-async function queryWaitingIds(db: any): Promise<Map<string, string>> {
-  const rows = (db.query(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS)).all() ?? []) as {
+async function queryWaitingIds(run: DbRun): Promise<Map<string, string>> {
+  const rows = (await run(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS))) as {
     id: unknown
     reason: unknown
   }[]
@@ -697,8 +780,8 @@ type WaitingDetail = { reason: "question" | "stuck"; since?: number }
 // The shared needs-input query decides *which* sessions are waiting. Read the
 // oldest still-unanswered question or stuck tool for each result so triage can
 // show how long it has waited, rather than its last (unrelated) update time.
-async function queryWaitingDetails(db: any): Promise<Map<string, WaitingDetail>> {
-  const reasons = await queryWaitingIds(db)
+async function queryWaitingDetails(run: DbRun): Promise<Map<string, WaitingDetail>> {
+  const reasons = await queryWaitingIds(run)
   const details = new Map<string, WaitingDetail>(
     [...reasons].map(([id, reason]) => [id, { reason: reason as WaitingDetail["reason"] }]),
   )
@@ -706,12 +789,12 @@ async function queryWaitingDetails(db: any): Promise<Map<string, WaitingDetail>>
   const cutoff = Date.now() - STUCK_AFTER_MS
   for (let i = 0; i < ids.length; i += 200) {
     const batch = ids.slice(i, i + 200)
-    const rows = (db.query(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
+    const rows = (await run(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
 SELECT live.session_id AS id,
   MIN(CASE WHEN ${QUESTION_OPEN} THEN live.created END) AS question_since,
   MIN(CASE WHEN live.status = 'running' AND live.created < ${cutoff} THEN live.created END) AS stuck_since
 FROM live
-GROUP BY live.session_id`).all(...batch) ?? []) as { id: string; question_since: number | null; stuck_since: number | null }[]
+GROUP BY live.session_id`, batch)) as { id: string; question_since: number | null; stuck_since: number | null }[]
     for (const row of rows) {
       const detail = details.get(row.id)
       if (!detail) continue
@@ -722,33 +805,41 @@ GROUP BY live.session_id`).all(...batch) ?? []) as { id: string; question_since:
   return details
 }
 
-function addTranscript(index: Map<string, string>, sid: string, data: string): void {
-  try {
-    const message = JSON.parse(data) as { text?: unknown; content?: unknown }
-    const texts: string[] = []
-    if (typeof message?.text === "string") texts.push(message.text)
-    if (Array.isArray(message?.content)) {
-      for (const part of message.content as { type?: unknown; text?: unknown }[]) {
-        if (part?.type === "text" && typeof part.text === "string") texts.push(part.text)
-      }
-    }
-    for (const text of texts) {
-      const base = index.get(sid) ?? ""
-      index.set(sid, `${base} ${text}`.trim())
-    }
-  } catch {
-    // ignore malformed messages
-  }
+// Text parts only, extracted inside SQLite so tool and reasoning payloads never
+// reach the caller. The CASE guards keep json_extract away from malformed rows
+// and non-object parts, which SQL AND ordering alone would not.
+function transcriptTextQuery(count: number): string {
+  const placeholders = Array.from({ length: count }, () => "?").join(",")
+  return `WITH msg AS (
+  SELECT session_id AS sid, seq, rowid AS rid, CASE WHEN json_valid(data) THEN data END AS doc
+  FROM session_message
+  WHERE session_id IN (${placeholders}) AND type IN ('user', 'assistant')
+), parts AS (
+  SELECT sid, seq, rid, 0 AS part,
+    CASE WHEN json_type(doc, '$.text') = 'text' THEN json_extract(doc, '$.text') END AS text
+  FROM msg
+  UNION ALL
+  SELECT msg.sid, msg.seq, msg.rid, 1 + item.key AS part,
+    CASE WHEN item.type = 'object' THEN
+      CASE WHEN json_extract(item.value, '$.type') = 'text' AND json_type(item.value, '$.text') = 'text'
+        THEN json_extract(item.value, '$.text') END
+    END AS text
+  FROM msg, json_each(msg.doc, '$.content') AS item
+  WHERE json_type(msg.doc, '$.content') = 'array'
+)
+SELECT sid, text FROM parts WHERE text IS NOT NULL AND text <> '' ORDER BY sid, seq, rid, part`
 }
 
 // Index titles/directories immediately, then add transcript text progressively
 // in batches so the render thread can breathe. Covers every entry, not a fixed
-// newest window; `onProgress` lets the picker show coverage.
+// newest window; `onProgress` lets the picker show coverage. Local extraction
+// runs through `run` (the worker client) and returns text only.
 async function buildSearchIndex(
   api: TuiPluginApi,
   entries: Entry[],
   onProgress?: (progress: IndexProgress, index: Map<string, string>) => void,
   active = () => true,
+  run: DbRun = dbClient.run,
 ): Promise<Map<string, string>> {
   const index = new Map<string, string>()
   for (const entry of entries) {
@@ -762,29 +853,26 @@ async function buildSearchIndex(
   report(false)
 
   if (!active()) return index
-  const db = await openTranscriptDb()
-  if (db) {
-    try {
-      for (let i = 0; i < ids.length; i += TRANSCRIPT_BATCH) {
-        if (!active()) break
-        const batch = ids.slice(i, i + TRANSCRIPT_BATCH)
-        const placeholders = batch.map(() => "?").join(",")
-        const rows = (db
-          .query(
-            `SELECT session_id AS sid, data FROM session_message WHERE session_id IN (${placeholders}) AND type IN ('user', 'assistant') ORDER BY seq`,
-          )
-          .all(...batch) ?? []) as { sid: string; data: string }[]
-        for (const row of rows) addTranscript(index, row.sid, row.data)
-        for (const id of batch) remaining.delete(id)
-        indexed += batch.length
-        report(false)
-        await nextTick()
+  try {
+    for (let i = 0; i < ids.length; i += TRANSCRIPT_BATCH) {
+      if (!active()) break
+      const batch = ids.slice(i, i + TRANSCRIPT_BATCH)
+      const rows = (await run(transcriptTextQuery(batch.length), batch)) as { sid: string; text: string }[]
+      if (!active()) break
+      const texts = new Map<string, string[]>()
+      for (const row of rows) {
+        const list = texts.get(row.sid)
+        if (list) list.push(row.text)
+        else texts.set(row.sid, [row.text])
       }
-    } catch {
-      // local store unavailable mid-walk; fall back to the remote path below
-    } finally {
-      db.close()
+      for (const [sid, list] of texts) index.set(sid, [index.get(sid) ?? "", ...list].join(" ").trim())
+      for (const id of batch) remaining.delete(id)
+      indexed += batch.length
+      report(false)
+      await nextTick()
     }
+  } catch {
+    // local store unavailable mid-walk; fall back to the remote path below
   }
 
   if (active() && remaining.size > 0) {
@@ -2227,21 +2315,14 @@ const tui: TuiPlugin = async (api) => {
     const [waitingCoverage, setWaitingCoverage] = createSignal<"loading" | "ready" | "unavailable">("loading")
     let alive = true
     void (async () => {
-      const db = await openTranscriptDb()
-      if (!db) {
-        if (alive) setWaitingCoverage("unavailable")
-        return
-      }
       try {
-        const ids = await queryWaitingIds(db)
+        const ids = await queryWaitingIds(dbClient.run)
         if (alive) {
           setWaitingIds(new Set(ids.keys()))
           setWaitingCoverage("ready")
         }
       } catch {
         if (alive) setWaitingCoverage("unavailable")
-      } finally {
-        db.close()
       }
     })()
     const [pendingDelete, setPendingDelete] = createSignal<Entry>()
@@ -3059,16 +3140,12 @@ const tui: TuiPlugin = async (api) => {
     let items: { entry: Entry; reason: string; since?: number }[] = []
     try {
       const { entries } = await fetchEntries(api)
-      const db = await openTranscriptDb()
-      if (!db) {
-        api.ui.toast({ message: "Needs-input data unavailable", variant: "error" })
-        return
-      }
       let waiting: Map<string, WaitingDetail>
       try {
-        waiting = await queryWaitingDetails(db)
-      } finally {
-        db.close()
+        waiting = await queryWaitingDetails(dbClient.run)
+      } catch {
+        api.ui.toast({ message: "Needs-input data unavailable", variant: "error" })
+        return
       }
       items = entries
         .filter((entry) => waiting.has(entry.id))
@@ -3521,6 +3598,7 @@ export default Plugin.define({
       if (api.ui.dialog.open) api.ui.dialog.clear()
       disposeSlot()
       removeRootMouse?.()
+      dbClient.close()
     }
   },
 })