@lamemind/loom-deck 0.39.0 → 0.41.0

package/README.md

@@ -26,6 +26,22 @@ Entrambi i prefissi del contratto loom entrano in lista: **`T`** (code task) e *
 Il deck è **UN processo Node**: spawna ma **non contiene** le sessioni CC — le possiede Ptyxis. Chiudere il deck non uccide le sessioni. La tab nasce nella window *attiva*
 (quella col focus = il deck) → desktop isolation "gratis".
 
+### La riga di stato dice il comando, non una parafrasi
+
+Ogni spawn di una sessione Claude — task (`⏎`/`^K`/`^P`/`^R`), resume, fork, sessione nuda (`c`) — scrive nella riga di stato in fondo al frame il **comando esatto** che è stato eseguito, quotato come lo si scriverebbe in bash:
+
+```
+$ /home/tizio/.local/lib/node_modules/@lamemind/loom-deck/scripts/deck-run T115 --session-id 9f3a… --prompt-kind run --model opus --title-note 'parser'
+```
+
+Task, `sessionId`, prompt-kind, modello e nota del titolo sono già argomenti del comando: una nota che li elencasse a parole li direbbe una seconda volta, in una grafia che non si può ricopiare in un terminale. Quello che si perde è il **tasto premuto**, che è ciò che hai appena fatto tu e non ciò che il deck ha fatto per te.
+
+Il deck non passa mai da una shell (`spawn` senza `shell:true` consegna l'argv a `execve`): il quoting esiste per la sola resa, e serve a rendere la riga ricopiabile senza cambiare di una virgola ciò che è stato eseguito.
+
+Su un terminale stretto il taglio è **al mezzo** (`…`), non dalla coda: la testa è il path assoluto di `deck-run`, identico a ogni invocazione, mentre quel che distingue una sessione dall'altra sta tutto in fondo.
+
+Restano fuori gli spawn che non aprono una sessione Claude interattiva: terminale (`t`), voci `launch` (`1`-`9`) e le skill headless (`C` create-task, `CANC` clean-tasks), dove la riga di stato serve a riportare l'**esito** di un'operazione asincrona.
+
 ## Stato
 
 Bootstrap + spike ① + **TUI ③** funzionante (legge `tasks.md`, `⏎` apre il detail). Roadmap:
@@ -66,7 +82,7 @@ Assegnazioni correnti:
 | modale | `F` | filtri |
 | modale | `^F` | **ricerca full-text** nelle conversazioni del progetto |
 | modale | `⏎` | **detail** della task selezionata: task file scrollabile + barra azioni |
-| modale | `CANC` | **elimina** — la task selezionata, oppure l'intera vista `archiviabili` se è quella attiva |
+| modale | `CANC` | **elimina** — la task selezionata; su una riga meta della vista `archiviabili`, l'intero insieme |
 | immediata | `^K` | spawna la task selezionata col prompt di **recap** |
 | immediata | `^P` | spawna la task selezionata sul **preflight** |
 | immediata | `^R` | spawna la task selezionata in **esecuzione** |
@@ -98,12 +114,14 @@ Le emoji sono quelle del menu compass. Per il terminale compass usa 🖥️, che
 
 Il deck **ordina** la potatura, non la esegue: la fa `loom-works:clean-tasks`, invocato da un processo Claude headless. Nessun `git rm` e nessuna riscrittura di `tasks.md` vivono qui — quella sequenza (task file + folder dot-prefixed + riga in `tasks.md`, un commit atomico per task, symlink `current-task.md` rimosso, righe orfane riconciliate) è implementata una volta sola, e averne una seconda darebbe due rimozioni capaci di divergere.
 
-Lo **stesso tasto ha due bersagli di taglia diversa**, e ciò che li discrimina è la vista attiva — un'informazione che sta in header, non sotto le dita:
+Lo **stesso tasto ha due bersagli di taglia diversa**, e a discriminarli è la **selezione prima della vista**:
 
-| Vista attiva | Bersaglio |
-|---|---|
-| `archiviabili` | **tutte** le task che la vista mostra |
-| qualunque altra | la **task selezionata** |
+|  | riga meta (`≡ tutte` / `○ spot`) | riga task |
+|---|---|---|
+| vista `archiviabili` | **tutte** le task che la vista mostra | quella task |
+| qualunque altra vista | rifiuto, con la nota che dice quale riga meta è | quella task |
+
+Con una riga task sotto il caret il tasto tocca **sempre e solo quella task**. Il bulk richiede quindi di essere usciti da ogni riga task, cioè un movimento in più: l'azione di massa non è mai a un tasto di distanza da quella singola, e non la si preme guardando una task evidenziata credendo che il bersaglio sia lei. Il costo è che la regola non si legge dallo schermo — la legenda la dice (`CANC elimina` contro `CANC elimina tutte`), ed è il solo canale che la rende visibile prima della conferma.
 
 Da qui la forma della conferma: nomina il bersaglio (quante e quali ID, troncando con `+N`) invece dell'azione, e dice l'**effetto sul disco** — mai «archiviare», che prometterebbe uno spostamento in un archivio che non esiste. I commit restano **locali**: `clean-tasks` non pusha, quindi finché nessuno lo fa un altro worktree continua a vedere le task potate.
 

package/dist/cli.js

@@ -10,7 +10,7 @@ import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowI
 import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
 import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, TASK_VIEWS, } from './pane-views.js';
 import { isCompact, layoutBudget, searchPreviewCapacity, windowRange, } from './viewport.js';
