@lamemind/loom-deck 0.12.0 → 0.14.0

package/dist/search.js

@@ -0,0 +1,250 @@
+// 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 nominale dell'estratto attorno al match. */
+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) {
+    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),
+                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) {
+    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);
+            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;
+}
+/** Prima riga selezionabile; null = lista vuota. Ogni riga è selezionabile —
+ *  non esiste un separatore, a differenza di `session-list.ts`. */
+export function firstRowKey(rows) {
+    return 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/session-list.js

@@ -0,0 +1,80 @@
+// T50 — Assemblaggio della lista sessioni a DUE gruppi: pinnate (sempre in
+// lista, in cima) + separatore + contestuali (figlie del parent selezionato).
+// Modulo PURO: nessun import da ink/react, nessun I/O → testabile senza terminale
+// (il pacchetto non ha infrastruttura TUI di test, solo unit sui core puri).
+//
+// Invarianti (decisioni congelate al preflight):
+//  - D2: dentro il blocco pinnate l'ordine è di PIN stabile (ultima pinnata in
+//    cima), dato dal rango del sidecar `session-tasks.jsonl` — non `ts desc`.
+//  - Dedup: una sessione sia pinnata sia contestuale compare SOLO fra le pinnate.
+//  - Cap: `maxContext` limita SOLO le contestuali; le pinnate sono esenti. Il
+//    conteggio delle troncate (`contextHidden`) resta esposto (non-silenzioso).
+//  - D3: una pinnata il cui transcript non esiste più è una riga STALE (session
+//    null), navigabile e spinnabile — non sparisce in silenzio.
+//  - Trap T39: la selezione è KEYED SU sessionId, non su indice posizionale. La
+//    lista è una vista trasformata (due gruppi + separatore): un indice grezzo
+//    identificherebbe la riga sbagliata dopo un pin/cambio-contesto.
+export function assembleSessionList(childSessions, allSessions, pinned, maxContext) {
+    // Le pinnate si risolvono contro TUTTE le sessioni del progetto, non solo le
+    // figlie del parent: una pinnata può appartenere a un'altra task. Assente
+    // dallo store → stale.
+    const byId = new Map(allSessions.map((s) => [s.sessionId, s]));
+    const pinnedIds = [...pinned.entries()]
+        .sort((a, b) => b[1] - a[1]) // rango desc → ultima pinnata in cima (D2)
+        .map(([id]) => id);
+    const pinnedRows = pinnedIds.map((id) => {
+        const session = byId.get(id) ?? null;
+        return { kind: 'pinned', sessionId: id, session, stale: session === null };
+    });
+    const pinnedSet = new Set(pinnedIds);
+    const dedupedContext = childSessions.filter((s) => !pinnedSet.has(s.sessionId));
+    const shownContext = dedupedContext.slice(0, Math.max(0, maxContext));
+    const contextRows = shownContext.map((s) => ({
+        kind: 'context',
+        sessionId: s.sessionId,
+        session: s,
+    }));
+    const rows = [...pinnedRows];
+    // Separatore SOLO fra due gruppi entrambi non vuoti: senza pinnate o senza
+    // contestuali non c'è confine da segnare.
+    if (pinnedRows.length > 0 && contextRows.length > 0)
+        rows.push({ kind: 'separator' });
+    rows.push(...contextRows);
+    return {
+        rows,
+        pinnedCount: pinnedRows.length,
+        contextTotal: dedupedContext.length,
+        contextHidden: dedupedContext.length - shownContext.length,
+    };
+}
+function isSelectable(r) {
+    return r.kind !== 'separator';
+}
+/** Primo id selezionabile (salta il separatore); null = lista senza righe. */
+export function firstSelectableId(rows) {
+    return rows.find(isSelectable)?.sessionId ?? null;
+}
+/** Indice della riga con quel sessionId nell'ARRAY COMPLETO (per il windowing);
+ *  -1 se assente o id null. Il separatore non ha id → mai matchato. */
+export function rowIndexOf(rows, sessionId) {
+    if (sessionId === null)
+        return -1;
+    return rows.findIndex((r) => isSelectable(r) && r.sessionId === sessionId);
+}
+/** Sposta la selezione di `delta` fra le sole righe selezionabili (attraversa il
+ *  separatore senza fermarcisi). Id perso → prima riga; lista vuota → null. */
+export function moveSelection(rows, currentId, delta) {
+    const selectable = rows.filter(isSelectable);
+    if (selectable.length === 0)
+        return null;
+    const cur = selectable.findIndex((r) => r.sessionId === currentId);
+    if (cur < 0)
+        return selectable[0].sessionId;
+    const next = Math.max(0, Math.min(selectable.length - 1, cur + delta));
+    return selectable[next].sessionId;
+}
+/** Session della riga selezionata; null se stale o nessuna selezione. */
+export function selectedSession(rows, sessionId) {
+    const r = rows.find((row) => isSelectable(row) && row.sessionId === sessionId);
+    return r && isSelectable(r) ? r.session : 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/task-index.js

@@ -11,6 +11,10 @@ export function appendSessionRecord(projectRoot, rec) {
 export function appendTaskBinding(projectRoot, sessionId, taskId) {
     appendSessionRecord(projectRoot, { sessionId, taskId });
 }
+/** T50 — pin/unpin (toggle): append immediato, il reader risolve last-wins. */
+export function appendPin(projectRoot, sessionId, pinned) {
+    appendSessionRecord(projectRoot, { sessionId, pinned });
+}
 // Una sola lettura del JSONL per entrambe le mappe: il deck poll-a l'indice a
 // ogni tick, leggere il file due volte raddoppierebbe l'I/O per nulla.
 // Last-wins per campo (un re-pin dello stesso sessionId sovrascrive), e i due
@@ -19,13 +23,15 @@ export function appendTaskBinding(projectRoot, sessionId, taskId) {
 export function loadSessionIndex(projectRoot) {
     const bindings = new Map();
     const forkOf = new Map();
+    const pinned = new Map();
     let content;
     try {
         content = readFileSync(taskIndexPath(projectRoot), 'utf8');
     }
     catch {
-        return { bindings, forkOf };
+        return { bindings, forkOf, pinned };
     }
+    let order = 0; // posizione crescente dei record pinned → rango di pin (D2)
     for (const line of content.split('\n')) {
         if (!line.trim())
             continue;
@@ -37,10 +43,18 @@ export function loadSessionIndex(projectRoot) {
                 bindings.set(d.sessionId, d.taskId);
             if (typeof d.forkOf === 'string')
                 forkOf.set(d.sessionId, d.forkOf);
+            // last-wins per campo: un `pinned:false` finale rimuove il pin, un
+            // `pinned:true` (ri)assegna il rango con la posizione corrente nel file.
+            if (typeof d.pinned === 'boolean') {
+                if (d.pinned)
+                    pinned.set(d.sessionId, order++);
+                else
+                    pinned.delete(d.sessionId);
+            }
         }
         catch {
             // riga corrotta → skip
         }
     }
-    return { bindings, forkOf };
+    return { bindings, forkOf, pinned };
 }

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,96 @@ 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);
+}
+/**
+ * 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.12.0",
+  "version": "0.14.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": {