@lamemind/loom-deck 0.13.0 → 0.15.0

package/README.md

@@ -51,9 +51,17 @@ senza collisioni:
 | `⏎` | azione primaria del pane | Tasks → spawna la task selezionata · Sessions → riprende (`claude --resume`) la sessione selezionata |
 | **MAIUSCOLA** | **apre un modale** | cattura tutti i tasti; `esc` annulla, non esce |
 | minuscola | azione immediata, one-shot | |
+| `CTRL`+lettera | idiomi universali e toggle dentro i modali di testo | `^F` = find, come ovunque |
 | `1`…`9` | voce `launch` n-esima del progetto | da `.claude/loom-works.json` |
 | `q` `esc` | esce dal deck | in un modale `esc` annulla soltanto |
 
+`CTRL` è il terzo livello, aggiunto quando è arrivata la ricerca. Serve perché
+un modale con **campi di testo** mangia ogni lettera nuda: là dentro nessun
+comando può essere una lettera semplice. `CTRL+X` e `x` nudo condividono lo
+stesso `input` e si distinguono solo per `key.ctrl`, quindi in modalità normale
+il ramo `CTRL` è valutato **per primo** e chiude l'intera classe — senza,
+`CTRL+F` cadrebbe nel ramo `f` e forkerebbe una sessione invece di cercare.
+
 Assegnazioni correnti:
 
 | | Tasto | Cosa fa |
@@ -62,6 +70,7 @@ Assegnazioni correnti:
 | modale | `E` | edit priorità/stato della task selezionata (salva + commit) |
 | modale | `S` | sort chain |
 | modale | `F` | filtri |
+| modale | `^F` | **ricerca full-text** nelle conversazioni del progetto |
 | immediata | `f` | **forka** la sessione selezionata (solo col focus sul pane Sessions) |
 | immediata | `t` | terminale @project-root (surface standard launch) |
 | immediata | `c` | sessione Claude **nuda**: nessuna task, nessun prompt iniziale |
@@ -107,6 +116,69 @@ pannello di dettaglio; la sua tab Ptyxis titola `<label> · <task> · fork`.
 > `codium`/`idea` non hanno più una lettera dedicata (erano `C`/`I` hardcoded):
 > ora sono voci `launch` del file config, raggiunte per indice `1`…`9`.
 
+### `^F` — cercare dentro le conversazioni
+
+Il navigator trova una conversazione per **metadati** (titolo, data, turni). `^F`
+la trova per **contenuto**: «l'IA me l'ha detto 150k di testo fa, ricordo mezza
+parola». Claude Code non ha un find-in-conversation, ma i transcript sono tutti
+su disco e il deck li legge già.
+
+Due campi, `tab` per passare dall'uno all'altro:
+
+- **hash** — prefisso del `sessionId` (gli 8 char della statusline bastano),
+  restringe a una conversazione. Vuoto = **tutte** quelle del progetto.
+- **chiave** — il termine cercato. La ricerca è **eager**: si aggiorna a ogni
+  carattere, da 3 in su.
+
+Sei toggle, tutti su `CTRL` perché i campi di testo occupano le lettere nude.
+Lo stato si legge da `[x]`/`[ ]`, non dal solo colore:
+
+| Tasto | Toggle | Default |
+|---|---|---|
+| `^R` | la chiave è una **regex** invece che testo letterale | off |
+| `^A` | **case-sensitive** | off |
+| `^W` | solo **parole intere** | off |
+| `^B` | cerca nel testo **dell'IA** | **on** |
+| `^T` | cerca nei **tool** (`tool_use` / `tool_result`) | off |
+| `^U` | cerca nei prompt **umani** | off |
+
+Non esiste un toggle *thinking*: quei blocchi sono persistiti **senza testo**
+(il transcript porta la sola firma crittografica), quindi sarebbe una casella
+che non può mai produrre un risultato.
+
+Con l'hash vuoto la lista è **raggruppata per conversazione**; `⏎` è contestuale
+alla riga selezionata — su una riga-conversazione **riprende** la sessione
+(come dal pane Sessions), su una riga-occorrenza apre il **reader**. La selezione
+parte dalla prima *occorrenza*, non dalla riga di gruppo: quella è un segnaposto
+di navigazione, raggiungibile con le frecce ma non una destinazione.
+
+L'estratto attorno al match **si allarga col terminale**: a 190 colonne sono
+~170 caratteri di contesto, non i 50 di un valore fisso — ed è il contesto la
+ragione per cui si legge la riga invece di aprire il reader.
+
+Sotto la lista, un **pannello di anteprima** mostra il contesto attorno
+all'occorrenza selezionata e si aggiorna navigando con le frecce. Prende solo le
+righe che la lista non usa: con pochi risultati riempie il terminale, con molti
+sparisce e la lista se le riprende — quando c'è tanto da scorrere la priorità è
+vedere più occorrenze, il contesto è il premio per una ricerca già stretta.
+
+Il reader mostra il messaggio intero, aperto già **posizionato sull'occorrenza**
+col match evidenziato: `↑↓` riga, `PgUp`/`PgDn` pagina, `g`/`G` estremi, `esc`
+torna alla lista senza perdere query, toggle e selezione. (Gli estremi stanno su
+lettera e non su `Home`/`End` perché Ink non espone quei due tasti: arrivano
+indistinguibili da qualunque tasto ignoto.)
+
+I toggle e la query sono **volatili**: sopravvivono alla chiusura del modale,
+non al riavvio del deck — comporre una ricerca non tocca il disco.
+
+**Come fa a essere istantanea.** I corpi dei messaggi restano in RAM dentro la
+cache mtime-keyed che il deck usa già per la lista sessioni: quei file venivano
+comunque deserializzati per turni e titoli, e i corpi buttati. Trattenerli non
+aggiunge I/O, aggiunge memoria — e ne aggiunge poca, perché un JSONL è per l'85%
+overhead (misurato su un progetto reale: 57 MB su disco = 9,8 MB di testo
+cercabile). Cercarci dentro costa 1-9 ms; un prefiltro `grep` sugli stessi file
+ne costerebbe 26, perché rileggerebbe il volume pieno a ogni battuta.
+
 ## Vista: filtri e ordinamenti
 
 La lista è una **vista** sulla `tasks.md`: si filtra e si ordina senza toccare il file.

package/dist/cli.js

@@ -9,10 +9,11 @@ import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, } from './tasks.js';
 import { discoverProjectSessions } from './sessions.js';
+import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions, selectedRow, DEFAULT_OPTIONS, MIN_QUERY, } from './search.js';
 import { appendPin, appendSessionRecord, appendTaskBinding, loadSessionIndex, } from './task-index.js';
 import { assembleSessionList, firstSelectableId, moveSelection, rowIndexOf, selectedSession, } from './session-list.js';
 import { launchLegend, loadIdentity, loadLaunch } from './config.js';
-import { layoutBudget, normalizeEmoji, windowRange, wrapLines, } from './viewport.js';
+import { isCompact, layoutBudget, normalizeEmoji, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, wrapLines, wrapWithOffsets, } from './viewport.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';
@@ -30,6 +31,25 @@ const SPOT = Symbol('spot');
 // Modale sort a grammatica libera: un tasto per chiave, pressioni successive
 // ciclano asc → desc → fuori dalla chain.
 const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id' };