-import { cut, sanitize, termWidth } from './width.js';
+import { cut, cutMiddle, sanitize, termWidth } from './width.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, writeTaskEdit, PRI_GLYPH, PRI_LABEL } from './task-edit.js';
 import { ALL, EDIT_PRI, EDIT_PROG, MAX_SESSIONS, MAX_SESSIONS_ALL, META_ROWS, ROW_ALL, ROW_SPOT, SORT_TASTI, SPOT, } from './model.js';
@@ -123,6 +123,19 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         : selectTasks(tasks, taskViewId, { view, archivable }), [taskViewId, viewTasks, tasks, view, archivable]);
     const isSpot = sel === SPOT;
     const isAll = sel === ALL;
+    // T112 — quando `CANC` pota in BLOCCO invece della sola task selezionata.
+    //
+    // La SELEZIONE batte la vista, non il contrario: con una riga task sotto il
+    // caret il tasto tocca quella task e basta, in ogni vista. Il bulk vive solo
+    // sulle righe meta della vista `archiviabili`, cioè richiede di essere usciti
+    // da ogni riga task — così l'azione di massa non è mai a un tasto di distanza
+    // da quella singola, e non si preme guardando una task evidenziata credendo
+    // che il bersaglio sia lei.
+    //
+    // Derivato una volta e letto sia dal ramo di apertura sia dalla legenda: due
+    // condizioni scritte due volte direbbero due cose diverse sullo stesso tasto
+    // alla prima modifica.
+    const purgeBulk = taskViewId === 'archivable' && (isAll || isSpot);
     const projectName = cwd.split('/').pop() || cwd;
     // Unica fonte della selezione: si legge SEMPRE dalla vista, mai dall'array
     // grezzo — è l'invariante che tiene allineati dettaglio mostrato e spawn.
@@ -260,6 +273,29 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         });
         child.on('error', () => setNote(`⚠ create-task: '${CLAUDE_CMD}' non lanciabile`));
     }
