@lamemind/loom-deck 0.41.0 → 0.43.0

package/README.md

@@ -28,17 +28,25 @@ Il deck è **UN processo Node**: spawna ma **non contiene** le sessioni CC — l
 
 ### La riga di stato dice il comando, non una parafrasi
 
-Ogni spawn di una sessione Claude — task (`⏎`/`^K`/`^P`/`^R`), resume, fork, sessione nuda (`c`) — scrive nella riga di stato in fondo al frame il **comando esatto** che è stato eseguito, quotato come lo si scriverebbe in bash:
+Ogni spawn di una sessione Claude — task (`⏎`/`^K`/`^P`/`^R`), resume, fork, sessione nuda (`c`) — scrive nella riga di stato in fondo al frame il **comando esatto** che gira dentro la tab, cioè l'invocazione `claude` vera con le env che la legano a task e progetto:
 
 ```
-$ /home/tizio/.local/lib/node_modules/@lamemind/loom-deck/scripts/deck-run T115 --session-id 9f3a… --prompt-kind run --model opus --title-note 'parser'
+$ LOOM_TASK=T115 claude --name '🧵 loom-works · T115 «parser»' --permission-mode auto --model opus --session-id 9f3a… '/loom-works:run-task T115'
 ```
 
-Task, `sessionId`, prompt-kind, modello e nota del titolo sono già argomenti del comando: una nota che li elencasse a parole li direbbe una seconda volta, in una grafia che non si può ricopiare in un terminale. Quello che si perde è il **tasto premuto**, che è ciò che hai appena fatto tu e non ciò che il deck ha fatto per te.
+Task, `sessionId`, modello, titolo e prompt iniziale sono già lì dentro: una nota che li elencasse a parole li direbbe una seconda volta, in una grafia che non si può ricopiare in un terminale. Quello che si perde è il **tasto premuto**, che è ciò che hai appena fatto tu e non ciò che il deck ha fatto per te.
 
