@lamemind/loom-deck 0.66.1 → 0.68.0

package/dist/spawn.js

@@ -3,8 +3,11 @@
 import { spawn } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { fileURLToPath } from 'node:url';
-import { basename, dirname, join } from 'node:path';
-import { findTaskFile } from './tasks.js';
+import { dirname, join } from 'node:path';
+// T161 — i cataloghi (kind, modelli, azioni) stanno in `spawn-catalog.ts`, che
+// è DATO PURO e non importa questo file: la dipendenza va in un verso solo.
+// Qui restano i soli effetti verso l'esterno — comporre un argv e lanciarlo.
+import { MODEL_DEFAULT, PROJECT_STATUS_MODEL } from './spawn-catalog.js';
 // scripts/deck-run è un sibling della dir del bundle: src/ (dev, tsx) e dist/
 // (build, node) stanno entrambi sotto la package root → risalita di un livello.
 export const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'deck-run');
@@ -118,169 +121,50 @@ export function onInTabCommand(child, cb) {
         }
     });
 }
-/**
- * `recap` → la sotto-skill giusta, quando chi spawna SA se la task è un cappello.
- *
- * `recap` resta il kind onesto per chi non lo sa: punta al dispatcher, che
- * risolve la task e classifica da sé. È il caso degli acceleratori della lista,
- * dove il deck ha in mano solo `tasks.md` — e lì il `Size` non c'è. Il DETAIL
- * invece il task file l'ha già letto, quindi può saltare il giro e pagare un
- * turno di modello in meno.
- *
- * Non è una classificazione duplicata: il criterio (`Size: Epic`) resta uno solo
- * e sta in `taskIsEpic`, che legge lo stesso campo che leggerebbe il dispatcher.
- * Quello che si evita è il RITARDO, non il giudizio.
- *
- * Ogni kind diverso da `recap` passa intatto: la specializzazione è un caso, non
- * una trasformazione da applicare a tutti.
- */
-export function specializeRecap(kind, epic) {
-    if (kind !== 'recap')
-        return kind;
-    return epic ? 'recap-epic' : 'recap-task';
-}
-// L'ordine È il giro di `tab` nel detail, non una preferenza di lettura:
-// cambiarlo sposta le voci sotto le dita di chi le ha imparate. Fino a T111 era
-// anche il binding delle cifre `1`-`4`, passate poi al campo nota.
-export const MODELS = ['fable', 'opus', 'sonnet', 'haiku'];
-// Default del selettore e FALLBACK per ogni kind fuori catalogo (kind `none`,
-// o un catalogo mutilo). Duplicato del default di deck-run e non letto da lì:
-// il deck deve poter MOSTRARE la selezione iniziale prima di spawnare
-// alcunché, e un valore che si conosce solo a spawn avvenuto non è mostrabile.
-//
-// T152 — non è più IL default di `^K`/`^P`/`^R` dalla lista: quei percorsi
-// leggono il catalogo come il detail (`modelFor`), e cadono qui solo quando il
-// kind non ha una riga. Resta l'unico default che resume e fork usano per
-// intero, perché lì il modello non è mai una funzione del kind — è quello
-// della conversazione d'origine (T148).
-export const MODEL_DEFAULT = 'fable';
-// T152 — `recap-status-project` non è una chiave del catalogo (§Doc Impact,
-// "le chiavi del catalogo sono i valori di --prompt-kind"): lo spawn headless
-// non passa mai --prompt-kind, quindi una riga lì sarebbe irraggiungibile da
-// ogni chiamante. Il default vive qui, accanto a MODEL_DEFAULT, e non nel
-// catalogo. Resta `opus` mentre i tre recap del catalogo stanno su fable: è
-// l'unico recap che gira in headless (`-p`), senza nessuno che ne legga
-// l'esito mentre si forma e possa rilanciarlo — il testo prodotto è il
-// deliverable, e viene riletto da disco anche giorni dopo.
-export const PROJECT_STATUS_MODEL = 'opus';
-// T66 — le azioni del detail. Non sono un catalogo nuovo: ognuna è un
-// `--prompt-kind` già esistente più `checkpoint`, e tutte passano dallo stesso
-// `spawnForTask` dei CTRL della lista — una superficie in più, zero percorsi di
-// spawn in più.
-//
-// L'etichetta è distinta dal kind dove il kind è il nome del MECCANISMO e
-// l'etichetta quello dell'INTENZIONE: `none` è "aprire la task a mani nude",
-// `recap` è "vedere a che punto sta".
-export const DETAIL_ACTIONS = [
-    { kind: 'none', label: 'open' },
-    { kind: 'preflight', label: 'preflight' },
-    { kind: 'run', label: 'run' },
-    { 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]));
-// T150 — titolo di fallback quando il campo nota è vuoto, derivato dall'AZIONE
-// e dal task. Mappa sul KIND, non sulla label (P2 preflight): alla sede del
-// fallback (`spawnForTask` in actions.ts) arriva il kind — già specializzato
-// quando la chiamata viene dal detail (`recap-task`/`recap-epic`) — mai la
-// label del catalogo.
-// D2/P7 — `none` (label "open") non ha un prefisso: è "nessuna azione", e
-// inventargliene uno contraddirebbe l'intenzione dell'utente.
-// P3 — le tre varianti di recap condividono il prefisso: la specializzazione
-// sceglie quale skill parte, non cosa l'utente sta chiedendo.
-//
-// T156 — emoji invece della parola in maiuscolo (`PREFL`, `RUN`, …): il titolo
-// si legge in lista deck e nella tab Ptyxis, dove l'azione va riconosciuta a
-// colpo d'occhio e non letta.
-// Le quattro sono ASTRALI (code point ≥ U+10000) per necessità, non per gusto:
-// `sanitize` (`src/width.ts`) sostituisce con `·` ogni glifo su cui le due
-// contabilità di larghezza divergono, e le emoji del BMP a presentazione testo
-// (⚙️ ⏱️ 🛠️ …) divergono sempre — string-width le conta 2, VTE ne disegna 1, e
-// il VS16 non sposta nessuno dei due verdetti. Un'emoji aggiunta qui va prima
-// passata in `sanitize` per vedere se sopravvive.
-// Le stesse quattro sono anche l'unica classe di emoji che `_sane_note` di
-// `deck-run` lascia passare nel titolo della tab: la whitelist è una lista
-// chiusa che nomina questi code point (P2 preflight), quindi cambiare una voce
-// qui e non là riapre la divergenza fra titolo in lista e titolo in tab.
-// Le quadre che delimitavano il prefisso sono cadute: l'emoji da sola si stacca
-// già dallo slug, e con lei sono uscite dalla whitelist di `_sane_note`.
-const ACTION_EMOJI = {
-    preflight: '📐',
-    run: '🚀',
-    recap: '📊',
-    'recap-task': '📊',
-    'recap-epic': '📊',
-    checkpoint: '🏁',
-};
-/**
- * Titolo di fallback per una conversazione con nota vuota: `{emoji} {slug}`,
- * o il solo slug per `none` (D1/D2 preflight). Lo slug viene dal NOME del
- * task file (`findTaskFile`), non dalla descrizione di `tasks.md`: il nome è
- * già dentro l'alfabeto di `_sane_note` per costruzione — minuscolo, separato
- * da trattini, senza punteggiatura — mentre la descrizione porta apostrofi e
- * `/` che la riduzione toglie senza sostituto, saldando le parole (D1
- * razionale).
- *
- * Il PREFISSO invece nell'alfabeto non ci sta per costruzione: l'emoji ci entra
- * solo perché la whitelist di `_sane_note` le nomina una per una (T156). È
- * l'unica parte del titolo di fallback che dipende da una modifica fatta
- * dall'altro lato.
- *
- * `null` quando il task file non si trova: il chiamante decide se ripiegare
- * su nota vuota o su un altro fallback.
- */
-export function fallbackTitle(tasksDir, id, kind) {
-    const path = findTaskFile(tasksDir, id);
-    if (!path)
-        return null;
-    const slug = basename(path, '.md').slice(id.length + 1).replace(/-/g, ' ');
-    const emoji = ACTION_EMOJI[kind];
-    return emoji ? `${emoji} ${slug}` : slug;
-}
 // 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.