+    // La riga di stato di OGNI spawn di sessione Claude: il comando esatto, come
+    // lo si scriverebbe in bash, invece di una parafrasi.
+    //
+    // Non è un di più sulla nota descrittiva, la sostituisce: task, sessionId,
+    // prompt-kind, modello e nota del titolo sono già tutti argomenti del comando,
+    // quindi elencarli a parole li direbbe una seconda volta in una grafia che non
+    // si può ricopiare in un terminale. Ciò che va perso è il tasto premuto
+    // (`^K`, `⏎`, `f`), che è ciò che l'utente ha appena fatto e non ciò che il
+    // deck ha fatto per lui.
+    //
+    // Il taglio è al MEZZO (`cutMiddle`, non `cut`): la testa è il path assoluto
+    // di `deck-run`, identico a ogni spawn, e un taglio dalla coda mostrerebbe
+    // solo quello. Si taglia QUI, alla composizione, e non al render: la riga di
+    // stato porta anche messaggi normali, dove è la testa a contare. Ne discende
+    // che un resize successivo non ricalcola l'elisione — la nota è transitoria e
+    // `wrap="truncate-end"` resta come rete.
+    function noteCommand(cmd) {
+        // 4 = bordo + padding della cornice esterna, 2 = il prompt `$ `. Sbagliare
+        // il budget non produce un errore visibile: la `truncate-end` di Ink taglia
+        // il resto dalla CODA, e il comando esce col mezzo eliso E la fine persa —
+        // cioè con entrambi i pezzi che l'elisione al mezzo voleva salvare.
+        setNote(`$ ${cutMiddle(cmd, Math.max(8, columns - 6))}`);
+    }
     // T56 — apre una sessione bound alla task selezionata. Punto UNICO dei quattro
     // tasti (⏎/^K/^P/^R): fra loro cambia solo il prompt iniziale, tutto il resto
     // è identico — uuid pinnato, binding scritto PRIMA dello spawn (la sessione
@@ -302,25 +338,24 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // il tempo di un tick la riga in lista comparirebbe nuda. Due record separati
     // sullo stesso `sessionId` sono la forma normale di un file append-only
     // last-wins, non una scrittura da fondere.
-    function spawnForTask(id, kind, model, keyLabel, spawnNote = '') {
+    function spawnForTask(id, kind, model, spawnNote = '') {
         const sid = randomUUID();
         appendTaskBinding(cwd, sid, id);
         if (spawnNote)
             appendNote(cwd, sid, spawnNote);
-        const child = spawnDeck(id, cwd, sid, kind, model, spawnNote);
+        const { child, cmd } = spawnDeck(id, cwd, sid, kind, model, spawnNote);
         child.on('error', () => setNote(`⚠ spawn ${id} fallito (${DECK_RUN})`));
-        const what = kind === 'none' ? '' : ` · ${kind}`;
-        // Il modello è SEMPRE nominato, anche quando è il default: gli acceleratori
-        // della lista non passano dal selettore del detail e usano il default fisso
-        // (T108 · via a), quindi senza dirlo l'utente crederebbe di aver ereditato
-        // la scelta fatta nell'ultimo detail aperto.
-        const named = spawnNote ? ` · «${cut(spawnNote, 24)}»` : '';
-        setNote(`${keyLabel} spawn ${id}${what} · ${model}${named} → tab CC (sid ${sid.slice(0, 8)})`);
+        // Il modello resta SEMPRE visibile anche quando è il default, perché è un
+        // argomento esplicito del comando (T108): gli acceleratori della lista non
+        // passano dal selettore del detail e usano il default fisso, quindi senza
+        // vederlo l'utente crederebbe di aver ereditato la scelta dell'ultimo
+        // detail aperto.
+        noteCommand(cmd);
     }
     function spawnTaskSession(kind, keyLabel) {
         const task = selectedTaskOr(keyLabel, 'spawnare');
         if (task)
-            spawnForTask(task.id, kind, MODEL_DEFAULT, keyLabel);
+            spawnForTask(task.id, kind, MODEL_DEFAULT);
     }
     // T53 — apertura del modale nota sulla conversazione selezionata. Come
     // `openEdit`, la bozza parte dal valore ATTUALE: annotare una seconda volta è
@@ -425,10 +460,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setNote(ok ? `✔ ${task.id} → ${summary} · committato` : `⚠ ${task.id} salvato, commit fallito: ${err}`);
         });
     }
