@lamemind/loom-deck 0.62.0 → 0.63.0

package/dist/actions.js

@@ -156,24 +156,30 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
         spawned.child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
         noteSpawn(spawned);
     }
-    /** T148 — `m`: scorre il modello con cui la sessione selezionata riprenderà
-     *  al successivo del catalogo. Stesso guard di `f` (serve un transcript
-     *  vero, non basta una riga selezionata): su una pinnata stale il blocco
-     *  preview non esiste — non c'è un bottone da cambiare. Nessuna nota di
-     *  conferma sul successo — il feedback è il bottone stesso, già a schermo
-     *  nella preview. */
+    /** T148/T154(P2,P3) — `m` col bersaglio RESUME: `input.ts` instrada qui solo
+     *  quando il focus è sulle sessioni E una riga è selezionata (P2), quindi il
+     *  solo caso residuo è il pin STALE — l'id c'è ma il transcript no, quindi
+     *  non c'è un bottone da cambiare (P3): resta sul selettore di resume con la
+     *  propria nota, invece di spostare di soppiatto il selettore della nuda
+     *  mentre il caret è su una riga sessione.
+     *
+     *  La nota sul SUCCESSO nomina bersaglio e valore (`m → resume: opus`, P2):
+     *  rovescia la scelta di T148 di non scriverne nessuna, perché lì `m` aveva
+     *  un bersaglio solo e il bottone che cambiava era l'unico a schermo — da
+     *  T154 i due selettori possono stare a schermo insieme. */
     function cycleResumeModel() {
-        if (model.focus !== 'sessions') {
-            setNote('m → modello: seleziona una sessione (→ per il pane)');
-            return;
-        }
         if (!model.selSessionObj) {
-            setNote(model.selSessionId
-                ? 'm → pin stale: nessun modello da cambiare'
-                : 'm → nessuna sessione selezionata');
+            setNote('m → pin stale: nessun modello da cambiare');
             return;
         }
-        model.cycleResumeModel();
+        const next = model.cycleResumeModel();
+        setNote(`m → resume: ${next}`);
+    }
+    /** T154 — `m` col bersaglio NUDA (`c`): il selettore che governa sta sempre
+     *  a schermo sulla riga launch, quindi il tasto non è mai inerte qui. */
+    function cycleBareModel() {
+        const next = model.cycleBareModel();
+        setNote(`m → nuda: ${next}`);
     }
     // T53 — scrive il sidecar e ricarica subito, senza attendere il tick del poll
     // (stesso feedback immediato del pin).
@@ -289,8 +295,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
      * il giorno in cui una natura nuova apre la skill sbagliata.
      *
      * Sessione NUDA e modello esplicito: il drain lavora sulla doc, non sulla
-     * task (D10 preflight), e `opus` passa nell'argv anche essendo il default,
-     * come `permissionMode`.
+     * task (D10 preflight), e `MODEL_DEFAULT` passa nell'argv anche essendo il
+     * default, come `permissionMode`.
      */
     function drainInbox(file, prompt) {
         const spawned = spawnBare(cwd, prompt, MODEL_DEFAULT);
@@ -311,9 +317,11 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
         spawned.child.on('error', () => setNote(`⚠ srotolamento ${path} fallito (${DECK_RUN})`));
         noteSpawn(spawned);
     }
-    /** `c` — sessione claude a mani nude, senza task e senza prompt. */
+    /** `c` — sessione claude a mani nude, senza task e senza prompt. T154 — il
+     *  modello è quello del selettore proprio della nuda (`model.bareModel`),
+     *  passato SEMPRE nell'argv anche sul default. */
     function openClaude() {
-        const spawned = spawnClaudeEmpty(cwd);
+        const spawned = spawnClaudeEmpty(cwd, model.bareModel);
         spawned.child.on('error', () => setNote(`⚠ c → spawn claude fallito (${DECK_RUN})`));
         noteSpawn(spawned);
     }
