@lamemind/loom-deck 0.44.0 → 0.46.0

package/dist/overlays/sheet.js

@@ -18,7 +18,20 @@ import { scanText, topForOffset } from '../text-search.js';
 import { parseMarkdown } from '../markdown.js';
 import { cpLen, insertAt, removeAt } from '../layout.js';
 import { sanitizeTyped } from '../glyphs.js';
-import { DETAIL_ACTIONS, MODELS, MODEL_DEFAULT } from '../spawn.js';
+import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, } from '../spawn.js';
+import { fieldsKey } from '../fields.js';
+import { loadPromptCatalog, promptFor } from '../prompt-catalog.js';
+// T117 — le quattro righe dell'area di compilazione del detail, nell'ordine in
+// cui si leggono dall'alto. Gli indici sono nominati perché li usano insieme
+// l'handler dei tasti e la resa, e un `2` nudo in due file diversi è la
+// coordinata che scade appena una riga si sposta.
+export const DROW = { action: 0, prompt: 1, model: 2, title: 3 };
+export const DETAIL_FIELDS = [
+    { kind: 'choice', count: DETAIL_ACTIONS.length, hotkeys: ACTION_HOTKEYS },
+    { kind: 'text' },
+    { kind: 'choice', count: MODELS.length },
+    { kind: 'text' },
+];
 export function useSheetOverlay(deps) {
     const { rows, columns, setMode, setNote, onAction } = deps;
     const [sheet, setSheet] = useState(null);
@@ -28,13 +41,19 @@ export function useSheetOverlay(deps) {
     // deck: si azzera a ogni apertura come scroll e azione, quindi non esiste una
     // selezione invisibile che cambi il comportamento dei tasti della lista.
     const [model, setModel] = useState(MODEL_DEFAULT);
-    // T111 — la nota con cui nascerà la conversazione. Campo SEMPRE ATTIVO: riceve
-    // la scrittura appena il detail si apre, senza nessun tasto che lo apra, e per
-    // questo si prende l'alfabeto nudo del modo (le cifre del selettore modello,
-    // `g`/`G` degli estremi del testo). Si azzera a ogni apertura come scroll,
-    // azione e modello: una nota armata che sopravvive alla chiusura sarebbe uno
-    // stato invisibile che cambia il titolo dello spawn successivo.
+    // T111 — il titolo con cui nascerà la conversazione (nel sidecar e in
+    // `deck-run` il dato si chiama ancora `note`: il rename è di sola etichetta).
+    // Si azzera a ogni apertura come scroll, azione e modello: un titolo armato
+    // che sopravvive alla chiusura sarebbe uno stato invisibile che cambia il
+    // titolo dello spawn successivo.
     const [spawnNote, setSpawnNote] = useState('');
+    // T117 — il prompt iniziale, EDITABILE. Quello che si legge nel campo è quello
+    // che parte: non un'anteprima di qualcos'altro.
+    const [prompt, setPrompt] = useState('');
+    const [cursor, setCursor] = useState({ row: DROW.action, caret: 0 });
+    // Il catalogo si legge una volta per vita del deck: è un file di quattro righe
+    // accanto al codice, non un dato che cambia sotto i piedi.
+    const catalog = useMemo(() => loadPromptCatalog(), []);
     // T91 — ricerca dentro il detail. `open` distingue i due modi in cui la si
     // lascia: `esc` butta via ciò che il modale ha prodotto (`find` a null,
     // evidenziazione via), `⏎` lo congela e restituisce il controllo allo strato
@@ -84,18 +103,43 @@ export function useSheetOverlay(deps) {
             return;
         setTop(topForOffset(lines, o.start, capacity));
     }, [findRes, occCur, lines, capacity]);
-    /** Apre il detail su una task, azzerando scroll, azione, modello, nota e ricerca. */
+    /** Apre il detail su una task, azzerando scroll, area di compilazione e ricerca. */
     function open(next) {
         setSheet(next);
         setTop(0);
         setAction(0);
         setModel(MODEL_DEFAULT);
         setSpawnNote('');
+        setPrompt(promptFor(catalog, DETAIL_ACTIONS[0].kind, next.id));
+        setCursor({ row: DROW.action, caret: 0 });
         setFind(null);
         setOccIdx(0);
         setNote('');
         setMode('detail');
     }
+    /** Cambia l'azione e RISCRIVE il prompt col default del nuovo kind (D2).
+     *
+     *  Nessuna preservazione del testo modificato a mano, e non è una svista: la
+     *  regola `initialDetail` del modale edit protegge da un cambio di sorgente
+     *  ACCIDENTALE, e col fuoco per riga quel caso non esiste — `←→` cambiano
+     *  azione solo dalla riga azione, mentre sul campo prompt muovono il caret.
+     *  Senza il cambio accidentale la preservazione difenderebbe da nulla, e
+     *  costerebbe un campo che non torna più al default. */
+    function selectAction(index) {
+        setAction(index);
+        const id = sheet?.id;
+        if (id)
+            setPrompt(promptFor(catalog, DETAIL_ACTIONS[index].kind, id));
+    }
+    // Il ponte fra le quattro righe e i quattro stati. Le righe restano
+    // TIPIZZATE dove vivono (`ModelKind`, indice dell'azione) invece di finire in
+    // un record generico: `fields.ts` governa la grammatica, non il modello dati.
+    const fieldsIO = {
+        text: (row) => (row === DROW.prompt ? prompt : spawnNote),
+        setText: (row, next) => (row === DROW.prompt ? setPrompt(next) : setSpawnNote(next)),
+        choice: (row) => (row === DROW.action ? action : Math.max(0, MODELS.indexOf(model))),
+        setChoice: (row, index) => row === DROW.action ? selectAction(index) : setModel(MODELS[index]),
+    };
     function close() {
         setMode('normal');
         setSheet(null);
@@ -154,36 +198,26 @@ export function useSheetOverlay(deps) {
             editFind((f) => ({ ...f, q: insertAt(f.q, f.caret, ins), caret: f.caret + cpLen(ins) }));
         }
     }
-    // T66 — detail della task: due zone (testo scrollabile + barra azioni) e una
-    // selezione per ognuna. Il modo cattura TUTTO, acceleratori `^K`/`^P`/`^R`
-    // compresi: chi è già nel detail ha i bottoni. L'unica deroga è `^F`, che qui
-    // apre la ricerca nel testo invece di quella sulle conversazioni.
+    // T66 — detail della task: due zone (testo scrollabile + area di compilazione)
+    // e una posizione per ognuna. Il modo cattura TUTTO, acceleratori
+    // `^K`/`^P`/`^R` compresi: chi è già nel detail ha i bottoni. L'unica deroga è
+    // `^F`, che qui apre la ricerca nel testo invece di quella sulle conversazioni.
     //
-    // T111 — con il campo nota sempre attivo l'ultimo ramo è la SCRITTURA, quindi
-    // ogni funzione che resta viva deve stare su un tasto che un campo di testo
-    // non contende: `tab`, frecce, `PgUp`/`PgDn`, CTRL, `⏎`, `esc`.
+    // T117 — le quattro righe si scorrono con `↑↓`, che quindi NON scrollano più il
+    // testo: la lettura del task file resta su `PgUp`/`PgDn`, cioè una granularità
+    // sola invece di due. È un costo reale su un task file lungo, ed è il prezzo di
+    // avere `↑↓` nel loro significato di sempre (muovere il fuoco) su una schermata
+    // che ospita insieme un documento e dei campi.
     function onKey(input, key) {
         if (find?.open) {
             onFindKey(input, key);
             return;
         }
-        if (key.ctrl) {
-            // Ramo CTRL chiuso in testa, e non più il solo `if` su `^F`: sotto c'è la
-            // scrittura nel campo nota, e senza questo ramo `^K` ci finirebbe come
-            // lettera `k` — la combo non arriva come tasto proprio, `key.ctrl` è
-            // l'unico discriminante fra `^X` e `x`.
-            //
-            // `^F` è la deroga dichiarata (`CTRL_DEROGATIONS.detail`): fuori dal
-            // detail è la ricerca conversazioni, qui è la ricerca nel testo. La query
-            // sopravvive a una chiusura con `⏎`, quindi riaprire riprende da dov'era.
-            // `^U` svuota la nota — non è una deroga ma una combo che il modo gestisce
-            // da sé, come il filtro del modale assegnazione. Ogni altro CTRL è inerte.
-            if (input === 'f') {
-                setFind((f) => (f ? { ...f, open: true } : { q: '', caret: 0, open: true }));
-            }
-            else if (input === 'u') {
-                setSpawnNote('');
-            }
+        if (key.ctrl && input === 'f') {
+            // Deroga dichiarata (`CTRL_DEROGATIONS.detail`): fuori dal detail `^F` è
+            // la ricerca conversazioni, qui la ricerca nel testo. La query sopravvive
+            // a una chiusura con `⏎`, quindi riaprire riprende da dov'era.
+            setFind((f) => (f ? { ...f, open: true } : { q: '', caret: 0, open: true }));
             return;
         }
         if (key.escape) {
@@ -195,57 +229,33 @@ export function useSheetOverlay(deps) {
                 setFind(null);
             else
                 close();
+            return;
         }
-        else if (key.return) {
-            // `⏎` esegue SEMPRE l'azione selezionata, mai "scrolla" o "chiudi": il
-            // testo non è un campo attivo (si scorre, non si edita), quindi nessuna
-            // competizione sul tasto.
+        if (key.return) {
+            // `⏎` esegue SEMPRE l'azione selezionata, da qualunque riga: i campi sono
+            // di una riga sola, quindi nessuno di loro ha da farci un a-capo.
             const act = DETAIL_ACTIONS[action];
             const id = sheet?.id;
             const note = spawnNote.trim();
+            const text = prompt.trim();
             close();
             if (id)
-                onAction(id, act.kind, model, note);
-        }
-        else if (key.tab) {
-            // T108 — `tab` scorre il catalogo dei modelli, e da T111 è il SOLO canale:
-            // le cifre `1`-`4` sono passate al campo nota. Libero solo QUI: in vista
-            // normale cicla la vista del pane a fuoco. Il detail cattura l'input per
-            // intero, quindi è dove un alfabeto già speso torna disponibile.
-            setModel((m) => MODELS[(MODELS.indexOf(m) + 1) % MODELS.length]);
-        }
-        else if (key.leftArrow || key.rightArrow) {
-            // Scorrimento CICLICO come le righe di scelta del modale edit: cinque
-            // voci, arrivare in fondo e ripartire costa meno che invertire direzione.
-            const d = key.leftArrow ? -1 : 1;
-            setAction((i) => (i + d + DETAIL_ACTIONS.length) % DETAIL_ACTIONS.length);
-        }
-        else if (key.upArrow) {
-            scroll(-1);
-        }
-        else if (key.downArrow) {
-            scroll(1);
+                onAction(id, act.kind, model, note, text);
+            return;
         }
-        else if (key.pageUp) {
+        if (key.pageUp) {
             scroll(-capacity);
+            return;
         }
-        else if (key.pageDown) {
+        if (key.pageDown) {
             scroll(capacity);
+            return;
         }
-        else if (key.backspace || key.delete) {
-            // Nessun movimento di caret nel campo (D3): `←→` sono già delle azioni e
-            // riprenderle costerebbe la barra. Si cancella quindi in coda — e
-            // `key.delete` è ANCHE Backspace in Ink, come nel campo di ricerca.
-            setSpawnNote((s) => removeAt(s, cpLen(s) - 1));
-        }
-        else if (input && !key.meta) {
-            // Ultimo ramo: tutto ciò che nessun tasto vivo ha reclamato è testo. Ci
-            // cadono le cifre `1`-`4` (prima il selettore modello) e `g`/`G` (prima
-            // gli estremi del testo, che nel detail si raggiungono con
-            // `PgUp`/`PgDn`); nel reader fullscreen restano, perché lì nessun campo
-            // contende le lettere.
-            setSpawnNote((s) => s + sanitizeTyped(input));
-        }
+        // Tutto il resto è dell'area di compilazione. Ciò che non consuma resta
+        // inerte — dentro un modo capturing è la scelta giusta: gli acceleratori
+        // globali non devono riattivarsi, e su una riga a scelta una lettera che
+        // non è la sua non deve finire in nessun campo.
+        fieldsKey(input, key, DETAIL_FIELDS, cursor, setCursor, fieldsIO);
     }
     return {
         sheet,
@@ -254,6 +264,8 @@ export function useSheetOverlay(deps) {
         action,
         model,
         spawnNote,
+        prompt,
+        cursor,
         find,
         lines,
         capacity,

package/dist/prompt-catalog.js

@@ -0,0 +1,55 @@
+// T117 — il testo dei prompt iniziali, letto dal file dati che il deck CONDIVIDE
+// con `deck-run`.
+//
+// Fino a T116 il catalogo era un `case` dentro `deck-run` e il deck non ne aveva
+// mai visto una stringa: passava un simbolo (`--prompt-kind`) e il testo restava
+// dall'altra parte. Un campo che MOSTRA il prompt prima dello spawn rompe quella
+// divisione — per mostrarlo bisogna averlo — e le due strade erano ricopiare il
+// catalogo qui (seconda scrittura delle stesse regole, divergente alla prima
+// voce aggiunta da una parte sola) oppure spostarlo in un dato che entrambi
+// leggono. È la seconda.
+//
+// Il file sta in `scripts/`, sibling di `deck-run`, e non in `src/`: la cartella
+// è già dentro `files` di package.json, quindi viene pubblicata as-is su npm,
+// mentre `tsc` non copia asset in `dist/` e un file dati sotto `src/` avrebbe
+// richiesto un passo di build apposta.
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+/** Stessa risalita di `DECK_RUN`: src/ (dev) e dist/ (build) sono entrambi
+ *  figli della package root, quindi il sibling è un livello sopra. */
+export const PROMPT_CATALOG = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'prompt-catalog');
+/**
+ * Il catalogo come mappa kind → template, col placeholder `{TASK}` ancora
+ * dentro.
+ *
+ * File illeggibile → mappa VUOTA, non un fallback cablato: un default scritto
+ * qui sarebbe esattamente la copia del catalogo che questo modulo esiste per non
+ * avere, e divergerebbe in silenzio. L'assenza si vede — il campo prompt resta
+ * vuoto — e uno spawn senza prompt è un esito benigno.
+ */
+export function loadPromptCatalog(path = PROMPT_CATALOG) {
+    const out = new Map();
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return out;
+    }
+    for (const line of raw.split('\n')) {
+        if (!line.trim() || line.startsWith('#'))
+            continue;
+        const tab = line.indexOf('\t');
+        if (tab < 0)
+            continue;
+        out.set(line.slice(0, tab).trim(), line.slice(tab + 1).trim());
+    }
+    return out;
+}
+/** Il prompt di un kind su una task. Kind fuori catalogo (`none`, o un file
+ *  mutilo) → stringa vuota, che è la stessa cosa che `deck-run` fa con `none`. */
+export function promptFor(catalog, kind, taskId) {
+    const template = catalog.get(kind);
+    return template ? template.replaceAll('{TASK}', taskId) : '';
+}

package/dist/spawn.js

@@ -142,6 +142,14 @@ export const DETAIL_ACTIONS = [
     { kind: 'recap', label: 'status' },
     { kind: 'checkpoint', label: 'checkpoint' },
 ];
+// T117 — selezione DIRETTA di un'azione con la sua iniziale (`o p r s c`),
+// accanto allo scorrimento `←→`. Derivate dalle label e non cablate: una voce
+// aggiunta al catalogo porta con sé la propria lettera, invece di lasciare
+// indietro una seconda lista.
+// Il vincolo che la derivazione impone al catalogo: le iniziali devono restare
+// DISTINTE fra loro. Due label con la stessa lettera renderebbero la seconda
+// irraggiungibile, e in silenzio — chi aggiunge una voce lo controlla qui.
+export const ACTION_HOTKEYS = Object.fromEntries(DETAIL_ACTIONS.map((a, i) => [a.label[0], i]));
 // 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.
@@ -157,14 +165,28 @@ export const DETAIL_ACTIONS = [
 // separino, quindi il flag non appartiene alla ripresa — vale su ogni spawn.
 // Assente quando la nota è vuota, e non passato vuoto: `--title-note ''`
 // produrrebbe un `«»` a vuoto nel titolo.
-export function deckArgs(id, sessionId, kind, model = MODEL_DEFAULT, spawnNote) {
-    const args = [id, '--session-id', sessionId, '--prompt-kind', kind, '--model', model];
+// T117 — `prompt` è il TESTO letterale, e quando c'è sostituisce il kind:
+// `--prompt` e `--prompt-kind` sono mutuamente esclusivi in deck-run. Serve al
+// detail, dove il prompt è un campo editabile e quello che l'utente legge è
+// quello che parte — dopo una modifica nessun kind lo descrive più.
+// `undefined` = questo percorso non ha un campo prompt (gli acceleratori della
+// lista) e viaggia col simbolo, come prima. Stringa VUOTA ≠ undefined: è la
+// richiesta esplicita di nessun prompt (azione `open`, o un campo svuotato a
+// mano) e si esprime col kind `none`, perché senza flag deck-run cadrebbe sul
+// proprio default `recap`.
+export function deckArgs(id, sessionId, kind, model = MODEL_DEFAULT, spawnNote, prompt) {
+    const promptArgs = prompt === undefined
+        ? ['--prompt-kind', kind]
+        : prompt
+            ? ['--prompt', prompt]
+            : ['--prompt-kind', 'none'];
+    const args = [id, '--session-id', sessionId, ...promptArgs, '--model', model];
     if (spawnNote)
         args.push('--title-note', spawnNote);
     return args;
 }
-export function spawnDeck(id, cwd, sessionId, kind, model = MODEL_DEFAULT, spawnNote) {
-    return launchDeckRun(deckArgs(id, sessionId, kind, model, spawnNote), cwd);
+export function spawnDeck(id, cwd, sessionId, kind, model = MODEL_DEFAULT, spawnNote, prompt) {
+    return launchDeckRun(deckArgs(id, sessionId, kind, model, spawnNote, prompt), cwd);
 }
 // T49 — resume di una sessione esistente come nuova tab Ptyxis. Scoped (taskId
 // presente) → `deck-run <task> --resume <sid>`: la ripresa eredita LOOM_TASK +

package/dist/ui/detail-screen.js

@@ -1,13 +1,14 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Detail della task (T66): quarta schermata sostitutiva, col markdown reso in
 // span tipizzati (T75) e la ricerca interna (T91).
 import { Box, Text } from 'ink';
-import { caretWindow, cut, cutParts, sanitize } from '../width.js';
+import { cut, cutParts } from '../width.js';
 import { sliceLine } from '../text-search.js';
 import { sliceSpans } from '../markdown.js';
-import { cpLen } from '../layout.js';
+import { FieldText } from './fields.js';
 import { DETAIL_ACTIONS, MODELS } from '../spawn.js';
-import { WARN } from '../glyphs.js';
+import { DROW } from '../overlays/sheet.js';
+import { CARET, CARET_OFF, WARN } from '../glyphs.js';
 /** Resa di ogni costrutto markdown (T75 · D4): un solo livello di enfasi per
  *  costrutto, senza un secondo alfabeto da imparare. Heading uguali a ogni
  *  livello — la gerarchia la porta già il testo. `code` e `fence` condividono
@@ -52,90 +53,74 @@ export function DetailLine({ line, spans, occ, current, }) {
             return (_jsx(Text, { bold: st?.bold, color: st?.color, children: sliceLine(seg.text, at, occ, current).map((p, j) => p.hit ? (_jsx(Text, { backgroundColor: p.current ? 'cyan' : 'yellow', color: "black", children: p.text }, j)) : (_jsx(Text, { children: p.text }, j))) }, i));
         }) }));
 }
-/** Campo di testo del detail: finestra ancorata al caret, cursore inverso sulla
- *  cella reale. Gemello di `EditTextField` senza la label, che qui sta fuori
- *  perché il campo vive in FLUSSO su una riga condivisa con altro (il contatore
- *  di occorrenze per la ricerca, il segnaposto per la nota) — non su una riga
- *  propria. Lo usano i due campi del detail: la ricerca `^F`, dove il caret si
- *  muove, e la nota (T111), dove il caret sta sempre in coda. */
-export function DetailTextField({ value, caret, cols }) {
-    const win = caretWindow(value, caret, cols);
-    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: sanitize(win.head) }), _jsx(Text, { inverse: true, children: sanitize(win.at) }), _jsx(Text, { children: sanitize(win.tail) })] }));
-}
-/** Segnaposto della riga nota quando il campo è vuoto. Costante e non letterale
- *  inline perché la sua larghezza entra nel budget del campo accanto. */
+/** Segnaposti delle due righe di testo a campo vuoto. Costanti e non letterali
+ *  inline perché la loro larghezza entra nel budget del campo accanto. */
 const NOTE_HINT = ' · nome della conversazione';
+const PROMPT_HINT = ' · nessun prompt iniziale';
+/** Le lettere di selezione diretta dell'azione, per la riga hint. Derivate dallo
+ *  stesso catalogo di `ACTION_HOTKEYS`, così una voce aggiunta compare qui senza
+ *  che nessuno ci ripassi — un'etichetta che nomina dei tasti a mano è accoppiata
+ *  al binding, e resta indietro appena il binding cambia. */
+const ACTION_KEYS = DETAIL_ACTIONS.map((a) => a.label[0]).join(' ');
+/** Prefisso incolonnato delle quattro righe dell'area di compilazione: le
+ *  etichette si leggono una sotto l'altra, quindi la larghezza è quella della
+ *  più lunga. Entra nel budget di ogni campo, da cui la costante. */
+const LABEL_W = 8;
+/** Una riga a SCELTA dell'area di compilazione: bottoni affiancati, voce attiva
+ *  in video inverso.
+ *
+ * Due passate di `cutParts`: la seconda serve SOLO quando qualcosa cade, e
+ * riserva le colonne del contatore. Riservarle sempre costerebbe 6 colonne su
+ * ogni terminale largo per un avviso che lì non comparirà mai.
+ *
+ * `priority` sulla voce SELEZIONATA e non sulla prima: qui il troncamento
+ * cancellerebbe l'unica informazione che la riga esiste per dare — quale valore
+ * sta per essere usato.
+ */
+function ChoiceRow({ label, values, index, focused, width, }) {
+    const segs = values.map((v) => `[ ${v} ]`);
+    const parts = [];
+    segs.forEach((s, i) => {
+        if (i > 0)
+            parts.push('  ');
+        parts.push(s);
+    });
+    const avail = Math.max(0, width - LABEL_W - CARET_OFF.length);
+    let shown = cutParts(parts, avail, index * 2);
+    const dropped = (v) => segs.filter((s, i) => v[i * 2] !== s).length;
+    if (dropped(shown) > 0)
+        shown = cutParts(parts, Math.max(0, avail - 6), index * 2);
+    const cut = dropped(shown);
+    return (_jsxs(Text, { wrap: "truncate-end", children: [focused ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: label.padEnd(LABEL_W) }), shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === index, color: i / 2 === index ? 'green' : 'gray', children: part }, i))), cut > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cut] }) : null] }));
+}
 /**
- * Detail della task (T66): il task file scrollabile più la barra azioni.
+ * Detail della task (T66): il task file scrollabile più l'area di compilazione.
  *
  * Unisce due gesti che erano due schermate — leggere la task e agire su di essa
  * — perché convergono sullo stesso oggetto: si legge la Description proprio per
  * decidere QUALE azione lanciare, e con due overlay separati quella decisione
  * costava uscire dal viewer e ricordarsi la combo.
  *
- * Le azioni sono BOTTONI AFFIANCATI e non voci di un menu verticale: un
+ * T117 — i quattro parametri dello spawn sono quattro RIGHE con un fuoco solo,
+ * la stessa forma del modale edit: prima erano tre alfabeti diversi sulla stessa
+ * schermata (`←→` per l'azione, `tab` per il modello, i tasti nudi per la nota),
+ * e ogni parametro aggiunto ne chiedeva un quarto.
+ *
+ * Le righe a scelta restano BOTTONI AFFIANCATI e non menu verticali: un
  * rettangolo ha già coordinate e area cliccabile, quindi il layout sopravvive
- * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione. La
- * navigazione da tastiera ci si sovrappone senza conflitti.
+ * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione.
  */
