@lamemind/loom-deck 0.14.0 → 0.15.0

package/README.md

@@ -148,7 +148,19 @@ 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**.
+(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`

package/dist/cli.js

@@ -13,7 +13,7 @@ import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions
 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 { isCompact, layoutBudget, normalizeEmoji, readerCapacity, searchListCapacity, windowRange, wrapLines, wrapWithOffsets, } 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';
@@ -497,11 +497,19 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // ≤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), [sessions, searchHash, searchQuery, searchOpts]);
+    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.
@@ -673,22 +681,52 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         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 più veloce di una read — arriva come stringa unica,
-    // byte di controllo compresi. Senza filtro finiscono DENTRO la query: non si
-    // vedono, ma Ink li conta nella larghezza della riga e nessun match li
-    // soddisfa, quindi la ricerca smette di trovare senza dire perché.
-    // Le newline diventano spazio invece di sparire: incollare due righe deve
-    // separare le parole, non fonderle.
+    // 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) {
-        const clean = chunk.replace(/[\r\n\t]/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '');
-        if (clean)
-            editSearchField((s) => s + clean);
+        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) => {
@@ -1095,7 +1133,26 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         }
         const selIdx = rowIndexOfKey(searchRows, searchSelKey);
         const win = windowRange(searchRows.length, selIdx, searchCap);
-        return (_jsx(SearchScreen, { 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, note: note }));
+        // 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
@@ -1171,6 +1228,31 @@ function EditModal({ id, draft, row }) {
 // 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.
  *
@@ -1227,27 +1309,34 @@ function SearchListHeader({ result, query, above, below, }) {
     }
     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] }));
 }
-/**
- * Schermata di ricerca full-text (T52).
- *
- * Due campi + toggle + lista di occorrenze. Con l'hash vuoto la lista è
- * raggruppata per conversazione: la riga-gruppo NON ripete il nome del progetto
- * (D3: sono tutte dello stesso progetto, sarebbe una colonna costante) e usa lo
- * spazio per ciò che distingue davvero una conversazione — hash, task legata,
- * titolo, data.
- */
-function SearchScreen({ hash, query, field, opts, result, rows, selectedKey, selectedKind, above, below, capacity, bindings, pinned, projectCore, note, }) {
+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), 44), _jsxs(Text, { dimColor: true, children: ['  ', "(", row.hitCount, row.hidden > 0 ? `+${row.hidden}` : '', ") ", fmtDateTime(s.ts)] })] }, row.key));
+                            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));
-                    })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: normalizeEmoji(note) }) : null] }));
+                    })] }), 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).

package/dist/search.js

@@ -19,7 +19,10 @@
 /** 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. */
+/** 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
@@ -121,7 +124,7 @@ export function excerptAround(text, start, end, width = EXCERPT_WIDTH) {
  *
  * `re` deve avere il flag `g` (lo garantisce buildMatcher).
  */
-function scanBody(sessionId, body, re, need) {
+function scanBody(sessionId, body, re, need, excerptWidth) {
     const hits = [];
     let count = 0;
     re.lastIndex = 0;
@@ -135,7 +138,7 @@ function scanBody(sessionId, body, re, need) {
                 sessionId,
                 idx: body.idx,
                 kind: body.kind,
-                excerpt: excerptAround(body.text, start, end),
+                excerpt: excerptAround(body.text, start, end, excerptWidth),
                 matchStart: start,
                 matchEnd: end,
                 text: body.text,
@@ -155,7 +158,7 @@ function scanBody(sessionId, body, re, need) {
  * 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) {
+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))
@@ -178,7 +181,7 @@ export function searchSessions(sessions, hashPrefix, query, opts) {
             // 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);
+            const r = scanBody(session.sessionId, body, re, need, excerptWidth);
             found += r.count;
             hits.push(...r.hits);
         }
@@ -221,10 +224,19 @@ export function buildRows(result, flat) {
     }
     return rows;
 }
-/** Prima riga selezionabile; null = lista vuota. Ogni riga è selezionabile —
- *  non esiste un separatore, a differenza di `session-list.ts`. */
+/**
+ * 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[0]?.key ?? null;
+    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) {

package/dist/viewport.js

@@ -202,6 +202,24 @@ const READER_CHROME = 8;
 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.

package/package.json

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