-Il deck non passa mai da una shell (`spawn` senza `shell:true` consegna l'argv a `execve`): il quoting esiste per la sola resa, e serve a rendere la riga ricopiabile senza cambiare di una virgola ciò che è stato eseguito.
+**Il comando non lo compone il deck**, e non potrebbe senza riscrivere le stesse regole due volte: catalogo dei prompt, quoting, permission mode, profilo di stato e titolo vivono in `deck-run`. Il primitive lo **annuncia** su stdout prima di `exec`, con una riga
 
-Su un terminale stretto il taglio è **al mezzo** (`…`), non dalla coda: la testa è il path assoluto di `deck-run`, identico a ogni invocazione, mentre quel che distingue una sessione dall'altra sta tutto in fondo.
+```
+LOOM_DECK_INTAB <comando>
+```
+
+e il deck la legge da lì. L'annuncio è utile anche a chi lancia `deck-run` a mano: dice cosa sta per partire, mentre le diagnostiche restano su stderr.
+
+Ne discende che il comando in-tab arriva **asincrono**, qualche millisecondo dopo lo spawn. Nel frattempo la riga mostra il comando `deck-run` — che resta l'unica cosa visibile quando l'annuncio non arriva affatto (argomenti rifiutati, `deck-run` morto prima dell'exec), ed è anche il comando da ripetere a mano per vedere l'errore.
+
+Su un terminale stretto il taglio è **al mezzo** (`…`), non dalla coda: in un comando di spawn è la coda a distinguere un'invocazione dall'altra, e tagliare da lì la butterebbe via per intero.
 
 Restano fuori gli spawn che non aprono una sessione Claude interattiva: terminale (`t`), voci `launch` (`1`-`9`) e le skill headless (`C` create-task, `CANC` clean-tasks), dove la riga di stato serve a riportare l'**esito** di un'operazione asincrona.
 
@@ -68,10 +76,13 @@ Regola unica, senza eccezioni — pensata per reggere l'aggiunta di nuove azioni
 | minuscola | azione immediata, one-shot | |
 | `CTRL`+lettera | idiomi universali, toggle dentro i modali di testo, varianti di un'azione | `^F` = find, come ovunque · `^K`/`^P`/`^R` = spawn con un altro prompt |
 | `1`…`9` | voce `launch` n-esima del progetto | da `.claude/loom-works.json` |
-| `esc` | chiude l'overlay aperto | in modalità normale è inerte: **nessun tasto chiude il deck** |
+| `esc` | chiude l'overlay aperto | in modalità normale è inerte: **nessuna lettera chiude il deck** |
+| `^C` `^C` | chiude il deck | la prima pressione avverte in riga di stato, la seconda entro **5 secondi** esce; passata la finestra si riparte dall'avviso. Da dentro un modale il primo `^C` riporta alla lista — l'avviso vive nella riga di stato, che le schermate a pieno frame non disegnano |
 
 `CTRL` è il terzo livello, aggiunto quando è arrivata la ricerca. Serve perché un modale con **campi di testo** mangia ogni lettera nuda: là dentro nessun comando può essere una lettera semplice. `CTRL+X` e `x` nudo condividono lo stesso `input` e si distinguono solo per `key.ctrl`, quindi in modalità normale il ramo `CTRL` è valutato **per primo** e chiude l'intera classe — senza, `CTRL+F` cadrebbe nel ramo `f` e forkerebbe una sessione invece di cercare.
 
+`^C` è l'unica combo fuori da questo schema: non sta nel ramo `CTRL` di `normal` ma **sopra** il dispatch dei modi, perché non è un acceleratore — è la via d'uscita dal processo, e una via d'uscita che funziona in una schermata su undici non è una via d'uscita.
+
 Assegnazioni correnti:
 
 | | Tasto | Cosa fa |
@@ -101,7 +112,7 @@ t 💻 · c 🤖 · 1 📝 codium · 2 ☕ idea
 
 - **tasti** — cosa puoi fare *qui e ora*. Solo le voci attive: quelle contestuali compaiono quando il pane a fuoco le rende possibili e altrimenti spariscono,
   invece di mostrarsi inerti. Fuori navigazione (`↑↓` `←→`) e indicatore `focus:` — la prima è universale in qualunque TUI, il pane a fuoco si vede già dall'evidenziazione.
-  Nessuna voce di uscita, perché non esiste un tasto che chiuda il deck.
+  Nessuna voce di uscita: `^C` non ha bisogno di essere annunciato — è il tasto che si prova per primo, e la prima pressione risponde da sé con l'avviso.
 - **surface** — *dove* puoi aprire qualcosa: prima le due built-in (`t`/`c`), poi le voci `launch` del progetto. Stanno insieme perché hanno la stessa natura — fire-once, `cwd` = project root, nessuno stato — e differiscono solo per essere universali invece che custom.
 
 L'indice da solo è opaco (le `launch` sono custom per-progetto, senza una lettera fissa per app), quindi la riga espone la mappa e non il conteggio. Se non entrano in larghezza, si ferma a voci intere e mostra il contatore di quelle fuori riga — mai un troncamento silenzioso; le celle delle due built-in sono riservate a monte, o le voci sfonderebbero il box di quel tanto. Il cap a `9` è imposto dai tasti-cifra, non dallo schema: un progetto può dichiarare più di 9 voci, quelle oltre la nona sono configurate ma non raggiungibili (e la riga lo dice).

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { render, Box, Text, useInput } from 'ink';
-import { useState, useEffect, useMemo } from 'react';
+import { render, Box, Text, useApp, useInput } from 'ink';
+import { useState, useEffect, useMemo, useRef } from 'react';
 import { randomUUID } from 'node:crypto';
 import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskFileText, } from './tasks.js';
 import { rowIndexOfKey, selectedRow, } from './search.js';
@@ -13,11 +13,11 @@ import { isCompact, layoutBudget, searchPreviewCapacity, windowRange, } from './
 import { cut, cutMiddle, sanitize, termWidth } from './width.js';
 import { applyView, cycleSort, describeSort, 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, ROW_ALL, ROW_SPOT, SORT_TASTI, SPOT, } from './model.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 { 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 { commitTaskEdit, runLaunch, spawnClaudeEmpty, spawnCleanTasks, spawnCreateTask, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, CLAUDE_CMD, DECK_RUN, MODEL_DEFAULT, } from './spawn.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';
 import { DetailScreen } from './ui/detail-screen.js';
@@ -31,6 +31,12 @@ import { useSheetOverlay } from './overlays/sheet.js';
 import { useAssignOverlay } from './overlays/assign.js';
 import { captures } from './input-modes.js';
 import { VERSION } from './version.js';
+// T116 — l'avviso della prima pressione di `^C`. La durata è INTERPOLATA dalla
+// finestra, non ricopiata: un numero scritto a mano in un testo che promette un
+// comportamento diventa falso il giorno che la costante cambia, e nessuno strumento
+// lo segnala. Vive a livello di modulo perché ha due lettori — il ramo che la
+// scrive e il timer che la ritira, e quest'ultimo deve poterla riconoscere.
+const QUIT_NOTE = `⚠ ^C di nuovo entro ${QUIT_WINDOW_MS / 1000}s per chiudere il deck`;
 function Deck({ cwd, tasksPath, tasksDir }) {
     const { tasks, loadError } = useTasks(tasksPath);
     // `notes` esce dall'indice come `sessionNotes`: in questo componente `note` è
@@ -78,6 +84,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const [editRow, setEditRow] = useState(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
+    // handle esiste la finestra è aperta, e non serve un secondo stato da tenere
+    // in fase con lui. In un `useRef` e non in `useState` perché il ramo di uscita
+    // lo legge NELLO STESSO tasto in cui potrebbe averlo scritto — un valore di
+    // stato React arriverebbe al render dopo, cioè troppo tardi per decidere.
+    const { exit } = useApp();
+    const quitTimer = useRef(null);
     // Dimensioni vive del terminale: sono l'input del budget d'altezza sotto.
     const { rows, columns } = useTerminalSize();
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
@@ -283,12 +296,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // (`^K`, `⏎`, `f`), che è ciò che l'utente ha appena fatto e non ciò che il
     // deck ha fatto per lui.
     //
-    // Il taglio è al MEZZO (`cutMiddle`, non `cut`): la testa è il path assoluto
-    // di `deck-run`, identico a ogni spawn, e un taglio dalla coda mostrerebbe
-    // solo quello. Si taglia QUI, alla composizione, e non al render: la riga di
-    // stato porta anche messaggi normali, dove è la testa a contare. Ne discende
-    // che un resize successivo non ricalcola l'elisione — la nota è transitoria e
-    // `wrap="truncate-end"` resta come rete.
+    // Il taglio è al MEZZO (`cutMiddle`, non `cut`): in un comando di spawn è la
+    // coda a distinguere un'invocazione dall'altra, e un taglio dalla coda la
+    // butterebbe via per intero. Si taglia QUI, alla composizione, e non al
+    // render: la riga di stato porta anche messaggi normali, dove è la testa a
+    // contare. Ne discende che un resize successivo non ricalcola l'elisione — la
+    // nota è transitoria e `wrap="truncate-end"` resta come rete.
     function noteCommand(cmd) {
         // 4 = bordo + padding della cornice esterna, 2 = il prompt `$ `. Sbagliare
         // il budget non produce un errore visibile: la `truncate-end` di Ink taglia
@@ -296,6 +309,29 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // cioè con entrambi i pezzi che l'elisione al mezzo voleva salvare.
         setNote(`$ ${cutMiddle(cmd, Math.max(8, columns - 6))}`);
     }
+    // Le due note di uno spawn, in quest'ordine: il comando di `deck-run` subito,
+    // e appena arriva l'annuncio quello della sessione `claude` che gira DENTRO
+    // la tab — che è ciò che si vuole vedere davvero (`deck-run` è l'involucro,
+    // l'invocazione vera la compone lui).
+    //
+    // La prima non è un ripiego di stile: è l'unica che esiste quando l'annuncio
+    // non arriva (spawn inerte nei test, argomenti rifiutati, `deck-run` morto
+    // prima dell'exec), ed è anche il comando da ripetere a mano per vedere
+    // l'errore. Il salto fra le due dura i millisecondi che `deck-run` impiega a
+    // comporre.
+    const spawnSeq = useRef(0);
+    function noteSpawn(spawned) {
+        noteCommand(spawned.cmd);
+        const mine = ++spawnSeq.current;
+        onInTabCommand(spawned.child, (inTab) => {
+            // Due spawn ravvicinati: gli annunci sono asincroni e possono tornare
+            // fuori ordine, e senza guardia il più vecchio scriverebbe sopra il più
+            // recente — la riga di stato mostrerebbe un comando che non è l'ultimo
+            // partito.
+            if (spawnSeq.current === mine)
+                noteCommand(inTab);
+        });
+    }
     // T56 — apre una sessione bound alla task selezionata. Punto UNICO dei quattro
     // tasti (⏎/^K/^P/^R): fra loro cambia solo il prompt iniziale, tutto il resto
     // è identico — uuid pinnato, binding scritto PRIMA dello spawn (la sessione
@@ -343,14 +379,14 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         appendTaskBinding(cwd, sid, id);
         if (spawnNote)
             appendNote(cwd, sid, spawnNote);
-        const { child, cmd } = spawnDeck(id, cwd, sid, kind, model, spawnNote);
-        child.on('error', () => setNote(`⚠ spawn ${id} fallito (${DECK_RUN})`));
+        const spawned = spawnDeck(id, cwd, sid, kind, model, spawnNote);
+        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
         // passano dal selettore del detail e usano il default fisso, quindi senza
         // vederlo l'utente crederebbe di aver ereditato la scelta dell'ultimo
         // detail aperto.
-        noteCommand(cmd);
+        noteSpawn(spawned);
     }
     function spawnTaskSession(kind, keyLabel) {
         const task = selectedTaskOr(keyLabel, 'spawnare');
@@ -637,9 +673,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // devono restare la stessa azione.
     function resumeSession(sessionId) {
         const bound = bindings.get(sessionId) ?? null;
-        const { child, cmd } = spawnDeckResume(bound, cwd, sessionId, sessionNotes.get(sessionId));
-        child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
-        noteCommand(cmd);
+        const spawned = spawnDeckResume(bound, cwd, sessionId, sessionNotes.get(sessionId));
+        spawned.child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
+        noteSpawn(spawned);
     }
     // T57 — ⏎ nel modale: riscrive il binding nel sidecar e ricarica subito.
     //
@@ -865,6 +901,49 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
         }
     }
+    /**
+     * T116 — `^C`: la prima pressione ARMA, la seconda entro la finestra chiude.
+     *
+     * Prima di questa task `^C` usciva subito, e a chiuderlo era Ink stesso
+     * (`exitOnCtrlC`, di default vero) PRIMA che il tasto raggiungesse
+     * `useInput`. Spegnere quell'opzione è la condizione perché il ramo esista —
+     * ma spegnerla e basta lascerebbe il deck senza NESSUNA uscita da tastiera:
+     * il ramo qui sotto è ciò che restituisce quella via, e i due cambi non si
+     * possono separare.
+     *
+     * La prima pressione RIPORTA IN `normal` quando si è dentro un modo
+     * capturing. L'avviso vive nella riga di stato, e le tre schermate
+     * sostitutive (detail, ricerca, reader) prendono l'intero frame senza
+     * renderizzarla: armare restando lì dentro darebbe un deck che sembra
+     * ignorare il tasto e che alla pressione successiva sparisce senza aver mai
+     * avvertito. Chiudere lo strato è anche coerente con `esc` — `^C` dice
+     * «voglio uscire», e il primo passo fuori è la lista.
+     */
+    function onQuitKey() {
+        if (quitTimer.current) {
+            clearTimeout(quitTimer.current);
+            quitTimer.current = null;
+            exit();
+            return;
+        }
+        if (captures(mode))
+            setMode('normal');
+        setNote(QUIT_NOTE);
+        quitTimer.current = setTimeout(() => {
+            quitTimer.current = null;
+            // Solo se l'avviso è ANCORA il proprio: nei 5 secondi una qualunque altra
+            // azione può aver scritto in riga di stato, e cancellare quella nota
+            // significherebbe far sparire il feedback di un'azione che non c'entra.
+            setNote((n) => (n === QUIT_NOTE ? '' : n));
+        }, QUIT_WINDOW_MS);
+    }
+    // Il timer pendente è un handle vivo del loop di Node: lasciarlo appeso allo
+    // smontaggio terrebbe il processo in piedi fino allo scadere della finestra,
+    // con lo schermo già restituito al terminale.
+    useEffect(() => () => {
+        if (quitTimer.current)
+            clearTimeout(quitTimer.current);
+    }, []);
     // Il dispatch consulta il CATALOGO (`input-modes.ts`), non l'ordine di una
     // catena di `if`. `MODE_KEYS` è il custode: essendo un `Record` su
     // `CapturingMode`, un modo nuovo senza handler non compila.
@@ -881,6 +960,17 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         purge: onPurgeKey,
     };
     useInput((input, key) => {
+        // T116 — `^C` sta SOPRA il dispatch dei modi, unico tasto a scavalcarlo.
+        // Ogni altra combo `ctrl` è un acceleratore, e un acceleratore dentro un
+        // modo capturing dev'essere inerte (`input-modes.ts`); questo non è un
+        // acceleratore ma la via d'uscita dal processo, e una via d'uscita che
+        // funziona solo in una schermata su undici non è una via d'uscita. Non è
+        // quindi una deroga di `CTRL_DEROGATIONS` — quelle vivono DENTRO un modo e
+        // le gestisce il modo, questa li precede tutti.
+        if (key.ctrl && input === 'c') {
+            onQuitKey();
+            return;
+        }
         // Un modo capturing consuma TUTTO — acceleratori globali compresi — e le
         // deroghe se le gestisce da sé (`CTRL_DEROGATIONS`). Da qui in giù si è
         // quindi in `normal`, l'unico modo che cede ai `key.ctrl`.
@@ -1043,9 +1133,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                         ...(bound ? { taskId: bound } : {}),
                         forkOf: s.sessionId,
                     });
