@lamemind/loom-deck 0.36.0 → 0.38.0

package/README.md

@@ -66,6 +66,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 |
 | 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** |
@@ -93,6 +94,24 @@ Le emoji sono quelle del menu compass. Per il terminale compass usa 🖥️, che
 
 `t` e `c` sono gemelle: entrambe aprono una surface del cappello nella stessa finestra Ptyxis, senza passare da un modale. `c` (minuscola, azione) e `C` (maiuscola, modale create-task) restano distinte per la regola sopra — così come `f` (fork) e `F` (filtri).
 
+### `CANC` — eliminare task
+
+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:
+
+| Vista attiva | Bersaglio |
+|---|---|
+| `archiviabili` | **tutte** le task che la vista mostra |
+| qualunque altra | la **task selezionata** |
+
+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.
+
+- **`CANC` è anche Backspace.** Ink battezza `delete` sia `\x7f` sia `\x1b[3~` e azzera `input`: a valle non resta nulla da cui distinguerli. Il binding vive nel modo `normal`, che non ha campi di testo, e ogni modo che ne ha uno cattura l'input e non vede quel ramo — la conferma è la rete contro chi usa Backspace come «indietro».
+- **Le folder con file non tracciati si scartano a monte.** `clean-tasks.sh` esce 2 appena trova una task folder con file che `git rm` non rimuove, e lo fa *prima* di potare qualsiasi cosa: in un bulk su N target, uno solo non conforme annullerebbe il lavoro sugli altri N-1. Il deck replica il predicato del gate (`git ls-files -o`), marca quelle task con `⚠` nella vista `archiviabili` e le esclude dal bulk — nominandole nella conferma, perché promettere 7 e farne 5 sarebbe una bugia invisibile.
+- **Sulla singola task sporca la conferma ha tre uscite**: `⏎` su `keep` (snapshot in git prima del purge), `⏎` su `purge` (file persi), `esc`. La scelta viaggia come `--ignored-files` ed è rara: nasconderla dentro un binario `⏎`/`esc` la mascherebbe.
+- **`CANC` col focus sul pane Sessions è inerte e lo dice**, come `F` fuori dalla vista principale.
+
 ### I cinque modi di entrare in una task
 
 Sulla task selezionata (focus sul pane Tasks) si apre una sessione **bound**: `LOOM_TASK` iniettata, `sessionId` pinnato, binding scritto nel sidecar. Fra i modi cambia **solo il prompt iniziale**.

package/dist/archivable.js

@@ -1,9 +1,13 @@
 // T61 — conteggio delle task Done potabili ("archiviabili").
 //
-// Il deck NON pota: mostra solo quante task Done hanno superato la soglia
-// d'età, così la policy di retention — manuale per scelta, nessuna GC
-// automatica — ha almeno un segnale che la renda esercitabile. La potatura
-// resta `loom-works:clean-tasks`, invocata da un umano.
+// Il deck ORDINA la potatura, non la esegue (T112): questo modulo dice quante
+// e quali Done hanno superato la soglia d'età, `CANC` sul pane task apre la
+// conferma, e la rimozione vera resta `loom-works:clean-tasks` — invocata da un
+// umano allora come adesso, con la sola differenza che ora la superficie da cui
+// la ordina è il deck. La sequenza distruttiva (task file + folder + riga in
+// tasks.md, un commit per task) è implementata una volta sola, nello script:
+// averne una seconda qui darebbe due `git rm` capaci di divergere.
+// La policy di retention resta manuale per scelta, nessuna GC automatica.
 //
 // D1 (preflight) — la regola d'età è RICALCOLATA qui, non delegata a
 // `cleanup-done-tasks.sh`: il deck è un binario npm globale spawnato da Ptyxis,

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { render, Box, Text, useApp, useInput } from 'ink';
 import { useState, useEffect, useMemo } from 'react';
 import { randomUUID } from 'node:crypto';
