@lamemind/loom-deck 0.19.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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { render, Box, Text, useApp, useInput, useStdout } from 'ink';
 import { useState, useEffect, useMemo, useRef } from 'react';
 import { spawn } from 'node:child_process';
@@ -15,7 +15,7 @@ import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, loadSess
 import { assembleSessionList, firstSelectableId, moveSelection, rowIndexOf, rowLabel, selectedSession, stripProjectCore, } from './session-list.js';
 import { launchLegend, loadIdentity, loadLaunch } from './config.js';
 import { isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
-import { cut, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
+import { caretWindow, cut, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, progressText, writeTaskEdit, PRI_GLYPH, PRI_LABEL, PROG_GLYPH, } from './task-edit.js';
 import { loadView, saveView, viewFilePath } from './view-store.js';
@@ -35,6 +35,31 @@ const EDIT_ROWS = 4;
 function isTextRow(r) {
     return r === 2 || r === 3;
 }
+/** Chiave della bozza scritta dalla riga di testo `r`. */
+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
+ * che si ferma a metà glifo e un `slice` che lo spezza in due surrogati.
+ */
+function cpLen(s) {
+    return [...s].length;
+}
+/** Inserisce `ins` alla posizione `at` (code point). */
+function insertAt(s, at, ins) {
+    const cp = [...s];
+    return cp.slice(0, at).join('') + ins + cp.slice(at).join('');
+}
+/** Toglie il code point in posizione `at`; fuori range = stringa invariata. */
+function removeAt(s, at) {
+    const cp = [...s];
+    if (at < 0 || at >= cp.length)
+        return s;
+    cp.splice(at, 1);
+    return cp.join('');
+}
 // Modale sort a grammatica libera: un tasto per chiave, pressioni successive
 // ciclano asc → desc → fuori dalla chain.
 const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id' };
@@ -95,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',
@@ -618,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
@@ -669,6 +727,9 @@ 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);
         setNote('');
@@ -1026,11 +1087,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             else if (key.return) {
                 submitEdit();
             }
-            else if (key.upArrow) {
-                setEditRow((r) => ((r + EDIT_ROWS - 1) % EDIT_ROWS));
-            }
-            else if (key.downArrow) {
-                setEditRow((r) => ((r + 1) % EDIT_ROWS));
+            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;
@@ -1049,16 +1112,48 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 // 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 = editRow === 2 ? 'detail' : 'title';
-                if (key.backspace || key.delete) {
-                    setEdit((e) => (e ? { ...e, [field]: e[field].slice(0, -1) } : e));
+                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.ctrl && !key.meta) {
+                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.
-                    setEdit((e) => (e ? { ...e, [field]: e[field] + sanitizeTyped(input) } : e));
+                    // 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);
                 }
             }
             return;
@@ -1076,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) {
@@ -1095,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
@@ -1345,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 \u00B7", ' ', _jsx(Text, { color: "yellow", children: "testo" }), " su prog/titolo \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:
@@ -1368,31 +1463,17 @@ function FilterModal({ view, cursor }) {
                     })] }, row.label)))] }));
 }
 /**
- * Taglio dalla TESTA: tiene la CODA della stringa dentro `cols`.
+ * Campo di testo del modale edit: finestra ancorata al caret + cursore inverso
+ * nella posizione REALE.
  *
- * `cut()` fa l'opposto (tiene l'inizio) ed è giusto per un testo che si LEGGE;
- * qui il testo si SCRIVE, il cursore sta in fondo (append-only come gli altri
- * campi del deck) e ciò che serve vedere è l'ultima parola digitata, non la
- * prima — con `cut()` un titolo lungo sparirebbe sotto l'ellissi proprio mentre
- * lo si sta scrivendo. Budget in COLONNE (`termWidth`), non in code unit: è
- * quello che decide se la riga sfonda il bordo del box.
+ * Il cursore non è più uno spazio inverso appiccicato in coda ma la cella `at`
+ * della finestra — cioè il carattere su cui il caret sta davvero. Fuori fuoco
+ * (`focused` falso) il caret non si disegna e la finestra si ancora in fondo,
+ * che è la vista utile per un campo che non si sta scrivendo.
  */