+// T52 — toggle del modale ricerca, tutti su CTRL (D2).
+//
+// I due campi di testo mangiano ogni lettera nuda, quindi un toggle non può
+// essere una lettera semplice: resterebbero i caratteri della query. CTRL è
+// l'unico livello che convive con la digitazione senza modi né navigazione.
+//
+// Le mnemoniche ovvie sono precluse dall'ASCII, non da una scelta di design:
+// `^I` È il Tab (0x09) e `^H` È il Backspace (0x08) — stesso byte, nessuna
+// distinzione possibile a valle. Quindi niente I=IA e niente H=human. Bruciati
+// per lo stesso motivo `^M` (Enter), `^J` (LF), `^[` (Esc). Tutto il resto passa
+// pulito, `^S`/`^Q` inclusi: il raw mode di Ink disattiva il flow-control XON/XOFF
+// che altrimenti se li mangerebbe il terminale.
+const SEARCH_TOGGLE_KEYS = {
+    r: 'regex',
+    a: 'caseSensitive',
+    w: 'wholeWord',
+};
+const SEARCH_KIND_KEYS = { b: 'ai', t: 'tool', u: 'human' };
+const KIND_LABEL = { ai: 'IA', tool: 'tools', human: 'human' };
 // T41 — ordine dei valori nel modale edit. Deliberatamente DIVERSO da
 // PRI_ENTRIES/PROG_ENTRIES (che seguono il rango di sort): qui si sceglie un
 // valore, non si ordina, quindi vince l'ordine del CICLO DI VITA — da fare →
@@ -414,6 +434,22 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // T41 — bozza dell'edit (null fuori dal modale) e riga attiva della griglia.
     const [edit, setEdit] = useState(null);
     const [editRow, setEditRow] = useState(0);
+    // T52 — stato del modale ricerca. VOLATILE per decisione (D4): vive in
+    // memoria, quindi riaprendo il modale ritrovi query e toggle come li avevi
+    // lasciati, ma un riavvio del deck riporta ai default. Niente schema nuovo su
+    // `deck-view.json` e nessuna scrittura implicita su disco — che
+    // contraddirebbe la regola T39 «il disco si tocca solo su `w`», qui non
+    // trasportabile perché dentro il modale `w` è un carattere digitabile.
+    const [searchHash, setSearchHash] = useState('');
+    const [searchQuery, setSearchQuery] = useState('');
+    const [searchField, setSearchField] = useState('query');
+    const [searchOpts, setSearchOpts] = useState(DEFAULT_OPTIONS);
+    const [searchSelKey, setSearchSelKey] = useState(null);
+    // Occorrenza aperta nel reader; null = reader chiuso. Tenerla separata dalla
+    // selezione della lista è ciò che permette a `esc` di tornare indietro
+    // trovando la lista esattamente com'era.
+    const [readerRow, setReaderRow] = useState(null);
+    const [readerTop, setReaderTop] = 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.
@@ -455,6 +491,32 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const assembled = useMemo(() => assembleSessionList(childSessions, sessions, pinned, MAX_SESSIONS), [childSessions, sessions, pinned]);
     const sessionRows = assembled.rows;
     const selSessionObj = selectedSession(sessionRows, selSessionId);
+    // T52 — ricerca EAGER: rigira a ogni carattere digitato, non su ⏎. È
+    // sostenibile perché i corpi sono già in RAM dentro la cache mtime-keyed
+    // dell'adapter (D5): misurato su questo progetto, 0,8 ms sui soli corpi IA e
+    // ≤9 ms su tutti i tipi — sotto il tempo fra due battute. Il memo evita di
+    // rifarla sui re-render che non toccano né query né opzioni (il poll delle
+    // sessioni ogni 1,5s è già filtrato dalla signature in `useSessions`).
+    const searchResult = useMemo(() => searchSessions(sessions, searchHash, searchQuery, searchOpts, searchExcerptWidth(columns)), [sessions, searchHash, searchQuery, searchOpts, columns]);
+    // Con l'hash valorizzato la conversazione è una sola e già nominata nel campo:
+    // la riga-sessione ripeterebbe un dato costante rubando una riga per gruppo.
+    const searchFlat = searchHash.trim().length > 0;
+    const searchRows = useMemo(() => buildRows(searchResult, searchFlat), [searchResult, searchFlat]);
+    // T52 — riga selezionata e, se è un'occorrenza, il suo corpo wrappato per
+    // l'anteprima sotto la lista. Memoizzato per (testo, larghezza): navigando
+    // con le frecce si ri-wrappa solo quando cambia davvero l'occorrenza.
+    const searchSelRow = useMemo(() => selectedRow(searchRows, searchSelKey), [searchRows, searchSelKey]);
+    const searchPreviewWidth = Math.max(20, (columns || 80) - 8);
+    const searchPreviewBody = useMemo(() => searchSelRow?.kind === 'hit'
+        ? wrapWithOffsets(searchSelRow.hit.text, searchPreviewWidth)
+        : [], [searchSelRow, searchPreviewWidth]);
+    // T52 — corpo del messaggio aperto nel reader, wrappato UNA volta per (testo,
+    // larghezza). Senza memo ogni pressione di freccia rifarebbe l'a-capo di un
+    // messaggio che nella coda lunga arriva a 150k char.
+    const readerWidth = Math.max(20, (columns || 80) - 6);
+    const readerLines = useMemo(() => (readerRow?.kind === 'hit' ? wrapWithOffsets(readerRow.hit.text, readerWidth) : []), [readerRow, readerWidth]);
+    const readerCap = readerCapacity(rows);
+    const readerMaxTop = Math.max(0, readerLines.length - readerCap);
     // T39 — selezione stabile sotto trasformazione. Se la task selezionata esce
     // dalla vista (filtro appena attivato, oppure sparita da tasks.md), si cade
     // sulla prima visibile — fallback deterministico, mai una posizione a caso.
@@ -472,6 +534,15 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setSelSessionId(firstSelectableId(sessionRows));
         }
     }, [sessionRows, selSessionId]);
+    // T52 — stessa invariante sulla lista occorrenze, dove è ancora più stretta:
+    // la lista si RICOSTRUISCE a ogni carattere digitato, quindi la chiave
+    // selezionata sparisce continuamente. Persa → prima riga, mai una posizione
+    // ereditata (che qui punterebbe a un'altra conversazione, non a un'altra riga).
+    useEffect(() => {
+        if (rowIndexOfKey(searchRows, searchSelKey) < 0) {
+            setSearchSelKey(firstRowKey(searchRows));
+        }
+    }, [searchRows, searchSelKey]);
     // T30: submit dell'input box. Il taskId nasce DOPO create-task (lo assegna la
     // skill scrivendo tasks.md) → non è noto allo spawn. Il sessionId invece è
     // pinnato qui: snapshot degli id PRIMA, poi al completamento re-leggo tasks.md
@@ -571,7 +642,175 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         const next = Math.max(0, Math.min(viewTasks.length, selIndex + delta));
         setSelId(next === 0 ? null : viewTasks[next - 1]?.id ?? null);
     }
