@lamemind/loom-deck 0.67.0 → 0.69.0

package/dist/hooks.js

@@ -8,13 +8,15 @@ import { statSync } from 'node:fs';
 import { loadTasks, loadTaskDetail } from './tasks.js';
 import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
-import { loadSessionIndex } from './task-index.js';
+import { appendSessionMeta, loadSessionIndex } from './task-index.js';
+import { sidecarGaps } from './session-meta.js';
 import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
 import { commitTimes } from './commit-times.js';
 import { scanEpicHierarchy, EMPTY_EPIC_HIERARCHY } from './epic-hierarchy.js';
 import { scanInbox, INBOX_SCAN_INTERVAL_MS } from './inbox.js';
 import { mixedCount, readWrapCache, runWrapScan, wrapCacheFile, wrapCount, } from './wrap-scan.js';
 import { purgeTargets } from './purge.js';
+import { loadSpawnOverrides, saveSpawnOverrides, } from './spawn-config.js';
 import { POLL_MS } from './model.js';
 // Dimensioni del terminale, live sul resize.
 //
@@ -136,7 +138,15 @@ export function useEpicHierarchy(tasksDir) {
 // ha cache mtime-keyed interna → il poll è economico; qui si evita comunque il
 // re-render inutile con una signature (sessionId:ts + binding entries): setState
 // solo quando cambia davvero qualcosa.
-export function useSessions(projectRoot) {
+//
+// T162 — è anche il posto dove il deck RIEMPIE I BUCHI dei campi derivati del
+// sidecar (`title`, `model`): qui le due fonti sono già in mano nello stesso
+// giro, la corrente (le `Session`) e quella su disco (l'indice). Il `core` del
+// progetto arriva per argomento e non si rilegge qui: la stessa derivazione
+// vive già nel modello (`projectCore`), e una seconda copia toglierebbe dal
+// titolo scritto nel sidecar una stringa diversa da quella che la lista toglie
+// dalle proprie righe.
+export function useSessions(projectRoot, core) {
     const [state, setState] = useState({
         sessions: [],
         bindings: new Map(),
@@ -167,6 +177,8 @@ export function useSessions(projectRoot) {
                     pinned: new Map(),
                     notes: new Map(),
                     priority: new Set(),
+                    titles: new Map(),
+                    models: new Map(),
                 };
             }
             // T62 — le vive stanno sullo STESSO tick delle altre fonti, non su una
@@ -182,6 +194,42 @@ export function useSessions(projectRoot) {
                 live = new Map();
             }
             const { bindings, forkOf, pinned, notes, priority } = index;
+            // T162 — i campi derivati delle PINNATE, allineati prima della signature.
+            //
+            // Gira a ogni giro e non solo al cambio di stato, perché il buco può
+            // nascere senza che nulla nel deck si muova: a pinnare può essere compass,
+            // dalla modale sulla conversazione in focus, e compass il titolo non lo
+            // conosce. Il deck è l'unico che ce l'ha, quindi è l'unico che può
+            // chiudere quel buco — e lo fa passando, non al momento del gesto.
+            //
+            // Costa solo quando c'è da scrivere: senza pinnate `sidecarGaps` esce
+            // subito, e con un sidecar già allineato ritorna una lista vuota (è
+            // l'invariante di convergenza del modulo — vedi `session-meta.ts`).
+            //
+            // Fuori dal gate della signature di proposito: un sidecar temporaneamente
+            // non scrivibile deve poter essere ritentato al giro dopo, e con lo stato
+            // invariato la signature non cambierebbe mai più.
+            //
+            // Gli append NON entrano nella signature e non producono un re-render: il
+            // deck il titolo lo ha dalla `Session`, che è la fonte. Questi campi
+            // esistono per un lettore che non può aprire un transcript, cioè compass.
+            try {
+                for (const gap of sidecarGaps({
+                    pinned,
+                    sessions,
+                    bindings,
+                    titles: index.titles,
+                    models: index.models,
+                    core,
+                })) {
+                    appendSessionMeta(projectRoot, gap.sessionId, gap);
+                }
+            }
+            catch {
+                // sidecar non scrivibile: il poll continua, il buco si riprova al giro
+                // dopo. Niente a schermo — è manutenzione di un campo di servizio, non
+                // un'azione che l'utente ha chiesto.
+            }
             // La signature copre anche fork, pin, note e marca di priorità: un record
             // di lineage, un toggle di pin, una nota appena scritta o un 🚨 acceso
             // cambiano la lista renderizzata, quindi devono forzare il re-render come
@@ -208,7 +256,7 @@ export function useSessions(projectRoot) {
         reload();
         const id = setInterval(reload, POLL_MS);
         return () => clearInterval(id);
-    }, [projectRoot]);
+    }, [projectRoot, core]);
     return { ...state, reload: () => reloadRef.current() };
 }
 // T61 — conteggio delle Done oltre soglia, su una scala di refresh TUTTA SUA.