-function tailCut(s, cols) {
-    if (cols <= 0)
-        return '';
-    if (termWidth(s) <= cols)
-        return s;
-    const chars = [...s];
-    let out = '';
-    let w = 1; // la colonna dell'ellissi di testa
-    for (let i = chars.length - 1; i >= 0; i--) {
-        const cw = termWidth(chars[i]);
-        if (w + cw > cols)
-            break;
-        out = chars[i] + out;
-        w += cw;
-    }
-    return `…${out}`;
+function EditTextField({ label, value, caret, focused, cols, }) {
+    const win = caretWindow(value, focused ? caret : cpLen(value), cols);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: label }), _jsxs(Text, { children: ['  ', sanitize(win.head)] }), focused ? _jsx(Text, { inverse: true, children: sanitize(win.at) }) : null, _jsx(Text, { children: sanitize(win.tail) })] }));
 }
 // T41 — modale edit, in flusso come gli altri (spinge giù i pane invece di
 // coprirli: la riga che stai modificando resta visibile sopra la lista).
@@ -1400,14 +1481,14 @@ function tailCut(s, cols) {
 // del task file — così il default (`✔️ Done at <oggi>`) non è una sorpresa.
 function EditModal({ id, draft, row, columns, }) {
     const mark = (r) => (row === r ? CARET : CARET_OFF);
-    // Budget del campo titolo, DERIVATO da `columns` (mai una costante): il box
+    // Budget dei campi di testo, DERIVATO da `columns` (mai una costante): il box
     // del modale è ANNIDATO nella cornice del deck, quindi le cornici da scalare
     // sono due — root (bordo 2 + paddingX 2) e modale (bordo 2 + paddingX 2) — più
     // caret 2, etichetta 6, gap 2 e cursore 1. Totale 19.
     // Un titolo di tasks.md arriva a ~64 caratteri: senza taglio la riga va a capo
     // dentro il box, che si alza di una riga e sfonda il budget verticale (invariante ③).
-    const titleBudget = Math.max(8, columns - 19);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 titolo, priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri   " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', sanitize(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato " }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', sanitize(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(Text, { dimColor: true, children: "prog  " }), _jsxs(Text, { children: ['  ', sanitize(draft.detail)] }), row === 2 ? _jsx(Text, { inverse: true, children: " " }) : null, !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { children: [mark(3), _jsx(Text, { dimColor: true, children: "titolo" }), _jsxs(Text, { children: ['  ', sanitize(tailCut(draft.title, titleBudget))] }), row === 3 ? _jsx(Text, { inverse: true, children: " " }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", sanitize(progressText(draft.prog, draft.detail))] })] }));
+    const fieldBudget = Math.max(8, columns - 19);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 titolo, priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri   " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', sanitize(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato " }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', sanitize(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(EditTextField, { label: "prog  ", value: draft.detail, caret: draft.caret, focused: row === 2, cols: fieldBudget }), !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { children: [mark(3), _jsx(EditTextField, { label: "titolo", value: draft.title, caret: draft.caret, focused: row === 3, cols: fieldBudget })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", sanitize(progressText(draft.prog, draft.detail))] })] }));
 }
 // T52 — marcatore compatto del tipo di corpo sulla riga-occorrenza. Due
 // caratteri ASCII e non un'emoji: con più toggle accesi la colonna deve

package/dist/width.js

@@ -202,6 +202,102 @@ export function cut(s, cols) {
     // informazione, tolgono una colonna di testo.
     return out.trimEnd().replace(/…$/, '') + '…';
 }
