@lamemind/loom-deck 0.55.0 → 0.56.0

package/dist/overlays/modals.js

@@ -0,0 +1,231 @@
+// I modali IN FLUSSO: quelli che si disegnano in un box dentro la cornice
+// invece di sostituirla. Sono due famiglie e stanno nello stesso file perché
+// hanno lo stesso mestiere — tenere una bozza mentre si digita — e perché il
+// loro gemello di vista esiste già e si chiama `ui/modals.tsx`. La simmetria
+// `ui/modals.tsx` (vista) ↔ `overlays/modals.ts` (stato e input) è essa stessa
+// un'informazione: chi cerca l'uno trova l'altro.
+//
+// `useViewModals` governa sort e filtri, che compongono la VISTA. Lo stato
+// `view` non è loro e vive nel modello (`deck-model.ts`): è ciò che `applyView`
+// consuma, è persistito su disco e lo rilegge il tasto `w`. Qui resta ciò che è
+// davvero del modale — la fotografia per l'annullamento e la posizione nella
+// griglia dei filtri.
+//
+// `useTextModals` governa create, nota ed edit, cioè i tre campi di testo. Le
+// scritture che ne conseguono escono come callback (deroga T104: un hook di
+// overlay non esce dal deck).
+import { useState } from 'react';
+import { caretAtEnd, fieldsKey } from '../fields.js';
+import { sanitizeTyped } from '../glyphs.js';
+import { EDIT_FIELDS, EDIT_PRI, EDIT_PROG, editTextField, SORT_TASTI, } from '../model.js';
+import { cycleSort, describeSort, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from '../view.js';
+export function useViewModals({ view, setView, hiddenTasks, setMode, setNote, }) {
+    // T39 — fotografia della vista all'apertura di un modale: la lista si
+    // aggiorna dal vivo, quindi `esc` deve poter ripristinare.
+    const [backup, setBackup] = useState(null);
+    const [filterCursor, setFilterCursor] = useState({ row: 0, col: 0 });
+    /** Chiusura: `restore` rimette la fotografia (esc = annulla), altrimenti tiene ciò che si è composto (⏎). */
+    function close(restore) {
+        if (restore && backup) {
+            const snapshot = backup;
+            setView(() => snapshot);
+        }
+        setBackup(null);
+        setMode('normal');
+    }
+    function openSort() {
+        setBackup(view);
+        setNote('');
+        setMode('sort');
+    }
+    function openFilter() {
+        setBackup(view);
+        setNote('');
+        setMode('filter');
+    }
+    function onSortKey(input, key) {
+        if (key.escape) {
+            close(true);
+            setNote('S → sort annullato');
+        }
+        else if (key.return) {
+            close(false);
+            setNote(`S → sort: ${describeSort(view.sort)}`);
+        }
+        else if (input) {
+            // useInput consegna il CHUNK letto da stdin, non un tasto: digitando
+            // veloce (o incollando) `ppi` arriva come stringa unica. Si cicla su
+            // ogni carattere, così la chain esce identica a battitura lenta.
+            const keys = [...input].map((ch) => SORT_TASTI[ch]).filter(Boolean);
+            if (keys.length > 0) {
+                setView((v) => ({ ...v, sort: keys.reduce(cycleSort, v.sort) }));
+            }
+        }
+    }
+    function onFilterKey(input, key) {
+        const rowLen = (r) => (r === 0 ? PRI_ENTRIES.length : PROG_ENTRIES.length);
+        if (key.escape) {
+            close(true);
+            setNote('F → filtri annullati');
+        }
+        else if (key.return) {
+            close(false);
+            setNote(hiddenTasks > 0 ? `F → ${hiddenTasks} task nascoste` : 'F → nessun filtro attivo');
+        }
+        else if (key.upArrow || key.downArrow) {
+            setFilterCursor((c) => {
+                const row = c.row === 0 ? 1 : 0;
+                return { row, col: Math.min(c.col, rowLen(row) - 1) };
+            });
+        }
+        else if (key.leftArrow) {
+            setFilterCursor((c) => ({ ...c, col: Math.max(0, c.col - 1) }));
+        }
+        else if (key.rightArrow) {
+            setFilterCursor((c) => ({ ...c, col: Math.min(rowLen(c.row) - 1, c.col + 1) }));
+        }
+        else if (input === ' ') {
+            const { row, col } = filterCursor;
+            setView((v) => row === 0
+                ? { ...v, hiddenPri: toggleHidden(v.hiddenPri, PRI_ENTRIES[col].name) }
+                : { ...v, hiddenProg: toggleHidden(v.hiddenProg, PROG_ENTRIES[col].name) });
+        }
+    }
+    return { filterCursor, openSort, openFilter, onSortKey, onFilterKey };
+}
+export function useTextModals({ setMode, setNote, onCreate, onNote, onEdit, editDraftFor, currentNote, }) {
+    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('');
+    const [noteSid, setNoteSid] = useState(null);
+    // T41 — bozza dell'edit (null fuori dal modale) e posizione nell'area di
+    // compilazione: riga in fuoco + caret dentro la riga di testo attiva.
+    const [edit, setEdit] = useState(null);
+    const [editTask, setEditTask] = useState(null);
+    const [editCursor, setEditCursor] = useState({ row: 0, caret: 0 });
+    function openCreate() {
+        setNote('');
+        setMode('create');
+    }
+    function openNote(sid) {
+        setNoteSid(sid);
+        setNoteDraft(currentNote(sid));
+        setNote('');
+        setMode('note');
+    }
+    function openEdit(task) {
+        setEditTask(task);
+        setEdit(editDraftFor(task));
+        // Si apre sulla riga 0 (priorità), che non è un campo di testo: il caret
+        // prende la sua posizione entrando in una riga di testo con ↑↓.
+        setEditCursor({ row: 0, caret: 0 });
+        setNote('');
+        setMode('edit');
+    }
+    function onCreateKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setDraft('');
+            setNote('C → create annullato');
+        }
+        else if (key.return) {
+            const text = draft.trim();
+            setMode('normal');
+            setDraft('');
+            onCreate(text);
+        }
+        else if (key.backspace || key.delete) {
+            setDraft((d) => d.slice(0, -1));
+        }
+        else if (input && !key.ctrl && !key.meta) {
+            setDraft((d) => d + input);
+        }
+    }
+    function onNoteKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setNoteDraft('');
+            setNote('N → titolo annullato');
+        }
+        else if (key.return) {
+            const sid = noteSid;
+            const text = noteDraft.trim();
+            setMode('normal');
+            setNoteDraft('');
+            if (sid)
+                onNote(sid, text);
+        }
+        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));
+        }
+    }
+    // Il ponte fra le quattro righe del modale e la bozza. I valori restano
+    // tipizzati (`PriName`, `ProgName`) invece di finire in un record generico:
+    // `fields.ts` governa la grammatica dei tasti, non il modello dati.
+    const editIO = {
+        text: (row) => edit?.[editTextField(row)] ?? '',
+        setText: (row, next) => setEdit((e) => (e ? { ...e, [editTextField(row)]: next } : e)),
+        choice: (row) => row === 0
+            ? Math.max(0, EDIT_PRI.indexOf(edit?.pri ?? 'med'))
+            : Math.max(0, EDIT_PROG.indexOf(edit?.prog ?? 'todo')),
+        setChoice: (row, index) => setEdit((e) => e ? (row === 0 ? { ...e, pri: EDIT_PRI[index] } : { ...e, prog: EDIT_PROG[index] }) : e),
+    };
+    function onEditKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setEdit(null);
+            setNote('E → edit annullato');
+            return;
+        }
+        if (key.return) {
+            const task = editTask;
+            const current = edit;
+            setMode('normal');
+            setEdit(null);
+            if (task && current)
+                onEdit(task, current);
+            return;
+        }
+        // Tutto il resto è dell'area di compilazione, che è la STESSA del detail
+        // (T117): una grammatica sola, non due copie da tenere allineate a mano.
+        fieldsKey(input, key, EDIT_FIELDS, editCursor, setEditCursor, editIO);
+    }
+    return {
+        draft,
+        noteDraft,
+        edit,
+        editTask,
+        editCursor,
+        openCreate,
+        openNote,
+        openEdit,
+        onCreateKey,
+        onNoteKey,
+        onEditKey,
+    };
+}
+export { caretAtEnd };

