rv-bible-cli 0.1.7 → 0.1.8

package/README.md

@@ -123,6 +123,7 @@ When you read a chapter in a terminal, rvb opens a full-screen interactive reade
 | `d` | enter study mode |
 | `c` | enter copy mode |
 | `/` | find text in current chapter |
+| `?` | search the whole Bible — type a query, browse results, Enter opens |
 | `:` | jump to any book — type `rom 8`, `jn 3`, etc. |
 | `[` / `]` | go back / forward (like browser history) |
 | `H` | go to home screen |

package/dist/ui/Pager.js

@@ -3,7 +3,7 @@ import { useState, useMemo, useEffect, useCallback, useRef } from 'react';
 import { render, Box, Text, useInput, useApp, useStdout } from 'ink';
 import chalk from 'chalk';
 import clipboard from 'clipboardy';
-import { getVersesByRef, getSectionHeaders, getFootnotesForChapter, getFootnotesForVerses, getCrossRefsForVerse, getBookInfo, getAllBooks, } from '../db.js';
+import { getVersesByRef, getSectionHeaders, getFootnotesForChapter, getFootnotesForVerses, getCrossRefsForVerse, getBookInfo, getAllBooks, isInConcordance, getTopicVerses, searchFTS, } from '../db.js';
 import { renderVerses, stripMarkers, highlightTerms, toSuperscript, wrapWords, zoomIn, zoomOut, zoomReset, getZoom, getMargin } from '../format.js';
 import { saveLastRead, getLastRead } from '../state.js';
 import { resolveBook } from '../parser.js';
@@ -139,11 +139,17 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
     // Copy mode state
     const [cursorIdx, setCursorIdx] = useState(0);
     const [selStart, setSelStart] = useState(null);
-    // Search mode state
-    const [searchQuery, setSearchQuery] = useState('');
-    const [searchSubmitted, setSearchSubmitted] = useState(false);
-    const [searchMatches, setSearchMatches] = useState([]);
-    const [matchIdx, setMatchIdx] = useState(0);
+    // Find-in-chapter mode state (the `/` modal)
+    const [findQuery, setFindQuery] = useState('');
+    const [findSubmitted, setFindSubmitted] = useState(false);
+    const [findMatches, setFindMatches] = useState([]);
+    const [findIdx, setFindIdx] = useState(0);
+    // Global search session state (the `?` modal — full Bible search)
+    const [gsearchInput, setGsearchInput] = useState('');
+    const [gsearchSession, setGsearchSession] = useState(null);
+    // Holds the search terms to highlight in the next-rendered chapter (consumed by
+    // a useEffect once `lines` rebuilds). Array so multi-term queries highlight all words.
+    const pendingFindTermsRef = useRef(null);
     // Goto mode state
     const [gotoInput, setGotoInput] = useState('');
     // Navigation history: back/forward stacks (refs so useInput always sees latest)
@@ -328,38 +334,69 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
         setScrollOffset(target);
     }, [studyCursorIdx, viewportH, mode, verseMap, overscrollLimit]);
     // ── Search highlights ────────────────────────────────────────────────────
+    // Highlights every space-separated token in findQuery (so multi-term gsearch
+    // results like "only begotten" light up both words). For pure single-word find,
+    // this collapses to the original single-term behavior.
     const displayLines = useMemo(() => {
-        if (!searchSubmitted || searchMatches.length === 0)
+        if (!findSubmitted || findMatches.length === 0)
             return lines;
-        const q = searchQuery.toLowerCase();
+        const queryTerms = findQuery.split(/\s+/).filter(Boolean);
+        if (queryTerms.length === 0)
+            return lines;
+        const lowers = queryTerms.map(t => t.toLowerCase());
         return lines.map((line) => {
             const stripped = stripAnsi(line);
-            if (!stripped.toLowerCase().includes(q))
+            const lower = stripped.toLowerCase();
+            if (!lowers.some(l => lower.includes(l)))
                 return line;
-            return highlightTerms(stripped, [searchQuery]);
+            return highlightTerms(stripped, queryTerms);
         });
-    }, [lines, searchSubmitted, searchMatches, searchQuery]);
+    }, [lines, findSubmitted, findMatches, findQuery]);
     // ── Navigation helpers ───────────────────────────────────────────────────
     const restoreMode = useCallback(() => {
         setMode(studyActiveRef.current ? 'study' : 'normal');
-        setSearchSubmitted(false);
-        setSearchQuery('');
-        setSearchMatches([]);
+        setFindSubmitted(false);
+        setFindQuery('');
+        setFindMatches([]);
         setStudyRefInput('');
         setStudyCursorIdx(0);
     }, []);
     const navigate = useCallback((newBook, newChapter, pushHistory = true) => {
         const sameChapter = newBook === bookRef.current && newChapter === chapterRef.current;
-        // Same-chapter cross-ref follow: jump cursor directly. Don't reset state via
-        // restoreMode (would clobber cursor to 0), don't push to history (cursor isn't tracked there).
+        // Same-chapter target: jump cursor (study) or scroll (normal) directly without
+        // re-rendering the chapter. Exits any modal mode (gsearch-list, etc.) via restoreMode.
         if (sameChapter && pendingVerseRef.current) {
             const target = pendingVerseRef.current;
             pendingVerseRef.current = null;
             let idx = verseMap.findIndex(e => e.verse === target);
             if (idx < 0)
                 idx = verseMap.findIndex(e => e.verse.startsWith(target));
-            if (idx >= 0)
-                setStudyCursorIdx(idx);
+            if (idx >= 0) {
+                const entry = verseMap[idx];
+                if (studyActiveRef.current) {
+                    setStudyCursorIdx(idx);
+                }
+                else {
+                    setScrollOffset(Math.max(0, entry.startLine - 2));
+                }
+            }
+            // Highlight pending terms in current chapter (no new `lines` to trigger the effect).
+            const terms = pendingFindTermsRef.current;
+            if (terms && terms.length > 0) {
+                pendingFindTermsRef.current = null;
+                const lowers = terms.map(t => t.toLowerCase());
+                const matches = [];
+                for (let i = 0; i < lines.length; i++) {
+                    const lower = stripAnsi(lines[i]).toLowerCase();
+                    if (lowers.some(l => lower.includes(l)))
+                        matches.push(i);
+                }
+                setFindQuery(terms.join(' '));
+                setFindMatches(matches);
+                setFindSubmitted(true);
+                setFindIdx(0);
+            }
+            setMode(studyActiveRef.current ? 'study' : 'normal');
             saveLastRead(newBook, newChapter);
             return;
         }
@@ -372,7 +409,7 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
         setScrollOffset(0);
         restoreMode();
         saveLastRead(newBook, newChapter);
-    }, [restoreMode, verseMap]);
+    }, [restoreMode, verseMap, lines]);
     const goBack = useCallback(() => {
         const hist = historyRef.current;
         if (hist.length === 0)
@@ -440,35 +477,149 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
         setSelStart(null);
     }, [selStart, cursorIdx, verses, bookName, chapter]);
     // ── Search helpers ───────────────────────────────────────────────────────
