diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6611ad2..044a787 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,7 +38,7 @@ jobs:
         run: |
           python - <<'PY'
           from app import create_app
-          app = create_app()
+          app = create_app(testing=True)
           client = app.test_client()
           assert client.get("/").status_code == 200
           PY
diff --git a/api/search.py b/api/search.py
index e16427f..6bfd5a0 100644
--- a/api/search.py
+++ b/api/search.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import os
 from datetime import datetime, timezone
 from typing import Any
 
@@ -11,17 +12,16 @@
 from api._flask_types import FlaskReturn, json_response
 from api.error_codes import ErrorCode, error_response
 from models.search import SearchHitDict
-from models.session import MessageDict
 from utils.exclusion_rules import is_session_excluded
 from utils.search_index import (
     index_is_usable,
     index_search_enabled,
+    message_searchable_text,
     query_index_hits,
     resolve_search_since_ms,
     search_snippet,
     timestamp_in_search_window_iso,
     timestamp_to_ms,
-    tool_result_searchable_text,
 )
 from utils.session_cache import get_cached_session
 from utils.session_path import get_claude_projects_dir, list_projects, list_sessions
@@ -32,6 +32,7 @@
 
 _DEFAULT_LIMIT = 50
 _MAX_LIMIT = 500
+_MAX_QUERY_LEN = 500
 _MAX_SEARCH_SINCE_DAYS = 36_500
 
 
@@ -53,10 +54,10 @@ def _parse_since_days(raw: str | None) -> int | None:
         return None
     try:
         days = int(str(raw).strip())
-    except ValueError:
-        return None
+    except ValueError as exc:
+        raise ValueError("Invalid since_days: must be a positive integer") from exc
     if days <= 0:
-        return None
+        raise ValueError("Invalid since_days: must be a positive integer")
     return min(days, _MAX_SEARCH_SINCE_DAYS)
 
 
@@ -71,16 +72,44 @@ def _rank_search_hits(results: list[SearchHitDict]) -> list[SearchHitDict]:
     )
 
 
-def _message_searchable_text(msg: MessageDict) -> str:
-    text = msg.get("text", "") or msg.get("content", "")
-    if not isinstance(text, str):
-        text = ""
-    tool_result = msg.get("tool_result")
-    if isinstance(tool_result, dict):
-        tool_text = tool_result_searchable_text(tool_result)
-        if tool_text:
-            text = f"{text}\n{tool_text}" if text else tool_text
-    return text
+def _hit_dedup_key(hit: SearchHitDict) -> tuple[str, str, str | None, str]:
+    ts = hit.get("timestamp")
+    return (
+        hit["project"],
+        hit["session_id"],
+        ts if isinstance(ts, str) else None,
+        hit["role"],
+    )
+
+
+def _merge_search_hits(
+    primary: list[SearchHitDict],
+    extra: list[SearchHitDict],
+    *,
+    max_results: int,
+) -> list[SearchHitDict]:
+    seen = {_hit_dedup_key(hit) for hit in primary}
+    merged = list(primary)
+    for hit in extra:
+        key = _hit_dedup_key(hit)
+        if key in seen:
+            continue
+        merged.append(hit)
+        seen.add(key)
+        if len(merged) >= max_results:
+            break
+    return _rank_search_hits(merged)[:max_results]
+
+
+def _projects_dir_inaccessible(projects_dir: str) -> bool:
+    """True when the projects path exists but cannot be listed (503 case)."""
+    try:
+        if not os.path.isdir(projects_dir):
+            return False
+        os.listdir(projects_dir)
+        return False
+    except OSError:
+        return True
 
 
 def _index_hit_excluded(
@@ -104,7 +133,7 @@ def _index_hit_excluded(
             file_path,
             exc_info=True,
         )
-        return False
+        return True
     return is_session_excluded(rules, session, project_name)
 
 
@@ -116,13 +145,14 @@ def _search_via_index(
     *,
     since_ms: int | None,
     max_results: int,
-) -> list[SearchHitDict] | None:
+) -> tuple[list[SearchHitDict] | None, bool]:
     if not index_search_enabled() or not index_is_usable(projects_dir, rules):
-        return None
+        return None, False
 
     rules_fp = rules_fingerprint(rules)
     results: list[SearchHitDict] = []
     sql_offset = 0
