@lamemind/loom-deck 0.54.1 → 0.56.0

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 };
+}

package/dist/ui/panes.js

@@ -5,7 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from 'ink';
 import { cut, pad, sanitize, termWidth } from '../width.js';
 import { paneTextWidth } from '../layout.js';
-import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
+import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
 import { TaskRow } from './task-row.js';
 import { META_ROWS, ROW_ALL, ROW_SPOT } from '../model.js';
 import { rowLabel, sessionTitle } from '../session-list.js';
@@ -94,24 +94,22 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                         ? 'nessuna conversazione nel progetto'
                         : isSpot
                             ? 'nessuna sessione libera'
-                            : 'nessuna sessione legata a questa task'), paneTextWidth(columns)) })) : (rows.map((row, i) => {
-                // T50 — separatore leggero fra pinnate e contestuali: riga dim, non un
-                // box pesante (coerente con lo styling delle Done dimmate).
-                if (row.kind === 'separator') {
-                    return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: SESSION_SEP }, `sep${i}`));
-                }
+                            : 'nessuna sessione legata a questa task'), paneTextWidth(columns)) })) : (rows.map((row) => {
                 const sel = row.sessionId === selectedId;
                 // T50 — pin stale: transcript sparito, nessuna Session da mostrare.
-                // Riga navigabile e spinnabile (`p`), marcata, mai un crash.
-                if (row.kind === 'pinned' && row.stale) {
+                // Riga navigabile e spinnabile (`p`), marcata, mai un crash. T133 D5 —
+                // compare nella sola vista `📌`, dove non ha accanto nessuna griglia da
+                // rispettare: resta testo libero.
+                if (row.kind === 'stale') {
                     // T60 — anche qui la nota si taglia sul budget DERIVATO, non su un
                     // 30 inchiodato: su un pane stretto quel valore fisso mandava la
                     // riga oltre il bordo, e a ripararla arrivava `cli-truncate` (che
                     // sfora di una colonna per emoji e mangia il bordo stesso).
                     const staleNote = sessionNotes.get(row.sessionId);
                     // La riga stale è libera (niente colonne: non ha né titolo né
-                    // data), ma il binding va detto lo stesso — è una pinnata, quindi
-                    // l'header del pane non ne dice l'appartenenza.
+                    // data), ma il binding va detto lo stesso — vive nella vista `📌`,
+                    // che raccoglie le pinnate di ogni task e quindi non ne dice
+                    // l'appartenenza dall'header.
                     const staleTask = bindings.get(row.sessionId) ?? null;
                     const staleW = Math.max(0, paneTextWidth(columns) -
                         (2 /* caret */ +
@@ -121,8 +119,8 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                             3 /* spazio + caporali */));
                     return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: true, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { color: "yellow", children: WARN }), " pin stale", ' ', _jsx(Text, { dimColor: true, children: row.sessionId.slice(0, SID_CHARS) }), staleTask ? _jsxs(Text, { color: "green", children: [" ", staleTask] }) : null, staleNote ? _jsxs(Text, { color: "yellow", children: [" \u00AB", cut(staleNote, staleW), "\u00BB"] }) : null] }, row.sessionId));
                 }
-                const s = row.session; // non-stale → session presente
-                const isPinnedRow = row.kind === 'pinned';
+                const s = row.session;
+                const isPinnedRow = row.pinned;
                 // T28 — un ramo eredita il titolo dell'origine: senza marcatore le due
                 // righe sarebbero identiche a occhio.
                 const forked = forkOf.has(s.sessionId);
@@ -139,13 +137,12 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                 // appartiene la conversazione (pin/task/spot), questa dice se è aperta
                 // adesso. Farle condividere una cella perderebbe una delle due.
                 const liveEntry = live.get(s.sessionId);