+/**
+ * Larghezza in colonne di UN carattere **dopo** `sanitize`.
+ *
+ * Misurare il carattere grezzo significa misurare qualcosa che nel frame non
+ * entra mai: la sanificazione può cambiarne la larghezza (`✔`, largo 1, diventa
+ * `✅`, largo 2 — invariante ①). Chi taglia su un budget deve contare le colonne
+ * che verranno DISEGNATE, altrimenti sbaglia di una colonna per ogni glifo
+ * sostituito. La cache di `fixChar` rende la doppia chiamata gratuita.
+ */
+export function cellWidth(ch) {
+    return termWidth(sanitize(ch));
+}
+/**
+ * Porzione visibile di un campo di testo con un caret MOBILE, larga al più
+ * `cols` colonne.
+ *
+ * Perché non basta un taglio dalla coda: mostrare sempre le ultime `cols`
+ * colonne è corretto solo finché si scrive in fondo. Con un caret che si muove,
+ * appena rientra a sinistra del bordo visibile si finirebbe per digitare in un
+ * punto che non si vede — il testo deve scorrere DIETRO il cursore, non
+ * viceversa.
+ *
+ * Il caret è un indice per CODE POINT (`[...s]`), non per code unit: un'emoji
+ * nel titolo sono due code unit e muoversi per unità la spezzerebbe a metà.
+ *
+ * La finestra si espande ALTERNANDO i due lati, così il cursore resta al centro
+ * finché il testo lo consente: muoversi di un carattere fa scorrere il testo di
+ * uno, invece di far saltare la vista da un bordo all'altro. Le ellissi entrano
+ * nel budget e ne escono da sole — quando un lato tocca il bordo del testo la
+ * sua ellissi non serve più e la colonna liberata va all'altro lato.
+ *
+ * Restituisce i tre pezzi già pronti al render (non la sola stringa visibile):
+ * il cursore si disegna invertendo `at`, e ricavarlo tagliando `visible` a
+ * `cursorCol` vorrebbe dire rifare qui fuori lo stesso conteggio in colonne.
+ */
+export function caretWindow(text, caret, cols) {
+    const empty = { head: '', at: '', tail: '', cursorCol: 0 };
+    if (cols <= 0)
+        return empty;
+    const chars = [...text];
+    const c = Math.max(0, Math.min(caret, chars.length));
+    // Il caret a fine campo non ha un carattere sotto di sé: gliene si dà uno
+    // virtuale, così il cursore ha sempre una cella da invertire e la finestra ha
+    // sempre un centro. È lo spazio inverso che il modale disegnava in coda.
+    const cells = c === chars.length ? [...chars, ' '] : chars;
+    const len = cells.length;
+    const w = cells.map(cellWidth);
+    const cost = (s, e, tw) => tw + (s > 0 ? 1 : 0) + (e < len ? 1 : 0);
+    let start = c;
+    let end = c + 1;
+    let textW = w[c];
+    // Budget più stretto della sola cella del cursore: non c'è finestra da dare.
+    if (cost(start, end, textW) > cols)
+        return empty;
+    let goRight = true;
+    let stuckL = false;
+    let stuckR = false;
+    while (!stuckL || !stuckR) {
+        const canR = end < len && !stuckR;
+        const canL = start > 0 && !stuckL;
+        if (!canR && !canL)
+            break;
+        if (canR && (goRight || !canL)) {
+            const nw = textW + w[end];
+            if (cost(start, end + 1, nw) > cols)
+                stuckR = true;
+            else {
+                textW = nw;
+                end++;
+                // Arrivare in fondo toglie l'ellissi di coda: la colonna che si libera
+                // può rimettere in gioco il lato che si era fermato per un pelo.
+                if (end === len)
+                    stuckL = false;
+            }
+        }
+        else {
+            const nw = textW + w[start - 1];
+            if (cost(start - 1, end, nw) > cols)
+                stuckL = true;
+            else {
+                textW = nw;
+                start--;
+                if (start === 0)
+                    stuckR = false;
+            }
+        }
+        goRight = !goRight;
+    }
+    const head = (start > 0 ? '…' : '') + cells.slice(start, c).join('');
+    return {
+        head,
+        at: cells[c],
+        tail: cells.slice(c + 1, end).join('') + (end < len ? '…' : ''),
+        cursorCol: termWidth(sanitize(head)),
+    };
+}
 /**
  * Indice sorgente raggiunto consumando al più `cols` colonne da `from`.
  *

package/package.json

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