opencode-sesh 0.1.4 → 0.1.6

package/AGENTS.md

@@ -50,9 +50,12 @@ the schema below. Keystrokes never touch the database:
 
 - `--refresh` (expensive): bulk-reads session metadata and per-session text
   parts, validates the persistent extraction cache
-  (`$SESH_CACHE_DIR/extractions/<ses_*.json>`) against `time_updated` + part
-  count, re-extracts only changed sessions, prunes vanished ones, and atomically
-  publishes `STATE_DIR/snapshot.jsonl` with `status = fresh`. Scope
+  (`$SESH_CACHE_DIR/extractions/<ses_*.json>`, schema 2) against `time_updated`,
+  part count and the latest part timestamp, re-extracts only changed sessions,
+  prunes vanished ones, and atomically publishes `STATE_DIR/snapshot.jsonl`.
+  Extraction moves transcripts through files, never argv (no ARG_MAX limit); if
+  any session fails, the published status is `stale` and that session stays
+  uncached so the next refresh retries, otherwise `status = fresh`. Scope
   (`--cwd`/toggle) and `--limit` apply at assembly, so metadata always covers
   the whole DB and pruning is always safe.
 - render (cheap, pure `jq`): reads the snapshot only. Filters on `searchText`
@@ -78,7 +81,7 @@ Resume happens in place (`exec` after `cd` to the session's cwd).
 - **Text parts only** in search/preview; reasoning and tool payloads are
   excluded (asserted in tests).
 - Validate session ids (`^ses_[A-Za-z0-9]+$`) before SQL interpolation — never
-  interpolate unvalidated input.
+  interpolate unvalidated input. Open SQLite read-only (`sqlite3 -readonly`).
 - Prefer direct `sqlite3` over `opencode db` (startup latency). Never parse
   `sqlite3 -json` in `-R` mode; it pretty-prints — parse as JSON.
 - `jq -R` output stays JSON-quoted: use `-Rr` when a shell variable needs the
@@ -105,6 +108,11 @@ Resume happens in place (`exec` after `cd` to the session's cwd).
   `api.route.navigate("session", …)`. `ctrl+o` and the command palette open it;
   Ctrl-X deletes via the opencode CLI and removes the row only after the server
   confirms the deletion.
+- **Picker search:** pages the global session list (`SESSION_PAGE_LIMIT`, capped
+  at `SESSION_MAX` and reported when truncated) instead of a fixed 500-row
+  window, then indexes transcript text for **every** session in batches
+  (`TRANSCRIPT_BATCH`) with bounded remote concurrency (`REMOTE_CONCURRENCY`).
+  The header shows indexing progress/coverage. `tests/tui.mjs` locks this.
 
 ### Hard-won rules — do not regress
 

package/CHANGELOG.md

@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.6] - 2026-09-13
+
+### Changed
+
+- The TUI picker pages through the entire global session list instead of a
+  fixed 500-session window, indexes transcript text for every session (not just
+  the newest 150) in batches, bounds remote transcript fetching, and shows
+  indexing progress/coverage in the search header.
+- Transcript extraction reads parts in batches and assembles all records in a
+  single `jq` pass. A 250-session cold index dropped from about 28 s to about
+  7 s locally (warm ~0.3 s).
+
+### Added
+
+- TUI data-layer contract tests (pagination, full index coverage, bounded
+  concurrency, progress, and the truncated cap), run on Node 24 in CI.
+
+## [0.1.5] - 2026-09-13
+
+### Fixed
+
+- Transcript indexing no longer puts the whole conversation on the command line,
+  so large sessions (over a megabyte of text) are indexed instead of silently
+  dropped. A failed extraction now reports the snapshot as `stale` and retries
+  on the next refresh rather than certifying an incomplete index as fresh.
+- Transcript preview renders text parts even when newer tool parts outnumber
+  them, and a long message no longer blanks the preview when the output pipe
+  closes early.
+- Warm extraction caches are invalidated on any part change (text or timestamp),
+  not only when the session timestamp or part count moves.
+- The installer refuses to replace a symlinked `sesh` launcher that is not a
+  sesh install, and uninstall leaves foreign launcher symlinks untouched.
+
+### Security
+
+- Session ids are validated with the anchored `^ses_[A-Za-z0-9]+$` pattern at
+  the preview and deletion boundaries before any SQL, and the local SQLite store
+  is opened read-only.
+
+### Added
+
+- Regression coverage for large transcripts, part-only cache invalidation,
+  preview text/tool ordering and long previews, malformed session ids, empty
+  stores, and installer launcher ownership.
+
 ## [0.1.4] - 2026-09-13
 
 ### Fixed
@@ -74,7 +119,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixture-database regression suite, TypeScript typechecking, and ShellCheck in
   CI.
 
-[Unreleased]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.4...HEAD
+[Unreleased]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.6...HEAD
+[0.1.6]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.4...v0.1.5
 [0.1.4]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.1...v0.1.2

package/README.md

@@ -137,6 +137,11 @@ read -r id cwd < <(sesh --print --query "auth")
 Click the sidebar's `search…` box to filter recent sessions in place; click
 elsewhere or press Esc to leave search.
 
+The full picker pages through your whole global session list (no fixed window)
+and indexes transcript text for every session in the background, showing
+indexing progress under the search box. It only stops at a safety cap of 5,000
+sessions, and says so when it does.
+
 ## Configuration
 
 All variables are optional.

package/bin/sesh-delete.sh

@@ -37,7 +37,7 @@ acquire_lock() {
 # fzf passes an empty second field for headers and notices. They are never
 # actions, and should not surface a misleading failure prompt.
 [ -n "$session_id" ] || exit 0
-case "$session_id" in ses_[A-Za-z0-9]*) ;; *) echo "Invalid session identity."; pause; exit 0;; esac
+[[ "$session_id" =~ ^ses_[A-Za-z0-9]+$ ]] || { echo "Invalid session identity."; pause; exit 0; }
 [ -n "$state_dir" ] && [ -f "$snapshot" ] || { echo "No session snapshot available."; pause; exit 0; }
 
 # Serialize this action with the sole snapshot publisher. A short collision

