@lamemind/loom-deck 0.49.1 → 0.51.0

package/README.md

@@ -123,6 +123,19 @@ 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).
 
+### Il mouse
+
+Le voci della riga surface sono **cliccabili**: un click su `t 💻`, su `c 🤖` o su una voce `launch` fa la stessa cosa del tasto che le sta scritto sopra. Non c'è una semantica nuova da imparare, e non c'è doppio-click — il protocollo non lo prevede, andrebbe ricostruito con un timer. Le liste (task, conversazioni, viste dell'header) **non** rispondono ancora al mouse, né per selezionare né per attivare.
+
+Il click è l'unico gesto tracciato: modi `1000` + `1006`, niente movimento, niente drag, niente hover. I modi che li porterebbero (`1002`, `1003`) generano una valanga di eventi che sotto render pesante si frammentano su `stdin` e leakano dentro i campi di testo — è una classe di difetto osservata in più TUI. Con `1000`+`1006` gli eventi sono due per click, pressione e rilascio, e il deck agisce solo sulla pressione.
+
+Il tracking si spegne su ogni via d'uscita: uscita normale, `^C`, segnale, crash. Un tracking lasciato acceso non è un difetto cosmetico — il terminale continua a mandare sequenze a qualunque programma prenda il posto del deck, che se le ritrova stampate come testo.
+
+Due conseguenze visibili di come è fatto:
+
+- **Il deck pulisce lo schermo all'avvio.** Non è cosmesi: Ink non posiziona mai il cursore in modo assoluto, quindi il frame nasce dove capitava il cursore all'avvio del processo e una coordinata del mouse non sarebbe traducibile in una riga del frame. Pulire e tornare in alto a sinistra pinna il frame a riga 1, e da lì non si sposta più — il frame è alto al massimo `rows - 1`, quindi non fa mai scorrere lo schermo.
+- **Incollare un testo che contenga `[<0;5;3M` viene letto come un click.** Ink consegna le sequenze mouse a `useInput` come testo normale, con l'`ESC` iniziale già tolto: non resta niente che distingua la sequenza vera da quella scritta a mano.
+
 ### `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.

package/dist/cli.js

@@ -7,7 +7,8 @@ import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskFileText, } from
 import { rowIndexOfKey, selectedRow, } from './search.js';
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, } from './task-index.js';
 import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, selectedSession, unpinLandingId, } from './session-list.js';
-import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
+import { cellWidth, launchLegend, LAUNCH_SEP, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
+import { anchorFrame, enableMouse, FRAME_TEXT_COL, hitRegion, isWheel, LAUNCH_ROW, rowRegions, takeMouse, WHEEL_LINES, wheelDir, } from './mouse.js';
 import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, TASK_VIEWS, } from './pane-views.js';
 import { isCompact, layoutBudget, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { cut, cutMiddle, sanitize, termWidth } from './width.js';
@@ -32,7 +33,7 @@ import { useSearchOverlay } from './overlays/search.js';
 import { useSheetOverlay } from './overlays/sheet.js';
 import { useAssignOverlay } from './overlays/assign.js';
 import { useProjectStatus } from './overlays/status.js';
-import { captures } from './input-modes.js';
+import { captures, scrolls } from './input-modes.js';
 import { VERSION } from './version.js';
 // T116 — l'avviso della prima pressione di `^C`. La durata è INTERPOLATA dalla
 // finestra, non ricopiata: un numero scritto a mano in un testo che promette un
@@ -40,6 +41,43 @@ import { VERSION } from './version.js';
 // lo segnala. Vive a livello di modulo perché ha due lettori — il ramo che la
 // scrive e il timer che la ritira, e quest'ultimo deve poterla riconoscere.
 const QUIT_NOTE = `⚠ ^C di nuovo entro ${QUIT_WINDOW_MS / 1000}s per chiudere il deck`;
+// Le due surface built-in del cappello, in testa alla riga launch. Non stanno
+// fra i tasti perché hanno la stessa natura delle voci `launch` — fire-once,
+// cwd = project root, nessuno stato — e la differenza è solo che sono
+// universali (nessun progetto le dichiara) invece che custom. Emoji del menu
+// compass: 🤖 = nuova sessione claude. Per il terminale compass usa 🖥️, che nel
+// frame Ink NON passa — `sanitize` lo sostituisce (VTE lo disegna largo 1,
+// string-width dice 2: discordante, invariante ① di width.ts) e resterebbe un
+// `·` muto. 💻 è il gemello concorde; il `sanitize` qui rende il vincolo
+// automatico invece che da ricordare.
+//
+// T21 — `key` è il tasto che la superficie rappresenta: un click su di essa
+// entra nell'handler di tastiera con quel tasto, invece di chiamare l'azione
+// per conto proprio. È ciò che tiene click e tasto per costruzione allineati.
+const SURFACE_SEGMENTS = [
+    { key: 't', text: sanitize('t 💻') },
+    { key: 'c', text: sanitize('c 🤖') },
+];
+// T21 — il `Key` che accompagna un tasto sintetizzato da un click: nessun
+// modificatore, nessun tasto speciale. Deve elencare ogni campo, o i rami che
+// leggono `key.ctrl` o `key.tab` riceverebbero `undefined` invece di `false` —
+// equivalente nel test di verità, ma non nel tipo.
+const NO_MODIFIERS = {
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    pageDown: false,
+    pageUp: false,
+    return: false,
+    escape: false,
+    ctrl: false,
+    shift: false,
+    tab: false,
+    backspace: false,
+    delete: false,
+    meta: false,
+};
 function Deck({ cwd, tasksPath, tasksDir }) {
     const { tasks, loadError } = useTasks(tasksPath);
     // `notes` esce dall'indice come `sessionNotes`: in questo componente `note` è
@@ -956,7 +994,73 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         edit: onEditKey,
         purge: onPurgeKey,
     };
-    useInput((input, key) => {
+    // T21 (mandata 2) — la ROTELLA, per i soli modi che scorrono un contenuto
+    // lungo (`SCROLLING_MODES`). Stessa forma di `MODE_KEYS`: un `Record` sul
+    // catalogo, quindi un modo dichiarato scorrevole senza uno scroll da chiamare
+    // non compila. Il delta è in righe, col segno del verso.
+    const MODE_WHEEL = {
+        detail: sheet.scroll,
+        status: status.scroll,
+        reader: search.scrollReader,
+    };
+    /**
+     * T21 — il MOUSE precede tutto, in ogni modo del deck.
+     *
+     * Il filtro è incondizionato — anche dentro un campo di testo, anche in un
+     * modo che non ha nessuna superficie cliccabile — e non è una precauzione:
+     * `useInput` riceve le sequenze SGR come testo (`mouse.ts`, fatto ①), quindi
+     * senza filtro un click battuto mentre è aperto il campo del titolo ci
+     * scriverebbe dentro `[<0;5;3M`. Un listener raw su stdin non risolverebbe:
+     * riceve gli stessi chunk in broadcast e non li sottrae a `useInput`.
+     *
+     * Il chunk MISTO — un tasto e un click nella stessa scrittura, che arriva
+     * come una sola chiamata — si separa a mano: gli eventi vanno al mouse, il
+     * testo residuo prosegue verso la tastiera. Solo un chunk di solo mouse
+     * chiude qui.
+     */
+    useInput((raw, key) => {
+        const { text, events } = takeMouse(raw);
+        for (const ev of events)
+            onMouse(ev);
+        if (events.length > 0 && !text)
+            return;
+        onKey(text, key);
+    });
+    function onMouse(ev) {
+        // Un click produce due eventi (pressione e rilascio): agire su entrambi
+        // spawnerebbe due volte. La rotella arriva come sola pressione, quindi il
+        // filtro su `press` la lascia passare e non la dedoppia.
+        if (!ev.press)
+            return;
+        if (isWheel(ev.button)) {
+            // La rotella NON rientra dalla porta della tastiera come il click: nel
+            // detail `↑↓` muovono il fuoco fra i campi (T117), non il testo, e il
+            // tasto che scorre — `PgUp`/`PgDn` — ha la granularità sbagliata per una
+            // tacca. Va quindi allo scroll del modo, in righe. Fuori dai modi
+            // scorrevoli è inerte: nelle liste la rotella non muove mai la
+            // selezione (D5), e una tacca mentre il deck è sulla lista non deve
+            // fare niente.
+            if (scrolls(mode))
+                MODE_WHEEL[mode](wheelDir(ev.button) * WHEEL_LINES);
+            return;
+        }
+        // Il bottone si legge sui due bit bassi, perché gli alti portano i
+        // modificatori (shift/meta/ctrl).
+        if ((ev.button & 3) !== 0)
+            return;
+        // Le superfici esistono solo nella lista: un modo capturing prende il
+        // frame intero e a quella riga c'è dell'altro.
+        if (mode !== 'normal' || ev.row !== LAUNCH_ROW)
+            return;
+        const hit = hitRegion(launchRegions, ev.col);
+        // Il click NON chiama l'azione: rientra dalla porta della tastiera col
+        // tasto che la superficie annuncia. Un ramo nuovo su `t`/`c`/cifre nasce
+        // così già cliccabile, e non esiste un secondo posto in cui il click possa
+        // dire una cosa diversa dal tasto che gli sta scritto sopra.
+        if (hit)
+            onKey(hit, NO_MODIFIERS);
+    }
+    function onKey(input, key) {
         // T116 — `^C` sta SOPRA il dispatch dei modi, unico tasto a scavalcarlo.
         // Ogni altra combo `ctrl` è un acceleratore, e un acceleratore dentro un
         // modo capturing dev'essere inerte (`input-modes.ts`); questo non è un
@@ -1251,27 +1355,27 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // chiuderlo, perché quel ramo esce prima di qui. L'unica uscita da tastiera
         // è `^C` battuto due volte (T116, in testa a questo handler); resta poi la
         // chiusura della tab Ptyxis che ospita il processo.
-    });
+    }
     const canSpawn = focus === 'tasks' && selTask !== null;
     const canResume = focus === 'sessions' && selSessionObj !== null;
     // T50 — il pin agisce su qualunque riga selezionata (anche stale, per
     // spinnarla); basta il focus sul pane e una selezione.
     const canPin = focus === 'sessions' && selSessionId !== null;
-    // Le due surface built-in del cappello stanno in testa alla riga launch, non
-    // fra i tasti: hanno la stessa natura delle voci `launch` — fire-once, cwd =
-    // project root, nessuno stato — e la differenza è solo che sono universali
-    // (nessun progetto le dichiara) invece che custom. Emoji del menu compass:
-    // 🤖 = nuova sessione claude. Per il terminale compass usa 🖥️, che nel frame
-    // Ink NON passa — `sanitize` lo sostituisce (VTE lo disegna largo 1,
-    // string-width dice 2: discordante, invariante ① di width.ts) e resterebbe un
-    // `·` muto. 💻 è il gemello concorde; il `sanitize` qui rende il vincolo
-    // automatico invece che da ricordare.
-    const surfaceLegend = sanitize('t 💻 · c 🤖');
+    const surfaceLegend = SURFACE_SEGMENTS.map((s) => s.text).join(LAUNCH_SEP);
     // Larghezza dal medesimo hook che dà l'altezza: dopo un resize la legenda si
     // ricalcola con lo stesso re-render che ridimensiona i pane. Le celle delle
     // surface (più il ` · ` che le separa dalle voci) sono già spese sulla riga →
     // vanno riservate, o le voci launch la sfonderebbero di quel tanto.
-    const legend = launchLegend(launch, columns, cellWidth(surfaceLegend) + 3);
+    const legend = launchLegend(launch, columns, cellWidth(surfaceLegend) + cellWidth(LAUNCH_SEP));
+    // T21 — la riga launch come DATO, non come stringa: gli stessi segmenti
+    // compongono il testo renderizzato e le colonne dell'hit-test. Derivare le
+    // seconde ri-splittando il primo sarebbe un conto parallelo, che diverge alla
+    // prima label che contenga il separatore.
+    const launchSegments = [
+        ...SURFACE_SEGMENTS,
+        ...legend.taken.map((text, i) => ({ key: String(i + 1), text })),
+    ];
+    const launchRegions = rowRegions(launchSegments, LAUNCH_SEP, FRAME_TEXT_COL);
     // Legenda della modalità normale. Elenca SOLO i tasti che fanno qualcosa qui e
     // ora: le voci contestuali compaiono quando il pane a fuoco le rende possibili
     // e altrimenti spariscono, invece di annunciarsi inerti con un `—`.
@@ -1446,7 +1550,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     if (budget.compact) {
         return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "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: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(StatusHeadline, { name: projectCore ?? projectName, label: status.label, building: status.building, failed: status.failed, cols: Math.max(4, columns - 4 - `v${VERSION}`.length - 1) }), _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: ["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"] })) : 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: editCursor.row, caret: editCursor.caret, 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, idW: taskCols.id, tailW: taskCols.tail, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, data: taskRowData }), _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(StatusHeadline, { name: projectCore ?? projectName, label: status.label, building: status.building, failed: status.failed, cols: Math.max(4, columns - 4 - `v${VERSION}`.length - 1) }), _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: ["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"] })) : 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: [launchSegments.map((s) => s.text).join(LAUNCH_SEP), 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: editCursor.row, caret: editCursor.caret, 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, idW: taskCols.id, tailW: taskCols.tail, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, data: taskRowData }), _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();
 // T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,
@@ -1454,6 +1558,13 @@ const cwd = process.cwd();
 // osservabile. In raw mode `^C` non è un SIGINT — è il byte `\x03` nello
 // stream di input, e chi lo consuma per primo decide. Da qui in poi lo consuma
 // il deck, quindi l'uscita è tutta a carico del suo handler.
+// T21 — l'ordine dei tre passi è vincolante. `anchorFrame` va PRIMA del render:
+// pinna il frame a riga 1 e con lui l'origine dell'hit-test, che senza sarebbe
+// la posizione casuale del cursore all'avvio del processo. `enableMouse`
+// registra il ripristino del tracking sulle vie d'uscita, quindi prima che
+// esista qualcosa da cui uscire.
+anchorFrame();
+enableMouse();
 render(_jsx(Deck, { cwd: cwd, tasksPath: resolveTasksPath(cwd), tasksDir: resolveTasksDir(cwd) }), {
     exitOnCtrlC: false,
 });

package/dist/config.js

@@ -48,6 +48,10 @@ export function loadLaunch(projectRoot) {
 // dallo schema config (che ne ammette quante se ne vogliono) ma dai tasti
 // disponibili. Le voci oltre la nona restano configurate e non raggiungibili.
 export const LAUNCH_MAX = 9;
+/** Separatore fra le voci della riga launch. Costante e non letterale sparso:
+ *  lo usano il calcolo di quante voci entrano in riga, la resa, e l'hit-test
+ *  del mouse — tre conti che devono misurare lo stesso spazio. */
+export const LAUNCH_SEP = ' · ';
 // Larghezza in celle terminale, approssimata: emoji astrali (U+1F000+) e simboli
 // BMP portati a presentazione emoji occupano 2 colonne, il VS16 è un modificatore
 // a larghezza 0, tutto il resto 1. Serve solo a decidere quante voci stanno in
@@ -85,7 +89,7 @@ export function launchLegend(entries, columns, reserved = 0) {
         const taken = [];
         let used = 0;
         for (const p of parts) {
-            const cost = cellWidth(p) + (taken.length > 0 ? 3 : 0); // ' · '
+            const cost = cellWidth(p) + (taken.length > 0 ? cellWidth(LAUNCH_SEP) : 0);
             if (used + cost > budget - reserve)
                 break;
             taken.push(p);
@@ -98,7 +102,12 @@ export function launchLegend(entries, columns, reserved = 0) {
     let taken = fit(0);
     if (taken.length < parts.length)
         taken = fit(10);
-    return { shown: taken.join(' · '), overflow: parts.length - taken.length, unreachable };
+    return {
+        shown: taken.join(LAUNCH_SEP),
+        taken,
+        overflow: parts.length - taken.length,
+        unreachable,
+    };
 }
 // T61 — soglia d'età del contatore archiviabili, campo `archivableDays`.
 //

package/dist/input-modes.js

@@ -55,3 +55,23 @@ export function captures(mode) {
 export const CTRL_DEROGATIONS = {
     detail: ['f'],
 };
+/**
+ * T21 (mandata 2) — i modi che SCORRONO un contenuto lungo, cioè gli unici in
+ * cui la rotella del mouse fa qualcosa.
+ *
+ * La rotella scorre il TESTO, mai la selezione di una lista (D5): nelle liste
+ * la selezione è un'intenzione — la riga su cui si preme `⏎` — e una rotella
+ * che la muovesse trasformerebbe ogni sfioramento in una scelta. Nei tre modi
+ * qui sotto lo scroll non sceglie niente, è solo posizione di lettura. Non
+ * coincide con «ha un documento a schermo»: `search` mostra un'anteprima, ma
+ * il fuoco lì è sulla lista dei risultati, che è una selezione.
+ *
+ * Il custode è `MODE_WHEEL` in `cli.tsx`, un `Record<ScrollingMode, …>` che non
+ * compila se un modo entra qui senza uno scroll da chiamare.
+ */
+export const SCROLLING_MODES = ['detail', 'status', 'reader'];
+const SCROLLING = new Set(SCROLLING_MODES);
+/** `true` se la rotella scorre il contenuto del modo. */
+export function scrolls(mode) {
+    return SCROLLING.has(mode);
+}

package/dist/mouse.js

@@ -0,0 +1,201 @@
+// T21 — MOUSE del deck: abilitazione del tracking SGR, parse delle sequenze,
+// hit-test sulle superfici cliccabili.
+//
+// Tre fatti misurati sotto pty reggono tutto il modulo, e ognuno spiega una
+// scelta che altrimenti sembrerebbe arbitraria.
+//
+// ① `useInput` di Ink riceve le sequenze mouse come TESTO, con l'ESC iniziale
+//    strippato e nessun flag di `key` attivo: un click arriva come `[<0;5;3M`.
+//    Un listener `data` raw agganciato a stdin accanto a Ink riceve gli stessi
+//    identici chunk (i listener `data` sono broadcast) e NON impedisce che le
+//    sequenze raggiungano comunque `useInput`. Il filtro dev'essere quindi
+//    dentro `useInput` in ogni caso — da cui: un punto solo, non due.
+// ② L'ESC è strippato solo se la sequenza APRE il chunk. In un chunk misto
+//    tasto+mouse (`a\x1b[<0;7;2M`, una sola chiamata) l'ESC interno resta.
+//    Il pattern lo rende quindi opzionale e lo consuma quando c'è, o
+//    resterebbe un ESC orfano nel testo restituito al deck.
+// ③ Modi di tracking `1000` (click) + `1006` (SGR) e basta. `1002` (drag) e
+//    `1003` (ogni movimento) sono la sorgente documentata delle valanghe di
+//    eventi che sotto render pesante si frammentano su stdin e leakano dentro
+//    i campi di testo. Con soli 1000+1006 gli eventi sono due per click.
+import { termWidth } from './width.js';
+/**
+ * Sequenza SGR: `ESC [ < b ; x ; y M|m`, con l'ESC opzionale (fatto ①).
+ *
+ * Il prezzo dell'ESC opzionale è che un INCOLLAGGIO della stringa letterale
+ * `[<0;5;3M` dentro un campo di testo verrebbe letto come un click. È accettato
+ * e non compensato: distinguerlo richiederebbe di fidarsi dell'ESC, che nel
+ * caso più comune — la sequenza che apre il chunk — non c'è.
+ */
+const SGR_MOUSE = /\x1b?\[<(\d+);(\d+);(\d+)([Mm])/g;
+/** `true` se il codice è una pressione di rotella (bit 6 del bottone). */
+export function isWheel(button) {
+    return (button & 64) !== 0;
+}
+/**
+ * Verso della rotella: `-1` su (codice 64), `+1` giù (65), `0` se non è una
+ * rotella. Il verso sta nel bit 0, i modificatori nei bit 2-4 (shift/meta/
+ * ctrl): `66`/`67` sono le rotelle orizzontali, che qui valgono `0` perché il
+ * deck non ha nulla da scorrere in orizzontale.
+ *
+ * Un terminale manda la rotella come SOLA pressione (`M`), mai seguita da un
+ * rilascio: un tacca = un evento, e il chiamante non deve dedoppiare come fa
+ * per il click.
+ */
+export function wheelDir(button) {
+    if (!isWheel(button) || (button & 2) !== 0)
+        return 0;
+    return (button & 1) === 0 ? -1 : 1;
+}
+/**
+ * Righe scorse per tacca di rotella nei contenuti lunghi (detail, project
+ * status, reader). Tre è la convenzione dei terminali e dei browser: una tacca
+ * a riga singola costringe a girare la rotella quanto basta a stancare la mano,
+ * una a pagina salta il testo che si stava leggendo.
+ */
+export const WHEEL_LINES = 3;
+/**
+ * Separa le sequenze mouse dal testo di un chunk di `useInput`.
+ *
+ * Ritorna il testo RIPULITO (quello che il deck deve continuare a trattare come
+ * input di tastiera) e gli eventi trovati, nell'ordine di arrivo.
+ *
+ * Una sequenza spezzata su due chunk — succede sotto render pesante — arriva
+ * come due frammenti monchi: nessuno dei due matcha, quindi entrambi finiscono
+ * nel testo ripulito. Il click va perso. È voluto: bufferizzare significherebbe
+ * tenere uno stato fra due chiamate di `useInput` e decidere quando scade, e un
+ * click perso costa una ripetizione mentre un buffer che non scade mai
+ * inghiotte i tasti che seguono.
+ */
+export function takeMouse(input) {
+    if (!input.includes('[<'))
+        return { text: input, events: [] };
+    const events = [];
+    const text = input.replace(SGR_MOUSE, (_all, b, x, y, kind) => {
+        events.push({
+            button: Number(b),
+            col: Number(x),
+            row: Number(y),
+            press: kind === 'M',
+        });
+        return '';
+    });
+    return { text, events };
+}
+// ── Tracking: accensione, spegnimento, ripristino ───────────────────────────
+const ENABLE = '\x1b[?1000h\x1b[?1006h';
+const DISABLE = '\x1b[?1006l\x1b[?1000l';
+/**
+ * Ancoraggio del frame: pulisce lo schermo e riporta il cursore in alto a
+ * sinistra PRIMA del primo render di Ink.
+ *
+ * Senza, l'hit-test non ha origine. Ink non posiziona mai il cursore in modo
+ * assoluto (verificato sul flusso di byte: solo `\x1b[2K` e `\x1b[1A`, cioè
+ * `log-update` puro): il frame nasce dove si trovava il cursore quando il
+ * processo è partito — riga 1 in una tab appena aperta, più in basso dopo un
+ * prompt di shell, più in alto ancora se la prima scrittura ha fatto scorrere
+ * lo schermo. Una coordinata assoluta del mouse non sarebbe traducibile.
+ *
+ * Pinnato a riga 1 il frame ci RESTA, senza bisogno di ri-ancorarlo a ogni
+ * resize: `log-update` cancella all'insù tante righe quante ne aveva scritte e
+ * poi riscrive da lì, e il frame è alto al massimo `rows - 1` (lo garantisce lo
+ * SLACK di `viewport.ts`) — quindi la scrittura non fa mai scorrere lo schermo
+ * e la cancellazione riporta sempre il cursore a riga 1. È un punto fisso.
+ */
+export function anchorFrame(out = process.stdout) {
+    out.write('\x1b[2J\x1b[H');
+}
+/**
+ * Accende il tracking e registra lo spegnimento su ogni via d'uscita.
+ *
+ * Un tracking lasciato acceso non è un difetto cosmetico: il terminale continua
+ * a mandare sequenze a qualunque programma prenda il posto del deck, che se le
+ * ritrova stampate come testo a ogni movimento.
+ *
+ * Due agganci coprono tutte le uscite, e la ragione per cui non ne basta uno è
+ * che le due classi non si attraversano. L'evento `exit` copre l'uscita normale
+ * (`exit()` di Ink, che è anche il secondo `^C` del deck) e il CRASH, perché
+ * un'eccezione non catturata termina il processo passando comunque di lì. I
+ * segnali no: `SIGINT`/`SIGTERM` terminano il processo senza emettere `exit`,
+ * quindi vogliono un handler proprio — che poi deve ri-emettere il segnale, o
+ * il processo resterebbe vivo (agganciare un handler ne disattiva la
+ * terminazione di default). `^C` battuto dentro il deck non è nessuno dei due:
+ * in raw mode è il byte `\x03` nello stream di input, che il deck consuma da sé
+ * e che sfocia nell'uscita normale.
+ *
+ * Ritorna la funzione di spegnimento per chi voglia chiamarla da sé.
+ */
+export function enableMouse(out = process.stdout) {
+    let off = false;
+    const disable = () => {
+        if (off)
+            return;
+        off = true;
+        try {
+            out.write(DISABLE);
+        }
+        catch {
+            // stdout già chiuso: non c'è più niente da ripristinare.
+        }
+    };
+    out.write(ENABLE);
+    process.on('exit', disable);
+    for (const sig of ['SIGINT', 'SIGTERM']) {
+        process.on(sig, () => {
+            disable();
+            process.kill(process.pid, sig);
+        });
+    }
+    return disable;
+}
+/**
+ * Colonne occupate da ogni segmento di una riga, dato il separatore che li
+ * unisce e la colonna in cui la riga comincia.
+ *
+ * Deriva dall'ARITMETICA di layout, non da un registro popolato al render:
+ * `measureElement` di Ink espone width e height ma mai la posizione assoluta di
+ * un elemento, quindi la mappa coordinate→superficie va costruita comunque. Il
+ * vincolo che la tiene onesta è che i `Segment` che entrano qui sono gli stessi
+ * che compongono la stringa renderizzata — una sola fonte, non due conti
+ * paralleli che possono divergere.
+ *
+ * La larghezza è quella del TERMINALE (`termWidth`), non quella di `cellWidth`
+ * in `config.ts`: la seconda è una stima prudente che serve a decidere quante
+ * voci stanno in riga e ha licenza di sovrastimare, mentre qui una colonna di
+ * troppo sposta il bersaglio.
+ */
+export function rowRegions(segments, sep, startCol) {
+    const sepW = termWidth(sep);
+    const out = [];
+    let col = startCol;
+    for (const seg of segments) {
+        const w = termWidth(seg.text);
+        if (w > 0)
+            out.push({ key: seg.key, start: col, end: col + w - 1 });
+        col += w + sepW;
+    }
+    return out;
+}
+/** Il tasto della superficie sotto la colonna, o `null` fuori da tutte. */
+export function hitRegion(regions, col) {
+    for (const r of regions) {
+        if (col >= r.start && col <= r.end)
+            return r.key;
+    }
+    return null;
+}
+/**
+ * Riga del terminale (1-based) su cui vive la riga launch in modalità normale.
+ *
+ * Il frame è ancorato a riga 1 (`anchorFrame`) e le righe sopra la launch sono
+ * fisse e sempre presenti: bordo superiore, testata (status + versione),
+ * legenda tasti. Nessuna delle tre è condizionale in modalità normale — la
+ * legenda tasti è una catena di ternari che rende SEMPRE esattamente un `Text`,
+ * e la testata è una riga `space-between`. Tutto ciò che varia in altezza (i
+ * due pane, il blocco preview, la riga di nota) sta SOTTO, quindi il conto non
+ * dipende da quanto è popolato il progetto.
+ */
+export const LAUNCH_ROW = 4;
+/** Colonna (1-based) del primo carattere di testo dentro il box esterno:
+ *  bordo + `paddingX={1}`. */
+export const FRAME_TEXT_COL = 3;

package/dist/overlays/search.js

@@ -255,5 +255,6 @@ export function useSearchOverlay(deps) {
         open,
         onReaderKey,
         onSearchKey,
+        scrollReader,
     };
 }

package/dist/overlays/sheet.js

@@ -286,5 +286,6 @@ export function useSheetOverlay(deps) {
         occCur,
         open,
         onKey,
+        scroll,
     };
 }

package/dist/overlays/status.js

@@ -155,5 +155,6 @@ export function useProjectStatus(deps) {
         generate,
         open,
         onKey,
+        scroll,
     };
 }

package/package.json

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