@lamemind/loom-deck 0.20.0 → 0.21.0

package/README.md

@@ -4,15 +4,19 @@ Deck TUI (Ink) **per-progetto** della famiglia [loom](https://github.com/lamemin
 
 Legge il `tasks.md` del progetto e, con un tasto (poi un click), **spawna** una tab
 [Ptyxis](https://gitlab.gnome.org/chergert/ptyxis) che avvia una sessione Claude Code
-già bound alla task via `LOOM_TASK`, con un prompt di recap sullo stato della task.
+già bound alla task via `LOOM_TASK`.
 
 ```
-↑↓ scegli la task  →  ⏎  →  tab CC di fianco  →  LOOM_TASK bound + recap stato task
+↑↓ scegli la task  →  ⏎  →  tab CC di fianco  →  LOOM_TASK bound
 ```
 
+Il tasto premuto sceglie **con quale prompt** si entra: `⏎` a mani nude, `^K`
+recap, `^P` preflight, `^R` esecuzione (vedi [I quattro modi di entrare in una
+task](#i-quattro-modi-di-entrare-in-una-task)).
+
 Entrambi i prefissi del contratto loom entrano in lista: **`T`** (code task) e
-**`D`** (doc task). Nessuna differenza di trattamento — il prompt iniziale è un
-recap, non l'invocazione di una skill, quindi vale identico sulle due famiglie.
+**`D`** (doc task). Il trattamento è identico ovunque tranne che su `^R`, dove il
+prompt dispatcha sulla skill di esecuzione della rispettiva famiglia.
 
 ## Ruolo nella famiglia loom
 
@@ -52,10 +56,10 @@ senza collisioni:
 |---|---|---|
 | `↑` `↓` | naviga nella lista | |
 | `←` `→` `tab` | cambia pane | |
-| `⏎` | azione primaria del pane | Tasks → spawna la task selezionata · Sessions → riprende (`claude --resume`) la sessione selezionata |
+| `⏎` | azione primaria del pane | Tasks → spawna la task selezionata (senza prompt) · Sessions → riprende (`claude --resume`) la sessione selezionata |
 | **MAIUSCOLA** | **apre un modale** | cattura tutti i tasti; `esc` annulla, non esce |
 | minuscola | azione immediata, one-shot | |
-| `CTRL`+lettera | idiomi universali e toggle dentro i modali di testo | `^F` = find, come ovunque |
+| `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` |
 | `q` `esc` | esce dal deck | in un modale `esc` annulla soltanto |
 
@@ -75,6 +79,9 @@ Assegnazioni correnti:
 | modale | `S` | sort chain |
 | modale | `F` | filtri |
 | modale | `^F` | **ricerca full-text** nelle conversazioni del progetto |
+| immediata | `^K` | spawna la task selezionata col prompt di **recap** |
+| immediata | `^P` | spawna la task selezionata sul **preflight** |
+| immediata | `^R` | spawna la task selezionata in **esecuzione** |
 | immediata | `f` | **forka** la sessione selezionata (solo col focus sul pane Sessions) |
 | immediata | `t` | terminale @project-root (surface standard launch) |
 | immediata | `c` | sessione Claude **nuda**: nessuna task, nessun prompt iniziale |
@@ -94,6 +101,34 @@ finestra Ptyxis, senza passare da un modale. `c` (minuscola, azione) e `C`
 (maiuscola, modale create-task) restano distinte per la regola sopra — così come
 `f` (fork) e `F` (filtri).
 
+### I quattro modi di entrare in una task
+
+Sulla task selezionata (focus sul pane Tasks) quattro tasti aprono una sessione
+**bound**: `LOOM_TASK` iniettata, `sessionId` pinnato, binding scritto nel
+sidecar. Fra loro cambia **solo il prompt iniziale**.
+
+| Tasto | Prompt |
+|---|---|
+| `⏎` | nessuno — il contesto lo carica l'hook `SessionStart`, il primo messaggio lo scrivi tu |
+| `^K` | `recap stato task <id>` — prompt diretto, nessuna skill |
+| `^P` | `/loom-works:preflight-task <id>` |
+| `^R` | `/loom-works:run-task <id>`, oppure `/loom-works:run-doc <id>` se l'id è una `D` |
+
+Il prompt iniziale è la scelta di **chi apre**, non una proprietà della task: lo
+stesso task file si apre per leggerne lo stato, per congelarne le decisioni, per
+eseguirlo o per entrarci a mani nude — e il tasto premuto *è* quell'intento.
+Prima esisteva il solo `⏎` col recap, quindi ogni altro ingresso passava per una
+sessione da correggere a mano.
+
+Col focus sul pane Sessions i tre `CTRL` non spawnano: l'oggetto dell'azione è la
+task selezionata, e senza quel pane a fuoco non ce n'è una (il deck lo dice nella
+riga di nota, invece di aprire qualcosa a caso).
+
+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.
+
 ### `f` — forkare una conversazione
 
 Il fork rama la sessione selezionata: `claude --resume <origine> --fork-session`
@@ -241,16 +276,21 @@ npx @lamemind/loom-deck
 ```bash
 # dalla project dir con un tasks.md
 scripts/deck-run T18
+scripts/deck-run T18 --prompt-kind none|recap|preflight|run
 ```
 
-Apre una tab Ptyxis nella window attiva con `LOOM_TASK=T18 claude 'recap stato task T18'`
-(prompt override-abile via `LOOM_DECK_ENTER_PROMPT`, placeholder `{TASK}`).
+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.
 
 ## Sviluppo (TUI Ink)
 
 ```bash
 npm install
-npm run dev      # tsx src/cli.tsx — lista tasks.md reale, ↑↓ naviga · ⏎ spawn · q esci
+npm run dev      # tsx src/cli.tsx — lista tasks.md reale, ↑↓ naviga · ⏎/^K/^P/^R spawn · q esci
 npm run build    # tsc → dist/
 npm test         # node:test sul core vista (src/view.ts), senza Ink né terminale
 ```

package/dist/cli.js

@@ -120,8 +120,11 @@ function spawnOut(cmd, args, opts) {
 // Spawn detached: il deck spawna ma NON contiene la sessione (la possiede
 // ptyxis-agent). unref + stdio ignore → ritorna subito, la TUI resta viva.
 // sessionId pinnato (T27) → il binding sidecar è deterministico allo spawn.
-function spawnDeck(id, cwd, sessionId) {
-    const child = spawnOut(DECK_RUN, [id, '--session-id', sessionId], {
+// Il kind è OBBLIGATORIO e non ha default qui: il default vive in deck-run (per
+// le invocazioni a mano), mentre dal deck ogni tasto dichiara il proprio intento
+// — un default silenzioso renderebbe indistinguibili `⏎` e `^K`.
+function spawnDeck(id, cwd, sessionId, kind) {
+    const child = spawnOut(DECK_RUN, [id, '--session-id', sessionId, '--prompt-kind', kind], {
         cwd,
         detached: true,
         stdio: 'ignore',
@@ -643,6 +646,36 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         });
         child.on('error', () => setNote(`⚠ create-task: '${CLAUDE_CMD}' non lanciabile`));
     }
+    // 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
+    // risulta figlia della task appena il JSONL compare), handler d'errore, nota.
+    // Quattro copie sarebbero quattro posti dove dimenticare il `child.on('error')`,
+    // e uno spawn fallito è async: senza handler diventa uncaughtException e
+    // ucciderebbe il deck, che invece deve restare vivo.
+    // La guardia di focus sta qui e non nei chiamanti perché l'oggetto dell'azione
+    // è la task SELEZIONATA: senza il pane task a fuoco non ce n'è una. Per `⏎` il
+    // ramo è irraggiungibile (ci arriva già dentro `focus === 'tasks'`); per i tre
+    // CTRL, che il ramo `key.ctrl` intercetta globalmente, è l'unico posto.
+    function spawnTaskSession(kind, keyLabel) {
+        if (focus !== 'tasks') {
+            setNote(`${keyLabel} → spawn: seleziona una task (←→ per il pane)`);
+            return;
+        }
+        if (isSpot) {
+            setNote('spot: sessioni libere, nessuna task da spawnare');
+            return;
+        }
+        if (!selTask)
+            return;
+        const task = selTask;
+        const sid = randomUUID();
+        appendTaskBinding(cwd, sid, task.id);
+        const child = spawnDeck(task.id, cwd, sid, kind);
+        child.on('error', () => setNote(`⚠ spawn ${task.id} fallito (${DECK_RUN})`));
+        const what = kind === 'none' ? '' : ` · ${kind}`;
+        setNote(`${keyLabel} spawn ${task.id}${what} → tab CC (sid ${sid.slice(0, 8)})`);
+    }
     // T53 — apertura del modale nota sulla conversazione selezionata. Come
     // `openEdit`, la bozza parte dal valore ATTUALE: annotare una seconda volta è
     // quasi sempre correggere, e ripartire da vuoto costringerebbe a ridigitare
@@ -1138,6 +1171,15 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 setNote('');
                 setMode('search');
             }
+            else if (input === 'k') {
+                spawnTaskSession('recap', '^K');
+            }
+            else if (input === 'p') {
+                spawnTaskSession('preflight', '^P');
+            }
+            else if (input === 'r') {
+                spawnTaskSession('run', '^R');
+            }
             return;
         }
         if (key.leftArrow || key.rightArrow || key.tab) {
@@ -1157,21 +1199,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         }
         else if (key.return) {
             if (focus === 'tasks') {
-                if (isSpot) {
-                    setNote('spot: sessioni libere, nessuna task da spawnare');
-                }
-                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)})`);
-                }
+                // T56 — ⏎ apre la sessione a MANI NUDE: bound alla task (LOOM_TASK,
+                // sessionId pinnato, binding) ma senza messaggio iniettato — il contesto
+                // lo carica l'hook SessionStart, il primo messaggio lo scrive l'utente.
+                // Il recap che ⏎ faceva prima è passato a ^K: resta a un tasto, ma smette
+                // di essere l'unico ingresso possibile nella task.
+                spawnTaskSession('none', '⏎');
             }
             else {
                 // T49 — ⏎ su una sessione = resume in nuova tab. Il binding si rilegge
@@ -1407,7 +1440,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: [' ', "\u00B7 ", viewTasks.length, " task \u00B7 sel ", selectedTaskId ?? 'spot', " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga"] })] }));
     }
-    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, 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 === '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"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : canResume ? 'resume' : '—', canResume ? ' · f fork' : '', canPin ? ' · p pin · N nota' : '', " \u00B7 ^F cerca \u00B7 C nuova \u00B7 E edit \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7 t term \u00B7 c claude \u00B7 q esci \u00B7 focus:", ' ', _jsx(Text, { color: "cyan", children: focus })] })), mode === 'normal' && launch.length > 0 ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["launch ", 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, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+    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, 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 === '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"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7", ' ', canSpawn ? '⏎/^K/^P/^R spawn' : canResume ? '⏎ resume' : '⏎ —', canResume ? ' · f fork' : '', canPin ? ' · p pin · N nota' : '', " \u00B7 ^F cerca \u00B7 C nuova \u00B7 E edit \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7 t term \u00B7 c claude \u00B7 q esci \u00B7 focus:", ' ', _jsx(Text, { color: "cyan", children: focus })] })), mode === 'normal' && launch.length > 0 ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["launch ", 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, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(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:

package/package.json

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

@@ -4,8 +4,20 @@
 #
 # Apre una tab Ptyxis nella window ATTIVA (quella col focus = il deck) e vi
 # avvia una sessione Claude Code già bound alla task via LOOM_TASK, dritta sul
-# prompt iniziale (default: prompt diretto "recap stato task <TaskID>" — no skill,
-# solo recap → più controllo). Riusabile identico da TUI (Ink) e da web.
+# prompt iniziale scelto con --prompt-kind (default: `recap`, prompt diretto
+# "recap stato task <TaskID>" — no skill, solo recap → più controllo).
+# Riusabile identico da TUI (Ink) e da web.
+#
+# Tre assi ORTOGONALI, da non confondere fra loro:
+#   binding task   <TaskID> ..... --no-task
+#   continuità     nuova ........ --resume [--fork]
+#   prompt         --prompt-kind none|recap|preflight|run
+# Il terzo asse (T56) prima non esisteva: il prompt era una CONSEGUENZA degli
+# altri due (bound ⇒ recap, --no-task ⇒ niente, --resume ⇒ niente), quindi
+# "task-bound SENZA prompt" era inesprimibile e l'unico modo di non avere un
+# prompt era perdere la task. Il catalogo dei prompt vive qui e non nel deck
+# perché questo è il primitive UI-agnostico: il chiamante passa un SIMBOLO, non
+# una stringa — il quoting resta verificato in un posto solo (vedi PROMPT sotto).
 #
 # Con --no-task la sessione è NUDA: niente LOOM_TASK, niente prompt iniziale,
 # niente --session-id. Serve al lavoro spot che non appartiene a nessuna task.
@@ -26,7 +38,7 @@
 #   LOOM_DECK_SPAWN_MODE   inline|profile          (default: inline)
 #   LOOM_DECK_PROFILE_UUID UUID profilo Ptyxis     (default: cc-host)
 #   LOOM_DECK_WORKDIR      dir di lavoro della tab (default: $PWD)
-#   LOOM_DECK_ENTER_PROMPT prompt iniziale sessione, {TASK}=TaskID (default: "recap stato task <TaskID>")
+#   LOOM_DECK_ENTER_PROMPT override del prompt iniziale, {TASK}=TaskID (vince sul kind, tranne `none`)
 #   LOOM_DECK_INTAB_CMD    override comando in-tab (default: la sessione CC; usato per i test)
 #   LOOM_DECK_PERMISSION_MODE  override del permissionMode del file config (default: campo file, poi 'manual')
 #
@@ -37,6 +49,10 @@ SESSION_ID=""
 RESUME_ID=""
 NO_TASK=0
 FORK=0
+# Vuoto = flag non passato (≠ un default già risolto): serve a distinguere
+# "kind implicito" da "kind chiesto", perché con --no-task il primo è legittimo
+# (nessun prompt, come sempre) e il secondo è un errore d'uso.
+PROMPT_KIND=""
 # Positional <TaskID> + flag opzionale --session-id <uuid> (T27): il deck genera
 # l'UUID e lo pinna così il binding sidecar sessionId↔taskId è deterministico.
 # --no-task (T42): modalità NUDA, senza TaskID — nessuna LOOM_TASK, nessun prompt
@@ -55,8 +71,17 @@ FORK=0
 # Sotto --fork il --session-id torna AMMESSO (anzi: è il punto) — la mutua
 # esclusione con --resume esiste perché una ripresa nuda riscrive il transcript
 # dell'id ripreso, mentre il fork ne apre uno NUOVO, che possiamo quindi pinnare.
+# --prompt-kind <none|recap|preflight|run> (T56): sceglie il prompt iniziale fra
+# quelli del catalogo qui sotto. Enum e non stringa libera: il prompt viaggia
+# dentro apici singoli in `bash -lc`, quindi il testo va tenuto in un posto solo
+# e verificato una volta, invece di spostare il rischio di quoting su ogni
+# chiamante. Assente → `recap`, così ogni invocazione preesistente è invariata.
 while [[ $# -gt 0 ]]; do
   case "$1" in
+    --prompt-kind)
+      PROMPT_KIND="${2:-}"; shift 2 ;;
+    --prompt-kind=*)
+      PROMPT_KIND="${1#*=}"; shift ;;
     --session-id)
       SESSION_ID="${2:-}"; shift 2 ;;
     --session-id=*)
@@ -75,12 +100,19 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-USAGE="uso: deck-run <TaskID> [--session-id <uuid>]   (es. deck-run T18)
+USAGE="uso: deck-run <TaskID> [--prompt-kind <kind>] [--session-id <uuid>]
+                                                   (es. deck-run T18)
      | deck-run --no-task                          (sessione nuda, senza task)
      | deck-run <TaskID> --resume <uuid>           (riprende sessione scoped)
      | deck-run --no-task --resume <uuid>          (riprende sessione spot)
      | deck-run <TaskID> --resume <uuid> --fork [--session-id <nuovo-uuid>]
-                                                   (forka: ramo con id NUOVO)"
+                                                   (forka: ramo con id NUOVO)
+
+  --prompt-kind  prompt iniziale della sessione bound (default: recap)
+       none        nessun prompt — sessione aperta sulla task, a mani nude
+       recap       recap stato task <TaskID>
+       preflight   /loom-works:preflight-task <TaskID>
+       run         /loom-works:run-task <TaskID>  (run-doc sulle task D)"
 
 if [[ $NO_TASK -eq 1 && -n "$TASK" ]]; then
   echo "--no-task e <TaskID> sono mutuamente esclusivi" >&2
@@ -102,6 +134,25 @@ if [[ -n "$RESUME_ID" && -n "$SESSION_ID" && $FORK -eq 0 ]]; then
   echo "$USAGE" >&2
   exit 2
 fi
+# Un kind fuori catalogo è un errore d'uso del CHIAMANTE (simbolo interno, non
+# configurazione utente) → exit, non fallback silenzioso come permissionMode:
+# lì il valore arriva da un file editabile a mano, qui da un argomento nostro.
+if [[ -n "$PROMPT_KIND" ]]; then
+  case "$PROMPT_KIND" in
+    none|recap|preflight|run) ;;
+    *) echo "--prompt-kind ignoto: '${PROMPT_KIND}' (usa none|recap|preflight|run)" >&2
+       echo "$USAGE" >&2
+       exit 2 ;;
+  esac
+fi
+# Ogni prompt del catalogo nomina il TaskID: senza task non c'è nulla da
+# chiedere, e un `--no-task --prompt-kind run` è una richiesta contraddittoria,
+# non una da degradare in silenzio.
+if [[ $NO_TASK -eq 1 && -n "$PROMPT_KIND" ]]; then
+  echo "--prompt-kind richiede una task: una sessione --no-task non ha prompt iniziale" >&2
+  echo "$USAGE" >&2
+  exit 2
+fi
 
 MODE="${LOOM_DECK_SPAWN_MODE:-inline}"
 PROFILE_UUID="${LOOM_DECK_PROFILE_UUID:-5a36ae48df1c4d4882f43060e3e59656}"
@@ -189,18 +240,42 @@ RES_FLAG=""
 FORK_FLAG=""
 [[ $FORK -eq 1 ]] && FORK_FLAG="--fork-session "
 
-# Prompt iniziale della sessione. Default: prompt DIRETTO (no skill) che chiede
-# a Claude un recap dello stato della task — l'utente rivede/steera prima di
-# lanciare (= più controllo), nessuna esecuzione automatica. Override completo via
-# LOOM_DECK_ENTER_PROMPT, con placeholder {TASK} rimpiazzato dal TaskID. Vincolo: il
-# template NON deve contenere apici singoli (viaggia dentro '...' nel comando in-tab).
-# NB: il default NON può stare nel `${VAR:-...}` perché conterrebbe `{TASK}` e la sua
-# `}` chiuderebbe in anticipo l'espansione → if/else esplicito (default interpola
-# ${TASK} diretto; il placeholder {TASK} vale solo per il valore dell'override).
-if [[ -n "${LOOM_DECK_ENTER_PROMPT:-}" ]]; then
+# ── Catalogo dei prompt iniziali (T56) ───────────────────────────────────────
+# Il prompt iniziale è la scelta di CHI APRE la sessione, non una proprietà della
+# task: lo stesso task file si apre per leggerne lo stato, per un preflight, per
+# eseguirlo o a mani nude. Il kind è quell'intento.
+#   none      → nessun prompt (≠ stringa vuota: PROMPT_ARG sparisce del tutto,
+#               come sul ramo --resume, altrimenti CC riceve un posizionale vuoto)
+#   recap     → prompt DIRETTO, no skill: l'utente rivede/steera prima di lanciare
+#   preflight → skill di preflight sulla task
+#   run       → skill di esecuzione sulla task
+# Vincolo di quoting: nessun template deve contenere apici singoli (viaggia
+# dentro '...' nel comando in-tab). `/loom-works:...` passa intero proprio perché
+# è single-quoted — lo slash e i due punti non sono metacaratteri lì dentro.
+#
+# Precedenza con l'env: LOOM_DECK_ENTER_PROMPT VINCE sul kind (retro-compat: chi
+# lo usa oggi non si accorge del cambio), tranne su `none` — chiedere
+# esplicitamente nessun prompt non è una richiesta che un default d'ambiente
+# possa scavalcare. Il placeholder {TASK} vale solo per il valore dell'override;
+# i template del catalogo interpolano ${TASK} diretto (nel `${VAR:-...}` la `}`
+# di `{TASK}` chiuderebbe in anticipo l'espansione).
+# `run` DISPATCHA sul prefisso: la lista del deck contiene entrambe le famiglie
+# del contratto loom (`T` code, `D` doc) e le due hanno skill di esecuzione
+# diverse — `run-task` è dichiarata code-only, `run-doc` è la sua complementare.
+# Su una D il prompt `run-task` invocherebbe la skill sbagliata. Gli altri kind
+# non discriminano: `recap` è un prompt diretto (nessuna skill) e
+# `preflight-task` risolve il task file per id, indifferente al prefisso.
+case "${PROMPT_KIND:-recap}" in
+  none)      PROMPT="" ;;
+  recap)     PROMPT="recap stato task ${TASK}" ;;
+  preflight) PROMPT="/loom-works:preflight-task ${TASK}" ;;
+  run)       case "$TASK" in
+               D*) PROMPT="/loom-works:run-doc ${TASK}" ;;
+               *)  PROMPT="/loom-works:run-task ${TASK}" ;;
+             esac ;;
+esac
+if [[ "${PROMPT_KIND:-}" != "none" && -n "${LOOM_DECK_ENTER_PROMPT:-}" ]]; then
   PROMPT="${LOOM_DECK_ENTER_PROMPT//\{TASK\}/${TASK}}"
-else
-  PROMPT="recap stato task ${TASK}"
 fi
 
 # Comando eseguito dentro la tab: bind LOOM_TASK per la sessione, avvia CC sul PROMPT.
@@ -213,8 +288,10 @@ fi
 # Su resume (T49) il prompt iniziale salta anche nel ramo task: riprendere una
 # conversazione significa continuarla, non iniettarle un nuovo messaggio. Il
 # fork (T28) ricade nello stesso ramo — è una ripresa, con id nuovo.
-PROMPT_ARG="'${PROMPT}'"
-[[ -n "$RESUME_ID" ]] && PROMPT_ARG=""
+# Il kind `none` (T56) atterra sulla stessa assenza per una ragione diversa: lì
+# la sessione è nuova e bound, ma l'utente ha chiesto di entrarci a mani nude.
+PROMPT_ARG=""
+[[ -n "$PROMPT" && -z "$RESUME_ID" ]] && PROMPT_ARG="'${PROMPT}'"
 # Il SID_FLAG entra anche nel ramo --no-task, che altrimenti lo scarta insieme
 # agli altri elementi task-bound: nel fork di una sessione SPOT il sessionId
 # pinnato non serve a legare una task (non c'è) ma a rendere noto in anticipo