@lamemind/loom-deck 0.43.0 → 0.45.0

package/README.md

@@ -92,7 +92,7 @@ Assegnazioni correnti:
 | modale | `S` | sort chain |
 | modale | `F` | filtri |
 | modale | `^F` | **ricerca full-text** nelle conversazioni del progetto |
-| modale | `⏎` | **detail** della task selezionata: task file scrollabile + barra azioni |
+| modale | `⏎` | **detail** della task selezionata: task file scrollabile + area di compilazione a quattro righe |
 | modale | `CANC` | **elimina** — la task selezionata; su una riga meta della vista `archiviabili`, l'intero insieme |
 | immediata | `^K` | spawna la task selezionata col prompt di **recap** |
 | immediata | `^P` | spawna la task selezionata sul **preflight** |
@@ -161,19 +161,26 @@ Col focus sul pane Sessions né `⏎` né i `CTRL` spawnano: l'oggetto dell'azio
 
 ### `⏎` — il detail della task
 
-Overlay fullscreen a due zone: il **task file per intero**, scrollabile
-(`↑↓` riga, `PgUp`/`PgDn` pagina, `g`/`G` estremi), e una riga di **bottoni**
-navigabile con `←→`, con `open` a fuoco all'apertura. `⏎` esegue l'azione
-selezionata e chiude; `esc` chiude lasciando la lista con la stessa selezione.
+Overlay fullscreen a due zone: il **task file per intero**, scrollabile con `PgUp`/`PgDn`, e sotto un'**area di compilazione** a quattro righe — i quattro parametri con cui la sessione sta per nascere.
 
-Le azioni non sono un catalogo nuovo: chiamano lo **stesso** percorso di spawn dei tasti diretti. Una superficie in più, zero percorsi di spawn in più.
+| Riga | Cosa | Come si cambia |
+|---|---|---|
+| `azione` | `open` `preflight` `run` `status` `checkpoint` | `←→`, oppure l'iniziale: `o` `p` `r` `s` `c` |
+| `prompt` | il testo che riceverà la sessione | si scrive; parte pre-riempito dall'azione scelta |
+| `modello` | `fable` `opus` `sonnet` `haiku` | `←→` |
+| `titolo` | il nome della conversazione, in lista e nella tab | si scrive |
+
+`↑↓` spostano il fuoco fra le righe, `⏎` spawna coi quattro valori correnti, `esc` chiude lasciando la lista con la stessa selezione. Le righe di testo ricevono i caratteri **solo quando sono in fuoco**: su `azione` una lettera che non è un'iniziale resta inerte invece di finire in un campo.
+
+`↑↓` sono quindi una risorsa contesa, e vanno al fuoco: la lettura del task file resta su `PgUp`/`PgDn`, cioè una granularità sola invece di due. È il prezzo di avere `↑↓` nel loro significato di sempre su una schermata che ospita insieme un documento e dei campi.
 
-Sono bottoni affiancati e non voci di un menu verticale perché è la forma che sopravvive all'arrivo del mouse: un rettangolo ha già coordinate e area cliccabile, una lista di voci andrebbe rifatta.
+**Il campo `prompt` è quello che parte davvero**, non un'anteprima: modificarlo cambia il messaggio che la sessione riceve. Cambiare azione lo riscrive col default della nuova — col fuoco per riga il cambio accidentale non esiste (`←→` toccano l'azione solo dalla sua riga), quindi non c'è nessuna modifica da proteggere.
 
-Dentro il detail `←→` cicla i bottoni invece di cambiare pane, e `tab` non cambia la vista — il
-ramo `useInput` della modalità chiude prima di arrivare a quello di default. Ink non ha focus-trap: la cattura **è** l'ordine dei rami, e cambiare cosa fa un tasto fuori dal detail non tocca cosa fa dentro.
+La grammatica delle righe è la **stessa** del modale edit (`SHIFT+E`) e sta in `src/fields.ts`: descrittore delle righe, fuoco, caret, `^A`/`^E`/`^D`/`^U`. Finché era scritta due volte andava tenuta allineata a mano a ogni tasto aggiunto. `Home`/`End` non ci sono e non possono esserci: `useInput` non le espone — verificato su otto sequenze diverse, arrivano tutte come input vuoto senza flag — da cui `^A`/`^E`.
 
