@lamemind/loom-deck 0.29.0 → 0.30.0

package/dist/cli.js

@@ -18,6 +18,7 @@ import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch,
 import { countArchivable, SCAN_INTERVAL_MS } from './archivable.js';
 import { assignListCapacity, detailCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { caretWindow, cut, cutParts, pad, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
+import { scanText, sliceLine, topForOffset, } from './text-search.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, progressText, writeTaskEdit, PRI_GLYPH, PRI_LABEL, PROG_GLYPH, } from './task-edit.js';
 import { loadView, saveView, viewFilePath } from './view-store.js';
@@ -665,6 +666,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const [sheet, setSheet] = useState(null);
     const [sheetTop, setSheetTop] = useState(0);
     const [sheetAction, setSheetAction] = useState(0);
+    // T91 — ricerca dentro il detail. `open` distingue i due modi in cui la si
+    // lascia: `esc` butta via ciò che il modale ha prodotto (`find` a null,
+    // evidenziazione via), `⏎` lo congela e restituisce il controllo allo strato
+    // sotto — campo chiuso, occorrenze ancora colorate, scroll dov'era. Senza il
+    // flag i due gesti collasserebbero su uno solo.
+    const [find, setFind] = useState(null);
+    const [occIdx, setOccIdx] = useState(0);
     // Dimensioni vive del terminale: sono l'input del budget d'altezza sotto.
     const { rows, columns } = useTerminalSize();
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
@@ -792,9 +800,32 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // 2 padding) = 8. Sottostimare tronca un carattere, sovrastimare manda a capo
     // una riga che il budget d'altezza non ha contato.
     const sheetWidth = Math.max(20, (columns || 80) - 8);
-    const sheetLines = useMemo(() => (sheet?.text ? wrapWithOffsets(sheet.text, sheetWidth).map((l) => l.text) : []), [sheet, sheetWidth]);
-    const sheetCap = detailCapacity(rows);
+    // Le righe conservano i propri offset invece di essere appiattite a stringa
+    // (T66 le buttava con `.map((l) => l.text)`): è ciò che rende
+    // l'evidenziazione un'intersezione di intervalli invece di un caso speciale
+    // per il match spezzato dall'a-capo.
+    const sheetLines = useMemo(() => (sheet?.text ? wrapWithOffsets(sheet.text, sheetWidth) : []), [sheet, sheetWidth]);
+    const sheetCap = detailCapacity(rows, find?.open === true);
     const sheetMaxTop = Math.max(0, sheetLines.length - sheetCap);
+    // Lo scan gira sulla STESSA stringa che si renderizza (`sheet.text`, già
+    // passata da `sanitize` in `loadTaskFileText`): una rilettura del file darebbe
+    // offset che indicizzano un documento diverso da quello a schermo, cioè
+    // un'evidenziazione spostata di N caratteri e nessun errore.
+    const findRes = useMemo(() => (find && sheet?.text ? scanText(sheet.text, find.q) : { occ: [], error: '' }), [find?.q, sheet]);
+    // L'indice si clampa qui invece di essere corretto a ogni `setOccIdx`: la
+    // lista si accorcia da sola mentre si digita, e un indice fuori range vivrebbe
+    // per il tempo di un render.
+    const occCur = findRes.occ.length > 0 ? Math.min(occIdx, findRes.occ.length - 1) : -1;
+    // Salto all'occorrenza corrente, centrata. Non dipende da `sheetTop`, quindi
+    // non si auto-rilancia; dipende da `sheetLines` e `sheetCap`, quindi un resize
+    // ricalcola la posizione senza toccare le occorrenze — che sono offset del
+    // sorgente e il resize non le sposta.
+    useEffect(() => {
+        const o = occCur >= 0 ? findRes.occ[occCur] : undefined;
+        if (!o)
+            return;
+        setSheetTop(topForOffset(sheetLines, o.start, sheetCap));
+    }, [findRes, occCur, sheetLines, sheetCap]);
     // T57 — righe del modale assegnazione: `null` (detach) in testa, poi le task
     // della VISTA corrente (D4 — filtri e sort inclusi, coerenza con ciò che si
     // stava leggendo a sinistra; le escluse restano contate nell'header).
@@ -954,16 +985,32 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         });
         setSheetTop(0);
         setSheetAction(0);
