@lamemind/loom-deck 0.16.0 → 0.18.0

package/dist/cli.js

@@ -10,10 +10,11 @@ import { dirname, join } from 'node:path';
 import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, } from './tasks.js';
 import { discoverProjectSessions } from './sessions.js';
 import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions, selectedRow, DEFAULT_OPTIONS, MIN_QUERY, } from './search.js';
-import { appendPin, appendSessionRecord, appendTaskBinding, loadSessionIndex, } from './task-index.js';
-import { assembleSessionList, firstSelectableId, moveSelection, rowIndexOf, selectedSession, } from './session-list.js';
+import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, loadSessionIndex, } from './task-index.js';
+import { assembleSessionList, firstSelectableId, moveSelection, rowIndexOf, rowLabel, selectedSession, stripProjectCore, } from './session-list.js';
 import { launchLegend, loadIdentity, loadLaunch } from './config.js';
-import { isCompact, layoutBudget, normalizeEmoji, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, wrapLines, wrapWithOffsets, } from './viewport.js';
+import { isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
+import { cut, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.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';
@@ -284,6 +285,7 @@ function useSessions(projectRoot) {
         bindings: new Map(),
         forkOf: new Map(),
         pinned: new Map(),
+        notes: new Map(),
     });
     // T50 — pin/unpin scrive il sidecar e vuole feedback IMMEDIATO, non al
     // prossimo tick del poll (1.5s): la reload è esposta via ref così il toggle la
@@ -300,23 +302,25 @@ function useSessions(projectRoot) {
             }
             catch {
                 sessions = [];
-                index = { bindings: new Map(), forkOf: new Map(), pinned: new Map() };
+                index = { bindings: new Map(), forkOf: new Map(), pinned: new Map(), notes: new Map() };
             }
-            const { bindings, forkOf, pinned } = index;
-            // La signature copre anche fork e pin: un record di lineage o un toggle di
-            // pin appena scritto cambia la lista renderizzata, quindi deve forzare il
-            // re-render come farebbe un binding nuovo.
+            const { bindings, forkOf, pinned, notes } = index;
+            // La signature copre anche fork, pin e note: un record di lineage, un
+            // toggle di pin o una nota appena scritta cambiano la lista renderizzata,
+            // quindi devono forzare il re-render come farebbe un binding nuovo.
             const sig = sessions.map((s) => `${s.sessionId}:${s.ts}`).join('|') +
                 '#' +
                 [...bindings.entries()].map(([k, v]) => `${k}=${v}`).sort().join(',') +
                 '#' +
                 [...forkOf.entries()].map(([k, v]) => `${k}<${v}`).sort().join(',') +
                 '#' +
-                [...pinned.entries()].map(([k, v]) => `${k}@${v}`).sort().join(',');
+                [...pinned.entries()].map(([k, v]) => `${k}@${v}`).sort().join(',') +
+                '#' +
+                [...notes.entries()].map(([k, v]) => `${k}"${v}`).sort().join(',');
             if (sig === lastSig)
                 return;
             lastSig = sig;
-            setState({ sessions, bindings, forkOf, pinned });
+            setState({ sessions, bindings, forkOf, pinned, notes });
         };
         reloadRef.current = reload;
         reload();
@@ -336,47 +340,23 @@ function useTaskDetail(tasksDir, id) {
     }, [tasksDir, id]);
     return detail;
 }
-// Collassa gli spazi (description multi-paragrafo → blocco unico wrappabile) e
-// tronca: il pane resta compatto e d'altezza prevedibile sotto la lista.
-function truncate(s, n) {
-    const flat = s.replace(/\s+/g, ' ').trim();
-    return flat.length > n ? flat.slice(0, n - 1).trimEnd() + '…' : flat;
-}
-// Normalizzazione larghezza glifi → `normalizeEmoji` in viewport.ts.
-//
-// Sostituisce il precedente `forceEmojiWidth`, che aveva l'intuizione giusta
-// (timbrare il VS16) ma due limiti che lasciavano passare il difetto:
-//  - agiva solo su stringhe di UN codepoint, quindi non toccava mai un testo
-//    composto — la riga della legenda launch, una descrizione task con emoji
-//    dentro, il titolo di una sessione;
-//  - decideva per intervallo di codepoint invece che per larghezza misurata,
-//    quindi avrebbe timbrato anche `↓` `↑` `−` (larghi 1) se gli fossero
-//    arrivati da soli, accorciando la riga invece di allargarla.
-const forceEmojiWidth = normalizeEmoji;
-// Glifi LETTERALI del JSX che ricadono nella classe mal misurata (BMP largo 2
-// senza VS16). I dati passano dai loader, questi no: normalizzati una volta
-// qui, così nessun sito di render li scrive nudi. `↳ ○ ▸ ⏎ · − ↑ ↓` sono
-// larghi 1 e restano intatti.
-const CARET = normalizeEmoji('▶ ');
+// Glifi LETTERALI del JSX. I dati passano dai loader, che sanificano al
+// confine; questi no — quindi passano da `sanitize` una volta qui, così nessun
+// sito di render scrive un glifo nudo. `↳ ○ ▸ ⏎ · − ↑ ↓` sono già concordi e
+// restano intatti; `▶` e `⚠` sono discordi e vengono sostituiti (`width.ts`).
+const CARET = sanitize('▶ ');
 const CARET_OFF = '  ';
-// T50 — glifo warning della riga pin-stale: BMP largo 2 senza VS16 → va timbrato
-// (come CARET), altrimenti la riga slitta di una colonna.
-const WARN = normalizeEmoji('⚠');
+const WARN = sanitize('⚠');
 // T50 — separatore leggero fra blocco pinnate e contestuali. `─` (box-drawing) è
-// largo 1 sia per string-width sia per il terminale → nessun timbro. Corto +
+// largo 1 sia per string-width sia per il terminale. Corto +
 // wrap="truncate-end" così non va mai a capo nel pane al 50%.
 const SESSION_SEP = '─'.repeat(16);