-    // T112 — apertura della conferma di eliminazione. Il tasto è uno, il bersaglio
-    // dipende dalla VISTA attiva: `archiviabili` → l'insieme intero, ogni altra →
-    // la task selezionata. Ciò che discrimina sta in header e non sotto le dita,
-    // quindi il modale deve nominare il bersaglio (quante e quali), non l'azione.
+    // T112 — apertura della conferma di eliminazione. Il tasto è uno e il
+    // bersaglio ha due taglie: la task selezionata, o l'insieme intero della vista
+    // `archiviabili`. A discriminare è `purgeBulk` — la selezione prima della
+    // vista. Il modale nomina comunque il bersaglio (quante e quali) e non
+    // l'azione: è l'unico punto in cui la differenza fra i due gesti è leggibile.
     //
     // Il bersaglio del bulk si legge da `paneTasks`, cioè dalla stessa fonte che
     // disegna le righe e alimenta il contatore in header (D6): mai il `Set` grezzo
@@ -444,7 +480,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setNote('CANC → eliminare: seleziona una task (← per il pane)');
             return;
         }
-        const bulk = taskViewId === 'archivable';
+        const bulk = purgeBulk;
         const ids = bulk ? paneTasks.map((t) => t.id) : [];
         if (!bulk) {
             const task = selectedTaskOr('CANC', 'eliminare');
@@ -601,9 +637,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // devono restare la stessa azione.
     function resumeSession(sessionId) {
         const bound = bindings.get(sessionId) ?? null;
-        const child = spawnDeckResume(bound, cwd, sessionId, sessionNotes.get(sessionId));
+        const { child, cmd } = spawnDeckResume(bound, cwd, sessionId, sessionNotes.get(sessionId));
         child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
-        setNote(`⏎ resume ${sessionId.slice(0, 8)} → tab CC${bound ? ` (${bound})` : ' (spot)'}`);
+        noteCommand(cmd);
     }
     // T57 — ⏎ nel modale: riscrive il binding nel sidecar e ricarica subito.
     //
@@ -641,7 +677,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         columns,
         setMode,
         setNote,
-        onAction: (id, kind, model, spawnNote, label) => spawnForTask(id, kind, model, label, spawnNote),
+        onAction: (id, kind, model, spawnNote) => spawnForTask(id, kind, model, spawnNote),
     });
     const search = useSearchOverlay({
         sessions,
@@ -1007,9 +1043,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                         ...(bound ? { taskId: bound } : {}),
                         forkOf: s.sessionId,
                     });
-                    const child = spawnDeckFork(bound, cwd, s.sessionId, newId);
+                    const { child, cmd } = spawnDeckFork(bound, cwd, s.sessionId, newId);
                     child.on('error', () => setNote(`⚠ fork fallito (${DECK_RUN})`));
-                    setNote(`⑂ fork ${s.sessionId.slice(0, 8)} → ${newId.slice(0, 8)}${bound ? ` (${bound})` : ' (spot)'}`);
+                    noteCommand(cmd);
                 }
             }
         }
@@ -1086,9 +1122,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // Minuscola = azione immediata (convenzione T39), gemella di `t`: entrambe
             // aprono una surface del cappello senza passare da un modale. `C` (create
             // task) resta distinta — stessa lettera, ma la maiuscola è per i modali.
-            const child = spawnClaudeEmpty(cwd);
+            const { child, cmd } = spawnClaudeEmpty(cwd);
             child.on('error', () => setNote(`⚠ c → spawn claude fallito (${DECK_RUN})`));