package/dist/overlays/purge.js

@@ -0,0 +1,44 @@
+// T112 — l'overlay di conferma dell'eliminazione (`CANC`).
+//
+// T131 — è nato dentro `cli.tsx` e ci è rimasto per centosessantacinque righe,
+// pur avendo da subito la forma esatta degli altri overlay: un modo dichiarato
+// in `CAPTURING_MODES`, uno stato proprio, un handler proprio, un'apertura con
+// precondizioni. È la prova che `MODE_KEYS` non basta come custode — quel
+// `Record` obbliga un modo nuovo ad avere un handler, non a tenerlo fuori dal
+// componente. Il gate che lo pretende è `test/input-wiring.test.ts`.
+//
+// La deroga di T104 vale anche qui: l'hook non esce dal deck. Costruire la
+// bozza e ordinarne l'esecuzione sono due cose diverse — la prima arriva come
+// `draftFor`, la seconda parte come `onSubmit`, ed entrambe vivono in
+// `actions.ts`. Quello che resta qui è lo stato del modale e i suoi tasti.
+import { useState } from 'react';
+export function usePurgeOverlay({ setMode, setNote, draftFor, onSubmit, }) {
+    // La bozza della conferma (null fuori dal modale).
+    const [draft, setDraft] = useState(null);
+    function open() {
+        const next = draftFor();
+        if (!next)
+            return;
+        setDraft(next);
+        setNote('');
+        setMode('purge');
+    }
+    function onKey(_input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setDraft(null);
+            setNote('CANC → eliminazione annullata');
+        }
+        else if (key.return) {
+            const current = draft;
+            setMode('normal');
+            setDraft(null);
+            if (current)
+                onSubmit(current);
+        }
+        else if ((key.leftArrow || key.rightArrow) && draft?.ignored) {
+            setDraft((p) => (p ? { ...p, ignored: p.ignored === 'keep' ? 'purge' : 'keep' } : p));
+        }
+    }
+    return { draft, open, onKey };
+}