+    fts_exhausted = False
     while len(results) < max_results:
         need = max_results - len(results)
         indexed = query_index_hits(
@@ -131,9 +161,18 @@ def _search_via_index(
             max_results=need,
             sql_offset=sql_offset,
         )
+        if indexed["index_locked"]:
+            _logger.warning(
+                "Search index locked during query; %d hit(s) collected so far",
+                len(results),
+            )
+            if results:
+                return _rank_search_hits(results)[:max_results], False
+            return None, False
         if not indexed["query_ok"]:
-            return None
+            return None, False
         if indexed["sql_rows_fetched"] == 0:
+            fts_exhausted = indexed["sql_exhausted"]
             break
 
         for hit in indexed["hits"]:
@@ -160,8 +199,50 @@ def _search_via_index(
 
         sql_offset += indexed["sql_rows_fetched"]
         if indexed["sql_exhausted"]:
+            fts_exhausted = True
             break
-    return _rank_search_hits(results)[:max_results]
+    return _rank_search_hits(results)[:max_results], fts_exhausted
+
+
+def _resolve_search_results(
+    base: str,
+    rules: list[Any],
+    query: str,
+    query_lower: str,
+    *,
+    since_ms: int | None,
+    max_results: int,
+) -> list[SearchHitDict]:
+    indexed, _fts_exhausted = _search_via_index(
+        base,
+        rules,
+        query,
+        query_lower,
+        since_ms=since_ms,
+        max_results=max_results,
+    )
+    if indexed is None:
+        return _search_live_scan(
+            base,
+            rules,
+            query,
+            query_lower,
+            since_ms=since_ms,
+            max_results=max_results,
+        )
+
+    if len(indexed) >= max_results:
+        return indexed
+
+    live = _search_live_scan(
+        base,
+        rules,
+        query,
+        query_lower,
+        since_ms=since_ms,
+        max_results=max_results,
+    )
+    return _merge_search_hits(indexed, live, max_results=max_results)
 
 
 def _search_live_scan(
@@ -192,7 +273,7 @@ def _search_live_scan(
                 continue
 
             for msg in session["messages"]:
-                text = _message_searchable_text(msg)
+                text = message_searchable_text(msg)
                 if not text or query_lower not in text.lower():
                     continue
                 if not timestamp_in_search_window_iso(
@@ -215,9 +296,20 @@ def _search_live_scan(
 
 @search_bp.route("/api/search")
 def search() -> FlaskReturn:
-    query = request.args.get("q", "").strip()
+    raw_query = request.args.get("q", "")
+    query = raw_query.strip()
     if not query:
-        return json_response([])
+        return error_response(
+            ErrorCode.SEARCH_EMPTY_QUERY,
+            "Search query is required",
+            400,
+        )
+    if len(query) > _MAX_QUERY_LEN:
+        return error_response(
+            ErrorCode.SEARCH_QUERY_TOO_LONG,
+            f"Search query must be at most {_MAX_QUERY_LEN} characters",
+            400,
+        )
 
     try:
         max_results = _parse_limit(request.args.get("limit"))
@@ -228,35 +320,49 @@ def search() -> FlaskReturn:
             400,
         )
 
+    since_days_raw = request.args.get("since_days")
+    try:
+        since_days = _parse_since_days(since_days_raw)
+    except ValueError:
+        return error_response(
+            ErrorCode.SEARCH_INVALID_SINCE_DAYS,
+            "Invalid since_days: must be a positive integer",
+            400,
+        )
+
     query_lower = query.lower()
     all_history = request.args.get("all_history") in ("1", "true")
     since_ms = resolve_search_since_ms(
         all_history=all_history,
-        since_days=_parse_since_days(request.args.get("since_days")),
+        since_days=since_days,
         now=datetime.now(timezone.utc),
     )
 
     base = current_app.config.get("CLAUDE_PROJECTS_DIR") or get_claude_projects_dir()
-    rules = current_app.config.get("EXCLUSION_RULES") or []
+    if _projects_dir_inaccessible(base):
+        return error_response(
+            ErrorCode.SEARCH_PROJECTS_UNAVAILABLE,
+            "Claude projects directory is not accessible",
+            503,
+        )
 
-    indexed = _search_via_index(
-        base,
-        rules,
-        query,
-        query_lower,
-        since_ms=since_ms,
-        max_results=max_results,
-    )
-    if indexed is not None:
-        return json_response(indexed)
+    rules = current_app.config.get("EXCLUSION_RULES") or []
 
-    return json_response(
-        _search_live_scan(
-            base,
-            rules,
-            query,
-            query_lower,
-            since_ms=since_ms,
-            max_results=max_results,
+    try:
+        return json_response(
+            _resolve_search_results(
+                base,
+                rules,
+                query,
+                query_lower,
+                since_ms=since_ms,
+                max_results=max_results,
+            )
+        )
+    except Exception:
+        _logger.exception("Unexpected error during search")
+        return error_response(
+            ErrorCode.INTERNAL_ERROR,
+            "Search failed",
+            500,
         )
-    )
diff --git a/app.py b/app.py
index 67b5b21..0144681 100644
--- a/app.py
+++ b/app.py
@@ -92,8 +92,11 @@ def validate_startup_cli(args: argparse.Namespace) -> None:
 def create_app(
     base_dir: str | None = None,
     exclusion_rules_path: str | None = None,
+    *,
+    testing: bool = False,
 ) -> Flask:
     app = Flask(__name__)
+    app.config["TESTING"] = testing
     app.config["CLAUDE_PROJECTS_DIR"] = base_dir
 
     resolved = resolve_exclusion_rules_path(exclusion_rules_path)
@@ -106,7 +109,7 @@ def create_app(
     app.register_blueprint(export_bp)
     app.register_blueprint(schema_report_bp)
 
-    if not app.config.get("TESTING"):
+    if not testing:
         try:
             from utils.search_index import start_search_index_background
 
diff --git a/docs/api-reference.md b/docs/api-reference.md
index d979cf3..47d1e77 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -56,6 +56,10 @@ Extra fields may appear for specific codes (for example `since` on invalid bulk-
 | `code` | HTTP | Routes | Meaning |
 |--------|------|--------|---------|
 | `SEARCH_INVALID_LIMIT` | 400 | `GET /api/search` | Query param `limit` is not a positive integer |
+| `SEARCH_EMPTY_QUERY` | 400 | `GET /api/search` | Query param `q` is empty or whitespace |
+| `SEARCH_QUERY_TOO_LONG` | 400 | `GET /api/search` | Query param `q` exceeds 500 characters |
+| `SEARCH_INVALID_SINCE_DAYS` | 400 | `GET /api/search` | Query param `since_days` is not a positive integer |
+| `SEARCH_PROJECTS_UNAVAILABLE` | 503 | `GET /api/search` | Claude projects directory exists but is not readable |
 | `INVALID_PATH` | 400 | Session, stats, export session | Path traversal or rejected URL segment |
 | `SESSION_NOT_FOUND` | 404 | Session, stats, export session | File missing on disk or session excluded by rules |
 | `INVALID_REQUEST_BODY` | 400 | `POST /api/export` | Body is not a JSON object |
@@ -280,14 +284,18 @@ curl -s "http://127.0.0.1:5000/api/sessions/F--boost-capy/session_abc123/stats"
 
 **Source:** [`api/search.py`](../api/search.py)
 
-Case-insensitive substring search across all non-excluded messages in all projects. Linear scan — suitable for local history size, not indexed search.
+Case-insensitive substring search across all non-excluded messages in all projects. Uses a local FTS5 index when available; falls back to a live JSONL scan when the index is missing, stale, or the query cannot be served from SQLite.
 
 #### Query parameters
 
 | Name | Type | Default | Description |
 |------|------|---------|-------------|
-| `q` | string | `""` | Search string; whitespace stripped; empty → `[]` |
+| `q` | string | — | Search string (required); whitespace stripped; max 500 characters |
 | `limit` | integer | `50` | Max results; must be ≥ 1; **capped at 500** |
+| `all_history` | flag | off | When `1` or `true`, search all history (no time window) |
+| `since_days` | integer | `30` | When `all_history` is off, include messages from the last *N* days (positive integer; capped at 36 500) |
+
+By default, messages older than 30 days are excluded. Sessions without a parseable timestamp may still match when windowed.
 
 #### Response — `200 OK`
 
@@ -306,10 +314,16 @@ Case-insensitive substring search across all non-excluded messages in all projec
 
 | Status | `code` | When |
 |--------|--------|------|
+| 400 | `SEARCH_EMPTY_QUERY` | `q` is empty or whitespace |
+| 400 | `SEARCH_QUERY_TOO_LONG` | `q` exceeds 500 characters |
 | 400 | `SEARCH_INVALID_LIMIT` | `limit` not a positive integer (e.g. `abc`, `0`, `1.5`) |
+| 400 | `SEARCH_INVALID_SINCE_DAYS` | `since_days` not a positive integer |
+| 503 | `SEARCH_PROJECTS_UNAVAILABLE` | Projects directory exists but is not readable |
+| 500 | `INTERNAL_ERROR` | Unexpected server failure |
 
 ```bash
 curl -s "http://127.0.0.1:5000/api/search?q=parser&limit=10" | jq '.[0]'
+curl -s "http://127.0.0.1:5000/api/search?q="   # → 400 SEARCH_EMPTY_QUERY
 curl -s "http://127.0.0.1:5000/api/search?q=test&limit=abc"   # → 400
 ```
 
diff --git a/models/error_codes.py b/models/error_codes.py
index 1d81781..4295b68 100644
--- a/models/error_codes.py
+++ b/models/error_codes.py
@@ -7,6 +7,10 @@
 
 class ErrorCode(StrEnum):
     SEARCH_INVALID_LIMIT = "SEARCH_INVALID_LIMIT"
+    SEARCH_EMPTY_QUERY = "SEARCH_EMPTY_QUERY"
+    SEARCH_QUERY_TOO_LONG = "SEARCH_QUERY_TOO_LONG"
+    SEARCH_INVALID_SINCE_DAYS = "SEARCH_INVALID_SINCE_DAYS"
+    SEARCH_PROJECTS_UNAVAILABLE = "SEARCH_PROJECTS_UNAVAILABLE"
     INVALID_PATH = "INVALID_PATH"
     SESSION_NOT_FOUND = "SESSION_NOT_FOUND"
     INVALID_REQUEST_BODY = "INVALID_REQUEST_BODY"
diff --git a/static/js/search.js b/static/js/search.js
index 8192c15..47bfcc1 100644
--- a/static/js/search.js
+++ b/static/js/search.js
@@ -6,8 +6,33 @@ import { showProjects } from './projects.js';
 
 // ==================== Search ====================
 
+const SEARCH_LIMIT = 50;
+
 let lastSearchRequestId = 0;
 
+export function highlightSnippet(snippet, query) {
+    if (!snippet) return '';
+    if (!query) return esc(snippet);
+    const chars = [...snippet];
+    const needle = [...query].map((ch) => ch.toLowerCase());
+    const hay = chars.map((ch) => ch.toLowerCase());
+    for (let i = 0; i <= hay.length - needle.length; i += 1) {
+        let matched = true;
+        for (let j = 0; j < needle.length; j += 1) {
+            if (hay[i + j] !== needle[j]) {
+                matched = false;
+                break;
+            }
+        }
+        if (!matched) continue;
+        const before = chars.slice(0, i).join('');
+        const match = chars.slice(i, i + needle.length).join('');
+        const after = chars.slice(i + needle.length).join('');
+        return esc(before) + '<mark>' + esc(match) + '</mark>' + esc(after);
+    }
+    return esc(snippet);
+}
+
 export function showSearchPage() {
     setHamburgerVisible(false);
     setWorkspaceMode(false);
@@ -21,6 +46,14 @@ export function showSearchPage() {
             </a>
             <br><br>
             <h1>Search</h1>
+            <p class="text-muted text-sm search-help">
+                By default, search covers the last 30 days. Chats without a parseable date may still appear.
+                Results are capped at ${SEARCH_LIMIT} (up to 500 via the API). Check
+                <label class="search-all-history-label">
+                    <input type="checkbox" id="search-all-history"> Search all history
+                </label>
+                to include older messages.
+            </p>
             <div class="search-bar">
                 <input class="input" type="text" id="search-input" placeholder="Search conversations..." autofocus>
                 <button type="button" class="btn btn-primary" id="search-submit-btn">Search</button>
@@ -51,39 +84,65 @@ export async function doSearch() {
     const localRequestId = ++lastSearchRequestId;
     const input = document.getElementById('search-input');
     if (!input) { showSearchPage(); return; }
+    const container = document.getElementById('search-results');
     const query = input.value.trim();
-    if (!query) return;
+    if (!query) {
+        container.innerHTML = '<p class="search-error">Enter a search term.</p>';
+        return;
+    }
 
-    const container = document.getElementById('search-results');
-    container.innerHTML = '<div class="loading">Searching...</div>';
+    const allHistory = document.getElementById('search-all-history')?.checked;
+    container.innerHTML = '<div class="search-loading">Searching...</div>';
+
+    const params = new URLSearchParams({
+        q: query,
+        limit: String(SEARCH_LIMIT),
+    });
+    if (allHistory) params.set('all_history', '1');
 
     try {
-        const res = await fetch(`/api/search?q=${encodeURIComponent(query)}&limit=50`);
+        const res = await fetch(`/api/search?${params.toString()}`);
         if (localRequestId !== lastSearchRequestId) return;
         if (!res.ok) {
-            let msg = `Search failed (${res.status})`;
-            try { msg = await res.text() || msg; } catch { /* ignore */ }
+            let message = `Search failed (${res.status})`;
+            let code = '';
+            const raw = await res.text();
+            try {
+                const body = JSON.parse(raw);
+                if (body && typeof body.error === 'string') message = body.error;
+                if (body && typeof body.code === 'string') code = body.code;
+            } catch {
+                const trimmed = raw.trim();
+                if (trimmed) message = trimmed;
+            }
             if (localRequestId !== lastSearchRequestId) return;
-            throw new Error(msg);
+            const codeAttr = code ? ` data-error-code="${esc(code)}"` : '';
+            container.innerHTML = `<p class="search-error"${codeAttr}>${esc(message)}</p>`;
+            return;
         }
         const results = await res.json();
         if (localRequestId !== lastSearchRequestId) return;
 
-        let html = `<p class="text-muted text-sm">${results.length} result${results.length !== 1 ? 's' : ''}</p><br>`;
+        let html = `<p class="text-muted text-sm">${results.length} result${results.length !== 1 ? 's' : ''}</p>`;
+        if (results.length >= SEARCH_LIMIT) {
+            html += `<p class="text-muted text-sm search-truncation">Showing the first ${SEARCH_LIMIT} matches. Narrow your query or raise <code>limit</code> in the API for more.</p>`;
+        }
         html += '<div class="search-results">';
 
         for (const r of results) {
             html += `<div class="search-result" data-project="${esc(r.project)}" data-session-id="${esc(r.session_id)}">
                 <div><strong>${esc(r.title)}</strong> <span class="text-muted text-sm">${esc(r.project)} &bull; ${esc(r.role)}</span></div>
-                <div class="snippet">...${esc(r.snippet)}...</div>
+                <div class="snippet">...${highlightSnippet(r.snippet, query)}...</div>
             </div>`;
         }
 
-        if (!results.length) html += '<div class="empty-state">No results found.</div>';
+        if (!results.length) {
+            html += '<div class="search-empty">No results found.</div>';
+        }
         html += '</div>';
         smoothSet(container, html);
     } catch (e) {
         if (localRequestId !== lastSearchRequestId) return;
-        container.innerHTML = `<div class="loading">Error: ${esc(e.message)}</div>`;
+        container.innerHTML = `<p class="search-error">${esc(e.message)}</p>`;
     }
 }
diff --git a/static/js/search.test.js b/static/js/search.test.js
index e5db512..6bec8d4 100644
--- a/static/js/search.test.js
+++ b/static/js/search.test.js
@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { showSearchPage, doSearch } from './search.js';
+import { showSearchPage, doSearch, highlightSnippet } from './search.js';
 
-// SearchHitDict[] — mirrors models/search.py (no highlight wrapper in search.js; snippets are escaped text only).
+// SearchHitDict[] — mirrors models/search.py.
 const SEARCH_HITS = [
     {
         project: 'alpha',
@@ -21,6 +21,21 @@ const SEARCH_HITS = [
     },
 ];
 
+describe('highlightSnippet', () => {
+    it('wraps a case-insensitive match in mark after escaping', () => {
+        const html = highlightSnippet('matched keyword here', 'Keyword');
+        expect(html).toContain('<mark>keyword</mark>');
+        expect(html).not.toContain('<script>');
+    });
+
+    it('does not inject raw HTML from session content', () => {
+        const html = highlightSnippet('<img onerror=alert(1)>', 'img');
+        expect(html).toContain('&lt;');
+        expect(html).not.toContain('<img onerror');
+        expect(html).not.toContain('<script>');
+    });
+});
+
 describe('search page', () => {
     beforeEach(() => {
         document.body.innerHTML = '<div id="content"></div>';
@@ -37,10 +52,21 @@ describe('search page', () => {
         expect(window.location.hash).toBe('#search');
         expect(document.getElementById('search-input')).not.toBeNull();
         expect(document.getElementById('search-results')).not.toBeNull();
-        expect(document.getElementById('content').innerHTML).toContain('Search conversations');
+        expect(document.getElementById('search-all-history')).not.toBeNull();
+        expect(document.getElementById('content').innerHTML).toContain('30 days');
+    });
+
+    it('doSearch prompts when query is empty', async () => {
+        showSearchPage();
+        document.getElementById('search-input').value = '   ';
+
+        await doSearch();
+
+        expect(document.getElementById('search-results').innerHTML).toContain('Enter a search term');
+        expect(fetch).not.toHaveBeenCalled();
     });
 
-    it('doSearch renders results with snippet text', async () => {
+    it('doSearch renders results with highlighted snippet text', async () => {
         showSearchPage();
         fetch.mockResolvedValue({
             ok: true,
@@ -53,10 +79,21 @@ describe('search page', () => {
         const results = document.getElementById('search-results');
         expect(results.innerHTML).toContain('2 results');
         expect(results.innerHTML).toContain('First hit');
-        expect(results.innerHTML).toContain('matched keyword here');
+        expect(results.innerHTML).toContain('<mark>keyword</mark>');
         expect(results.querySelectorAll('.search-result').length).toBe(2);
     });
 
+    it('doSearch sends all_history when checkbox is checked', async () => {
+        showSearchPage();
+        fetch.mockResolvedValue({ ok: true, json: () => Promise.resolve([]) });
+        document.getElementById('search-input').value = 'old';
+        document.getElementById('search-all-history').checked = true;
+
+        await doSearch();
+
+        expect(fetch).toHaveBeenCalledWith(expect.stringContaining('all_history=1'));
+    });
+
     it('doSearch shows empty state when no hits', async () => {
         showSearchPage();
         fetch.mockResolvedValue({ ok: true, json: () => Promise.resolve([]) });
@@ -66,18 +103,59 @@ describe('search page', () => {
 
         const results = document.getElementById('search-results');
         expect(results.innerHTML).toContain('0 results');
-        expect(results.innerHTML).toContain('No results found');
+        expect(results.innerHTML).toContain('search-empty');
+        expect(results.innerHTML).not.toContain('search-error');
     });
 
-    it('doSearch surfaces HTTP errors', async () => {
+    it('doSearch shows truncation warning when results hit the limit', async () => {
         showSearchPage();
-        fetch.mockResolvedValue({ ok: false, status: 503, text: () => Promise.resolve('unavailable') });
+        const full = Array.from({ length: 50 }, (_, i) => ({
+            ...SEARCH_HITS[0],
+            session_id: `sess-${i}`,
+        }));
+        fetch.mockResolvedValue({ ok: true, json: () => Promise.resolve(full) });
+        document.getElementById('search-input').value = 'keyword';
+
+        await doSearch();
+
+        expect(document.getElementById('search-results').innerHTML).toContain('search-truncation');
+    });
+
+    it('doSearch surfaces structured API errors with data-error-code', async () => {
+        showSearchPage();
+        fetch.mockResolvedValue({
+            ok: false,
+            status: 503,
+            text: () => Promise.resolve(JSON.stringify({
+                error: 'Claude projects directory is not accessible',
+                code: 'SEARCH_PROJECTS_UNAVAILABLE',
+            })),
+        });
+        document.getElementById('search-input').value = 'fail';
+
+        await doSearch();
+
+        const err = document.querySelector('.search-error');
+        expect(err).not.toBeNull();
+        expect(err.getAttribute('data-error-code')).toBe('SEARCH_PROJECTS_UNAVAILABLE');
+        expect(err.textContent).toContain('not accessible');
+    });
+
+    it('doSearch shows plain-text error body when response is not JSON', async () => {
+        showSearchPage();
+        fetch.mockResolvedValue({
+            ok: false,
+            status: 502,
+            text: () => Promise.resolve('Bad Gateway from proxy'),
+        });
         document.getElementById('search-input').value = 'fail';
 
         await doSearch();
 
-        expect(document.getElementById('search-results').innerHTML).toContain('Error:');
-        expect(document.getElementById('search-results').innerHTML).toContain('unavailable');
+        const err = document.querySelector('.search-error');
+        expect(err).not.toBeNull();
+        expect(err.textContent).toBe('Bad Gateway from proxy');
+        expect(err.getAttribute('data-error-code')).toBeNull();
     });
 
     it('doSearch ignores stale responses when a newer request was started', async () => {
diff --git a/tests/benchmarks/conftest.py b/tests/benchmarks/conftest.py
index 2bc4876..2b22088 100644
--- a/tests/benchmarks/conftest.py
+++ b/tests/benchmarks/conftest.py
@@ -119,6 +119,5 @@ def export_corpus(tmp_path: Path, request: pytest.FixtureRequest) -> Path:
 def bench_client_search_corpus(tmp_path: Path):
     """Flask test client backed by a 50-session synthetic project tree."""
     seed_search_corpus(tmp_path)
-    app = create_app(base_dir=str(tmp_path))
-    app.config["TESTING"] = True
+    app = create_app(base_dir=str(tmp_path), testing=True)
     return app.test_client()
diff --git a/tests/conftest.py b/tests/conftest.py
index f3e0a3d..5c08244 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -41,8 +41,7 @@ def _make_test_client(tmp_path, session_files: Mapping[str, str] | None = None):
         project_dir.mkdir(parents=True)
         for dest_name, fixture_name in session_files.items():
             shutil.copy(FIXTURES / fixture_name, project_dir / dest_name)
-    app = create_app(base_dir=str(tmp_path))
-    app.config["TESTING"] = True
+    app = create_app(base_dir=str(tmp_path), testing=True)
     return app.test_client()
 
 
diff --git a/tests/test_api_integration.py b/tests/test_api_integration.py
index 6944efd..bf329ac 100644
--- a/tests/test_api_integration.py
+++ b/tests/test_api_integration.py
@@ -109,8 +109,9 @@ def test_search_returns_results(client):
 
 def test_search_empty_query(client):
     resp = client.get("/api/search?q=")
-    assert resp.status_code == 200
-    assert resp.get_json() == []
+    assert resp.status_code == 400
+    _assert_error_shape(resp)
+    assert resp.get_json()["code"] == "SEARCH_EMPTY_QUERY"
 
 
 def test_search_invalid_limit(client):
diff --git a/tests/test_api_routes.py b/tests/test_api_routes.py
index e454e84..3e99020 100644
--- a/tests/test_api_routes.py
+++ b/tests/test_api_routes.py
@@ -39,7 +39,7 @@ def test_session_stats_excluded_session_returns_404(tmp_path, export_state_file)
     rules_path = tmp_path / "exclusion-rules.txt"
     rules_path.write_text("integration fixture\n", encoding="utf-8")
 
-    app = create_app(base_dir=str(tmp_path), exclusion_rules_path=str(rules_path))
+    app = create_app(base_dir=str(tmp_path), exclusion_rules_path=str(rules_path), testing=True)
     app.config["TESTING"] = True
     excluded_client = app.test_client()
 
diff --git a/tests/test_error_codes.py b/tests/test_error_codes.py
index 2546e8a..47f43b4 100644
--- a/tests/test_error_codes.py
+++ b/tests/test_error_codes.py
@@ -18,6 +18,20 @@
             400,
             ErrorCode.SEARCH_INVALID_LIMIT,
         ),
+        (
+            "get",
+            "/api/search?q=",
+            {},
+            400,
+            ErrorCode.SEARCH_EMPTY_QUERY,
+        ),
+        (
+            "get",
+            "/api/search?q=test&since_days=foo",
+            {},
+            400,
+            ErrorCode.SEARCH_INVALID_SINCE_DAYS,
+        ),
         (
             "get",
             "/api/sessions/test-project/nonexistent",
diff --git a/tests/test_error_propagation.py b/tests/test_error_propagation.py
index 9ddaf5d..845946f 100644
--- a/tests/test_error_propagation.py
+++ b/tests/test_error_propagation.py
@@ -203,6 +203,25 @@ def _boom(*args, **kwargs):
         assert "internal_secret_field_id" not in json.dumps(body)
 
 
+# ---------------------------------------------------------------------------
+# GET /api/search
+# ---------------------------------------------------------------------------
+
+
+def test_search_internal_error_does_not_leak(client_single, monkeypatch):
+    def _boom(*_args, **_kwargs):
+        raise RuntimeError("internal_secret_search_token")
+
+    monkeypatch.setattr("api.search._search_via_index", lambda *_a, **_kw: (None, False))
+    monkeypatch.setattr("api.search._search_live_scan", _boom)
+
+    resp = client_single.get("/api/search?q=Hello&all_history=1")
+    assert resp.status_code == 500
+    body_text = json.dumps(resp.get_json())
+    _assert_no_class_name_leak(body_text)
+    assert "internal_secret_search_token" not in body_text
+
+
 # ---------------------------------------------------------------------------
 # Source-level guard
 # ---------------------------------------------------------------------------
diff --git a/tests/test_search.py b/tests/test_search.py
index 01c7816..801eaad 100644
--- a/tests/test_search.py
+++ b/tests/test_search.py
@@ -11,6 +11,7 @@
 from pathlib import Path
 from unittest.mock import patch
 
+from api.search import _index_hit_excluded
 from app import create_app
 from tests.conftest import FIXTURES, assert_error_response
 from utils.search_index import build_search_index, reset_background_for_tests
@@ -82,8 +83,57 @@ def test_limit_negative(client_single):
 
 def test_empty_query(client_single):
     resp = client_single.get("/api/search?q=")
+    assert resp.status_code == 400
+    assert_error_response(resp, expected_code="SEARCH_EMPTY_QUERY")
+
+
+def test_query_too_long(client_single):
+    resp = client_single.get(f"/api/search?q={'x' * 501}")
+    assert resp.status_code == 400
+    assert_error_response(resp, expected_code="SEARCH_QUERY_TOO_LONG")
+
+
+def test_invalid_since_days(client_single):
+    resp = client_single.get("/api/search?q=Hello&since_days=foo")
+    assert resp.status_code == 400
+    assert_error_response(resp, expected_code="SEARCH_INVALID_SINCE_DAYS")
+
+
+def test_invalid_since_days_zero(client_single):
+    resp = client_single.get("/api/search?q=Hello&since_days=0")
+    assert resp.status_code == 400
+    assert_error_response(resp, expected_code="SEARCH_INVALID_SINCE_DAYS")
+
+
+def test_projects_unavailable(client_single, monkeypatch):
+    monkeypatch.setattr("api.search._projects_dir_inaccessible", lambda _path: True)
+    resp = client_single.get("/api/search?q=Hello")
+    assert resp.status_code == 503
+    assert_error_response(resp, expected_code="SEARCH_PROJECTS_UNAVAILABLE")
+
+
+def test_missing_projects_dir_is_not_unavailable(client_single, monkeypatch):
+    monkeypatch.setattr("api.search._projects_dir_inaccessible", lambda _path: False)
+    resp = client_single.get("/api/search?q=Hello")
     assert resp.status_code == 200
-    assert resp.get_json() == []
+
+
+def test_index_lock_falls_back_to_live_scan(tmp_path, monkeypatch):
+    recent_ts = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+    client = _seed_indexed_client(tmp_path, monkeypatch, timestamp=recent_ts)
+    with patch(
+        "api.search.query_index_hits",
+        return_value={
+            "hits": [],
+            "query_ok": True,
+            "sql_rows_fetched": 0,
+            "sql_exhausted": True,
+            "index_locked": True,
+        },
+    ):
+        resp = client.get("/api/search?q=Hello")
+    assert resp.status_code == 200
+    assert len(resp.get_json()) >= 1
 
 
 def _index_patches(cache_root: Path):
@@ -111,8 +161,7 @@ def _seed_indexed_client(tmp_path, monkeypatch, *, timestamp: str):
     with patches[0]:
         assert build_search_index(str(tmp_path / "projects"), [], force=True) is True
 
-    app = create_app(base_dir=str(tmp_path / "projects"))
-    app.config["TESTING"] = True
+    app = create_app(base_dir=str(tmp_path / "projects"), testing=True)
     return app.test_client()
 
 
@@ -142,6 +191,36 @@ def test_search_uses_index_when_usable(tmp_path, monkeypatch):
     assert len(resp.get_json()) >= 1
 
 
+def test_index_hit_excluded_fails_closed_when_session_unreadable():
+    rules = [[("word", "secret")]]
+    with (
+        patch("api.search.get_summary", return_value=None),
+        patch("api.search.get_cached_session", side_effect=OSError("unreadable")),
+    ):
+        assert _index_hit_excluded(
+            rules,
+            "rules-fp",
+            project_name="demo",
+            file_path="/tmp/session.jsonl",
+            mtime=1.0,
+        )
+
+
+def test_search_falls_back_on_tokenless_query(tmp_path, monkeypatch):
+    recent_ts = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+    client = _seed_indexed_client(tmp_path, monkeypatch, timestamp=recent_ts)
+    seen: list[bool] = []
+
+    def _fake_live_scan(*_args, **_kwargs):
+        seen.append(True)
+        return []
+
+    with patch("api.search._search_live_scan", side_effect=_fake_live_scan):
+        resp = client.get("/api/search?q=!!!")
+    assert resp.status_code == 200
+    assert seen == [True]
+
+
 def test_search_falls_back_when_index_query_fails(tmp_path, monkeypatch):
     recent_ts = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
     client = _seed_indexed_client(tmp_path, monkeypatch, timestamp=recent_ts)
@@ -152,6 +231,7 @@ def test_search_falls_back_when_index_query_fails(tmp_path, monkeypatch):
             "query_ok": False,
             "sql_rows_fetched": 0,
             "sql_exhausted": True,
+            "index_locked": False,
         },
     ):
         resp = client.get("/api/search?q=Hello")
diff --git a/tests/test_search_index.py b/tests/test_search_index.py
index 09af796..2a4efaa 100644
--- a/tests/test_search_index.py
+++ b/tests/test_search_index.py
@@ -11,7 +11,8 @@
 
 import pytest
 
-from api.search import _search_via_index
+from api.search import _resolve_search_results, _search_via_index
+from utils.exclusion_rules import load_rules
 from utils.search_index import (
     build_search_index,
     index_is_usable,
@@ -314,7 +315,7 @@ def test_phrase_filter_paginates_past_decoy_token_matches(self, tmp_path, monkey
         patches = _index_patches(cache_root)
         with patches[0]:
             build_search_index(str(projects), [], force=True)
-            results = _search_via_index(
+            results, _fts_exhausted = _search_via_index(
                 str(projects),
                 [],
                 phrase,
@@ -350,6 +351,13 @@ def close(self) -> None:
             assert result["query_ok"] is False
             assert result["hits"] == []
 
+    def test_tokenless_query_is_not_index_ok(self, indexed_tree):
+        patches = _index_patches(indexed_tree["cache_root"])
+        with patches[0]:
+            result = query_index_hits("!!!", since_ms=None, max_results=5)
+            assert result["query_ok"] is False
+            assert result["hits"] == []
+
 
 class TestBypassAndBackground:
     def test_no_search_index_env_disables_index(self, indexed_tree, monkeypatch):
@@ -379,6 +387,130 @@ def test_background_worker_starts_once(self, indexed_tree, monkeypatch):
             assert mock_thread.return_value.start.call_count == 1
 
 
+class TestIndexSearchCompleteness:
+    def test_partial_batch_not_marked_exhausted(self, tmp_path, monkeypatch):
+        """sql_exhausted stays false until every row in the SQL batch is scanned."""
+        cache_root = tmp_path / "cache"
+        cache_root.mkdir()
+        projects = tmp_path / "projects"
+        lines: list[dict[str, object]] = []
+        for i in range(120):
+            lines.append(
+                {
+                    "type": "user",
+                    "timestamp": f"2026-07-{(i % 28) + 1:02d}T10:00:00Z",
+                    "message": {
+                        "content": [{"type": "text", "text": f"batch sentinel token {i}"}],
+                    },
+                }
+            )
+        _write_session(projects / "batch-proj" / "session.jsonl", lines)
+        monkeypatch.setenv("CLAUDE_CODE_CHAT_BROWSER_SEARCH_INDEX_DIR", str(cache_root))
+        patches = _index_patches(cache_root)
+        with patches[0]:
+            build_search_index(str(projects), [], force=True)
+            result = query_index_hits(
+                "batch sentinel token",
+                since_ms=None,
+                max_results=50,
+                sql_offset=0,
+            )
+            assert result["query_ok"] is True
+            assert len(result["hits"]) == 50
+            assert result["sql_rows_fetched"] < 120
+            assert result["sql_exhausted"] is False
+
+    def test_index_search_fills_limit_after_excluded_hits(self, tmp_path, monkeypatch):
+        cache_root = tmp_path / "cache"
+        cache_root.mkdir()
+        projects = tmp_path / "projects"
+        term = "quota-fill-sentinel"
+        excl_lines: list[dict[str, object]] = []
+        for i in range(80):
+            excl_lines.append(
+                {
+                    "type": "user",
+                    "timestamp": f"2026-08-{(i % 28) + 1:02d}T10:00:00Z",
+                    "message": {"content": [{"type": "text", "text": f"{term} excluded"}]},
+                }
+            )
+        good_lines: list[dict[str, object]] = []
+        for i in range(60):
+            good_lines.append(
+                {
+                    "type": "user",
+                    "timestamp": f"2026-05-{(i % 28) + 1:02d}T10:00:00Z",
+                    "message": {"content": [{"type": "text", "text": f"{term} good"}]},
+                }
+            )
+        _write_session(projects / "excl-proj" / "session.jsonl", excl_lines)
+        _write_session(projects / "good-proj" / "session.jsonl", good_lines)
+        rules_path = tmp_path / "rules.txt"
+        rules_path.write_text("excl-proj\n", encoding="utf-8")
+        rules = load_rules(str(rules_path))
+
+        monkeypatch.setenv("CLAUDE_CODE_CHAT_BROWSER_SEARCH_INDEX_DIR", str(cache_root))
+        patches = _index_patches(cache_root)
+        with patches[0]:
+            build_search_index(str(projects), rules, force=True)
+            results, _fts_exhausted = _search_via_index(
+                str(projects),
+                rules,
+                term,
+                term.lower(),
+                since_ms=None,
+                max_results=50,
+            )
+            assert results is not None
+            assert len(results) == 50
+            assert all(hit["project"] == "good-proj" for hit in results)
+
+    def test_system_content_index_and_live_scan_parity(self, tmp_path, monkeypatch):
+        cache_root = tmp_path / "cache"
+        cache_root.mkdir()
+        projects = tmp_path / "projects"
+        sentinel = "system-role-sentinel-xyz"
+        _write_session(
+            projects / "sys-proj" / "session.jsonl",
+            [
+                {
+                    "type": "user",
+                    "timestamp": "2026-06-01T10:00:00Z",
+                    "message": {"content": [{"type": "text", "text": "hello"}]},
+                },
+                {
+                    "type": "system",
+                    "timestamp": "2026-06-01T10:00:01Z",
+                    "content": f"compact boundary note {sentinel}",
+                },
+                {
+                    "type": "assistant",
+                    "timestamp": "2026-06-01T10:00:02Z",
+                    "message": {"content": [{"type": "text", "text": "ack"}]},
+                },
+            ],
+        )
+        monkeypatch.setenv("CLAUDE_CODE_CHAT_BROWSER_SEARCH_INDEX_DIR", str(cache_root))
+        patches = _index_patches(cache_root)
+        with patches[0]:
+            build_search_index(str(projects), [], force=True)
+            indexed = query_index_hits(sentinel, since_ms=None, max_results=5)
+            assert indexed["query_ok"] is True
+            assert len(indexed["hits"]) == 1
+            assert indexed["hits"][0]["role"] == "system"
+
+            resolved = _resolve_search_results(
+                str(projects),
+                [],
+                sentinel,
+                sentinel.lower(),
+                since_ms=None,
+                max_results=5,
+            )
+            assert len(resolved) == 1
+            assert resolved[0]["role"] == "system"
+
+
 class TestResolveSearchSinceMs:
     def test_all_history_none(self):
         assert resolve_search_since_ms(all_history=True) is None
diff --git a/utils/search_index.py b/utils/search_index.py
index 9ddf0b8..5e74f7e 100644
--- a/utils/search_index.py
+++ b/utils/search_index.py
@@ -14,6 +14,7 @@
 import os
 import re
 import sqlite3
+import sys
 import threading
 import time
 import uuid
@@ -23,7 +24,7 @@
 from pathlib import Path
 from typing import Any, TypedDict
 
-from models.session import RoleLiteral
+from models.session import MessageDict, RoleLiteral
 from utils.jsonl_helpers import entry_message, extract_text, first_title_line
 from utils.session_path import list_projects, list_sessions
 from utils.session_summary_cache import rules_fingerprint
@@ -36,6 +37,7 @@
     "ensure_search_index",
     "index_is_usable",
     "index_search_enabled",
+    "message_searchable_text",
     "query_index_hits",
     "resolve_search_since_ms",
     "search_snippet",
@@ -55,6 +57,7 @@
 _index_lock = threading.Lock()
 _index_build_lock = threading.Lock()
 _background_started = False
+_background_lock_fd: int | None = None
 _usability_cache: dict[tuple[str, str], tuple[bool, float]] = {}
 _usability_cache_lock = threading.Lock()
 _USABILITY_CACHE_TTL_SECONDS = 30.0
@@ -77,6 +80,7 @@ class IndexQueryResult(TypedDict):
     query_ok: bool
     sql_rows_fetched: int
     sql_exhausted: bool
+    index_locked: bool
 
 
 def cache_dir() -> Path:
@@ -338,12 +342,51 @@ def tool_result_searchable_text(raw: object) -> str:
     return "\n".join(parts)
 
 
+def progress_searchable_text(raw: object) -> str:
+    if not isinstance(raw, dict):
+        return ""
+    output = raw.get("output")
+    return output if isinstance(output, str) and output.strip() else ""
+
+
+def combine_searchable_text(
+    *,
+    text: str = "",
+    content: str = "",
+    tool_result: object = None,
+    progress_data: object = None,
+) -> str:
+    """Merge searchable fields the same way for index build and live scan."""
+    merged = text if isinstance(text, str) else ""
+    if not merged and isinstance(content, str):
+        merged = content
+    tool_text = tool_result_searchable_text(tool_result) if tool_result is not None else ""
+    if tool_text:
+        merged = f"{merged}\n{tool_text}" if merged else tool_text
+    progress_text = progress_searchable_text(progress_data)
+    if progress_text:
+        merged = f"{merged}\n{progress_text}" if merged else progress_text
+    return merged
+
+
+def message_searchable_text(msg: MessageDict) -> str:
+    """Searchable text for one parsed session message (live-scan path)."""
+    text = msg.get("text", "") or msg.get("content", "")
+    if not isinstance(text, str):
+        text = ""
+    return combine_searchable_text(
+        text=text,
+        tool_result=msg.get("tool_result"),
+        progress_data=msg.get("data") if msg.get("role") == "progress" else None,
+    )
+
+
 def _coerce_role(entry_type: str | None) -> RoleLiteral | None:
-    if entry_type == "user":
-        return "user"
-    if entry_type == "assistant":
-        return "assistant"
-    return None
+    if entry_type in ("user", "assistant", "system", "progress"):
+        return entry_type  # type: ignore[return-value]
+    if entry_type is None:
+        return None
+    return "system"
 
 
 def _indexable_texts_from_entry(
@@ -359,22 +402,41 @@ def _indexable_texts_from_entry(
     ts = timestamp if isinstance(timestamp, str) else None
     texts: list[tuple[str, str | None, RoleLiteral]] = []
 
-    if role is not None:
+    if entry_type == "user":
         msg = entry_message(entry)
-        content = msg.get("content", [])
-        text = extract_text(content)
-        if isinstance(text, str) and text.strip():
-            texts.append((text, ts, role))
+        text = combine_searchable_text(
+            text=extract_text(msg.get("content", [])),
+            tool_result=entry.get("toolUseResult"),
+        )
+        if text:
+            texts.append((text, ts, "user"))
+        return texts
 
-    if entry_type == "user":
-        tool_text = tool_result_searchable_text(entry.get("toolUseResult"))
-        if tool_text:
-            texts.append((tool_text, ts, "user"))
+    if entry_type == "assistant":
+        msg = entry_message(entry)
+        text = combine_searchable_text(text=extract_text(msg.get("content", [])))
+        if text:
+            texts.append((text, ts, "assistant"))
+        return texts
 
-    if not texts and role is not None:
+    if entry_type == "system":
         raw_content = entry.get("content", "")
-        if isinstance(raw_content, str) and raw_content.strip():
-            texts.append((raw_content, ts, role))
+        content = raw_content if isinstance(raw_content, str) else ""
+        text = combine_searchable_text(content=content)
+        if text:
+            texts.append((text, ts, "system"))
+        return texts
+
+    if entry_type == "progress":
+        text = combine_searchable_text(progress_data=entry.get("data"))
+        if text:
+            texts.append((text, ts, "progress"))
+        return texts
+
+    if role is not None:
+        text = combine_searchable_text(content=entry.get("content", ""))
+        if text:
+            texts.append((text, ts, role))
 
     return texts
 
@@ -556,6 +618,31 @@ def ensure_search_index(projects_dir: str, rules: list[Any]) -> None:
             build_search_index(projects_dir, rules)
 
 
+def _try_acquire_cross_process_background_lock() -> bool:
+    """Return True when this process should own the background index worker."""
+    global _background_lock_fd
+    if _background_lock_fd is not None:
+        return True
+    root = cache_dir()
+    root.mkdir(parents=True, exist_ok=True)
+    lock_path = root / "search_index.background.lock"
+    fd = os.open(str(lock_path), os.O_CREAT | os.O_RDWR)
+    try:
+        if sys.platform == "win32":
+            import msvcrt
+
+            msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except (OSError, BlockingIOError):
+        os.close(fd)
+        return False
+    _background_lock_fd = fd
+    return True
+
+
 def start_search_index_background(
     projects_dir: str,
     rules: list[Any],
@@ -569,6 +656,8 @@ def start_search_index_background(
     with _index_lock:
         if _background_started:
             return
+        if not _try_acquire_cross_process_background_lock():
+            return
         _background_started = True
 
     def _worker() -> None:
@@ -616,23 +705,35 @@ def query_index_hits(
     sql_offset: int = 0,
 ) -> IndexQueryResult:
     """Return message hits from the FTS index (pre-exclusion, pre-snippet)."""
-    empty: IndexQueryResult = {
-        "hits": [],
-        "query_ok": True,
-        "sql_rows_fetched": 0,
-        "sql_exhausted": True,
-    }
     if not query_lower or not index_search_enabled():
-        return {"hits": [], "query_ok": False, "sql_rows_fetched": 0, "sql_exhausted": True}
+        return {
+            "hits": [],
+            "query_ok": False,
+            "sql_rows_fetched": 0,
+            "sql_exhausted": True,
+            "index_locked": False,
+        }
 
     fts_q = _fts_match_query(query_lower)
     if not fts_q:
-        return empty
+        return {
+            "hits": [],
+            "query_ok": False,
+            "sql_rows_fetched": 0,
+            "sql_exhausted": True,
+            "index_locked": False,
+        }
 
     sql_limit = max(max_results, _FTS_BATCH_SIZE)
     with _index_db_conn(readonly=True) as conn:
         if conn is None:
-            return {"hits": [], "query_ok": False, "sql_rows_fetched": 0, "sql_exhausted": True}
+            return {
+                "hits": [],
+                "query_ok": False,
+                "sql_rows_fetched": 0,
+                "sql_exhausted": True,
+                "index_locked": False,
+            }
         try:
             rows = conn.execute(
                 "SELECT m.session_id, m.project_name, m.role, m.timestamp_ms, m.text,"
@@ -645,9 +746,24 @@ def query_index_hits(
                 " LIMIT ? OFFSET ?",
                 (fts_q, sql_limit, sql_offset),
             ).fetchall()
+        except sqlite3.OperationalError as exc:
+            _logger.debug("FTS query locked (%s); index may be rebuilding", exc)
+            return {
+                "hits": [],
+                "query_ok": False,
+                "sql_rows_fetched": 0,
+                "sql_exhausted": True,
+                "index_locked": True,
+            }
         except sqlite3.Error as exc:
             _logger.debug("FTS query failed (%s); index may be rebuilding", exc)
-            return {"hits": [], "query_ok": False, "sql_rows_fetched": 0, "sql_exhausted": True}
+            return {
+                "hits": [],
+                "query_ok": False,
+                "sql_rows_fetched": 0,
+                "sql_exhausted": True,
+                "index_locked": False,
+            }
 
     hits: list[IndexMessageHitDict] = []
     rows_scanned = 0
@@ -673,17 +789,25 @@ def query_index_hits(
         )
         if len(hits) >= max_results:
             break
+    batch_fully_scanned = rows_scanned == len(rows)
     return {
         "hits": hits,
         "query_ok": True,
         "sql_rows_fetched": rows_scanned,
-        "sql_exhausted": len(rows) < sql_limit,
+        "sql_exhausted": batch_fully_scanned and len(rows) < sql_limit,
+        "index_locked": False,
     }
 
 
 def reset_background_for_tests() -> None:
     """Allow tests to restart the background worker."""
-    global _background_started
+    global _background_started, _background_lock_fd
     with _index_lock:
         _background_started = False
+        if _background_lock_fd is not None:
+            try:
+                os.close(_background_lock_fd)
+            except OSError:
+                pass
+            _background_lock_fd = None
     _clear_usability_cache()