+        setFind(null);
+        setOccIdx(0);
         setNote('');
         setMode('detail');
     }
     function closeDetail() {
         setMode('normal');
         setSheet(null);
+        setFind(null);
     }
     function scrollDetail(delta) {
         setSheetTop((t) => Math.max(0, Math.min(sheetMaxTop, t + delta)));
     }
+    /** Modifica la query: l'insieme delle occorrenze cambia, quindi si riparte
+     *  dalla prima. Il movimento del caret NON passa di qui — sposta il cursore,
+     *  non i risultati. */
+    function editFind(next) {
+        setFind((f) => (f ? next(f) : f));
+        setOccIdx(0);
+    }
+    function moveOcc(d) {
+        const n = findRes.occ.length;
+        if (n === 0)
+            return;
+        setOccIdx((i) => (Math.min(i, n - 1) + d + n) % n);
+    }
     // T53 — apertura del modale nota sulla conversazione selezionata. Come
     // `openEdit`, la bozza parte dal valore ATTUALE: annotare una seconda volta è
     // quasi sempre correggere, e ripartire da vuoto costringerebbe a ridigitare
@@ -1551,10 +1598,62 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // È anche prima del ramo CTRL, quindi `^K`/`^P`/`^R` restano acceleratori
         // della sola lista: chi è già nel detail ha i bottoni.
         if (mode === 'detail') {
+            // T91 — modale DENTRO il modale, e sta prima per la stessa ragione per cui
+            // il detail sta prima del ramo CTRL: Ink non ha focus-trap, quindi la
+            // cattura È l'ordine dei rami. Mentre il campo è aperto mangia ogni lettera
+            // nuda, `g`/`G` compresi.
+            if (find?.open) {
+                if (key.escape) {
+                    // Annulla: butta via ciò che il modale ha prodotto. Lo scroll resta
+                    // dove la ricerca l'ha portato — riavvolgerlo sarebbe una terza
+                    // semantica che nessun tasto ha chiesto.
+                    setFind(null);
+                }
+                else if (key.return) {
+                    // Congela: campo chiuso, occorrenze ancora colorate, scroll intatto.
+                    setFind((f) => (f ? { ...f, open: false } : f));
+                }
+                else if (key.upArrow) {
+                    moveOcc(-1);
+                }
+                else if (key.downArrow) {
+                    moveOcc(1);
+                }
+                else if (key.leftArrow || key.rightArrow) {
+                    const d = key.leftArrow ? -1 : 1;
+                    setFind((f) => f ? { ...f, caret: Math.max(0, Math.min(cpLen(f.q), f.caret + d)) } : f);
+                }
+                else if (key.backspace || key.delete) {
+                    editFind((f) => f.caret > 0 ? { ...f, q: removeAt(f.q, f.caret - 1), caret: f.caret - 1 } : f);
+                }
+                else if (key.ctrl) {
+                    // `^U` svuota, come il filtro del modale assegnazione; ogni altra combo
+                    // è no-op — `^F` incluso, siamo già dentro.
+                    if (input === 'u')
+                        editFind((f) => ({ ...f, q: '', caret: 0 }));
+                }
+                else if (input && !key.meta) {
+                    const ins = sanitizeTyped(input);
+                    editFind((f) => ({ ...f, q: insertAt(f.q, f.caret, ins), caret: f.caret + cpLen(ins) }));
+                }
+                return;
+            }
+            if (key.ctrl && input === 'f') {
+                // Fuori dal detail `^F` è la ricerca conversazioni; qui è la ricerca nel
+                // testo. La query sopravvive a una chiusura con `⏎`, quindi riaprire
+                // riprende da dov'era invece di ricominciare.
+                setFind((f) => (f ? { ...f, open: true } : { q: '', caret: 0, open: true }));
+                return;
+            }
             if (key.escape) {
+                // Uno strato alla volta: se resta un'evidenziazione congelata, `esc`
+                // smonta quella; il detail lo chiude il secondo.
                 // Nessun reset di `sel`: la selezione della lista non è mai stata
                 // toccata, quindi si ritrova esattamente dov'era.
-                closeDetail();
+                if (find)
+                    setFind(null);
+                else
+                    closeDetail();
             }
             else if (key.return) {
                 // `⏎` esegue SEMPRE l'azione selezionata, mai "scrolla" o "chiudi": il
@@ -1875,7 +1974,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // posizione è lo scroll mosso a mano. Il clamp serve comunque — un resize
         // può accorciare il testo sotto uno scroll già dato.
         const start = Math.min(sheetTop, sheetMaxTop);
-        return (_jsx(DetailScreen, { id: sheet.id, title: sheet.title, missing: sheet.text === null, lines: sheetLines.slice(start, start + sheetCap), top: start, total: sheetLines.length, capacity: sheetCap, action: sheetAction, columns: columns }));
+        return (_jsx(DetailScreen, { id: sheet.id, title: sheet.title, missing: sheet.text === null, lines: sheetLines.slice(start, start + sheetCap), top: start, total: sheetLines.length, capacity: sheetCap, action: sheetAction, columns: columns, find: find, occ: findRes.occ, occCur: occCur }));
     }
     // ── T52 · schermate sostitutive ─────────────────────────────────────────
     // Ricerca e reader sono gli unici modali che NON stanno in flusso sopra i
@@ -2133,7 +2232,8 @@ function SearchScreen({ preview, hash, query, field, opts, result, rows, selecte
  */
 function SearchPreviewPane({ p }) {
     const last = Math.min(p.total, p.from + p.lines.length);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["record ", p.hit.idx, " \u00B7 ", KIND_LABEL[p.hit.kind], p.ts ? ` · ${fmtDateTime(p.ts)}` : '', " \u00B7 righe ", p.from + 1, "-", last, " di ", p.total, " \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " apre il reader"] }), p.lines.map((l, i) => (_jsx(ReaderLine, { line: l, from: p.hit.matchStart, to: p.hit.matchEnd }, p.from + i)))] }));
+    const occ = [{ start: p.hit.matchStart, end: p.hit.matchEnd }];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["record ", p.hit.idx, " \u00B7 ", KIND_LABEL[p.hit.kind], p.ts ? ` · ${fmtDateTime(p.ts)}` : '', " \u00B7 righe ", p.from + 1, "-", last, " di ", p.total, " \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " apre il reader"] }), p.lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, p.from + i)))] }));
 }
 /**
  * Reader fullscreen (T52 · D8).
@@ -2145,18 +2245,32 @@ function SearchPreviewPane({ p }) {
  */
 function ReaderScreen({ hit, lines, top, total, capacity, bound, }) {
     const last = Math.min(total, top + capacity);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["reader \u00B7 ", _jsx(Text, { color: "cyan", children: hit.sessionId.slice(0, 8) }), " \u00B7 record ", hit.idx, " \u00B7", ' ', KIND_LABEL[hit.kind], bound ? ` · ${bound}` : '', " \u00B7 righe ", total === 0 ? 0 : top + 1, "-", last, " di ", total] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g" }), " inizio \u00B7 ", _jsx(Text, { color: "yellow", children: "G" }), " fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " torna alla lista"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: lines.map((l, i) => (_jsx(ReaderLine, { line: l, from: hit.matchStart, to: hit.matchEnd }, top + i))) })] }));
