@lamemind/loom-deck 0.46.0 → 0.48.0

package/dist/cli.js

@@ -11,13 +11,13 @@ 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';
@@ -162,28 +162,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.
@@ -1276,7 +1291,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
@@ -1381,7 +1401,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(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] }));
 }
 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)

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/sheet.js

@@ -18,7 +18,8 @@ import { scanText, topForOffset } from '../text-search.js';
 import { parseMarkdown } from '../markdown.js';
 import { cpLen, insertAt, removeAt } from '../layout.js';
 import { sanitizeTyped } from '../glyphs.js';
-import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, } from '../spawn.js';
+import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, specializeRecap, } from '../spawn.js';
+import { taskIsEpic } from '../tasks.js';
 import { fieldsKey } from '../fields.js';
 import { loadPromptCatalog, promptFor } from '../prompt-catalog.js';
 // T117 — le quattro righe dell'area di compilazione del detail, nell'ordine in
@@ -50,6 +51,10 @@ export function useSheetOverlay(deps) {
     // T117 — il prompt iniziale, EDITABILE. Quello che si legge nel campo è quello
     // che parte: non un'anteprima di qualcos'altro.
     const [prompt, setPrompt] = useState('');
+    /** La task aperta è un cappello (`Size: Epic`)? Deciso UNA VOLTA all'apertura,
+     *  dal testo che il detail ha già in mano: rifarlo a ogni cambio di azione
+     *  riparserebbe l'intero task file per un campo dell'header. */
+    const [epic, setEpic] = useState(false);
     const [cursor, setCursor] = useState({ row: DROW.action, caret: 0 });
     // Il catalogo si legge una volta per vita del deck: è un file di quattro righe
     // accanto al codice, non un dato che cambia sotto i piedi.
@@ -105,12 +110,16 @@ export function useSheetOverlay(deps) {
     }, [findRes, occCur, lines, capacity]);
     /** Apre il detail su una task, azzerando scroll, area di compilazione e ricerca. */
     function open(next) {
+        // Calcolato qui e usato subito: `setEpic` non ha ancora aggiornato lo stato
+        // quando `setPrompt` gira, quindi il valore locale è l'unico leggibile ora.
+        const isEpic = taskIsEpic(next.id, next.text);
         setSheet(next);
         setTop(0);
         setAction(0);
+        setEpic(isEpic);
         setModel(MODEL_DEFAULT);
         setSpawnNote('');
-        setPrompt(promptFor(catalog, DETAIL_ACTIONS[0].kind, next.id));
+        setPrompt(promptFor(catalog, specializeRecap(DETAIL_ACTIONS[0].kind, isEpic), next.id));
         setCursor({ row: DROW.action, caret: 0 });
         setFind(null);
         setOccIdx(0);
@@ -129,7 +138,7 @@ export function useSheetOverlay(deps) {
         setAction(index);
         const id = sheet?.id;
         if (id)
-            setPrompt(promptFor(catalog, DETAIL_ACTIONS[index].kind, id));
+            setPrompt(promptFor(catalog, specializeRecap(DETAIL_ACTIONS[index].kind, epic), id));
     }
     // Il ponte fra le quattro righe e i quattro stati. Le righe restano
     // TIPIZZATE dove vivono (`ModelKind`, indice dell'azione) invece di finire in
@@ -234,13 +243,16 @@ export function useSheetOverlay(deps) {
         if (key.return) {
             // `⏎` esegue SEMPRE l'azione selezionata, da qualunque riga: i campi sono
             // di una riga sola, quindi nessuno di loro ha da farci un a-capo.
+            // Il kind viaggia specializzato quanto il prompt che lo accompagna: se il
+            // campo è stato svuotato a mano il testo non parte e resta lui a dire cosa
+            // ricevera' la sessione, quindi i due non possono divergere.
             const act = DETAIL_ACTIONS[action];
             const id = sheet?.id;
             const note = spawnNote.trim();
             const text = prompt.trim();
             close();
             if (id)
-                onAction(id, act.kind, model, note, text);
+                onAction(id, specializeRecap(act.kind, epic), model, note, text);
             return;
         }
         if (key.pageUp) {

package/dist/spawn.js

@@ -117,6 +117,27 @@ export function onInTabCommand(child, cb) {
         }
     });
 }
