@lamemind/loom-deck 0.48.0 → 0.49.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 |
+| `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 |
 | `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 |
@@ -94,6 +94,8 @@ Assegnazioni correnti:
 | modale | `^F` | **ricerca full-text** nelle conversazioni del progetto |
 | modale | `⏎` | **detail** della task selezionata: task file scrollabile + area di compilazione a quattro righe |
 | 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 | `^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** |
@@ -106,7 +108,7 @@ Assegnazioni correnti:
 Il footer è **due righe con due nature diverse**:
 
 ```
-⏎ detail · ^K/^P/^R spawn · ^F cerca · C nuova · E edit · S sort · F filtri · w salva
+⏎ detail · ^K/^P/^R spawn · ^G genera status · ^O apri status · ^F cerca · C nuova · E edit · S sort · F filtri · w salva
 t 💻 · c 🤖 · 1 📝 codium · 2 ☕ idea
 ```
 
@@ -233,6 +235,32 @@ I toggle e la query sono **volatili**: sopravvivono alla chiusura del modale, no
 
 **Come fa a essere istantanea.** I corpi dei messaggi restano in RAM dentro la cache mtime-keyed che il deck usa già per la lista sessioni: quei file venivano comunque deserializzati per turni e titoli, e i corpi buttati. Trattenerli non aggiunge I/O, aggiunge memoria — e ne aggiunge poca, perché un JSONL è per l'85% overhead (misurato su un progetto reale: 57 MB su disco = 9,8 MB di testo cercabile). Cercarci dentro costa 1-9 ms; un prefiltro `grep` sugli stessi file ne costerebbe 26, perché rileggerebbe il volume pieno a ogni battuta.
 
+### `^G` / `^O` — il project status
+
+Il recap di progetto (`/loom-works:recap-status-project`) non è più solo una conversazione da aprire e perdere: il deck lo tiene come **artefatto**. La prima riga della cornice lo dice sempre.
+
+```
+loom-works :: PROJECT STATUS [ 09:42 ]        v0.49.0
+```
+
+Il campo fra parentesi ha tre stati e basta:
+
+| Stato | Significato |
+|---|---|
+| `missing` | nessun recap in cache: mai generato, o cache svuotata |
+| `◍ building 47...` | generazione in corso, coi secondi trascorsi dallo spawn |
+| `09:42` | ora dell'ultima generazione riuscita |
+
+Il glifo `◍` è lo stesso della colonna liveness delle sessioni: una generazione in corso **è** una conversazione che sta lavorando, non un simbolo nuovo da imparare. Dopo un tentativo fallito il campo porta un marker in coda (`[ 09:42 ⚠ ]`) e se lo tiene finché una generazione riuscita non lo azzera — la riga di stato sparisce al primo tasto premuto, e un fallimento non deve poter passare inosservato per una pressione di freccia. Il fallimento **non** cancella l'ora: la cache non è stata riscritta, quindi il recap di prima è ancora vero e ancora apribile.
+
+**Due tasti, non uno**: `^G` genera, `^O` apre. Aprire un recap vecchio costa una lettura di file, generarlo costa minuti di sessione Claude — legarli allo stesso tasto renderebbe il gesto economico un effetto collaterale di quello caro. `^G` con una generazione già in corso non ne fa partire una seconda; `^O` su cache assente lo dice nella riga di stato invece di aprire un viewer vuoto.
+
+Il recap vive in un file markdown sotto `/tmp/loom-deck-status-<uid>/`, col nome derivato dal path del progetto (non-alnum → `-`, la stessa trasformazione del transcript store di Claude Code). Da lì tre conseguenze volute: **sopravvive alla chiusura del deck** (riaperto, la testata mostra l'ora di prima), muore al reboot (un recap di ieri è comunque stale), e la coordinata resta una funzione pura del path invece di un registro da tenere allineato. L'ora mostrata è l'**mtime del file**, mai un campo scritto dentro il testo: un fatto scritto due volte diverge alla prima riscrittura parziale.
+
+`^O` apre un **viewer fullscreen** con lo stesso markdown reso del detail della task: `↑↓` riga, `PgUp`/`PgDn` pagina, `g`/`G` estremi, `esc` chiude. Aperto mentre una generazione gira, mostra la versione precedente e lo **dichiara** nella riga meta — il viewer è una fotografia e non si aggiorna da sé quando la generazione finisce.
+
+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.
+
 ## Vista: filtri e ordinamenti
 
 La lista è una **vista** sulla `tasks.md`: si filtra e si ordina senza toccare il file.

package/dist/cli.js

@@ -22,6 +22,7 @@ import { commitTaskEdit, runLaunch, spawnClaudeEmpty, spawnCleanTasks, spawnCrea
 import { EditModal, FilterModal, PurgeModal, SortModal, idList } from './ui/modals.js';
 import { ReaderScreen, SearchScreen } from './ui/search-screen.js';
 import { DetailScreen } from './ui/detail-screen.js';
+import { StatusHeadline, StatusScreen } from './ui/status-screen.js';
 import { AssignScreen } from './ui/assign-screen.js';
 import { SessionsPane, TasksPane } from './ui/panes.js';
 import { PreviewPane, detailMetaOf } from './ui/preview.js';
@@ -30,6 +31,7 @@ import { useArchivable, useDirtyFolders, useSessions, useTaskDetail, useTasks, u
 import { useSearchOverlay } from './overlays/search.js';
 import { useSheetOverlay } from './overlays/sheet.js';
 import { useAssignOverlay } from './overlays/assign.js';
+import { useProjectStatus } from './overlays/status.js';
 import { captures } from './input-modes.js';
 import { VERSION } from './version.js';
 // T116 — l'avviso della prima pressione di `^C`. La durata è INTERPOLATA dalla
@@ -757,6 +759,20 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         setNote,
         onResume: (row) => resumeSession(row.session.sessionId),
     });
+    // T121 — il project status. Non è solo un overlay come i tre sopra: il suo
+    // stato si legge in TESTATA a schermata chiusa, e il viewer è una delle sue
+    // superfici invece che il suo contenuto.
+    // Il nome è quello del file config quando c'è, la cartella altrimenti: la
+    // testata deve dire di quale progetto parla anche su un checkout non ancora
+    // registrato.
+    const status = useProjectStatus({
+        cwd,
+        name: projectCore ?? projectName,
+        rows,
+        columns,
+        setMode,
+        setNote,
+    });
     function onCreateKey(input, key) {
         if (key.escape) {
             setMode('normal');
@@ -929,6 +945,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // `CapturingMode`, un modo nuovo senza handler non compila.
     const MODE_KEYS = {
         detail: sheet.onKey,
+        status: status.onKey,
         reader: search.onReaderKey,
         search: search.onSearchKey,
         assign: assign.onKey,
@@ -980,6 +997,17 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             else if (input === 'r') {
                 spawnTaskSession('run', '^R');
             }
+            else if (input === 'g') {
+                // T121 — GENERA e APRI su due tasti distinti (D2): aprire un recap
+                // vecchio deve costare zero, e generare non deve essere un effetto
+                // collaterale del guardare. Nessuno dei due è preso né bruciato da Ink,
+                // e `^S`/`^Q` sono evitati perché il terminale li intercetta come flow
+                // control.
+                status.generate();
+            }
+            else if (input === 'o') {
+                status.open();
+            }
             return;
         }
         if (key.tab) {
@@ -1266,6 +1294,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // schermate. Rename di sola ETICHETTA: il dato resta `note` nel sidecar e
         // `--title-note` in deck-run, dove rinominarlo sarebbe un breaking.
         ...(canPin ? ['p pin', 'N titolo', 'A assegna'] : []),
+        // T121 — le due voci nominano il GESTO e non l'oggetto: «status» da solo
+        // sarebbe indistinguibile dal recap della task su `^K`, che è un'altra
+        // cosa e sta a due voci di distanza.
+        '^G genera status',
+        '^O apri status',
         '^F cerca',
         'C nuova',
         'E edit',
@@ -1312,6 +1345,18 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         const start = Math.min(sheet.top, sheet.maxTop);
         return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, model: sheet.model, spawnNote: sheet.spawnNote, prompt: sheet.prompt, cursor: sheet.cursor, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur }));
     }
+    // ── T121 · viewer del project status ────────────────────────────────────
+    // Quinta schermata sostitutiva, stessa ragione delle altre quattro: un recap
+    // di progetto è lungo quanto un task file e non entra in un box sopra i pane.
+    if (mode === 'status' && status.view) {
+        if (isCompact(status.capacity)) {
+            return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 project status \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga \u00B7 esc chiude"] })] }));
+        }
+        // Il clamp serve anche qui: un resize può accorciare il testo sotto uno
+        // scroll già dato.
+        const start = Math.min(status.top, status.maxTop);
+        return (_jsx(StatusScreen, { name: projectCore ?? projectName, label: status.label, building: status.building, failed: status.failed, view: status.view, lines: status.lines.slice(start, start + status.capacity), spans: status.doc?.spans ?? [], top: start, total: status.lines.length, capacity: status.capacity, columns: columns }));
+    }
     // ── T52 · schermate sostitutive ─────────────────────────────────────────
     // Ricerca e reader sono gli unici modali che NON stanno in flusso sopra i
     // pane: una lista di occorrenze non entra in un box da 4 righe. Prendono
@@ -1401,7 +1446,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     if (budget.compact) {
         return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "v", VERSION, " \u00B7 ", viewTasks.length, " task \u00B7 sel ", selectedTaskId ?? parentLabel, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga"] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: ["v", VERSION] })] }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["titolo conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'purge' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["elimina task \u00B7", ' ', purge?.ignored ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " keep/purge dei file non tracciati \u00B7", ' '] })) : null, _jsx(Text, { color: "yellow", children: "\u23CE" }), " conferma \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${legend.shown}` : '', legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editCursor.row, caret: editCursor.caret, columns: columns })) : null, mode === 'purge' && purge ? _jsx(PurgeModal, { draft: purge, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, idW: taskCols.id, tailW: taskCols.tail, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, data: taskRowData }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(StatusHeadline, { name: projectCore ?? projectName, label: status.label, building: status.building, failed: status.failed, cols: Math.max(4, columns - 4 - `v${VERSION}`.length - 1) }), _jsxs(Text, { dimColor: true, children: ["v", VERSION] })] }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["titolo conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'purge' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["elimina task \u00B7", ' ', purge?.ignored ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " keep/purge dei file non tracciati \u00B7", ' '] })) : null, _jsx(Text, { color: "yellow", children: "\u23CE" }), " conferma \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${legend.shown}` : '', legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editCursor.row, caret: editCursor.caret, columns: columns })) : null, mode === 'purge' && purge ? _jsx(PurgeModal, { draft: purge, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, idW: taskCols.id, tailW: taskCols.tail, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, data: taskRowData }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : 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/glyphs.js

@@ -139,6 +139,14 @@ export function fmtDateTime(ts) {
     const p = (n) => String(n).padStart(2, '0');
     return `${p(d.getDate())}/${p(d.getMonth() + 1)} ${p(d.getHours())}:${p(d.getMinutes())}`;
 }
+// T121 — sola ora del giorno, per l'indicatore di project status in testata. Il
+// giorno non ci sta e non servirebbe: un recap del giorno prima è comunque
+// stale, e la cache muore col reboot.
+export function fmtTime(ts) {
+    const d = new Date(ts);
+    const p = (n) => String(n).padStart(2, '0');
+    return `${p(d.getHours())}:${p(d.getMinutes())}`;
+}
 // Età relativa compatta (ms epoch → "2m"/"3h"/"5d") per il preview sessioni.
 export function relTime(ts) {
     const sec = Math.max(0, Math.floor((Date.now() - ts) / 1000));

package/dist/input-modes.js

@@ -21,6 +21,7 @@
  */
 export const CAPTURING_MODES = [
     'detail',
+    'status',
     'reader',
     'search',
     'assign',

package/dist/overlays/status.js

@@ -0,0 +1,159 @@
+// T121 — il PROJECT STATUS del deck: generazione headless, cache su disco,
+// indicatore in testata e viewer fullscreen.
+//
+// Non è solo un overlay come `sheet` o `search`: lo stato che tiene (cosa c'è
+// in cache, se una generazione è in corso, com'è andato l'ultimo tentativo) è
+// visibile in testata a schermata chiusa. Il viewer è una delle sue superfici,
+// non il suo contenuto.
+//
+// Le due attivazioni sono DISTINTE per costruzione (D2): generare costa minuti
+// di sessione Claude, aprire costa una lettura di file — legarle allo stesso
+// tasto renderebbe il gesto economico un effetto collaterale di quello caro.
+import { useEffect, useMemo, useState } from 'react';
+import { randomUUID } from 'node:crypto';
+import { statusCapacity } from '../viewport.js';
+import { cut, wrapWithOffsets } from '../width.js';
+import { parseMarkdown } from '../markdown.js';
+import { CLAUDE_CMD, notifyDone, spawnProjectStatus } from '../spawn.js';
+import { readStatusCache, statusFilePath, statusLabel, writeStatusCache, } from '../project-status.js';
+export function useProjectStatus(deps) {
+    const { cwd, name, rows, columns, setMode, setNote } = deps;
+    const path = useMemo(() => statusFilePath(cwd), [cwd]);
+    // Letta al mount e basta: è ciò che fa ripartire un deck riaperto dall'ora di
+    // prima invece che da `missing`.
+    const [cache, setCache] = useState(() => readStatusCache(path));
+    const [startedAt, setStartedAt] = useState(null);
+    const [failed, setFailed] = useState(false);
+    const [now, setNow] = useState(() => Date.now());
+    const [view, setView] = useState(null);
+    const [top, setTop] = useState(0);
+    // Il contatore dei secondi ha un tick PROPRIO, acceso solo mentre serve. Il
+    // poll del deck è a 1500ms: appeso a quello l'elapsed avanzerebbe a scatti
+    // irregolari. Un intervallo permanente, all'opposto, ridisegnerebbe il deck
+    // ogni secondo per sempre — costo invisibile in sviluppo, non su una macchina
+    // carica.
+    useEffect(() => {
+        if (startedAt === null)
+            return;
+        setNow(Date.now());
+        const id = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(id);
+    }, [startedAt]);
+    const label = statusLabel({ mtime: cache?.mtime ?? null, startedAt, now, failed });
+    function finish(ok, detail) {
+        setStartedAt(null);
+        const text = detail.trim();
+        if (!ok || !text) {
+            // Nessuna riscrittura della cache: il recap precedente resta leggibile e
+            // `^O` continua ad aprirlo. Il marker in testata è l'unica traccia che
+            // sopravvive alla riga di stato, che sparisce al primo tasto premuto.
+            setFailed(true);
+            setNote(`⚠ project status fallito · ${cut(detail || `${CLAUDE_CMD} -p`, 56)}`);
+            notifyDone('loom-deck · project status', `${name}: generazione fallita`);
+            return;
+        }
+        try {
+            writeStatusCache(path, text);
+        }
+        catch (e) {
+            setFailed(true);
+            setNote(`⚠ project status: cache non scrivibile (${e.message})`);
+            notifyDone('loom-deck · project status', `${name}: cache non scrivibile`);
+            return;
+        }
+        // Ri-letta da disco invece di comporre `{text, mtime: Date.now()}`: l'ora
+        // che l'indicatore mostra deve essere quella del file, o testata e viewer
+        // finirebbero a dire due orari diversi dello stesso recap.
+        setCache(readStatusCache(path));
+        setFailed(false);
+        setNote('✔ project status aggiornato · ^O per aprirlo');
+        notifyDone('loom-deck · project status', `${name}: recap pronto`);
+    }
+    function generate() {
+        if (startedAt !== null) {
+            setNote(`^G → generazione già in corso (${label})`);
+            return;
+        }
+        const sid = randomUUID();
+        setFailed(false);
+        setStartedAt(Date.now());
+        setNote(`⏳ project status di ${name}… (sid ${sid.slice(0, 8)})`);
+        const child = spawnProjectStatus(cwd, sid, finish);
+        child.on('error', () => {
+            setStartedAt(null);
+            setFailed(true);
+            setNote(`⚠ project status: '${CLAUDE_CMD}' non lanciabile`);
+        });
+    }
+    function open() {
+        if (!cache) {
+            // Un viewer vuoto direbbe «il recap è questo, ed è nulla»: la cache
+            // assente è uno stato del progetto, non un documento da mostrare.
+            setNote(startedAt !== null
+                ? '^O → nessun recap in cache · la prima generazione è in corso'
+                : '^O → nessun recap in cache · ^G per generarlo');
+            return;
+        }
+        setView({ text: cache.text, mtime: cache.mtime, stale: startedAt !== null });
+        setTop(0);
+        setNote('');
+        setMode('status');
+    }
+    function close() {
+        setMode('normal');
+        setView(null);
+    }
+    // Cornici da scalare: box esterno (2 bordi + 2 padding) + box testo (2 bordi
+    // + 2 padding) = 8, come il detail.
+    const width = Math.max(20, (columns || 80) - 8);
+    // Il markdown si rende PRIMA del wrap: `**foo**` occupa 3 colonne rese e 7
+    // grezze, quindi wrappare sui marker manderebbe a capo su un conteggio che il
+    // terminale non disegna.
+    const doc = useMemo(() => (view ? parseMarkdown(view.text) : null), [view]);
+    const lines = useMemo(() => (doc ? wrapWithOffsets(doc.text, width) : []), [doc, width]);
+    const capacity = statusCapacity(rows);
+    const maxTop = Math.max(0, lines.length - capacity);
+    function scroll(delta) {
+        setTop((t) => Math.max(0, Math.min(maxTop, t + delta)));
+    }
+    function onKey(input, key) {
+        if (key.escape) {
+            close();
+        }
+        else if (key.upArrow) {
+            scroll(-1);
+        }
+        else if (key.downArrow) {
+            scroll(1);
+        }
+        else if (key.pageUp) {
+            scroll(-capacity);
+        }
+        else if (key.pageDown) {
+            scroll(capacity);
+        }
+        else if (input === 'g') {
+            // `g`/`G` sugli estremi, come nel reader e nel detail: anche questa
+            // schermata scorre testo grezzo, quindi eredita lo stesso alfabeto invece
+            // di inventarne un secondo.
+            setTop(0);
+        }
+        else if (input === 'G') {
+            setTop(maxTop);
+        }
+    }
+    return {
+        label,
+        building: startedAt !== null,
+        failed,
+        view,
+        doc,
+        lines,
+        top,
+        capacity,
+        maxTop,
+        generate,
+        open,
+        onKey,
+    };
+}

package/dist/project-status.js

@@ -0,0 +1,71 @@
+// T121 — il recap di progetto come ARTEFATTO invece che come conversazione.
+//
+// La skill `loom-works:recap-status-project` produce un testo che oggi vive
+// solo dentro la sessione che l'ha chiesta: il deck la invoca in headless e ne
+// scrive il risultato su disco, così un deck riaperto lo ritrova invece di
+// ripartire da zero.
+//
+// Logica pura + accesso al file, zero React: gli stati dell'indicatore si
+// collaudano senza pseudo-terminale.
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fmtTime, WARN } from './glyphs.js';
+/**
+ * Cartella della cache, una per UTENTE.
+ *
+ * `/tmp` è condivisa e world-writable col solo sticky bit: un file a nome
+ * prevedibile lì dentro può essere preceduto da un symlink piazzato da un altro
+ * utente, e la scrittura lo seguirebbe. La cartella con `mode 0700` chiude il
+ * caso senza rinunciare a `/tmp` (D7), e l'uid è stabile quanto il path del
+ * progetto — la coordinata resta una funzione, non un registro.
+ */
+export function statusDir() {
+    return join(tmpdir(), `loom-deck-status-${process.getuid?.() ?? 0}`);
+}
+/**
+ * Coordinata del file di cache: derivata dal path del progetto con la stessa
+ * trasformazione del transcript store di Claude Code (non-alnum → `-`).
+ *
+ * L'env override esiste per i test e per la verifica a mano: senza, provare il
+ * viewer richiederebbe di spendere una generazione vera da minuti.
+ */
+export function statusFilePath(projectRoot) {
+    const env = process.env.LOOM_DECK_STATUS_FILE;
+    if (env)
+        return env;
+    return join(statusDir(), `${projectRoot.replace(/[^a-zA-Z0-9]/g, '-')}.md`);
+}
+/** File assente o illeggibile → nessuna cache. Mai un throw: `missing` non è
+ *  un errore, è lo stato di partenza di ogni progetto. */
+export function readStatusCache(path) {
+    try {
+        const text = readFileSync(path, 'utf8');
+        return { text, mtime: statSync(path).mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeStatusCache(path, text) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, text, { mode: 0o600 });
+}
+export const STATUS_MISSING = 'missing';
+/**
+ * Il campo fra parentesi della testata, nei suoi tre stati.
+ *
+ * Il marker di fallimento è un'AGGIUNTA e non un quarto stato (D5): un tentativo
+ * fallito non riscrive la cache, quindi il dato precedente resta vero e ancora
+ * apribile — sostituirlo con `failed` butterebbe via un'informazione che c'è.
+ * I due fatti (cosa c'è in cache, com'è andato l'ultimo tentativo) sono sempre
+ * entrambi veri nello stesso istante.
+ */
+export function statusLabel(s) {
+    const base = s.startedAt !== null
+        ? `building ${Math.max(0, Math.floor((s.now - s.startedAt) / 1000))}...`
+        : s.mtime !== null
+            ? fmtTime(s.mtime)
+            : STATUS_MISSING;
+    return s.failed ? `${base} ${WARN}` : base;
+}

package/dist/spawn.js

@@ -323,8 +323,17 @@ export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
 // un fallimento arriva come booleano nudo e la riga di stato può solo dire "non
 // ha funzionato" — che su un'operazione distruttiva non basta a sapere se
 // qualcosa è stato rimosso.
-function spawnSkill(prompt, cwd, sessionId, onResult) {
-    const child = spawnOut(CLAUDE_CMD, ['-p', '--output-format', 'stream-json', '--verbose', '--session-id', sessionId, prompt], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+function spawnSkill(prompt, cwd, sessionId, onResult, extraArgs = []) {
+    const child = spawnOut(CLAUDE_CMD, [
+        '-p',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--session-id',
+        sessionId,
+        ...extraArgs,
+        prompt,
+    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
     let buf = '';
     let isError = null;
     let detail = '';
@@ -399,6 +408,43 @@ export function spawnCleanTasks(ids, cwd, sessionId, ignored, onResult) {
         return null;
     return spawnSkill(cleanTasksPrompt(ids, ignored), cwd, sessionId, onResult);
 }
+// T121 — recap di progetto in headless. Qui il `detail` del result event NON è
+// un messaggio d'errore da troncare come per `create-task`/`clean-tasks`: è il
+// DELIVERABLE, cioè il testo intero della skill, e chi chiama lo scrive su
+// disco. Una skill read-only invocata in `-p` è una funzione che ritorna testo.
+//
+// `--permission-mode auto` e nessun token `yolo` (D4): le due cautele coprono
+// cause di stallo diverse e non sono intercambiabili. `yolo` toglie le domande
+// che la skill pone da sé, e `recap-status-project` non ne ha; il modo
+// permissivo toglie le richieste di permesso che il CLI pone su un tool, e
+// quelle in `-p` non hanno nessuno che risponda — il processo resterebbe appeso
+// senza emettere niente, cioè con l'indicatore che conta all'infinito.
+export function spawnProjectStatus(cwd, sessionId, onResult) {
+    return spawnSkill('/loom-works:recap-status-project', cwd, sessionId, onResult, [
+        '--permission-mode',
+        'auto',
+    ]);
+}
+// T121 — notifica desktop di fine generazione. La generazione dura minuti e chi
+// l'ha chiesta nel frattempo guarda altrove; la notifica di GNOME persiste nel
+// cassetto, quindi raggiunge anche chi torna dieci minuti dopo — cosa che un
+// suono non fa.
+//
+// Il listener su `error` è OBBLIGATORIO e non difensivo: un `error` non
+// agganciato su un `ChildProcess` diventa un'eccezione non catturata e abbatte
+// il deck, quindi senza di lui l'assenza di `notify-send` ucciderebbe la TUI.
+// Agganciato, la degradazione è MUTA (D6): un binario assente è una proprietà
+// stabile della macchina, e dirlo a ogni generazione sarebbe lo stesso messaggio
+// a ogni giro su una funzione che non è il deliverable.
+export function notifyDone(title, body) {
+    const child = spawnOut('notify-send', ['--app-name=loom-deck', title, body], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.on('error', () => { });
+    child.unref?.();
+    return child;
+}
 // T41 — Commit dell'edit. `git commit -- <paths>` committa lo stato working-tree
 // SOLO di quei path, ignorando l'index: se l'utente ha altro in stage (o altri
 // file sporchi) non finisce dentro per errore. NON detached: è un'operazione

package/dist/ui/status-screen.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// T121 — project status: l'indicatore di testata e il viewer fullscreen.
+//
+// I due stanno nello stesso file perché sono due rese dello STESSO dato — cosa
+// c'è in cache e come sta andando l'ultima generazione — e la testata compare
+// anche dentro il viewer.
+import { Box, Text } from 'ink';
+import { cutParts } from '../width.js';
+import { sanitize } from '../width.js';
+import { LIVE_BUSY } from '../glyphs.js';
+import { fmtTime } from '../glyphs.js';
+import { DetailLine } from './detail-screen.js';
+/** Nessuna occorrenza da evidenziare: il viewer non ha ricerca interna. Costanti
+ *  di modulo e non letterali inline — un array nuovo a ogni riga renderizzata
+ *  farebbe lavoro per niente su un recap di duecento righe. */
+const NO_OCC = [];
+/**
+ * L'indicatore: `<progetto> :: PROJECT STATUS [ <stato> ]`.
+ *
+ * Occupa la posizione SINISTRA della testata, quella che era di `loom-deck`
+ * (D1): il posto più visibile della cornice va a un dato che cambia, non a
+ * un'etichetta costante che chi guarda il deck sa già.
+ *
+ * Il taglio lo fa `cutParts` e non `wrap` di Ink (invariante ③ di `width.ts`),
+ * con `priority` sul blocco fra parentesi: su un terminale stretto a cadere è
+ * il nome del progetto — che chi guarda quel deck conosce — mai lo stato, che è
+ * l'unica cosa che la riga esiste per dire.
+ */
+export function StatusHeadline({ name, label, building, failed, cols, }) {
+    // `name` arriva dal file config, cioè da testo arbitrario: un glifo discorde
+    // allargherebbe la riga di una cella e manderebbe a capo la testata. Si
+    // sanifica QUI e non in `loadIdentity`, perché lo stesso valore serve intatto
+    // ai titoli delle tab, dove è la chiave di match di compass.
+    const shown = sanitize(name);
+    // Il glifo di conversazione viva sta DENTRO le parentesi, attaccato allo
+    // stato: qualifica quel campo, e il vocabolario è lo stesso della colonna
+    // liveness delle sessioni — una generazione in corso è una conversazione che
+    // sta lavorando, non un quinto simbolo da imparare.
+    const parts = [shown, ' :: PROJECT STATUS ', `[ ${building ? `${LIVE_BUSY} ` : ''}${label} ]`];
+    const shownParts = cutParts(parts, Math.max(4, cols), 2);
+    const color = building ? 'yellow' : failed ? 'yellow' : label === 'missing' ? 'gray' : 'green';
+    return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: shownParts[0] }), _jsx(Text, { dimColor: true, children: shownParts[1] }), _jsx(Text, { bold: building, color: color, children: shownParts[2] })] }));
+}
+/**
+ * Viewer fullscreen del recap: quinta schermata sostitutiva.
+ *
+ * Stessa forma del detail della task — markdown reso in span tipizzati, righe
+ * wrappate col proprio offset — meno l'area di compilazione: qui non c'è niente
+ * da lanciare, si legge e basta. Da cui `↑↓` liberi di scorrere il testo, che
+ * nel detail sono spesi sul fuoco fra i campi.
+ */
+export function StatusScreen({ name, label, building, failed, view, lines, spans, top, total, capacity, columns, }) {
+    const last = Math.min(total, top + capacity);
+    const width = Math.max(20, (columns || 80) - 4);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(StatusHeadline, { name: name, label: label, building: building, failed: failed, cols: width }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["generato alle ", _jsx(Text, { color: "cyan", children: fmtTime(view.mtime) }), " \u00B7 righe", ' ', total === 0 ? 0 : top + 1, "-", last, " di ", total, view.stale ? (_jsx(Text, { color: "yellow", children: " \u00B7 versione precedente, generazione in corso" })) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " chiude"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: NO_OCC, current: -1 }, top + i))) })] }));
+}

package/dist/viewport.js

@@ -69,6 +69,10 @@ export const MODAL_HEIGHT = {
     // entra in un box sopra i pane. La sua altezza la distribuisce
     // `detailCapacity`.
     detail: 0,
+    // T121 — il viewer del project status: quinta sostitutiva. Un recap di
+    // progetto è un documento lungo quanto un task file, quindi vale la stessa
+    // ragione delle altre quattro. La sua altezza la distribuisce `statusCapacity`.
+    status: 0,
 };
 /**
  * Distribuisce le righe disponibili fra lista task, lista sessioni e preview.
@@ -254,6 +258,20 @@ export function detailCapacity(rows, searching = false) {
     const extra = searching ? DETAIL_SEARCH_CHROME : 0;
     return Math.max(0, (rows || 24) - SLACK - DETAIL_CHROME - extra);
 }
+// T121 — cornice del viewer del project status. Gemella di READER_CHROME: il
+// viewer scorre testo e basta, senza l'area di compilazione che rende caro il
+// detail.
+//   2  bordi del box esterno
+//   1  riga di testata (progetto :: PROJECT STATUS)
+//   1  riga meta (ora della generazione · posizione nel testo)
+//   1  riga hint
+//   1  marginTop del box corpo
+//   2  bordi del box corpo
+const STATUS_CHROME = 8;
+/** Righe di recap che entrano nel terminale. */
+export function statusCapacity(rows) {
+    return Math.max(0, (rows || 24) - SLACK - STATUS_CHROME);
+}
 // T52 — cornice del pannello di anteprima sotto la lista occorrenze:
 // marginTop + 2 bordi + riga meta.
 const SEARCH_PREVIEW_CHROME = 4;

package/package.json

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