+    const occ = [{ start: hit.matchStart, end: hit.matchEnd }];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["reader \u00B7 ", _jsx(Text, { color: "cyan", children: hit.sessionId.slice(0, 8) }), " \u00B7 record ", hit.idx, " \u00B7", ' ', KIND_LABEL[hit.kind], bound ? ` · ${bound}` : '', " \u00B7 righe ", total === 0 ? 0 : top + 1, "-", last, " di ", total] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g" }), " inizio \u00B7 ", _jsx(Text, { color: "yellow", children: "G" }), " fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " torna alla lista"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, top + i))) })] }));
 }
-/** Una riga del reader, con la sola porzione di match evidenziata. Gli offset
- *  sono quelli del testo sorgente, quindi un match a cavallo dell'a-capo si
- *  colora su entrambe le righe senza casi speciali. */
-function ReaderLine({ line, from, to }) {
-    const a = Math.max(0, Math.min(line.text.length, from - line.start));
-    const b = Math.max(0, Math.min(line.text.length, to - line.start));
-    if (b <= a) {
+/** Una riga con le porzioni di match evidenziate. Gli offset sono quelli del
+ *  testo sorgente, quindi un match a cavallo dell'a-capo si colora su entrambe
+ *  le righe senza casi speciali — entrambe intersecano il suo intervallo.
+ *
+ *  Regge N occorrenze perché il detail (T91) ne mostra tutte quelle visibili; il
+ *  reader (T52) ne passa una sola, che è il caso degenere dello stesso taglio. */
+function ReaderLine({ line, occ, current, }) {
+    const segs = sliceLine(line.text, line.start, occ, current);
+    if (segs.length === 0)
         return _jsx(Text, { wrap: "truncate-end", children: line.text || ' ' });
-    }
-    return (_jsxs(Text, { wrap: "truncate-end", children: [line.text.slice(0, a), _jsx(Text, { backgroundColor: "yellow", color: "black", children: line.text.slice(a, b) }), line.text.slice(b)] }));
+    return (_jsx(Text, { wrap: "truncate-end", children: segs.map((s, i) => s.hit ? (
+        // La corrente si distingue dalle altre per COLORE di sfondo, non per
+        // presenza: tutte restano visibili, o navigare fra occorrenze non
+        // mostrerebbe più dove sono le altre.
+        _jsx(Text, { backgroundColor: s.current ? 'cyan' : 'yellow', color: "black", children: s.text }, i)) : (_jsx(Text, { children: s.text }, i))) }));
+}
+/** Campo della ricerca nel detail: finestra ancorata al caret, cursore inverso
+ *  sulla cella reale. Gemello di `EditTextField` senza la label, che qui sta
+ *  fuori perché il campo vive in FLUSSO su una riga condivisa col contatore —
+ *  non su una riga propria. */
+function DetailFindField({ value, caret, cols }) {
+    const win = caretWindow(value, caret, cols);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: sanitize(win.head) }), _jsx(Text, { inverse: true, children: sanitize(win.at) }), _jsx(Text, { children: sanitize(win.tail) })] }));
 }
 /**
  * Detail della task (T66): il task file scrollabile più la barra azioni.
@@ -2171,7 +2285,7 @@ function ReaderLine({ line, from, to }) {
  * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione. La
  * navigazione da tastiera ci si sovrappone senza conflitti.
  */
