@lamemind/loom-deck 0.5.1 → 0.7.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,10 @@ 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, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
+import { initialDetail, progressText, writeTaskEdit, PRI_GLYPH, PRI_LABEL, PROG_GLYPH, } from './task-edit.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 +25,16 @@ 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' };
+// T41 — ordine dei valori nel modale edit. Deliberatamente DIVERSO da
+// PRI_ENTRIES/PROG_ENTRIES (che seguono il rango di sort): qui si sceglie un
+// valore, non si ordina, quindi vince l'ordine del CICLO DI VITA — da fare →
+// in corso → chiusa → bloccata. La priorità resta alta→bassa, che è già
+// l'ordine naturale di lettura.
+const EDIT_PRI = ['high', 'med', 'low'];
+const EDIT_PROG = ['todo', 'wip', 'done', 'locked'];
 function isDone(prog) {
     return prog.includes('✔');
 }
@@ -36,18 +50,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',
@@ -105,6 +117,24 @@ function spawnCreateTask(text, cwd, sessionId, onResult) {
     });
     return child;
 }
+// T41 — Commit dell'edit. `git commit -- <paths>` committa lo stato working-tree
+// SOLO di quei path, ignorando l'index: se l'utente ha altro in stage (o altri
+// file sporchi) non finisce dentro per errore. NON detached: è un'operazione
+// veloce e il suo esito va riportato nella nota. stderr raccolto per dire perché
+// ha fallito (identità git assente, hook che rifiuta, …) invece di un generico ⚠.
+function commitTaskEdit(cwd, paths, message, onResult) {
+    const child = spawn('git', ['commit', '-m', message, '--', ...paths], {
+        cwd,
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let err = '';
+    child.stderr?.on('data', (c) => {
+        err += c.toString();
+    });
+    child.on('error', () => onResult(false, 'git non lanciabile'));
+    child.on('close', (code) => onResult(code === 0, err.trim().split('\n')[0] ?? ''));
+    return child;
+}
 // Carica tasks.md e lo ri-legge quando cambia sotto (poll su mtime). Poll
 // (non fs.watch) perché i writer di tasks.md — checkpoint-task/create-task —
 // riscrivono il file (probabile replace atomico), che rompe il watch sull'inode
@@ -235,18 +265,37 @@ 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 });
+    // T41 — bozza dell'edit (null fuori dal modale) e riga attiva della griglia.
+    const [edit, setEdit] = useState(null);
+    const [editRow, setEditRow] = useState(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();
@@ -266,15 +315,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]);
@@ -287,7 +339,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();
@@ -315,6 +367,68 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         });
         child.on('error', () => setNote(`⚠ create-task: '${CLAUDE_CMD}' non lanciabile`));
     }