-                // Stesso motivo per cui la colonna esiste: una pinnata resta in lista
-                // qualunque sia il parent selezionato, quindi l'header non ne dice
-                // l'appartenenza e la cella va riempita anche fuori dalla vista
-                // "tutte". Sulle contestuali, dove l'header parla già, resta vuota —
-                // ma la cella è comunque larga `taskW`, o le colonne a destra
-                // slitterebbero riga per riga.
-                const taskCell = isAll || isPinnedRow ? (bound ?? TASK_EMPTY) : '';
+                // T133 D10 — la colonna vive nella sola vista "tutte". Il ramo sulle
+                // pinnate esisteva perché una pinnata stava in lista anche sotto un
+                // parent che non era il suo; ora ogni riga è figlia del parent
+                // selezionato, quindi l'header parla già per tutte e la cella
+                // ripeterebbe N volte ciò che è scritto una riga sopra.
+                const taskCell = isAll ? (bound ?? TASK_EMPTY) : '';
                 // T60 — colonne VERE: ogni cella fissa è larga esattamente quanto
                 // dichiara, riempita di spazi con `pad` (che misura in colonne, non in
                 // caratteri). Il marker va portato a 2 anche quando è `○`, largo 1:

package/dist/ui/screens.js

@@ -0,0 +1,201 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Le SCHERMATE SOSTITUTIVE del deck e i due frammenti che le accompagnano.
+//
+// Una schermata sostitutiva prende il frame intero invece di stare in un box
+// sopra i due pane: assegnazione, detail della task, project status, ricerca e
+// reader. Il criterio è la taglia del contenuto — una lista di occorrenze o un
+// task file non entrano in quattro righe — e la conseguenza è che il budget
+// d'altezza dei pane non viene nemmeno calcolato, perché il render esce prima.
+//
+// `screenFor` è il ROUTER: sceglie fra le cinque e restituisce `null` quando
+// nessuna è attiva, cioè quando si resta sulla lista. È una funzione e non un
+// componente proprio per questo — il chiamante deve poter distinguere «ecco la
+// schermata» da «non è il tuo turno», e un componente che rende `null` non gli
+// direbbe la differenza in tempo utile per il proprio `return`.
+//
+// Fino a T131 le cinque vivevano in `cli.tsx` come cinque `if` consecutivi, con
+// dentro le derivazioni di finestra di ognuna. Sono uscite insieme perché la
+// scelta fra le viste non è né vista né input: la vista disegna ciò che le
+// viene dato, l'input decide cosa cambiare, e chi sceglie quale albero tornare
+// è un terzo mestiere.
+//
+// Direzione della dipendenza: questo file importa i TIPI di ritorno degli hook
+// di `src/overlays/` (`import type` + `ReturnType`, nessun import a runtime).
+// È lecito nell'asse — la vista sta a valle dell'input, mai a monte — ed è il
+// primo file di `ui/` a farlo, quindi va detto invece che scoperto a grep.
+import { Box, Text } from 'ink';
+import { rowIndexOfKey, selectedRow } from '../search.js';
+import { isCompact, searchPreviewCapacity, windowRange } from '../viewport.js';
+import { conversationLabel } from '../layout.js';
+import { taskColumns } from '../view.js';
+import { AssignScreen } from './assign-screen.js';
+import { DetailScreen } from './detail-screen.js';
+import { StatusScreen } from './status-screen.js';
+import { ReaderScreen, SearchScreen } from './search-screen.js';
+/**
+ * Il ripiego per un terminale troppo basso: una riga sola al posto della
+ * cornice. Perdere il layout è meglio che sfondare `rows` — oltre quella
+ * soglia Ink smette di aggiornare per differenza e pulisce lo schermo a ogni
+ * redraw, versando un frame intero nello scrollback a ogni tick del poll.
+ *
+ * Sei call site lo usavano in copia (le cinque schermate più la lista), identici
+ * tranne il soggetto e il verbo di `esc`. `dot` esiste perché la sesta copia —
+ * quella della lista — attacca al nome del programma la propria VERSIONE, e un
+ * punto in mezzo la staccherebbe da ciò di cui è la versione.
+ */
+export function CompactNotice({ what, esc, rows, columns, dot = true, }) {
+    return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [dot ? ' · ' : ' ', what, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga", esc ? ` · esc ${esc}` : ''] })] }));
+}
+/**
+ * La riga sotto la testata: in `normal` la legenda dei tasti, in un modale in
+ * flusso le sue istruzioni. I modali sostitutivi non arrivano qui — hanno già
+ * preso il frame.
+ *
+ * La legenda di `normal` la calcola il chiamante (`deckLegend` in `frame.ts`),
+ * perché dipende da cosa è selezionato; le sette righe dei modali sono testo
+ * fisso e vivono qui, accanto alla forma che le rende.
+ */
+export function HintBar({ mode, purge, keyLegend, }) {
+    if (mode === 'create') {
+        return (_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"] }));
+    }
+    if (mode === 'sort') {
+        return (_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"] }));
+    }
+    if (mode === 'filter') {
+        return (_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"] }));
+    }
+    if (mode === 'note') {
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["titolo 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"] }));
+    }
+    if (mode === 'purge') {
+        return (_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"] }));
+    }
+    if (mode === 'edit') {
+        return (_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"] }));
+    }
+    return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend }));
+}
+/**
+ * Sceglie la schermata sostitutiva attiva, o `null` per restare sulla lista.
+ *
+ * L'ordine dei rami è quello che avevano in `cli.tsx` e non è indifferente: i
+ * modi si escludono a vicenda, ma `detail` e `status` chiedono anche che il
+ * proprio contenuto esista (`sheet.sheet`, `status.view`) — un modo dichiarato
+ * senza contenuto deve cadere alla lista, non a una schermata vuota.
+ */
+export function screenFor(input) {
+    const { mode, rows, columns, note, overlays } = input;
+    const { assign, sheet, search, status } = overlays;
+    // ── T57 · schermata di assegnazione ─────────────────────────────────────
+    // Sostitutiva come ricerca e reader (D3): la lista task non entra in un box
+    // sopra i due pane, e prendendo l'intero frame non costa nulla al loro budget.
+    // Conseguenza obbligata della scelta: la sessione in assegnazione non è più
+    // visibile, quindi va RIPETUTA nel titolo — senza, non si sa più su cosa si
+    // sta agendo.
+    if (mode === 'assign') {
+        if (isCompact(assign.capacity)) {
+            return _jsx(CompactNotice, { what: "assegna", esc: "annulla", rows: rows, columns: columns });
+        }
+        const at = assign.list.findIndex((t) => (t?.id ?? null) === assign.sel);
+        const win = windowRange(assign.list.length, at, assign.capacity);
+        const s = assign.sid
+            ? input.sessions.find((x) => x.sessionId === assign.sid) ?? null
+            : null;
+        // Etichetta della conversazione: la nota umana se c'è (è il nome con cui la
+        // riconosci), altrimenti la stessa derivazione della ricerca. Su una pinnata
+        // stale non resta nulla: il titolo si accontenta dell'hash.
+        const label = (assign.sid ? input.sessionNotes.get(assign.sid) : '') ||
+            (s
+                ? conversationLabel(s, input.projectCore, assign.sid ? input.bindings.get(assign.sid) : undefined)
+                : '');
+        // T124 — le colonne si misurano sulla lista FILTRATA di questa schermata,
+        // non su `paneTasks`: la popolazione è un'altra, e riusare le larghezze del
+        // pane darebbe una colonna dimensionata su righe che qui non ci sono.
+        // `assign.list` porta in testa la riga `detach` (`null`), che non è una task.
+        const assignCols = taskColumns(assign.list.filter((t) => t !== null), input.taskRowData);
+        return (_jsx(AssignScreen, { sessionId: assign.sid ?? '', label: label, current: assign.sid ? input.bindings.get(assign.sid) ?? null : null, filter: assign.filter, rows: assign.list.slice(win.start, win.end), selected: assign.sel, matched: assign.list.length - 1, hidden: input.hiddenTasks, above: win.start, below: assign.list.length - win.end, idW: assignCols.id, tailW: assignCols.tail, data: input.taskRowData, columns: columns, note: note }));
+    }
+    // ── T66 · detail della task ─────────────────────────────────────────────
+    // Quarta schermata sostitutiva, stessa ragione delle altre tre: un task file
+    // non entra in un box sopra i due pane. Il budget dei pane non viene nemmeno
+    // calcolato — il render esce di qui prima.
+    if (mode === 'detail' && sheet.sheet) {
+        if (isCompact(sheet.capacity)) {
+            return (_jsx(CompactNotice, { what: sheet.sheet.id, esc: "chiude", rows: rows, columns: columns }));
+        }
+        // Niente `windowRange`: quella centra la finestra su una selezione, qui la
+        // posizione è lo scroll mosso a mano. Il clamp serve comunque — un resize
+        // può accorciare il testo sotto uno scroll già dato.
+        const start = Math.min(sheet.top, sheet.maxTop);
+        return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, model: sheet.model, spawnNote: sheet.spawnNote, prompt: sheet.prompt, cursor: sheet.cursor, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur }));
+    }
+    // ── T121 · viewer del project status ────────────────────────────────────
+    // Quinta schermata sostitutiva, stessa ragione delle altre quattro: un recap
+    // di progetto è lungo quanto un task file e non entra in un box sopra i pane.
+    if (mode === 'status' && status.view) {
+        if (isCompact(status.capacity)) {
+            return (_jsx(CompactNotice, { what: "project status", esc: "chiude", rows: rows, columns: columns }));
+        }
+        // Il clamp serve anche qui: un resize può accorciare il testo sotto uno
+        // scroll già dato.
+        const start = Math.min(status.top, status.maxTop);
+        return (_jsx(StatusScreen, { name: input.projectCore ?? input.projectName, label: status.label, building: status.building, failed: status.failed, view: status.view, lines: status.lines.slice(start, start + status.capacity), spans: status.doc?.spans ?? [], top: start, total: status.lines.length, capacity: status.capacity, columns: columns }));
+    }
+    // ── T52 · ricerca e reader ──────────────────────────────────────────────
+    // Gli unici modali che NON stanno in flusso sopra i pane: una lista di
+    // occorrenze non entra in un box da 4 righe. Prendono l'intero frame, quindi
+    // escono di qui — il budget dei due pane sotto non serve nemmeno calcolarlo,
+    // e la loro altezza la distribuiscono `searchListCapacity` / `readerCapacity`.
+    if (mode === 'search' || mode === 'reader') {
+        const hit = mode === 'reader' && search.readerRow?.kind === 'hit' ? search.readerRow.hit : null;
+        // Terminale sotto la cornice: riga singola invece del box, per lo stesso
+        // motivo del `budget.compact` del deck — un frame più alto di `rows` fa
+        // pulire lo schermo a Ink a ogni redraw, e il poll lo versa nello scrollback.
+        if (isCompact(hit ? search.readerCap : search.listCap)) {
+            return (_jsx(CompactNotice, { what: hit ? 'reader' : 'ricerca', esc: hit ? 'torna' : 'chiude', rows: rows, columns: columns }));
+        }
+        if (hit) {
+            // Niente `windowRange`: quella centra la finestra su una SELEZIONE, qui
+            // la posizione è lo scroll che l'utente muove a mano. Il clamp serve
+            // comunque — un resize può accorciare il testo sotto uno scroll già dato.
+            const start = Math.min(search.readerTop, search.readerMaxTop);
+            return (_jsx(ReaderScreen, { hit: hit, lines: search.readerLines.slice(start, start + search.readerCap), top: start, total: search.readerLines.length, capacity: search.readerCap, bound: input.bindings.get(hit.sessionId) ?? null }));
+        }
+        const selIdx = rowIndexOfKey(search.rows, search.selKey);
+        const win = windowRange(search.rows.length, selIdx, search.listCap);
+        // Anteprima dell'occorrenza selezionata: prende le righe che la lista non
+        // usa. Con molti risultati `spare` è 0 e il pannello non esiste — la lista
+        // se le riprende tutte, che è la priorità giusta quando c'è molto da
+        // scorrere. La finestra si CENTRA sul match (`windowRange`), così il
+        // contesto arriva da entrambi i lati.
+        const spare = searchPreviewCapacity(search.listCap, win.end - win.start);
+        let preview = null;
+        if (spare >= 1 && search.selRow?.kind === 'hit') {
+            const h = search.selRow.hit;
+            const mline = Math.max(0, search.previewBody.findIndex((l) => l.end > h.matchStart));
+            const pw = windowRange(search.previewBody.length, mline, spare);
+            preview = {
+                hit: h,
+                lines: search.previewBody.slice(pw.start, pw.end),
+                from: pw.start,
+                total: search.previewBody.length,
+                ts: input.sessions.find((s) => s.sessionId === h.sessionId)?.ts ?? 0,
+            };
+        }
+        return (_jsx(SearchScreen, { preview: preview, hash: search.hash, query: search.query, field: search.field, opts: search.opts, result: search.result, rows: search.rows.slice(win.start, win.end), selectedKey: search.selKey, selectedKind: selectedRow(search.rows, search.selKey)?.kind ?? null, above: win.start, below: search.rows.length - win.end, capacity: search.listCap, bindings: input.bindings, pinned: input.pinned, sessionNotes: input.sessionNotes, projectCore: input.projectCore, columns: columns, note: note }));
+    }
+    return null;
+}
+/**
+ * I due box di testo in flusso — create e nota — e i tre modali che li
+ * accompagnano stanno in `ui/modals.tsx`; qui resta il solo `CreateBox`, che
+ * non aveva una casa perché nato come JSX inline nel corpo del deck.
+ *
+ * Il cursore sta in coda al testo (append only): un cursore mobile vorrebbe
+ * gestire frecce e Home/End, e `Home`/`End` non sono nemmeno esposte da
+ * `useInput`.
+ */
+export function TextBox({ glyph, value }) {
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: [glyph, " \u203A "] }), _jsx(Text, { children: value }), _jsx(Text, { inverse: true, children: " " })] }));
+}

