@lamemind/loom-deck 0.47.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

@@ -11,17 +11,18 @@ import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch,
 import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, TASK_VIEWS, } from './pane-views.js';
 import { isCompact, layoutBudget, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { cut, cutMiddle, sanitize, termWidth } from './width.js';
-import { applyView, cycleSort, describeSort, idColumnWidth, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
+import { applyView, cycleSort, describeSort, priName, progName, taskColumns, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, writeTaskEdit, PRI_GLYPH, PRI_LABEL } from './task-edit.js';
 import { ALL, EDIT_FIELDS, EDIT_PRI, EDIT_PROG, editTextField, MAX_SESSIONS, MAX_SESSIONS_ALL, META_ROWS, QUIT_WINDOW_MS, ROW_ALL, ROW_SPOT, SORT_TASTI, SPOT, } from './model.js';
 import { purgeTargets, splitTargets } from './purge.js';
 import { conversationLabel, isDone } from './layout.js';
 import { fieldsKey } from './fields.js';
-import { TASK_EMPTY, relTime, sanitizeTyped, taskTail } from './glyphs.js';
+import { TASK_EMPTY, relTime, sanitizeTyped } from './glyphs.js';
 import { commitTaskEdit, runLaunch, spawnClaudeEmpty, spawnCleanTasks, spawnCreateTask, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, onInTabCommand, CLAUDE_CMD, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
 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
@@ -162,28 +164,43 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // alla vista che sceglie l'header (D2 create).
     const parentLabel = isAll ? 'tutte' : isSpot ? 'spot' : selectedTaskId ?? '—';
     // Conteggio figli per task + spot (badge nel Tasks pane).
+    //
+    // T124 — il rollup delle VIVE si deriva nello stesso ciclo, non da un secondo
+    // passaggio sul registry dei processi: quel registry conosce una conversazione
+    // PRIMA che abbia scritto il suo primo record di transcript, quindi due
+    // derivazioni indipendenti renderebbero producibile `1/0` — una viva senza
+    // totale — che non è un caso limite teorico ma la finestra normale fra lo
+    // spawn e il primo turno. Intersecando qui, `vive ≤ totali` è garantito per
+    // costruzione: la conversazione appena nata resta invisibile a entrambi i
+    // numeri finché non scrive, e il segnale arriva in ritardo di un turno invece
+    // che sbagliato.
     const childCount = new Map();
+    const taskLive = new Map();
     let spotCount = 0;
     for (const s of sessions) {
         const bound = bindings.get(s.sessionId);
-        if (bound)
-            childCount.set(bound, (childCount.get(bound) ?? 0) + 1);
-        else
+        if (!bound) {
             spotCount++;
+            continue;
+        }
+        childCount.set(bound, (childCount.get(bound) ?? 0) + 1);
+        const entry = live.get(s.sessionId);
+        if (!entry)
+            continue;
+        const prev = taskLive.get(bound);
+        // Rollup a stato misto: vince `busy`. Fra N vive, quella che sta lavorando è
+        // la ragione per cui si guarda la riga.
+        taskLive.set(bound, {
+            count: (prev?.count ?? 0) + 1,
+            status: prev?.status === 'busy' || entry.status === 'busy' ? 'busy' : 'idle',
+        });
     }
+    const taskRowData = { childCount, live: taskLive, dirty: dirtyFolders };
     // T118 — colonne fisse della lista task, misurate su `paneTasks` (la vista
     // attiva INTERA) e non sulla finestra visibile: gemelle di `sessionCols` e
     // per la stessa ragione, che una larghezza derivata dallo schermo si muove a
-    // ogni scroll. La coda porta dentro il proprio gutter, così l'allineamento a
-    // destra lo produce `pad` da sé; nessuna riga con qualcosa da scrivere →
-    // colonna spenta a `0`, e le descrizioni si riprendono lo spazio.
-    const taskCols = (() => {
-        let tail = 0;
-        for (const t of paneTasks) {
-            tail = Math.max(tail, termWidth(taskTail(childCount.get(t.id) ?? 0, dirtyFolders.has(t.id))));
-        }
-        return { id: idColumnWidth(paneTasks), tail: tail > 0 ? tail + 1 : 0 };
-    })();
+    // ogni scroll.
+    const taskCols = taskColumns(paneTasks, taskRowData);
     // Figli della selezione: tutte le conversazioni del progetto (`≡ tutte`), le
     // sessioni bound alla task selezionata, oppure (spot) quelle senza binding.
     // sessions è già ts desc → l'ordine si eredita in tutti e tre i rami.
@@ -742,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');
@@ -914,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,
@@ -965,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) {
@@ -1251,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',
@@ -1276,7 +1324,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // stale non resta nulla: il titolo si accontenta dell'hash.
         const label = (assign.sid ? sessionNotes.get(assign.sid) : '') ||
             (s ? conversationLabel(s, projectCore, assign.sid ? bindings.get(assign.sid) : undefined) : '');
-        return (_jsx(AssignScreen, { sessionId: assign.sid ?? '', label: label, current: assign.sid ? bindings.get(assign.sid) ?? null : null, filter: assign.filter, rows: assign.list.slice(win.start, win.end), selected: assign.sel, matched: assign.list.length - 1, hidden: hiddenTasks, above: win.start, below: assign.list.length - win.end, childCount: childCount, columns: columns, note: note }));
+        // T124 — le colonne si misurano sulla lista FILTRATA di questa schermata,
+        // non su `paneTasks`: la popolazione è un'altra, e riusare le larghezze del
+        // pane darebbe una colonna dimensionata su righe che qui non ci sono.
+        // `assign.list` porta in testa la riga `detach` (`null`), che non è una task.
+        const assignCols = taskColumns(assign.list.filter((t) => t !== null), taskRowData);
+        return (_jsx(AssignScreen, { sessionId: assign.sid ?? '', label: label, current: assign.sid ? bindings.get(assign.sid) ?? null : null, filter: assign.filter, rows: assign.list.slice(win.start, win.end), selected: assign.sel, matched: assign.list.length - 1, hidden: hiddenTasks, above: win.start, below: assign.list.length - win.end, idW: assignCols.id, tailW: assignCols.tail, data: taskRowData, columns: columns, note: note }));
     }
     // ── T66 · detail della task ─────────────────────────────────────────────
     // Quarta schermata sostitutiva, stessa ragione delle altre tre: un task file
@@ -1292,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
@@ -1381,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, childCount: childCount, idW: taskCols.id, tailW: taskCols.tail, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns, dirty: dirtyFolders }), _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

