@lamemind/loom-deck 0.63.0 → 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/cli.js

@@ -32,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';
@@ -110,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,
@@ -139,6 +145,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         status,
         inbox,
         wrap,
+        gitlink,
         purge,
         view: viewModals,
         text: textModals,
@@ -172,6 +179,17 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // 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,
@@ -251,6 +269,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     purgeBulk: model.purgeBulk,
                     inboxPane: model.rightPane === 'inbox',
                     hasInbox: model.selInbox !== 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();

package/dist/frame.js

@@ -106,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
@@ -232,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/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

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/package.json

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