@@ -14,21 +14,23 @@ import { cut, 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';
+import { purgeTargets, splitTargets } from './purge.js';
 import { conversationLabel, cpLen, editField, insertAt, isDone, isTextRow, removeAt, EDIT_ROWS, } from './layout.js';
 import { TASK_EMPTY, relTime, sanitizeTyped } from './glyphs.js';
-import { commitTaskEdit, runLaunch, spawnClaudeEmpty, spawnCreateTask, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, CLAUDE_CMD, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
-import { EditModal, FilterModal, SortModal } from './ui/modals.js';
+import { commitTaskEdit, runLaunch, spawnClaudeEmpty, spawnCleanTasks, spawnCreateTask, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, CLAUDE_CMD, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
+import { EditModal, FilterModal, PurgeModal, SortModal, idList } from './ui/modals.js';
 import { ReaderScreen, SearchScreen } from './ui/search-screen.js';
 import { DetailScreen } from './ui/detail-screen.js';
 import { AssignScreen } from './ui/assign-screen.js';
 import { SessionsPane, TasksPane } from './ui/panes.js';
 import { PreviewPane, detailMetaOf } from './ui/preview.js';
 import { loadView, saveView, viewFilePath } from './view-store.js';
-import { useArchivable, useSessions, useTaskDetail, useTasks, useTerminalSize } from './hooks.js';
+import { useArchivable, useDirtyFolders, useSessions, useTaskDetail, useTasks, useTerminalSize, } from './hooks.js';
 import { useSearchOverlay } from './overlays/search.js';
 import { useSheetOverlay } from './overlays/sheet.js';
 import { useAssignOverlay } from './overlays/assign.js';
 import { captures } from './input-modes.js';
+import { VERSION } from './version.js';
 function Deck({ cwd, tasksPath, tasksDir }) {
     const { exit } = useApp();
     const { tasks, loadError } = useTasks(tasksPath);
@@ -75,6 +77,8 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // T41 — bozza dell'edit (null fuori dal modale) e riga attiva della griglia.
     const [edit, setEdit] = useState(null);
     const [editRow, setEditRow] = useState(0);
+    // T112 — bozza della conferma di eliminazione (null fuori dal modale).
+    const [purge, setPurge] = useState(null);
     // Dimensioni vive del terminale: sono l'input del budget d'altezza sotto.
     const { rows, columns } = useTerminalSize();
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
@@ -99,6 +103,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const doneSig = useMemo(() => tasks.filter((t) => isDone(t.prog)).map((t) => t.id).join(','), [tasks]);
     const archivableDays = useMemo(() => loadArchivableDays(cwd), [cwd]);
     const archivable = useArchivable(doneSig, tasksDir, cwd, archivableDays);
+    // T112 — secondo asse di stato della vista `archiviabili`: quali fra le
+    // eliminabili hanno una folder che `git rm` non svuoterebbe. Si misura solo
+    // su quelle, non su tutta la lista: fuori da quella vista `CANC` agisce su
+    // una task sola e il dato lo ricalcola al momento.
+    const archivableSig = useMemo(() => [...archivable].sort().join(','), [archivable]);
+    const dirtyFolders = useDirtyFolders(archivableSig, tasksDir, cwd);
     // T100 — le task effettivamente a schermo: la vista principale coincide con
     // `viewTasks` (nessun ricalcolo sul cammino di default), le altre due passano
     // dal predicato del catalogo. I CONTATORI restano misurati sulla vista di
@@ -416,6 +426,137 @@ 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.
+    //
+    // 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
+    // di `archivable.ts`, mai un secondo filtro sullo stato. T100 ha fissato che
+    // ciò che si conta e ciò che si mostra siano lo stesso insieme per
+    // costruzione; qui l'invariante si estende a ciò che si pota.
+    function openPurge() {
+        // La guardia di focus sta QUI e non solo dentro `selectedTaskOr`: il ramo
+        // bulk non passa da quella, perché il suo oggetto è la vista e non la
+        // selezione. Senza, `CANC` col focus sulle sessioni potrebbe potare in
+        // blocco senza che nessuna task fosse selezionata.
+        if (focus !== 'tasks') {
+            setNote('CANC → eliminare: seleziona una task (← per il pane)');
+            return;
+        }
+        const bulk = taskViewId === 'archivable';
+        const ids = bulk ? paneTasks.map((t) => t.id) : [];
+        if (!bulk) {
+            const task = selectedTaskOr('CANC', 'eliminare');
+            if (!task)
+                return;
+            ids.push(task.id);
+        }
+        if (ids.length === 0) {
+            setNote('CANC → nessuna task in vista da eliminare');
+            return;
+        }
+        // Ricalcolo al momento dell'AZIONE, non lettura del campionamento in lista:
+        // una folder sporcata dopo l'ultimo scan si presenterebbe come eliminabile.
+        const { clean, dirty } = splitTargets(purgeTargets(ids, tasksDir, cwd));
+        if (bulk) {
+            // Il gate del plugin esce 2 PRIMA di toccare qualsiasi cosa, quindi una
+            // sola folder sporca annullerebbe il purge di tutte le altre: si scartano
+            // a monte e il modale nomina sia le potate sia le scartate.
+            if (clean.length === 0) {
+                setNote(`CANC → ${dirty.length} task con file non tracciati in folder: eliminale una per una`);
+                return;
+            }
+            setPurge({
+                ids: clean.map((t) => t.id),
+                skipped: dirty.map((t) => t.id),
+                bulk: true,
+                ignored: null,
+                survivors: 0,
+            });
+        }
+        else {
+            // Singola con superstiti → conferma a TRE uscite (D3): la scelta
+            // keep/purge è rara e distruttiva in modo diverso dal purge normale, e
+            // qui è visibile invece di stare davanti a ogni potatura.
+            const one = clean[0] ?? dirty[0];
+            setPurge({
+                ids: [one.id],
+                skipped: [],
+                bulk: false,
+                ignored: one.survivors > 0 ? 'keep' : null,
+                survivors: one.survivors,
+            });
+        }
+        setNote('');
+        setMode('purge');
+    }
+    function onPurgeKey(_input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setPurge(null);
+            setNote('CANC → eliminazione annullata');
+        }
+        else if (key.return) {
+            submitPurge();
+        }
+        else if ((key.leftArrow || key.rightArrow) && purge?.ignored) {
+            setPurge((p) => (p ? { ...p, ignored: p.ignored === 'keep' ? 'purge' : 'keep' } : p));
+        }
+    }
+    // ⏎ nella conferma: ordina la potatura a `loom-works:clean-tasks` e la
+    // osserva. Il deck non rimuove niente da sé — nessun `git rm`, nessuna
+    // riscrittura di tasks.md, nessuna `unlink`: quella sequenza è già
+    // implementata una volta, e averne due significherebbe due rimozioni capaci
+    // di divergere.
+    //
+    // La lista si riallinea al primo tick del poll e il set delle archiviabili
+    // allo scan che `doneSig` fa scattare quando la popolazione Done cambia; la
+    // selezione, keyed su id, cade sulla prima riga della vista (effect di
+    // validità) invece che su una posizione residua.
+    function submitPurge() {
+        const draft = purge;
+        setMode('normal');
+        setPurge(null);
+        if (!draft)
+            return;
+        const sid = randomUUID();
+        setNote(`⏳ eliminando ${draft.ids.length} task… ${idList(draft.ids, 6)}`);
+        const child = spawnCleanTasks(draft.ids, cwd, sid, draft.ignored, (ok, detail) => {
+            // L'esito si misura su `tasks.md`, NON sul solo `is_error`. Misurato: col
+            // gate `--ignored-files` che blocca, la skill spiega il blocco e chiude
+            // comunque `is_error: false` — un successo dichiarato su zero rimozioni.
+            // Il segnale robusto è quali degli ID bersaglio non hanno più una riga:
+            // deterministico, e indipendente da come la skill racconta sé stessa.
+            let survived = draft.ids;
+            try {
+                const now = new Set(loadTasks(tasksPath).map((t) => t.id));
+                survived = draft.ids.filter((id) => now.has(id));
+            }
+            catch {
+                // tasks.md illeggibile → nessuna verifica possibile, e allora si dice
+                // che non è stata fatta invece di dedurre un esito.
+                setNote(`⚠ ${draft.ids.length} task: esito non verificabile (tasks.md illeggibile)`);
+                return;
+            }
+            const removed = draft.ids.length - survived.length;
+            if (removed === draft.ids.length) {
+                // Il push non c'è, per scelta della skill: finché nessuno pusha, un
+                // altro worktree continua a vedere le task potate in tasks.md. Non
+                // dirlo lascerebbe leggere l'assenza di push come «fatto».
+                setNote(`✔ ${removed} task eliminate · commit locali, nessun push`);
+            }
+            else {
+                // Il gate `--ignored-files` (exit 2) può scattare lo stesso: la
+                // dirtiness è un dato campionato e una folder può sporcarsi fra il
+                // ricalcolo e l'apply. Il testo del result event è l'unica cosa che dice
+                // PERCHÉ, quindi entra nella riga invece di un ⚠ muto.
+                setNote(`⚠ ${removed}/${draft.ids.length} eliminate · restano ${idList(survived, 4)} · ${cut(detail || (ok ? '' : `${CLAUDE_CMD} -p`), 56)}`);
+            }
+        });
+        child?.on('error', () => setNote(`⚠ clean-tasks: '${CLAUDE_CMD}' non lanciabile`));
+    }
     // Chiusura di un modale di vista: `restore` rimette la fotografia scattata
     // all'apertura (esc = annulla), altrimenti tiene ciò che si è composto (⏎).
     function closeViewModal(restore) {
@@ -702,6 +843,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         sort: onSortKey,
         filter: onFilterKey,
         edit: onEditKey,
+        purge: onPurgeKey,
     };
     useInput((input, key) => {
         // Un modo capturing consuma TUTTO — acceleratori globali compresi — e le
@@ -799,6 +941,16 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 }
             }
         }
+        else if (key.delete) {
+            // T112/D1 — `CANC` non esiste come tasto distinto in Ink: `\x7f`
+            // (Backspace) e `\x1b[3~` (Canc) collassano entrambi su `key.delete` con
+            // `input` azzerato, quindi a valle non resta niente da cui distinguerli.
+            // Il binding vale per entrambi e si accetta come tale: in `normal` non
+            // c'è nessun campo di testo da cui Backspace possa rubare un significato,
+            // e ogni modo che ne ha uno è capturing e non vede questo ramo. Il modale
+            // di conferma è la rete contro chi usa Backspace come «indietro».
+            openPurge();
+        }
         else if (input === 'C') {
             setNote('');
             setMode('create');
@@ -993,6 +1145,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // ridirlo a parole costava colonne su una riga che tronca in silenzio.
     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.
+        ...(focus === 'tasks'
+            ? [taskViewId === 'archivable' ? 'CANC elimina tutte' : 'CANC elimina']
+            : []),
         ...(canResume ? ['f fork'] : []),
         ...(canPin ? ['p pin', 'N nota', 'A assegna'] : []),
         '^F cerca',
@@ -1123,9 +1281,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // a una riga sola. Perdere il deck per un terminale basso è meglio che
     // sporcare la cronologia del terminale a ogni poll.
     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 ?? parentLabel, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga"] })] }));
+        return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "v", VERSION, " \u00B7 ", viewTasks.length, " task \u00B7 sel ", selectedTaskId ?? parentLabel, " \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 === '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, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${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, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: ["v", VERSION] })] }), 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 === 'purge' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["elimina task \u00B7", ' ', purge?.ignored ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " keep/purge dei file non tracciati \u00B7", ' '] })) : null, _jsx(Text, { color: "yellow", children: "\u23CE" }), " conferma \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, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${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, columns: columns })) : null, mode === 'purge' && purge ? _jsx(PurgeModal, { draft: purge, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, dirty: dirtyFolders }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const cwd = process.cwd();
 render(_jsx(Deck, { cwd: cwd, tasksPath: resolveTasksPath(cwd), tasksDir: resolveTasksDir(cwd) }));

package/dist/hooks.js

@@ -10,6 +10,7 @@ import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { loadSessionIndex } from './task-index.js';
 import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
+import { purgeTargets } from './purge.js';
 import { POLL_MS } from './model.js';
 // Dimensioni del terminale, live sul resize.
 //
@@ -179,6 +180,42 @@ export function useArchivable(doneSig, tasksDir, projectRoot, days) {
     }, [doneSig, tasksDir, projectRoot, days]);
     return ids;
 }