-                    const { child, cmd } = spawnDeckFork(bound, cwd, s.sessionId, newId);
-                    child.on('error', () => setNote(`⚠ fork fallito (${DECK_RUN})`));
-                    noteCommand(cmd);
+                    const spawned = spawnDeckFork(bound, cwd, s.sessionId, newId);
+                    spawned.child.on('error', () => setNote(`⚠ fork fallito (${DECK_RUN})`));
+                    noteSpawn(spawned);
                 }
             }
         }
@@ -1122,9 +1212,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // Minuscola = azione immediata (convenzione T39), gemella di `t`: entrambe
             // aprono una surface del cappello senza passare da un modale. `C` (create
             // task) resta distinta — stessa lettera, ma la maiuscola è per i modali.
-            const { child, cmd } = spawnClaudeEmpty(cwd);
-            child.on('error', () => setNote(`⚠ c → spawn claude fallito (${DECK_RUN})`));
-            noteCommand(cmd);
+            const spawned = spawnClaudeEmpty(cwd);
+            spawned.child.on('error', () => setNote(`⚠ c → spawn claude fallito (${DECK_RUN})`));
+            noteSpawn(spawned);
         }
         else if (input === 'w') {
             // Salvataggio ESPLICITO: comporre una vista non tocca il disco, così
@@ -1148,11 +1238,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 setNote(`${input} → ${entry.label} su ${projectName}`);
             }
         }