+/**
+ * `recap` → la sotto-skill giusta, quando chi spawna SA se la task è un cappello.
+ *
+ * `recap` resta il kind onesto per chi non lo sa: punta al dispatcher, che
+ * risolve la task e classifica da sé. È il caso degli acceleratori della lista,
+ * dove il deck ha in mano solo `tasks.md` — e lì il `Size` non c'è. Il DETAIL
+ * invece il task file l'ha già letto, quindi può saltare il giro e pagare un
+ * turno di modello in meno.
+ *
+ * Non è una classificazione duplicata: il criterio (`Size: Epic`) resta uno solo
+ * e sta in `taskIsEpic`, che legge lo stesso campo che leggerebbe il dispatcher.
+ * Quello che si evita è il RITARDO, non il giudizio.
+ *
+ * Ogni kind diverso da `recap` passa intatto: la specializzazione è un caso, non
+ * una trasformazione da applicare a tutti.
+ */
+export function specializeRecap(kind, epic) {
+    if (kind !== 'recap')
+        return kind;
+    return epic ? 'recap-epic' : 'recap-task';
+}
 // L'ordine È il giro di `tab` nel detail, non una preferenza di lettura:
 // cambiarlo sposta le voci sotto le dita di chi le ha imparate. Fino a T111 era
 // anche il binding delle cifre `1`-`4`, passate poi al campo nota.

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/tasks.js

@@ -153,6 +153,30 @@ export function parseTaskDetail(id, content) {
         description: sanitize(descLines.join('\n').trim()),
     };
 }