package/dist/plugin-cache.js

@@ -0,0 +1,106 @@
+// T134 — dove sta il plugin loom-works su questa macchina, e quale versione.
+//
+// Terza volta che il deck incontra l'assenza di `CLAUDE_PLUGIN_ROOT`: è una env
+// che esiste solo dentro un processo Claude Code, e il deck è un binario npm
+// spawnato da Ptyxis. Le prime due volte (età delle task archiviabili in
+// `archivable.ts`, gate `--ignored-files` in `purge.ts`) hanno RIPLICATO un
+// criterio di poche righe. Qui si risolve invece di duplicare, perché la
+// superficie da replicare sarebbe troppo grande — la grammatica del marker
+// inbox da un lato, le tre euristiche tarate dello scanner di wrap dall'altro —
+// e una divergenza fra le due copie non si vedrebbe finché non conta i file
+// sbagliati.
+//
+// L'allow `Read(~/.claude/plugins/cache/…/**)` che `init` scrive in
+// `.claude/settings.json` non c'entra: è un permesso per gli agent di Claude
+// Code. Il deck non passa dal motore dei permessi e non ha niente da farsi
+// autorizzare — gli manca soltanto di sapere quale versione eseguire.
+import { readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const MARKETPLACE_OWNER = 'lamemind';
+const PLUGIN_NAME = 'loom-works';
+/** Radice delle cache version-pinned del plugin. */
+export function pluginCacheRoot() {
+    const env = process.env.LOOM_DECK_PLUGIN_CACHE_ROOT;
+    if (env)
+        return env;
+    return join(homedir(), '.claude', 'plugins', 'cache', MARKETPLACE_OWNER, PLUGIN_NAME);
+}
+const SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;
+/**
+ * Confronto semver NUMERICO per componente: `-1` se `a` precede `b`, `1` se lo
+ * segue, `0` se pari.
+ *
+ * È il punto di tutto il modulo. In ordine lessicografico `10.1.3` precede
+ * `7.9.1` — `'1' < '7'` al primo carattere — quindi un `sort()` ingenuo su
+ * questa cartella sceglierebbe `9.0.0` fra le quaranta presenti, cioè una cache
+ * di due major fa, e lo farebbe senza dare alcun segno di sbagliare: gli script
+ * ci sono, girano, e rispondono col contratto di allora.
+ */
+export function compareSemver(a, b) {
+    const pa = SEMVER_RE.exec(a);
+    const pb = SEMVER_RE.exec(b);
+    if (!pa || !pb)
+        return 0;
+    for (let i = 1; i <= 3; i++) {
+        const diff = Number(pa[i]) - Number(pb[i]);
+        if (diff !== 0)
+            return diff < 0 ? -1 : 1;
+    }
+    return 0;
+}
+/** La più alta fra le versioni passate; `null` se nessuna è un semver X.Y.Z. */
+export function pickLatestVersion(names) {
+    let best = null;
+    for (const name of names) {
+        if (!SEMVER_RE.test(name))
+            continue;
+        if (best === null || compareSemver(name, best) > 0)
+            best = name;
+    }
+    return best;
+}
+/**
+ * Cache installata più recente, o `null` se il plugin non è installato su questa
+ * macchina (radice assente, o presente ma senza una sola cartella semver).
+ *
+ * `null` non è un errore da riportare: un deck su una macchina senza il plugin
+ * deve restare muto sugli indicatori che ne dipendono, non rompersi.
+ */
+export function resolvePluginCache() {
+    const root = pluginCacheRoot();
+    let names;
+    try {
+        names = readdirSync(root, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return null;
+    }
+    const version = pickLatestVersion(names);
+    if (version === null)
+        return null;
+    return { root: join(root, version), version };
+}
+/**
+ * La versione si risolve UNA VOLTA e resta quella per tutta la vita del
+ * processo. La cache cambia solo a un `plugin update`, quindi un deck aperto
+ * durante l'update continua a leggere la versione di prima fino al riavvio.
+ * È il limite accettato, e sta scritto qui invece di essere scoperto dopo.
+ */
+let resolved;
+export function pluginCache() {
+    if (resolved === undefined)
+        resolved = resolvePluginCache();
+    return resolved;
+}
+/** Path assoluto di uno script del plugin, `null` se il plugin non c'è. */
+export function pluginScript(relative) {
+    const cache = pluginCache();
+    return cache ? join(cache.root, relative) : null;
+}
+/** Solo per i test: dimentica la versione risolta al primo accesso. */
+export function resetPluginCache() {
+    resolved = undefined;
+}

package/dist/task-ops.js

@@ -0,0 +1,235 @@
+// Le operazioni su una TASK: crearla, editarla, potarla.
+//
+// T131 — nate insieme agli spawn dentro `cli.tsx` e separate da quelli qui,
+// sulla linea di frattura che l'analisi dello split aveva indicato: ciò che
+// apre una conversazione da una parte, ciò che ordina un lavoro sulla task list
+// dall'altra. Il discriminante operativo è l'OGGETTO — una sessione contro una
+// riga di `tasks.md` — e si vede dagli effetti: qui si scrive il task file, si
+// committa, si delega a una skill headless.
+//
+// Il deck non rimuove e non riscrive mai la task list da sé: `createTask` e
+// `purgeTasks` ordinano a `loom-works:create-task` e `loom-works:clean-tasks`,
+// che quelle sequenze le implementano già una volta. Averne due significherebbe
+// due creazioni e due rimozioni capaci di divergere.
+//
+// Le stringhe di `setNote` di questo file sono ASSERITE dal gate
+// `test/modes-smoke.test.ts` (`eliminare N task?`, `nessun push`, `scartate`,
+// `tasks.md`): si copiano verbatim, non si migliorano di passaggio.
+import { randomUUID } from 'node:crypto';
+import { loadTasks } from './tasks.js';
+import { appendTaskBinding } from './task-index.js';
+import { cut, sanitize } from './width.js';
+import { idList } from './ui/modals.js';
+import { purgeTargets, splitTargets } from './purge.js';
+import { initialDetail, writeTaskEdit, PRI_GLYPH, PRI_LABEL } from './task-edit.js';
+import { priName, progName } from './view.js';
+import { commitTaskEdit, spawnCleanTasks, spawnCreateTask, CLAUDE_CMD, } from './spawn.js';
+export function useTaskOps({ cwd, tasksPath, tasksDir, model, setNote, selectedTaskOr, }) {
+    // T30 — il taskId nasce DOPO create-task (lo assegna la skill scrivendo
+    // tasks.md) → non è noto allo spawn. Il sessionId invece è pinnato qui:
+    // snapshot degli id PRIMA, poi al completamento re-leggo tasks.md e il diff dà
+    // il nuovo id → appendTaskBinding lega la sessione (scoped).
+    function createTask(text) {
+        if (!text) {
+            setNote('C → create annullato (vuoto)');
+            return;
+        }
+        const sid = randomUUID();
+        const beforeIds = new Set(model.tasks.map((t) => t.id));
+        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)`);
+                return;
+            }
+            let newId;
+            try {
+                newId = loadTasks(tasksPath).find((t) => !beforeIds.has(t.id))?.id;
+            }
+            catch {
+                // tasks.md illeggibile → id non rilevato, sotto
+            }
+            if (newId) {
+                appendTaskBinding(cwd, sid, newId);
+                setNote(`✔ ${newId} creata · sessione scoped (sid ${sid.slice(0, 8)})`);
+            }
+            else {
+                setNote(`✔ task creata (id non rilevato) · sid ${sid.slice(0, 8)}`);
+            }
+        });
+        child.on('error', () => setNote(`⚠ create-task: '${CLAUDE_CMD}' non lanciabile`));
+    }
+    // T41 — scrive tasks.md + task file, poi committa. Il commit è immediato e non
+    // confermato (scelta esplicita: l'edit è una micro-modifica, la storia
+    // granulare vale più di un batch). Se nessuno dei due lati è stato scritto non
+    // si committa nulla — `paths` vuoto renderebbe `git commit --` un commit di
+    // TUTTO il working tree, che è l'opposto di ciò che vogliamo.
+    function writeEdit(task, draft) {
+        // Il titolo si scrive solo se è CAMBIATO davvero: rimandarlo identico
+        // riscriverebbe comunque la cella (collassando spazi ed escape) e sporcherebbe
+        // il diff di una riga per un edit di sola priorità. Vuoto → scartato: una
+        // task senza descrizione in overview non è più riconoscibile.
+        const title = draft.title.trim();
+        const titleChanged = title.length > 0 && title !== task.rawDesc.trim();
+        let res;
+        try {
+            res = writeTaskEdit({
+                tasksPath,
+                tasksDir,
+                id: task.id,
+                pri: draft.pri,
+                prog: draft.prog,
+                detail: draft.detail,
+                title: titleChanged ? title : undefined,
+            });
+        }
+        catch (e) {
+            setNote(`⚠ ${task.id}: scrittura fallita (${e.message})`);
+            return;
+        }
+        if (res.paths.length === 0) {
+            setNote(`⚠ ${task.id}: nessun campo aggiornabile (riga o task file assenti)`);
+            return;
+        }
+        const summary = `${PRI_GLYPH[draft.pri]} ${PRI_LABEL[draft.pri]} · ${res.progress}${titleChanged ? ` · "${cut(sanitize(title), 32)}"` : ''}`;
+        setNote(`⏳ ${task.id} → ${summary} · commit…`);
+        commitTaskEdit(cwd, res.paths, `chore(${task.id}): pri ${PRI_LABEL[draft.pri]} · stato ${res.progress}${titleChanged ? ' · titolo' : ''}`, (ok, err) => {
+            setNote(ok
+                ? `✔ ${task.id} → ${summary} · committato`
+                : `⚠ ${task.id} salvato, commit fallito: ${err}`);
+        });
+    }
+    /**
+     * La bozza di conferma per `CANC`, o `null` se non c'è niente da confermare
+     * (in tal caso la nota dice già perché).
+     *
+     * 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 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 purgeDraftFor() {
+        // 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 (model.focus !== 'tasks') {
+            setNote('CANC → eliminare: seleziona una task (← per il pane)');
+            return null;
+        }
+        const bulk = model.purgeBulk;
+        const ids = bulk ? model.paneTasks.map((t) => t.id) : [];
+        if (!bulk) {
+            const task = selectedTaskOr('CANC', 'eliminare');
+            if (!task)
+                return null;
+            ids.push(task.id);
+        }
+        if (ids.length === 0) {
+            setNote('CANC → nessuna task in vista da eliminare');
+            return null;
+        }
+        // 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 null;
+            }
+            return {
+                ids: clean.map((t) => t.id),
+                skipped: dirty.map((t) => t.id),
+                bulk: true,
+                ignored: null,
+                survivors: 0,
+            };
+        }
+        // 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];
+        return {
+            ids: [one.id],
+            skipped: [],
+            bulk: false,
+            ignored: one.survivors > 0 ? 'keep' : null,
+            survivors: one.survivors,
+        };
+    }
+    // ⏎ 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 purgeTasks(draft) {
+        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`));
+    }
+    /** T41 — la bozza dell'edit seminata dai valori ATTUALI della task. */
+    function editDraftFor(task) {
+        // La priorità arriva dal glifo di tasks.md (già in `selTask`), lo stato dal
+        // suo glifo Prog; il progresso arbitrario dal campo `Progress` del task file
+        // — ma solo se è davvero custom (vedi `initialDetail`).
+        //
+        // Il titolo si semina dalla riga di tasks.md e non dall'H1 del task file per
+        // due ragioni: è la fonte che esiste SEMPRE (un task file può mancare), ed è
+        // il testo che l'utente sta guardando in lista quando preme `E`. Grezzo
+        // (`rawDesc`), non sanificato: rimandare a disco la forma sanificata
+        // riscriverebbe i glifi anche senza toccare il campo.
+        const prog = progName(task.prog) ?? 'todo';
+        return {
+            pri: priName(task.pri) ?? 'med',
+            prog,
+            detail: initialDetail(model.detail?.fields['Progress'] ?? '', prog),
+            title: task.rawDesc,
+        };
+    }
+    return { createTask, editDraftFor, writeEdit, purgeDraftFor, purgeTasks };
+}