-// Normalizza il marker Done per il display. `✔` (U+2714) è text-presentation-
-// default: string-width — quindi Ink, sia per il layout sia per il troncamento —
-// lo misura 2 (rispetta il VS16 di `✔️`), ma VTE/Ptyxis lo disegna largo 1
-// (ignora il VS16). Risultato: le righe Done finivano 1 colonna più strette del
-// riservato → la coda della riga (bordo destro del pane incluso) slittava a
-// sinistra, sfasando il layout solo su quelle righe. `✅` (U+2705) è invece
-// emoji-presentation-default → largo 2 sia per string-width sia per il terminale,
-// come 🔵/🟡: colonna Prog allineata. Cambia SOLO il display: `task.prog` resta
-// `✔️` così `isDone()` continua a matchare.
+// Marker Done per il DISPLAY. `task.prog` resta il `✔️` letto da tasks.md —
+// `isDone()` e le lookup di `view.ts` ci confrontano sopra, e `task-edit` lo
+// riscrive sul file: è una chiave semantica, non testo. Qui `sanitize` lo
+// traduce nel suo gemello concorde (`✅`) solo per finire nel frame.
 function displayProg(prog) {
-    return forceEmojiWidth(prog.replace(/✔️?/g, '✅'));
+    return sanitize(prog);
 }
 // T49 — size umana compatta per il detail pane sessione.
 function fmtSize(bytes) {
@@ -406,11 +386,28 @@ function relTime(ts) {
         return `${hr}h`;
     return `${Math.floor(hr / 24)}d`;
 }
+/**
+ * Ripulisce un chunk di stdin prima di scriverlo in un campo di testo.
+ *
+ * `useInput` consegna il CHUNK letto da stdin, non un tasto: un incollaggio — o
+ * una raffica piu' veloce di una read — arriva come stringa unica, byte di
+ * controllo compresi. Non si vedono a schermo, ma Ink li conta nella larghezza
+ * della riga, e in un campo che finisce su disco (la nota, T53) resterebbero
+ * li' per sempre. Le newline diventano SPAZIO invece di sparire: incollare due
+ * righe deve separare le parole, non fonderle.
+ */
+function sanitizeTyped(s) {
+    return s.replace(/[\r\n]/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '');
+}
 const META_KEYS = ['Priority', 'Size', 'Estimated Time', 'Progress'];
 function Deck({ cwd, tasksPath, tasksDir }) {
     const { exit } = useApp();
     const { tasks, loadError } = useTasks(tasksPath);
-    const { sessions, bindings, forkOf, pinned, reload: reloadSessions } = useSessions(cwd);
+    // `notes` esce dall'indice come `sessionNotes`: in questo componente `note` è
+    // già la riga di STATO in fondo al frame (il feedback di un'azione). Due
+    // concetti diversi a una lettera di distanza sarebbero una trappola di
+    // lettura — e di scrittura, visto che `setNote` compare in quasi ogni ramo.
+    const { sessions, bindings, forkOf, pinned, notes: sessionNotes, reload: reloadSessions, } = useSessions(cwd);
     const [focus, setFocus] = useState('tasks');
     // T39 — selezione KEYED SU ID, non su indice. Con una vista trasformata
     // (filtro/sort) l'indice non identifica più la stessa task: leggere l'array
@@ -426,6 +423,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // T30 create · T39 sort/filter.
     const [mode, setMode] = useState('normal');
     const [draft, setDraft] = useState('');
+    // T53 — bozza della nota sulla conversazione selezionata. Si apre PRECARICATA
+    // con la nota esistente: annotare due volte è quasi sempre correggere, non
+    // riscrivere da zero, e un campo vuoto costringerebbe a ridigitare tutto per
+    // cambiare una parola. Confermare il campo vuoto cancella la nota.
+    const [noteDraft, setNoteDraft] = useState('');
     // T39 — vista corrente (filtri + sort) e sua fotografia all'apertura di un
     // modale: la lista si aggiorna dal vivo, quindi `esc` deve poter ripristinare.
     const [view, setView] = useState(() => loadView(cwd));
@@ -456,6 +458,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const launch = useMemo(() => loadLaunch(cwd), [cwd]);
     // Identità (T37): titolo delle tab terminale spawnate col tasto `t`.
     const identity = useMemo(() => loadIdentity(cwd), [cwd]);
+    // T53 — `<owner> <name>`: il core che ogni titolo di tab porta, quindi la
+    // colonna costante da togliere quando serve spazio. Hoistato qui perché ora
+    // lo consumano DUE schermate (lista e ricerca): calcolarlo su ogni call site
+    // è il modo in cui le due smettono di togliere la stessa cosa.
+    const projectCore = identity ? `${identity.owner} ${identity.name}` : null;
     // La vista è una trasformazione DERIVATA, applicata a valle del load: il
     // polling di tasks.md continua a funzionare senza saperne nulla.
     const { visible: viewTasks, hidden: hiddenTasks } = useMemo(() => applyView(tasks, view), [tasks, view]);
@@ -557,7 +564,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         }
         const sid = randomUUID();
         const beforeIds = new Set(tasks.map((t) => t.id));
-        setNote(`⏳ creando task… "${truncate(text, 40)}" (sid ${sid.slice(0, 8)})`);
+        setNote(`⏳ creando task… "${cut(text, 40)}" (sid ${sid.slice(0, 8)})`);
         const child = spawnCreateTask(text, cwd, sid, (ok) => {
             if (!ok) {
                 setNote(`⚠ create-task fallito (${CLAUDE_CMD} -p)`);
@@ -580,6 +587,38 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         });
         child.on('error', () => setNote(`⚠ create-task: '${CLAUDE_CMD}' non lanciabile`));
     }
+    // T53 — apertura del modale nota sulla conversazione selezionata. Come
+    // `openEdit`, la bozza parte dal valore ATTUALE: annotare una seconda volta è
+    // quasi sempre correggere, e ripartire da vuoto costringerebbe a ridigitare
+    // tutto per cambiare una parola.
+    function openNote() {
+        if (!selSessionId)
+            return;
+        setNoteDraft(sessionNotes.get(selSessionId) ?? '');
+        setNote('');
+        setMode('note');
+    }
+    // T53 — ⏎ nel modale nota: scrive il sidecar e ricarica subito, senza
+    // attendere il tick del poll (stesso feedback immediato del pin).
+    //
+    // Il campo VUOTO non è un annullamento: è la CANCELLAZIONE della nota. Sono
+    // due intenzioni diverse e hanno due tasti diversi — `esc` lascia tutto com'è,
+    // `⏎` su campo svuotato toglie la nota. Trattare il vuoto come un no-op (come
+    // fa `submitCreate`, dove però una task senza titolo non esiste) renderebbe
+    // impossibile disannotare una conversazione se non con un editor sul JSONL.
+    function submitNote() {
+        const sid = selSessionId;
+        const text = noteDraft.trim();
+        setMode('normal');
+        setNoteDraft('');
+        if (!sid)
+            return;
+        appendNote(cwd, sid, text);
+        reloadSessions();
+        setNote(text
+            ? `✎ nota su ${sid.slice(0, 8)}: "${cut(text, 40)}"`
+            : `✎ nota rimossa da ${sid.slice(0, 8)}`);
+    }
     // T41 — apertura dell'edit: la bozza parte dai valori ATTUALI della task, non
     // da default. La priorità arriva dal glifo di tasks.md (già in `selTask`), lo
     // stato dal suo glifo Prog; il progresso arbitrario dal campo `Progress` del
@@ -713,7 +752,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // (T39), che cicla sui caratteri del chunk invece di leggerlo intero.
     function typeIntoField(chunk) {
         setNote('');
-        const clean = (s) => s.replace(/[\r\n]/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '');
+        const clean = sanitizeTyped;
         const parts = chunk.split('\t');
         let field = searchField;
         const add = { hash: '', query: '' };
@@ -830,6 +869,43 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             return;
         }
+        // T53 — modale nota. Come create, cattura il testo e corto-circuita la
+        // navigazione (qui `q` è una lettera da scrivere, non il quit).
+        if (mode === 'note') {
+            if (key.escape) {
+                setMode('normal');
+                setNoteDraft('');
+                setNote('N → nota annullata');
+            }
+            else if (key.return) {
+                submitNote();
+            }
+            else if (key.ctrl && input === 'u') {
+                // Svuota il campo in un colpo. NON è una scorciatoia di comodo: il
+                // backspace tenuto premuto cancella UN carattere per CHUNK letto da
+                // stdin, non per pressione (`useInput` consegna il chunk, e per una
+                // raffica di DEL Ink alza `key.backspace` una volta sola) — misurato,
+                // 30 pressioni → 2 caratteri. Siccome «campo vuoto» qui è l'unico modo
+                // di CANCELLARE una nota, dipendere dal backspace renderebbe
+                // l'operazione praticamente non eseguibile. `^U` è il kill-line delle
+                // shell, quindi il gesto è già nelle dita di chi usa un terminale.
+                setNoteDraft('');
+            }
+            else if (key.backspace || key.delete) {
+                setNoteDraft((d) => d.slice(0, -1));
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                // Sanificazione dei byte di controllo, come `typeIntoField` della
+                // ricerca: `useInput` consegna il CHUNK letto da stdin, quindi un
+                // incollaggio porta dentro newline e control char. Invisibili a schermo
+                // ma contati da Ink nella larghezza della riga — e qui finirebbero
+                // scritti su disco, dove resterebbero a sporcare la riga per sempre.
+                // Le newline diventano spazio: incollare due righe deve separare le
+                // parole, non fonderle.
+                setNoteDraft((d) => d + sanitizeTyped(input));
+            }
+            return;
+        }
         // T39 — modale sort a grammatica libera: la SEQUENZA di tasti È la chain.
         // Digitare `ppi` = p(asc) p(desc) i(asc) → [pri desc, id asc]. La lista si
         // riordina dal vivo a ogni pressione.
@@ -1061,6 +1137,23 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 setNote(`${isPinned ? 'unpin' : '📌 pin'} ${selSessionId.slice(0, 8)}`);
             }
         }