-// 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`.
-// Il modello, al contrario del kind, ha un default (T108): i percorsi che non
-// passano dal selettore del detail non devono nominarlo per forza, e l'unico
-// valore sensato per loro è quello che il selettore stesso mostra all'apertura.
+// Il modello ha un default (T108): i percorsi che non passano dal selettore del
+// detail non devono nominarlo per forza, e l'unico valore sensato per loro è
+// quello che il selettore stesso mostra all'apertura.
 // T111 — `spawnNote` è la nota data alla NASCITA della conversazione, dal campo
-// sempre attivo del detail. Stesso flag `--title-note` del resume (T64): il
+// sempre attivo del detail — che da T161 nasce PRE-RIEMPITO col template di
+// titolo dell'azione, reso sulla task aperta. Ne discende che un campo svuotato
+// a mano significa «nessuna nota» e non più «usa il titolo di fallback»: il
+// fallback non esiste più, perché il default è già a schermo.
+// Stesso flag `--title-note` del resume (T64): il
 // suffisso `«nota»` viene appeso a `TITLE` dentro deck-run PRIMA che i rami si
 // 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.
-// 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'];
+// T117 — `prompt` è il TESTO letterale, e sostituisce il kind: `--prompt` e
+// `--prompt-kind` sono mutuamente esclusivi in deck-run.
+//
+// T161 — dal deck viaggia SEMPRE il testo, mai più il simbolo. Prima gli
+// acceleratori della lista passavano `--prompt-kind` e lasciavano risolvere il
+// testo a `deck-run`, che consultava il proprio catalogo; il detail passava già
+// il letterale. Con un override di progetto sui prompt la risoluzione deve
+// stare da una parte sola, e quella parte è il deck — che è l'unico dei due a
+// leggere `.claude/loom-works.json` per questo (`jq` è dipendenza opzionale di
+// `deck-run`). Un percorso solo, quindi, e ciò che parte è verificabile
+// sull'argv.
+//
+// Due conseguenze dichiarate: `--prompt-kind` resta in `deck-run` per chi lo
+// invoca a mano, e `LOOM_DECK_ENTER_PROMPT` non ha più effetto sugli spawn dal
+// deck (non ha mai vinto su `--prompt`).
+//
+// Stringa VUOTA = richiesta esplicita di nessun prompt (azione `open`, o un
+// campo svuotato a mano): si esprime col kind `none`, perché senza nessun flag
+// `deck-run` cadrebbe sul proprio default `recap`.
+export function deckArgs(id, sessionId, model = MODEL_DEFAULT, spawnNote, prompt = '') {
+    const promptArgs = 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, prompt) {
-    return launchDeckRun(deckArgs(id, sessionId, kind, model, spawnNote, prompt), cwd);
+export function spawnDeck(id, cwd, sessionId, model = MODEL_DEFAULT, spawnNote, prompt = '') {
+    return launchDeckRun(deckArgs(id, sessionId, 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 +
@@ -399,9 +283,30 @@ export function spawnClaudeEmpty(cwd, model) {
  * Il modello è passato SEMPRE, anche sul default, per la stessa ragione di
  * `permissionMode`: lo spawn resta deterministico e leggibile nel process tree
  * invece di dipendere da un default che può cambiare fra versioni.
+ *
+ * `sessionId` e `title` viaggiano INSIEME o non viaggiano: il titolo lo mostrano
+ * due superfici — la tab Ptyxis (via `--title-note`) e la riga della lista
+ * sessioni (via la nota nel sidecar, che è keyed sul sessionId) — e senza un id
+ * pinnato la seconda non ha una chiave su cui scrivere. Pinnarlo è quindi ciò
+ * che rende il titolo visibile in entrambe, non un binding task: una sessione
+ * `--no-task` non ne ha uno, ma un NOME ce l'ha.
+ *
+ * Il titolo sta in TESTA all'argv, prima del prompt: la riga di stato del deck
+ * taglia il comando al mezzo, e il prompt (specialmente quello cablato dello
+ * srotolamento) è l'argomento più lungo — in coda al titolo lo spingerebbe
+ * fuori vista. Stessa ragione dell'ordine di `resumeArgs`.
  */
-export function spawnBare(cwd, prompt, model) {
-    return launchDeckRun(['--no-task', '--prompt', prompt, '--model', model], cwd);
+export function bareArgs(prompt, model, sessionId, title) {
+    const args = ['--no-task'];
+    if (title)
+        args.push('--title-note', title);
+    if (sessionId)
+        args.push('--session-id', sessionId);
+    args.push('--prompt', prompt, '--model', model);
+    return args;
+}
+export function spawnBare(cwd, prompt, model, sessionId, title) {
+    return launchDeckRun(bareArgs(prompt, model, sessionId, title), cwd);
 }
 // T39/T32: voce `launch` custom del file config, eseguita con cwd = project root.
 // Spawn detached come spawnDeck: il deck lancia ma non possiede il processo.
@@ -555,12 +460,19 @@ export function spawnCleanTasks(ids, cwd, sessionId, ignored, onResult) {
 // permissivo toglie le richieste di permesso che il CLI pone su un tool, e
 // quelle in `-p` non hanno nessuno che risponda — il processo resterebbe appeso
 // senza emettere niente, cioè con l'indicatore che conta all'infinito.
-export function spawnProjectStatus(cwd, sessionId, onResult) {
-    return spawnSkill('/loom-works:recap-status-project', cwd, sessionId, onResult, [
+//
+// T161 — modello e prompt arrivano dal CHIAMANTE, risolti sul catalogo delle
+// azioni: erano gli ultimi due valori che questa funzione sceglieva da sé
+// (`PROJECT_STATUS_MODEL` e la stringa della skill), e con l'override di
+// progetto il default deve stare in un posto solo insieme a quello delle altre
+// dieci azioni. Il `--permission-mode auto` invece resta qui: non è una
+// preferenza ma la condizione perché un `-p` non resti appeso.
+export function spawnProjectStatus(cwd, sessionId, onResult, model = PROJECT_STATUS_MODEL, prompt = '/loom-works:recap-status-project') {
+    return spawnSkill(prompt, cwd, sessionId, onResult, [
         '--permission-mode',
         'auto',
         '--model',
-        PROJECT_STATUS_MODEL,
+        model,
     ]);
 }
 // Comando della notifica desktop. L'override esiste per il collaudo del ramo

package/dist/tasks.js

@@ -1,5 +1,5 @@
 import { readFileSync, readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { sanitize } from './width.js';
 /**
  * Forma di un ID task: `T` + numero. FONTE UNICA del gate — `parseTasks` lo usa
@@ -108,6 +108,26 @@ export function loadTasks(path) {
 // ID → path del task file: `<id>-<slug>.md` nella tasks dir. Il dash dopo l'ID
 // disambigua i prefissi (`T20-` non matcha `T2-…`). Se più file matchano, primo
 // in ordine. `null` se la dir non è leggibile o nessun file matcha.
+/**
+ * T161 — lo SLUG di una task: il nome del suo file senza l'id e coi trattini
+ * sciolti in spazi, cioè il buco `{slug}` dei template di titolo.
+ *
+ * Viene dal NOME del file e non dalla descrizione in `tasks.md` per una ragione
+ * di alfabeto: il nome è già dentro quello di `_sane_note` per costruzione —
+ * minuscolo, separato da trattini, senza punteggiatura — mentre la descrizione
+ * porta apostrofi e `/`, che la riduzione toglie senza sostituto saldando le
+ * parole (`l'epica/doc` → `lepicadoc`).
+ *
+ * Stringa VUOTA quando il task file non si trova: chi interpola tratta un buco
+ * senza valore come «nessun titolo», invece di comporre un prefisso uguale per
+ * ogni task.
+ */
+export function taskSlug(tasksDir, id) {
+    const path = findTaskFile(tasksDir, id);
+    if (!path)
+        return '';
+    return basename(path, '.md').slice(id.length + 1).replace(/-/g, ' ');
+}
 export function findTaskFile(dir, id) {
     let entries;
     try {

package/dist/ui/detail-screen.js

@@ -6,7 +6,7 @@ import { cut } from '../width.js';
 import { sliceLine } from '../text-search.js';
 import { sliceSpans } from '../markdown.js';
 import { ChoiceRow, FieldText, LABEL_W } from './fields.js';
-import { DETAIL_ACTIONS, MODELS } from '../spawn.js';
+import { DETAIL_ACTIONS, MODELS } from '../spawn-catalog.js';
 import { DROW, PRIORITY_CHOICES } 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

package/dist/ui/preview.js

@@ -7,7 +7,7 @@ import { previewTextWidth, previewTitleParts } from '../layout.js';
 import { LIVE_BUSY, LIVE_IDLE, META_KEYS, fmtDateTime, fmtSize, modelAlias, } from '../glyphs.js';
 import { NATURA_SHORT, inboxMark } from '../inbox.js';
 import { ChoiceRow } from './fields.js';
-import { MODELS } from '../spawn.js';
+import { MODELS } from '../spawn-catalog.js';
 /** Colonne del prefisso delle due anteprime della preview sessione (`» `, `« `,
  *  e i due spazi delle righe di continuazione). Costante perché entra nel
  *  budget di wrap, che è il posto in cui dimenticarla non produce un errore ma

package/dist/ui/screens.js

@@ -36,6 +36,7 @@ import { DetailScreen } from './detail-screen.js';
 import { StatusScreen } from './status-screen.js';
 import { InboxScreen } from './inbox-screen.js';
 import { WrapScreen } from './wrap-screen.js';
+import { SpawnScreen } from './spawn-screen.js';
 import { ReaderScreen, SearchScreen } from './search-screen.js';
 /**
  * Il ripiego per un terminale troppo basso: una riga sola al posto della
@@ -107,7 +108,7 @@ export function HintBar({ mode, purge, keyLegend, indicators, columns, }) {
  */
 export function screenFor(input) {
     const { mode, rows, columns, note, overlays } = input;
-    const { assign, sheet, search, status, inbox, wrap } = overlays;
+    const { assign, sheet, search, status, inbox, wrap, spawn } = overlays;
     // ── T57 · schermata di assegnazione ─────────────────────────────────────
     // Sostitutiva come ricerca e reader (D3): la lista task non entra in un box
     // sopra i due pane, e prendendo l'intero frame non costa nulla al loro budget.
@@ -185,6 +186,16 @@ export function screenFor(input) {
         const start = Math.min(wrap.top, wrap.maxTop);
         return (_jsx(WrapScreen, { files: wrap.files.slice(start, start + wrap.capacity), count: wrap.count, mixed: wrap.mixed, mtime: wrap.mtime, top: start, capacity: wrap.capacity, path: wrap.path, caret: wrap.caret, columns: columns }));
     }
+    // ── T161 · pagina delle azioni di spawn ─────────────────────────────────
+    // Ottava schermata sostitutiva: undici righe per quattro colonne, più l'area
+    // di compilazione. In un box sopra i due pane al prompt resterebbero due
+    // colonne.
+    if (mode === 'spawn' && spawn.open) {
+        if (isCompact(spawn.capacity)) {
+            return _jsx(CompactNotice, { what: "azioni di spawn", esc: "chiude", rows: rows, columns: columns });
+        }
+        return (_jsx(SpawnScreen, { rows: spawn.table, sel: spawn.sel, top: Math.min(spawn.top, spawn.maxTop), capacity: spawn.capacity, configured: spawn.table.filter((r) => r.touched).length, dirty: spawn.dirty, editing: spawn.editing, editable: spawn.editable, fieldTitle: spawn.fieldTitle, fieldModel: spawn.fieldModel, fieldPrompt: spawn.fieldPrompt, cursor: spawn.cursor, example: spawn.example, columns: columns, note: note }));
+    }
     // ── T52 · ricerca e reader ──────────────────────────────────────────────
     // Gli unici modali che NON stanno in flusso sopra i pane: una lista di
     // occorrenze non entra in un box da 4 righe. Prendono l'intero frame, quindi

package/dist/ui/spawn-screen.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// T161 — la pagina delle azioni di spawn: la tabella e la sua area di
+// compilazione.
+import { Box, Text } from 'ink';
+import { cut, pad, sanitize, termWidth } from '../width.js';
+import { ChoiceRow, FieldText, LABEL_W } from './fields.js';
+import { CARET, CARET_OFF } from '../glyphs.js';
+import { interpolate, saneNote } from '../sane-note.js';
+import { MODELS, SPAWN_FIELDS, spawnCell, } from '../spawn-catalog.js';
+/**
+ * Il glifo della riga configurata.
+ *
+ * Non è riusato da nessun'altra superficie del deck: `●`/`◍` dicono la liveness
+ * di un processo, `📌`/`🔗`/`○` l'appartenenza di una conversazione, `✎` il
+ * titolo — un falso amico costa più di un simbolo nuovo. Concorde alle due
+ * contabilità di larghezza (`agrees('◆')`), quindi `sanitize` lo lascia passare
+ * invece di renderlo `·`.
+ */
+const TOUCHED = '◆';
+/** Cella del glifo: si riempie di spazi anche quando è vuota, o le righe non
+ *  configurate sposterebbero a sinistra tutto ciò che segue. */
+const MARK_W = 2;
+/** Colonna modello: il dominio è chiuso, e a decidere la larghezza non è la voce
+ *  più lunga (`sonnet`, 6) ma l'INTESTAZIONE — `modello` ne vuole 7, e una
+ *  testata di colonna troncata con l'ellissi si legge come un difetto. */
+const MODEL_W = 7;
+/** Tetto della colonna funzione: la label più lunga del catalogo (`drain di un
+ *  file inbox`) sta esattamente dentro. Un tetto più alto le celle le
+ *  toglierebbe al prompt, che è l'unico dei quattro valori senza una forma
+ *  breve; più basso troncherebbe due label su undici già a piena larghezza. */
+const FUNC_MAX = 22;
+/** Le etichette delle righe dell'area, in italiano come ogni altra etichetta a
+ *  schermo: la chiave del campo è un nome del codice e finisce nel file di
+ *  progetto, non sotto gli occhi di chi compila. */
+const FIELD_LABEL = {
+    title: 'titolo',
+    model: 'modello',
+    prompt: 'prompt',
+};
+/**
+ * Le quattro colonne, per sottrazione come ogni lista del deck: le fisse sono
+ * note, e ciò che resta si divide fra titolo e prompt.
+ *
+ * Il prompt prende la fetta maggiore perché è l'unico dei quattro valori che non
+ * ha una forma breve: un titolo tagliato resta riconoscibile dal prefisso, un
+ * prompt tagliato a dieci colonne dice solo `/loom-works…`.
+ *
+ * Pavimento 0 su ogni cella: è un tetto, non una preferenza, e alzarlo sopra lo
+ * spazio reale fa uscire la riga dal box mangiandone il bordo (invariante ③ di
+ * `width.ts`).
+ */
+export function spawnColumns(width, rows) {
+    // `- 4` = bordo + padding del box tabella, che sta DENTRO quello esterno.
+    const avail = Math.max(0, width - 4);
+    const func = Math.min(FUNC_MAX, Math.max(0, ...rows.map((r) => termWidth(r.action.label))));
+    // I tre separatori fra le quattro colonne vanno contati insieme alle celle:
+    // sommare solo le celle è l'off-by-one che tronca la coda della riga.
+    const rest = Math.max(0, avail - CARET_OFF.length - MARK_W - func - MODEL_W - 3);
+    // Il titolo ha un TETTO oltre il quale non cresce: i template sono corti
+    // (`📊 {slug}`), quindi su un terminale largo ogni colonna in più gli
+    // resterebbe vuota mentre al prompt serve.
+    const title = Math.min(28, Math.floor(rest * 0.4));
+    return { func, title, model: MODEL_W, prompt: Math.max(0, rest - title) };
+}
+/** Una cella della tabella, col suo colore: il valore in chiaro, il segnaposto
+ *  smorzato, l'override in ciano — l'origine si legge senza una legenda. */
+function Cell({ row, field, value, width, }) {
+    const cell = spawnCell(row.action, field, value, row.raw.overridden.has(field));
+    const text = cut(cell.text, width);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: cell.placeholder, color: cell.origin === 'override' && !cell.placeholder ? 'cyan' : undefined, children: text }), ' '.repeat(Math.max(0, width - termWidth(text)))] }));
+}
+export function SpawnScreen({ rows, sel, top, capacity, configured, dirty, editing, editable, fieldTitle, fieldModel, fieldPrompt, cursor, example, columns, note, }) {
+    const width = Math.max(20, (columns || 80) - 4);
+    const col = spawnColumns(width, rows);
+    const window = rows.slice(top, top + capacity);
+    const current = rows[sel];
+    /** La riga disegnata `field` è quella in fuoco? Il cursore indicizza le sole
+     *  celle editabili, la resa le disegna tutte e tre. */
+    const focused = (field) => editing && editable[cursor.row] === field;
+    const textW = Math.max(10, width - LABEL_W - CARET_OFF.length);
+    // L'anteprima si fa sul titolo GIÀ ridotto, come lo farà `deck-run`: mostrare
+    // il template interpolato ma non ridotto prometterebbe un titolo che la tab
+    // non porta.
+    const rendered = saneNote(interpolate(fieldTitle, example) ?? '');
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: "azioni di spawn" }), ' ', _jsxs(Text, { dimColor: true, children: ["\u00B7 ", rows.length, " azioni \u00B7 ", configured, " configurate"] }), dirty ? _jsx(Text, { color: "yellow", children: " \u00B7 modifiche non salvate" }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), ' ', editing ? 'conferma' : 'modifica', " \u00B7 ", _jsx(Text, { color: "yellow", children: "CANC" }), " torna al default \u00B7", ' ', _jsx(Text, { color: "yellow", children: "w" }), " salva \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), ' ', editing ? 'annulla' : 'chiude'] }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [CARET_OFF, ' '.repeat(MARK_W), pad('funzione', col.func), " ", pad('titolo', col.title), " ", pad('modello', col.model), ' ', pad('prompt', col.prompt)] }), window.map((r, i) => {
+                        const at = top + i;
+                        return (_jsxs(Text, { wrap: "truncate-end", children: [at === sel ? CARET : CARET_OFF, _jsx(Text, { color: "cyan", children: pad(r.touched ? TOUCHED : '', MARK_W) }), _jsx(Text, { bold: at === sel, children: pad(cut(r.action.label, col.func), col.func) }), ' ', _jsx(Cell, { row: r, field: "title", value: r.raw.title, width: col.title }), ' ', _jsx(Cell, { row: r, field: "model", value: r.raw.model, width: col.model }), ' ', _jsx(Cell, { row: r, field: "prompt", value: r.raw.prompt, width: col.prompt })] }, r.action.id));
+                    })] }), editing ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [SPAWN_FIELDS.map((field) => {
+                        const fixed = current.action.fixed[field];
+                        if (fixed !== undefined) {
+                            return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [CARET_OFF, FIELD_LABEL[field].padEnd(LABEL_W), "(", fixed, ")"] }, field));
+                        }
+                        if (field === 'model') {
+                            return (_jsx(ChoiceRow, { label: "modello", values: MODELS, index: Math.max(0, MODELS.indexOf(fieldModel)), focused: focused('model'), width: width }, field));
+                        }
+                        const value = field === 'title' ? fieldTitle : fieldPrompt;
+                        return (_jsxs(Text, { wrap: "truncate-end", children: [focused(field) ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: FIELD_LABEL[field].padEnd(LABEL_W) }), _jsx(FieldText, { value: value, caret: cursor.caret, focused: focused(field), cols: textW })] }, field));
+                    }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [CARET_OFF, 'esempio'.padEnd(LABEL_W), current.action.title === null ? ('nessun titolo per questa azione') : (_jsx(Text, { color: rendered ? 'green' : undefined, children: rendered ? cut(rendered, textW) : 'titolo a vuoto: nessuna nota' }))] })] })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+}

