@lamemind/loom-deck 0.67.0 → 0.69.0

package/dist/spawn-config.js

@@ -0,0 +1,280 @@
+// T161 — gli OVERRIDE di progetto delle azioni di spawn: lettura, validazione,
+// risoluzione della terna, scrittura.
+//
+// ── La sede (P19 preflight) ─────────────────────────────────────────────────
+// Blocco `spawn` dentro `.claude/loom-works.json`, il file di progetto che il
+// deck già apre in tre loader (`launch`, `archivableDays`, `identity`) e che
+// `deck-run` legge con `jq`. Nessun file nuovo: sotto `.claude/` ci sono già tre
+// file di loom, e le impostazioni di spawn sono decisioni di progetto che devono
+// viaggiare col repo — cioè committate, esattamente come `permissionMode` e
+// `order`, e a differenza della vista (`.claude/loom/deck-view.json`, che è
+// gitignored perché è una preferenza di questa macchina).
+//
+// Il costo della scelta, dichiarato: da qui in poi il deck SCRIVE in
+// `loom-works.json`, cosa che prima non faceva mai. Il saver è un
+// read-modify-write che conserva ogni altra chiave nel suo ordine e tocca il
+// solo blocco `spawn`, e RIFIUTA di scrivere se il file non si parsa — quel file
+// regge identità, label e registry di compass, e rigenerarlo da zero al posto di
+// uno rotto significherebbe perderli.
+//
+// Lo schema del plugin (`templates/loom-works.schema.json`) dichiara
+// `additionalProperties: false` e il blocco `spawn` non vi compare ancora: non è
+// un errore a runtime, perché `cfg_validate` in `lib-config.sh` è jq scritto a
+// mano sui soli campi noti e un campo sconosciuto passa. Lo schema è reference
+// per chi scrive il file a mano, e la voce `"spawn": { "type": "object" }` lo
+// raggiunge al prossimo publish del plugin (Prod Validation della task).
+//
+// ── Il formato ──────────────────────────────────────────────────────────────
+//   "spawn": { "<id azione>": { "title"?: string, "model"?: alias, "prompt"?: string } }
+//
+// SOLO override: una chiave assente significa «il default del deck», e il blocco
+// sparisce dal file quando non resta nessun override. Vuoto ≠ assente (P15): un
+// `"title": ""` è un override legittimo che dice «nessuna nota».
+//
+// ── Chi legge cosa ──────────────────────────────────────────────────────────
+// Il blocco lo legge il SOLO deck, che risolve la terna e la passa a `deck-run`
+// sempre esplicita nell'argv (`--title-note`, `--model`, `--prompt`). `deck-run`
+// non lo legge e non deve: `jq` è dipendenza OPZIONALE di quello script, e
+// dargli un blocco JSON da consultare la renderebbe obbligatoria su un percorso
+// che oggi degrada senza. La cascata env → catalogo → `fable` di `deck-run`
+// resta intatta per chi lo invoca a mano.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { configFilePath } from './config.js';
+import { modelFor } from './prompt-catalog.js';
+import { interpolate, saneNote, saneTemplate } from './sane-note.js';
+import { MODEL_DEFAULT, SPAWN_ACTIONS, SPAWN_FIELDS, editableFields, isModelKind, spawnAction, } from './spawn-catalog.js';
+/** La chiave del blocco nel file di progetto. Costante e non letterale sparso:
+ *  la nominano il parser, il saver e il messaggio d'avviso. */
+export const SPAWN_BLOCK = 'spawn';
+/**
+ * Validazione per VOCE, non per file (P7).
+ *
+ * La voce sbagliata cade con una nota che la nomina, il resto vive. Rifiutare
+ * l'intero blocco alla prima chiave sporca significherebbe che un refuso su una
+ * riga spegne in silenzio gli override di tutte le altre; e conservare per
+ * sempre le voci ignote significherebbe riscriverle a ogni salvataggio, cioè
+ * tenere in vita nel file una configurazione che nessuno legge più. È lo stesso
+ * regime di `sanitizeSort` (`view-store.ts`) e di `parseLaunch`.
+ *
+ * Cosa cade e cosa no:
+ *  - id fuori catalogo → l'intera voce, con nota (un'azione che non esiste più);
+ *  - modello fuori dai quattro alias → il solo campo, con nota (arriverebbe al
+ *    CLI e produrrebbe una tab con un comando che fallisce all'avvio);
+ *  - campo su una cella FISSA → il solo campo, con nota (il valore non avrebbe
+ *    nessuna strada per arrivare allo spawn);
+ *  - titolo → ridotto, mai scartato: quello che si legge nella pagina è quello
+ *    che comparirà nella tab, anche quando il file è stato scritto a mano;
+ *  - prompt → qualunque testo, che viaggia come argv singolo.
+ */
+export function parseSpawnOverrides(raw) {
+    const entries = new Map();
+    const warnings = [];
+    if (!raw || typeof raw !== 'object')
+        return { entries, warnings };
+    const block = raw[SPAWN_BLOCK];
+    if (block === undefined)
+        return { entries, warnings };
+    if (!block || typeof block !== 'object' || Array.isArray(block)) {
+        warnings.push(`blocco ${SPAWN_BLOCK} ignorato: non è un oggetto`);
+        return { entries, warnings };
+    }
+    for (const [id, value] of Object.entries(block)) {
+        const action = spawnAction(id);
+        if (!action) {
+            warnings.push(`${SPAWN_BLOCK}.${id}: azione fuori catalogo, voce scartata`);
+            continue;
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            warnings.push(`${SPAWN_BLOCK}.${id}: non è un oggetto, voce scartata`);
+            continue;
+        }
+        const src = value;
+        const editable = new Set(editableFields(action));
+        const out = {};
+        for (const field of SPAWN_FIELDS) {
+            const v = src[field];
+            if (v === undefined)
+                continue;
+            if (!editable.has(field)) {
+                warnings.push(`${SPAWN_BLOCK}.${id}.${field}: ${action.fixed[field]}, campo scartato`);
+                continue;
+            }
+            if (field === 'model') {
+                if (!isModelKind(v)) {
+                    warnings.push(`${SPAWN_BLOCK}.${id}.model: '${String(v)}' non è un modello, campo scartato`);
+                    continue;
+                }
+                out.model = v;
+                continue;
+            }
+            if (typeof v !== 'string') {
+                warnings.push(`${SPAWN_BLOCK}.${id}.${field}: non è un testo, campo scartato`);
+                continue;
+            }
+            if (field === 'title')
+                out.title = saneTemplate(v);
+            else
+                out.prompt = v;
+        }
+        // Una voce rimasta senza nessun campo valido non entra: nella pagina
+        // marcherebbe la riga come «toccata» senza che niente sia stato cambiato.
+        if (Object.keys(out).length > 0)
+            entries.set(action.id, out);
+    }
+    return { entries, warnings };
+}
+/** File assente → nessun override e NESSUN avviso: è lo stato normale di un
+ *  progetto che non ha mai aperto la pagina, come per `loadLaunch` e
+ *  `loadArchivableDays`. Illeggibile o non-JSON → default con avviso: lì c'è un
+ *  file, e sta dicendo qualcosa che non si riesce a leggere. */
+export function loadSpawnOverrides(projectRoot) {
+    let text;
+    try {
+        text = readFileSync(configFilePath(projectRoot), 'utf8');
+    }
+    catch {
+        return { entries: new Map(), warnings: [] };
+    }
+    try {
+        return parseSpawnOverrides(JSON.parse(text));
+    }
+    catch {
+        return {
+            entries: new Map(),
+            warnings: [`${configFilePath(projectRoot)} non si parsa: override di spawn ignorati`],
+        };
+    }
+}
+/**
+ * Default del deck ← override di progetto, più l'interpolazione dei buchi.
+ *
+ * La precedenza è a due soli livelli, per tutta la task: i valori cablati nel
+ * sorgente sono i default, l'unico livello di override è il progetto. Nessuna
+ * configurazione d'utente — né sotto `~/.claude/`, né sotto `~/.config/`.
+ *
+ * Dentro il livello «default» ci sono però due sorgenti, e l'ordine conta: il
+ * modello e il prompt cablati nella riga di catalogo vincono su quelli del
+ * catalogo dati, che si consulta solo per le azioni che hanno un `kind`. È
+ * l'ordine giusto perché un'azione senza `kind` non ha una riga in
+ * `prompt-catalog` per costruzione, e una che ce l'ha non porta valori propri.
+ */
+export function resolveSpawn(action, overrides, catalog, holes = {}) {
+    const raw = rawSpawn(action, overrides, catalog);
+    let prompt = raw.prompt;
+    if (prompt)
+        prompt = interpolate(prompt, holes) ?? '';
+    // La riduzione si applica DOPO l'interpolazione, perché i buchi portano dentro
+    // testo che l'alfabeto non ammette: uno slug col punto, un path con le barre.
+    // Quello che esce di qui è la stessa stringa che `deck-run` comporrà.
+    const filled = raw.title === null ? null : interpolate(raw.title, holes);
+    const title = filled === null ? null : saneNote(filled) || null;
+    return { title, model: raw.model, prompt, overridden: raw.overridden };
+}
+/** La terna di un'azione per ID di catalogo. Due chiamanti — l'attuatore, che la
+ *  espone a tutte le sedi di spawn, e il valore iniziale del selettore della
+ *  sessione nuda, che si risolve prima che l'attuatore esista — e una sola
+ *  implementazione. */
+export function resolveSpawnId(id, overrides, catalog, holes = {}) {
+    return resolveSpawn(spawnAction(id), overrides, catalog, holes);
+}
+/**
+ * Gli stessi tre valori PRIMA dell'interpolazione: i template coi buchi ancora
+ * dentro.
+ *
+ * È la forma che la pagina mostra e fa modificare (P9 preflight): nella cella si
+ * legge `🚀 {slug}`, non il titolo di una task particolare — un valore già reso
+ * si modificherebbe a partire da un esempio, e ogni modifica cancellerebbe il
+ * buco senza che nulla lo dica. L'esempio reso sta accanto, nell'area di
+ * compilazione, dove serve a vedere l'effetto senza essere il campo.
+ *
+ * Serve anche al confronto col DEFAULT: chi conferma una modifica scrive la
+ * cella solo se differisce dal grezzo che uscirebbe senza override, ed è così
+ * che un valore riportato a mano al default smette di essere un override invece
+ * di restare nel file come una riga che non cambia niente.
+ */
+export function rawSpawn(action, overrides, catalog) {
+    const ov = overrides.get(action.id) ?? {};
+    const overridden = new Set(Object.keys(ov));
+    const model = ov.model ??
+        action.model ??
+        (action.kind ? modelFor(catalog, action.kind) : undefined) ??
+        MODEL_DEFAULT;
+    let prompt;
+    if (ov.prompt !== undefined)
+        prompt = ov.prompt;
+    else if (action.prompt !== null)
+        prompt = action.prompt;
+    // Catalogo dati assente o voce mancante → nessun prompt, non un testo
+    // inventato qui: un default scritto nel deck sarebbe la copia del catalogo che
+    // il file dati esiste per non avere.
+    else if (action.kind)
+        prompt = catalog.get(action.kind)?.template ?? '';
+    else
+        prompt = null;
+    return { title: ov.title ?? action.title, model, prompt, overridden };
+}
+/**
+ * Il blocco `spawn` come lo si scrive nel file: le sole voci non vuote, coi soli
+ * campi presenti, ordinate come il catalogo.
+ *
+ * L'ordine è quello di `SPAWN_ACTIONS` e non quello di inserimento nella mappa:
+ * il file è committato e lo si legge in diff, dove una riga che si sposta da
+ * sola a ogni salvataggio è rumore su cui poi si fa merge.
+ *
+ * `undefined` quando non resta nessun override: il chiamante toglie la chiave
+ * invece di scrivere `"spawn": {}`, che sarebbe una configurazione vuota da
+ * spiegare a chi la legge.
+ */
+export function serializeSpawnBlock(entries) {
+    const out = {};
+    // L'ordine viene da `SPAWN_ACTIONS`, non da una seconda lista di id scritta
+    // qui: una copia dell'elenco diverge alla prima riga aggiunta al catalogo, e
+    // la voce nuova finirebbe fuori dal file senza che niente lo segnali.
+    for (const action of SPAWN_ACTIONS) {
+        const ov = entries.get(action.id);
+        if (!ov)
+            continue;
+        const clean = {};
+        if (ov.title !== undefined)
+            clean.title = ov.title;
+        if (ov.model !== undefined)
+            clean.model = ov.model;
+        if (ov.prompt !== undefined)
+            clean.prompt = ov.prompt;
+        if (Object.keys(clean).length > 0)
+            out[action.id] = clean;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * Scrive il blocco `spawn` nel file di progetto, conservando tutto il resto.
+ *
+ * Read-modify-write su un file che NON è nostro: `loom-works.json` regge
+ * identità, label, surface, registry di compass e `permissionMode`, e il deck
+ * finora non ci aveva mai scritto. Da qui le due cautele:
+ *  - se il file non si parsa la funzione LANCIA invece di rigenerarlo: un
+ *    `loom-works.json` rotto va riparato a mano, non sostituito con uno che ha
+ *    perso l'identità del progetto;
+ *  - ogni altra chiave sopravvive nel suo ordine (`JSON.parse` conserva l'ordine
+ *    di inserimento delle chiavi stringa, `JSON.stringify` lo riscrive uguale),
+ *    così il diff del commit mostra il solo blocco toccato.
+ *
+ * File ASSENTE: anche qui si lancia. Un progetto senza `loom-works.json` non è
+ * registrato, e creargliene uno col solo blocco `spawn` produrrebbe un file che
+ * fallisce ogni validazione a valle.
+ */
+export function saveSpawnOverrides(projectRoot, entries) {
+    const path = configFilePath(projectRoot);
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${path}: non è un oggetto JSON`);
+    }
+    const doc = parsed;
+    const block = serializeSpawnBlock(entries);
+    if (block)
+        doc[SPAWN_BLOCK] = block;
+    else
+        delete doc[SPAWN_BLOCK];
+    writeFileSync(path, JSON.stringify(doc, null, 2) + '\n', 'utf8');
+}

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,171 +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 stanno anche nella whitelist di `_sane_note` in `deck-run`,
-// che è una lista chiusa di code point (P2 preflight): cambiare una voce qui e
-// non là riapre la divergenza fra titolo in lista e titolo in tab. La whitelist
-// è più larga di questa tabella — porta anche le emoji dei titoli che non
-// nascono da un'azione su task (🧹 drain di un file inbox, `src/inbox.ts`; 📏
-// srotolamento di un path, `src/wrap-scan.ts`).
-// 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 +
@@ -578,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/task-index.js

@@ -37,6 +37,31 @@ export function appendNote(projectRoot, sessionId, note) {
 export function appendPriority(projectRoot, sessionId, priority) {
     appendSessionRecord(projectRoot, { sessionId, priority });
 }
+/**
+ * T162 — scrive i campi DERIVATI (`title`, `model`) di una conversazione.
+ *
+ * I due vanno in UN record e non in due, anche se il lettore risolve last-wins
+ * per campo e due append darebbero lo stesso esito finale: due record lasciano
+ * un istante in cui su disco lo stato è a metà, e in quel mezzo ci sta il
+ * lettore di compass — che mostrerebbe il titolo nuovo e riprenderebbe col
+ * modello vecchio. È la stessa regola di `writeSessionMarks` lato compass.
+ *
+ * Il record porta SOLO i campi passati: uno che portasse anche l'altro col
+ * valore che aveva prima lo riscriverebbe, e il last-wins trasformerebbe quella
+ * riscrittura in una sovrascrittura di ciò che un altro scrittore ha messo nel
+ * frattempo. Un insieme vuoto non scrive niente, invece di appendere un record
+ * col solo `sessionId` che nessun lettore userebbe.
+ */
+export function appendSessionMeta(projectRoot, sessionId, fields) {
+    const rec = { sessionId };
+    if (fields.title !== undefined)
+        rec.title = fields.title;
+    if (fields.model !== undefined)
+        rec.model = fields.model;
+    if (rec.title === undefined && rec.model === undefined)
+        return;
+    appendSessionRecord(projectRoot, rec);
+}
 // Una sola lettura del JSONL per entrambe le mappe: il deck poll-a l'indice a
 // ogni tick, leggere il file due volte raddoppierebbe l'I/O per nulla.
 // Last-wins per campo (un re-pin dello stesso sessionId sovrascrive), e i due
@@ -48,12 +73,14 @@ export function loadSessionIndex(projectRoot) {
     const pinned = new Map();
     const notes = new Map();
     const priority = new Set();
+    const titles = new Map();
+    const models = new Map();
     let content;
     try {
         content = readFileSync(taskIndexPath(projectRoot), 'utf8');
     }
     catch {
-        return { bindings, forkOf, pinned, notes, priority };
+        return { bindings, forkOf, pinned, notes, priority, titles, models };
     }
     let order = 0; // posizione crescente dei record pinned → rango di pin (D2)
     for (const line of content.split('\n')) {
@@ -108,10 +135,32 @@ export function loadSessionIndex(projectRoot) {
                 else
                     priority.delete(d.sessionId);
             }
+            // T162 — stesso last-wins per campo di `note`, con una differenza che
+            // conta: NESSUNA sanificazione in lettura. `note` la paga perché il deck
+            // la mette nel frame e il file è editabile a mano; qui il valore non
+            // entra nel frame (il deck il titolo lo ha dalla `Session`) e chi lo
+            // rende — compass, sotto Pango — non fa contabilità di colonne.
+            //
+            // Sanificare qui avrebbe un costo suo: il deck decide se riempire il
+            // buco CONFRONTANDO il valore letto con quello derivato, e un valore
+            // riscritto in lettura non combacerebbe mai col derivato — un append a
+            // ogni tick del poll, per sempre, senza nessun errore a dirlo.
+            if (typeof d.title === 'string') {
+                if (d.title)
+                    titles.set(d.sessionId, d.title);
+                else
+                    titles.delete(d.sessionId);
+            }
+            if (typeof d.model === 'string') {
+                if (d.model)
+                    models.set(d.sessionId, d.model);
+                else
+                    models.delete(d.sessionId);
+            }
         }
         catch {
             // riga corrotta → skip
         }
     }
-    return { bindings, forkOf, pinned, notes, priority };
+    return { bindings, forkOf, pinned, notes, priority, titles, models };
 }

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