@lamemind/loom-deck 0.61.0 → 0.62.0

package/dist/actions.js

@@ -15,8 +15,9 @@
 // `test/modes-smoke.test.ts` (`seleziona una task`, `terminale su`, `deck-run`,
 // `nessun push`, `eliminare N task?`, `scartate`): si copiano verbatim, non si
 // migliorano di passaggio.
-import { useRef } from 'react';
+import { useMemo, useRef } from 'react';
 import { randomUUID } from 'node:crypto';
+import { loadPromptCatalog, modelFor } from './prompt-catalog.js';
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, } from './task-index.js';
 import { neighborId } from './session-list.js';
 import { cut, cutMiddle } from './width.js';
@@ -57,6 +58,9 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
     // prima dell'exec), ed è anche il comando da ripetere a mano per vedere
     // l'errore. Il salto fra le due dura i millisecondi che `deck-run` impiega a
     // comporre.
+    // T152 — stessa fonte del detail (sheet.ts): un file di sei righe accanto al
+    // codice, letto una volta per vita del deck.
+    const catalog = useMemo(() => loadPromptCatalog(), []);
     const spawnSeq = useRef(0);
     function noteSpawn(spawned) {
         noteCommand(spawned.cmd);
@@ -132,8 +136,11 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
     // invece deve restare vivo.
     function spawnTaskSession(kind, keyLabel) {
         const task = selectedTaskOr(keyLabel, 'spawnare');
+        // T152 — stesso catalogo del detail: senza, `^R` partirebbe sul default
+        // fisso mentre l'azione `run` del detail parte sul modello del kind, e le
+        // due superfici divergerebbero sullo stesso comando.
         if (task)
-            spawnForTask(task.id, kind, MODEL_DEFAULT);
+            spawnForTask(task.id, kind, modelFor(catalog, kind) ?? MODEL_DEFAULT);
     }
     // T49 — resume di una conversazione in una nuova tab. Unico punto: lo chiamano
     // il `⏎` della lista sessioni e quello sulla riga-sessione della ricerca, che

package/dist/commit-times.js

@@ -18,6 +18,32 @@ const FORMAT_RE = /^#(\d+)$/;
 // Il basename del task file, non il path intero (che cambia con la docs-root)
 // e non `TASK_ID_RE` di tasks.ts (ancorata all'id nudo, non matcha `T136-x.md`).
 const TASK_FILE_RE = /^(T\d+)-.*\.md$/;
+const EMPTY_MAP = new Map();
+/**
+ * T153 — gate module-level: `git log` gira solo se lo sha di HEAD è cambiato
+ * dall'ultima chiamata su questa stessa coppia (tasksDir, projectRoot). Le
+ * date di ultimo commit cambiano SOLO se HEAD si muove (§Implementation
+ * Notes T153): un rev-parse fallito degrada come degradava il log, mai un
+ * throw. `key` tiene le due coppie separate — un test che passa tmpdir
+ * diversi a chiamate successive non deve leggere la cache dell'altro.
+ */
+let cache = null;
+let logSpawns = 0;
+/** T153/DLV6 — quante volte è partito lo spawn COSTOSO (`git log`), non il
+ *  gate. Il gate (`rev-parse`) gira a ogni chiamata per costruzione: contarlo
+ *  renderebbe il numero inutile a dimostrare il no-op. */
+export function commitLogSpawnCount() {
+    return logSpawns;
+}
+async function headSha(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: projectRoot });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Parsing puro dell'output `git log --format=#%ct --name-only`. Isolato da
  * `commitTimes` perché è l'unica parte che vale la pena collaudare: invocare