-export function DetailScreen({ id, title, missing, lines, spans, top, total, capacity, action, model, spawnNote, columns, find, occ, occCur, }) {
+export function DetailScreen({ id, title, missing, lines, spans, top, total, capacity, action, model, spawnNote, prompt, cursor, columns, find, occ, occCur, }) {
     const last = Math.min(total, top + capacity);
-    // Il taglio lo fa il chiamante (invariante ③ di width.ts): la riga bottoni è
-    // ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso — ma
-    // la correttezza non deve dipendere dall'alfabeto che capita nella riga.
+    // Il taglio lo fa il chiamante (invariante ③ di width.ts): le righe bottoni
+    // sono ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso
+    // — ma la correttezza non deve dipendere dall'alfabeto che capita nella riga.
     const width = Math.max(20, (columns || 80) - 4);
-    const segs = DETAIL_ACTIONS.map((a) => `[ ${a.label} ]`);
-    const parts = [];
-    segs.forEach((s, i) => {
-        if (i > 0)
-            parts.push('  ');
-        parts.push(s);
-    });
-    const dropped = (v, of) => of.filter((s, i) => v[i * 2] !== s).length;
-    // Due passate: la seconda serve SOLO quando qualcosa cade, e riserva le
-    // colonne del contatore. Riservarle sempre costerebbe 6 colonne su ogni
-    // terminale largo per un avviso che lì non comparirà mai.
-    let shown = cutParts(parts, width);
-    if (dropped(shown, segs) > 0)
-        shown = cutParts(parts, Math.max(0, width - 6));
-    const cutCount = dropped(shown, segs);
-    // T108 — riga del selettore modello: bottoni affiancati IDENTICI a quelli
-    // della barra azioni, quadre comprese, e voce attiva in video inverso. Due
-    // enfasi diverse su due righe adiacenti (là `inverse`, qui un grassetto
-    // colorato) obbligano a guardare da vicino per capire quale voce è scelta —
-    // la stessa resa si legge di colpo su entrambe.
-    // T111 — la cifra è USCITA dalla quadra: `1`-`4` sono passate al campo nota e
-    // il modello si scorre col solo `tab`. Un'etichetta che nomina un tasto è
-    // accoppiata al binding, e tenerla dopo che il binding è morto non è
-    // un'informazione parziale — è una resa che dichiara un tasto che non fa più
-    // quella cosa, cioè peggio di nessuna indicazione.
-    // `priority` sulla voce SELEZIONATA e non sulla prima: qui il troncamento
-    // cancellerebbe l'unica informazione che la riga esiste per dare — quale
-    // modello sta per essere usato — mentre nella barra azioni la voce attiva è
-    // comunque nota dal tasto appena premuto.
-    const mSegs = MODELS.map((m) => `[ ${m} ]`);
-    const mParts = [];
-    mSegs.forEach((s, i) => {
-        if (i > 0)
-            mParts.push('  ');
-        mParts.push(s);
-    });
-    const mIdx = Math.max(0, MODELS.indexOf(model));
-    // `- 8` = le colonne del prefisso "modello ", che sta fuori dai parts perché
-    // non è un bottone e non deve mai cadere.
-    const mWidth = Math.max(0, width - 8);
-    let mShown = cutParts(mParts, mWidth, mIdx * 2);
-    if (dropped(mShown, mSegs) > 0)
-        mShown = cutParts(mParts, Math.max(0, mWidth - 6), mIdx * 2);
-    const mCut = dropped(mShown, mSegs);
-    // T111 — riga della nota. FISSA (D1): il valore armato si vede sempre, e il
-    // suo costo sta in `DETAIL_CHROME` invece che in un secondo `extra`
-    // condizionale di `detailCapacity`. Prefisso largo 8 come `modello `, così i
-    // due parametri dello spawn si leggono incolonnati.
-    // Il campo non ha nessun tasto che lo apra: il cursore è l'unica cosa che lo
-    // dichiara attivo, e il segnaposto dice cosa ci si scrive. Le colonne del
-    // segnaposto si riservano SOLO quando c'è (cioè a nota vuota): riservarle
-    // sempre toglierebbe testo visibile a una nota lunga per un avviso assente.
-    const nWidth = Math.max(10, width - 8 - (spawnNote ? 0 : NOTE_HINT.length));
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193/PgUp/PgDn" }), " testo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "tab" }), " modello \u00B7", ' ', _jsx(Text, { color: "yellow", children: "scrivi" }), " nota \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^F" }), " cerca \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] })), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: occ, current: occCur }, top + i)))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(DetailTextField, { value: find.q, caret: find.caret, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "modello " }), mShown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === mIdx, color: i / 2 === mIdx ? 'green' : 'gray', children: part }, i))), mCut > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", mCut] }) : null] }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "nota    " }), _jsx(DetailTextField, { value: spawnNote, caret: cpLen(spawnNote), cols: nWidth }), spawnNote ? null : _jsx(Text, { dimColor: true, children: NOTE_HINT })] }), _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] })] })] }));
+    const mark = (row) => (cursor.row === row ? CARET : CARET_OFF);
+    // Budget dei due campi di testo: la cornice, il marker di riga e l'etichetta
+    // incolonnata. Le colonne del segnaposto si riservano SOLO quando c'è (cioè a
+    // campo vuoto): riservarle sempre toglierebbe testo visibile a un titolo lungo
+    // per un avviso assente.
+    const textW = (extra) => Math.max(10, width - LABEL_W - CARET_OFF.length - extra);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " testo \u00B7", ' ', _jsx(Text, { color: "yellow", children: ACTION_KEYS }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota campo \u00B7 ", _jsx(Text, { color: "yellow", children: "^F" }), " cerca"] })), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: occ, current: occCur }, top + i)))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(FieldText, { value: find.q, caret: find.caret, focused: true, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(ChoiceRow, { label: "azione", values: DETAIL_ACTIONS.map((a) => a.label), index: action, focused: cursor.row === DROW.action, width: width }), _jsxs(Text, { wrap: "truncate-end", children: [mark(DROW.prompt), _jsx(Text, { dimColor: true, children: 'prompt'.padEnd(LABEL_W) }), _jsx(FieldText, { value: prompt, caret: cursor.caret, focused: cursor.row === DROW.prompt, cols: textW(prompt ? 0 : PROMPT_HINT.length) }), prompt ? null : _jsx(Text, { dimColor: true, children: PROMPT_HINT })] }), _jsx(ChoiceRow, { label: "modello", values: MODELS, index: Math.max(0, MODELS.indexOf(model)), focused: cursor.row === DROW.model, width: width }), _jsxs(Text, { wrap: "truncate-end", children: [mark(DROW.title), _jsx(Text, { dimColor: true, children: 'titolo'.padEnd(LABEL_W) }), _jsx(FieldText, { value: spawnNote, caret: cursor.caret, focused: cursor.row === DROW.title, cols: textW(spawnNote ? 0 : NOTE_HINT.length) }), spawnNote ? null : _jsx(Text, { dimColor: true, children: NOTE_HINT })] })] })] }));
 }