@@ -352,6 +360,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
         spawnTaskSession,
         resumeSession,
         cycleResumeModel,
+        cycleBareModel,
         writeNote,
         assignSession,
         forkSession,

package/dist/cli.js

@@ -19,9 +19,10 @@ import { resolveTasksPath, resolveTasksDir } from './tasks.js';
 import { LAUNCH_SEP } from './config.js';
 import { anchorFrame, enableMouse } from './mouse.js';
 import { sanitize } from './width.js';
-import { modelAlias } from './glyphs.js';
-import { MODEL_DEFAULT } from './spawn.js';
-import { deckLegend, frameGeometry, headlineWidth, indicatorRow, launchRow } from './frame.js';
+import { MODEL_SHORT_LIST, modelAlias } from './glyphs.js';
+import { MODEL_DEFAULT, MODELS } from './spawn.js';
+import { BARE_BUTTONS_WIDTH, BARE_LABEL, deckLegend, frameGeometry, headlineWidth, indicatorRow, launchRow, } from './frame.js';
+import { choiceButtons } from './ui/fields.js';
 import { useDeckModel } from './deck-model.js';
 import { useDeckActions } from './actions.js';
 import { useDeckInput } from './input.js';
@@ -162,6 +163,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 : 'none';
     const detailParts = model.detail ? detailMetaOf(model.detail) : null;
     const launch = launchRow(model.launch, columns);
+    // T154 — i bottoni del blocco selettore della nuda: stessa primitiva
+    // (`choiceButtons`) del selettore di resume/fork, sulle SHORT (D1) e con
+    // `avail` pari alla larghezza naturale del gruppo, così `cutParts` non
+    // taglia mai (il blocco è riservato, non conteso — vedi `launchRow`).
+    const bareButtons = choiceButtons(MODEL_SHORT_LIST, MODELS.indexOf(model.bareModel), BARE_BUTTONS_WIDTH, MODELS.indexOf(MODEL_DEFAULT));
     // T134 — gli indicatori ancorati a destra della riga legenda. Si compongono
     // PRIMA della legenda perché è la loro larghezza a decidere quanto ne resta:
     // hanno la precedenza sul budget (D5 preflight).
@@ -245,7 +251,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     purgeBulk: model.purgeBulk,
                     inboxPane: model.rightPane === 'inbox',
                     hasInbox: model.selInbox !== null,