+    // T52 — `⏎` contestuale al TIPO di riga: la lista ne mescola due e l'azione
+    // giusta dipende da quale è selezionata. Riga sessione → resume, identico al
+    // `⏎` della lista sessioni (stessa funzione, T49). Riga occorrenza → reader.
+    function submitSearchRow() {
+        const row = selectedRow(searchRows, searchSelKey);
+        if (!row) {
+            setNote(searchResult.error ? '⚠ regex non valida' : 'nessuna occorrenza selezionata');
+            return;
+        }
+        if (row.kind === 'session') {
+            const bound = bindings.get(row.session.sessionId) ?? null;
+            const child = spawnDeckResume(bound, cwd, row.session.sessionId);
+            child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
+            setNote(`⏎ resume ${row.session.sessionId.slice(0, 8)} → tab CC${bound ? ` (${bound})` : ' (spot)'}`);
+            return;
+        }
+        // D8 — il reader si apre POSIZIONATO sull'occorrenza, non in cima. Il 94%
+        // dei messaggi entra in una schermata e la differenza non si vede; è sul 6%
+        // lungo (p99 ≈ 88 righe, max ≈ 1547) che aprire in cima costringerebbe a
+        // rifare a mano la ricerca appena fatta — cioè proprio il lavoro che questa
+        // feature esiste per evitare.
+        const lines = wrapWithOffsets(row.hit.text, readerWidth);
+        const cap = readerCapacity(rows);
+        const matchLine = lines.findIndex((l) => l.end > row.hit.matchStart);
+        const maxTop = Math.max(0, lines.length - cap);
+        setReaderRow(row);
+        setReaderTop(Math.max(0, Math.min(maxTop, Math.max(0, matchLine) - Math.floor(cap / 2))));
+        setNote('');
+        setMode('reader');
+    }
+    function scrollReader(delta) {
+        setReaderTop((t) => Math.max(0, Math.min(readerMaxTop, t + delta)));
+    }
+    // T52 — toggle di tipo messaggio. Spegnerli tutti è uno stato lecito (lista
+    // vuota, nessun errore): è l'utente che ha chiuso ogni canale, non un guasto.
+    function toggleKind(kind) {
+        setSearchOpts((o) => ({ ...o, kinds: { ...o.kinds, [kind]: !o.kinds[kind] } }));
+    }
+    function editSearchField(fn) {
+        // La nota racconta l'esito di un'AZIONE su una lista che, con l'eager, si
+        // ricostruisce a ogni carattere: appena la query cambia è già scaduta.
+        // Lasciarla lì la fa leggere come se descrivesse lo stato corrente — nello
+        // specifico «nessuna occorrenza selezionata» sopra una lista con una riga
+        // visibilmente selezionata, cioè una contraddizione a schermo.
+        setNote('');
+        if (searchField === 'hash')
+            setSearchHash(fn);
+        else
+            setSearchQuery(fn);
+    }
+    // `useInput` consegna il CHUNK letto da stdin, non un tasto: un incollaggio —
+    // o una raffica di tasti piu' veloce di una read — arriva come stringa unica,
+    // byte di controllo compresi. Due conseguenze, entrambe verificate su pty:
+    //
+    //  1. I byte di controllo finiscono DENTRO il campo se non li si filtra. Non
+    //     si vedono, ma Ink li conta nella larghezza della riga e nessun match li
+    //     soddisfa -> la ricerca smette di trovare senza dire perche'. Le newline
+    //     diventano spazio invece di sparire: incollare due righe deve separare
+    //     le parole, non fonderle.
+    //
+    //  2. Un TAB digitato subito dopo una lettera (~60 ms, cioe' battitura veloce
+    //     normale) arriva incollato ad essa: `key.tab` resta falso e il ramo del
+    //     cambio campo non scatta mai. Trattarlo come testo lo renderebbe uno
+    //     spazio, per giunta nel campo sbagliato — e' cosi' che `70897aff` + Tab
+    //     + `congelat` finiva tutto quanto nel campo hash.
+    //
+    // Si spezza quindi il chunk SUL TAB applicando il cambio campo in mezzo: il
+    // risultato e' identico alla battitura lenta. Stessa lezione del modale sort
+    // (T39), che cicla sui caratteri del chunk invece di leggerlo intero.
+    function typeIntoField(chunk) {
+        setNote('');
+        const clean = (s) => s.replace(/[\r\n]/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '');
+        const parts = chunk.split('\t');
+        let field = searchField;
+        const add = { hash: '', query: '' };
+        for (let k = 0; k < parts.length; k++) {
+            if (k > 0)
+                field = field === 'hash' ? 'query' : 'hash';
+            add[field] += clean(parts[k]);
+        }
+        if (add.hash)
+            setSearchHash((v) => v + add.hash);
+        if (add.query)
+            setSearchQuery((v) => v + add.query);
+        setSearchField(field);
+    }
+    const searchCap = searchListCapacity(rows, Boolean(note));
     useInput((input, key) => {
+        // T52 — MODALE DENTRO IL MODALE. `useInput` in Ink è globale e non ha
+        // focus-trap: non esiste un meccanismo che confini l'input a un componente.
+        // La cattura È l'ordine dei rami — quindi il reader va PRIMA della ricerca,
+        // e mentre è aperto il modale ricerca resta montato sotto con la sua
+        // selezione intatta, pronto a riprendere il controllo su `esc`.
+        if (mode === 'reader') {
+            if (key.escape) {
+                setMode('search');
+                setReaderRow(null);
+            }
+            else if (key.upArrow) {
+                scrollReader(-1);
+            }
+            else if (key.downArrow) {
+                scrollReader(1);
+            }
+            else if (key.pageUp) {
+                scrollReader(-readerCap);
+            }
+            else if (key.pageDown) {
+                scrollReader(readerCap);
+            }
+            else if (input === 'g') {
+                // Estremi su lettera e non su Home/End: Ink RICONOSCE quelle due (le
+                // mappa a 'home'/'end' nel parser) ma NON le espone — `nonAlphanumericKeys`
+                // azzera l'input e nessun flag le rappresenta, quindi arrivano
+                // indistinguibili da qualunque tasto ignoto. Verificato su pty reale.
+                // Nel reader non c'è input di testo, quindi le lettere sono libere.
+                setReaderTop(0);
+            }
+            else if (input === 'G') {
+                setReaderTop(readerMaxTop);
+            }
+            return;
+        }
+        // T52 — modale ricerca. I due campi di testo mangiano ogni lettera nuda:
+        // ogni comando che deve restare vivo MENTRE si digita passa da CTRL, dai
+        // tasti freccia o da Tab. `esc` chiude il modale, non il deck.
+        if (mode === 'search') {
+            if (key.escape) {
+                setMode('normal');
+                setNote('');
+                return;
+            }
+            if (key.ctrl) {
+                const flag = SEARCH_TOGGLE_KEYS[input];
+                if (flag) {
+                    setSearchOpts((o) => ({ ...o, [flag]: !o[flag] }));
+                    return;
+                }
+                const kind = SEARCH_KIND_KEYS[input];
+                if (kind)
+                    toggleKind(kind);
+                return; // ogni altra combo ctrl (^F incluso: siamo già dentro) = no-op
+            }
+            if (key.tab) {
+                setSearchField((f) => (f === 'hash' ? 'query' : 'hash'));
+            }
+            else if (key.upArrow) {
+                setSearchSelKey((k) => moveRowSelection(searchRows, k, -1));
+            }
+            else if (key.downArrow) {
+                setSearchSelKey((k) => moveRowSelection(searchRows, k, 1));
+            }
+            else if (key.pageUp) {
+                setSearchSelKey((k) => moveRowSelection(searchRows, k, -Math.max(1, searchCap)));
+            }
+            else if (key.pageDown) {
+                setSearchSelKey((k) => moveRowSelection(searchRows, k, Math.max(1, searchCap)));
+            }
+            else if (key.return) {
+                submitSearchRow();
+            }
+            else if (key.backspace || key.delete) {
+                editSearchField((s) => s.slice(0, -1));
+            }
+            else if (input && !key.meta) {
+                typeIntoField(input);
+            }
+            return;
+        }
         // T30: in modalità create l'handler cattura il testo e corto-circuita la
         // navigazione normale (incl. q/esc → quit: qui esc annulla, non esce).
         if (mode === 'create') {
@@ -688,6 +927,21 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             return;
         }
+        // T52/D1 — il ramo CTRL sta PRIMA di quelli su lettera nuda e li chiude
+        // tutti. `CTRL+F` e `f` nudo arrivano con lo STESSO `input` ('f'),
+        // distinguibili solo da `key.ctrl`: senza questa precedenza `CTRL+F`
+        // cadrebbe nel ramo fork e spawnerebbe una sessione invece di aprire la
+        // ricerca. Non è un caso isolato della `f` — `^Q` finirebbe nel quit, `^T`
+        // aprirebbe un terminale, `^C` … ogni lettera legata a un'azione ha la sua
+        // combo omonima. Chiudere qui l'intera classe è più solido che ricordarsi
+        // un `!key.ctrl` su ognuno dei rami, oggi e a ogni tasto aggiunto domani.
+        if (key.ctrl) {
+            if (input === 'f') {
+                setNote('');
+                setMode('search');
+            }
+            return;
+        }
         if (key.leftArrow || key.rightArrow || key.tab) {
             setFocus((f) => (f === 'tasks' ? 'sessions' : 'tasks'));
         }
@@ -856,6 +1110,50 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // Larghezza dal medesimo hook che dà l'altezza: dopo un resize la legenda si
     // ricalcola con lo stesso re-render che ridimensiona i pane.
     const legend = launchLegend(launch, columns);
+    // ── T52 · schermate sostitutive ─────────────────────────────────────────
+    // Ricerca e reader sono gli unici modali che NON stanno in flusso sopra i
+    // pane: una lista di occorrenze non entra in un box da 4 righe. Prendono
+    // l'intero frame, quindi escono di qui — il budget dei due pane sotto non
+    // serve nemmeno calcolarlo, e la loro altezza la distribuiscono
+    // `searchListCapacity` / `readerCapacity`.
+    if (mode === 'search' || mode === 'reader') {
+        const hit = mode === 'reader' && readerRow?.kind === 'hit' ? readerRow.hit : null;
+        // Terminale sotto la cornice: riga singola invece del box, per lo stesso
+        // motivo del `budget.compact` del deck — un frame più alto di `rows` fa
+        // pulire lo schermo a Ink a ogni redraw, e il poll lo versa nello scrollback.
+        if (isCompact(hit ? readerCap : searchCap)) {
+            return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", hit ? 'reader' : 'ricerca', " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga \u00B7", ' ', "esc ", hit ? 'torna' : 'chiude'] })] }));
+        }
+        if (hit) {
+            // Niente `windowRange`: quella centra la finestra su una SELEZIONE, qui
+            // la posizione è lo scroll che l'utente muove a mano. Il clamp serve
+            // comunque — un resize può accorciare il testo sotto uno scroll già dato.
+            const start = Math.min(readerTop, readerMaxTop);
+            return (_jsx(ReaderScreen, { hit: hit, lines: readerLines.slice(start, start + readerCap), top: start, total: readerLines.length, capacity: readerCap, bound: bindings.get(hit.sessionId) ?? null }));
+        }
+        const selIdx = rowIndexOfKey(searchRows, searchSelKey);
+        const win = windowRange(searchRows.length, selIdx, searchCap);
+        // Anteprima dell'occorrenza selezionata: prende le righe che la lista non
+        // usa. Con molti risultati `spare` è 0 e il pannello non esiste — la lista
+        // se le riprende tutte, che è la priorità giusta quando c'è molto da
+        // scorrere. La finestra si CENTRA sul match (`windowRange`), così il
+        // contesto arriva da entrambi i lati.
+        const spare = searchPreviewCapacity(searchCap, win.end - win.start);
+        let preview = null;
+        if (spare >= 1 && searchSelRow?.kind === 'hit') {
+            const h = searchSelRow.hit;
+            const mline = Math.max(0, searchPreviewBody.findIndex((l) => l.end > h.matchStart));
+            const pw = windowRange(searchPreviewBody.length, mline, spare);
+            preview = {
+                hit: h,
+                lines: searchPreviewBody.slice(pw.start, pw.end),
+                from: pw.start,
+                total: searchPreviewBody.length,
+                ts: sessions.find((s) => s.sessionId === h.sessionId)?.ts ?? 0,
+            };
+        }
+        return (_jsx(SearchScreen, { preview: preview, hash: searchHash, query: searchQuery, field: searchField, opts: searchOpts, result: searchResult, rows: searchRows.slice(win.start, win.end), selectedKey: searchSelKey, selectedKind: selectedRow(searchRows, searchSelKey)?.kind ?? null, above: win.start, below: searchRows.length - win.end, capacity: searchCap, bindings: bindings, pinned: pinned, projectCore: identity ? `${identity.owner} ${identity.name}` : null, columns: columns, note: note }));
+    }
     // ── Budget d'altezza ────────────────────────────────────────────────────
     // Il frame deve restare sotto `rows`, sempre: oltre quella soglia Ink smette
     // di aggiornare per differenza e pulisce lo schermo a ogni redraw, che su
@@ -894,7 +1192,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     if (budget.compact) {
         return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", viewTasks.length, " task \u00B7 sel ", selectedTaskId ?? 'spot', " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga"] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : canResume ? 'resume' : '—', canResume ? ' · f fork' : '', canPin ? ' · p pin' : '', " \u00B7 C nuova \u00B7 E edit \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7 t term \u00B7 c claude \u00B7 q esci \u00B7 focus:", ' ', _jsx(Text, { color: "cyan", children: focus })] })), mode === 'normal' && launch.length > 0 ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["launch ", legend.shown, legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: normalizeEmoji(note) }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : canResume ? 'resume' : '—', canResume ? ' · f fork' : '', canPin ? ' · p pin' : '', " \u00B7 ^F cerca \u00B7 C nuova \u00B7 E edit \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7 t term \u00B7 c claude \u00B7 q esci \u00B7 focus:", ' ', _jsx(Text, { color: "cyan", children: focus })] })), mode === 'normal' && launch.length > 0 ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["launch ", legend.shown, legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: normalizeEmoji(note) }) : null] }));
 }
 const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
 // Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
@@ -924,6 +1222,145 @@ function EditModal({ id, draft, row }) {
     const mark = (r) => (row === r ? CARET : CARET_OFF);
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri  " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato" }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(Text, { dimColor: true, children: "prog " }), _jsxs(Text, { children: ['  ', draft.detail] }), row === 2 ? _jsx(Text, { inverse: true, children: " " }) : null, !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", normalizeEmoji(progressText(draft.prog, draft.detail))] })] }));
 }
+// T52 — marcatore compatto del tipo di corpo sulla riga-occorrenza. Due
+// caratteri ASCII e non un'emoji: con più toggle accesi la colonna deve
+// allinearsi, e i glifi BMP larghi 2 sono proprio la classe che Ink e il
+// terminale misurano diversamente (vedi normalizeEmoji).
+const KIND_TAG = { ai: 'ai', tool: 'tl', human: 'hu' };
+const KIND_COLOR = { ai: 'cyan', tool: 'gray', human: 'green' };
+/**
+ * Larghezza dell'estratto, DERIVATA dalle colonne del terminale.
+ *
+ * Una costante qui è spazio buttato a ogni riga: su un terminale a 190 colonne
+ * un estratto fisso a 50 lascia il match con ~20 caratteri di contesto per lato
+ * quando potrebbe averne 80 — e il contesto attorno al match è l'unica ragione
+ * per cui si legge la riga invece di aprire il reader.
+ *
+ * Scomposizione delle colonne consumate dalla cornice e dal prefisso di riga:
+ *   4  box esterno (2 bordi + 2 padding)
+ *   4  box lista   (2 bordi + 2 padding)
+ *   2  caret
+ *   4  indice del record
+ *   3  spazio + tag del kind + spazio
+ * Prudente per costruzione: sottostimare tronca un carattere in più,
+ * sovrastimare manderebbe la riga a capo e sfonderebbe il budget d'altezza.
+ */
+function searchExcerptWidth(columns) {
+    return Math.max(30, (columns || 80) - 17);
+}
+/** Titolo della conversazione sulla riga-gruppo: prende ciò che avanza dopo le
+ *  colonne a larghezza fissa (caret, pin, hash, task, conteggio, data). */
+function searchTitleWidth(columns) {
+    return Math.max(24, (columns || 80) - 56);
+}
+/**
+ * Cosa scrivere sulla riga-gruppo per distinguere una conversazione dall'altra.
+ *
+ * Non basta `session.title`: quel titolo è la label della tab Ptyxis, cioè
+ * `<emoji> <owner> <name>` più un eventuale suffisso. Su una lista tutta dello
+ * stesso progetto (D3) è una COLONNA COSTANTE — tre righe su quattro
+ * identiche, che è esattamente il difetto che la riga-gruppo doveva evitare.
+ *
+ * Si toglie quindi il core `<owner> <name>` (noto dal file config), e se ciò
+ * che resta è vuoto o duplica la task già mostrata nella sua colonna, si
+ * ripiega sul primo prompt — l'unica cosa che davvero identifica quella
+ * conversazione e non un'altra.
+ */
+function conversationLabel(s, core, bound) {
+    let t = s.title;
+    if (core) {
+        const at = t.indexOf(core);
+        if (at >= 0)
+            t = t.slice(at + core.length);
+    }
+    t = t.replace(/^[\s·]+/, '').trim();
+    if (bound && t === bound)
+        t = '';
+    return t || s.firstPrompt || '(senza titolo)';
+}
+/**
+ * Riga di toggle del modale ricerca.
+ *
+ * La mappa tasto→significato è SEMPRE a schermo: `^R` da solo è opaco quanto lo
+ * era il range `1-9` delle launch prima di T43.
+ *
+ * Lo stato acceso/spento passa da `[x]`/`[ ]`, non dal solo colore — stessa
+ * convenzione del modale filtri. Il colore è ridondanza, non l'informazione: su
+ * un terminale monocromo, o in una cattura di testo, sei toggle tutti uguali
+ * non direbbero più quali sono attivi.
+ */
+function ToggleHint({ opts }) {
+    const flag = (on, key, label) => (_jsxs(Text, { color: on ? 'green' : 'gray', dimColor: !on, bold: on, children: ['  ', key, "[", on ? 'x' : ' ', "] ", label] }, key));
+    return (_jsxs(Text, { wrap: "truncate-end", children: [flag(opts.regex, '^R', 'regex'), flag(opts.caseSensitive, '^A', 'Aa'), flag(opts.wholeWord, '^W', 'word'), _jsx(Text, { dimColor: true, children: '  │' }), flag(opts.kinds.ai, '^B', 'IA'), flag(opts.kinds.tool, '^T', 'tools'), flag(opts.kinds.human, '^U', 'human')] }));
+}
+/** Intestazione della lista: dice sempre quanto NON si sta vedendo (regex rotta,
+ *  query troppo corta, occorrenze tagliate dal cap, righe fuori finestra). */
+function SearchListHeader({ result, query, above, below, }) {
+    if (result.error) {
+        return (_jsxs(Text, { color: "red", wrap: "truncate-end", children: [WARN, " regex non valida \u00B7 ", result.error] }));
+    }
+    if (result.idle) {
+        return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: query.length === 0
+                ? 'digita la chiave da cercare'
+                : `almeno ${MIN_QUERY} caratteri (${query.length})` }));
+    }
+    if (result.shown === 0) {
+        return (_jsx(Text, { color: "yellow", wrap: "truncate-end", children: "nessuna occorrenza" }));
+    }
+    return (_jsxs(Text, { bold: true, wrap: "truncate-end", children: [result.shown, " occorrenze in ", result.sessionCount, " conversazioni", result.hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", result.hidden, " oltre il cap"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }));
+}
+function SearchScreen({ preview, hash, query, field, opts, result, rows, selectedKey, selectedKind, above, below, capacity, bindings, pinned, projectCore, columns, note, }) {
+    const enter = selectedKind === 'session' ? 'resume' : selectedKind === 'hit' ? 'leggi' : '—';
+    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: ["ricerca \u00B7 ", _jsx(Text, { color: "yellow", children: "tab" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " naviga \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " ", enter, " \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "hash   " }), _jsx(Text, { color: field === 'hash' ? 'yellow' : undefined, children: hash }), field === 'hash' ? _jsx(Text, { inverse: true, children: " " }) : null, !hash ? _jsx(Text, { dimColor: true, children: "  (vuoto = tutte le conversazioni)" }) : null] }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "chiave " }), _jsx(Text, { color: field === 'query' ? 'yellow' : undefined, children: query }), field === 'query' ? _jsx(Text, { inverse: true, children: " " }) : null] }), _jsx(ToggleHint, { opts: opts })] }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsx(SearchListHeader, { result: result, query: query, above: above, below: below }), rows.slice(0, Math.max(0, capacity)).map((row) => {
+                        const sel = row.key === selectedKey;
+                        if (row.kind === 'session') {
+                            const s = row.session;
+                            const bound = bindings.get(s.sessionId);
+                            return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, pinned.has(s.sessionId) ? _jsx(Text, { color: "yellow", children: "\uD83D\uDCCC" }) : _jsx(Text, { dimColor: true, children: "\u25CB" }), ' ', _jsx(Text, { color: "cyan", children: s.sessionId.slice(0, 8) }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), bound ?? _jsx(Text, { dimColor: true, children: "spot" }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), truncate(conversationLabel(s, projectCore, bound), searchTitleWidth(columns)), _jsxs(Text, { dimColor: true, children: ['  ', "(", row.hitCount, row.hidden > 0 ? `+${row.hidden}` : '', ") ", fmtDateTime(s.ts)] })] }, row.key));
+                        }
+                        const h = row.hit;
+                        return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: String(h.idx).padStart(4) }), ' ', _jsx(Text, { color: KIND_COLOR[h.kind], children: KIND_TAG[h.kind] }), " ", h.excerpt] }, row.key));
+                    })] }), preview ? _jsx(SearchPreviewPane, { p: preview }) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: normalizeEmoji(note) }) : null] }));
+}
+/**
+ * Anteprima dell'occorrenza selezionata, sotto la lista.
+ *
+ * Riempie le righe che la lista non usa: con pochi risultati il terminale
+ * resterebbe vuoto per tre quarti, e il contesto attorno al match è proprio
+ * ciò che serve per decidere se è l'occorrenza giusta. Nel caso comune evita
+ * del tutto di aprire il reader.
+ *
+ * Si aggiorna navigando con le frecce, e la finestra è centrata sul match:
+ * stessa `windowRange` della lista, stessa evidenziazione del reader
+ * (`ReaderLine`) — nessuna primitiva nuova.
+ */
+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)))] }));
+}
+/**
+ * Reader fullscreen (T52 · D8).
+ *
+ * Mostra il messaggio INTERO che contiene l'occorrenza, aperto già posizionato
+ * sul match e con il match evidenziato. È un `mode` a sé, catturato prima del
+ * ramo `search`: il modale ricerca resta montato sotto e su `esc` si ritrova
+ * con query, toggle e selezione intatti.
+ */
+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))) })] }));
+}
+/** 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) {
+        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)] }));
+}
 function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, childCount, focused, loadError, detail, windowStart, above, below, detailLines, columns, }) {
     const spotSelected = selected === 0;
     return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: ["Tasks (", hidden > 0 ? `${filtered}/${total}` : filtered, ")", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", hidden, " nascoste"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort: ", describeSort(view.sort), view.hiddenPri.length + view.hiddenProg.length > 0 ? (_jsxs(Text, { children: [' ', "\u00B7 filtri:", ' ', [

package/dist/search.js

@@ -0,0 +1,262 @@
+// T52 — Core della ricerca full-text nelle conversazioni del progetto.
+//
+// Modulo PURO, gemello di `session-list.ts`: nessun import da ink/react, nessun
+// I/O, nessuno stato globale. Prende in ingresso le `Session` già parsate
+// dall'adapter (con i `bodies` trattenuti dalla cache mtime-keyed) e restituisce
+// le righe da renderizzare. Tutto ciò che è testabile senza terminale sta qui.
+//
+// Invarianti (decisioni congelate al preflight):
+//  - D3: perimetro = SOLO le sessioni del progetto corrente. Il modulo cerca su
+//    ciò che gli viene passato, e chi lo chiama passa `discoverProjectSessions`.
+//  - D5: ricerca IN MEMORIA sui corpi, nessun prefiltro esterno. Un solo motore
+//    di regex (`RegExp` JS) sia in modalità literal sia in `^R` → non esiste il
+//    caso "il prefiltro scarta un file che contiene un'occorrenza reale".
+//  - D6: tre kind (ai · tool · human). Il `thinking` non è persistito.
+//  - D7: la riga-occorrenza porta l'indice del record; la data sta una volta
+//    sola sulla riga-sessione.
+//  - Trap T39/T50: la selezione è keyed su una CHIAVE DISCRIMINATA, mai su
+//    indice posizionale — la lista si riordina a ogni carattere digitato.
+/** Sotto questa soglia non si cerca: 1-2 char matchano ovunque e la lista
+ *  sarebbe rumore. Stato lecito, non un errore. */
+export const MIN_QUERY = 3;
+/** Larghezza di ripiego dell'estratto, usata solo quando il chiamante non
+ *  conosce le colonne del terminale (test, uso non-TUI). In UI la larghezza
+ *  arriva SEMPRE da `columns`: inchiodarla qui sprecherebbe tutto lo spazio di
+ *  un terminale largo — su 190 colonne significa ~140 buttate per riga. */
+export const EXCERPT_WIDTH = 50;
+/** Cap per singola conversazione. Serve a tenere leggibile un gruppo, non a
+ *  proteggere la memoria: una query corta può matchare centinaia di volte nello
+ *  stesso transcript e sommergere tutte le altre conversazioni. */
+export const MAX_HITS_PER_SESSION = 20;
+/** Cap globale. Oltre, la lista non è più navigabile a mano: la risposta giusta
+ *  è restringere la query, e il contatore delle nascoste lo dice. */
+export const MAX_TOTAL_HITS = 400;
+export const DEFAULT_OPTIONS = {
+    regex: false,
+    caseSensitive: false,
+    wholeWord: false,
+    // D4/§Filtro: il testo IA è il caso d'uso che ha generato la task («l'IA me
+    // l'ha detto 150k fa»); tools e human si accendono a mano.
+    kinds: { ai: true, tool: false, human: false },
+};
+const EMPTY = {
+    groups: [],
+    shown: 0,
+    hidden: 0,
+    sessionCount: 0,
+    error: '',
+    idle: true,
+};
+function escapeLiteral(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Compila la query nel matcher.
+ *
+ * Ritorna `{re: null, error}` invece di lanciare: con la ricerca eager la regex
+ * viene ricompilata a ogni carattere, e uno stato intermedio invalido (`[a-`,
+ * `(`) è 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)
+        return { re: null, error: '' };
+    let source = opts.regex ? query : escapeLiteral(query);
+    // Il gruppo non-catturante è obbligatorio: senza, `\b` si legherebbe al solo
+    // primo/ultimo ramo di un'alternativa (`\bfoo|bar\b` ≠ `\b(?:foo|bar)\b`).
+    if (opts.wholeWord)
+        source = `\\b(?:${source})\\b`;
+    const flags = opts.caseSensitive ? 'g' : 'gi';
+    try {
+        return { re: new RegExp(source, flags), error: '' };
+    }
+    catch (e) {
+        return { re: null, error: e.message };
+    }
+}
+/**
+ * Estratto centrato sul match.
+ *
+ * Il testo è RAW (newline incluse) e gli offset sono suoi: si affetta prima e si
+ * collassa il whitespace dopo, su ciascun pezzo separatamente. Collassare prima
+ * sposterebbe gli offset; collassare l'intera finestra insieme fonderebbe i
+ * confini del match con il contesto.
+ *
+ * Degrada ai bordi: match a inizio o fine messaggio prende tutto il contesto
+ * disponibile dal lato che ce l'ha, invece di lasciare metà estratto vuoto.
+ */
+export function excerptAround(text, start, end, width = EXCERPT_WIDTH) {
+    const collapse = (s) => s.replace(/\s+/g, ' ');
+    // Un match più lungo dell'estratto: si tronca il match stesso, altrimenti la
+    // riga andrebbe a capo e sfonderebbe il budget d'altezza della lista.
+    if (end - start >= width) {
+        return collapse(text.slice(start, start + width - 1)).trimEnd() + '…';
+    }
+    const budget = width - (end - start);
+    // Metà per lato, poi il lato che non riesce a spendere la sua quota (match a
+    // ridosso di un bordo) la cede all'altro.
+    let before = Math.floor(budget / 2);
+    let after = budget - before;
+    const availBefore = start;
+    const availAfter = text.length - end;
+    if (before > availBefore) {
+        after += before - availBefore;
+        before = availBefore;
+    }
+    if (after > availAfter) {
+        before = Math.min(availBefore, before + (after - availAfter));
+        after = availAfter;
+    }
+    const from = start - before;
+    const to = end + after;
+    const head = collapse(text.slice(from, start));
+    const mid = collapse(text.slice(start, end));
+    const tail = collapse(text.slice(end, to));
+    return (from > 0 ? '…' : '') + head + mid + tail + (to < text.length ? '…' : '');
+}
+/**
+ * Scansiona un corpo: materializza al più `need` occorrenze, ma le CONTA tutte.
+ *
+ * I due numeri sono separati apposta. Fermare anche il conteggio al cap
+ * renderebbe silenziosa proprio la troncatura che il contatore deve dichiarare
+ * («+N occorrenze»), e il conteggio è la parte economica — costruire un Hit
+ * significa costruire un estratto, scorrere la stringa no.
+ *
+ * `re` deve avere il flag `g` (lo garantisce buildMatcher).
+ */
+function scanBody(sessionId, body, re, need, excerptWidth) {
+    const hits = [];
+    let count = 0;
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(body.text)) !== null) {
+        count++;
+        if (hits.length < need) {
+            const start = m.index;
+            const end = start + m[0].length;
+            hits.push({
+                sessionId,
+                idx: body.idx,
+                kind: body.kind,
+                excerpt: excerptAround(body.text, start, end, excerptWidth),
+                matchStart: start,
+                matchEnd: end,
+                text: body.text,
+            });
+        }
+        // Una regex può matchare la stringa vuota (`a*`, `^`): senza avanzare a
+        // mano, `exec` resta fermo sullo stesso indice e il ciclo non termina mai.
+        if (m[0].length === 0)
+            re.lastIndex++;
+    }
+    return { hits, count };
+}
+/**
+ * Cerca su tutte le sessioni passate.
+ *
+ * `hashPrefix` restringe a una conversazione per PREFISSO del sessionId, non per
+ * uguaglianza: gli 8 char che la statusline mostra bastano a individuarla, e
+ * nessuno copia un uuid intero a mano.
+ */
+export function searchSessions(sessions, hashPrefix, query, opts, excerptWidth = EXCERPT_WIDTH) {
+    const prefix = hashPrefix.trim().toLowerCase();
+    const scoped = prefix
+        ? sessions.filter((s) => s.sessionId.toLowerCase().startsWith(prefix))
+        : sessions;
+    const { re, error } = buildMatcher(query, opts);
+    if (error)
+        return { ...EMPTY, idle: false, error };
+    if (!re)
+        return EMPTY;
+    const groups = [];
+    let shown = 0;
+    let hidden = 0;
+    for (const session of scoped) {
+        const hits = [];
+        let found = 0;
+        for (const body of session.bodies) {
+            if (!opts.kinds[body.kind])
+                continue;
+            // Quanto ancora si può MATERIALIZZARE: il minore fra spazio nel gruppo e
+            // spazio nella lista. A zero la scansione prosegue lo stesso — serve il
+            // conteggio, che è ciò che alimenta «+N occorrenze».
+            const need = Math.max(0, Math.min(MAX_HITS_PER_SESSION - hits.length, MAX_TOTAL_HITS - shown - hits.length));
+            const r = scanBody(session.sessionId, body, re, need, excerptWidth);
+            found += r.count;
+            hits.push(...r.hits);
+        }
+        if (found === 0)
+            continue;
+        hidden += found - hits.length;
+        if (hits.length === 0)
+            continue; // tutte tagliate dal cap globale
+        groups.push({ session, hits, hidden: found - hits.length });
+        shown += hits.length;
+    }
+    return { groups, shown, hidden, sessionCount: groups.length, error: '', idle: false };
+}
+/** Chiave discriminata di una riga-occorrenza. `matchStart` è nella chiave
+ *  perché due match nello stesso record sono righe distinte. */
+function hitKey(h) {
+    return `hit:${h.sessionId}:${h.idx}:${h.kind}:${h.matchStart}`;
+}
+/**
+ * Appiattisce i gruppi in righe.
+ *
+ * Con `hashPrefix` valorizzato la lista è PIATTA: la conversazione è una sola e
+ * già nominata nel campo hash, quindi la riga-sessione ripeterebbe un dato
+ * costante rubando una riga per gruppo.
+ */
+export function buildRows(result, flat) {
+    const rows = [];
+    for (const g of result.groups) {
+        if (!flat) {
+            rows.push({
+                kind: 'session',
+                key: `sess:${g.session.sessionId}`,
+                session: g.session,
+                hitCount: g.hits.length,
+                hidden: g.hidden,
+            });
+        }
+        for (const h of g.hits)
+            rows.push({ kind: 'hit', key: hitKey(h), hit: h });
+    }
+    return rows;
+}
+/**
+ * Riga su cui atterrare quando la selezione va ricostruita.
+ *
+ * Preferisce la prima **occorrenza**, non la prima riga in assoluto. In modalità
+ * raggruppata la lista si apre sempre con una riga-sessione, che è un
+ * segnaposto di navigazione e non una destinazione: atterrarci lascerebbe
+ * l'anteprima vuota all'apertura di ogni ricerca, e `⏎` prometterebbe un resume
+ * quando l'utente ha appena cercato delle occorrenze.
+ *
+ * Le righe-sessione restano raggiungibili con le frecce. null = lista vuota.
+ */
+export function firstRowKey(rows) {
+    return (rows.find((r) => r.kind === 'hit') ?? rows[0])?.key ?? null;
+}
+/** Indice della riga con quella chiave; -1 se assente. */
+export function rowIndexOfKey(rows, key) {
+    if (key === null)
+        return -1;
+    return rows.findIndex((r) => r.key === key);
+}
+/** Sposta la selezione di `delta` righe. Chiave persa (la lista è cambiata sotto)
+ *  → prima riga; lista vuota → null. */
+export function moveRowSelection(rows, currentKey, delta) {
+    if (rows.length === 0)
+        return null;
+    const cur = rowIndexOfKey(rows, currentKey);
+    if (cur < 0)
+        return rows[0].key;
+    return rows[Math.max(0, Math.min(rows.length - 1, cur + delta))].key;
+}
+/** Riga selezionata, o null. */
+export function selectedRow(rows, key) {
+    if (key === null)
+        return null;
+    return rows.find((r) => r.key === key) ?? null;
+}