-function DetailScreen({ id, title, missing, lines, top, total, capacity, action, columns, }) {
+function DetailScreen({ id, title, missing, lines, top, total, capacity, action, columns, find, occ, occCur, }) {
     const last = Math.min(total, top + capacity);
     // Il taglio lo fa il chiamante (invariante ③ di width.ts): la riga bottoni è
     // ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso — ma
@@ -2192,10 +2306,10 @@ function DetailScreen({ id, title, missing, lines, top, total, capacity, action,
     if (dropped(shown) > 0)
         shown = cutParts(parts, Math.max(0, width - 6));
     const cutCount = dropped(shown);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^F" }), " cerca \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] })), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (
                 // Riga vuota → uno spazio: un `<Text>` senza contenuto Ink non lo
                 // disegna, e il testo si compatterebbe perdendo la struttura del file.
-                lines.map((l, i) => (_jsx(Text, { wrap: "truncate-end", children: l || ' ' }, top + i)))) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] }) })] }));
+                lines.map((l, i) => _jsx(ReaderLine, { line: l, occ: occ, current: occCur }, top + i))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(DetailFindField, { value: find.q, caret: find.caret, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] }) })] }));
 }
 /**
  * Larghezza del testo dentro la lista della schermata di assegnazione: box

package/dist/search.js

@@ -58,8 +58,8 @@ function escapeLiteral(s) {
  * `(`) è la NORMA durante la digitazione, non un caso limite. Deve degradare a
  * lista vuota con segnalazione inline, mai a un crash della TUI.
  */