-            setNote(`c → claude nuda su ${projectName} (nessuna task)`);
+            noteCommand(cmd);
         }
         else if (input === 'w') {
             // Salvataggio ESPLICITO: comporre una vista non tocca il disco, così
@@ -1147,11 +1183,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // Nessuna voce di uscita: non esiste più un tasto che chiuda il deck.
     const keyLegend = sanitize([
         ...(canSpawn ? ['⏎ detail', '^K/^P/^R spawn'] : canResume ? ['⏎ resume'] : []),
-        // T112 — la voce nomina il BERSAGLIO, che cambia con la vista attiva
-        // senza che cambi il tasto: dire solo «CANC elimina» lascerebbe credere
-        // che sulla vista `archiviabili` agisca sulla riga selezionata.
+        // T112 — la voce nomina il BERSAGLIO, che cambia di taglia senza che
+        // cambi il tasto. Legge `purgeBulk`, la stessa condizione del ramo di
+        // apertura: una legenda che annunciasse «tutte» dove il tasto ne pota una
+        // sola sarebbe peggio di nessuna legenda.
         ...(focus === 'tasks'
-            ? [taskViewId === 'archivable' ? 'CANC elimina tutte' : 'CANC elimina']
+            ? [purgeBulk ? 'CANC elimina tutte' : 'CANC elimina']
             : []),
         ...(canResume ? ['f fork'] : []),
         ...(canPin ? ['p pin', 'N nota', 'A assegna'] : []),

package/dist/overlays/sheet.js

@@ -205,7 +205,7 @@ export function useSheetOverlay(deps) {
             const note = spawnNote.trim();
             close();
             if (id)
-                onAction(id, act.kind, model, note, `⏎ ${act.label}`);
+                onAction(id, act.kind, model, note);
         }
         else if (key.tab) {
             // T108 — `tab` scorre il catalogo dei modelli, e da T111 è il SOLO canale:

package/dist/spawn.js

@@ -32,6 +32,40 @@ export function spawnOut(cmd, args, opts) {
     fake.unref = () => fake;
     return fake;
 }
+// Caratteri che una shell POSIX passa attraverso senza interpretarli: tutto il
+// resto (spazi, apici, `$`, glob, non-ASCII) va quotato o il comando ricopiato
+// dalla riga di stato non farebbe la stessa cosa di quello eseguito.
+const SHELL_SAFE = /^[A-Za-z0-9_@%+=:,./-]+$/;
+/**
+ * Un argomento come lo si scriverebbe in bash.
+ *
+ * Apici SINGOLI, non doppi: dentro i singoli nessun carattere resta speciale,
+ * quindi non c'è da enumerare cosa sfuggire. L'unico caso da chiudere è l'apice
+ * stesso, che si esce dalla stringa (`'\''`) invece di essere escapato dentro.
+ *
+ * Il deck non passa MAI da una shell — `spawn` senza `shell:true` consegna
+ * l'argv a execve così com'è. Questo quoting esiste per la sola RESA: rende la
+ * riga ricopiabile in un terminale senza cambiare di una virgola ciò che il
+ * deck ha davvero eseguito.
+ */
+export function shellQuote(arg) {
+    if (arg === '')
+        return "''";
+    if (SHELL_SAFE.test(arg))
+        return arg;
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+export function shellCommand(cmd, args) {
+    return [cmd, ...args].map(shellQuote).join(' ');
+}
+// I quattro percorsi di spawn di una sessione Claude interattiva differiscono
+// SOLO per l'argv: stesso eseguibile, stesso detached, stesso `unref`. Il corpo
+// sta qui una volta sola, così anche il comando mostrato nasce in un punto solo.
+function launchDeckRun(args, cwd) {
+    const child = spawnOut(DECK_RUN, args, { cwd, detached: true, stdio: 'ignore' });
+    child.unref();
+    return { child, cmd: shellCommand(DECK_RUN, args) };
+}
 // L'ordine È il giro di `tab` nel detail, non una preferenza di lettura:
 // cambiarlo sposta le voci sotto le dita di chi le ha imparate. Fino a T111 era
 // anche il binding delle cifre `1`-`4`, passate poi al campo nota.
@@ -79,13 +113,7 @@ export function deckArgs(id, sessionId, kind, model = MODEL_DEFAULT, spawnNote)
     return args;
 }
 export function spawnDeck(id, cwd, sessionId, kind, model = MODEL_DEFAULT, spawnNote) {
-    const child = spawnOut(DECK_RUN, deckArgs(id, sessionId, kind, model, spawnNote), {
-        cwd,
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    return child;
+    return launchDeckRun(deckArgs(id, sessionId, kind, model, spawnNote), cwd);
 }
 // T49 — resume di una sessione esistente come nuova tab Ptyxis. Scoped (taskId
 // presente) → `deck-run <task> --resume <sid>`: la ripresa eredita LOOM_TASK +
@@ -109,13 +137,7 @@ export function resumeArgs(taskId, sessionId, note) {
     return args;
 }
 export function spawnDeckResume(taskId, cwd, sessionId, note) {
-    const child = spawnOut(DECK_RUN, resumeArgs(taskId, sessionId, note), {
-        cwd,
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    return child;
+    return launchDeckRun(resumeArgs(taskId, sessionId, note), cwd);
 }
 // T28 — FORK: `deck-run <task|--no-task> --resume <origine> --fork --session-id
 // <nuovo>`. Variante del resume, non una terza forma: cambia solo che CC apre un
@@ -140,13 +162,7 @@ export function forkArgs(taskId, originId, newId) {
     ];
 }
 export function spawnDeckFork(taskId, cwd, originId, newId) {
-    const child = spawnOut(DECK_RUN, forkArgs(taskId, originId, newId), {
-        cwd,
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    return child;
+    return launchDeckRun(forkArgs(taskId, originId, newId), cwd);
 }
 // T42 — sessione Claude NUDA: nessuna task, nessun prompt iniziale, nessun
 // sessionId pinnato (quindi nessuna entry nel sidecar session-tasks.jsonl: senza
@@ -155,13 +171,7 @@ export function spawnDeckFork(taskId, cwd, originId, newId) {
 // sporcherebbe il percorso bound. Il titolo tab resta la label loom — lo mette
 // deck-run, perché il match compass è window-level e non sa nulla di task.
 export function spawnClaudeEmpty(cwd) {
-    const child = spawnOut(DECK_RUN, ['--no-task'], {
-        cwd,
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    return child;
+    return launchDeckRun(['--no-task'], cwd);
 }
 // T39/T32: voce `launch` custom del file config, eseguita con cwd = project root.
 // Spawn detached come spawnDeck: il deck lancia ma non possiede il processo.

package/dist/width.js

@@ -328,6 +328,56 @@ export function pad(s, cols, align = 'left') {
     const fill = ' '.repeat(Math.max(0, cols - termWidth(t)));
     return align === 'right' ? fill + t : t + fill;
 }
+/**
+ * Taglio a un budget di COLONNE che sacrifica il MEZZO invece della coda.
+ *
+ * Serve dove la testa e la coda portano informazione diversa e la TESTA è quella
+ * costante: il comando di uno spawn è sempre lo stesso path assoluto di
+ * `deck-run`, e quel che cambia da un'invocazione all'altra (task, sessionId,
+ * prompt-kind, modello, nota) sta tutto in fondo. Un `cut()` su quella riga
+ * mostrerebbe l'unica parte che non cambia mai.
+ *
+ * La coda prende due terzi del budget e la testa il resto: basta a riconoscere
+ * l'eseguibile senza mangiare gli argomenti. Testa e coda non possono
+ * sovrapporsi — insieme occupano al più `cols - 1` colonne, cioè meno della
+ * stringa intera (che qui è già più larga del budget).
+ *
+ * Niente collasso del whitespace (a differenza di `cut`): la stringa in ingresso
+ * è un comando, e due spazi dentro un argomento quotato sono suoi. Restano
+ * appiattiti i soli a-capo, che sfonderebbero la riga singola.
+ */
+export function cutMiddle(s, cols) {
+    const flat = s.replace(/[\r\n\t]+/g, ' ');
+    if (cols <= 0)
+        return '';
+    if (termWidth(flat) <= cols)
+        return flat;
+    if (cols === 1)
+        return '…';
+    const budget = cols - 1; // -1 = la colonna dell'ellissi, che qui c'è di sicuro
+    const headCols = budget - Math.ceil((budget * 2) / 3);
+    let head = '';
+    let hw = 0;
+    for (const ch of flat) {
+        const cw = termWidth(ch);
+        if (hw + cw > headCols)
+            break;
+        head += ch;
+        hw += cw;
+    }
+    const chars = [...flat];
+    let tail = '';
+    let tw = 0;
+    for (let i = chars.length - 1; i >= 0; i--) {
+        const ch = chars[i];
+        const cw = termWidth(ch);
+        if (hw + tw + cw > budget)
+            break;
+        tail = ch + tail;
+        tw += cw;
+    }
+    return head + '…' + tail;
+}
 /**
  * Larghezza in colonne di UN carattere **dopo** `sanitize`.
  *

package/package.json

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