@lamemind/loom-deck 0.5.0 → 0.6.0

package/README.md

@@ -39,6 +39,68 @@ Bootstrap + spike ① + **TUI ③** funzionante (legge `tasks.md`, `⏎` spawna)
 ⑤ azioni extra (start/preflight/checkpoint/merge dal deck)
 ```
 
+## Standard shortcut
+
+Regola unica, senza eccezioni — pensata per reggere l'aggiunta di nuove azioni
+senza collisioni:
+
+| Tasto | Semantica | Note |
+|---|---|---|
+| `↑` `↓` | naviga nella lista | |
+| `←` `→` `tab` | cambia pane | |
+| `⏎` | azione primaria del pane | Tasks → spawna la task selezionata |
+| **MAIUSCOLA** | **apre un modale** | cattura tutti i tasti; `esc` annulla, non esce |
+| minuscola | azione immediata, one-shot | |
+| `1`…`9` | voce `launch` n-esima del progetto | da `.claude/loom-works.json` |
+| `q` `esc` | esce dal deck | in un modale `esc` annulla soltanto |
+
+Assegnazioni correnti:
+
+| | Tasto | Cosa fa |
+|---|---|---|
+| modale | `C` | nuova task (create-task inline) |
+| modale | `S` | sort chain |
+| modale | `F` | filtri |
+| immediata | `w` | salva la vista corrente su disco |
+| launch | `1`…`9` | esegue il `command` della voce, con `cwd` = project root |
+
+Le minuscole sono deliberatamente quasi tutte libere: le consumeranno le azioni
+in arrivo (start/preflight/checkpoint, fork/resume, terminale @project-root).
+
+> **Nota di migrazione (0.6.0)**: `c` → **`C`** per creare una task, e le voci
+> `codium`/`idea` non hanno più una lettera dedicata (erano `C`/`I` hardcoded):
+> ora sono voci `launch` del file config, raggiunte per indice `1`…`9`.
+
+## Vista: filtri e ordinamenti
+
+La lista è una **vista** sulla `tasks.md`: si filtra e si ordina senza toccare il file.
+
+**`S` — sort chain.** Grammatica libera: la *sequenza* di tasti **è** la catena di
+ordinamento. Ogni tasto cicla `asc → desc → fuori dalla catena`; una chiave
+rimossa e ripremuta si riaccoda in fondo.
+
+```
+p  priorità     s  stato     i  id
+```
+
+Partendo da catena vuota, digitare `ppi` produce `[pri ↓, id ↑]`. Il ciclo parte
+sempre **dallo stato corrente**, che il modale mostra dal vivo mentre digiti.
+A parità su tutte le chiavi decide sempre l'`id` (confronto **numerico**: `T9`
+prima di `T10`) → l'ordine è deterministico, mai instabile fra un refresh e l'altro.
+
+**`F` — filtri.** Un toggle per ogni priorità e per ogni stato, componibili in AND.
+`↑↓` cambia riga, `←→` scorre i valori, `spazio` mostra/nasconde.
+
+In entrambi i modali la lista si aggiorna **dal vivo**; `⏎` conferma, `esc`
+ripristina la vista com'era all'apertura.
+
+Con un filtro attivo l'header dichiara sempre quanto sta nascondendo
+(`Tasks (9/25) · 16 nascoste`): il deck non finge mai una lista completa.
+
+**Persistenza.** La vista non si salva da sola — sperimentare non sporca nulla.
+`w` la scrive in `.claude/loom/deck-view.json` (macchina-locale, da gitignorare)
+e al riavvio viene ripristinata. File assente o corrotto → default puliti.
+
 ## Installazione
 
 ```bash
@@ -72,8 +134,13 @@ Apre una tab Ptyxis nella window attiva con `LOOM_TASK=T18 claude '/loom-works:r
 npm install
 npm run dev      # tsx src/cli.tsx — lista tasks.md reale, ↑↓ naviga · ⏎ spawn · q esci
 npm run build    # tsc → dist/
+npm test         # node:test sul core vista (src/view.ts), senza Ink né terminale
 ```
 