package/dist/ui/fields.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// T117 — resa di un campo di testo dentro un'area di compilazione: finestra
+// ancorata al caret, cursore inverso sulla cella REALE.
+//
+// Uno solo per le due schermate. Esisteva in due copie — `EditTextField` nel
+// modale edit e `DetailTextField` nel detail — e la seconda si dichiarava
+// «gemello del primo senza la label»: la label infatti non è del campo, è del
+// LAYOUT che lo ospita, e i due layout la mettono in posti diversi (l'edit dopo
+// il marker di riga, il detail dentro un prefisso incolonnato). Tolta di mezzo,
+// dei due gemelli resta una cosa sola.
+import { Text } from 'ink';
+import { caretWindow, sanitize } from '../width.js';
+import { cpLen } from '../layout.js';
+/**
+ * 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: `at` lì
+ * è solo la cella virtuale di fine campo, e disegnarla aggiungerebbe al testo
+ * uno spazio che non gli appartiene.
+ */
+export function FieldText({ value, caret, focused, cols, }) {
+    const win = caretWindow(value, focused ? caret : cpLen(value), cols);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: sanitize(win.head) }), focused ? _jsx(Text, { inverse: true, children: sanitize(win.at) }) : null, _jsx(Text, { children: sanitize(win.tail) })] }));
+}