@@ -54,13 +80,33 @@ export function parseCommitLog(output) {
  * incompleta proprio per le task vecchie mai più toccate, quelle che sotto
  * `desc` finiscono in coda — dove un timestamp assente e uno vecchio si
  * confonderebbero.
+ *
+ * T153 — gate su `rev-parse HEAD` (un ordine di grandezza più economico
+ * dello spawn del log che sostituisce, cifre misurate nel Progress Log): a
+ * sha invariato torna la STESSA istanza di mappa, non una ricostruita — è
+ * ciò che rende inutile il confronto per firma in `useCommitTimes` (P1
+ * preflight).
  */
 export async function commitTimes(tasksDir, projectRoot) {
+    const key = `${projectRoot}\u0000${tasksDir}`;
+    const sha = await headSha(projectRoot);
+    if (sha !== null && cache && cache.key === key && cache.sha === sha) {
+        return cache.map;
+    }
+    let map;
     try {
+        // Il contatore sale PRIMA dell'await: conta gli spawn partiti, e uno
+        // spawn fallito costa comunque la fork del processo.
+        logSpawns++;
         const { stdout } = await execFileAsync('git', ['log', '--format=#%ct', '--name-only', '--', tasksDir], { cwd: projectRoot });
-        return parseCommitLog(stdout);
+        map = parseCommitLog(stdout);
     }
     catch {
-        return new Map();
+        map = EMPTY_MAP;
     }
+    // sha === null (git muto): non si cachea uno stato che il prossimo giro
+    // potrebbe smentire in silenzio (repo che ricompare) senza mai vedersi
+    // ricontrollato.
+    cache = sha !== null ? { key, sha, map } : null;
+    return map;
 }

package/dist/epic-hierarchy.js

@@ -8,7 +8,7 @@
 // parentela si edita anche a mano dentro un task file già in tabella, non solo
 // alla nascita di una riga: un trigger sulla sola firma degli id (come
 // `useArchivable`) lascerebbe quell'edit stale fino al prossimo giro largo.
-import { readdirSync, readFileSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { taskEpicOf, taskIsEpic } from './tasks.js';
 // Stesso pattern di `TASK_FILE_RE` in commit-times.ts: il basename del task
@@ -17,10 +17,23 @@ import { taskEpicOf, taskIsEpic } from './tasks.js';
 const TASK_FILE_RE = /^(T\d+)-.*\.md$/;
 export const EMPTY_EPIC_HIERARCHY = { epicOf: new Map(), epics: new Set() };
 /**
- * Lettura SINCRONA di tutti i task file sotto `tasksDir`: costo misurato in P2,
- * accettabile sul poll da 1,5s. Cartella illeggibile o singolo file non
- * apribile → entry saltata, mai un throw — un dato di rendering non può
- * rompere il deck, stessa regola di `archivableIds`/`commitTimes`.
+ * T153 — gate module-level: il read+parse dei task file gira solo se la mtime
+ * MASSIMA fra i file `T<N>-*.md` di `tasksDir` è cambiata da ultima chiamata
+ * (un ordine di grandezza più economico del parse pieno che sostituisce,
+ * cifre misurate nel Progress Log). Sulla SOLA mtime e non su una firma
+ * degli id: deve intercettare un edit a mano di
+ * `**Parent Task**` DENTRO un file già in tabella, che non aggiunge né toglie
+ * nessun id (Testing Notes T153). A gate scattato torna la STESSA istanza —
+ * `useEpicHierarchy` non ha più bisogno di una firma propria per lo stesso
+ * motivo di `useCommitTimes` (P1 preflight).
+ */
+let cache = null;
+/**
+ * Lettura SINCRONA di tutti i task file sotto `tasksDir`: costo del gate
+ * accettabile sul poll da 1,5s anche a scan pieno (mai il caso in regime).
+ * Cartella illeggibile o singolo file non apribile → entry saltata, mai un
+ * throw — un dato di rendering non può rompere il deck, stessa regola di
+ * `archivableIds`/`commitTimes`.
  */
 export function scanEpicHierarchy(tasksDir) {
     let entries;
@@ -28,15 +41,32 @@ export function scanEpicHierarchy(tasksDir) {
         entries = readdirSync(tasksDir);
     }
     catch {
+        cache = null;
         return EMPTY_EPIC_HIERARCHY;
     }
-    const epicOf = new Map();
-    const epics = new Set();
+    let maxMtime = 0;
+    const files = [];
     for (const file of entries) {
-        const m = TASK_FILE_RE.exec(file);
-        if (!m)
+        if (!TASK_FILE_RE.test(file))
             continue;
-        const id = m[1];
+        let mtime;
+        try {
+            mtime = statSync(join(tasksDir, file)).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        files.push(file);
+        if (mtime > maxMtime)
+            maxMtime = mtime;
+    }
+    if (cache && cache.key === tasksDir && cache.maxMtime === maxMtime) {
+        return cache.hierarchy;
+    }
+    const epicOf = new Map();
+    const epics = new Set();
+    for (const file of files) {
+        const id = TASK_FILE_RE.exec(file)[1];
         let content;
         try {
             content = readFileSync(join(tasksDir, file), 'utf8');
@@ -50,5 +80,7 @@ export function scanEpicHierarchy(tasksDir) {
         if (parent)
             epicOf.set(id, parent);
     }
-    return { epicOf, epics };
+    const hierarchy = { epicOf, epics };
+    cache = { key: tasksDir, maxMtime, hierarchy };
+    return hierarchy;
 }

package/dist/hooks.js

@@ -72,28 +72,26 @@ export function useTasks(tasksPath) {
 /**
  * T136 — data dell'ultimo commit di ogni task file, per la chiave di sort
  * `commit`. D1 (preflight): sullo STESSO poll di `tasks.md` (`POLL_MS`), non
- * su una scala propria come `useArchivable` — una passata di `git log` costa
- * ~33ms ed è UNA invocazione per tick, indipendentemente dal numero di task.
+ * su una scala propria come `useArchivable`.
  *
- * P5 (preflight): `commitTimes` ritorna una `Map` nuova a ogni tick anche
- * quando il contenuto non cambia; passata nuda a una `useMemo` a valle ne
- * romperebbe la memoizzazione ogni 1,5s. Si confronta per FIRMA prima di
- * aggiornare lo stato, come `lastMtime` in `useTasks` e `lastSig` in
- * `useSessions`: l'identità della mappa cambia solo dopo un commit vero.
+ * T153 — `commitTimes` gatea da sé su `rev-parse HEAD` (davanti allo spawn
+ * caro del log, vedi `commit-times.ts`) e a sha invariato torna la STESSA
+ * istanza di mappa. L'hook confronta quindi per IDENTITÀ, non più per firma
+ * ricostruita: la firma evitava solo il re-render, il gate a monte evita il
+ * lavoro. `lastMtime` in `useTasks` resta il gemello sullo stesso schema.
  */
 export function useCommitTimes(tasksDir, projectRoot) {
     const [commitAt, setCommitAt] = useState(() => new Map());
     useEffect(() => {
-        let lastSig = '';
+        let last = null;
         let alive = true;
         const reload = () => {
             commitTimes(tasksDir, projectRoot).then((next) => {
                 if (!alive)
                     return;
-                const sig = [...next.entries()].map(([id, ts]) => `${id}:${ts}`).sort().join(',');
-                if (sig === lastSig)
-                    return;
-                lastSig = sig;
+                if (next === last)
+                    return; // stessa istanza → il gate non è scattato
+                last = next;
                 setCommitAt(next);
             });
         };
@@ -108,29 +106,24 @@ export function useCommitTimes(tasksDir, projectRoot) {
 }
 /**
  * T67 — mappa cappello/figlie (`**Parent Task**`, `Size: Epic`), sullo STESSO
- * poll di `tasks.md` e non su una scala propria: P2 (preflight) misura 7,86 ms
- * per il read+parse di 106 task file, meno dei ~33 ms di `git log` che
- * `useCommitTimes` paga già ogni tick. La parentela si edita anche a mano su
- * un task file già in tabella — un trigger sulla sola firma degli id, come
- * `useArchivable`, non vedrebbe quell'edit e lo lascerebbe stale fino al
- * prossimo giro largo.
+ * poll di `tasks.md` e non su una scala propria.
  *
- * Firma prima di `setState`, gemella di `lastSig`/`lastMtime` degli altri
- * poll: senza, la mappa cambia identità a ogni tick e rompe le `useMemo` a
- * valle che la consumano (`applyView`, `selectTasks`).
+ * T153 — `scanEpicHierarchy` gatea da sé sulla mtime massima dei task file
+ * (davanti al read+parse caro, vedi `epic-hierarchy.ts`) e a mtime invariata
+ * torna la STESSA istanza: la parentela editata a mano dentro un file già in
+ * tabella resta vista, perché il gate è sulla mtime e non sugli id. L'hook
+ * confronta quindi per IDENTITÀ, non più per firma ricostruita, gemello di
+ * `useCommitTimes` per lo stesso motivo (P1 preflight).
  */
 export function useEpicHierarchy(tasksDir) {
     const [hierarchy, setHierarchy] = useState(EMPTY_EPIC_HIERARCHY);
     useEffect(() => {
-        let lastSig = '';
+        let last = null;
         const reload = () => {
             const next = scanEpicHierarchy(tasksDir);
-            const sig = [...next.epicOf.entries()].map(([c, p]) => `${c}<${p}`).sort().join(',') +
-                '#' +
-                [...next.epics].sort().join(',');
-            if (sig === lastSig)
-                return;
-            lastSig = sig;
+            if (next === last)
+                return; // stessa istanza → il gate non è scattato
+            last = next;
             setHierarchy(next);
         };
         reload();

package/dist/overlays/sheet.js

@@ -21,7 +21,7 @@ import { sanitizeTyped } from '../glyphs.js';
 import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, specializeRecap, } from '../spawn.js';
 import { taskIsEpic } from '../tasks.js';
 import { fieldsKey } from '../fields.js';
-import { loadPromptCatalog, promptFor } from '../prompt-catalog.js';
+import { loadPromptCatalog, modelFor, promptFor } from '../prompt-catalog.js';
 // T117 — le quattro righe dell'area di compilazione del detail, nell'ordine in
 // cui si leggono dall'alto. Gli indici sono nominati perché li usano insieme
 // l'handler dei tasti e la resa, e un `2` nudo in due file diversi è la
@@ -113,32 +113,39 @@ export function useSheetOverlay(deps) {
         // Calcolato qui e usato subito: `setEpic` non ha ancora aggiornato lo stato
         // quando `setPrompt` gira, quindi il valore locale è l'unico leggibile ora.
         const isEpic = taskIsEpic(next.id, next.text);
+        const kind = specializeRecap(DETAIL_ACTIONS[0].kind, isEpic);
         setSheet(next);
         setTop(0);
         setAction(0);
         setEpic(isEpic);
-        setModel(MODEL_DEFAULT);
+        // 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, specializeRecap(DETAIL_ACTIONS[0].kind, isEpic), next.id));
+        setPrompt(promptFor(catalog, kind, next.id));
         setCursor({ row: DROW.action, caret: 0 });
         setFind(null);
         setOccIdx(0);
         setNote('');
         setMode('detail');
     }
-    /** Cambia l'azione e RISCRIVE il prompt col default del nuovo kind (D2).
+    /** Cambia l'azione e RISCRIVE prompt e modello col default del nuovo kind (D2).
      *
-     *  Nessuna preservazione del testo modificato a mano, e non è una svista: la
-     *  regola `initialDetail` del modale edit protegge da un cambio di sorgente
-     *  ACCIDENTALE, e col fuoco per riga quel caso non esiste — `←→` cambiano
-     *  azione solo dalla riga azione, mentre sul campo prompt muovono il caret.
-     *  Senza il cambio accidentale la preservazione difenderebbe da nulla, e
-     *  costerebbe un campo che non torna più al default. */
+     *  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). */
     function selectAction(index) {
         setAction(index);
         const id = sheet?.id;
-        if (id)
-            setPrompt(promptFor(catalog, specializeRecap(DETAIL_ACTIONS[index].kind, epic), id));
+        if (!id)
+            return;
+        const kind = specializeRecap(DETAIL_ACTIONS[index].kind, epic);
+        setPrompt(promptFor(catalog, kind, id));
+        setModel(modelFor(catalog, kind) ?? MODEL_DEFAULT);
     }
     // Il ponte fra le quattro righe e i quattro stati. Le righe restano
     // TIPIZZATE dove vivono (`ModelKind`, indice dell'azione) invece di finire in

package/dist/prompt-catalog.js

@@ -16,17 +16,25 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { MODELS } from './spawn.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');
 /**
- * Il catalogo come mappa kind → template, col placeholder `{TASK}` ancora
- * dentro.
+ * Il catalogo come mappa kind → entry, col placeholder `{TASK}` del template
+ * ancora dentro.
  *
  * File illeggibile → mappa VUOTA, non un fallback cablato: un default scritto
  * qui sarebbe esattamente la copia del catalogo che questo modulo esiste per non
  * avere, e divergerebbe in silenzio. L'assenza si vede — il campo prompt resta
  * vuoto — e uno spawn senza prompt è un esito benigno.
+ *
+ * Il taglio è su DUE tab, non uno: il primo separa il kind, l'ultimo separa un
+ * modello opzionale in coda — così una riga a due colonne (nessun secondo tab)
+ * lascia il template intatto. Un valore in terza colonna che non è un
+ * `ModelKind` viene scartato come se la colonna non ci fosse (P2 preflight
+ * T152): il chiamante cade sul proprio default, stesso esito bash del `case`
+ * di `deck-run` che degrada un modello ignoto.
  */
 export function loadPromptCatalog(path = PROMPT_CATALOG) {
     const out = new Map();
@@ -43,13 +51,27 @@ export function loadPromptCatalog(path = PROMPT_CATALOG) {
         const tab = line.indexOf('\t');
         if (tab < 0)
             continue;
-        out.set(line.slice(0, tab).trim(), line.slice(tab + 1).trim());
+        const kind = line.slice(0, tab).trim();
+        const rest = line.slice(tab + 1);
+        const lastTab = rest.lastIndexOf('\t');
+        const template = (lastTab >= 0 ? rest.slice(0, lastTab) : rest).trim();
+        const rawModel = lastTab >= 0 ? rest.slice(lastTab + 1).trim() : '';
+        const model = MODELS.includes(rawModel)
+            ? rawModel
+            : undefined;
+        out.set(kind, model ? { template, model } : { template });
     }
     return out;
 }
 /** Il prompt di un kind su una task. Kind fuori catalogo (`none`, o un file
  *  mutilo) → stringa vuota, che è la stessa cosa che `deck-run` fa con `none`. */
 export function promptFor(catalog, kind, taskId) {
-    const template = catalog.get(kind);
+    const template = catalog.get(kind)?.template;
     return template ? template.replaceAll('{TASK}', taskId) : '';
 }
+/** Il modello di un kind, gemello di `promptFor`. Kind fuori catalogo o riga
+ *  priva del campo → `undefined`: il chiamante cade sul proprio default
+ *  (`MODEL_DEFAULT`), mai su un valore inventato qui. */
+export function modelFor(catalog, kind) {
+    return catalog.get(kind)?.model;
+}

package/dist/spawn.js

@@ -143,12 +143,24 @@ export function specializeRecap(kind, epic) {
 // 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 di ogni percorso di spawn che non passa da lui
-// (`^K`/`^P`/`^R` dalla lista, resume, fork). 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.
+// 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 = 'opus';
+// 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. Valore = copia del frontmatter `model: opus` che la skill portava
+// prima di T152 (P4 preflight), nessuna ri-taratura.
+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
@@ -502,6 +514,8 @@ export function spawnProjectStatus(cwd, sessionId, onResult) {
     return spawnSkill('/loom-works:recap-status-project', cwd, sessionId, onResult, [
         '--permission-mode',
         'auto',
+        '--model',
+        PROJECT_STATUS_MODEL,
     ]);
 }
 // Comando della notifica desktop. L'override esiste per il collaudo del ramo

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.61.0",
+  "version": "0.62.0",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {

package/scripts/deck-run

@@ -60,7 +60,7 @@
 #   LOOM_DECK_STATE_PROFILE  PTYXIS_PROFILE annunciata a compass (default: bindings/claude
 #                            del progetto, letto da dconf; settata a vuoto = nessun annuncio)
 #   LOOM_DECK_PERMISSION_MODE  override del permissionMode del file config (default: campo file, poi 'manual')
-#   LOOM_DECK_MODEL        modello quando --model non è passato (default: opus)
+#   LOOM_DECK_MODEL        modello quando --model non è passato (batte il catalogo, default: opus)
 #
 set -euo pipefail
 
@@ -180,7 +180,8 @@ USAGE="uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--sessio
                  prompt. Ammesso anche con --no-task: un testo già scritto non
                  ha una task da nominare, a differenza dei kind del catalogo
 
-  --model        modello della sessione: fable|opus|sonnet|haiku (default: opus)
+  --model        modello della sessione: fable|opus|sonnet|haiku
+                 (default: il modello del kind in catalogo, o 'opus' fuori catalogo)
                  valore ignoto → fallback sul default, con avviso su stderr
 
   --title-note   nota della conversazione, appesa al titolo tab
@@ -353,11 +354,16 @@ case "${PERM_MODE:-}" in
 esac
 MODE_FLAG="--permission-mode ${PERM_MODE} "
 
-# ── modello (T108) ───────────────────────────────────────────────────────────
-# Precedenza: --model > env LOOM_DECK_MODEL > 'opus'. Nessun campo nel file
-# config: il default è unico per tutta la famiglia, e uno scalare per-progetto
-# aggiungerebbe una chiave allo schema del plugin per un valore che il selettore
-# del deck sovrascrive a ogni spawn.
+# ── modello (T108 + T152) ────────────────────────────────────────────────────
+# Precedenza: --model > env LOOM_DECK_MODEL > modello del kind nel catalogo >
+# 'opus'. Fino a T152 il default era un valore unico per tutta la famiglia,
+# perché il frontmatter `model:` delle skill riscriveva comunque il modello di
+# sessione — un default configurabile qui non sarebbe servito a nulla. Da
+# quando le skill non dichiarano più `model:`, il default DEVE viaggiare col
+# kind: `run` costa quanto `preflight` solo se «vuole sonnet» è scritto da
+# qualche parte che deck-run consulta, e quella parte è il catalogo che il
+# deck TUI legge già per il testo del prompt (T117) — stessa fonte, stesso
+# `kind`, niente seconda copia.
 # Il flag è passato SEMPRE, anche sul default, per la stessa ragione di
 # permissionMode: lo spawn resta leggibile nel process tree invece di dipendere
 # dal default del CLI, che cambia fra versioni.
@@ -366,7 +372,27 @@ MODE_FLAG="--permission-mode ${PERM_MODE} "
 # ferma DENTRO lo script (nessun template da scegliere, l'errore è del deck),
 # un modello ignoto arriverebbe al CLI e produrrebbe una tab con un comando che
 # fallisce all'avvio — cioè il guasto che permissionMode evita degradando.
+_model_for_kind() {  # <kind> → modello dichiarato in catalogo (3ª colonna), o niente
+  local want="$1" k t m
+  [[ -n "$want" && -f "$PROMPT_CATALOG" ]] || return 1
+  while IFS=$'\t' read -r k t m || [[ -n "$k" ]]; do
+    [[ -z "$k" || "$k" == \#* ]] && continue
+    [[ "$k" == "$want" && -n "$m" ]] && { printf '%s' "$m"; return 0; }
+  done < "$PROMPT_CATALOG"
+  return 1
+}
+# Kind di catalogo effettivo: SOLO quando la sessione è bound e senza prompt
+# letterale — le due strade (--no-task, --prompt) non hanno una riga di
+# catalogo da consultare, né per il prompt (sotto) né per il modello (qui).
+# Riusato tal quale nella composizione del prompt: stesso guard, stesso valore.
+CATALOG_KIND=""
+if [[ $PROMPT_GIVEN -eq 0 && $NO_TASK -eq 0 ]]; then
+  CATALOG_KIND="${PROMPT_KIND:-recap}"
+fi
 MODEL="${MODEL:-${LOOM_DECK_MODEL:-}}"
+if [[ -z "$MODEL" && -n "$CATALOG_KIND" && "$CATALOG_KIND" != "none" ]]; then
+  MODEL="$(_model_for_kind "$CATALOG_KIND" || true)"
+fi
 case "${MODEL:-}" in
   fable|opus|sonnet|haiku) ;;
   '') MODEL="opus" ;;
@@ -476,9 +502,12 @@ FORK_FLAG=""
 # (`T`, unico prefisso del contratto loom), quindi nessun prompt discrimina sulla
 # forma dell'id.
 _prompt_template() {  # <kind> → template col placeholder {TASK}, o niente
-  local want="$1" k t
+  local want="$1" k t m
   [[ -f "$PROMPT_CATALOG" ]] || return 1
-  while IFS=$'\t' read -r k t || [[ -n "$k" ]]; do
+  # 3 variabili, non 2 (T152): da quando il catalogo porta una 3ª colonna
+  # modello, un `read -r k t` a due si mangerebbe il tab separatore e il
+  # modello dentro `t`, che è esattamente il template passato al CLI.
+  while IFS=$'\t' read -r k t m || [[ -n "$k" ]]; do
     [[ -z "$k" || "$k" == \#* ]] && continue
     [[ "$k" == "$want" ]] && { printf '%s' "$t"; return 0; }
   done < "$PROMPT_CATALOG"
@@ -503,7 +532,7 @@ elif [[ $NO_TASK -eq 1 ]]; then
   # volta e qui resta quindi inerte: senza task non ha nulla da nominare.
   PROMPT=""
 else
-  _kind="${PROMPT_KIND:-recap}"
+  _kind="$CATALOG_KIND"
   if [[ "$_kind" == "none" ]]; then
     PROMPT=""
   else

package/scripts/prompt-catalog

@@ -1,28 +1,37 @@
 # Catalogo dei prompt iniziali di una sessione Claude aperta dal deck.
 #
-# Formato a righe: <kind><TAB><template>, con `{TASK}` interpolato col TaskID.
-# Righe vuote e righe che iniziano con `#` sono commenti.
+# Formato a righe: <kind><TAB><template><TAB><modello>, con `{TASK}`
+# interpolato col TaskID. Righe vuote e righe che iniziano con `#` sono
+# commenti. Il modello è OPZIONALE: una riga a due colonne resta leggibile e
+# chi la consulta cade sul proprio default (`MODEL_DEFAULT`/`opus`) — il campo
+# esiste per i kind bound a una skill (T152), non per ogni riga del file.
 #
 # Perché un file dati e non un `case` dentro deck-run: due lati hanno bisogno
 # dello stesso testo — deck-run per comporre il comando in-tab, il deck TUI per
-# pre-riempire il campo prompt del detail con ciò che sta per essere eseguito.
-# Come codice, il secondo lato dovrebbe riscriverlo, e le due copie divergono
-# alla prima voce aggiunta da una parte sola.
+# pre-riempire il campo prompt (e ora anche il modello) del detail con ciò che
+# sta per essere eseguito. Come codice, il secondo lato dovrebbe riscriverlo, e
+# le due copie divergono alla prima voce aggiunta da una parte sola.
 #
 # `none` non compare: nessun prompt non è un template vuoto, è l'assenza della
-# voce. Chi chiede un kind fuori da questo file riceve un prompt vuoto.
+# voce. Chi chiede un kind fuori da questo file riceve un prompt vuoto e nessun
+# modello (fallback sul default del chiamante).
 #
 # Vincolo sui template: nessun apice singolo. Il testo finisce dentro `'...'`
 # nel comando passato a `bash -lc`, e questo file è committato — un apice qui
 # sarebbe un errore di scrittura, non un input da quotare.
+#
+# Il modello è la copia esatta del `model:` che il frontmatter delle sei skill
+# portava prima di T152 — non una ri-taratura: nasce da un difetto di canale
+# (il frontmatter vinceva sempre su `--model`, rendendo il selettore del detail
+# inerte), non da un giudizio su quale modello convenga a quale skill.
 # `recap` è il DISPATCHER: risolve la task, ne legge il Size e passa da sé alla
 # sotto-skill. Lo usa chi non sa se la task è un cappello — gli acceleratori
 # della lista, dove il deck ha in mano solo tasks.md, che il Size non ce l'ha.
 # Le due voci `recap-task`/`recap-epic` saltano quel giro: le sceglie il DETAIL,
 # che il task file l'ha già aperto e quindi il Size lo conosce.
-recap	/loom-works:recap-status {TASK}
-recap-task	/loom-works:recap-status-task {TASK}
-recap-epic	/loom-works:recap-status-epic {TASK}
-preflight	/loom-works:preflight-task {TASK}
-run	/loom-works:run-task {TASK}
-checkpoint	/loom-works:checkpoint-task {TASK}
+recap	/loom-works:recap-status {TASK}	opus
+recap-task	/loom-works:recap-status-task {TASK}	opus
+recap-epic	/loom-works:recap-status-epic {TASK}	opus
+preflight	/loom-works:preflight-task {TASK}	opus
+run	/loom-works:run-task {TASK}	sonnet
+checkpoint	/loom-works:checkpoint-task {TASK}	sonnet