+Il core di filtri e ordinamenti (`src/view.ts`) è **puro**: nessun import da Ink o
+React, nessun I/O. È il motivo per cui è testabile con `node:test` su array
+fixture, mentre la TUI resta un guscio sottile che lo consuma.
+
 Il deck cerca `tasks.md` in `$PWD/${LOOM_DECK_DOCS_ROOT:-docs}/tasks.md`. Progetti
 con docs-root non-standard esportano la variabile, es. `LOOM_DECK_DOCS_ROOT=runtime`.
 

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { render, Box, Text, useApp, useInput } from 'ink';
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useMemo } from 'react';
 import { spawn } from 'node:child_process';
 import { statSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
@@ -10,6 +10,9 @@ import { dirname, join } from 'node:path';
 import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, } from './tasks.js';
 import { discoverProjectSessions } from './sessions.js';
 import { appendTaskBinding, loadTaskBindings } from './task-index.js';
+import { loadLaunch } from './config.js';
+import { applyView, cycleSort, describeSort, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
+import { loadView, saveView, viewFilePath } from './view-store.js';
 // scripts/deck-run è un sibling della dir del bundle: src/ (dev, tsx) e dist/
 // (build, node) stanno entrambi sotto la package root → risalita di un livello.
 const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'deck-run');
@@ -21,6 +24,9 @@ const MAX_SESSIONS = 30;
 // meta "spot" (sentinella) che raccoglie le sessioni NON legate ad alcuna task.
 // La selezione nel Tasks pane è il "padre"; il Sessions pane mostra i suoi figli.
 const SPOT = Symbol('spot');
+// Modale sort a grammatica libera: un tasto per chiave, pressioni successive
+// ciclano asc → desc → fuori dalla chain.
+const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id' };
 function isDone(prog) {
     return prog.includes('✔');
 }
@@ -36,18 +42,16 @@ function spawnDeck(id, cwd, sessionId) {
     child.unref();
     return child;
 }
-// Editor esterni: aprono l'IDE sulla project root. Il comando risolve attraverso
-// la shell login+interattiva dell'utente (bash -lic) → alias/funzioni in ~/.bashrc
-// (es. `codium`=alias flatpak, `idea`=funzione) risolvono come nel terminale.
-// Override via env per ambienti senza quegli alias (loom-deck è destinato a NPM).
-const EDITOR_CMD = {
-    codium: process.env.LOOM_DECK_EDITOR_CODIUM ?? 'codium',
-    idea: process.env.LOOM_DECK_EDITOR_IDEA ?? 'idea',
-};
-// Spawn detached come spawnDeck: il deck lancia ma non possiede l'IDE. La project
-// root arriva via $PWD (spawn cwd) → niente interpolazione di path, zero injection.
-function openEditor(cmd, cwd) {
-    const child = spawn('bash', ['-lic', `${cmd} "$PWD"`], {
+// T39/T32: voce `launch` custom del file config, eseguita con cwd = project root.
+// Spawn detached come spawnDeck: il deck lancia ma non possiede il processo.
+// Shell login+interattiva (bash -lic) perché i comandi tipici sono alias o
+// funzioni di ~/.bashrc (`codium`=alias flatpak, `idea`=funzione) — con `bash -c`
+// non risolverebbero. Il comando NON è input utente: viene dal file committato
+// `.claude/loom-works.json`, fidato quanto un custom-command Ptyxis (contratto
+// esplicito in project-config-architecture.md). La project root arriva via cwd,
+// non interpolata nella stringa.
+function runLaunch(entry, cwd) {
+    const child = spawn('bash', ['-lic', entry.command], {
         cwd,
         detached: true,
         stdio: 'ignore',
@@ -204,6 +208,18 @@ function forceEmojiWidth(s) {
         return s + VS16;
     return s;
 }
+// Normalizza il marker Done per il display. `✔` (U+2714) è text-presentation-
+// default: string-width — quindi Ink, sia per il layout sia per il troncamento —
+// lo misura 2 (rispetta il VS16 di `✔️`), ma VTE/Ptyxis lo disegna largo 1
+// (ignora il VS16). Risultato: le righe Done finivano 1 colonna più strette del
+// riservato → la coda della riga (bordo destro del pane incluso) slittava a
+// sinistra, sfasando il layout solo su quelle righe. `✅` (U+2705) è invece
+// emoji-presentation-default → largo 2 sia per string-width sia per il terminale,
+// come 🔵/🟡: colonna Prog allineata. Cambia SOLO il display: `task.prog` resta
+// `✔️` così `isDone()` continua a matchare.
+function displayProg(prog) {
+    return forceEmojiWidth(prog.replace(/✔️?/g, '✅'));
+}
 // Età relativa compatta (ms epoch → "2m"/"3h"/"5d") per il preview sessioni.
 function relTime(ts) {
     const sec = Math.max(0, Math.floor((Date.now() - ts) / 1000));
@@ -223,18 +239,34 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const { tasks, loadError } = useTasks(tasksPath);
     const { sessions, bindings } = useSessions(cwd);
     const [focus, setFocus] = useState('tasks');
-    // selParent ∈ [0, tasks.length]: l'indice 0 è la riga meta "spot" (prima voce),
-    // gli indici 1..tasks.length sono le task reali (task = selParent-1).
-    const [selParent, setSelParent] = useState(0);
+    // T39 — selezione KEYED SU ID, non su indice. Con una vista trasformata
+    // (filtro/sort) l'indice non identifica più la stessa task: leggere l'array
+    // grezzo per posizione spawnerebbe la task sbagliata, in silenzio. `null` = la
+    // riga meta "spot", sempre in testa alla lista.
+    const [selId, setSelId] = useState(null);
     const [selSession, setSelSession] = useState(0);
     const [note, setNote] = useState('');
-    // T30: modale di creazione task inline. mode='create' → useInput cattura il
-    // testo (gating della navigazione normale) e mostra l'input box.
+    // Modali: catturano i tasti e corto-circuitano la navigazione normale.
+    // T30 create · T39 sort/filter.
     const [mode, setMode] = useState('normal');
     const [draft, setDraft] = useState('');
-    const isSpot = selParent === 0;
+    // T39 — vista corrente (filtri + sort) e sua fotografia all'apertura di un
+    // modale: la lista si aggiorna dal vivo, quindi `esc` deve poter ripristinare.
+    const [view, setView] = useState(() => loadView(cwd));
+    const [viewBackup, setViewBackup] = useState(null);
+    const [filterCursor, setFilterCursor] = useState({ row: 0, col: 0 });
+    // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
+    const launch = useMemo(() => loadLaunch(cwd), [cwd]);
+    // La vista è una trasformazione DERIVATA, applicata a valle del load: il
+    // polling di tasks.md continua a funzionare senza saperne nulla.
+    const { visible: viewTasks, hidden: hiddenTasks } = useMemo(() => applyView(tasks, view), [tasks, view]);
+    const isSpot = selId === null;
     const projectName = cwd.split('/').pop() || cwd;
-    const selectedTaskId = isSpot ? null : tasks[selParent - 1]?.id ?? null;
+    // Unica fonte della selezione: si legge SEMPRE dalla vista, mai dall'array
+    // grezzo — è l'invariante che tiene allineati dettaglio mostrato e spawn.
+    const selTask = selId === null ? null : viewTasks.find((t) => t.id === selId) ?? null;
+    const selectedTaskId = selTask?.id ?? null;
+    const selIndex = selTask ? viewTasks.indexOf(selTask) + 1 : 0;
     const detail = useTaskDetail(tasksDir, selectedTaskId ?? undefined);
     // Conteggio figli per task + spot (badge nel Tasks pane).
     const childCount = new Map();
@@ -254,15 +286,18 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     });
     const visibleSessions = childSessions.slice(0, MAX_SESSIONS);
     const hiddenSessions = childSessions.length - visibleSessions.length;
-    // Dopo un refresh le liste possono accorciarsi: tieni le selezioni in range
-    // (max index = tasks.length; spot è sempre l'indice 0).
+    // T39 — selezione stabile sotto trasformazione. Se la task selezionata esce
+    // dalla vista (filtro appena attivato, oppure sparita da tasks.md), si cade
+    // sulla prima visibile — fallback deterministico, mai una posizione a caso.
     useEffect(() => {
-        setSelParent((s) => Math.min(s, tasks.length));
-    }, [tasks.length]);
+        if (selId !== null && !viewTasks.some((t) => t.id === selId)) {
+            setSelId(viewTasks[0]?.id ?? null);
+        }
+    }, [viewTasks, selId]);
     // Cambio padre → riparti dalla prima sessione figlia.
     useEffect(() => {
         setSelSession(0);
-    }, [selParent]);
+    }, [selId]);
     useEffect(() => {
         setSelSession((s) => Math.min(s, Math.max(0, visibleSessions.length - 1)));
     }, [visibleSessions.length]);
@@ -275,7 +310,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         setMode('normal');
         setDraft('');
         if (!text) {
-            setNote('c → create annullato (vuoto)');
+            setNote('C → create annullato (vuoto)');
             return;
         }
         const sid = randomUUID();
@@ -303,6 +338,21 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         });
         child.on('error', () => setNote(`⚠ create-task: '${CLAUDE_CMD}' non lanciabile`));
     }
+    // Chiusura di un modale di vista: `restore` rimette la fotografia scattata
+    // all'apertura (esc = annulla), altrimenti tiene ciò che si è composto (⏎).
+    function closeViewModal(restore) {
+        if (restore && viewBackup)
+            setView(viewBackup);
+        setViewBackup(null);
+        setMode('normal');
+    }
+    // Sposta la selezione di `delta` righe nella VISTA (0 = spot, 1..N = task
+    // visibili) e la riconverte subito in id: l'indice non sopravvive a un
+    // cambio di filtro, l'id sì.
+    function moveTaskSel(delta) {
+        const next = Math.max(0, Math.min(viewTasks.length, selIndex + delta));
+        setSelId(next === 0 ? null : viewTasks[next - 1]?.id ?? null);
+    }
     useInput((input, key) => {
         // T30: in modalità create l'handler cattura il testo e corto-circuita la
         // navigazione normale (incl. q/esc → quit: qui esc annulla, non esce).
@@ -310,7 +360,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             if (key.escape) {
                 setMode('normal');
                 setDraft('');
-                setNote('c → create annullato');
+                setNote('C → create annullato');
             }
             else if (key.return) {
                 submitCreate();
@@ -323,18 +373,73 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             return;
         }
+        // T39 — modale sort a grammatica libera: la SEQUENZA di tasti È la chain.
+        // Digitare `ppi` = p(asc) p(desc) i(asc) → [pri desc, id asc]. La lista si
+        // riordina dal vivo a ogni pressione.
+        if (mode === 'sort') {
+            if (key.escape) {
+                closeViewModal(true);
+                setNote('S → sort annullato');
+            }
+            else if (key.return) {
+                closeViewModal(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) }));
+                }
+            }
+            return;
+        }
+        // T39 — modale filtri: griglia 2 righe (priorità / stato), un toggle per
+        // valore. Anche qui l'effetto è immediato sulla lista.
+        if (mode === 'filter') {
+            const rowLen = (r) => (r === 0 ? PRI_ENTRIES.length : PROG_ENTRIES.length);
+            if (key.escape) {
+                closeViewModal(true);
+                setNote('F → filtri annullati');
+            }
+            else if (key.return) {
+                closeViewModal(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;
+        }
         if (key.leftArrow || key.rightArrow || key.tab) {
             setFocus((f) => (f === 'tasks' ? 'sessions' : 'tasks'));
         }
         else if (key.upArrow) {
             if (focus === 'tasks')
-                setSelParent((i) => Math.max(0, i - 1));
+                moveTaskSel(-1);
             else
                 setSelSession((i) => Math.max(0, i - 1));
         }
         else if (key.downArrow) {
             if (focus === 'tasks')
-                setSelParent((i) => Math.min(tasks.length, i + 1));
+                moveTaskSel(1);
             else
                 setSelSession((i) => Math.min(visibleSessions.length - 1, i + 1));
         }
@@ -343,39 +448,58 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 if (isSpot) {
                     setNote('spot: sessioni libere, nessuna task da spawnare');
                 }
-                else {
-                    const task = tasks[selParent - 1];
-                    if (task) {
-                        // sessionId pinnato lato deck → binding sidecar scritto PRIMA dello
-                        // spawn: la sessione risulta figlia della task appena il JSONL compare.
-                        const sid = randomUUID();
-                        appendTaskBinding(cwd, sid, task.id);
-                        const child = spawnDeck(task.id, cwd, sid);
-                        // Un errore di spawn è async: senza handler diventa uncaughtException
-                        // e ucciderebbe il deck. Lo intercetto per preservare l'invariante
-                        // "il deck resta vivo" e mostro la nota d'errore.
-                        child.on('error', () => setNote(`⚠ spawn ${task.id} fallito (${DECK_RUN})`));
-                        setNote(`⏎ spawn ${task.id} → tab CC (sid ${sid.slice(0, 8)})`);
-                    }
+                else if (selTask) {
+                    // sessionId pinnato lato deck → binding sidecar scritto PRIMA dello
+                    // spawn: la sessione risulta figlia della task appena il JSONL compare.
+                    const sid = randomUUID();
+                    appendTaskBinding(cwd, sid, selTask.id);
+                    const child = spawnDeck(selTask.id, cwd, sid);
+                    // Un errore di spawn è async: senza handler diventa uncaughtException
+                    // e ucciderebbe il deck. Lo intercetto per preservare l'invariante
+                    // "il deck resta vivo" e mostro la nota d'errore.
+                    child.on('error', () => setNote(`⚠ spawn ${selTask.id} fallito (${DECK_RUN})`));
+                    setNote(`⏎ spawn ${selTask.id} → tab CC (sid ${sid.slice(0, 8)})`);
                 }
             }
             else {
                 setNote('sessioni read-only in T27 · fork/resume → T28');
             }
         }
-        else if (input === 'c') {
+        else if (input === 'C') {
             setNote('');
             setMode('create');
         }
-        else if (input === 'C') {
-            const child = openEditor(EDITOR_CMD.codium, cwd);
-            child.on('error', () => setNote(`⚠ codium: '${EDITOR_CMD.codium}' non lanciabile`));
-            setNote(`C → codium su ${projectName}`);
+        else if (input === 'S') {
+            setViewBackup(view);
+            setNote('');
+            setMode('sort');
         }
-        else if (input === 'I') {
-            const child = openEditor(EDITOR_CMD.idea, cwd);
-            child.on('error', () => setNote(`⚠ idea: '${EDITOR_CMD.idea}' non lanciabile`));
-            setNote(`I → idea su ${projectName}`);
+        else if (input === 'F') {
+            setViewBackup(view);
+            setNote('');
+            setMode('filter');
+        }
+        else if (input === 'w') {
+            // Salvataggio ESPLICITO: comporre una vista non tocca il disco, così
+            // sperimentare non sporca lo stato persistito.
+            try {
+                saveView(cwd, view);
+                setNote(`w → vista salvata (${viewFilePath(cwd)})`);
+            }
+            catch {
+                setNote('⚠ salvataggio vista fallito');
+            }
+        }
+        else if (input && /^[1-9]$/.test(input)) {
+            const entry = launch[Number(input) - 1];
+            if (!entry) {
+                setNote(`${input} → nessuna voce launch (${launch.length} configurate)`);
+            }
+            else {
+                const child = runLaunch(entry, cwd);
+                child.on('error', () => setNote(`⚠ ${entry.label}: '${entry.command}' non lanciabile`));
+                setNote(`${input} → ${entry.label} su ${projectName}`);
+            }
         }
         else if (input === 'q' || key.escape) {
             exit();
@@ -384,14 +508,40 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const selSessionId = visibleSessions[selSession]?.sessionId;
     const parentLabel = isSpot ? 'spot' : selectedTaskId ?? '—';
     const canSpawn = focus === 'tasks' && !isSpot;
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : '—', " \u00B7 c nuova \u00B7 C codium \u00B7 I idea \u00B7 q esci \u00B7 focus: ", _jsx(Text, { color: "cyan", children: focus })] })), 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, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: tasks, selected: selParent, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, sessions: visibleSessions, total: childSessions.length, hidden: hiddenSessions, selectedId: selSessionId, focused: focus === 'sessions' })] }), note ? _jsx(Text, { color: "green", children: note }) : null] }));
+    const launchHint = launch.length > 0 ? `1-${Math.min(9, launch.length)} launch · ` : '';
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, 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, 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, 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"] })) : (_jsxs(Text, { dimColor: true, children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : '—', " \u00B7 C nuova \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7", ' ', launchHint, "q esci \u00B7 focus: ", _jsx(Text, { color: "cyan", children: focus })] })), 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 === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: viewTasks, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, sessions: visibleSessions, total: childSessions.length, hidden: hiddenSessions, selectedId: selSessionId, focused: focus === 'sessions' })] }), note ? _jsx(Text, { color: "green", children: note }) : null] }));
+}
+const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
+// Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
+// spingono giù i pane invece di coprirli, così la lista che stai filtrando
+// resta sempre visibile mentre la componi.
+function SortModal({ sort }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "S \u203A sort chain" }), sort.length === 0 ? (_jsx(Text, { dimColor: true, children: "nessuna chiave \u00B7 resta l'ordine per id \u2191" })) : (_jsx(Text, { children: sort
+                    .map((e, i) => `${i + 1}. ${SORT_UI[e.key]} ${e.dir === 'asc' ? '↑' : '↓'}`)
+                    .join('    ') }))] }));
+}
+function FilterModal({ view, cursor }) {
+    const rows = [
+        { label: 'pri  ', entries: PRI_ENTRIES, hidden: new Set(view.hiddenPri) },
+        { label: 'stato', entries: PROG_ENTRIES, hidden: new Set(view.hiddenProg) },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "F \u203A filtri" }), rows.map((row, r) => (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: row.label }), row.entries.map((e, c) => {
+                        const on = !row.hidden.has(e.name);
+                        const here = cursor.row === r && cursor.col === c;
+                        return (_jsxs(Text, { inverse: here, color: on ? 'green' : 'gray', dimColor: !on, children: ['  ', "[", on ? 'x' : ' ', "] ", forceEmojiWidth(e.glyph)] }, e.name));
+                    })] }, row.label)))] }));
 }