package/dist/ui/modals.js

@@ -3,8 +3,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // schermate sostitutive costano righe al budget d'altezza, quindi ognuno ha un
 // costo dichiarato in `viewport.ts`.
 import { Box, Text } from 'ink';
-import { caretWindow, cut, cutParts, sanitize } from '../width.js';
-import { cpLen } from '../layout.js';
+import { cut, cutParts, sanitize } from '../width.js';
+import { FieldText } from './fields.js';
 import { CARET, CARET_OFF, WARN } from '../glyphs.js';
 import { EDIT_PRI, EDIT_PROG } from '../model.js';
 import { PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
@@ -80,24 +80,17 @@ function IgnoredChoice({ survivors, mode, width, }) {
     const shown = cutParts(parts, width, mode === 'keep' ? 1 : 3);
     return (_jsx(Text, { wrap: "truncate-end", children: shown.map((s, i) => s ? (_jsx(Text, { color: "yellow", inverse: (i === 1 && mode === 'keep') || (i === 3 && mode === 'purge'), children: s }, i)) : null) }));
 }
-/**
- * Campo di testo del modale edit: finestra ancorata al caret + cursore inverso
- * nella posizione REALE.
- *
- * 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.
- */
-export 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) })] }));
+/** Campo di testo con la sua etichetta, nel layout dell'edit: label, due spazi,
+ *  campo. La label sta qui e non dentro `FieldText` perché è del LAYOUT, non del
+ *  campo — il detail la mette in un prefisso incolonnato di larghezza diversa. */
+function LabelledField({ label, value, caret, focused, cols, }) {
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: label }), _jsx(Text, { children: '  ' }), _jsx(FieldText, { value: value, caret: caret, focused: focused, cols: cols })] }));
 }
 // T41 — modale edit, in flusso come gli altri (spinge giù i pane invece di
 // coprirli: la riga che stai modificando resta visibile sopra la lista).
 // La riga di anteprima mostra il testo ESATTO che finirà nel campo `Progress`
 // del task file — così il default (`✔️ Done at <oggi>`) non è una sorpresa.
-export function EditModal({ id, draft, row, columns, }) {
+export function EditModal({ id, draft, row, caret, columns, }) {
     const mark = (r) => (row === r ? CARET : CARET_OFF);
     // 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
@@ -106,5 +99,5 @@ export function EditModal({ id, draft, row, columns, }) {
     // 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 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))] })] }));
+    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(LabelledField, { label: "prog  ", value: draft.detail, caret: caret, focused: row === 2, cols: fieldBudget }), !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { children: [mark(3), _jsx(LabelledField, { label: "titolo", value: draft.title, caret: caret, focused: row === 3, cols: fieldBudget })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", sanitize(progressText(draft.prog, draft.detail))] })] }));
 }