-                }), indicators: indicators, columns: columns }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData, blockMark: model.blockMark }), model.rightPane === 'inbox' ? (_jsx(InboxPane, { files: frame.windowInbox, counts: model.inboxCounts, activeView: model.inboxViewId, paneCount: model.inboxFiles.length, selectedPath: model.selInboxPath, focused: model.focus === 'inbox', above: frame.inboxWin.start, below: model.inboxFiles.length - frame.inboxWin.end, columns: columns, ok: model.inboxOk, scanned: model.inboxScanned })) : (_jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live }))] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'inbox' && model.selInbox ? (_jsx(PreviewPane, { kind: "inbox", file: model.selInbox, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null, resumeModel: model.resumeModel })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+                }), indicators: indicators, columns: columns }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null, launch.filler, BARE_LABEL.text, ' ', bareButtons.nodes] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData, blockMark: model.blockMark }), model.rightPane === 'inbox' ? (_jsx(InboxPane, { files: frame.windowInbox, counts: model.inboxCounts, activeView: model.inboxViewId, paneCount: model.inboxFiles.length, selectedPath: model.selInboxPath, focused: model.focus === 'inbox', above: frame.inboxWin.start, below: model.inboxFiles.length - frame.inboxWin.end, columns: columns, ok: model.inboxOk, scanned: model.inboxScanned })) : (_jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live }))] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'inbox' && model.selInbox ? (_jsx(PreviewPane, { kind: "inbox", file: model.selInbox, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null, resumeModel: model.resumeModel })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const cwd = process.cwd();
 // T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,

package/dist/deck-model.js

@@ -131,6 +131,12 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // tornare su una riga già visitata NON ricorda la scelta fatta lì — è lo
     // stesso costo che T108 ha già accettato per il selettore del detail.
     const [resumeModel, setResumeModel] = useState(MODEL_DEFAULT);
+    // T154 — il modello con cui la sessione NUDA (`c`) apre. Stato PROPRIO,
+    // indipendente da `resumeModel`: non segue nessuna riga selezionata (`c` non
+    // ha una riga, è un'azione sulla surface del cappello) e quindi non si
+    // azzera mai — resta quello scelto finché non si sceglie altro, per tutta la
+    // vita del deck.
+    const [bareModel, setBareModel] = useState(MODEL_DEFAULT);
     // T39 — vista corrente (filtri + sort). Vive nel modello e non nell'hook dei
     // modali che la editano: è ciò che `applyView` consuma per produrre la lista,
     // è persistita su disco e la rilegge il tasto `w`. È stato del modello che due
@@ -407,10 +413,22 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
      *  valore SUCCESSIVO del catalogo (ciclico), gemella di `cycleView` ma su un
      *  asse diverso: qui non c'è una vista da cambiare, solo un valore da far
      *  avanzare. Il guard (nessuna sessione, focus altrove) sta nell'attuatore
-     *  `actions.ts`, come per `f`/`p`: qui c'è solo la meccanica dello stato. */
+     *  `actions.ts`, come per `f`/`p`: qui c'è solo la meccanica dello stato.
+     *  T154/P2 — ritorna il valore NUOVO: il chiamante lo scrive nella nota di
+     *  conferma prima che il render con lo stato aggiornato arrivi. */
     function cycleResumeModel() {
         const next = MODELS[(MODELS.indexOf(resumeModel) + 1) % MODELS.length];
         setResumeModel(next);
+        return next;
+    }
+    /** T154 — gemella di `cycleResumeModel`, sullo stato della sessione NUDA:
+     *  `m` ci finisce quando il focus non è su una riga sessione vera (P2, D4/D5
+     *  degli AC). Nessun guard qui: il bersaglio non è mai inerte — il selettore
+     *  che governa è sempre a schermo sulla riga launch. */
+    function cycleBareModel() {
+        const next = MODELS[(MODELS.indexOf(bareModel) + 1) % MODELS.length];
+        setBareModel(next);
+        return next;
     }
     /**
      * T134 — `^B` scambia i due pane dello slot destro (D8 preflight).
@@ -493,6 +511,8 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         sessionCols,
         resumeModel,
         cycleResumeModel,
+        bareModel,
+        cycleBareModel,
         // derivazioni del pane inbox
         rightPane,
         inboxScanned: inbox.scanned,

package/dist/frame.js

@@ -20,17 +20,15 @@ import { FRAME_TEXT_COL, HINT_ROW, inlineRegions, LAUNCH_ROW, PANE_TEXT_PAD, pan
 import { cellWidth, launchLegend, LAUNCH_SEP } from './config.js';
 import { layoutBudget, windowRange } from './viewport.js';
 import { sanitize, termWidth } from './width.js';
-import { WARN } from './glyphs.js';
+import { MODEL_SHORT_LIST, WARN } from './glyphs.js';
 import { STATUS_MISSING } from './project-status.js';
 import { META_ROWS } from './model.js';
 import { rowIndexOf } from './session-list.js';
 import { VERSION } from './version.js';
-// Le due surface built-in del cappello, in testa alla riga launch. Non stanno
-// fra i tasti perché hanno la stessa natura delle voci `launch` — fire-once,
-// cwd = project root, nessuno stato — e la differenza è solo che sono
-// universali (nessun progetto le dichiara) invece che custom. Emoji del menu
-// compass: 🤖 = nuova sessione claude. Per il terminale compass usa 🖥️, che nel
-// frame Ink NON passa — `sanitize` lo sostituisce (VTE lo disegna largo 1,
+// La surface built-in del cappello, in testa alla riga launch. Non sta fra i
+// tasti perché ha la stessa natura delle voci `launch` — fire-once, cwd =
+// project root, nessuno stato. Per il terminale compass usa 🖥️, che nel frame
+// Ink NON passa — `sanitize` lo sostituisce (VTE lo disegna largo 1,
 // string-width dice 2: discordante, invariante ① di width.ts) e resterebbe un
 // `·` muto. 💻 è il gemello concorde; il `sanitize` qui rende il vincolo
 // automatico invece che da ricordare.
@@ -38,10 +36,35 @@ import { VERSION } from './version.js';
 // T21 — `key` è il tasto che la superficie rappresenta: un click su di essa
 // entra nell'handler di tastiera con quel tasto, invece di chiamare l'azione
 // per conto proprio. È ciò che tiene click e tasto per costruzione allineati.
-export const SURFACE_SEGMENTS = [
-    { key: 't', text: sanitize('t 💻') },
-    { key: 'c', text: sanitize('c 🤖') },
-];
+//
+// T154/P9 — `c` non vive più qui: la surface trasloca a destra come etichetta
+// del blocco selettore della nuda (`BARE_LABEL` sotto), adiacente ai bottoni
+// col modello con cui apre invece che sull'estremo opposto della riga.
+export const SURFACE_SEGMENTS = [{ key: 't', text: sanitize('t 💻') }];
+// T154/P9 — l'etichetta del blocco selettore della nuda: unico segmento
+// cliccabile del blocco (nessun tasto nomina un modello, `m` cicla e non
+// seleziona — i bottoni non lo sono).
+export const BARE_LABEL = { key: 'c', text: sanitize('c 🤖') };
+// T154/D1 — i bottoni usano le SHORT (`fab`/`ops`/`son`/`hak`), non i nomi
+// interi del selettore di resume/fork: la riga launch compete per spazio con
+// la legenda delle voci custom, e le short sono già il vocabolario compatto
+// che la colonna modello della lista sessioni usa per lo stesso motivo.
+const BARE_BUTTONS_TEXT = MODEL_SHORT_LIST.map((s) => `[ ${s} ]`).join('  ');
+/** Larghezza dei soli bottoni, in celle: passata come `avail` a
+ *  `choiceButtons` — esattamente la larghezza naturale, così `cutParts` non
+ *  taglia mai (il blocco è RISERVATO, D1/P8: a cedere sono le voci `launch`,
+ *  mai il selettore). */
+export const BARE_BUTTONS_WIDTH = termWidth(BARE_BUTTONS_TEXT);
+/** Spazio fra l'etichetta `c 🤖` e il primo bottone. */
+const BARE_LABEL_GAP = ' ';
+/** Larghezza FISSA del blocco intero (etichetta + spazio + bottoni): non
+ *  dipende da quale modello sia selezionato né dal default — ogni short è
+ *  larga uguale (3 lettere) — quindi la geometria non ha bisogno di saperli;
+ *  la STILATURA sì, e la fa il chiamante con `choiceButtons` sugli stessi
+ *  valori (`MODEL_SHORT_LIST`). 39 celle con l'attuale `MODELS` a 4 voci
+ *  (D1 preflight).
+ */
+const BARE_BLOCK_WIDTH = termWidth(BARE_LABEL.text) + termWidth(BARE_LABEL_GAP) + BARE_BUTTONS_WIDTH;
 /**
  * La legenda della modalità normale. Elenca SOLO i tasti che fanno qualcosa qui
  * e ora: le voci contestuali compaiono quando il pane a fuoco le rende possibili
@@ -102,21 +125,46 @@ export function deckLegend(state) {
  * seconde ri-splittando il primo sarebbe un conto parallelo, che diverge alla
  * prima label che contenga il separatore.
  *
- * Le celle delle surface (più il ` · ` che le separa dalle voci) sono già spese
- * sulla riga → vanno riservate, o le voci launch la sfonderebbero di quel tanto.
+ * Le celle della surface (più il ` · ` che la separa dalle voci) sono già spese
+ * sulla riga → vanno riservate, o le voci launch la sfonderebbero di quel
+ * tanto. T154/P8 — il blocco selettore della nuda entra nella STESSA riserva:
+ * su un progetto con molte voci `launch` a cedere per prima è una voce custom,
+ * mai il selettore (un bottone di modello troncato sarebbe indistinguibile da
+ * un modello che non esiste, una voce launch resta raggiungibile col suo
+ * tasto-cifra anche quando non è scritta in riga).
  */
 export function launchRow(launch, columns) {
     const surfaceLegend = SURFACE_SEGMENTS.map((s) => s.text).join(LAUNCH_SEP);
-    const legend = launchLegend(launch, columns, cellWidth(surfaceLegend) + cellWidth(LAUNCH_SEP));
+    const reserved = cellWidth(surfaceLegend) + cellWidth(LAUNCH_SEP) + BARE_BLOCK_WIDTH;
+    const legend = launchLegend(launch, columns, reserved);
     const segments = [
         ...SURFACE_SEGMENTS,
         ...legend.taken.map((text, i) => ({ key: String(i + 1), text })),
     ];
+    // Larghezza REALE della sinistra, testo di overflow/irraggiungibili incluso:
+    // sono loro a decidere quanto riempimento serve, non solo i segmenti.
+    const leftWidth = termWidth(segments.map((s) => s.text).join(LAUNCH_SEP)) +
+        (legend.overflow > 0 ? termWidth(` · +${legend.overflow} fuori riga`) : 0) +
+        (legend.unreachable > 0
+            ? termWidth(` · ${legend.unreachable} oltre la 9ª (non raggiungibili)`)
+            : 0);
+    // T154/P5 — la formula dell'ancoraggio: colonne del bordo esterno, meno la
+    // sinistra già disegnata, meno il blocco che deve starci per intero. Un
+    // pavimento di 1 tiene sempre almeno uno spazio fra le due metà, invece di
+    // farle toccare quando lo schermo è troppo stretto per il resto.
+    const filler = ' '.repeat(Math.max(1, columns - 6 - leftWidth - BARE_BLOCK_WIDTH));
+    const bareCol = FRAME_TEXT_COL + leftWidth + termWidth(filler);
+    const bareRegion = {
+        key: BARE_LABEL.key,
+        start: bareCol,
+        end: bareCol + termWidth(BARE_LABEL.text) - 1,
+    };
     return {
         segments,
-        regions: rowRegions(segments, LAUNCH_SEP, FRAME_TEXT_COL),
+        regions: [...rowRegions(segments, LAUNCH_SEP, FRAME_TEXT_COL), bareRegion],
         overflow: legend.overflow,
         unreachable: legend.unreachable,
+        filler,
     };
 }
 /**

package/dist/glyphs.js

@@ -1,6 +1,11 @@
 // Glifi letterali del frame e formatter di display. Fase VISTA, ma senza JSX:
 // tutto qui è puro e testabile, e nessun sito di render scrive un glifo nudo.
 import { sanitize } from './width.js';
+// T148/P3 — costo accettato: la fase vista importa dalla fase effetti esterni.
+// Il TIPO si cancella alla compilazione (nessuna dipendenza runtime); T154
+// aggiunge MODELS come VALORE — una dipendenza runtime vera, ma senza ciclo:
+// `spawn.ts` non importa questo file, quindi il verso resta uno solo.
+import { MODELS } from './spawn.js';
 // Glifi LETTERALI del JSX. I dati passano dai loader, che sanificano al
 // confine; questi no — quindi passano da `sanitize` una volta qui, così nessun
 // sito di render scrive un glifo nudo. `↳ ○ ▸ ⏎ · − ↑ ↓` sono già concordi e
@@ -41,6 +46,12 @@ export const MODEL_EMPTY = TASK_EMPTY;
  *  legge come una riga normale e si scorre senza notarla; l'id per intero sta
  *  nel blocco preview. */
 export const MODEL_UNKNOWN = '?';
+/** T154 — le short di `MODEL_SHORT` nell'ordine POSIZIONALE di `MODELS`, non
+ *  quello di inserimento dell'oggetto sopra: il blocco selettore della nuda
+ *  sulla riga launch cicla su questo elenco, e `index`/`originIndex` restano
+ *  indici in `MODELS` — derivarlo da lì invece di scriverlo a mano evita una
+ *  seconda lista capace di disallinearsi al primo modello aggiunto. */
+export const MODEL_SHORT_LIST = MODELS.map((m) => MODEL_SHORT[m]);
 export function modelShort(id) {
     if (!id)
         return MODEL_EMPTY;

package/dist/input.js

@@ -467,9 +467,16 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
             actions.togglePin();
         }
         else if (input === 'm') {
-            // T148 — scorre il modello di resume/fork della riga selezionata,
-            // gemella di `f`/`p`: azione immediata, nessun modale.
-            actions.cycleResumeModel();
+            // T148/T154 — bersaglio deciso dal focus E dalla selezione (P2): con
+            // una riga sessioni selezionata (stale compresa, P3) scorre il modello
+            // di resume/fork di quella riga; altrove (focus task, focus inbox,
+            // pane sessioni senza selezione) scorre il modello della sessione nuda.
+            if (model.focus === 'sessions' && model.selSessionId) {
+                actions.cycleResumeModel();
+            }
+            else {
+                actions.cycleBareModel();
+            }
         }
         else if (input === 'N') {
             // T53 — nota sulla conversazione selezionata. MAIUSCOLA perché apre un

package/dist/overlays/inbox.js

@@ -9,7 +9,7 @@
 // Molto più magro dello sheet: nessuna area di compilazione. Lo sheet ha
 // quattro righe perché quattro parametri dello spawn sono una scelta (azione,
 // prompt, modello, titolo); qui non ce n'è nessuna — la skill la decide la
-// natura (D8), il modello è `opus` per tutte e tre (D11 preflight), la sessione
+// natura (D8), il modello è `MODEL_DEFAULT` per tutte e tre (D11 preflight), la sessione
 // nasce nuda (D10 preflight). Restano la lettura e un tasto.
 //
 // Lo spawn NON sta qui: arriva come callback `onDrain`, per lo stesso confine

package/dist/spawn.js

@@ -153,13 +153,15 @@ export const MODELS = ['fable', 'opus', 'sonnet', 'haiku'];
 // 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';
+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. Valore = copia del frontmatter `model: opus` che la skill portava
-// prima di T152 (P4 preflight), nessuna ri-taratura.
+// 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
@@ -276,9 +278,9 @@ export function spawnDeck(id, cwd, sessionId, kind, model = MODEL_DEFAULT, spawn
 // volta sola, quindi una nota cambiata DOPO non ri-titola la tab già aperta.
 //
 // T148 — il modello viaggia SEMPRE, come in `deckArgs`: senza `--model`
-// `deck-run` risolve il proprio default fisso (`opus`) e lo passa comunque al
-// CLI, quindi una conversazione haiku ripresa senza il flag ripartirebbe in
-// opus (P2 preflight). Qui però non c'è un default fisso da cablare: chi
+// `deck-run` risolve il proprio default (`MODEL_DEFAULT`) e lo passa comunque
+// al CLI, quindi una conversazione haiku ripresa senza il flag ripartirebbe sul
+// default (P2 preflight). Qui però non c'è un default da cablare: chi
 // chiama ha già risolto il valore — il modello della conversazione d'origine,
 // o quello scelto al suo posto — e lo passa come argomento obbligatorio.
 export function resumeArgs(taskId, sessionId, model, note) {
@@ -328,8 +330,17 @@ export function spawnDeckFork(taskId, cwd, originId, newId, model) {
 // di spawnDeck: i tre argomenti mancano tutti insieme, un `if` per ciascuno
 // sporcherebbe il percorso bound. Il titolo tab resta la label loom — lo mette
 // deck-run, perché il match compass è window-level e non sa nulla di task.
-export function spawnClaudeEmpty(cwd) {
-    return launchDeckRun(['--no-task'], cwd);
+//
+// T154 — il modello viaggia SEMPRE nell'argv (`emptyArgs`), anche sul default:
+// prima di questa task il tasto `c` non lo passava affatto, e chi lo premeva
+// non sceglieva né vedeva quale modello `deck-run` avrebbe risolto da sé.
+// Estratta come i suoi fratelli (`deckArgs`/`resumeArgs`/`forkArgs`): tutti i
+// costruttori di argv con un test proprio lo sono (P4 preflight).
+export function emptyArgs(model) {
+    return ['--no-task', '--model', model];
+}
+export function spawnClaudeEmpty(cwd, model) {
+    return launchDeckRun(emptyArgs(model), cwd);
 }
 /**
  * T134 — sessione NUDA con un prompt letterale: `deck-run --no-task --prompt

package/dist/ui/fields.js

@@ -28,8 +28,8 @@ export function FieldText({ value, caret, focused, cols, }) {
  *  preview sessione). */
 export const LABEL_W = 8;
 /**
- * T117 — una riga a SCELTA di un'area di compilazione: bottoni affiancati,
- * voce attiva in video inverso.
+ * T117 — i soli BOTTONI di una riga a scelta: valore per valore, già tagliati
+ * al budget e stilati (voce attiva in video inverso, origine sottolineata).
  *
  * Due passate di `cutParts`: la seconda serve SOLO quando qualcosa cade, e
  * riserva le colonne del contatore. Riservarle sempre costerebbe 6 colonne su
@@ -39,11 +39,14 @@ export const LABEL_W = 8;
  * cancellerebbe l'unica informazione che la riga esiste per dare — quale valore
  * sta per essere usato.
  *
- * T148 — estratto dal detail della task perché un secondo chiamante (il
- * selettore modello della preview sessione) ne riusa la stessa resa a quadre,
- * non un componente gemello capace di divergere.
+ * T154/P6 — estratta da `ChoiceRow`, che ne resta il primo chiamante: un
+ * secondo (il blocco selettore della nuda sulla riga launch) ha bisogno dei
+ * soli bottoni dentro una cornice propria (nessun caret, un'etichetta diversa
+ * da `label.padEnd`), e riscriverne la resa produrrebbe la seconda copia della
+ * regola di troncamento e sottolineatura — quella che diverge al primo modello
+ * aggiunto a `MODELS`.
  */
-export function ChoiceRow({ label, values, index, focused, width, originIndex, }) {
+export function choiceButtons(values, index, avail, originIndex) {
     const segs = values.map((v) => `[ ${v} ]`);
     const parts = [];
     segs.forEach((s, i) => {
@@ -51,11 +54,24 @@ export function ChoiceRow({ label, values, index, focused, width, originIndex, }
             parts.push('  ');
         parts.push(s);
     });
-    const avail = Math.max(0, width - LABEL_W - CARET_OFF.length);
     let shown = cutParts(parts, avail, index * 2);
     const dropped = (v) => segs.filter((s, i) => v[i * 2] !== s).length;
     if (dropped(shown) > 0)
         shown = cutParts(parts, Math.max(0, avail - 6), index * 2);
     const cut = dropped(shown);
-    return (_jsxs(Text, { wrap: "truncate-end", children: [focused ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: label.padEnd(LABEL_W) }), shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === index, underline: i / 2 === originIndex, color: i / 2 === index ? 'green' : 'gray', children: part }, i))), cut > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cut] }) : null] }));
+    const nodes = shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === index, underline: i / 2 === originIndex, color: i / 2 === index ? 'green' : 'gray', children: part }, i)));
+    return { nodes, cut };
+}
+/**
+ * T117 — una riga a SCELTA di un'area di compilazione: caret + etichetta +
+ * bottoni di `choiceButtons`.
+ *
+ * T148 — estratto dal detail della task perché un secondo chiamante (il
+ * selettore modello della preview sessione) ne riusa la stessa resa a quadre,
+ * non un componente gemello capace di divergere.
+ */
+export function ChoiceRow({ label, values, index, focused, width, originIndex, }) {
+    const avail = Math.max(0, width - LABEL_W - CARET_OFF.length);
+    const { nodes, cut } = choiceButtons(values, index, avail, originIndex);
+    return (_jsxs(Text, { wrap: "truncate-end", children: [focused ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: label.padEnd(LABEL_W) }), nodes, cut > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cut] }) : null] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.62.0",
+  "version": "0.63.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 (batte il catalogo, default: opus)
+#   LOOM_DECK_MODEL        modello quando --model non è passato (batte il catalogo, default: fable)
 #
 set -euo pipefail
 
@@ -181,7 +181,7 @@ USAGE="uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--sessio
                  ha una task da nominare, a differenza dei kind del catalogo
 
   --model        modello della sessione: fable|opus|sonnet|haiku
-                 (default: il modello del kind in catalogo, o 'opus' fuori catalogo)
+                 (default: il modello del kind in catalogo, o 'fable' fuori catalogo)
                  valore ignoto → fallback sul default, con avviso su stderr
 
   --title-note   nota della conversazione, appesa al titolo tab
@@ -356,7 +356,12 @@ MODE_FLAG="--permission-mode ${PERM_MODE} "
 
 # ── 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,
+# 'fable'. L'ultimo gradino è il gemello bash di `MODEL_DEFAULT` in spawn.ts e
+# va tenuto allineato a mano: i due lati non si leggono a vicenda (il deck deve
+# poter MOSTRARE la selezione iniziale prima che deck-run esista come processo),
+# quindi un cambio qui senza l'altro fa partire dalla lista un modello diverso
+# da quello che il detail aveva scritto a schermo.
+# 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
@@ -395,9 +400,9 @@ if [[ -z "$MODEL" && -n "$CATALOG_KIND" && "$CATALOG_KIND" != "none" ]]; then
 fi
 case "${MODEL:-}" in
   fable|opus|sonnet|haiku) ;;
-  '') MODEL="opus" ;;
-  *)  echo "modello ignoto: '${MODEL}' → fallback 'opus' (usa fable|opus|sonnet|haiku)" >&2
-      MODEL="opus" ;;
+  '') MODEL="fable" ;;
+  *)  echo "modello ignoto: '${MODEL}' → fallback 'fable' (usa fable|opus|sonnet|haiku)" >&2
+      MODEL="fable" ;;
 esac
 MODEL_FLAG="--model ${MODEL} "
 

package/scripts/prompt-catalog

@@ -3,7 +3,7 @@
 # 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
+# chi la consulta cade sul proprio default (`MODEL_DEFAULT`/`fable`) — 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
@@ -20,18 +20,19 @@
 # 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.
+# Il criterio della colonna modello: lettura e conversazione stanno su fable
+# (i tre recap, il preflight), la scrittura presidiata su opus (run e
+# checkpoint, che toccano codice e committano). Cambiare una parola qui cambia
+# il costo di OGNI sessione aperta su quel kind, da ogni superficie del deck —
+# non è una preferenza di questo progetto, è il default di famiglia.
 # `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}	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
+recap	/loom-works:recap-status {TASK}	fable
+recap-task	/loom-works:recap-status-task {TASK}	fable
+recap-epic	/loom-works:recap-status-epic {TASK}	fable
+preflight	/loom-works:preflight-task {TASK}	fable
+run	/loom-works:run-task {TASK}	opus
+checkpoint	/loom-works:checkpoint-task {TASK}	opus