+        else if (input === 'N') {
+            // T53 — nota sulla conversazione selezionata. MAIUSCOLA perché apre un
+            // modale: nel deck le minuscole sono azioni immediate (`f` fork, `p` pin,
+            // `t` term, `c` claude) e le maiuscole aprono un box (`C` create, `E`
+            // edit, `S` sort, `F` filtri). Vincolo di focus identico a `p`: vale anche
+            // su una pinnata STALE, perché annotare «questa non c'è più, era X» è
+            // proprio il caso in cui una nota serve.
+            if (focus !== 'sessions') {
+                setNote('N → nota: seleziona una sessione (←→ per il pane)');
+            }
+            else if (!selSessionId) {
+                setNote('N → nessuna sessione da annotare');
+            }
+            else {
+                openNote();
+            }
+        }
         else if (input === 't') {
             const title = identity ? `🖥️ ${identity.owner} ${identity.name} [term]` : null;
             const child = spawnTerminal(cwd, title);
@@ -1152,7 +1245,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 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 }));
+        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, sessionNotes: sessionNotes, projectCore: projectCore, columns: columns, note: note }));
     }
     // ── Budget d'altezza ────────────────────────────────────────────────────
     // Il frame deve restare sotto `rows`, sempre: oltre quella soglia Ink smette
@@ -1192,7 +1285,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     if (budget.compact) {
         return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", viewTasks.length, " task \u00B7 sel ", selectedTaskId ?? 'spot', " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga"] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : canResume ? 'resume' : '—', canResume ? ' · f fork' : '', canPin ? ' · p pin' : '', " \u00B7 ^F cerca \u00B7 C nuova \u00B7 E edit \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7 t term \u00B7 c claude \u00B7 q esci \u00B7 focus:", ' ', _jsx(Text, { color: "cyan", children: focus })] })), mode === 'normal' && launch.length > 0 ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["launch ", legend.shown, legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: normalizeEmoji(note) }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nota conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : canResume ? 'resume' : '—', canResume ? ' · f fork' : '', canPin ? ' · p pin · N nota' : '', " \u00B7 ^F cerca \u00B7 C nuova \u00B7 E edit \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7 t term \u00B7 c claude \u00B7 q esci \u00B7 focus:", ' ', _jsx(Text, { color: "cyan", children: focus })] })), mode === 'normal' && launch.length > 0 ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["launch ", legend.shown, legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
 // Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
@@ -1211,7 +1304,7 @@ function FilterModal({ view, cursor }) {
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "F \u203A filtri" }), rows.map((row, r) => (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: row.label }), row.entries.map((e, c) => {
                         const on = !row.hidden.has(e.name);
                         const here = cursor.row === r && cursor.col === c;
-                        return (_jsxs(Text, { inverse: here, color: on ? 'green' : 'gray', dimColor: !on, children: ['  ', "[", on ? 'x' : ' ', "] ", forceEmojiWidth(e.glyph)] }, e.name));
+                        return (_jsxs(Text, { inverse: here, color: on ? 'green' : 'gray', dimColor: !on, children: ['  ', "[", on ? 'x' : ' ', "] ", sanitize(e.glyph)] }, e.name));
                     })] }, row.label)))] }));
 }
 // T41 — modale edit, in flusso come gli altri (spinge giù i pane invece di
@@ -1220,12 +1313,12 @@ function FilterModal({ view, cursor }) {
 // del task file — così il default (`✔️ Done at <oggi>`) non è una sorpresa.
 function EditModal({ id, draft, row }) {
     const mark = (r) => (row === r ? CARET : CARET_OFF);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri  " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato" }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(Text, { dimColor: true, children: "prog " }), _jsxs(Text, { children: ['  ', draft.detail] }), row === 2 ? _jsx(Text, { inverse: true, children: " " }) : null, !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", normalizeEmoji(progressText(draft.prog, draft.detail))] })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri  " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', sanitize(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato" }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', sanitize(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(Text, { dimColor: true, children: "prog " }), _jsxs(Text, { children: ['  ', draft.detail] }), row === 2 ? _jsx(Text, { inverse: true, children: " " }) : null, !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", sanitize(progressText(draft.prog, draft.detail))] })] }));
 }
 // T52 — marcatore compatto del tipo di corpo sulla riga-occorrenza. Due
 // caratteri ASCII e non un'emoji: con più toggle accesi la colonna deve
 // allinearsi, e i glifi BMP larghi 2 sono proprio la classe che Ink e il
-// terminale misurano diversamente (vedi normalizeEmoji).
+// terminale misurano diversamente (vedi width.ts).
 const KIND_TAG = { ai: 'ai', tool: 'tl', human: 'hu' };
 const KIND_COLOR = { ai: 'cyan', tool: 'gray', human: 'green' };
 /**
@@ -1241,12 +1334,12 @@ const KIND_COLOR = { ai: 'cyan', tool: 'gray', human: 'green' };
  *   4  box lista   (2 bordi + 2 padding)
  *   2  caret
  *   4  indice del record
- *   3  spazio + tag del kind + spazio
+ *   4  spazio + tag del kind (2 caratteri) + 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);
+    return Math.max(30, (columns || 80) - 18);
 }
 /** Titolo della conversazione sulla riga-gruppo: prende ciò che avanza dopo le
  *  colonne a larghezza fissa (caret, pin, hash, task, conteggio, data). */
@@ -1267,13 +1360,7 @@ function searchTitleWidth(columns) {
  * conversazione e non un'altra.
  */
 function conversationLabel(s, core, bound) {
-    let t = s.title;
-    if (core) {
-        const at = t.indexOf(core);
-        if (at >= 0)
-            t = t.slice(at + core.length);
-    }
-    t = t.replace(/^[\s·]+/, '').trim();
+    let t = stripProjectCore(s.title, core);
     if (bound && t === bound)
         t = '';
     return t || s.firstPrompt || '(senza titolo)';
@@ -1309,18 +1396,26 @@ 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] }));
 }
-function SearchScreen({ preview, hash, query, field, opts, result, rows, selectedKey, selectedKind, above, below, capacity, bindings, pinned, projectCore, columns, note, }) {
+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);
-                            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 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] }), " ", h.excerpt] }, row.key));
-                    })] }), preview ? _jsx(SearchPreviewPane, { p: preview }) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: normalizeEmoji(note) }) : null] }));
+                        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.
@@ -1367,16 +1462,25 @@ function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount,
                                 ...PRI_ENTRIES.filter((e) => view.hiddenPri.includes(e.name)),
                                 ...PROG_ENTRIES.filter((e) => view.hiddenProg.includes(e.name)),
                             ]