@@ -398,3 +446,38 @@ export function useTaskDetail(tasksDir, id) {
     }, [tasksDir, id]);
     return detail;
 }
+/**
+ * T161 — gli OVERRIDE di spawn del progetto, tenuti vivi per la durata del deck.
+ *
+ * Lettura una volta al mount, e da lì in poi lo stato in memoria è la fonte: la
+ * pagina delle azioni è l'unico scrittore, e rileggere il file a ogni tick del
+ * poll significherebbe pagare una `readFileSync` ogni 1,5 secondi per un dato
+ * che cambia quando lo si cambia. Chi lo modifica fuori dal deck (a mano, o un
+ * altro deck sullo stesso progetto) si riallinea alla riapertura, che è lo stesso
+ * regime di `launch` e `archivableDays`.
+ *
+ * Gli AVVISI del parse si mostrano una volta, all'avvio, nella riga di stato: una
+ * voce scartata in silenzio si presenta come un override che non fa niente, cioè
+ * come un guasto del deck. La riga di stato è l'unica superficie sempre presente
+ * — la pagina potrebbe non venire mai aperta.
+ *
+ * Il salvataggio NON si fida: ricarica dal disco quello che ha appena scritto,
+ * così quello che la pagina mostra dopo `w` è quello che il file dice davvero,
+ * riduzione del titolo e scarti compresi.
+ */
+export function useSpawnConfig({ cwd, setNote, }) {
+    const [parsed, setParsed] = useState(() => loadSpawnOverrides(cwd));
+    const warned = useRef(false);
+    useEffect(() => {
+        if (warned.current || parsed.warnings.length === 0)
+            return;
+        warned.current = true;
+        const [first, ...rest] = parsed.warnings;
+        setNote(`⚠ ${first}${rest.length > 0 ? ` · +${rest.length}` : ''}`);
+    }, [parsed, setNote]);
+    const save = useCallback((entries) => {
+        saveSpawnOverrides(cwd, entries);
+        setParsed(loadSpawnOverrides(cwd));
+    }, [cwd]);
+    return { overrides: parsed.entries, warnings: parsed.warnings, save };
+}

package/dist/inbox.js

@@ -192,16 +192,11 @@ export function inboxPrompt(f) {
     }
     return `/loom-works:${DRAIN_SKILL[f.natura]} ${f.basename}`;
 }
-/** Prefisso del titolo di una sessione aperta su un file inbox. Astrale come le
- *  emoji delle azioni su task (`ACTION_EMOJI` in `src/spawn.ts`) e per la stessa
- *  ragione: `sanitize` di `src/width.ts` sostituisce con `·` ogni glifo su cui
- *  le due contabilità di larghezza divergono, e le emoji del BMP divergono
- *  sempre. Sta anche nella whitelist di `_sane_note` in `deck-run`, o arriverebbe
- *  nella tab ridotta a niente mentre la lista del deck la mostra. */
-const INBOX_EMOJI = '🧹';
 /**
- * Il titolo della sessione che il deck apre su un file inbox: `🧹 <basename>`,
- * senza l'estensione.
+ * T161 — il buco `{file}` del titolo di una sessione di drain: il basename senza
+ * estensione e senza punti. L'emoji del prefisso non sta più qui — è dentro il
+ * template della riga `drain` del catalogo delle azioni, dove il progetto può
+ * riscriverla.
  *
  * Il `.md` si toglie QUI e non lo si lascia cadere a valle: l'alfabeto di
  * `_sane_note` non ha il punto, quindi il titolo della tab uscirebbe con le due
@@ -213,9 +208,8 @@ const INBOX_EMOJI = '🧹';
  * invece di drenare, ma l'oggetto su cui lavora è lo stesso file, ed è il file
  * che il titolo nomina. L'azione la dice il prompt.
  */