package/dist/viewport.js

@@ -95,6 +95,10 @@ export const MODAL_HEIGHT = {
     // 77 `WRAP` e 147 `misto`, cioè una lista che non entra in nessun box sopra i
     // pane. Altezza da `wrapListCapacity`.
     wrap: 0,
+    // T161 — la pagina delle azioni di spawn: ottava sostitutiva. Undici righe di
+    // tabella più l'area di compilazione: in un box sopra i pane resterebbero due
+    // colonne per il prompt. Altezza da `spawnListCapacity`.
+    spawn: 0,
 };
 /**
  * Distribuisce le righe disponibili fra lista task, lista sessioni e preview.
@@ -335,6 +339,37 @@ const WRAP_CHROME = 12;
 export function wrapListCapacity(rows) {
     return Math.max(0, (rows || 24) - SLACK - WRAP_CHROME);
 }
+// T161 — cornice della pagina delle azioni di spawn.
+//   2  bordi del box esterno
+//   1  riga di testata (nome della pagina · quante righe · quante configurate)
+//   1  riga hint
+//   1  marginTop del box tabella
+//   2  bordi del box tabella
+//   1  riga di intestazione delle colonne
+const SPAWN_CHROME = 8;
+// L'area di compilazione: marginTop + le TRE righe (titolo, modello, prompt) +
+// la riga dell'anteprima resa.
+//
+// Fisse e non proporzionali alle celle editabili della riga aperta: su `bare`,
+// che ha il solo modello, le altre due si disegnano comunque per dire perché non
+// si modificano. Un'altezza che dipendesse dalla riga selezionata farebbe
+// saltare la tabella di due righe a ogni movimento del caret, e il budget
+// dovrebbe sapere quale riga è aperta per non sottostimare — lo stesso motivo
+// per cui le cinque righe del detail sono dentro `DETAIL_CHROME` invece che
+// condizionali (T111 · D1).
+const SPAWN_FIELDS_CHROME = 5;
+/**
+ * Righe di tabella che entrano nel terminale.
+ *
+ * Le righe dell'area aperta e la riga di stato si pagano QUI, non altrove: la
+ * pagina è una schermata sostitutiva, quindi la nota che le sue azioni scrivono
+ * la disegna lei — a differenza della lista, dove la riga di stato sta fuori dai
+ * pane e il suo costo è già in `layoutBudget`.
+ */
+export function spawnListCapacity(rows, editing = false, noteLine = false) {
+    const extra = (editing ? SPAWN_FIELDS_CHROME : 0) + (noteLine ? 1 : 0);
+    return Math.max(0, (rows || 24) - SLACK - SPAWN_CHROME - extra);
+}
 /**
  * Righe scorse da una pressione di PagGiù/PagSu: METÀ della capienza visibile.
  *

package/dist/wrap-scan.js

@@ -84,23 +84,29 @@ export function mixedCount(files) {
 /** Radice di default dell'area di srotolamento: la project root intera (D4). */
 export const WRAP_DEFAULT_PATH = '.';
 /**
- * Il prompt della sessione che srotola un path.
+ * T161 — il buco `{path}` del titolo e del prompt di una sessione di
+ * srotolamento: il path reso a parole.
  *
- * CABLATO per decisione, non per fretta (D9): parametrizzarlo prima di aver
- * visto come si comporta significherebbe scegliere i parametri a occhio. Le tre
- * cose che dice sono le tre che rendono l'operazione reversibile e verificabile
- * — backup fuori dal repo, rapporto, commit solo se il diff è chiaramente
- * innocuo — e nessuna delle tre è una preferenza da esporre.
+ * Le barre diventano spazi e l'estensione cade QUI, prima di `_sane_note`, il
+ * cui alfabeto non ha né `/` né `.`: lasciandoceli cadere le parole si
+ * salderebbero (`runtimereferencedoc-systemmd`), e il titolo della tab
+ * divergerebbe da quello che la lista del deck legge dal sidecar.
  *
- * Il `<path>` è l'unico buco. Arriva dal campo della lista e finisce dentro
- * `--prompt` come argv singolo, quindi non passa da nessuna shell prima di
- * `deck-run`, che lo quota ad apici singoli: non c'è quoting da fare qui.
+ * Il path di default (`.`, la project root intera) non ha parole da mostrare e
+ * diventa una frase: interpolato in `📏 {path}` darebbe il solo prefisso, cioè
+ * un titolo uguale per ogni srotolamento.
+ *
+ * L'emoji del prefisso non sta più qui: è dentro il template della riga
+ * `unwrap` del catalogo delle azioni, dove il progetto può riscriverla.
  */
-export function wrapPrompt(path) {
+export function wrapWords(path) {
     const target = path.trim() || WRAP_DEFAULT_PATH;
-    return (`lancia md-wrap modo apply su ${target} e backup in cartella tmp dedicata. ` +
-        'verifica risultato e fai rapporto. se le modifiche sono tutte chiaramente safe, ' +
-        'puoi committare direttamente');
+    if (target === WRAP_DEFAULT_PATH)
+        return 'tutto il progetto';
+    return target
+        .replace(/\.md$/i, '')
+        .replace(/[./]+/g, ' ')
+        .trim();
 }
 /**
  * Cartella della cache, una per utente e con `mode 0700` — stessa ragione del

package/package.json

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