+    // T41 — apertura dell'edit: la bozza parte dai valori ATTUALI della task, non
+    // da default. 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`).
+    function openEdit() {
+        if (!selTask)
+            return;
+        const prog = progName(selTask.prog) ?? 'todo';
+        setEdit({
+            pri: priName(selTask.pri) ?? 'med',
+            prog,
+            detail: initialDetail(detail?.fields['Progress'] ?? '', prog),
+        });
+        setEditRow(0);
+        setNote('');
+        setMode('edit');
+    }
+    // T41 — ⏎ nell'edit: 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 submitEdit() {
+        const task = selTask;
+        const draft = edit;
+        setMode('normal');
+        setEdit(null);
+        if (!task || !draft)
+            return;
+        let res;
+        try {
+            res = writeTaskEdit({ tasksPath, tasksDir, id: task.id, ...draft });
+        }
+        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}`;
+        setNote(`⏳ ${task.id} → ${summary} · commit…`);
+        commitTaskEdit(cwd, res.paths, `chore(${task.id}): pri ${PRI_LABEL[draft.pri]} · stato ${res.progress}`, (ok, err) => {
+            setNote(ok ? `✔ ${task.id} → ${summary} · committato` : `⚠ ${task.id} salvato, commit fallito: ${err}`);
+        });
+    }
+    // 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).
@@ -322,7 +436,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();
@@ -335,18 +449,115 @@ 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;
+        }
+        // T41 — modale edit: griglia a 3 righe. Righe 0/1 = scelta a valore singolo
+        // (←→ scorre), riga 2 = testo libero (ogni carattere stampabile entra nel
+        // progresso). Come gli altri modali cattura tutto: `esc` annulla senza
+        // scrivere né uscire dal deck.
+        if (mode === 'edit') {
+            if (key.escape) {
+                setMode('normal');
+                setEdit(null);
+                setNote('E → edit annullato');
+            }
+            else if (key.return) {
+                submitEdit();
+            }
+            else if (key.upArrow) {
+                setEditRow((r) => ((r + 2) % 3));
+            }
+            else if (key.downArrow) {
+                setEditRow((r) => ((r + 1) % 3));
+            }
+            else if (key.leftArrow || key.rightArrow) {
+                const d = key.leftArrow ? -1 : 1;
+                // Scorrimento CICLICO (wrap) e non clampato: le liste sono di 3-4 voci,
+                // arrivare in fondo e ripartire costa meno di invertire direzione.
+                if (editRow === 0) {
+                    setEdit((e) => e ? { ...e, pri: EDIT_PRI[(EDIT_PRI.indexOf(e.pri) + d + EDIT_PRI.length) % EDIT_PRI.length] } : e);
+                }
+                else if (editRow === 1) {
+                    setEdit((e) => e
+                        ? { ...e, prog: EDIT_PROG[(EDIT_PROG.indexOf(e.prog) + d + EDIT_PROG.length) % EDIT_PROG.length] }
+                        : e);
+                }
+            }
+            else if (editRow === 2) {
+                if (key.backspace || key.delete) {
+                    setEdit((e) => (e ? { ...e, detail: e.detail.slice(0, -1) } : e));
+                }
+                else if (input && !key.ctrl && !key.meta) {
+                    setEdit((e) => (e ? { ...e, detail: e.detail + input } : e));
+                }
+            }
+            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));
         }
@@ -355,39 +566,65 @@ 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 === 'E') {
+            // L'edit ha senso solo su una task reale: la riga meta "spot" non ne è una.
+            if (isSpot || !selTask)
+                setNote('E → nessuna task selezionata');
+            else
+                openEdit();
+        }
+        else if (input === 'S') {
+            setViewBackup(view);
+            setNote('');
+            setMode('sort');
+        }
+        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 === '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 && /^[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();
@@ -396,11 +633,45 @@ 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"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \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 E edit \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, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow })) : 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)))] }));
+}
+// T41 — modale edit, in flusso come gli altri (spinge giù i pane invece di
+// coprirli: la riga che stai modificando resta visibile sopra la lista).
+// La riga di anteprima mostra il testo ESATTO che finirà nel campo `Progress`
+// del task file — così il default (`✔️ Done at <oggi>`) non è una sorpresa.
+function EditModal({ id, draft, row }) {
+    const mark = (r) => (row === r ? '▶ ' : '  ');
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri  " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato" }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(Text, { dimColor: true, children: "prog " }), _jsxs(Text, { children: ['  ', draft.detail] }), row === 2 ? _jsx(Text, { inverse: true, children: " " }) : null, !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { dimColor: true, children: ["\u21B3 ", progressText(draft.prog, draft.detail)] })] }));
 }
-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), "  ", displayProg(task.prog), "  ", task.desc, n > 0 ? ` (${n})` : ''] }, task.id));

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/task-edit.js

@@ -0,0 +1,160 @@
+// T41 — Edit inline di priorità/stato dal deck.
+// Le funzioni di rewrite sono PURE (stringa → stringa): la scrittura su disco è
+// isolata in `writeTaskEdit`, così la grammatica delle sostituzioni è testabile
+// senza toccare il filesystem.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { findTaskFile } from './tasks.js';
+// Il task file scrive la priorità per NOME (`- **Priority**: Med`), tasks.md la
+// scrive come GLIFO (colonna Pri). Due rappresentazioni dello stesso valore →
+// due mappe, entrambe keyed sul nome canonico di view.ts (unica fonte del rango).
+export const PRI_LABEL = { high: 'High', med: 'Med', low: 'Low' };
+export const PRI_GLYPH = { high: '🔥', med: '⚡', low: '🔹' };
+// `✔️` CON VS16: è la forma usata nelle righe Done già presenti in tasks.md e nei
+// task file. view.ts normalizza via VS16 in lettura, quindi scrivere la forma
+// lunga resta riconosciuto da priName/progName/isDone.
+export const PROG_GLYPH = {
+    todo: '🔵',
+    wip: '🟡',
+    done: '✔️',
+    locked: '🔒',
+};
+// Testo di default per stato, usato quando l'utente non digita un progresso
+// arbitrario. Il campo `Progress` del task file è testo libero (`🟡 85%`,
+// `🔵 Todo`, `✔️ Done at 2026-07-20`) → il glifo è il prefisso, il resto è prosa.
+const PROG_DEFAULT = {
+    todo: 'Todo',
+    wip: 'In Progress',
+    done: 'Done',
+    locked: 'Locked',
+};
+/** Data locale `YYYY-MM-DD` (non UTC: `toISOString` sposterebbe il giorno la sera). */
+export function today(d = new Date()) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+/**
+ * Riga `Progress` del task file. `detail` è il progresso ARBITRARIO digitato
+ * dall'utente: se c'è vince sempre (anche su done/locked — nessuna forma è
+ * preclusa), se manca si cade sul default dello stato. Solo `done` senza detail
+ * data-stampa, coerente con le righe già presenti (`✔️ Done at YYYY-MM-DD`).
+ */
+export function progressText(prog, detail, date = today()) {
+    const glyph = PROG_GLYPH[prog];
+    const d = detail.trim();
+    if (d)
+        return `${glyph} ${d}`;
+    if (prog === 'done')
+        return `${glyph} Done at ${date}`;
+    return `${glyph} ${PROG_DEFAULT[prog]}`;
+}
+/**
+ * Toglie il glifo di testa da un valore `Progress` (`🟡 85%` → `85%`).
+ * Il glifo lo ri-deriva `progressText` dallo stato selezionato.
+ */
+export function stripProgGlyph(s) {
+    return s.replace(/^[\p{Extended_Pictographic}✔️\s]+/u, '').trim();
+}
+/**
+ * Valore iniziale del campo "progresso arbitrario" all'apertura del modale.
+ *
+ * NON è semplicemente il testo corrente spogliato del glifo: se quel testo è
+ * esattamente ciò che il default già produrrebbe (`🔵 Todo`, `🟡 In Progress`)
+ * non c'è nulla di custom da preservare, e pre-riempirlo lo renderebbe
+ * APPICCICOSO — cambiando stato la scritta vecchia resterebbe attaccata al
+ * glifo nuovo (`🔵 Todo` → wip → `🟡 Todo`). Si parte quindi da vuoto e il
+ * default segue lo stato scelto.
+ *
+ * Un testo che il default NON sa riprodurre è invece informazione dell'utente e
+ * va tenuta: `🟡 85%` → `85%`, e `✔️ Done at 2026-07-14` → `Done at 2026-07-14`
+ * (la data storica sopravvive, non viene ri-stampata a oggi).
+ */
+export function initialDetail(current, prog, date = today()) {
+    const s = current.trim();
+    if (!s || s === progressText(prog, '', date))
+        return '';
+    return stripProgGlyph(s);
+}
+/**
+ * Riscrive le celle Pri (col 2) e Prog (col 4) della riga `| Tnn | … |` in
+ * tasks.md. Solo la PRIMA riga con quell'id — l'overview è unica, un secondo
+ * match sarebbe un duplicato da non propagare. Le altre celle (K, descrizione)
+ * restano i token grezzi originali: nessun re-flow della tabella, il diff resta
+ * di una riga. `ok:false` = id assente → il chiamante non scrive nulla.
+ *
+ * L'id deve rispettare `^T\d+$`, stesso gate di `parseTasks`: senza, un id
+ * arbitrario matcherebbe la riga di HEADER (`| ID | Pri | K | Prog |`) o quella
+ * di separatore, riscrivendone le celle e sfondando la tabella.
+ */
+const TASK_ID_RE = /^T\d+$/;
+export function updateTasksMdRow(content, id, priGlyph, progGlyph) {
+    if (!TASK_ID_RE.test(id))
+        return { content, ok: false };
+    let ok = false;
+    const lines = content.split('\n').map((line) => {
+        if (ok)
+            return line;
+        if (!line.trim().startsWith('|'))
+            return line;
+        const cells = line.split('|');
+        if ((cells[1] ?? '').trim() !== id)
+            return line;
+        if (cells.length < 6)
+            return line; // riga malformata → non toccarla
+        ok = true;
+        cells[2] = ` ${priGlyph} `;
+        cells[4] = ` ${progGlyph} `;
+        return cells.join('|');
+    });
+    return { content: ok ? lines.join('\n') : content, ok };
+}
+/**
+ * Riscrive i bullet header `- **Priority**:` e `- **Progress**:` del task file.
+ * First-match-wins per chiave, stessa regola di `parseTaskDetail`: se un campo
+ * ricompare nel body (residuo template) vince quello dell'header — così ciò che
+ * il deck mostra e ciò che scrive restano la stessa riga.
+ */
+export function updateTaskFileFields(content, priLabel, progress) {
+    let priDone = false;
+    let progDone = false;
+    const lines = content.split('\n').map((line) => {
+        if (!priDone && /^-\s*\*\*Priority\*\*:/.test(line)) {
+            priDone = true;
+            return `- **Priority**: ${priLabel}`;
+        }
+        if (!progDone && /^-\s*\*\*Progress\*\*:/.test(line)) {
+            progDone = true;
+            return `- **Progress**: ${progress}`;
+        }
+        return line;
+    });
+    const ok = priDone || progDone;
+    return { content: ok ? lines.join('\n') : content, ok };
+}
+/**
+ * Scrive i DUE lati della task: la riga di tasks.md (vista d'insieme) e i campi
+ * del task file (dettaglio). Sono due fonti che devono restare allineate — il
+ * deck legge la prima e mostra la seconda — quindi si toccano insieme.
+ * Un lato mancante (id fuori overview, o nessun task file) non blocca l'altro:
+ * si scrive ciò che esiste e il risultato dice cosa è stato toccato.
+ */
+export function writeTaskEdit(input) {
+    const { tasksPath, tasksDir, id, pri, prog, detail } = input;
+    const progress = progressText(prog, detail);
+    const paths = [];
+    const row = updateTasksMdRow(readFileSync(tasksPath, 'utf8'), id, PRI_GLYPH[pri], PROG_GLYPH[prog]);
+    if (row.ok) {
+        writeFileSync(tasksPath, row.content, 'utf8');
+        paths.push(tasksPath);
+    }
+    let fileUpdated = false;
+    const taskFile = findTaskFile(tasksDir, id);
+    if (taskFile) {
+        const upd = updateTaskFileFields(readFileSync(taskFile, 'utf8'), PRI_LABEL[pri], progress);
+        if (upd.ok) {
+            writeFileSync(taskFile, upd.content, 'utf8');
+            paths.push(taskFile);
+            fileUpdated = true;
+        }
+    }
+    return { paths, rowUpdated: row.ok, fileUpdated, progress };
+}

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,10 +1,10 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.5.1",
+  "version": "0.7.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": {
-    "loom-deck": "./dist/cli.js"
+    "loom-deck": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -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"
   },