-export function inboxTitle(f) {
-    const name = f.basename.replace(/\.md$/i, '').replace(/\./g, '-');
-    return `${INBOX_EMOJI} ${name}`;
+export function inboxWords(f) {
+    return f.basename.replace(/\.md$/i, '').replace(/\./g, '-');
 }
 /**
  * Il testo del file inbox, per il detail fullscreen. `null` = illeggibile —

package/dist/input-modes.js

@@ -26,6 +26,7 @@ export const CAPTURING_MODES = [
     'status',
     'inbox',
     'wrap',
+    'spawn',
     'reader',
     'search',
     'assign',

package/dist/input.js

@@ -79,6 +79,7 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
         status: overlays.status.onKey,
         inbox: overlays.inbox.onKey,
         wrap: overlays.wrap.onKey,
+        spawn: overlays.spawn.onKey,
         reader: overlays.search.onReaderKey,
         search: overlays.search.onSearchKey,
         assign: overlays.assign.onKey,
@@ -335,6 +336,21 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 // stesso doppio significato per contesto già in esercizio su `^F`.
                 overlays.gitlink.bump();
             }
+            else if (input === 's') {
+                // T161/P13 preflight — `^S` apre la pagina delle azioni di spawn. Le
+                // schermate sostitutive si aprono tutte con `CTRL` più lettera, e `s`
+                // sta per «spawn»; `^A`, che sarebbe l'altra mnemonica, è già
+                // inizio-riga dentro ogni campo di testo del deck.
+                //
+                // Sul flow-control XON/XOFF il repo porta due commenti in
+                // contraddizione — `model.ts` dice che il raw mode di Ink lo disattiva e
+                // il tasto passa pulito, `cli.tsx` che il terminale lo intercetta. La
+                // contraddizione si chiude qui con una MISURA, non con un'opinione: il
+                // gate pty di `test/modes-smoke.test.ts` manda `^S` al deck vero dentro
+                // un pseudo-terminale e pretende che la pagina si apra, quindi se il
+                // byte non arrivasse il test fallirebbe invece di lasciare il dubbio.
+                overlays.spawn.openPage();
+            }
             else if (input === 'b') {
                 // T134/D8 preflight — `^B` (box/bacheca) scambia i due pane dello slot
                 // destro. Non è un modale né una schermata: il pane resta uno dei due

package/dist/overlays/sheet.js

@@ -18,10 +18,9 @@ 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 { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, specializeRecap, } from '../spawn.js';
+import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, specializeRecap, } from '../spawn-catalog.js';
 import { taskIsEpic } from '../tasks.js';
 import { fieldsKey } from '../fields.js';
-import { loadPromptCatalog, modelFor, promptFor } from '../prompt-catalog.js';
 // T117 — le 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
@@ -41,7 +40,7 @@ export const DETAIL_FIELDS = [
     { kind: 'choice', count: PRIORITY_CHOICES.length },
 ];
 export function useSheetOverlay(deps) {
-    const { rows, columns, setMode, setNote, onAction } = deps;
+    const { rows, columns, setMode, setNote, defaults, onAction } = deps;
     const [sheet, setSheet] = useState(null);
     const [top, setTop] = useState(0);
     const [action, setAction] = useState(0);
@@ -68,9 +67,6 @@ export function useSheetOverlay(deps) {
      *  riparserebbe l'intero task file per un campo dell'header. */
     const [epic, setEpic] = useState(false);
     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
@@ -130,13 +126,13 @@ export function useSheetOverlay(deps) {
         setTop(0);
         setAction(0);
         setEpic(isEpic);
-        // T152 — il modello segue l'azione iniziale, come già il prompt: su una
-        // task Epic la prima azione specializza a `recap-epic`, che nel catalogo
-        // può portare un modello diverso da `recap`. Nessun kind fuori catalogo →
-        // MODEL_DEFAULT, lo stesso fallback che vale ovunque nel deck.
-        setModel(modelFor(catalog, kind) ?? MODEL_DEFAULT);
-        setSpawnNote('');
-        setPrompt(promptFor(catalog, kind, next.id));
+        // T152/T161 — i tre campi partono dalla terna dell'azione, risolta sul
+        // catalogo e sugli override di progetto: su una task Epic la prima azione
+        // specializza a `recap-epic`, che può portare valori diversi da `recap`.
+        const d = defaults(kind, next.id);
+        setModel(d.model);
+        setSpawnNote(d.title ?? '');
+        setPrompt(d.prompt ?? '');
         setPriority(false);
         setCursor({ row: DROW.action, caret: 0 });
         setFind(null);
@@ -144,21 +140,27 @@ export function useSheetOverlay(deps) {
         setNote('');
         setMode('detail');
     }
-    /** Cambia l'azione e RISCRIVE prompt e modello col default del nuovo kind (D2).
+    /** Cambia l'azione e RISCRIVE i tre campi col default del nuovo kind (D2).
      *
-     *  Nessuna preservazione della scelta manuale di modello, per la stessa
-     *  ragione già scritta sul prompt: col fuoco per riga un cambio di azione
-     *  ACCIDENTALE non esiste — `←→` cambiano azione solo dalla riga azione —
-     *  quindi la preservazione difenderebbe da nulla e costerebbe un campo che
-     *  non torna più al default della nuova azione (T152). */
+     *  Nessuna preservazione delle scelte fatte a mano, per la stessa ragione già
+     *  scritta sul prompt: col fuoco per riga un cambio di azione ACCIDENTALE non
+     *  esiste — `←→` cambiano azione solo dalla riga azione — quindi la
+     *  preservazione difenderebbe da nulla e costerebbe campi che non tornano più
+     *  al default della nuova azione (T152).
+     *
+     *  T161 — da qui ci passa anche il TITOLO, che prima restava vuoto e veniva
+     *  riempito allo spawn da `fallbackTitle`: ora il campo mostra quello che
+     *  partirà, come già il prompt e il modello. */
     function selectAction(index) {
         setAction(index);
         const id = sheet?.id;
         if (!id)
             return;
         const kind = specializeRecap(DETAIL_ACTIONS[index].kind, epic);
-        setPrompt(promptFor(catalog, kind, id));
-        setModel(modelFor(catalog, kind) ?? MODEL_DEFAULT);
+        const d = defaults(kind, id);
+        setPrompt(d.prompt ?? '');
+        setModel(d.model);
+        setSpawnNote(d.title ?? '');
     }
     // Il ponte fra le quattro righe e i quattro stati. Le righe restano
     // TIPIZZATE dove vivono (`ModelKind`, indice dell'azione) invece di finire in
@@ -279,13 +281,12 @@ export function useSheetOverlay(deps) {
             // Il kind viaggia specializzato quanto il prompt che lo accompagna: se il
             // campo è stato svuotato a mano il testo non parte e resta lui a dire cosa
             // ricevera' la sessione, quindi i due non possono divergere.
-            const act = DETAIL_ACTIONS[action];
             const id = sheet?.id;
             const note = spawnNote.trim();
             const text = prompt.trim();
             close();
             if (id)
-                onAction(id, specializeRecap(act.kind, epic), model, note, text, priority);
+                onAction(id, model, note, text, priority);
             return;
         }
         if (key.pageUp) {

package/dist/overlays/spawn.js

@@ -0,0 +1,240 @@
+// T161 — la PAGINA DELLE AZIONI DI SPAWN: ottava schermata sostitutiva.
+//
+// Una tabella di undici righe — una per azione che il deck sa aprire — con le
+// quattro colonne funzione, titolo, modello, prompt. Le ultime tre si modificano
+// e il salvataggio scrive il blocco `spawn` di `.claude/loom-works.json`.
+//
+// Due LIVELLI, non un edit dentro la cella (P14 preflight). Al primo si scorre
+// la tabella; `⏎` apre sotto di essa l'area di compilazione della riga
+// selezionata, che è la stessa forma già in esercizio nel detail della task —
+// righe con un fuoco solo, `↑↓` fra le righe, `←→` sul valore o sul caret
+// secondo il tipo (`fields.ts`). Un editor dentro la cella avrebbe voluto un
+// caret che scorre dentro una colonna larga venti colonne, cioè una terza
+// grammatica di input su una schermata che ne ha già due.
+//
+// La bozza vive IN MEMORIA fino a `w`. Comporre una configurazione non tocca il
+// disco — stesso regime del salvataggio esplicito della vista (`w` sul deck) —
+// e il file di progetto è committato: scriverci a ogni freccia produrrebbe un
+// working tree sporco per una prova.
+import { useState } from 'react';
+import { pageStep, spawnListCapacity } from '../viewport.js';
+import { fieldsKey } from '../fields.js';
+import { cpLen } from '../layout.js';
+import { saneTemplate } from '../sane-note.js';
+import { configFilePath } from '../config.js';
+import { cut } from '../width.js';
+import { EXAMPLE_HOLES, MODELS, SPAWN_ACTIONS, editableFields, } from '../spawn-catalog.js';
+import { rawSpawn, } from '../spawn-config.js';
+/** Le tre righe dell'area di compilazione, nell'ordine in cui si leggono. Sono
+ *  posizioni di SCHERMO e non indici del cursore: le righe non editabili si
+ *  disegnano comunque (dicono perché non lo sono) ma il fuoco non ci passa. */
+export const SROW = { title: 0, model: 1, prompt: 2 };
+export function useSpawnPage(deps) {
+    const { cwd, rows, hasNote, overrides, save, catalog, setMode, setNote } = deps;
+    /** La bozza, `null` a pagina chiusa. Copia degli override all'apertura: una
+     *  bozza che sopravvive alla chiusura sarebbe uno stato invisibile che `w`
+     *  scriverebbe la volta dopo. */
+    const [draft, setDraft] = useState(null);
+    const [sel, setSel] = useState(0);
+    const [top, setTop] = useState(0);
+    const [dirty, setDirty] = useState(false);
+    /** L'area di compilazione è aperta sulla riga selezionata. */
+    const [editing, setEditing] = useState(false);
+    const [fieldTitle, setFieldTitle] = useState('');
+    const [fieldModel, setFieldModel] = useState(MODELS[0]);
+    const [fieldPrompt, setFieldPrompt] = useState('');
+    const [cursor, setCursor] = useState({ row: 0, caret: 0 });
+    const capacity = spawnListCapacity(rows, editing, hasNote);
+    const maxTop = Math.max(0, SPAWN_ACTIONS.length - capacity);
+    const open = draft !== null;
+    const action = SPAWN_ACTIONS[sel];
+    const editable = editableFields(action);
+    /** Le specifiche che `fields.ts` consuma: SOLO le celle editabili di questa
+     *  riga, nell'ordine di schermo. Il cursore indicizza qui, non le tre righe
+     *  disegnate — su `bare`, che ha il solo modello, `↑↓` non hanno dove andare e
+     *  non devono finire su una riga che non si modifica. */
+    const specs = editable.map((f) => f === 'model' ? { kind: 'choice', count: MODELS.length } : { kind: 'text' });
+    const table = SPAWN_ACTIONS.map((a) => ({
+        action: a,
+        raw: rawSpawn(a, draft ?? overrides, catalog),
+        touched: (draft ?? overrides).has(a.id),
+    }));
+    function openPage() {
+        setDraft(new Map(overrides));
+        setSel(0);
+        setTop(0);
+        setDirty(false);
+        setEditing(false);
+        setNote('');
+        setMode('spawn');
+    }
+    function close() {
+        setMode('normal');
+        setDraft(null);
+        setEditing(false);
+    }
+    function scroll(delta) {
+        const next = Math.max(0, Math.min(SPAWN_ACTIONS.length - 1, sel + delta));
+        setSel(next);
+        // La finestra INSEGUE la selezione invece di centrarla: la tabella è di
+        // undici righe e su un terminale normale ci sta intera, quindi centrare
+        // farebbe saltare la lista sotto il caret per niente.
+        setTop(Math.max(0, Math.min(next, Math.max(Math.min(top, maxTop), next - capacity + 1))));
+    }
+    /** Apre l'area sulla riga selezionata, coi valori GREZZI correnti. */
+    function openFields() {
+        const raw = rawSpawn(action, draft ?? overrides, catalog);
+        const title = raw.title ?? '';
+        const prompt = raw.prompt ?? '';
+        setFieldTitle(title);
+        setFieldModel(raw.model);
+        setFieldPrompt(prompt);
+        // Caret in coda al primo campo editabile, come `caretAtEnd`: è la posizione
+        // da cui si continua a scrivere, e l'unica che non dipende da dove stava il
+        // cursore l'ultima volta che l'area era aperta.
+        const first = editable[0];
+        setCursor({ row: 0, caret: first === 'model' ? 0 : cpLen(first === 'title' ? title : prompt) });
+        setEditing(true);
+    }
+    /**
+     * Congela l'area nella bozza, tenendo solo ciò che DIFFERISCE dal default.
+     *
+     * È ciò che rende reversibile una modifica senza un gesto apposta: un valore
+     * riportato a mano a quello di partenza smette di essere un override, invece
+     * di restare nel file come una riga che non cambia niente (AC7). Il gesto
+     * apposta — `CANC` — resta per togliere tutte e tre le celle in un colpo.
+     */
+    function commitFields() {
+        const base = rawSpawn(action, new Map(), catalog);
+        const next = {};
+        for (const f of editable) {
+            if (f === 'model') {
+                if (fieldModel !== base.model)
+                    next.model = fieldModel;
+            }
+            else if (f === 'title') {
+                // P10 — la riduzione al confine: quello che entra nella bozza è quello
+                // che comparirà nella tab, coi buchi preservati. Farla solo al
+                // salvataggio mostrerebbe per tutta la sessione un titolo che la tab non
+                // porterà mai.
+                const title = saneTemplate(fieldTitle);
+                if (title !== (base.title ?? ''))
+                    next.title = title;
+            }
+            else if (fieldPrompt !== (base.prompt ?? '')) {
+                next.prompt = fieldPrompt;
+            }
+        }
+        setDraft((d) => {
+            const m = new Map(d ?? overrides);
+            if (Object.keys(next).length > 0)
+                m.set(action.id, next);
+            else
+                m.delete(action.id);
+            return m;
+        });
+        setDirty(true);
+        setEditing(false);
+    }
+    /** `CANC` sulla riga: via l'override, la riga torna al default. */
+    function clearRow() {
+        if (!(draft ?? overrides).has(action.id)) {
+            setNote(`CANC → ${action.id}: nessun override da togliere`);
+            return;
+        }
+        setDraft((d) => {
+            const m = new Map(d ?? overrides);
+            m.delete(action.id);
+            return m;
+        });
+        setDirty(true);
+        setNote(`CANC → ${action.id}: override rimosso, torna al default`);
+    }
+    function write() {
+        const entries = draft ?? overrides;
+        try {
+            save(entries);
+        }
+        catch (e) {
+            // Il file non è del deck: se non si parsa il saver rifiuta invece di
+            // rigenerarlo, e qui si dice perché. La bozza resta viva — chi ripara il
+            // file a mano può ripremere `w` senza rifare le modifiche.
+            setNote(`⚠ ${cut(e.message, 70)}`);
+            return;
+        }
+        setDirty(false);
+        const n = entries.size;
+        setNote(`w → ${n === 0 ? 'nessun override' : `${n} azione${n > 1 ? 'i' : ''} configurate`} · ${configFilePath(cwd)}`);
+    }
+    const fieldsIO = {
+        text: (row) => (editable[row] === 'title' ? fieldTitle : fieldPrompt),
+        setText: (row, next) => editable[row] === 'title' ? setFieldTitle(next) : setFieldPrompt(next),
+        choice: () => Math.max(0, MODELS.indexOf(fieldModel)),
+        setChoice: (_row, index) => setFieldModel(MODELS[index]),
+    };
+    function onFieldsKey(input, key) {
+        if (key.escape) {
+            setEditing(false);
+            return;
+        }
+        if (key.return) {
+            commitFields();
+            return;
+        }
+        fieldsKey(input, key, specs, cursor, setCursor, fieldsIO);
+    }
+    function onKey(input, key) {
+        if (!open)
+            return;
+        if (editing) {
+            onFieldsKey(input, key);
+            return;
+        }
+        if (key.escape) {
+            // Una bozza non salvata si perde: dirlo è l'unico modo di non perderla per
+            // sbaglio, e un modale di conferma su una pagina di configurazione
+            // costerebbe una domanda a ogni uscita.
+            if (dirty)
+                setNote('modifiche non salvate perse · w salva prima di uscire');
+            close();
+            return;
+        }
+        if (key.return) {
+            openFields();
+            return;
+        }
+        if (key.delete) {
+            clearRow();
+            return;
+        }
+        if (key.upArrow)
+            scroll(-1);
+        else if (key.downArrow)
+            scroll(1);
+        else if (key.pageUp)
+            scroll(-pageStep(capacity));
+        else if (key.pageDown)
+            scroll(pageStep(capacity));
+        else if (input === 'w' && !key.ctrl)
+            write();
+    }
+    return {
+        open,
+        table,
+        sel,
+        top,
+        capacity,
+        maxTop,
+        dirty,
+        editing,
+        editable,
+        fieldTitle,
+        fieldModel,
+        fieldPrompt,
+        cursor,
+        /** L'anteprima resa della riga aperta: i buchi riempiti coi valori finti. */
+        example: EXAMPLE_HOLES,
+        openPage,
+        onKey,
+    };
+}

package/dist/overlays/status.js

@@ -17,7 +17,7 @@ import { parseMarkdown } from '../markdown.js';
 import { CLAUDE_CMD, notifyDone, spawnProjectStatus } from '../spawn.js';
 import { readStatusCache, statusFilePath, statusLabel, writeStatusCache, } from '../project-status.js';
 export function useProjectStatus(deps) {
-    const { cwd, name, rows, columns, setMode, setNote } = deps;
+    const { cwd, name, rows, columns, model, prompt, setMode, setNote } = deps;
     const path = useMemo(() => statusFilePath(cwd), [cwd]);
     // Letta al mount e basta: è ciò che fa ripartire un deck riaperto dall'ora di
     // prima invece che da `missing`.
@@ -78,7 +78,7 @@ export function useProjectStatus(deps) {
         setFailed(false);
         setStartedAt(Date.now());
         setNote(`⏳ project status di ${name}… (sid ${sid.slice(0, 8)})`);
-        const child = spawnProjectStatus(cwd, sid, finish);
+        const child = spawnProjectStatus(cwd, sid, finish, model, prompt);
         child.on('error', () => {
             setStartedAt(null);
             setFailed(true);

package/dist/overlays/wrap.js

@@ -14,7 +14,7 @@ import { useWrapScan } from '../hooks.js';
 import { pageStep, wrapListCapacity } from '../viewport.js';
 import { cpLen, insertAt, removeAt } from '../layout.js';
 import { sanitizeTyped } from '../glyphs.js';
-import { WRAP_DEFAULT_PATH, wrapPrompt } from '../wrap-scan.js';
+import { WRAP_DEFAULT_PATH } from '../wrap-scan.js';
 export function useWrapOverlay(deps) {
     const { cwd, rows, setMode, setNote, onApply } = deps;
     // Lo stato dello scan vive QUI e non nel modello, sul precedente di
@@ -69,7 +69,7 @@ export function useWrapOverlay(deps) {
         if (key.return) {
             const target = path.trim() || WRAP_DEFAULT_PATH;
             close();
-            onApply(target, wrapPrompt(target));
+            onApply(target);
             return;
         }
         if (key.upArrow) {

package/dist/prompt-catalog.js

@@ -16,7 +16,7 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { MODELS } from './spawn.js';
+import { MODELS } from './spawn-catalog.js';
 /** 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');