-Il catalogo dei prompt vive in `scripts/deck-run`, non nella TUI: è il primitive UI-agnostico, il deck gli passa un **simbolo** (`--prompt-kind`) e non una stringa. Così il testo sta in un posto solo, e con lui il suo vincolo di quoting — il prompt viaggia dentro apici singoli in `bash -lc`, quindi non può contenerne.
+Le azioni non sono un catalogo nuovo: chiamano lo **stesso** percorso di spawn dei tasti diretti. Una superficie in più, zero percorsi di spawn in più. Sono bottoni affiancati e non voci di un menu verticale perché è la forma che sopravvive all'arrivo del mouse: un rettangolo ha già coordinate e area cliccabile, una lista di voci andrebbe rifatta.
+
+Il **testo** dei prompt vive in `scripts/prompt-catalog`, un file dati sibling di `deck-run` che entrambi leggono a runtime: il deck per pre-riempire il campo, `deck-run` per comporre il comando in-tab. Come codice posseduto da un lato solo il deck avrebbe dovuto riscriverlo per mostrarlo, e le due copie divergerebbero alla prima voce aggiunta da una parte sola. Un prompt modificato a mano viaggia poi letterale (`--prompt`), perché a quel punto nessun `--prompt-kind` lo descrive più.
 
 ### `f` — forkare una conversazione
 
@@ -301,10 +308,13 @@ npx @lamemind/loom-deck
 # dalla project dir con un tasks.md
 scripts/deck-run T18
 scripts/deck-run T18 --prompt-kind none|recap|preflight|run|checkpoint