-    const submitSearch = useCallback(() => {
-        if (!searchQuery)
+    const submitFind = useCallback(() => {
+        if (!findQuery)
+            return;
+        const queryTerms = findQuery.split(/\s+/).filter(Boolean);
+        if (queryTerms.length === 0)
             return;
-        const q = searchQuery.toLowerCase();
+        const lowers = queryTerms.map(t => t.toLowerCase());
         const matches = [];
         for (let i = 0; i < lines.length; i++) {
-            if (stripAnsi(lines[i]).toLowerCase().includes(q))
+            const lower = stripAnsi(lines[i]).toLowerCase();
+            if (lowers.some(l => lower.includes(l)))
                 matches.push(i);
         }
-        setSearchMatches(matches);
-        setSearchSubmitted(true);
-        setMatchIdx(0);
+        setFindMatches(matches);
+        setFindSubmitted(true);
+        setFindIdx(0);
         if (matches.length > 0)
             scrollTo(matches[0]);
-    }, [searchQuery, lines, scrollTo]);
-    const nextMatch = useCallback(() => {
-        if (searchMatches.length === 0)
+    }, [findQuery, lines, scrollTo]);
+    const nextFindMatch = useCallback(() => {
+        if (findMatches.length === 0)
             return;
-        const next = (matchIdx + 1) % searchMatches.length;
-        setMatchIdx(next);
-        scrollTo(searchMatches[next]);
-    }, [matchIdx, searchMatches, scrollTo]);
-    const prevMatch = useCallback(() => {
-        if (searchMatches.length === 0)
+        const next = (findIdx + 1) % findMatches.length;
+        setFindIdx(next);
+        scrollTo(findMatches[next]);
+    }, [findIdx, findMatches, scrollTo]);
+    const prevFindMatch = useCallback(() => {
+        if (findMatches.length === 0)
             return;
-        const prev = (matchIdx - 1 + searchMatches.length) % searchMatches.length;
-        setMatchIdx(prev);
-        scrollTo(searchMatches[prev]);
-    }, [matchIdx, searchMatches, scrollTo]);
+        const prev = (findIdx - 1 + findMatches.length) % findMatches.length;
+        setFindIdx(prev);
+        scrollTo(findMatches[prev]);
+    }, [findIdx, findMatches, scrollTo]);
+    // ── Global search helpers (the `?` modal — full Bible search) ─────────────
+    // Page size for paginating results in the gsearch-list view (←/→ to page).
+    const GSEARCH_PAGE_SIZE = 100;
+    // Parse "in <book>" scope from tokens (mirrors CLI parseScope behavior)
+    const parseGsearchScope = useCallback((tokens) => {
+        for (let nameLen = 3; nameLen >= 1; nameLen--) {
+            const inIdx = tokens.length - nameLen - 1;
+            if (inIdx < 1)
+                continue;
+            if (tokens[inIdx]?.toLowerCase() !== 'in')
+                continue;
+            const resolved = resolveBook(tokens.slice(inIdx + 1, inIdx + 1 + nameLen).join(' '));
+            if (resolved)
+                return { queryTokens: tokens.slice(0, inIdx), book: resolved };
+        }
+        return { queryTokens: tokens, book: undefined };
+    }, []);
+    // Run the search. Single known concordance word → concordance, else FTS LIKE.
+    // Returns ALL results — pagination happens at render time (GSEARCH_PAGE_SIZE per page).
+    const executeGsearch = useCallback((rawInput) => {
+        const trimmed = rawInput.trim();
+        if (!trimmed)
+            return null;
+        const tokens = trimmed.split(/\s+/);
+        const { queryTokens, book: scopeBook } = parseGsearchScope(tokens);
+        if (queryTokens.length === 0)
+            return null;
+        const word = queryTokens.join(' ');
+        let results;
+        let terms;
+        if (queryTokens.length === 1 && isInConcordance(word)) {
+            results = getTopicVerses(word, scopeBook);
+            terms = [word];
+        }
+        else {
+            const ftsQuery = queryTokens.length === 1
+                ? `"${queryTokens[0].replace(/"/g, '')}"`
+                : queryTokens.map(t => `"${t.replace(/"/g, '')}"`).join(' AND ');
+            results = searchFTS(ftsQuery, scopeBook);
+            terms = queryTokens.map(t => t.replace(/"/g, '').trim()).filter(Boolean);
+        }
+        return { query: trimmed, results, terms, cursor: 0, pageIdx: 0 };
+    }, [parseGsearchScope]);
+    // Build the rendered result list lines + per-result line ranges (for cursor scroll).
+    // Renders only the current page (GSEARCH_PAGE_SIZE results); the cursor index in
+    // the session is page-local, so itemMap aligns directly.
+    const gsearchListData = useMemo(() => {
+        if (!gsearchSession)
+            return null;
+        const { results, terms, cursor, pageIdx } = gsearchSession;
+        const start = pageIdx * GSEARCH_PAGE_SIZE;
+        const pageResults = results.slice(start, start + GSEARCH_PAGE_SIZE);
+        const renderLines = [];
+        const itemMap = [];
+        const wrapWidth = Math.max(40, Math.min(cols - 10, 90));
+        pageResults.forEach((v, i) => {
+            const startLine = renderLines.length;
+            const bn = getBookInfo(v.book)?.full_name ?? v.book;
+            const ref = `${bn} ${v.chapter}:${v.verse}`;
+            const cleanText = stripMarkers(v.text);
+            const highlighted = highlightTerms(cleanText, terms);
+            const wrapped = wrapWords(highlighted, wrapWidth, true);
+            const mark = i === cursor ? chalk.magenta('›') : ' ';
+            renderLines.push(`  ${mark} ${chalk.bold(ref)}`);
+            for (const wl of wrapped)
+                renderLines.push(`      ${wl}`);
+            const endLine = renderLines.length - 1;
+            renderLines.push(''); // blank separator
+            itemMap.push({ startLine, endLine });
+        });
+        return { lines: renderLines, itemMap, pageResults };
+    }, [gsearchSession, cols]);
+    // Center the cursor result in the list viewport (same pattern as study mode).
+    const gsearchScroll = useMemo(() => {
+        if (mode !== 'gsearch-list' || !gsearchSession || !gsearchListData)
+            return 0;
+        const item = gsearchListData.itemMap[gsearchSession.cursor];
+        if (!item)
+            return 0;
+        const itemH = item.endLine - item.startLine + 1;
+        let target;
+        if (itemH >= viewportH) {
+            target = item.startLine;
+        }
+        else {
+            const itemMid = item.startLine + Math.floor(itemH / 2);
+            target = itemMid - Math.floor(viewportH / 2);
+        }
+        return Math.max(0, Math.min(target, Math.max(0, gsearchListData.lines.length - 1)));
+    }, [mode, gsearchSession, gsearchListData, viewportH]);
+    // After navigate from a search result, highlight ALL search terms in the new chapter
+    // (piggybacks on the chapter-find code path so n/N cycling works too). Doesn't
+    // scroll — the pendingVerseRef effect already positioned the cursor on the picked verse.
+    useEffect(() => {
+        const terms = pendingFindTermsRef.current;
+        if (!terms || terms.length === 0 || lines.length === 0)
+            return;
+        pendingFindTermsRef.current = null;
+        const lowers = terms.map(t => t.toLowerCase());
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+            const lower = stripAnsi(lines[i]).toLowerCase();
+            if (lowers.some(l => lower.includes(l)))
+                matches.push(i);
+        }
+        setFindQuery(terms.join(' '));
+        setFindMatches(matches);
+        setFindSubmitted(true);
+        setFindIdx(0);
+    }, [lines]);
     // ── Goto helpers ─────────────────────────────────────────────────────────
     const submitGoto = useCallback(() => {
         const trimmed = gotoInput.trim();
@@ -557,8 +708,8 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
                 if (matches.length > 0) {
                     if (lower === lastLetterRef.current) {
                         // Same letter again: cycle to next match after current position
-                        const nextMatch = matches.find(m => m.i > homeIdx) ?? matches[0];
-                        setHomeIdx(nextMatch.i);
+                        const nextLetterMatch = matches.find(m => m.i > homeIdx) ?? matches[0];
+                        setHomeIdx(nextLetterMatch.i);
                     }
                     else {
                         setHomeIdx(matches[0].i);
@@ -608,35 +759,145 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
             }
             return;
         }
-        // ── Search mode ──────────────────────────────────────────────────────
-        if (mode === 'search') {
+        // ── Find-in-chapter mode (`/` modal) ────────────────────────────────
+        if (mode === 'find') {
             const returnMode = studyActiveRef.current ? 'study' : 'normal';
             if (key.escape) {
                 setMode(returnMode);
-                setSearchQuery('');
-                setSearchSubmitted(false);
-                setSearchMatches([]);
+                setFindQuery('');
+                setFindSubmitted(false);
+                setFindMatches([]);
                 return;
             }
             if (key.return) {
-                submitSearch();
+                submitFind();
                 setMode(returnMode);
                 return;
             }
             if (key.backspace || key.delete) {
-                setSearchQuery(prev => prev.slice(0, -1));
+                setFindQuery(prev => prev.slice(0, -1));
                 return;
             }
-            if (searchSubmitted && input === 'n') {
-                nextMatch();
+            if (findSubmitted && input === 'n') {
+                nextFindMatch();
                 return;
             }
-            if (searchSubmitted && input === 'N') {
-                prevMatch();
+            if (findSubmitted && input === 'N') {
+                prevFindMatch();
                 return;
             }
             if (input && !key.ctrl && !key.meta) {
-                setSearchQuery(prev => prev + input);
+                setFindQuery(prev => prev + input);
+            }
+            return;
+        }
+        // ── Global-search input mode (`?` modal — type query) ───────────────
+        if (mode === 'gsearch-input') {
+            const returnMode = studyActiveRef.current ? 'study' : 'normal';
+            if (key.escape) {
+                setMode(returnMode);
+                setGsearchInput('');
+                return;
+            }
+            if (key.return) {
+                const trimmed = gsearchInput.trim();
+                if (!trimmed)
+                    return;
+                // Same query as the live session → restore the cached list at last cursor.
+                if (gsearchSession && gsearchSession.query === trimmed) {
+                    setMode('gsearch-list');
+                    setGsearchInput('');
+                    return;
+                }
+                const session = executeGsearch(gsearchInput);
+                if (session) {
+                    setGsearchSession(session);
+                    setMode('gsearch-list');
+                }
+                else {
+                    // Empty results case still gets a session so the list shows "0 results".
+                    setGsearchSession({ query: trimmed, results: [], terms: trimmed.split(/\s+/), cursor: 0, pageIdx: 0 });
+                    setMode('gsearch-list');
+                }
+                setGsearchInput('');
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setGsearchInput(prev => prev.slice(0, -1));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setGsearchInput(prev => prev + input);
+            }
+            return;
+        }
+        // ── Global-search list mode (`?` modal — browse results) ────────────
+        if (mode === 'gsearch-list') {
+            if (!gsearchSession) {
+                setMode('normal');
+                return;
+            }
+            const totalResults = gsearchSession.results.length;
+            const pageCount = Math.max(1, Math.ceil(totalResults / GSEARCH_PAGE_SIZE));
+            const pageStart = gsearchSession.pageIdx * GSEARCH_PAGE_SIZE;
+            const pageEnd = Math.min(pageStart + GSEARCH_PAGE_SIZE, totalResults);
+            const pageLen = pageEnd - pageStart;
+            const returnMode = studyActiveRef.current ? 'study' : 'normal';
+            if (key.escape || input === 'q') {
+                setMode(returnMode);
+                return;
+            }
+            if (input === '?') {
+                setMode('gsearch-input');
+                setGsearchInput(gsearchSession.query);
+                return;
+            }
+            if (key.return) {
+                const v = gsearchSession.results[pageStart + gsearchSession.cursor];
+                if (v) {
+                    pendingVerseRef.current = v.verse;
+                    pendingFindTermsRef.current = gsearchSession.terms.length > 0 ? gsearchSession.terms : null;
+                    // navigate() calls restoreMode() which puts us back in normal/study.
+                    navigate(v.book, v.chapter);
+                }
+                return;
+            }
+            if (totalResults === 0)
+                return;
+            // Page navigation: ← prev page, → next page (cursor resets to top of new page).
+            if (key.leftArrow || input === 'h') {
+                if (gsearchSession.pageIdx > 0) {
+                    setGsearchSession(s => s ? { ...s, pageIdx: s.pageIdx - 1, cursor: 0 } : s);
+                }
+                return;
+            }
+            if (key.rightArrow || input === 'l') {
+                if (gsearchSession.pageIdx < pageCount - 1) {
+                    setGsearchSession(s => s ? { ...s, pageIdx: s.pageIdx + 1, cursor: 0 } : s);
+                }
+                return;
+            }
+            if (key.upArrow || input === 'k') {
+                setGsearchSession(s => s ? { ...s, cursor: Math.max(0, s.cursor - 1) } : s);
+                return;
+            }
+            if (key.downArrow || input === 'j') {
+                setGsearchSession(s => s ? { ...s, cursor: Math.min(pageLen - 1, s.cursor + 1) } : s);
+                return;
+            }
+            if (input === 'g') {
+                setGsearchSession(s => s ? { ...s, cursor: 0 } : s);
+                return;
+            }
+            if (input === 'G') {
+                setGsearchSession(s => s ? { ...s, cursor: Math.max(0, pageLen - 1) } : s);
+                return;
+            }
+            if (key.tab) {
+                const step = Math.max(1, Math.floor(pageLen / 4));
+                const dir = key.shift ? -1 : 1;
+                setGsearchSession(s => s ? { ...s, cursor: Math.max(0, Math.min(pageLen - 1, s.cursor + dir * step)) } : s);
+                return;
             }
             return;
         }
@@ -802,12 +1063,18 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
                 setGotoInput('');
                 return;
             }
-            // Search within chapter
+            // Find within chapter
             if (input === '/') {
-                setMode('search');
-                setSearchQuery('');
-                setSearchSubmitted(false);
-                setSearchMatches([]);
+                setMode('find');
+                setFindQuery('');
+                setFindSubmitted(false);
+                setFindMatches([]);
+                return;
+            }
+            // Global search (full Bible)
+            if (input === '?') {
+                setMode('gsearch-input');
+                setGsearchInput(gsearchSession?.query ?? '');
                 return;
             }
             return;
@@ -889,8 +1156,8 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
             return;
         }
         if (input === 'n' || key.rightArrow) {
-            if (searchSubmitted && searchMatches.length > 0) {
-                nextMatch();
+            if (findSubmitted && findMatches.length > 0) {
+                nextFindMatch();
             }
             else {
                 goNext();
@@ -898,7 +1165,7 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
             return;
         }
         if (input === 'N') {
-            prevMatch();
+            prevFindMatch();
             return;
         }
         if (input === 'p' || key.leftArrow) {
@@ -914,10 +1181,15 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
             return;
         }
         if (input === '/') {
-            setMode('search');
-            setSearchQuery('');
-            setSearchSubmitted(false);
-            setSearchMatches([]);
+            setMode('find');
+            setFindQuery('');
+            setFindSubmitted(false);
+            setFindMatches([]);
+            return;
+        }
+        if (input === '?') {
+            setMode('gsearch-input');
+            setGsearchInput(gsearchSession?.query ?? '');
             return;
         }
         if (input === 'c') {
@@ -1085,7 +1357,31 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
         }
         return line;
     }) : visibleSlice;
-    const content = contentLines.join('\n');
+    // Global-search list view replaces the chapter content slot.
+    let content;
+    if (mode === 'gsearch-list' && gsearchSession && gsearchListData) {
+        const slice = gsearchListData.lines.slice(gsearchScroll, gsearchScroll + viewportH);
+        while (slice.length < viewportH)
+            slice.push('');
+        if (gsearchSession.results.length === 0) {
+            // Empty-state: center "no results" text in the viewport
+            const msg = chalk.dim(`  No results for "${gsearchSession.query}"`);
+            const padTop = Math.max(0, Math.floor(viewportH / 2) - 1);
+            const out = [];
+            for (let i = 0; i < padTop; i++)
+                out.push('');
+            out.push(msg);
+            while (out.length < viewportH)
+                out.push('');
+            content = out.join('\n');
+        }
+        else {
+            content = slice.join('\n');
+        }
+    }
+    else {
+        content = contentLines.join('\n');
+    }
     // ── Header ───────────────────────────────────────────────────────────────
     const CATEGORY_LABELS = {
         Moses: 'Books of Moses', Israel: 'History of Israel', Poetry: 'Poetry & Wisdom',
@@ -1105,7 +1401,24 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
         ? `  ${title}  ${chalk.dim('·')}  ${chalk.dim(categoryLabel)}${zoomLabel}`
         : `  ${title}${zoomLabel}`;
     const headerPad = Math.max(1, cols - stripAnsi(titleLeft).length - position.length - 2);
-    const header = `${titleLeft}${' '.repeat(headerPad)}${chalk.dim(position)}`;
+    let header = `${titleLeft}${' '.repeat(headerPad)}${chalk.dim(position)}`;
+    // Override header for the global-search list view
+    if (mode === 'gsearch-list' && gsearchSession) {
+        const totalResults = gsearchSession.results.length;
+        const pageCount = Math.max(1, Math.ceil(totalResults / GSEARCH_PAGE_SIZE));
+        const pageStart = gsearchSession.pageIdx * GSEARCH_PAGE_SIZE;
+        const pageEnd = Math.min(pageStart + GSEARCH_PAGE_SIZE, totalResults);
+        const pageLen = pageEnd - pageStart;
+        const countLabel = totalResults === 0
+            ? 'no results'
+            : pageCount > 1
+                ? `page ${gsearchSession.pageIdx + 1}/${pageCount} · ${pageStart + 1}–${pageEnd} of ${totalResults}`
+                : `${totalResults} result${totalResults === 1 ? '' : 's'}`;
+        const gsTitleLeft = `  ${chalk.bold(`Search: "${gsearchSession.query}"`)}  ${chalk.dim('·')}  ${chalk.dim(countLabel)}`;
+        const gsPosition = pageLen > 0 ? `${gsearchSession.cursor + 1}/${pageLen}` : '';
+        const gsPad = Math.max(1, cols - stripAnsi(gsTitleLeft).length - gsPosition.length - 2);
+        header = `${gsTitleLeft}${' '.repeat(gsPad)}${chalk.dim(gsPosition)}`;
+    }
     // ── Footer (two lines for normal/study, one line for modal modes) ──────
     // Toggle indicator: cyan when active (state cue), magenta key + dim desc when off.
     const toggleHint = (on, key, desc) => on ? chalk.cyan(`${key} ${desc}`) : kb(key, desc);
@@ -1114,20 +1427,35 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
     if (flash) {
         footer1 = `  ${chalk.green(`✓ ${flash}`)}`;
     }
-    else if (mode === 'search') {
-        if (searchSubmitted) {
-            const countLabel = searchMatches.length === 0
+    else if (mode === 'find') {
+        if (findSubmitted) {
+            const countLabel = findMatches.length === 0
                 ? 'no matches'
-                : `match ${matchIdx + 1}/${searchMatches.length}`;
-            footer1 = `  / ${searchQuery}  ${chalk.dim(countLabel)}  ${[kb('n/N', 'cycle'), kb('Esc', 'clear')].join(FOOTER_SEP)}`;
+                : `match ${findIdx + 1}/${findMatches.length}`;
+            footer1 = `  / ${findQuery}  ${chalk.dim(countLabel)}  ${[kb('n/N', 'cycle'), kb('Esc', 'clear')].join(FOOTER_SEP)}`;
         }
         else {
-            footer1 = `  / ${searchQuery}${chalk.dim('_')}  ${[kb('Enter', 'search'), kb('Esc', 'cancel')].join(FOOTER_SEP)}`;
+            footer1 = `  / ${findQuery}${chalk.dim('_')}  ${[kb('Enter', 'find'), kb('Esc', 'cancel')].join(FOOTER_SEP)}`;
         }
     }
     else if (mode === 'goto') {
         footer1 = `  : ${gotoInput}${chalk.dim('_')}  ${chalk.dim('e.g. rom 8')}${FOOTER_SEP}${[kb('Enter', 'go'), kb('Esc', 'cancel')].join(FOOTER_SEP)}`;
     }
+    else if (mode === 'gsearch-input') {
+        footer1 = `  ? ${gsearchInput}${chalk.dim('_')}  ${chalk.dim('try grace · "only begotten" · grace in romans')}${FOOTER_SEP}${[kb('Enter', 'search'), kb('Esc', 'cancel')].join(FOOTER_SEP)}`;
+    }
+    else if (mode === 'gsearch-list') {
+        const showPageHint = gsearchSession ? gsearchSession.results.length > GSEARCH_PAGE_SIZE : false;
+        const listKeys = [
+            kb('↑↓', 'select'),
+            kb('Tab/⇧Tab', 'quarter'),
+            kb('g/G', 'first/last'),
+        ];
+        if (showPageHint)
+            listKeys.push(kb('←→', 'page'));
+        listKeys.push(kb('Enter', 'open'), kb('?', 'edit'), kb('Esc', 'back'));
+        footer1 = `  ${listKeys.join(FOOTER_SEP)}`;
+    }
     else if (mode === 'study') {
         const inputHint = studyRefInput ? ` ${chalk.yellow(studyRefInput)}${chalk.dim('_')}` : '';
         const rangeHint = studySelStart !== null ? chalk.dim(' (range)') : '';
@@ -1138,6 +1466,7 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
             toggleHint(notes, 'f', 'notes'),
             toggleHint(outline, 'o', 'outline'),
             kb('/', 'find'),
+            kb('?', 'search'),
         ].join(FOOTER_SEP)}`;
         const f2Parts = [
             kb('↑↓', 'verse'),
@@ -1168,6 +1497,7 @@ function Pager({ initialBook, initialChapter, initialNotes, initialOutline, star
             kb('d', 'study'),
             kb('c', 'copy'),
             kb('/', 'find'),
+            kb('?', 'search'),
         ].join(FOOTER_SEP)}`;
         footer2 = `  ${[
             kb('↑↓', 'scroll'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rv-bible-cli",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Fast, offline terminal Bible reader for the Recovery Version. Footnotes, cross-references, concordance search, interactive pager.",
   "type": "module",
   "main": "dist/index.js",