-function TasksPane({ tasks, selected, spotCount, childCount, focused, loadError, detail, }) {
+function TasksPane({ tasks, total, hidden, view, selected, spotCount, childCount, focused, loadError, detail, }) {
     const spotSelected = selected === 0;
-    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, children: ["Tasks (", tasks.length, ")"] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? '▶ ' : '  ', "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : (tasks.map((task, i) => {
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, children: ["Tasks (", hidden > 0 ? `${tasks.length}/${total}` : tasks.length, ")", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", hidden, " nascoste"] }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort: ", describeSort(view.sort), view.hiddenPri.length + view.hiddenProg.length > 0 ? (_jsxs(Text, { children: [' ', "\u00B7 filtri:", ' ', [
+                                ...PRI_ENTRIES.filter((e) => view.hiddenPri.includes(e.name)),
+                                ...PROG_ENTRIES.filter((e) => view.hiddenProg.includes(e.name)),
+                            ]
+                                .map((e) => `−${e.glyph}`)
+                                .join(' ')] })) : null] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? '▶ ' : '  ', "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : (tasks.map((task, i) => {
                 const sel = i + 1 === selected; // +1: lo 0 è spot
                 const n = childCount.get(task.id) ?? 0;
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? '▶ ' : '  ', task.id, "  ", forceEmojiWidth(task.pri), "  ", forceEmojiWidth(task.prog), "  ", task.desc, n > 0 ? ` (${n})` : ''] }, task.id));
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? '▶ ' : '  ', task.id, "  ", forceEmojiWidth(task.pri), "  ", displayProg(task.prog), "  ", task.desc, n > 0 ? ` (${n})` : ''] }, task.id));
             })), detail ? _jsx(DetailPane, { detail: detail }) : null] }));
 }
 function SessionsPane({ parentLabel, isSpot, sessions, total, hidden, selectedId, focused, }) {

package/dist/config.js

@@ -0,0 +1,41 @@
+// T39 — Lettura delle voci `launch` da `.claude/loom-works.json`.
+// Allineamento T32: le launch sono voci CUSTOM per-progetto {emoji,label,command},
+// di numero e nome arbitrari. Il deck non può quindi avere una lettera fissa per
+// app (com'era `C`→codium / `I`→idea, hardcoded): le voci si raggiungono per
+// indice 1..9. Il `command` gira con cwd = project root.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function configFilePath(projectRoot) {
+    return join(projectRoot, '.claude', 'loom-works.json');
+}
+export function parseLaunch(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const list = raw.launch;
+    if (!Array.isArray(list))
+        return [];
+    const out = [];
+    for (const item of list) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const { emoji, label, command } = item;
+        if (typeof command !== 'string' || !command.trim())
+            continue;
+        out.push({
+            emoji: typeof emoji === 'string' ? emoji : '▸',
+            // `label` è opzionale per contratto → fallback sul comando stesso.
+            label: typeof label === 'string' && label ? label : command,
+            command,
+        });
+    }
+    return out;
+}
+/** File assente o malformato → nessuna voce launch. Mai un throw. */
+export function loadLaunch(projectRoot) {
+    try {
+        return parseLaunch(JSON.parse(readFileSync(configFilePath(projectRoot), 'utf8')));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/view-store.js

@@ -0,0 +1,66 @@
+// T39 — Persistenza della vista (filtri + sort).
+// D3 (preflight): sidecar `.claude/loom/deck-view.json`, GITIGNORED. La vista è
+// preferenza personale macchina-locale, non config di progetto portabile: sta
+// fuori da `.claude/loom-works.json` (committato), come session-tasks.jsonl.
+// Formato JSON singolo documento read-modify-write — non JSONL append-only:
+// lì l'append serviva la concorrenza fra spawn, qui il writer è uno solo.
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { DEFAULT_VIEW, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
+export function viewFilePath(projectRoot) {
+    return join(projectRoot, '.claude', 'loom', 'deck-view.json');
+}
+const SORT_KEYS = ['pri', 'prog', 'id'];
+const PRI_NAMES = PRI_ENTRIES.map((e) => e.name);
+const PROG_NAMES = PROG_ENTRIES.map((e) => e.name);
+// Il file è editabile a mano e sopravvive ai cambi di schema: si tiene solo ciò
+// che è riconoscibile e si scarta il resto, invece di fidarsi del JSON o di
+// rifiutare l'intero documento per una chiave sporca.
+function sanitizeSort(raw) {
+    if (!Array.isArray(raw))
+        return [...DEFAULT_VIEW.sort];
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const { key, dir } = item;
+        if (!SORT_KEYS.includes(key))
+            continue;
+        if (dir !== 'asc' && dir !== 'desc')
+            continue;
+        if (out.some((e) => e.key === key))
+            continue; // una chiave compare una volta sola
+        out.push({ key: key, dir });
+    }
+    return out;
+}
+function sanitizeNames(raw, allowed) {
+    if (!Array.isArray(raw))
+        return [];
+    return allowed.filter((name) => raw.includes(name));
+}
+export function parseView(raw) {
+    if (!raw || typeof raw !== 'object')
+        return { ...DEFAULT_VIEW };
+    const o = raw;
+    return {
+        sort: sanitizeSort(o.sort),
+        hiddenPri: sanitizeNames(o.hiddenPri, PRI_NAMES),
+        hiddenProg: sanitizeNames(o.hiddenProg, PROG_NAMES),
+    };
+}
+/** File assente, illeggibile o corrotto → default puliti. Mai un throw. */
+export function loadView(projectRoot) {
+    try {
+        return parseView(JSON.parse(readFileSync(viewFilePath(projectRoot), 'utf8')));
+    }
+    catch {
+        return { ...DEFAULT_VIEW };
+    }
+}
+/** Scrittura esplicita (tasto `w`), mai automatica: sperimentare non persiste. */
+export function saveView(projectRoot, view) {
+    const path = viewFilePath(projectRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(view, null, 2) + '\n', 'utf8');
+}

package/dist/view.js

@@ -0,0 +1,133 @@
+// T39 — Core della vista: ordinali, sort chain multi-chiave, filtri.
+// Modulo PURO: nessun import da ink/react, nessun I/O → testabile senza terminale.
+// D2 (preflight T39): sort opinato, filtri off. La lista parte ordinata ma
+// completa — nessuna task sparisce senza che l'utente abbia toccato una leva.
+export const DEFAULT_VIEW = {
+    sort: [
+        { key: 'pri', dir: 'desc' },
+        { key: 'id', dir: 'asc' },
+    ],
+    hiddenPri: [],
+    hiddenProg: [],
+};
+// Le celle Pri/Prog di tasks.md sono glifi grezzi (tasks.ts:47-50), non ranghi.
+// Il rango è un'IMPORTANZA: valore alto = più urgente/attivo, così `desc` legge
+// naturalmente come "prima i più importanti" (ed è il default della chain).
+const PRI_TABLE = [
+    { name: 'high', glyph: '🔥', rank: 3 },
+    { name: 'med', glyph: '⚡', rank: 2 },
+    { name: 'low', glyph: '🔹', rank: 1 },
+];
+// Ordine per "attivabilità" (desc = prima ciò su cui puoi agire): in corso →
+// da fare → bloccata → chiusa. Non è l'ordine del ciclo di vita: il deck serve
+// a scegliere su cosa lavorare, quindi le Done stanno in fondo sotto `desc`.
+const PROG_TABLE = [
+    { name: 'wip', glyph: '🟡', rank: 4 },
+    { name: 'todo', glyph: '🔵', rank: 3 },
+    { name: 'locked', glyph: '🔒', rank: 2 },
+    { name: 'done', glyph: '✔', rank: 1 },
+];
+/** Rango dei glifi non riconosciuti: sotto tutti i noti → coda sotto `desc`. */
+const UNKNOWN_RANK = 0;
+// `✔️` (con VS16) e `✔` (senza) coesistono in tasks.md; una lookup per
+// uguaglianza mancherebbe una delle due forme. Stessa insidia già aggirata ad
+// hoc da isDone() con un includes(). Qui si normalizza una volta sola.
+const VS16_RE = /️/g;
+function normGlyph(s) {
+    return s.replace(VS16_RE, '').trim();
+}
+export function priName(glyph) {
+    const g = normGlyph(glyph);
+    return PRI_TABLE.find((e) => e.glyph === g)?.name ?? null;
+}
+export function progName(glyph) {
+    const g = normGlyph(glyph);
+    return PROG_TABLE.find((e) => e.glyph === g)?.name ?? null;
+}
+export function priRank(glyph) {
+    const g = normGlyph(glyph);
+    return PRI_TABLE.find((e) => e.glyph === g)?.rank ?? UNKNOWN_RANK;
+}
+export function progRank(glyph) {
+    const g = normGlyph(glyph);
+    return PROG_TABLE.find((e) => e.glyph === g)?.rank ?? UNKNOWN_RANK;
+}
+// `T10`.localeCompare(`T9`) mette T10 prima: l'ID va confrontato NUMERICO.
+// parseTasks ammette solo /^T\d+$/, ma un id fuori forma non deve far esplodere
+// il comparator → finisce in coda con Number.MAX_SAFE_INTEGER.
+export function idNum(id) {
+    const m = /^T(\d+)$/.exec(id);
+    return m ? Number(m[1]) : Number.MAX_SAFE_INTEGER;
+}
+function rankOf(task, key) {
+    if (key === 'pri')
+        return priRank(task.pri);
+    if (key === 'prog')
+        return progRank(task.prog);
+    return idNum(task.id);
+}
+/**
+ * Comparator della chain: chiavi valutate in cascata, prima differenza vince.
+ * A parità piena decide `id` ascendente — fallback implicito che rende l'ordine
+ * SEMPRE deterministico (mai instabile fra re-render). Se `id` è già una chiave
+ * esplicita della chain il fallback non serve: l'id è unico, la parità è totale.
+ */
+export function compareTasks(a, b, sort) {
+    for (const entry of sort) {
+        const diff = rankOf(a, entry.key) - rankOf(b, entry.key);
+        if (diff !== 0)
+            return entry.dir === 'asc' ? diff : -diff;
+    }
+    if (sort.some((e) => e.key === 'id'))
+        return 0;
+    return idNum(a.id) - idNum(b.id);
+}
+/**
+ * Ciclo di una chiave nella chain: assente → asc → desc → assente.
+ * La POSIZIONE nella chain nasce dall'ordine di prima pressione (digitare
+ * `ppi` produce [pri desc, id asc]); ri-aggiungere una chiave rimossa la
+ * riaccoda in fondo, non la rimette al posto vecchio.
+ */
+export function cycleSort(sort, key) {
+    const i = sort.findIndex((e) => e.key === key);
+    if (i < 0)
+        return [...sort, { key, dir: 'asc' }];
+    if (sort[i].dir === 'asc') {
+        const next = [...sort];
+        next[i] = { key, dir: 'desc' };
+        return next;
+    }
+    return sort.filter((e) => e.key !== key);
+}
+export function toggleHidden(hidden, name) {
+    return hidden.includes(name) ? hidden.filter((h) => h !== name) : [...hidden, name];
+}
+/**
+ * Un filtro nasconde solo valori RICONOSCIUTI: un glifo ignoto non è
+ * classificabile, quindi resta visibile. Regola voluta — un filtro non deve
+ * far sparire in silenzio task che non sa leggere.
+ */
+export function isVisible(task, view) {
+    const p = priName(task.pri);
+    if (p && view.hiddenPri.includes(p))
+        return false;
+    const s = progName(task.prog);
+    if (s && view.hiddenProg.includes(s))
+        return false;
+    return true;
+}
+/** Filtra poi ordina. Non muta l'input: il polling di tasks.md resta ignaro. */
+export function applyView(tasks, view) {
+    const visible = tasks.filter((t) => isVisible(t, view));
+    visible.sort((a, b) => compareTasks(a, b, view.sort));
+    return { visible, hidden: tasks.length - visible.length };
+}
+export const PRI_ENTRIES = PRI_TABLE.map((e) => ({ name: e.name, glyph: e.glyph }));
+export const PROG_ENTRIES = PROG_TABLE.map((e) => ({ name: e.name, glyph: e.glyph }));
+const SORT_LABEL = { pri: 'pri', prog: 'stato', id: 'id' };
+/** Riassunto della chain per l'header ("pri↓ id↑"); vuota → "—". */
+export function describeSort(sort) {
+    if (sort.length === 0)
+        return '—';
+    return sort.map((e) => `${SORT_LABEL[e.key]}${e.dir === 'asc' ? '↑' : '↓'}`).join(' ');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.5.0",
+  "version": "0.6.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": {
@@ -13,6 +13,7 @@
   "scripts": {
     "dev": "tsx src/cli.tsx",
     "build": "tsc",
+    "test": "tsx --test test/*.test.ts",
     "start": "node dist/cli.js",
     "prepare": "tsc"
   },