+// T112 — quali fra le task passate hanno una folder che `git rm` non
+// svuoterebbe (file ignorati o mai tracciati). È il SECONDO asse di stato della
+// vista `archiviabili`: eliminabile · dirty.
+//
+// Non viene dalla fonte della lista. Le righe arrivano da `tasks.md` (poll
+// 1,5s), la dirtiness dal filesystem via git su questa cadenza — mount, cambio
+// dell'insieme, poi ogni SCAN_INTERVAL_MS, gemella di `useArchivable` e per la
+// stessa ragione: una folder non si sporca al ritmo di un poll.
+//
+// Ne discende che il dato è CAMPIONATO e può essere stale nell'istante in cui
+// si preme il tasto — perciò il momento dell'azione lo ricalcola da sé
+// (`purgeTargets`), e questo hook serve solo a mostrarlo in lista.
+export function useDirtyFolders(idsSig, tasksDir, projectRoot) {
+    const [dirty, setDirty] = useState(() => new Set());
+    useEffect(() => {
+        const ids = idsSig ? idsSig.split(',') : [];
+        const scan = () => {
+            try {
+                const found = purgeTargets(ids, tasksDir, projectRoot)
+                    .filter((t) => t.survivors > 0)
+                    .map((t) => t.id);
+                setDirty(new Set(found));
+            }
+            catch {
+                // git muto o task file illeggibili → nessun marker. Il gate del plugin
+                // resta la rete: un marker mancante non autorizza niente, fa solo
+                // arrivare il rifiuto più tardi.
+                setDirty(new Set());
+            }
+        };
+        scan();
+        const id = setInterval(scan, SCAN_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, [idsSig, tasksDir, projectRoot]);
+    return dirty;
+}
 // Legge il task file della task selezionata (Q1+B T20). On-id-change: navigare
 // con ↑↓ ricarica il dettaglio; leggere un singolo file 4-9KB è I/O triviale,
 // niente debounce serve per la tastiera. Il refresh del contenuto a file fermo

package/dist/input-modes.js

@@ -29,6 +29,7 @@ export const CAPTURING_MODES = [
     'sort',
     'filter',
     'edit',
+    'purge',
 ];
 const _MODES_ARE_EXHAUSTIVE = true;
 void _MODES_ARE_EXHAUSTIVE;
@@ -46,6 +47,9 @@ export function captures(mode) {
  * sopravvive: è un tasto diverso che porta lo stesso nome, e il modo se lo
  * gestisce da sé. Sta scritto qui perché è l'eccezione a una regola dichiarata,
  * e un'eccezione che vive solo dentro un `if` annidato è come non averla.
+ *
+ * `purge` (T112) non ne ha e non può averne: è una domanda binaria, e dentro
+ * una domanda non c'è nessun acceleratore da salvare.
  */
 export const CTRL_DEROGATIONS = {
     detail: ['f'],

package/dist/purge.js

@@ -0,0 +1,116 @@
+// T112 — il BERSAGLIO di una potatura, e se il gate del plugin lo lascerebbe
+// passare.
+//
+// Il deck non pota: ordina la potatura a `loom-works:clean-tasks`, che possiede
+// l'intera sequenza distruttiva (task file + folder dot-prefixed + riga in
+// tasks.md, un commit atomico per task, symlink `current-task.md` rimosso,
+// righe orfane riconciliate). Qui non c'è nessun `git rm` e nessuna riscrittura
+// di tasks.md — solo il calcolo di CHI si può potare.
+//
+// D3/D4 (preflight) — il gate `--ignored-files` di `clean-tasks.sh` esce 2
+// PRIMA di toccare qualsiasi cosa: in un'invocazione su N target, una sola
+// folder con file che `git rm` non rimuove annulla il lavoro sugli altri N-1.
+// Un chiamante che scoprisse la condizione dall'exit code potrebbe solo
+// riportare il fallimento intero, quindi il deck replica il predicato del gate
+// e scarta i non conformi a monte. È la TERZA duplicazione di un criterio del
+// plugin dentro il deck (dopo la regola d'età, D1 di T61): se lo script cambia
+// il modo di contare i superstiti, le due letture divergono in silenzio. Costo
+// accettato perché il canale alternativo — un dry-run via processo Claude
+// headless — non è rifacibile on-demand, cioè al momento in cui il tasto viene
+// premuto.
+import { execFileSync } from 'node:child_process';
+import { readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { findTaskFile } from './tasks.js';
+/**
+ * Il campo `- **Folder**: <path>` del task file, primo token soltanto.
+ *
+ * Gemello di `read_field` in `clean-tasks.sh`, che chiude il valore con un
+ * `awk '{print $1; exit}'`: il campo ammette un'annotazione inline dopo il path
+ * (`.26-06-16-cat (condivisa con T19)`) e prenderla dentro produrrebbe una
+ * directory inesistente.
+ *
+ * `[ \t]*` e non `\s*`: con un campo vuoto (`- **Folder**:` seguito dall'a
+ * capo) uno `\s*` mangerebbe la newline e `(\S+)` catturerebbe il primo token
+ * della riga SUCCESSIVA — cioè un path preso da un altro campo.
+ */
+export function folderField(content) {
+    const m = content.match(/^-[ \t]*\*\*Folder\*\*:[ \t]*(\S+)/m);
+    return m ? m[1] : '';
+}
+/** Task folder della task, risolta e verificata su disco. */
+export function taskFolder(projectRoot, taskFilePath) {
+    let content;
+    try {
+        content = readFileSync(taskFilePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const field = folderField(content);
+    if (!field)
+        return null;
+    const abs = join(projectRoot, field.replace(/^\.\//, ''));
+    try {
+        if (!statSync(abs).isDirectory())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return abs;
+}
+/**
+ * I file di una folder che `git rm` non rimuove — ignorati da un `.gitignore` o
+ * mai tracciati.
+ *
+ * Stesso comando di `lw_folder_survivors` in `lib.sh` (`git ls-files -o`, senza
+ * `--exclude-standard`, quindi ignorati inclusi): replicare il predicato del
+ * gate ha senso solo se è LO STESSO predicato.
+ *
+ * Git muto (non installato, repo assente) → lista vuota, cioè "conforme". La
+ * direzione dell'errore è deliberata: il gate a valle resta comunque la rete,
+ * e il chiamante ne riporta il fallimento invece di dichiarare successo.
+ */
+export function folderSurvivors(projectRoot, folder) {
+    const rel = relative(projectRoot, folder);
+    if (!rel || rel.startsWith('..'))
+        return [];
+    try {
+        const out = execFileSync('git', ['ls-files', '-o', '--', rel], {
+            cwd: projectRoot,
+            encoding: 'utf8',
+        });
+        return out.split('\n').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Il bersaglio, misurato ADESSO.
+ *
+ * Sincrono apposta: la dirtiness è un dato campionato (la vista `archiviabili`
+ * lo mostra da uno scan periodico) e nell'istante in cui si preme il tasto può
+ * essere stale — una folder sporcata dopo l'ultimo scan si presenterebbe come
+ * eliminabile. Ricalcolarlo al momento dell'azione costa uno spawn di git per
+ * le sole task che dichiarano una folder, cioè quasi nulla.
+ */
+export function purgeTargets(ids, tasksDir, projectRoot) {
+    return ids.map((id) => {
+        const taskFile = findTaskFile(tasksDir, id);
+        const folder = taskFile ? taskFolder(projectRoot, taskFile) : null;
+        return {
+            id,
+            folder,
+            survivors: folder ? folderSurvivors(projectRoot, folder).length : 0,
+        };
+    });
+}
+/** Conformi al gate (potabili in blocco) e non conformi (da scartare a monte). */
+export function splitTargets(targets) {
+    return {
+        clean: targets.filter((t) => t.survivors === 0),
+        dirty: targets.filter((t) => t.survivors > 0),
+    };
+}

package/dist/spawn.js

@@ -204,28 +204,26 @@ export function spawnTerminal(cwd, title) {
 }
 // Comando claude (override per ambienti dove non è su PATH; loom-deck → NPM).
 export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
-// T30: create-task inline. Spawna CC HEADLESS (`-p`) con `--session-id` pinnato
-// che invoca la skill create-task. Differenze da spawnDeck:
+// T30: invocazione di una skill del plugin da CC HEADLESS (`-p`), con
+// `--session-id` pinnato. È la TERZA strada per eseguire uno script del plugin
+// da un consumer che non ha `CLAUDE_PLUGIN_ROOT`: il path version-pinned della
+// cache lo risolve il processo Claude, e il deck non lo nomina mai.
 //  - headless (`-p`), non una tab Ptyxis interattiva → il deck osserva l'esito;
-//  - `yolo` FORZATO: create-task è interattiva di default (AskUserQuestion) e in
-//    `-p` non può ricevere risposte → si impianterebbe. yolo = zero domande.
 //  - `--output-format stream-json` (richiede `--verbose`): l'ultima riga è
-//    `{type:"result", is_error}`, segnale di completamento robusto (> exit code).
-//  - detached (own process-group) → il create sopravvive alla chiusura del deck e
-//    completa commit+push da sé; stdout in pipe SOLO per leggere il result event.
-// Il prompt viaggia come singolo argv (no shell) → nessuna injection dal testo utente.
-export function spawnCreateTask(text, cwd, sessionId, onResult) {
-    const child = spawnOut(CLAUDE_CMD, [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--session-id',
-        sessionId,
-        `/loom-works:create-task yolo ${text}`,
-    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+//    `{type:"result", is_error}`, segnale di completamento robusto (> exit code);
+//  - detached (own process-group) → il lavoro sopravvive alla chiusura del deck
+//    e completa i commit da sé; stdout in pipe SOLO per leggere il result event.
+// Il prompt viaggia come singolo argv (no shell) → nessuna injection dal testo.
+//
+// `detail` è il testo finale del result event, troncato dal chiamante: senza,
+// un fallimento arriva come booleano nudo e la riga di stato può solo dire "non
+// ha funzionato" — che su un'operazione distruttiva non basta a sapere se
+// qualcosa è stato rimosso.
+function spawnSkill(prompt, cwd, sessionId, onResult) {
+    const child = spawnOut(CLAUDE_CMD, ['-p', '--output-format', 'stream-json', '--verbose', '--session-id', sessionId, prompt], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
     let buf = '';
     let isError = null;
+    let detail = '';
     child.stdout?.on('data', (chunk) => {
         buf += chunk.toString();
         let nl;
@@ -236,8 +234,11 @@ export function spawnCreateTask(text, cwd, sessionId, onResult) {
                 continue;
             try {
                 const obj = JSON.parse(line);
-                if (obj.type === 'result')
+                if (obj.type === 'result') {
                     isError = obj.is_error ?? false;
+                    if (typeof obj.result === 'string')
+                        detail = obj.result;
+                }
             }
             catch {
                 // riga parziale / non-json → skip
@@ -246,12 +247,54 @@ export function spawnCreateTask(text, cwd, sessionId, onResult) {
     });
     // Drena stderr per non riempire il buffer pipe (deadlock del figlio).
     child.stderr?.on('data', () => { });
-    child.on('error', () => onResult(false));
+    child.on('error', () => onResult(false, `'${CLAUDE_CMD}' non lanciabile`));
     child.on('close', (code) => {
-        onResult(isError === null ? code === 0 : !isError);
+        onResult(isError === null ? code === 0 : !isError, detail);
     });
     return child;
 }
+// T30: create-task inline. `yolo` FORZATO: create-task è interattiva di default
+// (AskUserQuestion) e in `-p` non c'è nessuno che risponda → la sessione
+// resterebbe appesa. yolo = zero domande.
+export function spawnCreateTask(text, cwd, sessionId, onResult) {
+    return spawnSkill(`/loom-works:create-task yolo ${text}`, cwd, sessionId, (ok) => onResult(ok));
+}
+// T112 — potatura ordinata a `loom-works:clean-tasks`. Modo A della skill (ID
+// espliciti), MAI il modo B (`--days`): passarle una soglia d'età le farebbe
+// ricalcolare il bersaglio con la propria regola, che è già la copia divergibile
+// di quella del deck (D6 preflight). Il bersaglio lo decide il deck e la skill
+// lo esegue.
+//
+// `yolo` come in create-task, e per la stessa ragione con una posta più alta:
+// `clean-tasks` chiede conferma quando fra i target ci sono task non-Done, e in
+// headless quella domanda non ha nessuno che risponda. Il token dichiara che la
+// conferma è già stata raccolta dal chiamante — qui, dal modale del deck.
+//
+// `--ignored-files` viaggia solo quando la scelta keep/purge è stata fatta
+// davvero (una singola task con superstiti): passarlo sempre significherebbe
+// deciderlo di default su un'operazione che perde file.
+export function cleanTasksPrompt(ids, ignored) {
+    const flag = ignored ? ` --ignored-files ${ignored}` : '';
+    return `/loom-works:clean-tasks yolo${flag} ${ids.join(' ')}`;
+}
+export function cleanTasksArgs(ids, sessionId, ignored) {
+    return [
+        '-p',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--session-id',
+        sessionId,
+        cleanTasksPrompt(ids, ignored),
+    ];
+}
+/** Bersaglio vuoto → nessuno spawn e `null`: un `clean-tasks` senza SPEC esce 1
+ *  e il deck riporterebbe un fallimento per un'operazione mai chiesta. */
+export function spawnCleanTasks(ids, cwd, sessionId, ignored, onResult) {
+    if (ids.length === 0)
+        return null;
+    return spawnSkill(cleanTasksPrompt(ids, ignored), cwd, sessionId, onResult);
+}
 // T41 — Commit dell'edit. `git commit -- <paths>` committa lo stato working-tree
 // SOLO di quei path, ignorando l'index: se l'utente ha altro in stage (o altri
 // file sporchi) non finisce dentro per errore. NON detached: è un'operazione

package/dist/ui/modals.js

@@ -3,9 +3,9 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // schermate sostitutive costano righe al budget d'altezza, quindi ognuno ha un
 // costo dichiarato in `viewport.ts`.
 import { Box, Text } from 'ink';
-import { caretWindow, sanitize } from '../width.js';
+import { caretWindow, cut, cutParts, sanitize } from '../width.js';
 import { cpLen } from '../layout.js';
-import { CARET, CARET_OFF } from '../glyphs.js';
+import { CARET, CARET_OFF, WARN } from '../glyphs.js';
 import { EDIT_PRI, EDIT_PROG } from '../model.js';
 import { PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
 import { progressText, PRI_GLYPH, PRI_LABEL, PROG_GLYPH } from '../task-edit.js';
@@ -29,6 +29,57 @@ export function FilterModal({ view, cursor }) {
                         return (_jsxs(Text, { inverse: here, color: on ? 'green' : 'gray', dimColor: !on, children: ['  ', "[", on ? 'x' : ' ', "] ", sanitize(e.glyph)] }, e.name));
                     })] }, row.label)))] }));
 }
+/**
+ * T112 — conferma di ELIMINAZIONE, in flusso come gli altri modali.
+ *
+ * Quattro righe, e nessuna è decorativa:
+ *
+ * ① il bersaglio per TAGLIA — «7 task» o «T31». Lo stesso tasto pota una task
+ *   sulla vista principale e N sulla vista `archiviabili`, e ciò che discrimina
+ *   è quale vista è attiva, cioè un'informazione che sta in header e non sotto
+ *   le dita di chi preme: la conferma è l'unico punto in cui quella differenza
+ *   torna visibile.
+ * ② gli ID, troncati con `+N`: una conferma che non dice COSA sparisce non è
+ *   informata.
+ * ③ l'EFFETTO sul disco, non il nome della vista. «Archiviare 7 task?»
+ *   prometterebbe uno spostamento in un archivio che non esiste — `clean-tasks`
+ *   rimuove task file, folder e riga, e il recupero da git history è il rimedio,
+ *   non l'operazione.
+ * ④ ciò che il bersaglio dichiarato NON copre: le scartate del bulk (promettere
+ *   7 e farne 5 è una bugia che non compare da nessuna parte, perché le 2
+ *   restano in lista come prima) oppure, sulla singola task sporca, la scelta
+ *   keep/purge che accompagna l'ordine.
+ */
+export function PurgeModal({ draft, columns }) {
+    // Due cornici annidate da scalare — root (bordo 2 + paddingX 2) e modale
+    // (bordo 2 + paddingX 2): il taglio è del chiamante, o la riga esce dal box e
+    // il frame va a capo (invariante ③ di width.ts).
+    const width = Math.max(8, columns - 8);
+    const target = draft.bulk ? `${draft.ids.length} task` : (draft.ids[0] ?? '—');
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "red", children: ["CANC \u203A eliminare ", target, "?"] }), _jsx(Text, { wrap: "truncate-end", children: cut(idList(draft.ids), width) }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut('via clean-tasks: task file + folder + riga in tasks.md · un commit per task · nessun push', width) }), draft.ignored ? (_jsx(IgnoredChoice, { survivors: draft.survivors, mode: draft.ignored, width: width })) : (_jsx(Text, { color: draft.skipped.length > 0 ? 'yellow' : undefined, dimColor: draft.skipped.length === 0, wrap: "truncate-end", children: cut(draft.skipped.length > 0
+                    ? `${WARN} ${draft.skipped.length} scartate (folder con file non tracciati): ${idList(draft.skipped)}`
+                    : 'nessuna esclusa · ⏎ conferma · esc annulla', width) }))] }));
+}
+/** Gli ID del bersaglio, troncati con `+N` quando non ci stanno tutti. Il
+ *  troncamento lo fa questa funzione e non `cut`, perché tagliare a metà un id
+ *  (`T1…`) direbbe una cosa falsa invece di dire che manca. */
+export function idList(ids, max = 12) {
+    if (ids.length <= max)
+        return ids.join(' ');
+    return `${ids.slice(0, max).join(' ')} +${ids.length - max}`;
+}
+/** D3 — la sola task con superstiti apre una conferma a TRE uscite: `⏎` su
+ *  KEEP, `⏎` su PURGE, `esc`. La scelta viaggia come `--ignored-files` nel
+ *  comando passato alla skill, ed è rara e distruttiva in modo diverso dal
+ *  purge normale: nasconderla dentro un binario `⏎`/`esc` la mascherebbe. */
+function IgnoredChoice({ survivors, mode, width, }) {
+    const segs = ['[ keep ]', '[ purge ]'];
+    const parts = [`${WARN} ${survivors} file non tracciati · `, segs[0], '  ', segs[1], ' · ←→'];
+    // `priority` sulla voce SCELTA: è l'unica informazione che la riga esiste per
+    // dare, e su un terminale stretto deve restare a schermo per prima.
+    const shown = cutParts(parts, width, mode === 'keep' ? 1 : 3);
+    return (_jsx(Text, { wrap: "truncate-end", children: shown.map((s, i) => s ? (_jsx(Text, { color: "yellow", inverse: (i === 1 && mode === 'keep') || (i === 3 && mode === 'purge'), children: s }, i)) : null) }));
+}
 /**
  * Campo di testo del modale edit: finestra ancorata al caret + cursore inverso
  * nella posizione REALE.

package/dist/ui/panes.js

@@ -49,7 +49,7 @@ export function TasksHeader({ counts, active, above, below, focused, columns, })
     const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns), segments.findIndex((s) => s.active));
     return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
 }
-export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, }) {
+export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, dirty, }) {
     const allSelected = selected === ROW_ALL;
     const spotSelected = selected === ROW_SPOT;
     return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(TasksHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
@@ -79,7 +79,7 @@ export function TasksPane({ tasks, counts, activeView, paneCount, view, selected
                 // 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 tail = `${n > 0 ? ` (${n})` : ''}${dirty.has(task.id) ? ` ${WARN}` : ''}`;
                 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));
             }))] }));

package/dist/version.js

@@ -0,0 +1,22 @@
+// Versione del pacchetto, letta dal `package.json` vero invece che cablata in
+// un `const`: una costante duplicata dal manifest è un calco — al primo bump
+// dimenticato il deck mostrerebbe con sicurezza un numero falso, ed è
+// esattamente il caso in cui serve (capire quale build sto guardando).
+//
+// Il path relativo `../package.json` vale per entrambe le forme in cui questo
+// modulo gira: `src/version.ts` sotto `tsx` e `dist/version.js` dopo il build —
+// il manifest sta un livello sopra in tutti e due i casi.
+import { readFileSync } from 'node:fs';
+function readVersion() {
+    try {
+        const raw = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === 'string' ? parsed.version : '?';
+    }
+    catch {
+        // Installazione monca o manifest illeggibile: la versione è cosmetica,
+        // non vale far cadere il deck per averla persa.
+        return '?';
+    }
+}
+export const VERSION = readVersion();

package/dist/viewport.js

@@ -45,6 +45,13 @@ export const MODAL_HEIGHT = {
     sort: 5, // marginTop + 2 bordi + titolo + 1 riga catena
     filter: 6, // marginTop + 2 bordi + titolo + 2 righe (pri, stato)
     edit: 9, // marginTop + 2 bordi + titolo + 4 campi (pri, stato, prog, titolo) + riga anteprima
+    // T112 — conferma di eliminazione: marginTop + 2 bordi + 4 righe di contenuto
+    // (titolo, elenco ID, effetto sul disco, riga di stato del bersaglio).
+    // Le quattro righe sono FISSE, non condizionali: la quarta ospita tanto gli
+    // scarti del bulk quanto la scelta keep/purge della singola task sporca, e due
+    // condizionali mutuamente esclusivi obbligherebbero il budget a sapere QUALE
+    // dei due è a schermo (stessa ragione della riga nota in DETAIL_CHROME, T111).
+    purge: 7,
     // T52 — search e reader sono gli unici modali NON in flusso: sostituiscono i
     // due pane invece di spingerli giù (una lista di occorrenze non entra in un
     // box sopra il deck). Costo 0 nel budget dei pane perché quel budget non

package/package.json

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