package/dist/wrap-scan.js

@@ -0,0 +1,122 @@
+// T134 — l'hard-wrap dei `.md` come dato del deck.
+//
+// Lo scanner è `scripts/docs/md-wrap.py` del plugin, e resta lì per intero: il
+// riconoscimento del wrap sta in tre euristiche tarate su un collaudo (la
+// colonna è una banda con tolleranza, si stima sul 90° percentile, lo
+// srotolamento itera a colonna ferma) e replicarle qui darebbe due misure
+// destinate a divergere in silenzio.
+//
+// A differenza della coda inbox, questa misura è CARA: cammina l'albero del
+// progetto intero, submodule compresi. Da qui la forma già in casa per il
+// project status — generare e aprire su due tasti distinti, con una cache su
+// disco in mezzo — invece di uno scan all'avvio che rallenterebbe proprio il
+// momento in cui si vuole vedere qualcosa subito.
+import { execFile } from 'node:child_process';
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { pluginScript } from './plugin-cache.js';
+const execFileAsync = promisify(execFile);
+export const WRAP_SCRIPT = 'scripts/docs/md-wrap.py';
+const FIELD_RE = /^(col|ratio|breaks|prose)=(.*)$/;
+/**
+ * Il TSV di `md-wrap.py --scan`: una riga per file NON `libero`, nella forma
+ * `verdetto ⇥ path ⇥ col=N ⇥ ratio=N ⇥ breaks=N ⇥ prose=N`.
+ *
+ * I campi si leggono per nome e non per posizione: sono già etichettati
+ * nell'output, e leggerli per indice trasformerebbe una colonna aggiunta in
+ * fondo in numeri sbagliati invece che in un campo ignorato.
+ */
+export function parseWrapTsv(stdout) {
+    const out = [];
+    for (const line of stdout.split('\n')) {
+        if (!line.trim())
+            continue;
+        const cells = line.split('\t');
+        const verdict = cells[0];
+        if (verdict !== 'WRAP' && verdict !== 'misto')
+            continue;
+        if (!cells[1])
+            continue;
+        const fields = {};
+        for (const cell of cells.slice(2)) {
+            const m = FIELD_RE.exec(cell.trim());
+            if (m)
+                fields[m[1]] = m[2];
+        }
+        const column = Number(fields.col);
+        out.push({
+            verdict,
+            path: cells[1],
+            column: Number.isFinite(column) ? column : null,
+            ratio: Number(fields.ratio) || 0,
+            breaks: Number(fields.breaks) || 0,
+            prose: Number(fields.prose) || 0,
+        });
+    }
+    // I peggiori in cima: chi apre la lista srotola da lì.
+    return out.sort((a, b) => {
+        if (a.verdict !== b.verdict)
+            return a.verdict === 'WRAP' ? -1 : 1;
+        return b.breaks - a.breaks;
+    });
+}
+/**
+ * D4 — il contatore conta i soli `WRAP`.
+ *
+ * `misto` ospita il falso allarme strutturale: file di note scritte una riga per
+ * pensiero, che nessuno vuole srotolare. Sommarlo darebbe un numero che non si
+ * può portare a zero, e un contatore che non arriva mai a zero smette di essere
+ * letto.
+ */
+export function wrapCount(files) {
+    return files.filter((f) => f.verdict === 'WRAP').length;
+}
+/**
+ * Cartella della cache, una per utente e con `mode 0700` — stessa ragione del
+ * project status: `/tmp` è condivisa, e un file a nome prevedibile può essere
+ * preceduto dal symlink di un altro utente.
+ */
+export function wrapCacheDir() {
+    return join(tmpdir(), `loom-deck-wrap-${process.getuid?.() ?? 0}`);
+}
+export function wrapCacheFile(projectRoot) {
+    const env = process.env.LOOM_DECK_WRAP_FILE;
+    if (env)
+        return env;
+    return join(wrapCacheDir(), `${projectRoot.replace(/[^a-zA-Z0-9]/g, '-')}.tsv`);
+}
+/** File assente o illeggibile → nessuna cache: `missing` è lo stato di partenza. */
+export function readWrapCache(path) {
+    try {
+        const raw = readFileSync(path, 'utf8');
+        return { files: parseWrapTsv(raw), mtime: statSync(path).mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Lo scan, in headless. `false` = guasto — plugin assente, `python3` assente,
+ * script in errore: i tre casi collassano, perché a schermo non cambiano la
+ * prima mossa di chi li vede.
+ *
+ * La cache si riscrive SOLO su successo: un tentativo fallito lascia in piedi
+ * l'esito dell'ultimo scan riuscito, che resta vero e ancora apribile.
+ */
+export async function runWrapScan(projectRoot) {
+    const script = pluginScript(WRAP_SCRIPT);
+    if (!script)
+        return false;
+    try {
+        const { stdout } = await execFileAsync('python3', [script, '--root', projectRoot, '--scan'], { cwd: projectRoot, maxBuffer: 16 * 1024 * 1024 });
+        const path = wrapCacheFile(projectRoot);
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        writeFileSync(path, stdout, { mode: 0o600 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

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