+/**
+ * La task è un cappello (epica)?
+ *
+ * Il marker è `Size: Epic`, e sta sul CAPPELLO perché la parentela la dichiara
+ * la figlia (`**Parent Task**`): un padre non sa di averne senza scandagliare
+ * tutti gli altri task file, cosa che il deck non può fare nel loop di poll.
+ *
+ * Legge dal testo INTEGRALE del task file, l'unico posto dove il `Size` esiste:
+ * in `tasks.md` quella colonna non c'è, quindi la lista non può rispondere e la
+ * domanda ha senso solo dove il file è già stato aperto (il detail).
+ *
+ * Riusa `parseTaskDetail` invece di una regex propria: la grammatica dei bullet
+ * header (`- **Campo**: valore`) è già scritta lì, e una seconda copia
+ * divergerebbe al primo campo che cambia forma. Confronto case-insensitive — il
+ * valore lo scrive un umano nel file, non uno script.
+ *
+ * Testo assente (`null`, task file non ancora letto) → `false`: la mancanza di
+ * prova non è prova di cappello, e degradare sul caso comune è l'esito benigno.
+ */
+export function taskIsEpic(id, text) {
+    if (!text)
+        return false;
+    return (parseTaskDetail(id, text).fields['Size'] ?? '').trim().toLowerCase() === 'epic';
+}
 /**
  * Testo INTEGRALE del task file (T66 · detail).
  *

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

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.46.0",
+  "version": "0.48.0",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {

package/scripts/deck-run

@@ -103,7 +103,7 @@ MODEL=""
 # Sotto --fork il --session-id torna AMMESSO (anzi: è il punto) — la mutua
 # esclusione con --resume esiste perché una ripresa nuda riscrive il transcript
 # dell'id ripreso, mentre il fork ne apre uno NUOVO, che possiamo quindi pinnare.
-# --prompt-kind <none|recap|preflight|run|checkpoint> (T56, T66): sceglie il prompt iniziale fra
+# --prompt-kind <none|recap|recap-task|recap-epic|preflight|run|checkpoint>: sceglie il prompt iniziale fra
 # quelli del catalogo qui sotto. Enum e non stringa libera: il prompt viaggia
 # dentro apici singoli in `bash -lc`, quindi il testo va tenuto in un posto solo
 # e verificato una volta, invece di spostare il rischio di quoting su ogni
@@ -164,7 +164,9 @@ USAGE="uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--sessio
 
   --prompt-kind  prompt iniziale della sessione bound (default: recap)
        none        nessun prompt — sessione aperta sulla task, a mani nude
-       recap       /loom-works:recap-status <TaskID>
+       recap       /loom-works:recap-status <TaskID>       (dispatcher)
+       recap-task  /loom-works:recap-status-task <TaskID>  (task non cappello)
+       recap-epic  /loom-works:recap-status-epic <TaskID>  (Size: Epic)
        preflight   /loom-works:preflight-task <TaskID>
        run         /loom-works:run-task <TaskID>
        checkpoint  /loom-works:checkpoint-task <TaskID>
@@ -203,8 +205,8 @@ fi
 # lì il valore arriva da un file editabile a mano, qui da un argomento nostro.
 if [[ -n "$PROMPT_KIND" ]]; then
   case "$PROMPT_KIND" in
-    none|recap|preflight|run|checkpoint) ;;
-    *) echo "--prompt-kind ignoto: '${PROMPT_KIND}' (usa none|recap|preflight|run|checkpoint)" >&2
+    none|recap|recap-task|recap-epic|preflight|run|checkpoint) ;;
+    *) echo "--prompt-kind ignoto: '${PROMPT_KIND}' (usa none|recap|recap-task|recap-epic|preflight|run|checkpoint)" >&2
        echo "$USAGE" >&2
        exit 2 ;;
   esac
@@ -427,6 +429,15 @@ FORK_FLAG=""
 #                ("recap stato task <id>"), scelto perché non esisteva una skill
 #                di recap tarata sulla singola task e quella di progetto avrebbe
 #                risposto largo — vincolo caduto col dispatcher.
+#   recap-task → la sotto-skill diretta, senza il giro del dispatcher
+#   recap-epic → idem per un cappello (`Size: Epic`)
+#                I due specializzati li sceglie chi SA già come è fatta la task:
+#                il detail del deck, che il task file l'ha aperto. Chi non lo sa
+#                — gli acceleratori della lista, che leggono solo `tasks.md`, e
+#                quindi non vedono il `Size` — resta su `recap` e lascia
+#                classificare al dispatcher. Il criterio non è duplicato: sta in
+#                `taskIsEpic` (src/tasks.ts) e legge lo stesso campo che leggerebbe
+#                il dispatcher; quello che cambia è solo QUANDO viene letto.
 #   preflight  → skill di preflight sulla task
 #   run        → skill di esecuzione sulla task
 #   checkpoint → skill di checkpoint sulla task

package/scripts/prompt-catalog

@@ -15,7 +15,14 @@
 # Vincolo sui template: nessun apice singolo. Il testo finisce dentro `'...'`
 # nel comando passato a `bash -lc`, e questo file è committato — un apice qui
 # sarebbe un errore di scrittura, non un input da quotare.
+# `recap` è il DISPATCHER: risolve la task, ne legge il Size e passa da sé alla
+# sotto-skill. Lo usa chi non sa se la task è un cappello — gli acceleratori
+# della lista, dove il deck ha in mano solo tasks.md, che il Size non ce l'ha.
+# Le due voci `recap-task`/`recap-epic` saltano quel giro: le sceglie il DETAIL,
+# che il task file l'ha già aperto e quindi il Size lo conosce.
 recap	/loom-works:recap-status {TASK}
+recap-task	/loom-works:recap-status-task {TASK}
+recap-epic	/loom-works:recap-status-epic {TASK}
 preflight	/loom-works:preflight-task {TASK}
 run	/loom-works:run-task {TASK}
 checkpoint	/loom-works:checkpoint-task {TASK}