-                                .map((e) => `−${normalizeEmoji(e.glyph)}`)
+                                .map((e) => `−${sanitize(e.glyph)}`)
                                 .join(' ')] })) : null] }), _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 })) : (tasks.map((task, i) => {
                 // windowStart riporta l'indice di finestra a quello della lista
                 // completa, su cui è keyata la selezione. +1: lo 0 è spot.
                 const sel = windowStart + i + 1 === selected;
                 const n = childCount.get(task.id) ?? 0;
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", forceEmojiWidth(task.pri), "  ", displayProg(task.prog), "  ", task.desc, n > 0 ? ` (${n})` : ''] }, task.id));
+                // 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));
             })), detail && detailLines > 0 ? (_jsx(DetailPane, { detail: detail, maxLines: detailLines, columns: columns })) : null] }));
 }
-function SessionsPane({ parentLabel, isSpot, rows, total, pinnedCount, hidden, selectedId, focused, above, below, detail, firstLines, lastLines, columns, forkOf, }) {
+function SessionsPane({ parentLabel, isSpot, rows, total, pinnedCount, hidden, selectedId, focused, above, below, detail, firstLines, lastLines, columns, forkOf, sessionNotes, projectCore, }) {
     return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: ["Sessions \u00B7 ", parentLabel, " (", total, ")", pinnedCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 \uD83D\uDCCC", pinnedCount] }) : null, hidden > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 +", hidden, " pi\u00F9 vecchie"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }), total === 0 ? (_jsx(Text, { color: "yellow", wrap: "truncate-end", children: isSpot ? 'nessuna sessione libera' : 'nessuna sessione legata a questa task' })) : (rows.map((row, i) => {
                 // T50 — separatore leggero fra pinnate e contestuali: riga dim, non un
                 // box pesante (coerente con lo styling delle Done dimmate).
@@ -1387,7 +1491,7 @@ function SessionsPane({ parentLabel, isSpot, rows, total, pinnedCount, hidden, s
                 // T50 — pin stale: transcript sparito, nessuna Session da mostrare.
                 // Riga navigabile e spinnabile (`p`), marcata, mai un crash.
                 if (row.kind === 'pinned' && row.stale) {
-                    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, 8) })] }, row.sessionId));
+                    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, 8) }), sessionNotes.get(row.sessionId) ? (_jsxs(Text, { color: "yellow", children: [" \u00AB", cut(sessionNotes.get(row.sessionId), 30), "\u00BB"] })) : null] }, row.sessionId));
                 }
                 const s = row.session; // non-stale → session presente
                 const isPinnedRow = row.kind === 'pinned';
@@ -1395,8 +1499,21 @@ function SessionsPane({ parentLabel, isSpot, rows, total, pinnedCount, hidden, s
                 // righe sarebbero identiche a occhio. `⑂` sta PRIMA del titolo, dove
                 // la troncatura non arriva mai.
                 const forked = forkOf.has(s.sessionId);
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: "\uD83D\uDCCC" })) : isSpot ? (_jsx(Text, { dimColor: true, children: "\u25CB" })) : (_jsx(Text, { color: "green", children: "\uD83D\uDD17" })), ' ', forked ? _jsx(Text, { color: "magenta", children: "\u2442 " }) : null, truncate(s.title, forked ? 42 : 44), ' ', _jsxs(Text, { dimColor: true, children: ["\u00B7 ", s.gitBranch || '-', " \u00B7 ", relTime(s.ts)] })] }, s.sessionId));
-            })), detail ? (_jsx(SessionDetailPane, { s: detail, firstLines: firstLines, lastLines: lastLines, columns: columns, origin: forkOf.get(detail.sessionId) ?? null })) : null] }));
+                // T53 — con una nota il prefisso di progetto sparisce e le sue colonne
+                // passano alla nota; senza, il titolo resta com'è (vedi `rowLabel`).
+                //
+                // Invariante ③: il budget è DERIVATO da `columns`, non inchiodato.
+                // Con un valore fisso (erano 44) su un terminale stretto la riga
+                // superava il pane, e a troncarla finiva `cli-truncate` — che sfora
+                // di una colonna per emoji e si mangia il bordo destro.
+                const meta = ` · ${s.gitBranch || '-'} · ${relTime(s.ts)}`;
+                const labelBudget = Math.max(12, paneTextWidth(columns) -
+                    (2 /* caret */ + 2 /* icona */ + 1 /* spazio */ + (forked ? 2 : 0)) -
+                    termWidth(meta) -
+                    1 /* spazio prima del meta */);
+                const label = rowLabel(s.title, sessionNotes.get(s.sessionId), projectCore, labelBudget);
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: "\uD83D\uDCCC" })) : isSpot ? (_jsx(Text, { dimColor: true, children: "\u25CB" })) : (_jsx(Text, { color: "green", children: "\uD83D\uDD17" })), ' ', forked ? _jsx(Text, { color: "magenta", children: "\u2442 " }) : 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, ' ', _jsxs(Text, { dimColor: true, children: ["\u00B7 ", s.gitBranch || '-', " \u00B7 ", relTime(s.ts)] })] }, s.sessionId));
+            })), detail ? (_jsx(SessionDetailPane, { s: detail, firstLines: firstLines, lastLines: lastLines, columns: columns, origin: forkOf.get(detail.sessionId) ?? null, note: sessionNotes.get(detail.sessionId) ?? '' })) : null] }));
 }
 // T49 — detail pane della sessione selezionata (hover), gemello del DetailPane
 // task. Tutti i campi vengono dal parse già cached dell'adapter (mtime-keyed):
