@lamemind/loom-deck 0.34.0 → 0.34.2

package/dist/ui/panes.js

@@ -0,0 +1,220 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// I due pane della vista principale — task e sessioni — con i rispettivi
+// header. Sono presentazionali puri: ricevono la vista già selezionata e le
+// larghezze già calcolate, non li derivano.
+import { Box, Text } from 'ink';
+import { cut, cutParts, pad, sanitize, termWidth } from '../width.js';
+import { isDone, paneTextWidth } from '../layout.js';
+import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, displayProg, relTime, } from '../glyphs.js';
+import { META_ROWS, ROW_ALL, ROW_SPOT } from '../model.js';
+import { rowLabel, sessionTitle } from '../session-list.js';
+import { sessionView, taskView, SESSION_VIEWS, TASK_VIEWS, } from '../pane-views.js';
+import { describeSort, PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
+/**
+ * Header del pane task, tagliato QUI e non da Ink — stesso motivo del gemello
+ * `SessionsHeader`, con una differenza di rischio: qui i segmenti sono tutti
+ * ASCII più le frecce `↑↓` (larghe 1), quindi `cli-truncate` oggi darebbe la
+ * riga giusta per caso. Il taglio resta del deck perché la correttezza non deve
+ * dipendere dall'alfabeto che capita nella riga: il primo glifo largo 2 che
+ * entrasse in un segmento nuovo riaprirebbe il difetto in silenzio, e a
+ * scoprirlo sarebbe il bordo del pane a schermo.
+ *
+ * `truncate-end` taglia dalla coda, e `cutParts` conserva l'ordine: l'ultimo
+ * segmento resta il primo a cedere il posto (`↑↓` in coda alle voci navigabili).
+ *
+ * T100 — la riga non è più informativa: le voci del catalogo sono SELEZIONABILI
+ * con `tab`, e l'attiva si distingue in video inverso (D5 — costa 0 colonne e non
+ * entra in gara con la semantica di colore già occupata). Le voci ci sono tutte
+ * anche a 0 (D1): un catalogo che si accorcia sposta le voci sotto le dita.
+ * L'ordine è vincolato — le navigabili PRIMA di `↑N`/`↓N`, che cadono per primi
+ * su un terminale stretto — e la voce attiva ha la precedenza sul budget (D6).
+ */
+export function TasksHeader({ counts, active, above, below, focused, columns, }) {
+    const views = TASK_VIEWS.map((v, i) => {
+        const n = v.count(counts);
+        return {
+            // Il separatore sta nel segmento, non fra i segmenti: `cutParts` misura la
+            // riga pezzo per pezzo e uno spazio fuori dai pezzi non verrebbe contato.
+            text: `${i > 0 ? ' · ' : ''}${v.label(counts)}`,
+            color: v.color,
+            dim: v.dim || n === 0,
+            active: v.id === active,
+        };
+    });
+    const segments = [
+        ...views,
+        { text: above > 0 ? ` · ↑${above}` : '', dim: true, active: false, color: undefined },
+        { text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false, color: undefined },
+    ];
+    const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns), segments.findIndex((s) => s.active));
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
+}
+export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, }) {
+    const allSelected = selected === ROW_ALL;
+    const spotSelected = selected === ROW_SPOT;
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(TasksHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
+                    (view.hiddenPri.length + view.hiddenProg.length > 0
+                        ? ' · filtri: ' +
+                            [
+                                ...PRI_ENTRIES.filter((e) => view.hiddenPri.includes(e.name)),
+                                ...PROG_ENTRIES.filter((e) => view.hiddenProg.includes(e.name)),
+                            ]
+                                .map((e) => `−${e.glyph}`)
+                                .join(' ')
+                        : '')), paneTextWidth(columns)) }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", allCount > 0 ? ` (${allCount})` : ''] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : paneCount === 0 ? (
+            // T100/D1 — una voce a contatore 0 resta navigabile, e selezionarla dà
+            // una lista vuota che DICE perché è vuota. Senza la nota il pane si
+            // legge come rotto: le righe meta restano, le task no, e niente spiega
+            // che è la vista scelta a non contenere nulla.
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(taskView(activeView).empty, paneTextWidth(columns)) })) : (tasks.map((task, i) => {
+                // windowStart riporta l'indice di finestra a quello della lista
+                // completa, su cui è keyata la selezione. +META_ROWS: le prime due
+                // righe sono le meta.
+                const sel = windowStart + i + META_ROWS === selected;
+                const n = childCount.get(task.id) ?? 0;
+                // Invariante ③: la descrizione è l'unico pezzo a lunghezza libera, e
+                // si taglia QUI sul budget che resta dopo le colonne fisse. Lasciarlo
+                // fare a `truncate-end` significa passare da `cli-truncate`, che
+                // restituisce una riga più larga del pane (una colonna per emoji) e
+                // quindi scrive sopra il bordo. Le parti fisse si misurano con
+                // `termWidth`: `task.id` è `T9` o `T52`, i due glifi valgono 2 ciascuno.
+                const head = `${CARET_OFF}${task.id}  ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
+                const tail = n > 0 ? ` (${n})` : '';
+                const desc = cut(task.desc, Math.max(4, paneTextWidth(columns) - termWidth(head) - termWidth(tail)));
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
+            }))] }));
+}
+/**
+ * Header del pane sessioni, tagliato QUI e non da Ink.
+ *
+ * `📌{pinnedCount}` è un glifo largo 2 in mezzo alla riga: con
+ * `wrap="truncate-end"` il taglio passava da `cli-truncate`, che indicizza per
+ * code point con un budget in colonne e restituiva una riga larga 45 su un
+ * budget di 44 — la colonna in più finiva sopra il bordo destro del pane, che
+ * spariva dalla riga (invariante ③ di `width.ts`).
+ *
+ * I segmenti restano segmenti fino al render: il taglio è della RIGA (budget
+ * condiviso, `cutParts`), la resa è del pezzo. Il giallo su `📌N` distingue le
+ * pinnate dal resto dell'header e non è decorazione.
+ */
+export function SessionsHeader({ parentLabel, counts, active, above, below, focused, columns, }) {
+    const views = SESSION_VIEWS.map((v) => {
+        const n = v.count(counts);
+        return {
+            text: ` · ${v.label(counts, parentLabel)}`,
+            color: v.color,
+            dim: v.dim || n === 0,
+            active: v.id === active,
+        };
+    });
+    const segments = [
+        // `Sessions` non è una voce del catalogo: nomina il pane, non un
+        // sottoinsieme, quindi non è raggiungibile con le frecce.
+        { text: 'Sessions', color: undefined, dim: false, active: false },
+        ...views,
+        { text: above > 0 ? ` · ↑${above}` : '', dim: true, active: false, color: undefined },
+        { text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false, color: undefined },
+    ];
+    const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns), segments.findIndex((s) => s.active));
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
+}
+export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows, counts, activeView, paneCount, selectedId, focused, above, below, columns, forkOf, sessionNotes, projectCore, live, }) {
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(SessionsHeader, { parentLabel: parentLabel, counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), paneCount === 0 ? (
+            // T100 — la nota della vista di default resta quella storica, che nomina
+            // il PARENT (task, spot o tutte); le altre tre viste portano la propria,
+            // che nomina il sottoinsieme. Sono due vuoti diversi: «questo parent non
+            // ha conversazioni» e «questo sottoinsieme del parent è vuoto».
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(sessionView(activeView).empty ??
+                    (isAll
+                        ? 'nessuna conversazione nel progetto'
+                        : isSpot
+                            ? 'nessuna sessione libera'
+                            : 'nessuna sessione legata a questa task'), paneTextWidth(columns)) })) : (rows.map((row, i) => {
+                // T50 — separatore leggero fra pinnate e contestuali: riga dim, non un
+                // box pesante (coerente con lo styling delle Done dimmate).
+                if (row.kind === 'separator') {
+                    return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: SESSION_SEP }, `sep${i}`));
+                }
+                const sel = row.sessionId === selectedId;
+                // T50 — pin stale: transcript sparito, nessuna Session da mostrare.
+                // Riga navigabile e spinnabile (`p`), marcata, mai un crash.
+                if (row.kind === 'pinned' && row.stale) {
+                    // T60 — anche qui la nota si taglia sul budget DERIVATO, non su un
+                    // 30 inchiodato: su un pane stretto quel valore fisso mandava la
+                    // riga oltre il bordo, e a ripararla arrivava `cli-truncate` (che
+                    // sfora di una colonna per emoji e mangia il bordo stesso).
+                    const staleNote = sessionNotes.get(row.sessionId);
+                    // La riga stale è libera (niente colonne: non ha né titolo né
+                    // data), ma il binding va detto lo stesso — è una pinnata, quindi
+                    // l'header del pane non ne dice l'appartenenza.
+                    const staleTask = bindings.get(row.sessionId) ?? null;
+                    const staleW = Math.max(0, paneTextWidth(columns) -
+                        (2 /* caret */ +
+                            termWidth(`${WARN} pin stale `) +
+                            SID_CHARS +
+                            (staleTask ? termWidth(staleTask) + 1 : 0) +
+                            3 /* spazio + caporali */));
+                    return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: true, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { color: "yellow", children: WARN }), " pin stale", ' ', _jsx(Text, { dimColor: true, children: row.sessionId.slice(0, SID_CHARS) }), staleTask ? _jsxs(Text, { color: "green", children: [" ", staleTask] }) : null, staleNote ? _jsxs(Text, { color: "yellow", children: [" \u00AB", cut(staleNote, staleW), "\u00BB"] }) : null] }, row.sessionId));
+                }
+                const s = row.session; // non-stale → session presente
+                const isPinnedRow = row.kind === 'pinned';
+                // T28 — un ramo eredita il titolo dell'origine: senza marcatore le due
+                // righe sarebbero identiche a occhio.
+                const forked = forkOf.has(s.sessionId);
+                // T59 D2 — nella vista "tutte" il marker è PER-SESSIONE (binding letto
+                // dal sidecar) e non deciso dal parent: la lista mescola scoped e spot,
+                // quindi un marker uniforme mentirebbe su metà delle righe. E il solo
+                // glifo direbbe *che* la conversazione è legata senza dire *a cosa* —
+                // informazione monca proprio qui, l'unica vista dove l'appartenenza
+                // non è scritta da nessun'altra parte dello schermo: da qui la colonna
+                // task accanto, che esiste solo in questa vista.
+                const bound = bindings.get(s.sessionId) ?? null;
+                const linked = isAll ? Boolean(bound) : !isSpot;
+                // T62 — liveness e binding sono ORTOGONALI: la cella marker dice a chi
+                // appartiene la conversazione (pin/task/spot), questa dice se è aperta
+                // adesso. Farle condividere una cella perderebbe una delle due.
+                const liveEntry = live.get(s.sessionId);
+                // Stesso motivo per cui la colonna esiste: una pinnata resta in lista
+                // qualunque sia il parent selezionato, quindi l'header non ne dice
+                // l'appartenenza e la cella va riempita anche fuori dalla vista
+                // "tutte". Sulle contestuali, dove l'header parla già, resta vuota —
+                // ma la cella è comunque larga `taskW`, o le colonne a destra
+                // slitterebbero riga per riga.
+                const taskCell = isAll || isPinnedRow ? (bound ?? TASK_EMPTY) : '';
+                // T60 — colonne VERE: ogni cella fissa è larga esattamente quanto
+                // dichiara, riempita di spazi con `pad` (che misura in colonne, non in
+                // caratteri). Il marker va portato a 2 anche quando è `○`, largo 1:
+                // era lui a far slittare a sinistra di una colonna tutta la riga di
+                // ogni sessione spot.
+                const age = relTime(s.ts);
+                // Il taglio del titolo è ciò che RESTA, calcolato per sottrazione: le
+                // colonne fisse sono note, quindi l'unica cella elastica prende il
+                // resto. Pavimento `0` e non un minimo di cortesia — è un tetto, non
+                // una preferenza: alzarlo sopra lo spazio reale fa uscire la riga dal
+                // pane e le mangia il bordo (invariante ③).
+                const titleW = Math.max(0, paneTextWidth(columns) -
+                    (2 /* caret */ +
+                        2 /* marker */ +
+                        1 /* gutter */ +
+                        1 /* T62 · colonna liveness */ +
+                        SID_CHARS +
+                        1 /* gutter */ +
+                        (taskW > 0 ? taskW + 1 : 0) +
+                        1 /* gutter prima della data */ +
+                        ageW));
+                // T28 — `⑂` sta DENTRO la cella titolo, non in una colonna sua: una
+                // colonna dedicata costerebbe 2 spazi vuoti su ogni riga non-fork, e
+                // metterlo fuori cella sposterebbe il bordo del titolo solo sui rami —
+                // cioè rimetterebbe lo slittamento che le colonne tolgono.
+                const forkMark = forked ? '⑂ ' : '';
+                const inner = Math.max(0, titleW - termWidth(forkMark));
+                // T60 — il testo arriva già ripulito di ciò che le colonne accanto
+                // dicono già (progetto e task id): senza, la cella conterrebbe
+                // `🧵 loom-works · T59` accanto a una colonna che dice `T59`.
+                const label = rowLabel(sessionTitle(s, projectCore, bound), sessionNotes.get(s.sessionId), inner);
+                const used = (label.note ? termWidth(label.note) + 2 : 0) +
+                    (label.note && label.rest ? 1 : 0) +
+                    termWidth(label.rest);
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: pad('📌', 2) })) : linked ? (_jsx(Text, { color: "green", children: pad('🔗', 2) })) : (_jsx(Text, { dimColor: true, children: pad('○', 2) })), ' ', _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : undefined, children: liveEntry ? (liveEntry.status === 'busy' ? LIVE_BUSY : LIVE_IDLE) : LIVE_NONE }), _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : 'cyan', bold: Boolean(liveEntry), children: s.sessionId.slice(0, SID_CHARS) }), ' ', taskW > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: bound && taskCell ? 'green' : undefined, dimColor: !bound, children: pad(taskCell, taskW) }), ' '] })) : null, forkMark ? _jsx(Text, { color: "magenta", children: forkMark }) : null, label.note ? (_jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", label.note, "\u00BB"] })) : null, label.note && label.rest ? ' ' : null, label.rest ? _jsx(Text, { dimColor: Boolean(label.note), children: label.rest }) : null, ' '.repeat(Math.max(0, inner - used)), ' ', _jsx(Text, { dimColor: true, children: pad(age, ageW, 'right') })] }, s.sessionId));
+            }))] }));
+}

package/dist/ui/preview.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Blocco preview a piena larghezza sotto i due pane: mostra la task o la
+// conversazione selezionata a seconda del pane a fuoco.
+import { Box, Text } from 'ink';
+import { wrapLines } from '../width.js';
+import { previewTextWidth } from '../layout.js';
+import { LIVE_BUSY, LIVE_IDLE, META_KEYS, SID_CHARS, fmtDateTime, fmtSize } from '../glyphs.js';
+export function PreviewPane(p) {
+    return (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: p.kind === 'task' ? (_jsx(TaskPreview, { detail: p.detail, maxLines: p.maxLines, columns: p.columns })) : (_jsx(SessionPreview, { s: p.s, firstLines: p.firstLines, lastLines: p.lastLines, columns: p.columns, origin: p.origin, note: p.note, live: p.live })) }));
+}
+// T49 — corpo della preview sessione. Tutti i campi vengono dal parse già
+// cached dell'adapter (mtime-keyed): non costa I/O al movimento di selezione.
+// Mostra "da dove parte, dove è arrivata": il primo prompt utente (`» `) e
+// l'ultima risposta del modello (`« `). L'anteprima del primo prompt compare
+// SOLO con un titolo custom — senza, il titolo È già il primo prompt e la riga
+// lo duplicherebbe (D4 preflight). Le righe rese non superano mai il riservato
+// dal budget (`firstLines`/`lastLines`); renderne meno è sicuro (frame più corto).
+export function SessionPreview({ s, firstLines, lastLines, columns, origin, note, live, }) {
+    const width = previewTextWidth(columns);
+    const first = s.customTitle && firstLines > 0 ? wrapLines(s.firstPrompt, width, firstLines) : [];
+    const last = s.lastReply && lastLines > 0 ? wrapLines(s.lastReply, width, lastLines) : [];
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', note ? _jsxs(Text, { color: "yellow", children: ["\u00AB", note, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : '', live ? (_jsx(Text, { color: live.status === 'busy' ? 'yellow' : 'green', children: ` · ${live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE} viva pid ${live.pid} (${live.status})` })) : null] }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
+}
+/**
+ * Righe non-wrappabili del dettaglio (titolo + meta + commit) e loro conteggio.
+ * Estratto dal componente perché il budget deve saperlo PRIMA di renderizzare:
+ * sono righe fisse che tolgono spazio alla descrizione.
+ */
+export function detailMetaOf(detail) {
+    const meta = META_KEYS.map((k) => detail.fields[k])
+        .filter(Boolean)
+        .join('  ·  ');
+    const commit = detail.fields['Last tracked commit'] ?? '';
+    return { meta, commit, metaLines: 1 + (meta ? 1 : 0) + (commit ? 1 : 0) };
+}
+/** Corpo della preview task: titolo, meta, descrizione wrappata, commit. */
+export function TaskPreview({ detail, maxLines, columns, }) {
+    const { meta, commit } = detailMetaOf(detail);
+    // Wrap calcolato qui, non delegato a `<Text wrap="wrap">`: il budget ha
+    // riservato ESATTAMENTE `maxLines` righe, e un wrap deciso da Ink a runtime
+    // ne produrrebbe un numero che il budget non conosce — cioè il frame torna a
+    // sforare e il bug si riapre da questa singola casella di testo.
+    const lines = wrapLines(detail.description ?? '', previewTextWidth(columns), maxLines);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: detail.title || detail.id }), meta ? _jsx(Text, { dimColor: true, wrap: "truncate-end", children: meta }) : null, lines.map((line, i) => (_jsx(Text, { wrap: "truncate-end", children: line }, i))), commit ? _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", commit] }) : null] }));
+}

package/dist/ui/search-screen.js

@@ -0,0 +1,115 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+// Schermate SOSTITUTIVE della ricerca full-text (T52): lista delle occorrenze
+// e reader del messaggio aperto. Prendono l'intero frame — il budget dei due
+// pane non viene nemmeno calcolato.
+import { Box, Text } from 'ink';
+import { cut, sanitize, termWidth } from '../width.js';
+import { sliceLine } from '../text-search.js';
+import { MIN_QUERY } from '../search.js';
+import { KIND_LABEL } from '../model.js';
+import { conversationLabel, searchExcerptWidth, searchTitleWidth } from '../layout.js';
+import { CARET, CARET_OFF, WARN, fmtDateTime } from '../glyphs.js';
+// 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 width.ts).
+export const KIND_TAG = { ai: 'ai', tool: 'tl', human: 'hu' };
+export const KIND_COLOR = { ai: 'cyan', tool: 'gray', human: 'green' };
+/**
+ * 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.
+ */
+export 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). */
+export 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] }));
+}
+export function SearchScreen({ preview, hash, query, field, opts, result, rows, selectedKey, selectedKind, above, below, capacity, bindings, pinned, sessionNotes, 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);
+                            const rowNote = sessionNotes.get(s.sessionId);
+                            const noteShown = rowNote ? cut(rowNote, 24) : '';
+                            // `+3` = i due caporali e lo spazio che li separa dall'etichetta.
+                            // Il pavimento non è cosmetico: senza, un terminale stretto manda
+                            // l'argomento di `cut` sotto zero, cioè un budget negativo.
+                            // La nota si misura con `termWidth`, non con `.length`: contiene
+                            // testo umano, emoji compresi.
+                            const restWidth = Math.max(8, searchTitleWidth(columns) - (noteShown ? termWidth(noteShown) + 3 : 0));
+                            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 " }), noteShown ? _jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", noteShown, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(noteShown), children: cut(conversationLabel(s, projectCore, bound), restWidth) }), _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] }), ' ', cut(h.excerpt, searchExcerptWidth(columns))] }, row.key));
+                    })] }), preview ? _jsx(SearchPreviewPane, { p: preview }) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(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.
+ */
+export function SearchPreviewPane({ p }) {
+    const last = Math.min(p.total, p.from + p.lines.length);
+    const occ = [{ start: p.hit.matchStart, end: p.hit.matchEnd }];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["record ", p.hit.idx, " \u00B7 ", KIND_LABEL[p.hit.kind], p.ts ? ` · ${fmtDateTime(p.ts)}` : '', " \u00B7 righe ", p.from + 1, "-", last, " di ", p.total, " \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " apre il reader"] }), p.lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, p.from + i)))] }));
+}
+/**
+ * Reader fullscreen (T52 · D8).
+ *
+ * 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.
+ */
+export function ReaderScreen({ hit, lines, top, total, capacity, bound, }) {
+    const last = Math.min(total, top + capacity);
+    const occ = [{ start: hit.matchStart, end: hit.matchEnd }];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["reader \u00B7 ", _jsx(Text, { color: "cyan", children: hit.sessionId.slice(0, 8) }), " \u00B7 record ", hit.idx, " \u00B7", ' ', KIND_LABEL[hit.kind], bound ? ` · ${bound}` : '', " \u00B7 righe ", total === 0 ? 0 : top + 1, "-", last, " di ", total] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g" }), " inizio \u00B7 ", _jsx(Text, { color: "yellow", children: "G" }), " fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " torna alla lista"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, top + i))) })] }));
+}
+/** Una riga con le porzioni di match evidenziate. Gli offset sono quelli del
+ *  testo sorgente, quindi un match a cavallo dell'a-capo si colora su entrambe
+ *  le righe senza casi speciali — entrambe intersecano il suo intervallo.
+ *
+ *  Regge N occorrenze perché il detail (T91) ne mostra tutte quelle visibili; il
+ *  reader (T52) ne passa una sola, che è il caso degenere dello stesso taglio. */
+export function ReaderLine({ line, occ, current, }) {
+    const segs = sliceLine(line.text, line.start, occ, current);
+    if (segs.length === 0)
+        return _jsx(Text, { wrap: "truncate-end", children: line.text || ' ' });
+    return (_jsx(Text, { wrap: "truncate-end", children: segs.map((s, i) => s.hit ? (
+        // La corrente si distingue dalle altre per COLORE di sfondo, non per
+        // presenza: tutte restano visibili, o navigare fra occorrenze non
+        // mostrerebbe più dove sono le altre.
+        _jsx(Text, { backgroundColor: s.current ? 'cyan' : 'yellow', color: "black", children: s.text }, i)) : (_jsx(Text, { children: s.text }, i))) }));
+}

package/dist/viewport.js

@@ -217,13 +217,14 @@ export function readerCapacity(rows) {
 //   1  marginTop del box testo
 //   2  bordi del box testo
 //   1  marginTop della riga azioni
+//   1  riga modello (T108)
 //   1  riga azioni
 //
-// Le ultime due sono il motivo per cui il detail non può riusare READER_CHROME:
-// la barra bottoni è una riga FISSA in più dentro l'overlay, e ogni riga fissa
-// aggiunta va scalata dalla capienza del contenuto o il frame sfonda `rows`
-// (stessa invariante di TASKS_PANE_CHROME).
-const DETAIL_CHROME = 10;
+// Le ultime tre sono il motivo per cui il detail non può riusare READER_CHROME:
+// barra bottoni e selettore modello sono righe FISSE in più dentro l'overlay, e
+// ogni riga fissa aggiunta va scalata dalla capienza del contenuto o il frame
+// sfonda `rows` (stessa invariante di TASKS_PANE_CHROME).
+const DETAIL_CHROME = 11;
 // T91 — la ricerca dentro il detail: marginTop + riga del campo.
 //
 // `MODAL_HEIGHT` dice che il detail costa 0 ai due pane (li sostituisce), e da

package/package.json

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

package/scripts/deck-run

@@ -8,16 +8,19 @@
 # "recap stato task <TaskID>" — no skill, solo recap → più controllo).
 # Riusabile identico da TUI (Ink) e da web.
 #
-# Tre assi ORTOGONALI, da non confondere fra loro:
+# Quattro assi ORTOGONALI, da non confondere fra loro:
 #   binding task   <TaskID> ..... --no-task
 #   continuità     nuova ........ --resume [--fork]
 #   prompt         --prompt-kind none|recap|preflight|run|checkpoint
+#   modello        --model fable|opus|sonnet|haiku
 # Il terzo asse (T56) prima non esisteva: il prompt era una CONSEGUENZA degli
 # altri due (bound ⇒ recap, --no-task ⇒ niente, --resume ⇒ niente), quindi
 # "task-bound SENZA prompt" era inesprimibile e l'unico modo di non avere un
 # prompt era perdere la task. Il catalogo dei prompt vive qui e non nel deck
 # perché questo è il primitive UI-agnostico: il chiamante passa un SIMBOLO, non
 # una stringa — il quoting resta verificato in un posto solo (vedi PROMPT sotto).
+# Il quarto asse (T108) è indipendente dagli altri tre: vale sul ramo bound come
+# su --no-task, su una sessione nuova come su una ripresa.
 #
 # Con --no-task la sessione è NUDA: niente LOOM_TASK, niente prompt iniziale,
 # niente --session-id. Serve al lavoro spot che non appartiene a nessuna task.
@@ -43,6 +46,7 @@
 #   LOOM_DECK_STATE_PROFILE  PTYXIS_PROFILE annunciata a compass (default: bindings/claude
 #                            del progetto, letto da dconf; settata a vuoto = nessun annuncio)
 #   LOOM_DECK_PERMISSION_MODE  override del permissionMode del file config (default: campo file, poi 'manual')
+#   LOOM_DECK_MODEL        modello quando --model non è passato (default: opus)
 #
 set -euo pipefail
 
@@ -56,6 +60,10 @@ TITLE_NOTE=""
 # "kind implicito" da "kind chiesto", perché con --no-task il primo è legittimo
 # (nessun prompt, come sempre) e il secondo è un errore d'uso.
 PROMPT_KIND=""
+# Vuoto = flag non passato: la cascata (env, poi default) si risolve più sotto,
+# insieme alla validazione, così l'ingresso da argomento e quello da env passano
+# per lo stesso enum.
+MODEL=""
 # Positional <TaskID> + flag opzionale --session-id <uuid> (T27): il deck genera
 # l'UUID e lo pinna così il binding sidecar sessionId↔taskId è deterministico.
 # --no-task (T42): modalità NUDA, senza TaskID — nessuna LOOM_TASK, nessun prompt
@@ -84,8 +92,17 @@ PROMPT_KIND=""
 # (emoji/name dal file committato, TaskID) sono controllati — quindi il testo non
 # si quota, si RIDUCE a un alfabeto sicuro (vedi _sane_note): tutto ciò che non
 # ci rientra sparisce, apici inclusi.
+# --model <fable|opus|sonnet|haiku> (T108): modello della sessione. Enum e non
+# stringa libera perché il valore finisce dentro `bash -lc` e un refuso
+# produrrebbe una tab con un comando che il CLI rifiuta. Le voci sono ALIAS e
+# restano tali: espanderle a id versionati (`claude-opus-5`) cablerebbe qui una
+# generazione, che al primo bump diventa un modello inesistente.
 while [[ $# -gt 0 ]]; do
   case "$1" in
+    --model)
+      MODEL="${2:-}"; shift 2 ;;
+    --model=*)
+      MODEL="${1#*=}"; shift ;;
     --title-note)
       TITLE_NOTE="${2:-}"; shift 2 ;;
     --title-note=*)
@@ -112,7 +129,7 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-USAGE="uso: deck-run <TaskID> [--prompt-kind <kind>] [--session-id <uuid>]
+USAGE="uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--session-id <uuid>]
                                                    (es. deck-run T18)
      | deck-run --no-task                          (sessione nuda, senza task)
      | deck-run <TaskID> --resume <uuid>           (riprende sessione scoped)
@@ -127,6 +144,9 @@ USAGE="uso: deck-run <TaskID> [--prompt-kind <kind>] [--session-id <uuid>]
        run         /loom-works:run-task <TaskID>
        checkpoint  /loom-works:checkpoint-task <TaskID>
 
+  --model        modello della sessione: fable|opus|sonnet|haiku (default: opus)
+                 valore ignoto → fallback sul default, con avviso su stderr
+
   --title-note   nota della conversazione, appesa al titolo tab come «nota»
                  (ridotta a lettere/cifre/spazi/-/_, cap 60 char)"
 
@@ -274,6 +294,28 @@ case "${PERM_MODE:-}" in
 esac
 MODE_FLAG="--permission-mode ${PERM_MODE} "
 
+# ── modello (T108) ───────────────────────────────────────────────────────────
+# Precedenza: --model > env LOOM_DECK_MODEL > 'opus'. Nessun campo nel file
+# config: il default è unico per tutta la famiglia, e uno scalare per-progetto
+# aggiungerebbe una chiave allo schema del plugin per un valore che il selettore
+# del deck sovrascrive a ogni spawn.
+# Il flag è passato SEMPRE, anche sul default, per la stessa ragione di
+# permissionMode: lo spawn resta leggibile nel process tree invece di dipendere
+# dal default del CLI, che cambia fra versioni.
+# Valore fuori enum → fallback con avviso, non exit. Regime opposto a
+# --prompt-kind, e il discriminante è dove finisce il valore: un kind ignoto si
+# ferma DENTRO lo script (nessun template da scegliere, l'errore è del deck),
+# un modello ignoto arriverebbe al CLI e produrrebbe una tab con un comando che
+# fallisce all'avvio — cioè il guasto che permissionMode evita degradando.
+MODEL="${MODEL:-${LOOM_DECK_MODEL:-}}"
+case "${MODEL:-}" in
+  fable|opus|sonnet|haiku) ;;
+  '') MODEL="opus" ;;
+  *)  echo "modello ignoto: '${MODEL}' → fallback 'opus' (usa fable|opus|sonnet|haiku)" >&2
+      MODEL="opus" ;;
+esac
+MODEL_FLAG="--model ${MODEL} "
+
 # ── Profilo di stato per compass ─────────────────────────────────────────────
 # Lo stato di una sessione (running/ask/done) viaggia verso compass via D-Bus
 # keyed su $PTYXIS_PROFILE (hook Claude → `compass <stato>`), e compass lo mappa
@@ -388,10 +430,13 @@ PROMPT_ARG=""
 # PROFILE_ENV in testa a entrambi i rami: lo stato è una proprietà della SESSIONE
 # (esiste anche senza task), esattamente come la label del titolo — legarlo al
 # ramo task-bound ripeterebbe l'errore di layer già evitato per la titolazione.
+# MODEL_FLAG in entrambi i rami e prima dei flag di continuità: il modello è la
+# scelta di chi apre la sessione, non una proprietà della task né della ripresa
+# (T108) — stesso layer di MODE_FLAG, che infatti gli sta accanto.
 if [[ $NO_TASK -eq 1 ]]; then
-  _default_intab="${PROFILE_ENV}claude --name '${TITLE}' ${MODE_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}"
+  _default_intab="${PROFILE_ENV}claude --name '${TITLE}' ${MODE_FLAG}${MODEL_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}"
 else
-  _default_intab="${PROFILE_ENV}LOOM_TASK=${TASK} claude --name '${TITLE}' ${MODE_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}${PROMPT_ARG}"
+  _default_intab="${PROFILE_ENV}LOOM_TASK=${TASK} claude --name '${TITLE}' ${MODE_FLAG}${MODEL_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}${PROMPT_ARG}"
 fi
 IN_TAB_CMD="${LOOM_DECK_INTAB_CMD:-$_default_intab}"