@@ -64,6 +64,14 @@ export function modelShort(id) {
 // Sulla riga CHIUSA c'è uno spazio e non un terzo glifo: le chiuse sono la
 // maggioranza di ogni lista, e marcarle vorrebbe dire disegnare N volte «niente
 // da dire» — la colonna diventerebbe rumore invece di un segnale.
+//
+// T124 — non sono più il vocabolario di una superficie sola: la riga del pane
+// task adotta la stessa coppia, nella stessa forma (glifo attaccato all'id che
+// qualifica, colore e grassetto sull'id) e con lo stesso significato. L'unica
+// differenza ammessa è la POPOLAZIONE su cui il glifo si pronuncia — una
+// conversazione di là, le N conversazioni di una task di qua, con un rollup che
+// fa vincere `busy`. Riusarli con un significato spostato sarebbe un falso
+// amico, peggio di un glifo nuovo.
 export const LIVE_IDLE = '●';
 export const LIVE_BUSY = '◍';
 export const LIVE_NONE = ' ';
@@ -89,13 +97,33 @@ export function displayProg(prog) {
  * a disegnarla (sulla finestra, in `panes.tsx`). Due formattazioni gemelle
  * divergerebbero alla prima modifica, e la colonna risulterebbe larga quanto
  * una stringa che nessuno scrive.
+ *
+ * T124 — il contatore spezza vive e totali (`(1/5`) invece di sommarle: un
+ * numero solo cresce e non torna più indietro, quindi dice quanta storia ha la
+ * task e non se lì sta succedendo qualcosa adesso. A zero vive resta il solo
+ * totale (`(5`): scrivere `(0/5` metterebbe uno zero su quasi tutte le righe di
+ * ogni lista, e il segnale sparirebbe nel rumore.
+ *
+ * La parentesi di CHIUSURA cade sempre. La colonna è ancorata a destra, quindi
+ * la `)` costerebbe una cella per spostare verso l'interno l'unica cosa che si
+ * legge davvero; il bordo del pane chiude già il gruppo. Quella di apertura
+ * serve invece a staccare il contatore dalla descrizione a lunghezza libera che
+ * gli sta a sinistra — l'asimmetria è voluta.
  */
-export function taskTail(childCount, dirty) {
-    const count = childCount > 0 ? `(${childCount})` : '';
+export function taskTail(live, total, dirty) {
+    const count = total > 0 ? (live > 0 ? `(${live}/${total}` : `(${total}`) : '';
     if (!dirty)
         return count;
     return count ? `${WARN} ${count}` : WARN;
 }
+/** T124 — contatore di una riga META del pane task (`≡ tutte`, `○ spot`), che
+ *  non è una colonna ancorata a niente. Prende comunque la grafia senza chiusa:
+ *  due forme dello stesso oggetto a due righe di distanza si leggono come un
+ *  errore, mentre una forma sola applicata anche dove la sua ragione non serve
+ *  si legge come una convenzione. */
+export function metaCount(n) {
+    return n > 0 ? ` (${n}` : '';
+}
 // T49 — size umana compatta per il detail pane sessione.
 export function fmtSize(bytes) {
     if (bytes < 1024)
@@ -111,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/model.js

@@ -56,10 +56,14 @@ export const KIND_LABEL = { ai: 'IA', tool: 'tools', human: 'human' };
 // T41 — ordine dei valori nel modale edit. Deliberatamente DIVERSO da
 // PRI_ENTRIES/PROG_ENTRIES (che seguono il rango di sort): qui si sceglie un
 // valore, non si ordina, quindi vince l'ordine del CICLO DI VITA — da fare →
-// in corso → chiusa → bloccata. La priorità resta alta→bassa, che è già
-// l'ordine naturale di lettura.
+// preflight fatto → in corso → chiusa → bloccata. La priorità resta alta→bassa,
+// che è già l'ordine naturale di lettura.
+//
+// L'elenco deve coprire OGNI valore di ProgName: il cursore del modale nasce da
+// `Math.max(0, EDIT_PROG.indexOf(prog))` (cli.tsx), quindi un valore assente
+// torna -1, viene schiacciato a 0 e salvare retrocede la task alla prima voce.
 export const EDIT_PRI = ['high', 'med', 'low'];
-export const EDIT_PROG = ['todo', 'wip', 'done', 'locked'];
+export const EDIT_PROG = ['todo', 'ready', 'wip', 'done', 'locked'];
 // T117 — le righe del modale edit come DATO, nella forma che `fields.ts`
 // consuma: 0 priorità · 1 stato · 2 progresso libero · 3 titolo. Il modale non
 // dà lettere di selezione alle due righe a scelta, dove i valori sono glifi e

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/task-edit.js

@@ -14,6 +14,7 @@ export const PRI_GLYPH = { high: '🔥', med: '⚡', low: '🔹' };
 // lunga resta riconosciuto da priName/progName/isDone.
 export const PROG_GLYPH = {
     todo: '🔵',
+    ready: '🟢',
     wip: '🟡',
     done: '✔️',
     locked: '🔒',
@@ -23,6 +24,7 @@ export const PROG_GLYPH = {
 // `🔵 Todo`, `✔️ Done at 2026-07-20`) → il glifo è il prefisso, il resto è prosa.
 const PROG_DEFAULT = {
     todo: 'Todo',
+    ready: 'Ready',
     wip: 'In Progress',
     done: 'Done',
     locked: 'Locked',

package/dist/ui/assign-screen.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Schermata di assegnazione conversazione → task (T57).
 import { Box, Text } from 'ink';
-import { cut, sanitize, termWidth } from '../width.js';
-import { assignTextWidth, isDone } from '../layout.js';
-import { CARET, CARET_OFF, displayProg } from '../glyphs.js';
+import { cut, sanitize } from '../width.js';
+import { assignTextWidth } from '../layout.js';
+import { CARET, CARET_OFF } from '../glyphs.js';
+import { TaskRow } from './task-row.js';
 /**
  * Schermata di assegnazione di una conversazione a una task (T57).
  *
@@ -16,7 +17,7 @@ import { CARET, CARET_OFF, displayProg } from '../glyphs.js';
  * filtro può nascondere proprio il bersaglio, e quel prezzo non deve essere
  * silenzioso — stessa convenzione del `+N più vecchie` del pane sessioni.
  */
-export function AssignScreen({ sessionId, label, current, filter, rows, selected, matched, hidden, above, below, childCount, columns, note, }) {
+export function AssignScreen({ sessionId, label, current, filter, rows, selected, matched, hidden, above, below, idW, tailW, data, columns, note, }) {
     const width = assignTextWidth(columns);
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["assegna ", _jsx(Text, { color: "cyan", children: sessionId.slice(0, 8) }), label ? ` «${cut(sanitize(label), Math.max(10, Math.floor(width / 4)))}»` : '', " \u00B7 ora", ' ', current ? _jsx(Text, { color: "green", children: current }) : 'spot', " \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), ' ', "assegna \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " pulisci \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }), _jsx(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "filtro " }), _jsx(Text, { color: "yellow", children: cut(filter, Math.max(8, width - 24)) }), _jsx(Text, { inverse: true, children: " " }), !filter ? _jsx(Text, { dimColor: true, children: "  (id o titolo)" }) : null] }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [matched, " task", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", hidden, " fuori dai filtri"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }), rows.map((task) => {
                         // T57/D2 — `detach` è una VOCE della lista, non un tasto a parte: un
@@ -30,11 +31,11 @@ export function AssignScreen({ sessionId, label, current, filter, rows, selected
                             // il nome dell'azione invece di un moncone di frase.
                             return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, "\u25CB detach  ", cut('la sessione torna spot', width - 12)] }, "detach"));
                         }
-                        const sel = selected === task.id;
-                        const n = childCount.get(task.id) ?? 0;
-                        const head = `${CARET_OFF}${task.id}  ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
-                        const tail = n > 0 ? ` (${n})` : '';
-                        const desc = cut(task.desc, Math.max(4, width - termWidth(head) - termWidth(tail)));
-                        return (_jsxs(Text, { inverse: sel, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
+                        // T124 — la riga è la STESSA del pane task, non più una copia
+                        // ricomposta qui: id paddato alla colonna, coda ancorata al bordo
+                        // destro, marker dirty ed evidenze della liveness arrivano tutti dal
+                        // componente condiviso. `focused` è sempre vero — una schermata
+                        // sostitutiva non cede il fuoco a nessun altro pane.
+                        return (_jsx(TaskRow, { task: task, sel: selected === task.id, focused: true, width: width, idW: idW, tailW: tailW, data: data }, task.id));
                     })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }

package/dist/ui/panes.js

@@ -4,12 +4,13 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // larghezze già calcolate, non li derivano.
 import { Box, Text } from 'ink';
 import { cut, cutParts, pad, sanitize, termWidth } from '../width.js';
-import { isDone, paneTextWidth } from '../layout.js';
-import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, displayProg, modelShort, relTime, taskTail, } from '../glyphs.js';
+import { paneTextWidth } from '../layout.js';
+import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
+import { TaskRow } from './task-row.js';
 import { META_ROWS, ROW_ALL, ROW_SPOT } from '../model.js';
 import { rowLabel, sessionTitle } from '../session-list.js';
 import { sessionView, taskView, SESSION_VIEWS, TASK_VIEWS, } from '../pane-views.js';
-import { describeSort, padId, PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
+import { describeSort, PRI_ENTRIES, PROG_ENTRIES, } from '../view.js';
 /**
  * Header del pane task, tagliato QUI e non da Ink — stesso motivo del gemello
  * `SessionsHeader`, con una differenza di rischio: qui i segmenti sono tutti
@@ -49,7 +50,7 @@ export function TasksHeader({ counts, active, above, below, focused, columns, })
     const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns), segments.findIndex((s) => s.active));
     return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
 }
-export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, idW, tailW, focused, loadError, windowStart, above, below, columns, dirty, }) {
+export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, idW, tailW, focused, loadError, windowStart, above, below, columns, data, }) {
     const allSelected = selected === ROW_ALL;
     const spotSelected = selected === ROW_SPOT;
     return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(TasksHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
@@ -61,42 +62,16 @@ export function TasksPane({ tasks, counts, activeView, paneCount, view, selected
                             ]
                                 .map((e) => `−${e.glyph}`)
                                 .join(' ')
-                        : '')), paneTextWidth(columns)) }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", allCount > 0 ? ` (${allCount})` : ''] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : paneCount === 0 ? (
+                        : '')), paneTextWidth(columns)) }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", metaCount(allCount)] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", metaCount(spotCount)] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : paneCount === 0 ? (
             // T100/D1 — una voce a contatore 0 resta navigabile, e selezionarla dà
             // una lista vuota che DICE perché è vuota. Senza la nota il pane si
             // legge come rotto: le righe meta restano, le task no, e niente spiega
             // che è la vista scelta a non contenere nulla.
-            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(taskView(activeView).empty, paneTextWidth(columns)) })) : (tasks.map((task, i) => {
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(taskView(activeView).empty, paneTextWidth(columns)) })) : (tasks.map((task, i) => (_jsx(TaskRow, { task: task, 
                 // windowStart riporta l'indice di finestra a quello della lista
                 // completa, su cui è keyata la selezione. +META_ROWS: le prime due
                 // righe sono le meta.
-                const sel = windowStart + i + META_ROWS === selected;
-                const tail = taskTail(childCount.get(task.id) ?? 0, dirty.has(task.id));
-                // T118 — l'id è paddato a `idW`, quindi `head` ha la stessa larghezza
-                // su ogni riga e Pri/Prog cadono sempre nella stessa colonna.
-                const id = padId(task.id, idW);
-                // Invariante ③: la descrizione è l'unico pezzo a lunghezza libera, e
-                // si taglia QUI sul budget che resta dopo le colonne fisse. Lasciarlo
-                // fare a `truncate-end` significa passare da `cli-truncate`, che
-                // restituisce una riga più larga del pane (una colonna per emoji) e
-                // quindi scrive sopra il bordo. Le parti fisse si misurano con
-                // `termWidth`: i due glifi Pri/Prog valgono 2 ciascuno.
-                const head = `${CARET_OFF}${id}  ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
-                // T118 — la colonna della coda si riserva PRIMA di tagliare la
-                // descrizione, e per la stessa larghezza su ogni riga: appesa dopo,
-                // entrava nel budget solo dove c'era qualcosa da scrivere, e la
-                // descrizione si tagliava a una colonna diversa riga per riga.
-                //
-                // Pavimento `0` su tutte e tre le misure e non un minimo di cortesia:
-                // il budget è un TETTO. Un pavimento sopra lo spazio reale fa uscire
-                // la riga dal pane e le mangia il bordo. `reserve` si clampa su ciò
-                // che avanza, così `head + desc + coda` sta sempre dentro il pane.
-                const avail = Math.max(0, paneTextWidth(columns) - termWidth(head));
-                const reserve = Math.min(tailW, avail);
-                const descW = avail - reserve;
-                const desc = cut(task.desc, descW);
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, ' '.repeat(Math.max(0, descW - termWidth(desc))), pad(tail, reserve, 'right')] }, task.id));
-            }))] }));
+                sel: windowStart + i + META_ROWS === selected, focused: focused, width: paneTextWidth(columns), idW: idW, tailW: tailW, data: data }, task.id))))] }));
 }
 /**
  * Header del pane sessioni, tagliato QUI e non da Ink.

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/ui/task-row.js

@@ -0,0 +1,58 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+// La riga di lista di UNA task, condivisa fra il pane task e la schermata di
+// assegnazione (T124).
+//
+// Prima viveva solo nel pane, e la schermata di assegnazione ne teneva una copia
+// ricomposta a mano: id non paddato alla colonna, coda non ancorata al bordo,
+// marker dirty assente, contatore scritto in proprio. Nessuna di quelle
+// differenze produceva un errore — la schermata rendeva righe valide, solo
+// diverse — quindi nessun test le vedeva e ogni evoluzione della lista si
+// fermava al suo confine. Un componente solo è ciò che toglie il gemello.
+//
+// Le due sedi differiscono per tre cose sole, tutte parametri: la larghezza
+// utile, il concetto di fuoco (la schermata di assegnazione è sempre a fuoco) e
+// la finestra di righe che il chiamante ha già ritagliato.
+import { Text } from 'ink';
+import { cut, pad, sanitize, termWidth } from '../width.js';
+import { isDone } from '../layout.js';
+import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, displayProg, taskTail, } from '../glyphs.js';
+import { padId } from '../view.js';
+export function TaskRow({ task, sel, focused, width, idW, tailW, data, }) {
+    // T124 — il predicato è UNO e si valuta qui una volta sola: da lui dipendono
+    // tutte e tre le evidenze (id in grassetto+colore, glifo, numeratore in coda).
+    // Tre condizioni scritte in tre siti divergono alla prima modifica, e la riga
+    // finirebbe per dire due cose diverse su sé stessa.
+    const live = data.live.get(task.id) ?? null;
+    // Stessa resa dell'hash conversazione del pane sessioni, perché è lo stesso
+    // stato: `◍` giallo di là e `◍` nero di qua sarebbero due grafie di una cosa
+    // sola.
+    const color = live ? (live.status === 'busy' ? 'yellow' : 'green') : undefined;
+    // Attaccato all'id, non staccato: il glifo qualifica QUELL'id, e uno spazio in
+    // mezzo lo farebbe leggere come una colonna a sé. Consuma il primo dei due
+    // spazi verso Pri, quindi la riga non si allarga di una cella quando si
+    // accende — `LIVE_NONE` è uno spazio, e tutti e tre sono larghi 1.
+    const glyph = live ? (live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE) : LIVE_NONE;
+    const tail = taskTail(live?.count ?? 0, data.childCount.get(task.id) ?? 0, data.dirty.has(task.id));
+    const id = padId(task.id, idW);
+    // Invariante ③: la descrizione è l'unico pezzo a lunghezza libera, e si taglia
+    // QUI sul budget che resta dopo le colonne fisse. Lasciarlo fare a
+    // `truncate-end` significa passare da `cli-truncate`, che restituisce una riga
+    // più larga del pane (una colonna per emoji) e quindi scrive sopra il bordo.
+    // Le parti fisse si misurano con `termWidth`: i due glifi Pri/Prog valgono 2
+    // ciascuno.
+    const head = `${CARET_OFF}${id}${glyph} ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
+    // T118 — la colonna della coda si riserva PRIMA di tagliare la descrizione, e
+    // per la stessa larghezza su ogni riga: appesa dopo, entrava nel budget solo
+    // dove c'era qualcosa da scrivere, e la descrizione si tagliava a una colonna
+    // diversa riga per riga.
+    //
+    // Pavimento `0` su tutte e tre le misure e non un minimo di cortesia: il
+    // budget è un TETTO. Un pavimento sopra lo spazio reale fa uscire la riga dal
+    // pane e le mangia il bordo. `reserve` si clampa su ciò che avanza, così
+    // `head + desc + coda` sta sempre dentro la sede.
+    const avail = Math.max(0, width - termWidth(head));
+    const reserve = Math.min(tailW, avail);
+    const descW = avail - reserve;
+    const desc = cut(task.desc, descW);
+    return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsxs(Text, { bold: Boolean(live), color: color, children: [id, glyph] }), ` ${sanitize(task.pri)}  ${displayProg(task.prog)}  ${desc}`, ' '.repeat(Math.max(0, descW - termWidth(desc))), pad(tail, reserve, 'right')] }));
+}

package/dist/view.js

@@ -1,5 +1,7 @@
 // T39 — Core della vista: ordinali, sort chain multi-chiave, filtri.
 // Modulo PURO: nessun import da ink/react, nessun I/O → testabile senza terminale.
+import { taskTail } from './glyphs.js';
+import { termWidth } from './width.js';
 // D2 (preflight T39): sort opinato, filtri off. La lista parte ordinata ma
 // completa — nessuna task sparisce senza che l'utente abbia toccato una leva.
 export const DEFAULT_VIEW = {
@@ -19,10 +21,15 @@ const PRI_TABLE = [
     { name: 'low', glyph: '🔹', rank: 1 },
 ];
 // Ordine per "attivabilità" (desc = prima ciò su cui puoi agire): in corso →
-// da fare → bloccata → chiusa. Non è l'ordine del ciclo di vita: il deck serve
-// a scegliere su cosa lavorare, quindi le Done stanno in fondo sotto `desc`.
+// preflight fatto → da fare → bloccata → chiusa. Non è l'ordine del ciclo di
+// vita: il deck serve a scegliere su cosa lavorare, quindi le Done stanno in
+// fondo sotto `desc`. `ready` sta sopra `todo` perché il design è già congelato
+// (run-task parte senza Q&A), e sotto `wip` perché il lavoro già aperto viene
+// prima. Il rango governa anche l'ordine delle colonne della barra SHIFT+F,
+// derivata da PROG_ENTRIES.
 const PROG_TABLE = [
-    { name: 'wip', glyph: '🟡', rank: 4 },
+    { name: 'wip', glyph: '🟡', rank: 5 },
+    { name: 'ready', glyph: '🟢', rank: 4 },
     { name: 'todo', glyph: '🔵', rank: 3 },
     { name: 'locked', glyph: '🔒', rank: 2 },
     { name: 'done', glyph: '✔', rank: 1 },
@@ -90,6 +97,25 @@ export function padId(id, cols) {
         return id.padEnd(cols);
     return m[1] + ' '.repeat(Math.max(0, cols - id.length)) + m[2];
 }
+/**
+ * T118/T124 — le due colonne fisse della lista task, misurate sulla popolazione
+ * COMPLETA della vista e non sulla finestra visibile.
+ *
+ * `tail` porta dentro il proprio gutter (`+1`), così l'allineamento a destra lo
+ * produce `pad` da sé; nessuna riga con qualcosa da scrivere → `0`, colonna
+ * spenta, e le descrizioni si riprendono lo spazio.
+ *
+ * La stringa misurata qui è la STESSA che il render disegna (`taskTail`): due
+ * formattazioni gemelle divergerebbero alla prima modifica, e la colonna
+ * risulterebbe larga quanto una stringa che nessuno scrive.
+ */
+export function taskColumns(tasks, data) {
+    let tail = 0;
+    for (const t of tasks) {
+        tail = Math.max(tail, termWidth(taskTail(data.live.get(t.id)?.count ?? 0, data.childCount.get(t.id) ?? 0, data.dirty.has(t.id))));
+    }
+    return { id: idColumnWidth(tasks), tail: tail > 0 ? tail + 1 : 0 };
+}
 function rankOf(task, key) {
     if (key === 'pri')
         return priRank(task.pri);

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.47.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": {