package/bin/sesh-list.sh

@@ -95,7 +95,9 @@ fi
 # would make every preview keystroke laggy.
 db_json() {
   if [ -n "$SQLITE_BIN" ]; then
-    "$SQLITE_BIN" -json "$DB_PATH" "$1"
+    # Read-only: sesh never writes the store directly (deletes go through
+    # `opencode session delete`).
+    "$SQLITE_BIN" -json -readonly "$DB_PATH" "$1"
   else
     "$OPENCODE_BIN" db "$1" --format json
   fi
@@ -243,11 +245,11 @@ refresh() {
     | ($parts[0] | map({key:.session_id, value:.}) | from_entries) as $stats
     | [$sessions[0][] | . + {partCount: ($stats[.id].n // 0), partMax: ($stats[.id].m // 0)}] as $meta
     | ($meta | map({key:.id, value:.}) | from_entries) as $byId
-    | [$caches[0][]? | select(.cacheSchema == 1 and (.sessionId | type) == "string")
-       | select($byId[.sessionId] as $m | $m != null and .cacheUpdated == $m.time_updated and .cacheParts == $m.partCount)] as $cached
-    | ($cached | map({key:.sessionId, value:true}) | from_entries) as $cachedIds
+    | [$caches[0][]? | select(.cacheSchema == 2 and (.sessionId | type) == "string")
+       | select($byId[.sessionId] as $m | $m != null and .cacheUpdated == $m.time_updated and .cacheParts == $m.partCount and .cacheMax == $m.partMax)] as $cached
+    | ($cached | map({key: .sessionId, value:true}) | from_entries) as $cachedIds
     | {cached: $cached,
-       stale: [$meta[] | select($cachedIds[.id] != true) | {id, directory, title, time_created, time_updated, archived, partCount}],
+       stale: [$meta[] | select($cachedIds[.id] != true) | {id, directory, title, time_created, time_updated, archived, partCount, partMax}],
        prune: [$caches[0][]? | select(.sessionId? as $s | $byId[$s] == null) | .cachePath],
        meta: $meta}
   ' "$cache_records" > "$cache_state" || {
@@ -258,45 +260,77 @@ refresh() {
   "$JQ_BIN" -c '.stale[]?' "$cache_state" > "$needs_extract"
   while IFS= read -r cache; do [ -n "$cache" ] && rm -f "$cache"; done < <("$JQ_BIN" -r '.prune[]?' "$cache_state")
 
-  local sid dir title created updated archived partCount text fulltext record cache
+  local stale_ids=() sid chunk j i
   while IFS= read -r row; do
     [ -n "$row" ] || continue
     sid=$(printf '%s' "$row" | "$JQ_BIN" -r '.id')
     valid_session_id "$sid" || continue
-    dir=$(printf '%s' "$row" | "$JQ_BIN" -r '.directory // ""')
-    title=$(printf '%s' "$row" | "$JQ_BIN" -r '.title // ""')
-    created=$(printf '%s' "$row" | "$JQ_BIN" -r '.time_created // 0')
-    updated=$(printf '%s' "$row" | "$JQ_BIN" -r '.time_updated // 0')
-    partCount=$(printf '%s' "$row" | "$JQ_BIN" -r '.partCount // 0')
-    cache="$EXTRACTIONS/$sid.json"
-    # Text parts only: reasoning blobs and tool payloads would bloat the
-    # search index without helping anyone find a session.
-    text=$(db_json "SELECT data FROM part WHERE session_id = '$sid' AND json_extract(data, '\$.type') = 'text' ORDER BY time_created;" 2>/dev/null \
-      | "$JQ_BIN" -r '[.[]? | (.data? // empty) | (try fromjson catch empty) | select(type == "object" and .type == "text") | .text // empty] | join(" ")' 2>/dev/null) || text=''
-    fulltext=$(printf '%s' "$title $text" | "$JQ_BIN" -Rrs 'ascii_downcase' 2>/dev/null) || fulltext=''
-    if [ -z "$title" ]; then
-      title=$(printf '%s' "$text" | "$JQ_BIN" -Rrs 'gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end | select(length > 0) // "(untitled)"' 2>/dev/null) || title='(untitled)'
-      [ -n "$title" ] || title='(untitled)'
+    stale_ids+=("$sid")
+  done < "$needs_extract"
+
+  # Batch the transcript read: one SQL query per chunk of sessions and a single
+  # jq pass to assemble every record, instead of a query plus three jq processes
+  # per session. Text still travels through files, never argv. Any failure leaves
+  # every stale session uncached, so the next refresh retries them.
+  local extract_failed=0 parts_raw="$scratch/parts.jsonl" records="$scratch/records.jsonl"
+  : > "$parts_raw"
+  j=0
+  while [ "$j" -lt "${#stale_ids[@]}" ]; do
+    chunk=''
+    for ((i = j; i < j + 200 && i < ${#stale_ids[@]}; i++)); do
+      chunk="${chunk:+$chunk,}'${stale_ids[$i]}'"
+    done
+    if ! db_json "SELECT session_id, data FROM part WHERE session_id IN ($chunk) AND json_extract(data, '\$.type') = 'text' ORDER BY session_id, time_created;" 2>/dev/null \
+      | "$JQ_BIN" -c '.[]?' >> "$parts_raw"; then
+      extract_failed=1
+      break
     fi
-    record=$("$JQ_BIN" -cn --arg sid "$sid" --arg cwd "$dir" --arg title "$title" \
-      --argjson created "$created" --argjson updated "$updated" --argjson parts "$partCount" --arg fulltext "$fulltext" '
-      {cacheSchema: 1, cacheSession: $sid, cacheUpdated: $updated, cacheParts: $parts,
-       sessionId: $sid, transcriptPath: "", source: "opencode",
-       cwd: $cwd, title: ($title | gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end),
-       updatedEpoch: (($updated / 1000 | floor) | if . > 0 then . else ($created / 1000 | floor) end),
-       fulltextLower: $fulltext}') || record=''
-    if [ -n "$record" ]; then
+    j=$((j + 200))
+  done
+
+  if [ "$extract_failed" = 0 ]; then
+    "$JQ_BIN" -cnr --arg extractions "$EXTRACTIONS" --slurpfile stale "$needs_extract" --slurpfile parts "$parts_raw" '
+      ($parts
+       | map({sid: .session_id,
+              text: ((.data | try fromjson catch null)
+                     | if type == "object" and .type == "text" and (.text | type) == "string" then .text else empty end)})
+       | group_by(.sid)
+       | map({key: .[0].sid, value: ([.[].text] | join(" "))})
+       | from_entries) as $bySid
+      | $stale[]
+      | select((.id | type) == "string" and (.id | test("^ses_[A-Za-z0-9]+$")))
+      | . as $s
+      | ($bySid[$s.id] // "") as $text
+      | (if ($s.title // "") == ""
+         then (($text | gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end) | select(length > 0) // "(untitled)")
+         else $s.title end) as $title
+      | {sessionId: $s.id,
+         cachePath: ($extractions + "/" + $s.id + ".json"),
+         record: {cacheSchema: 2, cacheSession: $s.id,
+                  cacheUpdated: ($s.time_updated // 0), cacheParts: ($s.partCount // 0), cacheMax: ($s.partMax // 0),
+                  sessionId: $s.id, transcriptPath: "", source: "opencode",
+                  cwd: ($s.directory // ""),
+                  title: ($title | gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end),
+                  updatedEpoch: ((($s.time_updated // 0) / 1000 | floor) | if . > 0 then . else ((($s.time_created // 0) / 1000) | floor) end),
+                  fulltextLower: (($title + " " + $text) | ascii_downcase)}}
+      | "\(.sessionId)\n\(.cachePath)\n\(.record | tojson)"' > "$records" || extract_failed=1
+  fi
+
+  if [ "$extract_failed" = 0 ]; then
+    while IFS= read -r sid && IFS= read -r cache_path && IFS= read -r record; do
+      [ -n "$sid" ] || continue
       cache_tmp=$(mktemp "$EXTRACTIONS/$sid.json.XXXXXX")
       printf '%s\n' "$record" > "$cache_tmp"
-      mv "$cache_tmp" "$cache"
+      mv "$cache_tmp" "$cache_path"
       printf '%s\n' "$record" >> "$historical"
-    fi
-  done < "$needs_extract"
+    done < "$records"
+  fi
 
   if ! "$JQ_BIN" -c --slurpfile hist "$historical" --arg scope "$SCOPE_CWD" --argjson limit "$LIMIT" --argjson archived "$INCLUDE_ARCHIVED" '
     .meta as $meta
     | ($hist | map({key: .sessionId, value: .}) | from_entries) as $histById
     | [$meta[]
+       | select((.id | type) == "string" and (.id | test("^ses_[A-Za-z0-9]+$")))
        | select($archived == 1 or .archived == 0)
        | select($scope == "" or .directory == $scope)
        | . as $m | ($histById[$m.id] // {}) as $h
@@ -313,7 +347,13 @@ refresh() {
     return 1
   fi
   mv -f "$out" "$SNAPSHOT"
-  set_status fresh || true
+  if [ "$extract_failed" = 1 ]; then
+    # Publish what we have, but say the index is incomplete and keep the
+    # failed sessions uncached so the next refresh retries them.
+    set_status 'stale: transcript extraction incomplete; refresh to retry' || true
+  else
+    set_status fresh || true
+  fi
 }
 
 if [ "$REFRESH" = 1 ] || [ "$TOGGLE_SCOPE" = 1 ]; then refresh; fi

package/bin/sesh-preview.sh

@@ -10,7 +10,7 @@ JQ_BIN=${SESH_JQ:-jq}
 
 [ -n "$state_dir" ] && [ -n "$session_id" ] || { echo "(no session selected)"; exit 0; }
 [ -f "$snapshot" ] || { echo "(no session snapshot available)"; exit 0; }
-case "$session_id" in ses_[A-Za-z0-9]*) ;; *) echo "(no transcript for this row)"; exit 0;; esac
+[[ "$session_id" =~ ^ses_[A-Za-z0-9]+$ ]] || { echo "(no transcript for this row)"; exit 0; }
 "$JQ_BIN" -se --arg sid "$session_id" 'any(.sessionId == $sid)' "$snapshot" >/dev/null 2>&1 \
   || { echo "(selected session is no longer in this snapshot)"; exit 0; }
 
@@ -26,26 +26,31 @@ fi
 
 SQLITE_BIN=${SESH_SQLITE:-}
 if [ -z "$SQLITE_BIN" ] && command -v sqlite3 >/dev/null 2>&1; then SQLITE_BIN=sqlite3; fi
-SQL="SELECT m.data AS msg, p.data AS part FROM part p JOIN message m ON m.id = p.message_id WHERE p.session_id = '$session_id' ORDER BY p.time_created DESC LIMIT 200;"
+SQL="SELECT m.data AS msg, p.data AS part FROM part p JOIN message m ON m.id = p.message_id WHERE p.session_id = '$session_id' AND json_extract(p.data, '\$.type') = 'text' ORDER BY p.time_created DESC LIMIT 200;"
 if [ -n "$SQLITE_BIN" ]; then
-  rows=$("$SQLITE_BIN" -json "$DB_PATH" "$SQL" 2>/dev/null) || rows=''
+  rows=$("$SQLITE_BIN" -json -readonly "$DB_PATH" "$SQL" 2>/dev/null) || rows=''
 else
   OPENCODE_BIN=${SESH_OPENCODE:-opencode}
   rows=$("$OPENCODE_BIN" db "$SQL" --format json 2>/dev/null) || rows=''
 fi
 [ -n "$rows" ] || { echo "(no displayable transcript messages)"; exit 0; }
 
-# Text parts only, newest first, with role headers. Control bytes are stripped
-# with tr (byte-safe for UTF-8: only 0x00-0x1F and 0x7F are removed).
+# Text parts only, newest first, with role headers. The 120-block cap is applied
+# inside jq so nothing closes the pipe early (a `head` here would trip pipefail
+# with SIGPIPE and blank the preview). Control bytes are stripped with tr
+# (byte-safe for UTF-8: only 0x00-0x1F and 0x7F are removed).
 rendered=$(printf '%s' "$rows" | "$JQ_BIN" -r '
   (if type == "array" then . else [] end)
+  | map(
+      ((.msg | try fromjson catch {}) | .role? // "") as $role
+      | (.part | try fromjson catch {}) as $p
+      | select(($p.type? // "") == "text")
+      | ($p.text? // "") | select(type == "string" and length > 0)
+      | (if $role == "user" then "# You" elif $role == "assistant" then "# Opencode" else "# Message" end) + "\n\n" + .
+    )
+  | .[0:120]
   | .[]
-  | ((.msg | try fromjson catch {}) | .role? // "") as $role
-  | (.part | try fromjson catch {}) as $p
-  | select(($p.type? // "") == "text")
-  | ($p.text? // "") | select(type == "string" and length > 0)
-  | (if $role == "user" then "# You" elif $role == "assistant" then "# Opencode" else "# Message" end) + "\n\n" + .
-' 2>/dev/null | tr -d '\000-\010\013\014\016-\037\177' | head -120) || rendered=''
+' 2>/dev/null | tr -d '\000-\010\013\014\016-\037\177') || rendered=''
 [ -n "$rendered" ] || { echo "(no displayable transcript messages)"; exit 0; }
 
 resolve_glow() {

package/install.sh

@@ -91,8 +91,33 @@ remove_tui_entry() {
   fi
 }
 
+# The launcher is a symlink we create. Treat it as ours only when it resolves to
+# a sesh launcher, so a foreign symlink is never replaced on install nor deleted
+# on uninstall. Recognized by the exact source path, a `.../bin/sesh` target, or
+# the marker in the target file (covers npm upgrades and a moved checkout).
+launcher_is_ours() {
+  local link=$1 target
+  [ -L "$link" ] || return 1
+  target=$(readlink "$link" 2>/dev/null) || return 1
+  [ -n "$target" ] || return 1
+  case "$target" in
+    /*) ;;
+    *) target="$(cd "$(dirname "$link")" && pwd -P)/$target" ;;
+  esac
+  case "$target" in
+    "$SOURCE_DIR/bin/sesh"|*/bin/sesh) return 0 ;;
+  esac
+  [ -f "$target" ] && grep -qF 'Pick an opencode session' "$target" 2>/dev/null
+}
+
 if [ "$UNINSTALL" = 1 ]; then
-  [ -L "$LAUNCHER" ] && rm -f "$LAUNCHER" && note "removed $LAUNCHER"
+  if [ -L "$LAUNCHER" ]; then
+    if launcher_is_ours "$LAUNCHER"; then
+      rm -f "$LAUNCHER" && note "removed $LAUNCHER"
+    else
+      note "left $LAUNCHER untouched (not a sesh launcher: $(readlink "$LAUNCHER" 2>/dev/null))"
+    fi
+  fi
   remove_if_marker "$COMMAND_DST" "rich interactive picker" && note "removed $COMMAND_DST"
   remove_if_marker "$TOOL_DST" "list opencode sessions for the agent" && note "removed $TOOL_DST"
   remove_if_marker "$PANEL_DST" "@jsxImportSource @opentui/solid" && note "removed $PANEL_DST"
@@ -135,6 +160,9 @@ mkdir -p "$BIN_DIR"
 if [ -e "$LAUNCHER" ] && [ ! -L "$LAUNCHER" ]; then
   fail "$LAUNCHER already exists and is not a symlink. Move it aside, then retry."
 fi
+if [ -L "$LAUNCHER" ] && ! launcher_is_ours "$LAUNCHER"; then
+  fail "$LAUNCHER is a symlink to $(readlink "$LAUNCHER" 2>/dev/null), which is not a sesh install. Move it aside, then retry."
+fi
 ln -sfn "$SOURCE_DIR/bin/sesh" "$LAUNCHER"
 note "linked $LAUNCHER -> $SOURCE_DIR/bin/sesh"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sesh",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "description": "Browse, search, preview and resume opencode sessions from the terminal and the TUI.",
   "license": "MIT",

package/tui/sesh-panel.tsx

@@ -159,20 +159,47 @@ function ensureRootMouse(renderer: TuiPluginApi["renderer"]) {
 }
 
 type Entry = { id: string; title: string; dir: string; group: string; updated: number }
+type EntryResult = { entries: Entry[]; truncated: boolean }
 
-async function fetchEntries(api: TuiPluginApi): Promise<Entry[]> {
+const SESSION_PAGE_LIMIT = 200
+const SESSION_MAX = 5000
+
+async function fetchEntries(api: TuiPluginApi): Promise<EntryResult> {
   const home = process.env.HOME ?? ""
-  const [sessionResult, projectResult] = await Promise.all([
-    api.client.experimental.session.list({ limit: 500, roots: true, directory: "" }),
-    api.client.project.list({}),
-  ])
-  const sessions = ((sessionResult?.data ?? sessionResult) as Session[]) ?? []
+  const projectResult = await api.client.project.list({})
   const projects = ((projectResult?.data ?? projectResult) as Project[]) ?? []
-  if (!Array.isArray(sessions)) return []
   const projectName = new Map<string, string>(
     projects.map((p) => [p.id, p.name?.trim() || shortDir(p.worktree ?? "", home)]),
   )
-  return sessions
+  const sessions: Session[] = []
+  let cursor: number | undefined
+  let truncated = false
+  // Page through the global list instead of one fixed window, so sessions in
+  // older directories stay searchable. `cursor` is the previous page's oldest
+  // `time.updated`; a repeated or missing cursor stops the walk.
+  for (;;) {
+    const result = await api.client.experimental.session.list({
+      limit: SESSION_PAGE_LIMIT,
+      roots: true,
+      directory: "",
+      ...(cursor === undefined ? {} : { cursor }),
+    })
+    const page = ((result?.data ?? result) as Session[]) ?? []
+    if (!Array.isArray(page) || page.length === 0) break
+    sessions.push(...page)
+    if (page.length < SESSION_PAGE_LIMIT) break
+    if (sessions.length >= SESSION_MAX) {
+      truncated = true
+      break
+    }
+    const next = page[page.length - 1]?.time?.updated
+    if (typeof next !== "number" || next === cursor) {
+      truncated = true
+      break
+    }
+    cursor = next
+  }
+  const entries = sessions
     .filter((s) => !s.time?.archived && !s.parentID)
     .sort((a, b) => b.time.updated - a.time.updated)
     .map((s) => {
@@ -187,76 +214,118 @@ async function fetchEntries(api: TuiPluginApi): Promise<Entry[]> {
         updated: s.time.updated,
       }
     })
+  return { entries, truncated }
 }
 
-const TRANSCRIPT_INDEX_LIMIT = 150
 const SESSION_ID_PATTERN = /^ses_[A-Za-z0-9]+$/
+const TRANSCRIPT_BATCH = 64
+const REMOTE_CONCURRENCY = 8
 
-async function buildSearchIndex(api: TuiPluginApi, entries: Entry[]): Promise<Map<string, string>> {
-  const index = new Map<string, string>()
-  const targets = entries.slice(0, TRANSCRIPT_INDEX_LIMIT)
-  for (const entry of targets) {
-    index.set(entry.id, `${entry.title.toLowerCase()} ${entry.dir.toLowerCase()}`)
-  }
-  const ids = targets.map((entry) => entry.id).filter((id) => SESSION_ID_PATTERN.test(id))
-  if (ids.length === 0) return index
+type IndexProgress = { indexed: number; total: number; complete: boolean }
+
+const nextTick = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
+
+async function openTranscriptDb(): Promise<any | undefined> {
   try {
     const home = process.env.HOME ?? ""
     const dataHome = process.env.XDG_DATA_HOME ?? `${home}/.local/share`
     // @ts-ignore - bun:sqlite ships with the Bun runtime (verified); no type package installed
     const sqlite: any = await import("bun:sqlite")
-    if (typeof sqlite?.Database !== "function") throw new Error("bun:sqlite unavailable")
-    const db = new sqlite.Database(`${dataHome}/opencode/opencode.db`, { readonly: true })
+    if (typeof sqlite?.Database !== "function") return undefined
+    return new sqlite.Database(`${dataHome}/opencode/opencode.db`, { readonly: true })
+  } catch {
+    return undefined
+  }
+}
+
+function addTranscript(index: Map<string, string>, sid: string, data: string): void {
+  try {
+    const part = JSON.parse(data) as { type?: unknown; text?: unknown }
+    if (part?.type !== "text" || typeof part.text !== "string") return
+    const base = index.get(sid) ?? ""
+    index.set(sid, `${base} ${part.text.toLowerCase()}`.trim())
+  } catch {
+    // ignore malformed parts
+  }
+}
+
+// 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: TuiPluginApi,
+  entries: Entry[],
+  onProgress?: (progress: IndexProgress) => void,
+): Promise<Map<string, string>> {
+  const index = new Map<string, string>()
+  for (const entry of entries) {
+    index.set(entry.id, `${entry.title.toLowerCase()} ${entry.dir.toLowerCase()}`)
+  }
+  const ids = entries.map((entry) => entry.id).filter((id) => SESSION_ID_PATTERN.test(id))
+  const remaining = new Set(ids)
+  const total = ids.length
+  let indexed = 0
+  const report = (complete: boolean) => onProgress?.({ indexed, total, complete })
+  report(false)
+
+  const db = await openTranscriptDb()
+  if (db) {
     try {
-      const placeholders = ids.map(() => "?").join(",")
-      const rows = (db
-        .query(
-          `SELECT session_id AS sid, data FROM part WHERE session_id IN (${placeholders}) AND json_extract(data, '$.type') = 'text' ORDER BY time_created`,
-        )
-        .all(...ids) ?? []) as { sid: string; data: string }[]
-      const byId = new Map<string, string[]>()
-      for (const row of rows) {
-        try {
-          const part = JSON.parse(row.data) as { type?: unknown; text?: unknown }
-          if (part?.type === "text" && typeof part.text === "string") {
-            const list = byId.get(row.sid) ?? []
-            list.push(part.text)
-            byId.set(row.sid, list)
-          }
-        } catch {}
-      }
-      for (const entry of targets) {
-        const text = (byId.get(entry.id) ?? []).join(" ").toLowerCase()
-        if (text) index.set(entry.id, `${index.get(entry.id)} ${text}`)
+      for (let i = 0; i < ids.length; i += TRANSCRIPT_BATCH) {
+        const batch = ids.slice(i, i + TRANSCRIPT_BATCH)
+        const placeholders = batch.map(() => "?").join(",")
+        const rows = (db
+          .query(
+            `SELECT session_id AS sid, data FROM part WHERE session_id IN (${placeholders}) AND json_extract(data, '$.type') = 'text' ORDER BY time_created`,
+          )
+          .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()
       }
+    } catch {
+      // local store unavailable mid-walk; fall back to the remote path below
     } finally {
       db.close()
     }
-  } catch {
-    await buildSearchIndexRemote(api, targets, index)
   }
+
+  if (remaining.size > 0) {
+    await buildSearchIndexRemote(api, [...remaining], index, () => {
+      indexed += 1
+      report(false)
+    })
+  }
+  report(true)
   return index
 }
 
 async function buildSearchIndexRemote(
   api: TuiPluginApi,
-  targets: Entry[],
+  ids: string[],
   index: Map<string, string>,
+  onEach: () => void,
 ): Promise<void> {
   const home = process.env.HOME ?? ""
   const cacheDir = process.env.SESH_CACHE_DIR ?? `${home}/.cache/sesh`
-  await Promise.all(
-    targets.map(async (entry) => {
-      const base = index.get(entry.id) ?? ""
-      if (!SESSION_ID_PATTERN.test(entry.id)) return
+  let cursor = 0
+  // Bounded concurrency: a fixed worker pool instead of one request per session.
+  const worker = async () => {
+    for (;;) {
+      const i = cursor++
+      if (i >= ids.length) return
+      const id = ids[i]
+      const base = index.get(id) ?? ""
       try {
-        const raw = await readFile(`${cacheDir}/extractions/${entry.id}.json`, "utf8")
+        const raw = await readFile(`${cacheDir}/extractions/${id}.json`, "utf8")
         const record = JSON.parse(raw) as { fulltextLower?: unknown }
         const fulltext = typeof record?.fulltextLower === "string" ? record.fulltextLower : ""
-        index.set(entry.id, `${base} ${fulltext}`)
+        index.set(id, `${base} ${fulltext}`.trim())
       } catch {
         try {
-          const result = await api.client.session.messages({ sessionID: entry.id })
+          const result = await api.client.session.messages({ sessionID: id })
           const messages = result.data ?? []
           const text = messages
             .flatMap((message) =>
@@ -266,11 +335,13 @@ async function buildSearchIndexRemote(
             )
             .join(" ")
             .toLowerCase()
-          index.set(entry.id, `${base} ${text}`)
+          index.set(id, `${base} ${text}`.trim())
         } catch {}
       }
-    }),
-  )
+      onEach()
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(REMOTE_CONCURRENCY, ids.length) }, worker))
 }
 
 const TRANSCRIPT_PREVIEW_TURNS = 8
@@ -397,7 +468,7 @@ function SidebarSessions(props: { api: TuiPluginApi }) {
     let alive = true
     const load = async () => {
       try {
-        const all = await fetchEntries(props.api)
+        const { entries: all } = await fetchEntries(props.api)
         if (alive) setEntries(all)
       } catch {
         // leave the previous list in place rather than flashing to blank
@@ -469,7 +540,7 @@ function SidebarSessions(props: { api: TuiPluginApi }) {
         directory: entry.dir || undefined,
       })
       if (result && "error" in result && result.error) throw result.error
-      const remaining = await fetchEntries(props.api)
+      const { entries: remaining } = await fetchEntries(props.api)
       if (remaining.some((item) => item.id === entry.id)) {
         setEntries(remaining)
         props.api.ui.toast({ message: "Session was not deleted", variant: "error" })
@@ -723,7 +794,7 @@ function HomeSessions(props: { api: TuiPluginApi }) {
     let alive = true
     const load = async () => {
       try {
-        const all = await fetchEntries(props.api)
+        const { entries: all } = await fetchEntries(props.api)
         if (alive) setEntries(all)
       } catch {}
     }
@@ -827,13 +898,14 @@ const tui: TuiPlugin = async (api) => {
     if (api.mode.current() !== BASE_MODE) return
     if (api.renderer.currentFocusedEditor === null) return
 
-    let entries: Entry[]
+    let entriesResult: EntryResult
     try {
-      entries = await fetchEntries(api)
+      entriesResult = await fetchEntries(api)
     } catch {
       api.ui.toast({ message: "Could not load sessions", variant: "error" })
       return
     }
+    const entries = entriesResult.entries
     if (entries.length === 0) {
       api.ui.toast({ message: "No sessions found", variant: "warning" })
       return
@@ -844,7 +916,12 @@ const tui: TuiPlugin = async (api) => {
     const [query, setQuery] = createSignal("")
     const [cursor, setCursor] = createSignal(0)
     const [searchIndex, setSearchIndex] = createSignal<Map<string, string>>(new Map())
-    void buildSearchIndex(api, entries).then(setSearchIndex)
+    const [indexProgress, setIndexProgress] = createSignal<IndexProgress>({
+      indexed: 0,
+      total: 0,
+      complete: false,
+    })
+    void buildSearchIndex(api, entries, setIndexProgress).then(setSearchIndex)
     let pickerInput: { value: string; isDestroyed?: boolean } | undefined
 
     type DialogRow = { kind: "group"; label: string; count: number } | { kind: "item"; entry: Entry }
@@ -868,6 +945,22 @@ const tui: TuiPlugin = async (api) => {
 
     const selectableEntries = createMemo(() => matchedGroups().flatMap((g) => g.list))
 
+    // Visible bounding: say how much transcript text search actually covers and
+    // when the metadata walk hit its cap, instead of silently under-reporting.
+    const coverageLabel = createMemo(() => {
+      const progress = indexProgress()
+      const bits: string[] = []
+      if (progress.total > 0) {
+        bits.push(
+          progress.complete
+            ? `transcripts ${progress.total}`
+            : `indexing transcripts ${progress.indexed}/${progress.total}`,
+        )
+      }
+      if (entriesResult.truncated) bits.push(`showing newest ${entries.length}`)
+      return bits.join(" · ")
+    })
+
     createEffect(() => {
       const count = selectableEntries().length
       if (cursor() >= count) setCursor(Math.max(0, count - 1))
@@ -1041,6 +1134,11 @@ const tui: TuiPlugin = async (api) => {
                 }}
               />
             </box>
+            <Show when={coverageLabel()}>
+              <box paddingTop={1}>
+                <text style={{ fg: api.theme.current.textMuted }}>{coverageLabel()}</text>
+              </box>
+            </Show>
           </box>
           <box
             flexDirection="column"