-        // Nessun tasto di uscita: il deck non si chiude da dentro. `q` resta libera
-        // per un binding futuro, `esc` in modalità normale è inerte — dentro un
-        // overlay continua a chiuderlo, perché quel ramo esce prima di qui.
-        // Restano le vie di sistema: `^C` (Ink lo intercetta da sé, `exitOnCtrlC`
-        // di default) e la chiusura della tab Ptyxis che ospita il processo.
+        // Nessun tasto NUDO di uscita: `q` resta libera per un binding futuro, e
+        // `esc` in modalità normale è inerte — dentro un overlay continua a
+        // chiuderlo, perché quel ramo esce prima di qui. L'unica uscita da tastiera
+        // è `^C` battuto due volte (T116, in testa a questo handler); resta poi la
+        // chiusura della tab Ptyxis che ospita il processo.
     });
     const canSpawn = focus === 'tasks' && selTask !== null;
     const canResume = focus === 'sessions' && selSessionObj !== null;
@@ -1325,4 +1415,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     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] }));
 }
 const cwd = process.cwd();
-render(_jsx(Deck, { cwd: cwd, tasksPath: resolveTasksPath(cwd), tasksDir: resolveTasksDir(cwd) }));
+// T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,
+// il tasto non arriverebbe mai a `useInput` e il doppio colpo non sarebbe
+// osservabile. In raw mode `^C` non è un SIGINT — è il byte `\x03` nello
+// stream di input, e chi lo consuma per primo decide. Da qui in poi lo consuma
+// il deck, quindi l'uscita è tutta a carico del suo handler.
+render(_jsx(Deck, { cwd: cwd, tasksPath: resolveTasksPath(cwd), tasksDir: resolveTasksDir(cwd) }), {
+    exitOnCtrlC: false,
+});