package/dist/sessions.js

@@ -45,6 +45,91 @@ function extractText(message) {
     }
     return '';
 }
+// Un record `type:user` che porta SOLO questo testo è un evento di UI (l'utente
+// ha premuto esc), non un messaggio scritto. Stesso `type` di un prompt vero:
+// senza escluderlo comparirebbe come «primo prompt» della conversazione e
+// gonfierebbe la ricerca sui messaggi umani. Prefisso e non uguaglianza —
+// esistono varianti («…by user for tool use»).
+const INTERRUPT_MARKER = '[Request interrupted by user';
+function isInterrupt(text) {
+    return text.trimStart().startsWith(INTERRUPT_MARKER);
+}
+// T52 — estrae i corpi cercabili di UN record, uno per `kind` presente.
+//
+// Blocchi dello stesso kind nello stesso record vengono CONCATENATI, non emessi
+// separatamente: il reader promette «il messaggio intero», e la coppia
+// (idx, kind) resta così una chiave univoca per la riga-occorrenza.
+//
+// Mappatura dei blocchi, verificata sullo store:
+//  - assistant `text`            → ai
+//  - assistant `tool_use`        → tool  (nome + input serializzato: il comando
+//                                  eseguito è ciò che si cerca, non il wrapper)
+//  - assistant `thinking`        → SCARTATO: il campo `thinking` è SEMPRE ''
+//                                  (persistita solo la `signature`, la firma
+//                                  crittografica). Indicizzarlo produrrebbe una
+//                                  categoria che non può mai dare un risultato.
+//  - user stringa nuda / `text`  → human
+//  - user `tool_result`          → tool  (viaggia come type:user, ma non è
+//                                  scritto da un umano)
+//
+// `isAssistant` arriva dal `type` del RECORD, non da `message.role`: è il campo
+// su cui il resto del parser già dispatcha (i due combaciano sullo store attuale
+// — verificato — ma dipendere da uno solo evita che divergano in silenzio).
+function collectBodies(message, idx, isAssistant, out) {
+    if (!message || typeof message !== 'object')
+        return;
+    const content = message.content;
+    const parts = { ai: [], tool: [], human: [] };
+    if (typeof content === 'string') {
+        if (content)
+            parts[isAssistant ? 'ai' : 'human'].push(content);
+    }
+    else if (Array.isArray(content)) {
+        for (const block of content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const b = block;
+            if (b.type === 'text' && typeof b.text === 'string' && b.text) {
+                parts[isAssistant ? 'ai' : 'human'].push(b.text);
+            }
+            else if (b.type === 'tool_use') {
+                const name = typeof b.name === 'string' ? b.name : 'tool';
+                let input = '';
+                try {
+                    input = JSON.stringify(b.input ?? {});
+                }
+                catch {
+                    input = ''; // input ciclico/non serializzabile → resta il solo nome
+                }
+                parts.tool.push(`${name} ${input}`);
+            }
+            else if (b.type === 'tool_result') {
+                const r = b.content;
+                if (typeof r === 'string') {
+                    if (r)
+                        parts.tool.push(r);
+                }
+                else if (Array.isArray(r)) {
+                    for (const rb of r) {
+                        if (rb && typeof rb === 'object' && rb.type === 'text') {
+                            const t = rb.text;
+                            if (typeof t === 'string' && t)
+                                parts.tool.push(t);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for (const kind of ['ai', 'tool', 'human']) {
+        const text = parts[kind].join('\n');
+        if (!text)
+            continue;
+        if (kind === 'human' && isInterrupt(text))
+            continue;
+        out.push({ idx, kind, text });
+    }
+}
 // Cache mtime-keyed: re-parse solo i file cambiati. Steady-state di una TUI che
 // poll-a resta economico anche con decine di sessioni multi-MB. Lo stato vive
 // dentro l'adapter così l'invariante "unico modulo che tocca lo store" regge.
@@ -57,6 +142,18 @@ function parseSessionFile(path, mtime, sizeBytes) {
     catch {
         return null;
     }
+    return parseTranscript(content, path, mtime, sizeBytes);
+}
+/**
+ * Semantica del transcript, separata dalla lettura del file.
+ *
+ * L'I/O resta in `parseSessionFile` (l'invariante «unico modulo che tocca lo
+ * store» vale per QUESTO file, non per la funzione): qui c'è solo la parte non
+ * ovvia — cosa conta come turno, cosa è un corpo cercabile, quali record sono
+ * eventi di UI travestiti da messaggi. È anche l'unica parte che vale la pena
+ * testare, e su una stringa si testa senza inventare un finto `~/.claude`.
+ */
+export function parseTranscript(content, path, mtime, sizeBytes) {
     let sessionId = basename(path).replace(/\.jsonl$/, '');
     let cwd = '';
     let gitBranch = '';
@@ -65,6 +162,8 @@ function parseSessionFile(path, mtime, sizeBytes) {
     let firstUserText = '';
     let lastAssistantText = '';
     let turns = 0;
+    const bodies = [];
+    let recordIdx = -1;
     for (const line of content.split('\n')) {
         if (!line.trim())
             continue;
@@ -75,6 +174,12 @@ function parseSessionFile(path, mtime, sizeBytes) {
         catch {
             continue;
         }
+        // Indice progressivo sui soli record VALIDI: è ciò che prefissa la
+        // riga-occorrenza, quindi deve contare come li conta chi legge il file.
+        recordIdx++;
+        if (d.type === 'user' || d.type === 'assistant') {
+            collectBodies(d.message, recordIdx, d.type === 'assistant', bodies);
+        }
         if (typeof d.sessionId === 'string' && d.sessionId)
             sessionId = d.sessionId;
         if (!cwd && typeof d.cwd === 'string' && d.cwd)
@@ -89,8 +194,11 @@ function parseSessionFile(path, mtime, sizeBytes) {
         if (d.type === 'user') {
             // T49: turno = prompt umano. I tool_result viaggiano anch'essi come
             // type:user ma senza blocchi text → extractText '' li esclude.
+            // T52: e nemmeno l'interruzione da esc è un prompt — stesso `type`, ma è
+            // un evento di UI. Senza il filtro gonfia i turni e può diventare il
+            // «primo prompt» mostrato nel detail pane.
             const t = extractText(d.message);
-            if (t) {
+            if (t && !isInterrupt(t)) {
                 turns++;
                 if (!firstUserText)
                     firstUserText = t;
@@ -120,6 +228,7 @@ function parseSessionFile(path, mtime, sizeBytes) {
         customTitle,
         firstPrompt: firstUserText,
         lastReply: lastAssistantText,
+        bodies,
     };
 }
 // Discovery read-only delle sessioni del SOLO progetto corrente (D2 preflight

package/dist/viewport.js

@@ -78,6 +78,13 @@ export const MODAL_HEIGHT = {
     sort: 5, // marginTop + 2 bordi + titolo + 1 riga catena
     filter: 6, // marginTop + 2 bordi + titolo + 2 righe (pri, stato)
     edit: 8, // marginTop + 2 bordi + titolo + 3 campi + riga anteprima
+    // T52 — search e reader sono gli unici modali NON in flusso: sostituiscono i
+    // due pane invece di spingerli giù (una lista di occorrenze non entra in un
+    // box sopra il deck). Costo 0 nel budget dei pane perché quel budget non
+    // viene nemmeno calcolato: il render esce prima. La loro altezza la
+    // distribuiscono `searchListCapacity`/`readerCapacity`.
+    search: 0,
+    reader: 0,
 };
 /**
  * Distribuisce le righe disponibili fra lista task, lista sessioni e dettaglio.
@@ -164,6 +171,114 @@ export function layoutBudget(input) {
         compact: false,
     };
 }
+// T52 — cornice fissa della schermata di ricerca. Stesso vincolo del deck
+// normale (il frame non deve superare `rows`), contabilità separata perché la
+// schermata è sostitutiva, non additiva.
+//
+//   2  bordi del box esterno
+//   1  titolo "loom-deck"
+//   1  riga hint/legenda tasti
+//   1  marginTop del box query
+//   2  bordi del box query
+//   3  righe del box query: hash · chiave · toggle
+//   1  marginTop del box lista
+//   2  bordi del box lista
+//   1  header della lista (conteggi)
+const SEARCH_CHROME = 14;
+/** Righe di lista occorrenze che entrano nel terminale. Zero = la cornice non
+ *  ci sta nemmeno vuota → la schermata va sostituita (vedi `isCompact`). */
+export function searchListCapacity(rows, noteLine) {
+    return Math.max(0, (rows || 24) - SLACK - SEARCH_CHROME - (noteLine ? 1 : 0));
+}
+// T52 — cornice del reader fullscreen.
+//   2  bordi del box esterno
+//   1  titolo "loom-deck"
+//   1  riga meta (sessione · record · tipo · posizione)
+//   1  riga hint
+//   1  marginTop del box corpo
+//   2  bordi del box corpo
+const READER_CHROME = 8;
+/** Righe di testo del messaggio che entrano nel terminale. */
+export function readerCapacity(rows) {
+    return Math.max(0, (rows || 24) - SLACK - READER_CHROME);
+}
+// T52 — cornice del pannello di anteprima sotto la lista occorrenze:
+// marginTop + 2 bordi + riga meta.
+const SEARCH_PREVIEW_CHROME = 4;
+/**
+ * Righe di contesto concesse all'anteprima dell'occorrenza selezionata.
+ *
+ * Prende SOLO ciò che avanza: la lista si dimensiona sul contenuto e, quando i
+ * risultati sono pochi, il resto del terminale resterebbe vuoto. Con molti
+ * risultati lo spazio torna alla lista e il pannello sparisce da sé — la
+ * priorità è vedere quante più occorrenze possibile, il contesto è il premio
+ * per una ricerca già stretta.
+ *
+ * Restituisce 0 quando non c'è spazio nemmeno per una riga utile: un pannello
+ * di sola cornice ruberebbe 4 righe per non mostrare nulla.
+ */
+export function searchPreviewCapacity(capacity, listRows) {
+    return Math.max(0, capacity - listRows - SEARCH_PREVIEW_CHROME);
+}
+/**
+ * Il terminale non ospita nemmeno la cornice della schermata: va sostituita da
+ * una riga singola, come fa `Budget.compact` per il deck.
+ *
+ * Non è una comodità estetica ed è lo stesso ragionamento del layout a box: un
+ * frame più alto di `rows` fa cadere Ink nel ramo `clearTerminal`, che su
+ * VTE/Ptyxis riversa ogni redraw nello scrollback. Un terminale basso è proprio
+ * la condizione che innesca quel ramo, quindi qui il fallback È il fix.
+ */
+export function isCompact(capacity) {
+    return capacity < 1;
+}
+/**
+ * A-capo che PRESERVA la struttura del testo e traccia gli offset.
+ *
+ * Distinto da `wrapLines`, che collassa tutto in un flusso unico: lì serviva una
+ * preview compatta di 2-4 righe, qui si legge un messaggio intero — appiattire
+ * le newline renderebbe illeggibile qualunque blocco di codice o elenco.
+ *
+ * Ogni riga prodotta è una FETTA CONTIGUA del sorgente: è ciò che permette di
+ * intersecarla con l'intervallo del match e colorare solo la parte giusta,
+ * anche quando il match cade a cavallo di due righe.
+ *
+ * Taglia sull'ultimo spazio disponibile; una parola più larga della riga viene
+ * spezzata a forza, altrimenti l'a-capo lo farebbe il terminale — fuori dal
+ * conteggio delle righe, cioè di nuovo un frame più alto di `rows`.
+ */
+export function wrapWithOffsets(text, width) {
+    const out = [];
+    if (width <= 0)
+        return out;
+    let base = 0;
+    for (const raw of text.split('\n')) {
+        // Tab e CR diventano UN singolo spazio, non quattro: la sostituzione deve
+        // conservare la lunghezza, o gli offset delle righe smettono di indicizzare
+        // il sorgente e il match verrebbe evidenziato spostato. Un tab lasciato
+        // passare sarebbe l'errore opposto — lo conteremmo 1 e il terminale 8.
+        const line = raw.replace(/[\t\r]/g, ' ');
+        if (line.length === 0) {
+            out.push({ text: '', start: base, end: base });
+        }
+        let pos = 0;
+        while (pos < line.length) {
+            if (line.length - pos <= width) {
+                out.push({ text: line.slice(pos), start: base + pos, end: base + line.length });
+                break;
+            }
+            let brk = line.lastIndexOf(' ', pos + width);
+            if (brk <= pos)
+                brk = pos + width; // parola più lunga della riga
+            out.push({ text: line.slice(pos, brk), start: base + pos, end: base + brk });
+            pos = brk;
+            while (line[pos] === ' ')
+                pos++; // lo spazio del taglio non apre la riga dopo
+        }
+        base += raw.length + 1; // +1 = il '\n' consumato dallo split
+    }
+    return out;
+}
 /**
  * Finestra scorrevole su una lista più lunga della capienza.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.13.0",
+  "version": "0.15.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": {