-export function buildMatcher(query, opts) {
-    if (query.length < MIN_QUERY)
+export function buildMatcher(query, opts, min = MIN_QUERY) {
+    if (query.length < min)
         return { re: null, error: '' };
     let source = opts.regex ? query : escapeLiteral(query);
     // Il gruppo non-catturante è obbligatorio: senza, `\b` si legherebbe al solo

package/dist/text-search.js

@@ -0,0 +1,100 @@
+/**
+ * Ricerca dentro UN documento: occorrenze come offset del testo sorgente.
+ *
+ * Gemello di `search.ts` per il motore, opposto per forma. Lì il corpus è N
+ * conversazioni, quindi il risultato raggruppa per sessione, cappa le occorrenze
+ * e produce estratti; qui il corpus è una stringa sola e la risposta utile è la
+ * posizione, non l'estratto — il testo è già a schermo.
+ *
+ * Gli offset sono quelli del SORGENTE, mai coordinate riga/colonna del testo
+ * wrappato. Due proprietà ne discendono, ed è il motivo per cui il modulo esiste:
+ *
+ *  - **Immunità al re-wrap.** Un resize cambia larghezza e numero di righe ma non
+ *    sposta un match, perché il sorgente non cambia. Coordinate «riga 42,
+ *    colonna 7» andrebbero ricalcolate a ogni SIGWINCH.
+ *  - **Match a cavallo dell'a-capo senza casi speciali.** Ogni riga di
+ *    `wrapWithOffsets` è una fetta contigua del sorgente, quindi evidenziare è
+ *    intersecare due intervalli — e un match spezzato su due righe si colora su
+ *    entrambe perché entrambe intersecano.
+ *
+ * Puro: nessun Ink, nessun terminale, nessun filesystem.
+ */
+import { buildMatcher } from './search.js';
+export const LITERAL = { regex: false, caseSensitive: false, wholeWord: false };
+/**
+ * Minimo di caratteri più basso di `MIN_QUERY`.
+ *
+ * Su N conversazioni una query di 2 caratteri produce migliaia di occorrenze
+ * inutili, e la soglia a 3 protegge dall'indicizzazione a vuoto. Su un task file
+ * `T7` o `⏎` sono query legittime e frequenti: la soglia lì non protegge da
+ * niente, impedisce soltanto.
+ */
+export const MIN_DETAIL_QUERY = 1;
+const EMPTY = { occ: [], error: '' };
+/**
+ * Tutte le occorrenze di `query` in `text`, in ordine di posizione.
+ *
+ * Il testo deve essere **la stessa stringa che si renderizza**: passa da
+ * `sanitize` al confine di caricamento, e cercare su una rilettura del file
+ * produrrebbe offset che indicizzano un documento diverso da quello a schermo —
+ * evidenziazione spostata di N caratteri, senza nessun errore.
+ */
+export function scanText(text, query, opts = LITERAL) {
+    const { re, error } = buildMatcher(query, opts, MIN_DETAIL_QUERY);
+    if (!re)
+        return error ? { occ: [], error } : EMPTY;
+    const occ = [];
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        // Una regex può matchare la STRINGA VUOTA (`a*`, `^`, `\b`): `exec` non
+        // avanzerebbe `lastIndex` e il ciclo non terminerebbe mai. Un match di
+        // larghezza zero non è nemmeno evidenziabile, quindi si salta invece di
+        // registrarlo.
+        if (m[0].length === 0) {
+            re.lastIndex++;
+            continue;
+        }
+        occ.push({ start: m.index, end: m.index + m[0].length });
+    }
+    return { occ, error };
+}
+/**
+ * Taglia una riga wrappata nei pezzi da colorare, intersecando gli offset.
+ *
+ * `occ` è in ordine e senza sovrapposizioni (`exec` avanza monotono), quindi
+ * basta una passata. Il guard `a < pos` regge comunque il caso di intervalli
+ * sovrapposti passati da un chiamante futuro, senza produrre testo duplicato.
+ */
+export function sliceLine(lineText, lineStart, occ, current) {
+    const out = [];
+    let pos = 0;
+    for (let i = 0; i < occ.length; i++) {
+        const a = Math.max(0, Math.min(lineText.length, occ[i].start - lineStart));
+        const b = Math.max(0, Math.min(lineText.length, occ[i].end - lineStart));
+        if (b <= a || a < pos)
+            continue;
+        if (a > pos)
+            out.push({ text: lineText.slice(pos, a), hit: false, current: false });
+        out.push({ text: lineText.slice(a, b), hit: true, current: i === current });
+        pos = b;
+    }
+    if (pos < lineText.length) {
+        out.push({ text: lineText.slice(pos), hit: false, current: false });
+    }
+    return out;
+}
+/**
+ * Scroll che porta l'offset al CENTRO della finestra visibile.
+ *
+ * Stessa ricetta di `submitSearchRow` (T52). Centrare conta più che sembri:
+ * un'occorrenza portata in cima alla finestra arriva senza il contesto che la
+ * precede, ed è il contesto che dice se è quella giusta.
+ */
+export function topForOffset(lines, offset, capacity) {
+    const maxTop = Math.max(0, lines.length - capacity);
+    let i = lines.findIndex((l) => l.end > offset);
+    if (i < 0)
+        i = Math.max(0, lines.length - 1);
+    return Math.max(0, Math.min(maxTop, i - Math.floor(capacity / 2)));
+}

package/dist/viewport.js

@@ -224,9 +224,20 @@ export function readerCapacity(rows) {
 // aggiunta va scalata dalla capienza del contenuto o il frame sfonda `rows`
 // (stessa invariante di TASKS_PANE_CHROME).
 const DETAIL_CHROME = 10;
-/** Righe di task file che entrano nel terminale. */
-export function detailCapacity(rows) {
-    return Math.max(0, (rows || 24) - SLACK - DETAIL_CHROME);
+// T91 — la ricerca dentro il detail: marginTop + riga del campo.
+//
+// `MODAL_HEIGHT` dice che il detail costa 0 ai due pane (li sostituisce), e da
+// lì è facile leggere «dentro l'overlay lo spazio è gratis». Le due contabilità
+// sono distinte: quella dice quanto l'overlay toglie ai PANE, questa quanto
+// toglie al PROPRIO contenuto. Una riga fissa aggiunta e non scalata è ciò che
+// fa sfondare `rows` e manda Ink nel ramo `clearTerminal`, che su VTE riversa un
+// frame nello scrollback a ogni tick del poll.
+const DETAIL_SEARCH_CHROME = 2;
+/** Righe di task file che entrano nel terminale; con la ricerca aperta il campo
+ *  si paga qui, non altrove. */
+export function detailCapacity(rows, searching = false) {
+    const extra = searching ? DETAIL_SEARCH_CHROME : 0;
+    return Math.max(0, (rows || 24) - SLACK - DETAIL_CHROME - extra);
 }
 // T52 — cornice del pannello di anteprima sotto la lista occorrenze:
 // marginTop + 2 bordi + riga meta.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {