@lamemind/loom-deck 0.62.1 → 0.64.0

package/README.md

@@ -74,7 +74,7 @@ Regola unica, senza eccezioni — pensata per reggere l'aggiunta di nuove azioni
 | `⏎` | azione primaria del pane | Tasks → apre il **detail** della task selezionata · Sessions → riprende (`claude --resume`) la sessione selezionata |
 | **MAIUSCOLA** | **apre un modale** | cattura tutti i tasti; `esc` annulla, non esce |
 | minuscola | azione immediata, one-shot | |
-| `CTRL`+lettera | idiomi universali, toggle dentro i modali di testo, varianti di un'azione | `^F` = find, come ovunque · `^K`/`^P`/`^R` = spawn con un altro prompt · `^G`/`^O` = genera/apri il project status |
+| `CTRL`+lettera | idiomi universali, toggle dentro i modali di testo, varianti di un'azione | `^F` = find, come ovunque · `^K`/`^P`/`^R` = spawn con un altro prompt · `^G`/`^O` = genera/apri il project status · `^U` = update del gitlink |
 | `1`…`9` | voce `launch` n-esima del progetto | da `.claude/loom-works.json` |
 | `esc` | chiude l'overlay aperto | in modalità normale è inerte: **nessuna lettera chiude il deck** |
 | `^C` `^C` | chiude il deck | la prima pressione avverte in riga di stato, la seconda entro **5 secondi** esce; passata la finestra si riparte dall'avviso. Da dentro un modale il primo `^C` riporta alla lista — l'avviso vive nella riga di stato, che le schermate a pieno frame non disegnano |
@@ -96,6 +96,7 @@ Assegnazioni correnti:
 | modale | `CANC` | **elimina** — la task selezionata; su una riga meta della vista `archiviabili`, l'intero insieme |
 | modale | `^O` | apre il **project status** in cache (viewer fullscreen) |
 | immediata | `^G` | **genera** il project status (skill headless, dura minuti) |
+| immediata | `^U` | **bumpa il gitlink** dei submodule idonei (solo su un progetto con `.gitmodules`) |
 | immediata | `^K` | spawna la task selezionata col prompt di **recap** |
 | immediata | `^P` | spawna la task selezionata sul **preflight** |
 | immediata | `^R` | spawna la task selezionata in **esecuzione** |
@@ -108,7 +109,7 @@ Assegnazioni correnti:
 Il footer è **due righe con due nature diverse**:
 
 ```
-⏎ detail · ^K/^P/^R spawn · ^G genera status · ^O apri status · ^F cerca · C nuova · E edit · S sort · F filtri · w salva
+⏎ detail · ^K/^P/^R spawn · ^G genera status · ^O apri status · ^U bumpa gitlink · ^F cerca · C nuova · E edit · S sort · F filtri · w salva
 t 💻 · c 🤖 · 1 📝 codium · 2 ☕ idea
 ```
 
@@ -274,6 +275,38 @@ Il recap vive in un file markdown sotto `/tmp/loom-deck-status-<uid>/`, col nome
 
 A generazione finita arriva una notifica desktop (`notify-send`): la generazione dura minuti e nel frattempo si guarda altrove, e la notifica di GNOME persiste nel cassetto — cosa che un suono non farebbe. Senza `notify-send` installato non succede **niente**: nessuna riga, nessun messaggio. L'assenza di un binario è una proprietà stabile della macchina, non un evento, e segnalarla a ogni generazione sarebbe rumore ripetuto su una funzione accessoria mentre il deliverable vero è arrivato comunque.
 
+### `^U` — il gitlink dei submodule
+
+Su un progetto **cappello** (un repo che aggrega altri repo come submodule) ogni membro è pinnato a un commit fisso. Quando il membro avanza — un commit nel deck, nel plugin — quel puntatore resta indietro finché qualcuno non lo bumpa, e il gesto vive nella memoria di chi committa. Il deck lo mette sotto gli occhi e lo rende un tasto.
+
+L'indicatore sta in coda alla riga della legenda, accanto agli altri due:
+
+```
+gitlink 2   wrap 77   [ Inbox 📄 3/1/2 ]
+```
+
+| Corpo | Significato |
+|---|---|
+| _(assente)_ | il progetto non ha `.gitmodules`: nessun timer, nessuno spawn, nessuna colonna spesa |
+| `missing` | prima misura non ancora tornata |
+| `?` | plugin loom-works non installato su questa macchina, o script in errore |
+| `ok` | ogni membro coincide col proprio gitlink |
+| `2` | due membri col checkout diverso dal gitlink |
+| `⚠` in coda | l'ultimo bump è fallito, **oppure** un membro richiede un gesto che il bump non fa |
+
+Nel numero entrano solo i membri che un bump può sistemare. Un submodule non inizializzato o in conflitto di merge resta fuori e si dice col glifo: sommarlo darebbe un contatore che il tasto non porta mai a zero, e un contatore così smette di essere letto.
+
+**`^U` bumpa**, senza conferma: il commit è locale e si annulla con un `git reset` che non tocca nessun remote. Il deck non pusha il cappello — quel gesto resta al flusso normale, perché un gitlink pushato per sbaglio è già nella copia di chiunque abbia pullato.
+
+Il deck **non classifica da sé**: spawna `bump-gitlink.sh` del plugin (in `--dry-run` per la misura, nudo per il bump) e mostra il TSV che ne esce. Nessuna sessione Claude in mezzo — è un `execFile` con esito sincrono, come il contatore inbox e lo scan hard-wrap. Lo stesso script si lancia a mano da shell, ed è lì che vivono le due guardie che rendono il bump sicuro:
+
+- **il verso** — `git submodule status` marca con `+` un checkout diverso dal gitlink **in entrambi i versi**, senza distinguerli. Un cappello pullato senza `git submodule update` ha il checkout più vecchio del gitlink e porta lo stesso `+`: bumparlo pinnerebbe il cappello a un commit precedente. Quel membro si salta, e la riga di stato nomina `git submodule update`.
+- **il remote** — il cappello può pinnare solo commit già raggiungibili dal remote del membro. Un gitlink verso un commit locale produce un cappello che si clona ma non si ricostruisce, e il difetto è invisibile a chi lo introduce: nella sua copia quel commit esiste. Quel membro si salta, e la riga di stato nomina `git -C <membro> push`.
+
+La riga di stato dopo il tasto riporta **un esito per membro**, non un totale: nel caso misto — uno pushato, uno no — un riassunto direbbe «1 bumpato» e lascerebbe fuori proprio il comando che sblocca l'altro.
+
+La misura gira ogni 30 secondi e subito dopo un bump. Il `--dry-run` non contatta la rete: il `fetch` che precede la guardia sul remote gira solo nel bump, quindi il contatore può dire «bumpabile» di un commit che il bump poi salta perché sparito dal remote. La guardia sta sull'azione, e un contatore non è un'autorizzazione.
+
 ## Vista: filtri e ordinamenti
 
 La lista è una **vista** sulla `tasks.md`: si filtra e si ordina senza toccare il file.

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).
@@ -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';
@@ -31,6 +32,7 @@ import { useAssignOverlay } from './overlays/assign.js';
 import { useProjectStatus } from './overlays/status.js';
 import { useInboxOverlay } from './overlays/inbox.js';
 import { useWrapOverlay } from './overlays/wrap.js';
+import { useGitlink } from './overlays/gitlink.js';
 import { usePurgeOverlay } from './overlays/purge.js';
 import { useTextModals, useViewModals } from './overlays/modals.js';
 import { useTerminalSize } from './hooks.js';
@@ -109,6 +111,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         setNote,
         onApply: actions.unwrapPath,
     });
+    // T155 — il gitlink dei submodule. Terzo sensore con lo stato in vista
+    // normale, dopo il project status e l'hard-wrap: qui però non c'è nessuna
+    // schermata da aprire — l'unica superficie è l'indicatore, e l'unica azione
+    // committa.
+    const gitlink = useGitlink({ cwd, setNote });
     const purge = usePurgeOverlay({
         setMode,
         setNote,
@@ -138,6 +145,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         status,
         inbox,
         wrap,
+        gitlink,
         purge,
         view: viewModals,
         text: textModals,
@@ -162,10 +170,26 @@ 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).
     const indicators = indicatorRow({
+        // T155 — `null` chiude il gate: su un progetto senza `.gitmodules` il
+        // segmento non esiste, e la riga legenda si riprende quelle colonne.
+        gitlink: gitlink.enabled
+            ? {
+                count: gitlink.count,
+                attention: gitlink.attention,
+                scanned: gitlink.scanned,
+                ok: gitlink.ok,
+                failed: gitlink.failed,
+            }
+            : null,
         inbox: {
             counts: model.inboxCounts,
             stale: model.inboxStale,
@@ -245,7 +269,8 @@ 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] }));
+                    gitlink: gitlink.enabled,
+                }), 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
@@ -83,6 +106,9 @@ export function deckLegend(state) {
         // cosa e sta a due voci di distanza.
         '^G genera status',
         '^O apri status',
+        // T155 — la voce nomina il GESTO, come le due sopra: «gitlink» da solo
+        // direbbe l'oggetto e non che il tasto lo allinea con un commit.
+        ...(state.gitlink ? ['^U bumpa gitlink'] : []),
         // T134 — la voce nomina il pane che il tasto MONTA, non quello montato:
         // `^B` scambia i due, e annunciare quello che si sta già guardando
         // direbbe il contrario di ciò che il tasto fa. Stessa regola di `CANC
@@ -102,21 +128,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,
     };
 }
 /**
@@ -184,11 +235,47 @@ export function wrapIndicator(state) {
             : String(state.count);
     return sanitize(`wrap ${body}${state.ok ? '' : ` ${WARN}`}`);
 }
+/**
+ * T155 — l'indicatore del gitlink: `gitlink 2`.
+ *
+ * Conta i membri il cui checkout NON coincide col gitlink registrato, in
+ * entrambi i versi (`disalignedCount` in `gitlink.ts`). Fuori dal numero restano
+ * i membri che nessun bump sistema — non inizializzati, in conflitto — perché un
+ * contatore che il tasto non può portare a zero smette di essere letto: è la
+ * stessa regola per cui `misto` non entra nel contatore dell'hard-wrap.
+ *
+ * Quattro corpi distinti, come per gli altri due indicatori: `missing` finché la
+ * prima misura non è tornata, `?` quando lo script non è raggiungibile (plugin
+ * non installato su questa macchina, o uscito male), il numero quando c'è
+ * qualcosa da bumpare, `ok` quando tutti i membri coincidono.
+ *
+ * Il glifo di allerta si AGGIUNGE al corpo invece di sostituirlo, e copre i due
+ * fatti che il numero non dice: l'ultimo bump è fallito, oppure un membro
+ * richiede un gesto che il bump non fa. Entrambi restano veri accanto al
+ * conteggio, e chi lo vede preme il tasto per leggere la riga di stato, che
+ * nomina i membri.
+ */
+export function gitlinkIndicator(state) {
+    const body = !state.scanned
+        ? STATUS_MISSING
+        : !state.ok
+            ? '?'
+            : state.count > 0
+                ? String(state.count)
+                : 'ok';
+    const warn = state.failed || state.attention > 0 ? ` ${WARN}` : '';
+    return sanitize(`gitlink ${body}${warn}`);
+}
 export function indicatorRow(state, columns) {
-    // Ordine di lettura: l'indicatore, poi il bottone. Il bottone sta all'estremo
-    // destro perché è l'unico dei due che MONTA qualcosa restando in vista
-    // normale — la lista del wrap è una schermata che si apre e si chiude.
+    // Ordine di lettura: gli indicatori, poi il bottone. Il bottone sta
+    // all'estremo destro perché è l'unico dei tre che MONTA qualcosa restando in
+    // vista normale — la lista del wrap è una schermata che si apre e si chiude.
+    //
+    // Il gitlink sta in TESTA al blocco, che è ancorato al bordo destro: è l'unico
+    // segmento che può mancare del tutto (il gate su `.gitmodules`), e da lì la
+    // sua assenza non sposta gli altri due.
     const segments = [
+        ...(state.gitlink ? [{ key: '^u', text: gitlinkIndicator(state.gitlink) }] : []),
         { key: '^w', text: wrapIndicator(state.wrap) },
         { key: '^b', text: inboxButton(state.inbox) },
     ];

package/dist/gitlink.js

@@ -0,0 +1,210 @@
+// T155 — il gitlink dei submodule come dato del deck.
+//
+// Il cappello pinna ogni membro a un commit fisso (gitlink `160000`). Quando un
+// submodule avanza — un commit nel deck, nel plugin, in compass — il gitlink
+// resta indietro finché qualcuno non lo bumpa a mano.
+//
+// LA CLASSIFICAZIONE NON STA QUI (P1 preflight). Il deck spawna
+// `bump-gitlink.sh --dry-run` del plugin e mostra il TSV che ne esce: la stessa
+// sequenza che poi committa è quella che ha misurato, quindi il sensore non può
+// dire «bumpabile» in base a un criterio diverso da quello del bump. Replicarla
+// in TypeScript darebbe due implementazioni delle due guardie — quella sul verso
+// e quella sul remote — e una divergenza fra le due si vedrebbe solo come un
+// cappello pinnato su un commit sbagliato, giorni dopo, nel clone di qualcun
+// altro. Stesso confine di `inbox.ts` e `wrap-scan.ts`, e non quello di
+// `purge.ts`, che passa da una sessione Claude: qui non c'è nessun prompt, solo
+// un `execFile` con esito sincrono.
+//
+// Lettore puro + spawn: nessun React, nessuna resa. È l'unico modo di provarlo
+// senza pseudo-terminale.
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { pluginScript } from './plugin-cache.js';
+const execFileAsync = promisify(execFile);
+export const GITLINK_SCRIPT = 'scripts/utils/bump-gitlink.sh';
+/**
+ * Ogni 30 secondi (P2 preflight).
+ *
+ * Il gate che regge gli altri poll stretti del deck qui NON funziona: il
+ * disallineamento nasce da un commit dentro il submodule, che lascia fermi sia
+ * `HEAD` del cappello (`commit-times.ts`) sia la mtime dei task file
+ * (`epic-hierarchy.ts`) — non c'è niente di economico da misurare prima. Resta
+ * il costo nudo, misurato sul cappello a tre submodule: 0,03s per giro, dentro
+ * il budget che T153 ha fissato per il loop.
+ *
+ * Il dry-run NON contatta la rete (P11): la guardia col `fetch` gira solo nel
+ * bump. Ne discende che il sensore può contare «bumpabile» un commit che il
+ * bump poi salta perché sparito dal remote — la guardia sta sull'AZIONE, e un
+ * contatore non è un'autorizzazione.
+ */
+export const GITLINK_SCAN_INTERVAL_MS = 30 * 1000;
+/**
+ * Gli stati che lo script emette, più `sconosciuto` che è del solo lettore.
+ *
+ * I primi tre vengono dai prefissi di `git submodule status`; gli altri
+ * spacchettano il prefisso `+`, che da solo NON dice il verso — `man
+ * git-submodule`: «`+` if the currently checked out submodule commit does not
+ * match the SHA-1 found in the index». Un checkout più vecchio del gitlink
+ * (cappello pullato senza `git submodule update`) porta lo stesso `+` di un
+ * commit nuovo nel membro, e le due situazioni hanno rimedi opposti.
+ *
+ * `bumpato` esiste solo nell'output del bump: nel dry-run un membro idoneo resta
+ * `avanti`. Sono due fatti diversi — «lo bumperei» e «l'ho bumpato» — e un solo
+ * nome per entrambi renderebbe la riga di stato indistinguibile da un'anteprima.
+ */
+export const GITLINK_STATES = [
+    'allineato',
+    'non-inizializzato',
+    'conflitto',
+    'avanti',
+    'indietro',
+    'non-pushato',
+    'remote-irraggiungibile',
+    'bumpato',
+];
+const KNOWN = new Set(GITLINK_STATES);
+/**
+ * Il TSV di `bump-gitlink.sh`: una riga per submodule, `path ⇥ stato ⇥ dettaglio`.
+ * Nessuna riga di intestazione — il primo campo è già un path.
+ *
+ * Uno stato che il deck non conosce diventa `sconosciuto` invece di sparire: la
+ * riga la si è comunque ricevuta, e scartarla farebbe calare il contatore ogni
+ * volta che lo script guadagna uno stato nuovo — cioè proprio quando il deck ha
+ * più bisogno di dirlo. Il dettaglio è l'ULTIMO campo e si ricompone: può
+ * contenere un comando, e un comando può contenere un tab.
+ */
+export function parseGitlinkTsv(stdout) {
+    const out = [];
+    for (const line of stdout.split('\n')) {
+        if (!line.trim())
+            continue;
+        const c = line.split('\t');
+        if (c.length < 2 || !c[0])
+            continue;
+        out.push({
+            path: c[0],
+            state: KNOWN.has(c[1]) ? c[1] : 'sconosciuto',
+            detail: c.slice(2).join('\t'),
+        });
+    }
+    return out;
+}
+/**
+ * Gli stati che il contatore somma: i membri il cui checkout non coincide col
+ * gitlink, in entrambi i versi.
+ *
+ * `non-inizializzato` e `conflitto` restano FUORI per decisione: nessun bump li
+ * sistema — il primo vuole un `git submodule update --init`, il secondo la
+ * risoluzione di un merge — e sommarli darebbe un numero che il tasto non può
+ * portare a zero. Un contatore che non arriva mai a zero smette di essere letto
+ * (stessa regola di `misto` nell'indicatore hard-wrap). Si dicono comunque, col
+ * glifo di allerta accanto al numero.
+ */
+const DISALIGNED = new Set([
+    'avanti',
+    'indietro',
+    'non-pushato',
+    'remote-irraggiungibile',
+]);
+/** Quanti membri hanno il checkout diverso dal gitlink: è il numero a schermo. */
+export function disalignedCount(members) {
+    return members.filter((m) => DISALIGNED.has(m.state)).length;
+}
+/** Quanti sono bumpabili adesso: il solo `avanti` passa entrambe le guardie. */
+export function bumpableCount(members) {
+    return members.filter((m) => m.state === 'avanti').length;
+}
+/**
+ * Qualcosa richiede attenzione ma nessun bump lo sistema: un membro non
+ * inizializzato, un conflitto di merge, uno stato che questo deck non conosce.
+ * Vale il glifo di allerta, mai una cifra nel contatore.
+ */
+export function attentionCount(members) {
+    return members.filter((m) => m.state === 'non-inizializzato' || m.state === 'conflitto' || m.state === 'sconosciuto').length;
+}
+/**
+ * Gli stati che il bump ha SALTATO: il membro è disallineato ma una delle due
+ * guardie l'ha fermato, e il rimedio non è un bump ma il gesto che il dettaglio
+ * nomina.
+ */
+const SKIPPED = new Set(['indietro', 'non-pushato', 'remote-irraggiungibile']);
+/**
+ * La riga di stato dopo un bump: un esito per membro, non un totale.
+ *
+ * Il caso che rende necessario nominarli è il MISTO — un membro pushato e uno
+ * no. Lì un messaggio riassuntivo direbbe «1 bumpato» e lascerebbe fuori proprio
+ * l'informazione che serve ad agire: quale membro è rimasto indietro e con quale
+ * comando lo si sblocca. Il gesto arriva già scritto dallo script, che è dove la
+ * guardia lo ha deciso: comporlo qui darebbe due frasi da tenere allineate.
+ *
+ * I bumpati vengono per primi — è l'esito che il tasto prometteva — e i saltati
+ * dopo, ognuno col proprio glifo di allerta. I membri allineati non compaiono:
+ * la riga di stato dice cosa è successo, non cosa esiste.
+ */
+export function gitlinkNote(members) {
+    const done = members
+        .filter((m) => m.state === 'bumpato')
+        .map((m) => `✔ ${m.path} ${m.detail}`.trim());
+    const skipped = members
+        .filter((m) => SKIPPED.has(m.state))
+        .map((m) => `⚠ ${m.path}: ${m.detail}`);
+    return [...done, ...skipped].join(' · ');
+}
+/**
+ * Il progetto ha submodule da misurare.
+ *
+ * È il gate di ATTIVAZIONE dell'intero sensore (DLV2): senza `.gitmodules` non
+ * parte nessun timer, non si spawna niente e l'indicatore non compare affatto —
+ * non «0», che occuperebbe colonne per dire che la funzione non si applica.
+ *
+ * Il file, non `git submodule status`: rispondere alla domanda «ci sono
+ * submodule?» con lo stesso spawn che si vuole evitare sarebbe la misura che il
+ * gate esiste per non pagare.
+ */
+export function hasGitmodules(projectRoot) {
+    return existsSync(join(projectRoot, '.gitmodules'));
+}
+/**
+ * Invoca lo script e ne parsa l'output.
+ *
+ * I modi di non avere il dato — plugin non installato su questa macchina,
+ * script in errore, git muto — collassano in un solo `ok: false`, come per la
+ * coda inbox: a schermo non cambiano la prima mossa di chi li vede. Nessuno dei
+ * due è un throw, un indicatore informativo non può rompere il deck.
+ *
+ * Lo stdout si legge ANCHE quando l'exit è non-zero: lo script classifica tutti
+ * i membri prima di agire, quindi su un errore parziale (un `git` che fallisce
+ * su un membro) le righe già emesse restano vere e dicono più di una schermata
+ * vuota.
+ */
+async function run(projectRoot, args) {
+    const script = pluginScript(GITLINK_SCRIPT);
+    if (!script)
+        return { members: [], ok: false };
+    try {
+        const { stdout } = await execFileAsync(script, args, {
+            cwd: projectRoot,
+            maxBuffer: 1024 * 1024,
+        });
+        return { members: parseGitlinkTsv(stdout), ok: true };
+    }
+    catch (e) {
+        const stdout = e.stdout ?? '';
+        return { members: parseGitlinkTsv(stdout), ok: false };
+    }
+}
+/** La misura, senza toccare niente: nessun fetch, nessun commit. */
+export function scanGitlink(projectRoot) {
+    return run(projectRoot, ['--dry-run']);
+}
+/**
+ * Il bump vero: fetch, due guardie, commit unico coi soli membri idonei. Il
+ * cappello NON viene pushato — quel gesto resta al flusso normale, perché un
+ * gitlink committato per sbaglio si annulla con un `git reset` che non tocca
+ * nessun remote, mentre uno pushato è già nella copia di chiunque abbia pullato.
+ */
+export function bumpGitlink(projectRoot) {
+    return run(projectRoot, []);
+}

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

@@ -322,6 +322,19 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
             else if (input === 'e') {
                 overlays.wrap.scan();
             }
+            else if (input === 'u') {
+                // T155/P5 preflight — `^U` (update del gitlink) bumpa i submodule
+                // idonei. Non è la coppia genera/apri di `^G`/`^O` e `^W`/`^E`: qui non
+                // c'è nessuna schermata da aprire, la misura gira da sé ogni 30 secondi
+                // e l'unico gesto è l'azione. Nessuna conferma, perché il commit è
+                // locale e reversibile (P6).
+                //
+                // `^B` era la mnemonica migliore per «bump» ed è di T134 (scambia i due
+                // pane dello slot destro). `^U` svuota un campo dentro i modi capturing,
+                // ma quelli consumano l'input per intero e non vedono mai questo ramo —
+                // stesso doppio significato per contesto già in esercizio su `^F`.
+                overlays.gitlink.bump();
+            }
             else if (input === 'b') {
                 // T134/D8 preflight — `^B` (box/bacheca) scambia i due pane dello slot
                 // destro. Non è un modale né una schermata: il pane resta uno dei due
@@ -467,9 +480,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/gitlink.js

@@ -0,0 +1,154 @@
+// T155 — il sensore del gitlink: stato, gate di attivazione, cadenza.
+//
+// Non è un overlay come `sheet` o `search` — non apre nessuna schermata e non
+// entra in `MODE_KEYS`. Sta qui per la stessa ragione di `useProjectStatus` e
+// `useWrapOverlay`: tiene uno stato che si legge in vista normale e possiede
+// l'azione che quello stato abilita, e `hooks.ts` è già a 487 righe (P3
+// preflight, D1/P12 — nessuno split dentro questa task).
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { attentionCount, bumpableCount, bumpGitlink, disalignedCount, gitlinkNote, GITLINK_SCAN_INTERVAL_MS, hasGitmodules, scanGitlink, } from '../gitlink.js';
+export function useGitlink(deps) {
+    const { cwd, setNote } = deps;
+    /**
+     * IL GATE. Senza `.gitmodules` il progetto non ha submodule, quindi non c'è
+     * niente da misurare: nessun timer parte, nessuno spawn viene fatto, e
+     * l'indicatore non compare affatto — non «0», che occuperebbe colonne della
+     * riga legenda per dire che la funzione non si applica.
+     *
+     * Misurato UNA VOLTA per project root e non a ogni giro: un repo non guadagna
+     * submodule mentre il deck è aperto, e se lo facesse basta riavviarlo. È lo
+     * stesso limite accettato dalla cache del plugin (`plugin-cache.ts`), scritto
+     * qui invece che scoperto dopo.
+     */
+    const enabled = useMemo(() => hasGitmodules(cwd), [cwd]);
+    const [members, setMembers] = useState([]);
+    const [ok, setOk] = useState(true);
+    /** Almeno un tentativo è stato fatto: distingue «non ho ancora misurato» da
+     *  «ho misurato e sono tutti allineati», che a schermo sono due cose diverse. */
+    const [scanned, setScanned] = useState(false);
+    const [epoch, setEpoch] = useState(0);
+    const [bumping, setBumping] = useState(false);
+    /** L'ultimo bump si è fermato prima di committare. STICKY: un giro di misura
+     *  riuscito non lo azzera — dice com'è andata l'ultima AZIONE, che è un fatto
+     *  diverso da com'è andata l'ultima misura, e i due restano entrambi veri.
+     *  Stessa regola del `failed` del project status. */
+    const [failed, setFailed] = useState(false);
+    // Il flag di corsa sta in un ref e non in stato, come in `useInboxScan`: due
+    // richieste ravvicinate girano nello stesso tick di React, e un valore di
+    // stato arriverebbe al render dopo — cioè troppo tardi per impedire il
+    // secondo spawn.
+    const busy = useRef(false);
+    // `alive` vive fuori dall'effect perché la richiesta forzata sopravvive al
+    // giro che l'ha ospitata: la scatena un gesto, non l'effect.
+    const alive = useRef(true);
+    useEffect(() => {
+        alive.current = true;
+        return () => {
+            alive.current = false;
+        };
+    }, []);
+    const run = useCallback(() => {
+        if (busy.current)
+            return;
+        busy.current = true;
+        scanGitlink(cwd).then((res) => {
+            busy.current = false;
+            if (!alive.current)
+                return;
+            // Un tentativo fallito NON butta via l'esito dell'ultimo riuscito: le
+            // righe precedenti restano vere, e il guasto si dice col glifo di allerta
+            // accanto al numero. Stessa regola del project status e della coda inbox.
+            setOk(res.ok);
+            setScanned(true);
+            if (res.ok || res.members.length > 0)
+                setMembers(res.members);
+        });
+    }, [cwd]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        run();
+        const id = setInterval(run, GITLINK_SCAN_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, [enabled, run, epoch]);
+    /**
+     * Rimisura adesso e riparte col timer da zero.
+     *
+     * Il reset non è cosmetico: senza, l'intervallo continuerebbe a scorrere
+     * dall'ultimo tick automatico e potrebbe rimisurare pochi istanti dopo un
+     * dato appena misurato — costo pieno, risultato identico. Stessa forma di
+     * `useWrapScan` e `useInboxScan`.
+     */
+    const refresh = useCallback(() => {
+        setEpoch((e) => e + 1);
+    }, []);
+    const count = disalignedCount(members);
+    const bumpable = bumpableCount(members);
+    /**
+     * Il bump vero — l'unica azione del sensore.
+     *
+     * NESSUNA CONFERMA (P6 preflight): il commit è locale e si annulla con un
+     * `git reset` che non tocca nessun remote, e lo script non pusha il cappello.
+     * È la stessa forma di `^G`, che genera senza chiedere.
+     *
+     * I quattro rifiuti dicono SEMPRE perché (AC: il tasto su zero disallineati
+     * non spawna niente e lo dice). Un tasto che non facesse niente in silenzio
+     * sarebbe indistinguibile da un binding mancante.
+     */
+    function bump() {
+        if (!enabled) {
+            setNote('^U → questo progetto non ha submodule: nessun gitlink da bumpare');
+            return;
+        }
+        if (busy.current || bumping) {
+            setNote('^U → bump del gitlink già in corso');
+            return;
+        }
+        if (!scanned) {
+            setNote('^U → gitlink non ancora misurato');
+            return;
+        }
+        if (bumpable === 0) {
+            const why = gitlinkNote(members);
+            setNote(count === 0
+                ? '^U → gitlink già allineato: niente da bumpare'
+                : `^U → nessun membro bumpabile · ${why}`);
+            return;
+        }
+        busy.current = true;
+        setBumping(true);
+        setNote(`⏳ bump del gitlink su ${bumpable} membro${bumpable > 1 ? 'i' : ''}…`);
+        bumpGitlink(cwd).then((res) => {
+            busy.current = false;
+            if (!alive.current)
+                return;
+            setBumping(false);
+            setOk(res.ok);
+            setScanned(true);
+            setFailed(!res.ok);
+            if (res.members.length > 0)
+                setMembers(res.members);
+            const note = gitlinkNote(res.members);
+            setNote(note || (res.ok ? '✔ gitlink: nessun membro bumpato' : '⚠ bump del gitlink fallito'));
+            // Rimisura: l'output del bump porta già gli stati nuovi, ma il giro
+            // successivo li conferma da `git submodule status` invece che dalla
+            // memoria di ciò che si è appena fatto — ed è ciò che fa scendere il
+            // contatore senza riavviare il deck anche quando il commit ha toccato più
+            // di quanto lo script credeva.
+            refresh();
+        });
+    }
+    return {
+        enabled,
+        members,
+        ok,
+        scanned,
+        bumping,
+        failed,
+        count,
+        bumpable,
+        attention: attentionCount(members),
+        bump,
+        refresh,
+    };
+}

package/dist/spawn.js

@@ -330,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.1",
+  "version": "0.64.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": {