package/dist/model.js

@@ -1,4 +1,11 @@
 export const POLL_MS = 1500;
+// Finestra entro cui la SECONDA pressione di `^C` chiude il deck. Scaduta, la
+// prima pressione è dimenticata e la successiva riparte dall'avviso: un `^C`
+// battuto per abitudine mezzo minuto prima non deve poter uscire a insaputa di
+// chi preme. Il valore è anche il tempo per cui l'avviso resta in riga di stato
+// — armamento e messaggio scadono insieme, o la riga prometterebbe un'uscita
+// che il tasto non fa più.
+export const QUIT_WINDOW_MS = 5000;
 // Cap del pane sessioni: le più recenti (ts desc), le altre restano nell'indice
 // ma fuori vista. Non-silenzioso → l'header mostra quante sono nascoste.
 export const MAX_SESSIONS = 30;

package/dist/spawn.js

@@ -61,11 +61,62 @@ export function shellCommand(cmd, args) {
 // I quattro percorsi di spawn di una sessione Claude interattiva differiscono
 // SOLO per l'argv: stesso eseguibile, stesso detached, stesso `unref`. Il corpo
 // sta qui una volta sola, così anche il comando mostrato nasce in un punto solo.
+//
+// stdout in PIPE e non `ignore`: è il canale su cui `deck-run` annuncia il
+// comando in-tab (vedi `onInTabCommand`). Il figlio resta detached — la pipe
+// serve a leggere una riga, non a possedere il processo.
 function launchDeckRun(args, cwd) {
-    const child = spawnOut(DECK_RUN, args, { cwd, detached: true, stdio: 'ignore' });
+    const child = spawnOut(DECK_RUN, args, {
+        cwd,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
     child.unref();
     return { child, cmd: shellCommand(DECK_RUN, args) };
 }
+/** Prefisso della riga con cui `deck-run` annuncia il comando in-tab. */
+export const INTAB_MARKER = 'LOOM_DECK_INTAB ';
+/**
+ * Il comando che gira DENTRO la tab: la sessione `claude` vera, con le env che
+ * la legano a task e progetto (`LOOM_TASK`, `PTYXIS_PROFILE`), il titolo, il
+ * permission mode e il prompt iniziale già quotato.
+ *
+ * Non si compone qui e non si può: lo compone `deck-run`, che è il primitive
+ * dove vivono catalogo dei prompt, quoting, permission mode, profilo di stato e
+ * titolo. Ricostruirlo nel deck sarebbe una seconda scrittura delle stesse
+ * regole, che diverge al primo flag aggiunto da una parte sola — quindi
+ * `deck-run` lo annuncia su stdout prima di `exec` e qui lo si legge.
+ *
+ * Arriva ASINCRONO, millisecondi dopo lo spawn: chi mostra il comando deve
+ * avere già scritto qualcosa (il comando di `deck-run`), perché l'annuncio può
+ * non arrivare affatto — spawn inerte (`LOOM_DECK_NO_SPAWN`, che non ha nemmeno
+ * uno stdout), validazione degli argomenti fallita, `deck-run` morto prima
+ * dell'exec.
+ *
+ * Dopo la riga attesa lo stdout si drena e basta: da lì in poi appartiene a
+ * `ptyxis`, che ha preso il posto del processo.
+ */
+export function onInTabCommand(child, cb) {
+    if (!child.stdout)
+        return;
+    let buf = '';
+    let seen = false;
+    child.stdout.on('data', (chunk) => {
+        if (seen)
+            return;
+        buf += chunk.toString();
+        let nl;
+        while ((nl = buf.indexOf('\n')) >= 0) {
+            const line = buf.slice(0, nl);
+            buf = buf.slice(nl + 1);
+            if (line.startsWith(INTAB_MARKER)) {
+                seen = true;
+                cb(line.slice(INTAB_MARKER.length));
+                return;
+            }
+        }
+    });
+}
 // L'ordine È il giro di `tab` nel detail, non una preferenza di lettura:
 // cambiarlo sposta le voci sotto le dita di chi le ha imparate. Fino a T111 era
 // anche il binding delle cifre `1`-`4`, passate poi al campo nota.

package/package.json

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

package/scripts/deck-run

@@ -29,6 +29,12 @@
 # riprende RAMANDOLA (`--fork-session`): id nuovo, transcript copiato, l'origine
 # resta intatta e scrivibile.
 #
+# Su stdout, prima di aprire la tab, stampa una riga
+#   LOOM_DECK_INTAB <comando>
+# col comando che girerà DENTRO la tab (la sessione `claude` con le sue env).
+# Serve a chi spawna deck-run e vuole mostrare l'invocazione vera senza
+# ricomporla per conto proprio; le diagnostiche restano tutte su stderr.
+#
 # Modalità spawn (LOOM_DECK_SPAWN_MODE):
 #   inline   → ptyxis --tab -- <cmd>            (default)  comando inline, LOOM_TASK diretta, zero dconf
 #   profile  → ptyxis --tab-with-profile=<UUID>            riusa il profilo, riscrive il custom-command via dconf
@@ -440,6 +446,24 @@ else
 fi
 IN_TAB_CMD="${LOOM_DECK_INTAB_CMD:-$_default_intab}"
 
+# ANNUNCIO del comando in-tab, su stdout, prima dell'exec.
+#
+# È l'unico modo che ha un chiamante di sapere cosa gira davvero dentro la tab:
+# il comando si compone QUI — catalogo dei prompt, quoting, permission mode,
+# profilo di stato, titolo — e ricomporlo dall'altro lato sarebbe una seconda
+# scrittura delle stesse regole, divergente al primo flag aggiunto. Il deck lo
+# legge da questa riga e la mostra nella propria riga di stato.
+#
+# Deve stare DOPO l'ultima assegnazione di IN_TAB_CMD e PRIMA dell'exec (che
+# sostituisce il processo): annunciare un valore ancora modificabile
+# annuncerebbe qualcosa di diverso da quello eseguito.
+#
+# stdout e non stderr: qui non c'è nessuna anomalia da segnalare, è l'esito
+# normale del lavoro dello script. Le diagnostiche restano su stderr, e i
+# chiamanti che leggono l'ULTIMA riga di stdout (lo shim `ptyxis` dei test)
+# vedono comunque quello che vedevano prima.
+printf 'LOOM_DECK_INTAB %s\n' "$IN_TAB_CMD"
+
 case "$MODE" in
   inline)
     # --tab: tab nella window attiva. -- <cmd>: comando inline nella tab.