@@ -1406,11 +1523,11 @@ function SessionsPane({ parentLabel, isSpot, rows, total, pinnedCount, hidden, s
 // — 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).
-function SessionDetailPane({ s, firstLines, lastLines, columns, origin, }) {
+function SessionDetailPane({ s, firstLines, lastLines, columns, origin, note, }) {
     const width = detailTextWidth(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(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: s.title }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), origin ? ` · ⑂ da ${origin.slice(0, 8)}` : ''] }), 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}`)))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [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), origin ? ` · ⑂ da ${origin.slice(0, 8)}` : ''] }), 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.
@@ -1435,6 +1552,20 @@ function detailMetaOf(detail) {
 function detailTextWidth(columns) {
     return Math.max(10, Math.floor(((columns || 80) - 4) / 2) - 9);
 }
+/**
+ * Larghezza del TESTO dentro un pane al 50%: box esterno (2 bordi + 2 padding)
+ * → metà → bordo + padding del pane.
+ *
+ * Invariante ③ (`width.ts`): chi renderizza una riga a lunghezza libera la
+ * taglia PRIMA con questa larghezza. Delegarlo a `wrap="truncate-end"`
+ * significa passare da `cli-truncate`, che indicizza per code point e restituisce
+ * una riga più larga di quella chiesta — una colonna per ogni emoji astrale a
+ * sinistra del taglio. Quelle colonne finiscono sopra il bordo del pane, che
+ * sparisce dalla riga: è la sminchiatura visibile a schermo.
+ */
+function paneTextWidth(columns) {
+    return Math.max(20, Math.floor(((columns || 80) - 4) / 2) - 4);
+}
 function DetailPane({ detail, maxLines, columns, }) {
     const { meta, commit } = detailMetaOf(detail);
     // Wrap calcolato qui, non delegato a `<Text wrap="wrap">`: il budget ha

package/dist/config.js

@@ -5,7 +5,7 @@
 // indice 1..9. Il `command` gira con cwd = project root.
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { normalizeEmoji } from './viewport.js';
+import { sanitize } from './width.js';
 export function configFilePath(projectRoot) {
     return join(projectRoot, '.claude', 'loom-works.json');
 }
@@ -25,10 +25,10 @@ export function parseLaunch(raw) {
         out.push({
             // L'emoji arriva dal file config: testo arbitrario, quindi va normalizzato
             // come ogni altro dato esterno — `☕` senza VS16 allargherebbe di una cella
-            // la riga della legenda, mandandola a capo (vedi normalizeEmoji).
-            emoji: normalizeEmoji(typeof emoji === 'string' ? emoji : '▸'),
+            // la riga della legenda, mandandola a capo (vedi width.ts).
+            emoji: sanitize(typeof emoji === 'string' ? emoji : '▸'),
             // `label` è opzionale per contratto → fallback sul comando stesso.
-            label: normalizeEmoji(typeof label === 'string' && label ? label : command),
+            label: sanitize(typeof label === 'string' && label ? label : command),
             command,
         });
     }

package/dist/session-list.js

@@ -14,6 +14,71 @@
 //  - 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.
+import { cut, termWidth } from './width.js';
+// ── T53 · etichetta di riga ────────────────────────────────────────────────
+/**
+ * Toglie dal titolo il core `<owner> <name>` del progetto e la punteggiatura di
+ * giunzione che resta appesa davanti.
+ *
+ * Il titolo di una sessione È la label della tab Ptyxis (`🧵 LOCAL loom-works ·
+ * T52`): dentro un deck che mostra un progetto solo, il core è una COLONNA
+ * COSTANTE ripetuta su ogni riga. Toglierlo libera le colonne per ciò che
+ * distingue davvero una conversazione dall'altra.
+ *
+ * `core` null (file config assente o senza identità) → titolo intatto: senza
+ * sapere cosa togliere non si indovina, si lascia stare.
+ */
+export function stripProjectCore(title, core) {
+    let t = title;
+    if (core) {
+        const at = t.indexOf(core);
+        if (at >= 0)
+            t = t.slice(at + core.length);
+    }
+    return t.replace(/^[\s·]+/, '').trim();
+}
+/** Colonne minime perché un residuo dopo la nota valga la riga: sotto questa
+ *  soglia si vedrebbero due lettere e un'ellissi, cioè rumore. */
+const MIN_REST = 6;
+/** Colonne garantite alla nota quando c'è anche un residuo da mostrare: la nota
+ *  è la parte scelta da un umano, non è lei a cedere il posto per prima. */
+const MIN_NOTE = 14;
+/**
+ * Cosa scrivere sulla riga di una conversazione, dentro `budget` colonne.
+ *
+ * Due regimi, ed è una decisione deliberata che NON siano lo stesso:
+ *
+ *  - **senza nota** → il titolo resta INTATTO, prefisso di progetto incluso.
+ *    Togliere il core qui lascerebbe `T52` o il nulla (i titoli di tab non
+ *    contengono altro), cioè meno informazione di prima, non più spazio.
+ *  - **con nota** → il core se ne va: la nota dice già quale conversazione è,
+ *    quindi le colonne del prefisso passano a lei. Il residuo (tipicamente la
+ *    task, `T52`) segue dimmato se ci sta; se non resta nulla va benissimo.
+ *
+ * Il budget si divide dando la precedenza alla nota, ma senza affamare il
+ * residuo: con entrambi presenti la nota cede fino a `MIN_NOTE` per lasciare
+ * spazio al residuo, e il residuo sparisce del tutto sotto `MIN_REST` invece di
+ * ridursi a un moncone.
+ */
+export function rowLabel(title, note, core, budget) {
+    if (!note)
+        return { note: '', rest: cut(title, Math.max(0, budget)) };
+    // 2 colonne per i caporali « », 1 per lo spazio prima del residuo.
+    const rest = stripProjectCore(title, core);
+    const noteBudget = Math.max(0, budget - 2);
+    if (!rest)
+        return { note: cut(note, noteBudget), rest: '' };
+    // Il `min` col budget totale non è ridondante: su un pane strettissimo
+    // `MIN_NOTE` supererebbe le colonne disponibili e la riga andrebbe a capo —
+    // che è precisamente il difetto che ogni larghezza qui dentro esiste per
+    // evitare (una riga wrappata sfonda il budget d'ALTEZZA, non solo l'estetica).
+    const shownNote = cut(note, Math.min(noteBudget, Math.max(MIN_NOTE, noteBudget - MIN_REST - 1)));
+    // `termWidth`, non `.length`: quanto RESTA si misura in colonne come tutto il
+    // resto: una nota con un emoji conta 2 sullo schermo e 1 (o 2) code unit, e
+    // sottrarre le une dalle altre rimetterebbe la riga fuori dal pane.
+    const restBudget = noteBudget - termWidth(shownNote) - 1;
+    return { note: shownNote, rest: restBudget >= MIN_REST ? cut(rest, restBudget) : '' };
+}
 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

package/dist/sessions.js

@@ -1,7 +1,7 @@
 import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { normalizeEmoji } from './viewport.js';
+import { sanitize } from './width.js';
 // CC codifica la project dir sostituendo ogni char non-alfanumerico con '-'
 // (verificato: `/home/lamemind/cc-host` → `-home-lamemind-cc-host`). È LOSSY
 // (un '-' nel path e un '/' collassano nello stesso char) → il forward è
@@ -122,7 +122,12 @@ function collectBodies(message, idx, isAssistant, out) {
         }
     }
     for (const kind of ['ai', 'tool', 'human']) {
-        const text = parts[kind].join('\n');
+        // Sanificato QUI, prima che la ricerca ci giri sopra: gli offset del match
+        // (`matchStart`/`matchEnd`) indicizzano questo testo, e sanificare a valle —
+        // al render — li sposterebbe, evidenziando la parte sbagliata della riga.
+        // Un corpo di transcript è la sorgente più ostile che il deck legge: emoji
+        // qualsiasi, output di tool con byte di controllo, CJK.
+        const text = sanitize(parts[kind].join('\n'));
         if (!text)
             continue;
         if (kind === 'human' && isInterrupt(text))
@@ -220,7 +225,7 @@ export function parseTranscript(content, path, mtime, sizeBytes) {
         cwd,
         gitBranch,
         parentUuid,
-        title: normalizeEmoji(customTitle || firstUserText || '(senza titolo)'),
+        title: sanitize(customTitle || firstUserText || '(senza titolo)'),
         ts: mtime,
         path,
         sizeBytes,

package/dist/task-index.js

@@ -15,6 +15,10 @@ export function appendTaskBinding(projectRoot, sessionId, taskId) {
 export function appendPin(projectRoot, sessionId, pinned) {
     appendSessionRecord(projectRoot, { sessionId, pinned });
 }
+/** T53 — scrive (o cancella, con `note` vuota) la nota di una conversazione. */
+export function appendNote(projectRoot, sessionId, note) {
+    appendSessionRecord(projectRoot, { sessionId, note });
+}
 // 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
@@ -24,12 +28,13 @@ export function loadSessionIndex(projectRoot) {
     const bindings = new Map();
     const forkOf = new Map();
     const pinned = new Map();
+    const notes = new Map();
     let content;
     try {
         content = readFileSync(taskIndexPath(projectRoot), 'utf8');
     }
     catch {
-        return { bindings, forkOf, pinned };
+        return { bindings, forkOf, pinned, notes };
     }
     let order = 0; // posizione crescente dei record pinned → rango di pin (D2)
     for (const line of content.split('\n')) {
@@ -51,10 +56,19 @@ export function loadSessionIndex(projectRoot) {
                 else
                     pinned.delete(d.sessionId);
             }
+            // T53 — stesso last-wins: la stringa vuota è la CANCELLAZIONE, non una
+            // nota vuota da mostrare. Il `typeof` esclude i record senza il campo, che
+            // non devono toccare una nota scritta da un record precedente.
+            if (typeof d.note === 'string') {
+                if (d.note)
+                    notes.set(d.sessionId, d.note);
+                else
+                    notes.delete(d.sessionId);
+            }
         }
         catch {
             // riga corrotta → skip
         }
     }
-    return { bindings, forkOf, pinned };
+    return { bindings, forkOf, pinned, notes };
 }

package/dist/tasks.js

@@ -1,6 +1,6 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { normalizeEmoji } from './viewport.js';
+import { sanitize } from './width.js';
 /**
  * Forma di un ID task: `T` (code) o `D` (doc) + numero. FONTE UNICA del gate —
  * `parseTasks` lo usa per scartare header/separatore della tabella, `task-edit`
@@ -42,16 +42,17 @@ export function parseTasks(content) {
         const prog = cells[4] ?? '';
         // desc = colonna finale; join per resistere a eventuali `|` nella descrizione.
         const desc = cells.slice(5, -1).join('|').trim();
-        // Normalizzazione larghezza glifi AL CONFINE: tutto ciò che entra da
-        // tasks.md è testo arbitrario e può contenere emoji BMP che Ink misura una
-        // cella in meno del terminale (vedi normalizeEmoji). Farlo qui invece che a
-        // ogni sito di render è ciò che impedisce di dimenticarne uno.
-        tasks.push({
-            id,
-            pri: normalizeEmoji(pri),
-            prog: normalizeEmoji(prog),
-            desc: normalizeEmoji(desc),
-        });
+        // Sanificazione AL CONFINE: tutto ciò che entra da tasks.md è testo
+        // arbitrario e può contenere glifi che Ink e il terminale misurano in modo
+        // diverso (vedi `width.ts`). Farlo qui invece che a ogni sito di render è
+        // ciò che impedisce di dimenticarne uno.
+        //
+        // `pri` e `prog` sono l'eccezione: NON si sanificano qui perché sono chiavi
+        // SEMANTICHE, non testo — `isDone()` e le lookup di `view.ts` confrontano
+        // il glifo, e `task-edit` lo riscrive in tasks.md. Sanificarli qui
+        // renderebbe `✔` un `✅` anche su disco, cambiando il formato di famiglia.
+        // La sanificazione di quei due avviene al display (`displayProg`).
+        tasks.push({ id, pri, prog, desc: sanitize(desc) });
     }
     return tasks;
 }
@@ -112,12 +113,12 @@ export function parseTaskDetail(id, content) {
     // allarga la riga oltre il bordo del pane.
     const normFields = {};
     for (const [k, v] of Object.entries(fields))
-        normFields[k] = normalizeEmoji(v);
+        normFields[k] = sanitize(v);
     return {
         id,
-        title: normalizeEmoji(title),
+        title: sanitize(title),
         fields: normFields,
-        description: normalizeEmoji(descLines.join('\n').trim()),
+        description: sanitize(descLines.join('\n').trim()),
     };
 }
 export function loadTaskDetail(dir, id) {

package/dist/viewport.js

@@ -13,43 +13,6 @@
 // dettaglio) passa da qui e riceve una capienza in righe.
 //
 // Logica pura, zero React/Ink: testabile senza pseudo-terminale.
-import stringWidth from 'string-width';
-/** Variation Selector-16: forza la presentazione emoji del carattere che precede. */
-const VS16 = '️';
-/**
- * Riallinea la larghezza dei glifi fra Ink e il terminale.
- *
- * Secondo meccanismo di sporcamento dello scrollback, indipendente dal budget
- * d'altezza. Ink assembla ogni riga su una griglia di CARATTERI: per un emoji
- * BMP senza VS16 (`☕` U+2615, `✔` U+2714, `⚡` U+26A1, `✅` U+2705, `▶` U+25B6)
- * riserva una sola posizione, mentre il terminale ne disegna due. La riga esce
- * larga `columns + 1`, il terminale la manda a capo, e l'altezza reale supera
- * quella che Ink crede — senza mai passare dal ramo `clearTerminal`. Con più
- * glifi sulla stessa riga l'eccesso si somma.
- *
- * Il VS16 esplicito fa contare 2 anche a Ink, riallineando le due contabilità.
- *
- * Il predicato è la LARGHEZZA MISURATA, non l'intervallo di codepoint: nello
- * stesso blocco U+2190–U+2BFF vivono anche `↓` `↑` `−`, larghi 1, e timbrarli
- * col VS16 li porterebbe a 2 accorciando la riga — l'errore opposto, con lo
- * stesso effetto di layout rotto. Gli astrali (U+1F000+) Ink li conta già bene.
- *
- * Idempotente: un glifo che ha già il VS16 non viene ri-timbrato.
- */
-export function normalizeEmoji(s) {
-    if (!s)
-        return s;
-    const cps = [...s];
-    let out = '';
-    for (let i = 0; i < cps.length; i++) {
-        const ch = cps[i];
-        out += ch;
-        const cp = ch.codePointAt(0);
-        if (cp < 0x10000 && stringWidth(ch) === 2 && cps[i + 1] !== VS16)
-            out += VS16;
-    }
-    return out;
-}
 /** Righe lasciate libere sotto il frame. La condizione di Ink è `>=`, quindi
  *  basterebbe 1; ne teniamo 1 come margine per l'a-capo del cursore. */
 export const SLACK = 1;
@@ -75,6 +38,7 @@ const MIN_SESSION_ROWS = 3;
 export const MODAL_HEIGHT = {
     normal: 0,
     create: 4, // marginTop + 2 bordi + 1 riga input
+    note: 4, // T53 — gemello di create: marginTop + 2 bordi + 1 riga input
     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
@@ -232,53 +196,6 @@ export function searchPreviewCapacity(capacity, listRows) {
 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.
  *
@@ -297,58 +214,3 @@ export function windowRange(total, selected, capacity) {
     const start = Math.max(0, Math.min(sel - Math.floor(capacity / 2), total - capacity));
     return { start, end: start + capacity };
 }
-/**
- * Hard-wrap a larghezza fissa, con tetto di righe.
- *
- * Serve un conteggio righe DETERMINISTICO: `<Text wrap="wrap">` di Ink wrappa a
- * runtime su una larghezza che il budget non conosce, quindi il pannello
- * dettaglio potrebbe sforare il tetto e riaprire il bug. Qui il testo viene
- * spezzato prima, e ogni riga è renderizzata con `wrap="truncate-end"`.
- *
- * Sottostimare `width` è sicuro (tronca prima), sovrastimarlo no (la riga
- * andrebbe a capo aggiungendo altezza non contabilizzata).
- */
-export function wrapLines(text, width, maxLines) {
-    if (maxLines <= 0 || width <= 0)
-        return [];
-    const flat = text.replace(/\s+/g, ' ').trim();
-    if (!flat)
-        return [];
-    const lines = [];
-    let line = '';
-    for (const word of flat.split(' ')) {
-        if (!line) {
-            line = word;
-        }
-        else if (line.length + 1 + word.length <= width) {
-            line += ' ' + word;
-        }
-        else {
-            lines.push(line);
-            line = word;
-            if (lines.length === maxLines)
-                break;
-        }
-        // Parola più lunga della riga: spezzala a forza, altrimenti l'a-capo lo
-        // farebbe il terminale — fuori dal nostro conteggio.
-        while (line.length > width) {
-            lines.push(line.slice(0, width));
-            line = line.slice(width);
-            if (lines.length === maxLines)
-                break;
-        }
-        if (lines.length === maxLines)
-            break;
-    }
-    if (line && lines.length < maxLines)
-        lines.push(line);
-    const kept = lines.slice(0, maxLines);
-    // Troncamento MAI silenzioso, come le liste: l'ellissi segnala che il testo
-    // continua oltre il pannello.
-    const consumed = kept.join(' ').length;
-    if (consumed < flat.length && kept.length > 0) {
-        const last = kept[kept.length - 1];
-        kept[kept.length - 1] = last.length >= width ? last.slice(0, Math.max(0, width - 1)) + '…' : last + '…';
-    }
-    return kept;
-}

package/dist/width.js

@@ -0,0 +1,333 @@
+// Contabilità UNICA della larghezza — fonte di verità per «quanto è larga
+// questa stringa sullo schermo».
+//
+// PERCHÉ ESISTE. Nel frame convivevano tre unità di misura diverse, e nessuna
+// era la colonna del terminale:
+//
+//   1. `string-width` — quella con cui Ink misura per il layout (Yoga) e per il
+//      troncamento. Conta 2 ogni emoji, VS16 o no.
+//   2. `.length` / `.slice` — code unit UTF-16, usate dai vecchi `truncate` e
+//      `wrapLines`. Un emoji astrale (`🔥`) sono 2 unità per 2 colonne (caso
+//      fortunato), uno BMP (`⚡`) 1 unità per 2 colonne (sbagliato).
+//   3. `slice-ansi`, dentro `cli-truncate`, dentro `wrap="truncate-end"` di Ink
+//      (`ink/build/wrap-text.js`): indicizza per CODE POINT ma riceve un budget
+//      di COLONNE. Ogni glifo largo 2 che sta a sinistra del taglio fa uscire
+//      la riga 1 colonna più larga del richiesto.
+//   4. VTE/Ptyxis, che disegna: largo 2 solo se East-Asian-Width ∈ {W, F}, con
+//      gli Ambiguous a 1 e il VS16 IGNORATO.
+//
+// Una riga più larga del riservato sovrascrive il bordo del pane nella griglia
+// di caratteri di Ink (bordo mangiato = layout sminchiato) e, quando il taglio
+// cade su un glifo largo, fa crescere la riga composta oltre `columns`: il
+// terminale la manda a capo, compare una riga vuota e tutto ciò che sta sotto
+// slitta di una riga. Una riga più STRETTA del riservato sposta a sinistra
+// bordo e pane vicino, sempre e solo sulle righe che contengono il glifo.
+//
+// LE TRE INVARIANTI. Tutto il resto del deck si appoggia a queste:
+//
+//   ① Alfabeto concorde — nel frame entrano solo caratteri per cui
+//      `stringWidth(ch) === termWidth(ch)`. Il predicato è CALCOLATO, non una
+//      lista: qualunque glifo nuovo (in una descrizione, in un transcript) è
+//      giudicato dalla stessa regola. I discordi sono i ~120 emoji a
+//      presentazione-testo del BMP (`▶ ✔ ⚠ ❤ ✂ ➡ …`): string-width li dà 2, il
+//      terminale ne disegna 1. Non sono riparabili con un selettore di
+//      variazione (né VS16 né VS15 cambiano il verdetto di string-width) →
+//      vengono SOSTITUITI con un gemello concorde.
+//
+//   ② VS16 sui glifi larghi 2 del BMP, e SOLO su quelli. Ink compone il frame
+//      su una griglia di celle assegnando 2 celle a un carattere se
+//      `isFullwidthCodePoint(cp) || value.length > 1`
+//      (`@alcalzone/ansi-tokenize`, un token per CODE POINT). `isFullwidthCodePoint`
+//      copre il CJK ma NON gli emoji, quindi:
+//        · astrale (`🔥`, 2 code unit) → `value.length > 1` → 2 celle, giusto;
+//        · BMP largo 2 (`⚡`, 1 code unit) → 1 sola cella, una in meno del dovuto;
+//        · BMP + VS16 → 1 + 1 = 2 celle, di nuovo giusto.
+//      Timbrare un ASTRALE è quindi l'errore opposto: gli darebbe 3 celle per 2
+//      colonne e la riga uscirebbe una colonna più CORTA del padding calcolato.
+//
+//   ③ Il taglio lo fa il deck, non Ink. Restava scoperta la terza contabilità
+//      (`slice-ansi`, per code point): con un budget di colonne in ingresso,
+//      ogni glifo largo 2 a sinistra del taglio allarga il risultato di una
+//      colonna, e nessun timbro può ripararlo senza rompere ② o ①. L'unica via
+//      è non farlo mai intervenire: chi renderizza una riga a lunghezza libera
+//      la taglia PRIMA con `cut()`, su un budget derivato da `columns`.
+//      `wrap="truncate-end"` resta come rete, non come meccanismo.
+//
+// L'assunzione sul terminale (EAW, ambiguous = 1, VS16 ignorato) vive TUTTA in
+// `termWidth`. Se un giorno cambia il terminale, cambia questa funzione e basta.
+import stringWidth from 'string-width';
+import { eastAsianWidth } from 'get-east-asian-width';
+/** Variation Selector-16: forza la presentazione emoji del carattere che precede. */
+const VS16 = '️';
+/** Zero-width per il terminale: combining marks e format chars (VS16 incluso). */
+const ZERO_WIDTH = /^[\p{Mn}\p{Me}\p{Cf}]$/u;
+/**
+ * Larghezza in colonne secondo il TERMINALE (VTE/Ptyxis).
+ *
+ * `eastAsianWidth` restituisce già 1 per gli Ambiguous — che è il default di
+ * VTE (`utf8-ambiguous-width`) e il motivo per cui `▶` (EAW = Ambiguous) e `✔`
+ * (EAW = Neutral) vengono disegnati stretti anche col VS16 appiccicato.
+ */
+export function termWidth(s) {
+    let w = 0;
+    for (const ch of s) {
+        if (ZERO_WIDTH.test(ch))
+            continue;
+        w += eastAsianWidth(ch.codePointAt(0));
+    }
+    return w;
+}
+/** Il carattere è misurato allo stesso modo da Ink e dal terminale? */
+export function agrees(ch) {
+    return stringWidth(ch) === termWidth(ch);
+}
+/**
+ * Sostituzioni esplicite per i discordi che il deck usa come SEGNALE: qui la
+ * semantica del glifo va preservata, non degradata a segnaposto.
+ *
+ * I sostituti sono concordi per costruzione (verificati dal test): `▸` è
+ * Neutral e non-emoji → 1 ovunque; `✅` `❗` sono astrali a presentazione-emoji
+ * → 2 ovunque.
+ */
+const GLYPH_MAP = new Map([
+    ['▶', '▸'], // caret di selezione
+    ['◀', '◂'],
+    ['✔', '✅'], // marker Done
+    ['☑', '✅'],
+    ['✖', '❌'],
+    ['⚠', '❗'], // warning (riga pin stale)
+    ['❗', '❗'],
+]);
+/**
+ * Segnaposto per i discordi che arrivano da testo NON nostro (descrizioni,
+ * titoli, corpi dei transcript): non c'è una traduzione sensata glifo-per-glifo
+ * di `❤ ✂ ☀ ➡ …`, e lasciarli passare romperebbe la riga che li ospita.
+ * Largo 1 e concorde.
+ */
+const FILLER = '·';
+/**
+ * Fast-path: sotto U+1100 non esiste né un wide né un discorde, quindi non
+ * c’è niente da sanificare. `\n` e `\t` stanno fuori dal sospetto pur essendo
+ * control char — li normalizzano i chiamanti (`wrapLines` collassa il
+ * whitespace, `wrapWithOffsets` li mappa preservando gli offset) e tenerli
+ * dentro costerebbe il fast-path su OGNI corpo di transcript, visto che
+ * `sanitize` gira anche sui ~10 MB di testo cercabile del progetto.
+ */
+const SUSPECT = /[^\n\t\u0020-\u10FF]/;
+/**
+ * Byte di controllo che il terminale INTERPRETA — ESC in testa. Passati nudi
+ * da un transcript muoverebbero il cursore o cambierebbero i colori dal mezzo
+ * di una preview. Diventano uno spazio: largo 1, concorde, inerte.
+ */
+const CONTROL = /[\u0000-\u001F\u007F-\u009F]/;
+/**
+ * Sostituzione di UN carattere secondo le invarianti ① e ②. Memoizzata: i
+ * corpi cercabili sono ~10 MB e i caratteri distinti che li attraversano sono
+ * poche decine — misurare la stessa emoji un milione di volte è il costo che
+ * questa cache toglie.
+ */
+const FIXED = new Map();
+function fixChar(ch) {
+    const cached = FIXED.get(ch);
+    if (cached !== undefined)
+        return cached;
+    let out;
+    if (CONTROL.test(ch)) {
+        out = ' ';
+    }
+    else if (ZERO_WIDTH.test(ch)) {
+        // Il VS16 in ingresso si scarta SEMPRE: se serve lo ri-mette il ramo ② sul
+        // carattere che lo precede. Passare da «scarta e ri-timbra» invece che da
+        // «tieni se c'è» è ciò che rende `sanitize` idempotente. Le altre combining
+        // mark e i format char restano dove sono (0 colonne per entrambe le conte).
+        out = ch === VS16 ? '' : ch;
+    }
+    else {
+        const fixedGlyph = agrees(ch) ? ch : (GLYPH_MAP.get(ch) ?? FILLER); // ①
+        // ② una cella per colonna nella griglia di Ink — SOLO sui BMP.
+        const bmpWide = fixedGlyph.codePointAt(0) < 0x10000 && termWidth(fixedGlyph) === 2;
+        out = bmpWide ? fixedGlyph + VS16 : fixedGlyph;
+    }
+    FIXED.set(ch, out);
+    return out;
+}
+/**
+ * Caratteri che possono violare un'invariante: control char, tutto ciò che sta
+ * da U+1100 in su (primo wide dell'insieme) e gli astrali. `\n` e `\t` restano
+ * fuori — li normalizzano i chiamanti, e includerli qui costerebbe una
+ * sostituzione su ogni riga di ogni transcript.
+ */
+const RISKY = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]|[\u1100-\uFFFF]|[\u{10000}-\u{10FFFF}]/gu;
+/**
+ * Rende una stringa sicura da mettere nel frame: applica le invarianti ① e ②.
+ *
+ * Idempotente, e a costo quasi zero sul testo ASCII (fast-path) — cioè sulla
+ * stragrande maggioranza dei corpi di transcript, che è il volume vero: la
+ * versione carattere-per-carattere costava secondi all'avvio del deck.
+ */
+export function sanitize(s) {
+    if (!s || !SUSPECT.test(s))
+        return s;
+    return s.replace(RISKY, fixChar);
+}
+/**
+ * Taglio a un budget di COLONNE, ellissi inclusa nel budget.
+ *
+ * Rimpiazza il vecchio `truncate`, che tagliava per code unit: su una riga con
+ * due emoji il risultato usciva 2 colonne oltre il budget, cioè esattamente
+ * dentro il bordo del pane.
+ *
+ * Collassa il whitespace come faceva il predecessore: i chiamanti passano
+ * descrizioni multi-riga e si aspettano un blocco unico.
+ */
+export function cut(s, cols) {
+    const flat = s.replace(/\s+/g, ' ').trim();
+    if (cols <= 0)
+        return '';
+    if (termWidth(flat) <= cols)
+        return flat;
+    if (cols === 1)
+        return '…';
+    let out = '';
+    let w = 0;
+    for (const ch of flat) {
+        const cw = termWidth(ch);
+        if (w + cw > cols - 1)
+            break; // -1 = la colonna dell'ellissi
+        out += ch;
+        w += cw;
+    }
+    // Un estratto può arrivare qui con la SUA ellissi già in coda (la ricerca
+    // ritaglia il contesto attorno al match): due ellissi di fila non aggiungono
+    // informazione, tolgono una colonna di testo.
+    return out.trimEnd().replace(/…$/, '') + '…';
+}
+/**
+ * Indice sorgente raggiunto consumando al più `cols` colonne da `from`.
+ *
+ * Il conteggio è per colonne, l'indice restituito è in code unit: è ciò che
+ * tiene gli offset del match allineati al sorgente mentre l'a-capo ragiona in
+ * colonne.
+ */
+function advance(line, from, cols) {
+    let i = from;
+    let w = 0;
+    while (i < line.length) {
+        const cp = line.codePointAt(i);
+        const ch = String.fromCodePoint(cp);
+        const cw = termWidth(ch);
+        if (w + cw > cols)
+            break;
+        w += cw;
+        i += ch.length;
+    }
+    return i;
+}
+/**
+ * A-capo che PRESERVA la struttura del testo e traccia gli offset.
+ *
+ * Distinto da `wrapLines`, che collassa tutto in un flusso unico: lì serve 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) {
+            const stop = advance(line, pos, width);
+            if (stop >= line.length) {
+                out.push({ text: line.slice(pos), start: base + pos, end: base + line.length });
+                break;
+            }
+            let brk = line.lastIndexOf(' ', stop);
+            if (brk <= pos)
+                brk = stop; // 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;
+}
+/**
+ * Hard-wrap a larghezza fissa, con tetto di righe.
+ *
+ * Serve un conteggio righe DETERMINISTICO: `<Text wrap="wrap">` di Ink wrappa a
+ * runtime su una larghezza che il budget non conosce, quindi il pannello
+ * dettaglio potrebbe sforare il tetto e riaprire il bug dell'altezza. Qui il
+ * testo viene spezzato prima, e ogni riga è renderizzata con `truncate-end`.
+ *
+ * Sottostimare `width` è sicuro (tronca prima), sovrastimarlo no (la riga
+ * andrebbe a capo aggiungendo altezza non contabilizzata).
+ */
+export function wrapLines(text, width, maxLines) {
+    if (maxLines <= 0 || width <= 0)
+        return [];
+    const flat = text.replace(/\s+/g, ' ').trim();
+    if (!flat)
+        return [];
+    const lines = [];
+    let line = '';
+    const push = () => {
+        lines.push(line);
+        line = '';
+    };
+    for (const word of flat.split(' ')) {
+        if (!line) {
+            line = word;
+        }
+        else if (termWidth(line) + 1 + termWidth(word) <= width) {
+            line += ' ' + word;
+        }
+        else {
+            push();
+            line = word;
+            if (lines.length === maxLines)
+                break;
+        }
+        // Parola più lunga della riga: spezzala a forza, altrimenti l'a-capo lo
+        // farebbe il terminale — fuori dal nostro conteggio.
+        while (termWidth(line) > width) {
+            const stop = advance(line, 0, width);
+            lines.push(line.slice(0, stop));
+            line = line.slice(stop);
+            if (lines.length === maxLines)
+                break;
+        }
+        if (lines.length === maxLines)
+            break;
+    }
+    if (line && lines.length < maxLines)
+        lines.push(line);
+    const kept = lines.slice(0, maxLines);
+    // Troncamento MAI silenzioso, come le liste: l'ellissi segnala che il testo
+    // continua oltre il pannello.
+    const consumed = kept.join(' ').length;
+    if (consumed < flat.length && kept.length > 0) {
+        const last = kept[kept.length - 1];
+        kept[kept.length - 1] = termWidth(last) >= width ? cut(last, width) : last + '…';
+    }
+    return kept;
+}

package/package.json

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