+scripts/deck-run T18 --prompt 'testo letterale del prompt'
 ```
 
 Apre una tab Ptyxis nella window attiva con `LOOM_TASK=T18 claude 'recap stato task T18'`. Il prompt iniziale è il terzo asse dello spawn, ortogonale al binding task (`<TaskID>` vs `--no-task`) e alla continuità (nuova vs `--resume`/`--fork`): senza flag resta `recap`, `none` apre la sessione bound **senza** alcun prompt. `LOOM_DECK_ENTER_PROMPT` (placeholder `{TASK}`) resta un override che vince sul kind — tranne su `none`, che è una richiesta esplicita di non averne.
 
+I testi del catalogo stanno in `scripts/prompt-catalog` (formato `kind<TAB>template`, `{TASK}` interpolato), non dentro lo script: li legge anche il deck, per mostrare nel detail il prompt prima dello spawn. `--prompt` passa invece un testo **letterale** ed è esclusivo con `--prompt-kind` — sono due modi di dire la stessa cosa, e accettarli insieme costringerebbe a stabilire quale vince. Il testo viene quotato per la shell in-tab, apici singoli compresi: è l'unico ingresso di testo libero in una riga che una shell parsa.
+
 La tab porta anche `PTYXIS_PROFILE` forzata al profilo bindato al progetto nel registry (`bindings/claude`), letto da dconf: è la chiave con cui loom-compass associa a un progetto lo stato annunciato dagli hook (running/ask/done). Una tab `ptyxis --tab` nuda erediterebbe il profilo di default, e l'annuncio finirebbe keyed su un UUID che nessun progetto dichiara — pallino fermo su idle, senza alcun errore visibile. Override o disattivazione via `LOOM_DECK_STATE_PROFILE`
 (settata a vuoto → nessun annuncio); progetto non registrato → nessun prefisso.
 

package/dist/cli.js

@@ -11,12 +11,13 @@ import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch,
 import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, TASK_VIEWS, } from './pane-views.js';
 import { isCompact, layoutBudget, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { cut, cutMiddle, sanitize, termWidth } from './width.js';
-import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
+import { applyView, cycleSort, describeSort, idColumnWidth, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, writeTaskEdit, PRI_GLYPH, PRI_LABEL } from './task-edit.js';
-import { ALL, EDIT_PRI, EDIT_PROG, MAX_SESSIONS, MAX_SESSIONS_ALL, META_ROWS, QUIT_WINDOW_MS, ROW_ALL, ROW_SPOT, SORT_TASTI, SPOT, } from './model.js';
+import { ALL, EDIT_FIELDS, EDIT_PRI, EDIT_PROG, editTextField, MAX_SESSIONS, MAX_SESSIONS_ALL, META_ROWS, QUIT_WINDOW_MS, ROW_ALL, ROW_SPOT, SORT_TASTI, SPOT, } from './model.js';
 import { purgeTargets, splitTargets } from './purge.js';
-import { conversationLabel, cpLen, editField, insertAt, isDone, isTextRow, removeAt, EDIT_ROWS, } from './layout.js';
-import { TASK_EMPTY, relTime, sanitizeTyped } from './glyphs.js';
+import { conversationLabel, isDone } from './layout.js';
+import { fieldsKey } from './fields.js';
+import { TASK_EMPTY, relTime, sanitizeTyped, taskTail } from './glyphs.js';
 import { commitTaskEdit, runLaunch, spawnClaudeEmpty, spawnCleanTasks, spawnCreateTask, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, onInTabCommand, CLAUDE_CMD, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
 import { EditModal, FilterModal, PurgeModal, SortModal, idList } from './ui/modals.js';
 import { ReaderScreen, SearchScreen } from './ui/search-screen.js';
@@ -79,9 +80,10 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const [taskViewId, setTaskViewId] = useState('tasks');
     const [sessionViewId, setSessionViewId] = useState('context');
     const [filterCursor, setFilterCursor] = useState({ row: 0, col: 0 });
-    // T41 — bozza dell'edit (null fuori dal modale) e riga attiva della griglia.
+    // T41 — bozza dell'edit (null fuori dal modale) e posizione nell'area di
+    // compilazione: riga in fuoco + caret dentro la riga di testo attiva.
     const [edit, setEdit] = useState(null);
-    const [editRow, setEditRow] = useState(0);
+    const [editCursor, setEditCursor] = useState({ row: 0, caret: 0 });
     // T112 — bozza della conferma di eliminazione (null fuori dal modale).
     const [purge, setPurge] = useState(null);
     // T116 — uscita a doppio `^C`. Il timer È lo stato dell'armamento: finché il
@@ -169,6 +171,19 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         else
             spotCount++;
     }
+    // T118 — colonne fisse della lista task, misurate su `paneTasks` (la vista
+    // attiva INTERA) e non sulla finestra visibile: gemelle di `sessionCols` e
+    // per la stessa ragione, che una larghezza derivata dallo schermo si muove a
+    // ogni scroll. La coda porta dentro il proprio gutter, così l'allineamento a
+    // destra lo produce `pad` da sé; nessuna riga con qualcosa da scrivere →
+    // colonna spenta a `0`, e le descrizioni si riprendono lo spazio.
+    const taskCols = (() => {
+        let tail = 0;
+        for (const t of paneTasks) {
+            tail = Math.max(tail, termWidth(taskTail(childCount.get(t.id) ?? 0, dirtyFolders.has(t.id))));
+        }
+        return { id: idColumnWidth(paneTasks), tail: tail > 0 ? tail + 1 : 0 };
+    })();
     // Figli della selezione: tutte le conversazioni del progetto (`≡ tutte`), le
     // sessioni bound alla task selezionata, oppure (spot) quelle senza binding.
     // sessions è già ts desc → l'ordine si eredita in tutti e tre i rami.
@@ -374,12 +389,16 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // il tempo di un tick la riga in lista comparirebbe nuda. Due record separati
     // sullo stesso `sessionId` sono la forma normale di un file append-only
     // last-wins, non una scrittura da fondere.
-    function spawnForTask(id, kind, model, spawnNote = '') {
+    // T117 — `prompt` è il testo LETTERALE quando lo spawn arriva dal detail, dove
+    // il campo è editabile: quello che l'utente legge è quello che parte. Assente
+    // per gli acceleratori della lista, che non hanno un campo da cui prenderlo e
+    // viaggiano col simbolo.
+    function spawnForTask(id, kind, model, spawnNote = '', prompt) {
         const sid = randomUUID();
         appendTaskBinding(cwd, sid, id);
         if (spawnNote)
             appendNote(cwd, sid, spawnNote);
-        const spawned = spawnDeck(id, cwd, sid, kind, model, spawnNote);
+        const spawned = spawnDeck(id, cwd, sid, kind, model, spawnNote, prompt);
         spawned.child.on('error', () => setNote(`⚠ spawn ${id} fallito (${DECK_RUN})`));
         // Il modello resta SEMPRE visibile anche quando è il default, perché è un
         // argomento esplicito del comando (T108): gli acceleratori della lista non
@@ -422,8 +441,8 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         appendNote(cwd, sid, text);
         reloadSessions();
         setNote(text
-            ? `✎ nota su ${sid.slice(0, 8)}: "${cut(text, 40)}"`
-            : `✎ nota rimossa da ${sid.slice(0, 8)}`);
+            ? `✎ titolo su ${sid.slice(0, 8)}: "${cut(text, 40)}"`
+            : `✎ titolo rimosso da ${sid.slice(0, 8)}`);
     }
     // 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
@@ -444,11 +463,10 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             prog,
             detail: initialDetail(detail?.fields['Progress'] ?? '', prog),
             title: selTask.rawDesc,
-            // Si apre sulla riga 0 (priorità), che non è un campo di testo: il caret
-            // prende la sua posizione entrando in una riga di testo con ↑↓.
-            caret: 0,
         });
-        setEditRow(0);
+        // Si apre sulla riga 0 (priorità), che non è un campo di testo: il caret
+        // prende la sua posizione entrando in una riga di testo con ↑↓.
+        setEditCursor({ row: 0, caret: 0 });
         setNote('');
         setMode('edit');
     }
@@ -713,7 +731,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         columns,
         setMode,
         setNote,
-        onAction: (id, kind, model, spawnNote) => spawnForTask(id, kind, model, spawnNote),
+        onAction: (id, kind, model, spawnNote, prompt) => spawnForTask(id, kind, model, spawnNote, prompt),
     });
     const search = useSearchOverlay({
         sessions,
@@ -744,7 +762,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         if (key.escape) {
             setMode('normal');
             setNoteDraft('');
-            setNote('N → nota annullata');
+            setNote('N → titolo annullato');
         }
         else if (key.return) {
             submitNote();
@@ -822,84 +840,31 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 : { ...v, hiddenProg: toggleHidden(v.hiddenProg, PROG_ENTRIES[col].name) });
         }
     }
+    // Il ponte fra le quattro righe del modale e la bozza. I valori restano
+    // tipizzati (`PriName`, `ProgName`) invece di finire in un record generico:
+    // `fields.ts` governa la grammatica dei tasti, non il modello dati.
+    const editIO = {
+        text: (row) => edit?.[editTextField(row)] ?? '',
+        setText: (row, next) => setEdit((e) => (e ? { ...e, [editTextField(row)]: next } : e)),
+        choice: (row) => row === 0
+            ? Math.max(0, EDIT_PRI.indexOf(edit?.pri ?? 'med'))
+            : Math.max(0, EDIT_PROG.indexOf(edit?.prog ?? 'todo')),
+        setChoice: (row, index) => setEdit((e) => e ? (row === 0 ? { ...e, pri: EDIT_PRI[index] } : { ...e, prog: EDIT_PROG[index] }) : e),
+    };
     function onEditKey(input, key) {
         if (key.escape) {
             setMode('normal');
             setEdit(null);
             setNote('E → edit annullato');
+            return;
         }
-        else if (key.return) {
+        if (key.return) {
             submitEdit();
+            return;
         }
-        else if (key.upArrow || key.downArrow) {
-            const next = ((editRow + EDIT_ROWS + (key.upArrow ? -1 : 1)) % EDIT_ROWS);
-            setEditRow(next);
-            // Il caret segue la riga attiva e atterra in CODA al nuovo campo: è la
-            // posizione da cui si continua a scrivere, ed è anche l'unica che non
-            // dipende da dove stava il cursore nel campo precedente.
-            setEdit((e) => (e && isTextRow(next) ? { ...e, caret: cpLen(e[editField(next)]) } : e));
-        }
-        else if ((key.leftArrow || key.rightArrow) && !isTextRow(editRow)) {
-            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 (isTextRow(editRow)) {
-            // Un solo ramo per i due campi di testo, la riga sceglie la chiave:
-            // duplicarlo significherebbe tenere allineate a mano due copie della
-            // stessa grammatica di input a ogni tasto aggiunto.
-            const field = editField(editRow);
-            if (key.ctrl) {
-                // T54 — ramo CTRL ANTEPOSTO a quelli su carattere, come in modalità
-                // normale: `^A` e `a` arrivano con lo stesso `input`, quindi senza
-                // questa precedenza il `^A` finirebbe dentro il testo.
-                //
-                // `^A`/`^E` (convenzione readline) perché `Home`/`End` NON sono
-                // esposte da `useInput`: arrivano come input vuoto, indistinguibili
-                // da qualunque altro tasto senza nome.
-                //
-                // `^D` è il delete-forward, e anche qui il motivo è un limite di Ink:
-                // il tasto Backspace fisico manda `\x7f` e il tasto Canc manda
-                // `\x1b[3~`, ma `parseKeypress` li battezza ENTRAMBI `delete` e
-                // svuota `input` — a valle sono lo stesso evento. `key.delete` va
-                // quindi al backspace (il tasto che si usa davvero) e la
-                // cancellazione in avanti prende il suo tasto readline.
-                if (input === 'a')
-                    setEdit((e) => (e ? { ...e, caret: 0 } : e));
-                else if (input === 'e')
-                    setEdit((e) => (e ? { ...e, caret: cpLen(e[field]) } : e));
-                else if (input === 'd')
-                    setEdit((e) => (e ? { ...e, [field]: removeAt(e[field], e.caret) } : e));
-            }
-            else if (key.leftArrow || key.rightArrow) {
-                // CLAMP agli estremi, non wrap: a inizio campo `←` non deve saltare in
-                // fondo. Le liste di valori (righe 0/1) ciclano perché sono 3-4 voci;
-                // un testo no — il salto sarebbe indistinguibile da uno sfarfallio.
-                const d = key.leftArrow ? -1 : 1;
-                setEdit((e) => e ? { ...e, caret: Math.max(0, Math.min(cpLen(e[field]), e.caret + d)) } : e);
-            }
-            else if (key.backspace || key.delete) {
-                setEdit((e) => e ? { ...e, [field]: removeAt(e[field], e.caret - 1), caret: Math.max(0, e.caret - 1) } : e);
-            }
-            else if (input && !key.meta) {
-                // `sanitizeTyped`: `useInput` consegna il CHUNK di stdin, quindi un
-                // incollaggio porta dentro newline e byte di controllo — invisibili
-                // nel campo ma contati da Ink nella larghezza della riga, e destinati
-                // a finire tali e quali dentro tasks.md. Ed è per lo stesso motivo che
-                // il caret avanza della LUNGHEZZA del chunk, non di uno: un incollaggio
-                // entra tutto insieme.
-                const ins = sanitizeTyped(input);
-                setEdit((e) => e ? { ...e, [field]: insertAt(e[field], e.caret, ins), caret: e.caret + cpLen(ins) } : e);
-            }
-        }
+        // Tutto il resto è dell'area di compilazione, che è la STESSA del detail
+        // (T117): una grammatica sola, non due copie da tenere allineate a mano.
+        fieldsKey(input, key, EDIT_FIELDS, editCursor, setEditCursor, editIO);
     }
     /**
      * T116 — `^C`: la prima pressione ARMA, la seconda entro la finestra chiude.
@@ -1174,7 +1139,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // su una pinnata STALE, perché annotare «questa non c'è più, era X» è
             // proprio il caso in cui una nota serve.
             if (focus !== 'sessions') {
-                setNote('N → nota: seleziona una sessione (→ per il pane)');
+                setNote('N → titolo: seleziona una sessione (→ per il pane)');
             }
             else if (!selSessionId) {
                 setNote('N → nessuna sessione da annotare');
@@ -1281,7 +1246,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             ? [purgeBulk ? 'CANC elimina tutte' : 'CANC elimina']
             : []),
         ...(canResume ? ['f fork'] : []),
-        ...(canPin ? ['p pin', 'N nota', 'A assegna'] : []),
+        // T117 · D3 — «titolo» anche qui: è lo stesso valore che il detail chiede
+        // allo spawn, e due nomi per una cosa sola li paga chi legge le due
+        // schermate. Rename di sola ETICHETTA: il dato resta `note` nel sidecar e
+        // `--title-note` in deck-run, dove rinominarlo sarebbe un breaking.
+        ...(canPin ? ['p pin', 'N titolo', 'A assegna'] : []),
         '^F cerca',
         'C nuova',
         'E edit',
@@ -1321,7 +1290,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // posizione è lo scroll mosso a mano. Il clamp serve comunque — un resize
         // può accorciare il testo sotto uno scroll già dato.
         const start = Math.min(sheet.top, sheet.maxTop);
-        return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, model: sheet.model, spawnNote: sheet.spawnNote, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur }));
+        return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, model: sheet.model, spawnNote: sheet.spawnNote, prompt: sheet.prompt, cursor: sheet.cursor, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur }));
     }
     // ── T52 · schermate sostitutive ─────────────────────────────────────────
     // Ricerca e reader sono gli unici modali che NON stanno in flusso sopra i
@@ -1412,7 +1381,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     if (budget.compact) {
         return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "v", VERSION, " \u00B7 ", viewTasks.length, " task \u00B7 sel ", selectedTaskId ?? parentLabel, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga"] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: ["v", VERSION] })] }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nota conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'purge' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["elimina task \u00B7", ' ', purge?.ignored ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " keep/purge dei file non tracciati \u00B7", ' '] })) : null, _jsx(Text, { color: "yellow", children: "\u23CE" }), " conferma \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${legend.shown}` : '', legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow, columns: columns })) : null, mode === 'purge' && purge ? _jsx(PurgeModal, { draft: purge, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, dirty: dirtyFolders }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: ["v", VERSION] })] }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["titolo conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'purge' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["elimina task \u00B7", ' ', purge?.ignored ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " keep/purge dei file non tracciati \u00B7", ' '] })) : null, _jsx(Text, { color: "yellow", children: "\u23CE" }), " conferma \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${legend.shown}` : '', legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editCursor.row, caret: editCursor.caret, columns: columns })) : null, mode === 'purge' && purge ? _jsx(PurgeModal, { draft: purge, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, idW: taskCols.id, tailW: taskCols.tail, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, dirty: dirtyFolders }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const cwd = process.cwd();
 // T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,

package/dist/fields.js

@@ -0,0 +1,108 @@
+import { cpLen, insertAt, removeAt } from './layout.js';
+import { sanitizeTyped } from './glyphs.js';
+/** La riga `row` è un campo di testo (e quindi mangia le lettere). */
+export function isTextField(specs, row) {
+    return specs[row]?.kind === 'text';
+}
+/** Caret in CODA al campo della riga `row`: la posizione da cui si continua a
+ *  scrivere, e l'unica che non dipende da dove stava il cursore prima. Su una
+ *  riga a scelta il caret non ha significato e vale 0. */
+export function caretAtEnd(specs, row, io) {
+    return isTextField(specs, row) ? cpLen(io.text(row)) : 0;
+}
+/**
+ * Un tasto dell'area di compilazione. Ritorna `true` se lo ha consumato.
+ *
+ * Il chiamante gestisce PRIMA i tasti che sono suoi e non dell'area (`esc`,
+ * `⏎`, `^F`, `PgUp`/`PgDn`), poi delega qui; ciò che torna `false` è inerte, e
+ * lasciarlo cadere è la scelta giusta dentro un modo capturing.
+ *
+ * Il ramo CTRL è ANTEPOSTO a quelli su carattere, come in modalità normale: `^A`
+ * e `a` arrivano con lo stesso `input`, e `key.ctrl` è l'unico discriminante —
+ * senza la precedenza il `^A` finirebbe dentro il testo.
+ */
+export function fieldsKey(input, key, specs, cursor, setCursor, io) {
+    const spec = specs[cursor.row];
+    if (!spec)
+        return false;
+    if (key.upArrow || key.downArrow) {
+        // Ciclico: le aree sono di 4 righe, arrivare in fondo e ripartire costa meno
+        // che invertire direzione.
+        const d = key.upArrow ? -1 : 1;
+        const row = (cursor.row + specs.length + d) % specs.length;
+        setCursor({ row, caret: caretAtEnd(specs, row, io) });
+        return true;
+    }
+    if (spec.kind === 'choice') {
+        if (key.leftArrow || key.rightArrow) {
+            const d = key.leftArrow ? -1 : 1;
+            io.setChoice(cursor.row, (io.choice(cursor.row) + spec.count + d) % spec.count);
+            return true;
+        }
+        // Le lettere di selezione diretta arrivano nude: un `key.ctrl` con lo stesso
+        // carattere è un acceleratore, non una scelta.
+        if (input && !key.ctrl && !key.meta && spec.hotkeys) {
+            const at = spec.hotkeys[input];
+            if (at !== undefined && at < spec.count) {
+                io.setChoice(cursor.row, at);
+                return true;
+            }
+        }
+        return false;
+    }
+    const value = io.text(cursor.row);
+    if (key.ctrl) {
+        // `^A`/`^E` (convenzione readline) perché `Home`/`End` NON sono esposte da
+        // `useInput`: misurate su otto sequenze diverse (`\x1b[H`, `\x1bOH`,
+        // `\x1b[1~`, `\x1b[7~` e i gemelli End), arrivano tutte come `input` vuoto
+        // senza nessun flag alzato — indistinguibili fra loro e da qualunque altro
+        // tasto senza nome.
+        //
+        // `^D` è il delete-forward, e anche lì il motivo è un limite di Ink: il
+        // Backspace fisico manda `\x7f` e il Canc manda `\x1b[3~`, ma
+        // `parseKeypress` li battezza ENTRAMBI `delete` — a valle sono lo stesso
+        // evento. `key.delete` va quindi al backspace (il tasto che si usa davvero)
+        // e la cancellazione in avanti prende il suo tasto readline.
+        //
+        // `^U` svuota il campo in fuoco. Non è comodità: il backspace tenuto premuto
+        // cancella UN carattere per CHUNK letto da stdin, non per pressione, quindi
+        // svuotare un campo lungo a colpi di backspace è di fatto non eseguibile.
+        if (input === 'a')
+            setCursor({ ...cursor, caret: 0 });
+        else if (input === 'e')
+            setCursor({ ...cursor, caret: cpLen(value) });
+        else if (input === 'd')
+            io.setText(cursor.row, removeAt(value, cursor.caret));
+        else if (input === 'u') {
+            io.setText(cursor.row, '');
+            setCursor({ ...cursor, caret: 0 });
+        }
+        else
+            return false;
+        return true;
+    }
+    if (key.leftArrow || key.rightArrow) {
+        // CLAMP agli estremi, non wrap: a inizio campo `←` non deve saltare in
+        // fondo. Le righe a scelta ciclano perché sono 3-5 voci; un testo no — il
+        // salto sarebbe indistinguibile da uno sfarfallio.
+        const d = key.leftArrow ? -1 : 1;
+        setCursor({ ...cursor, caret: Math.max(0, Math.min(cpLen(value), cursor.caret + d)) });
+        return true;
+    }
+    if (key.backspace || key.delete) {
+        io.setText(cursor.row, removeAt(value, cursor.caret - 1));
+        setCursor({ ...cursor, caret: Math.max(0, cursor.caret - 1) });
+        return true;
+    }
+    if (input && !key.meta) {
+        // `sanitizeTyped`: `useInput` consegna il CHUNK di stdin, quindi un
+        // incollaggio porta dentro newline e byte di controllo — invisibili nel
+        // campo ma contati da Ink nella larghezza della riga. Ed è per lo stesso
+        // motivo che il caret avanza della LUNGHEZZA del chunk, non di uno.
+        const ins = sanitizeTyped(input);
+        io.setText(cursor.row, insertAt(value, cursor.caret, ins));
+        setCursor({ ...cursor, caret: cursor.caret + cpLen(ins) });
+        return true;
+    }
+    return false;
+}

package/dist/glyphs.js

@@ -74,6 +74,28 @@ export const LIVE_NONE = ' ';
 export function displayProg(prog) {
     return sanitize(prog);
 }
+/**
+ * T118 — coda della riga task: marker dirty e contatore di conversazioni, nella
+ * colonna ancorata al bordo destro del pane.
+ *
+ * Il contatore va per ULTIMO perché è lui ad allinearsi al bordo — la colonna è
+ * resa `pad(…, 'right')`, quindi ciò che sta in fondo alla stringa cade sempre
+ * nella stessa colonna. Il marker gli sta a sinistra, dentro la stessa cella
+ * invece che in una colonna propria: è raro, e una colonna dedicata costerebbe
+ * 3 spazi vuoti su ogni riga di un pane largo la metà del terminale.
+ *
+ * Vive qui e non nel sito di render perché la STESSA stringa serve due volte —
+ * a misurare la larghezza della colonna (sulla vista completa, in `cli.tsx`) e
+ * a disegnarla (sulla finestra, in `panes.tsx`). Due formattazioni gemelle
+ * divergerebbero alla prima modifica, e la colonna risulterebbe larga quanto
+ * una stringa che nessuno scrive.
+ */
+export function taskTail(childCount, dirty) {
+    const count = childCount > 0 ? `(${childCount})` : '';
+    if (!dirty)
+        return count;
+    return count ? `${WARN} ${count}` : WARN;
+}
 // T49 — size umana compatta per il detail pane sessione.
 export function fmtSize(bytes) {
     if (bytes < 1024)

package/dist/layout.js

@@ -3,15 +3,6 @@
 // da scalare va tolta in un posto solo, o due chiamanti tolgono cose diverse
 // dalla stessa larghezza e il bordo viene mangiato.
 import { stripProjectCore } from './session-list.js';
-export const EDIT_ROWS = 4;
-/** Le righe del modale edit che sono campi di TESTO (il resto è scelta ←→). */
-export function isTextRow(r) {
-    return r === 2 || r === 3;
-}
-/** Chiave della bozza scritta dalla riga di testo `r`. */
-export function editField(r) {
-    return r === 2 ? 'detail' : 'title';
-}
 /**
  * Lunghezza in CODE POINT. Il caret ci indicizza sopra: `.length` conterebbe le
  * code unit UTF-16 e un'emoji nel titolo varrebbe 2 posizioni, cioè un cursore

package/dist/model.js

@@ -60,3 +60,17 @@ export const KIND_LABEL = { ai: 'IA', tool: 'tools', human: 'human' };
 // l'ordine naturale di lettura.
 export const EDIT_PRI = ['high', 'med', 'low'];
 export const EDIT_PROG = ['todo', 'wip', 'done', 'locked'];
+// T117 — le righe del modale edit come DATO, nella forma che `fields.ts`
+// consuma: 0 priorità · 1 stato · 2 progresso libero · 3 titolo. Il modale non
+// dà lettere di selezione alle due righe a scelta, dove i valori sono glifi e
+// non hanno un'iniziale da premere.
+export const EDIT_FIELDS = [
+    { kind: 'choice', count: EDIT_PRI.length },
+    { kind: 'choice', count: EDIT_PROG.length },
+    { kind: 'text' },
+    { kind: 'text' },
+];
+/** Chiave della bozza scritta dalla riga di testo `r` (2 = progresso, 3 = titolo). */
+export function editTextField(r) {
+    return r === 2 ? 'detail' : 'title';
+}