@lamemind/loom-deck 0.27.3 → 0.29.0

package/README.md

@@ -10,9 +10,10 @@ già bound alla task via `LOOM_TASK`.
 ↑↓ scegli la task  →  ⏎  →  tab CC di fianco  →  LOOM_TASK bound
 ```
 
-Il tasto premuto sceglie **con quale prompt** si entra: `⏎` a mani nude, `^K`
-recap, `^P` preflight, `^R` esecuzione (vedi [I quattro modi di entrare in una
-task](#i-quattro-modi-di-entrare-in-una-task)).
+`⏎` apre il **detail** della task — task file scrollabile più una barra azioni —
+e da lì si sceglie con quale prompt entrare; `^K`/`^P`/`^R` restano acceleratori
+per chi lo sa già (vedi [I cinque modi di entrare in una
+task](#i-cinque-modi-di-entrare-in-una-task)).
 
 Entrambi i prefissi del contratto loom entrano in lista: **`T`** (code task) e
 **`D`** (doc task). Il trattamento è identico ovunque tranne che su `^R`, dove il
@@ -37,7 +38,7 @@ Ptyxis. Chiudere il deck non uccide le sessioni. La tab nasce nella window *atti
 
 ## Stato
 
-Bootstrap + spike ① + **TUI ③** funzionante (legge `tasks.md`, `⏎` spawna). Roadmap:
+Bootstrap + spike ① + **TUI ③** funzionante (legge `tasks.md`, `⏎` apre il detail). Roadmap:
 
 ```
 ① spike spawn-tab + LOOM_TASK   ✅ scripts/deck-run
@@ -56,7 +57,7 @@ senza collisioni:
 |---|---|---|
 | `↑` `↓` | naviga nella lista | |
 | `←` `→` `tab` | cambia pane | |
-| `⏎` | azione primaria del pane | Tasks → spawna la task selezionata (senza prompt) · Sessions → riprende (`claude --resume`) la sessione selezionata |
+| `⏎` | 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 |
@@ -79,6 +80,7 @@ Assegnazioni correnti:
 | modale | `S` | sort chain |
 | modale | `F` | filtri |
 | modale | `^F` | **ricerca full-text** nelle conversazioni del progetto |
+| modale | `⏎` | **detail** della task selezionata: task file scrollabile + barra azioni |
 | 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** |
@@ -91,7 +93,7 @@ Assegnazioni correnti:
 Il footer è **due righe con due nature diverse**:
 
 ```
-⏎/^K/^P/^R spawn · ^F cerca · C nuova · E edit · S sort · F filtri · w salva
+⏎ detail · ^K/^P/^R spawn · ^F cerca · C nuova · E edit · S sort · F filtri · w salva
 t 💻 · c 🤖 · 1 📝 codium · 2 ☕ idea
 ```
 
@@ -123,28 +125,50 @@ finestra Ptyxis, senza passare da un modale. `c` (minuscola, azione) e `C`
 (maiuscola, modale create-task) restano distinte per la regola sopra — così come
 `f` (fork) e `F` (filtri).
 
-### I quattro modi di entrare in una task
+### I cinque modi di entrare in una task
 
-Sulla task selezionata (focus sul pane Tasks) quattro tasti aprono una sessione
-**bound**: `LOOM_TASK` iniettata, `sessionId` pinnato, binding scritto nel
-sidecar. Fra loro cambia **solo il prompt iniziale**.
+Sulla task selezionata (focus sul pane Tasks) si apre una sessione **bound**:
+`LOOM_TASK` iniettata, `sessionId` pinnato, binding scritto nel sidecar. Fra i
+modi cambia **solo il prompt iniziale**.
 
-| Tasto | Prompt |
-|---|---|
-| `⏎` | nessuno — il contesto lo carica l'hook `SessionStart`, il primo messaggio lo scrivi tu |
-| `^K` | `recap stato task <id>` — prompt diretto, nessuna skill |
-| `^P` | `/loom-works:preflight-task <id>` |
-| `^R` | `/loom-works:run-task <id>`, oppure `/loom-works:run-doc <id>` se l'id è una `D` |
+| Azione (detail) | Tasto diretto | Prompt |
+|---|---|---|
+| `open` | — | nessuno — il contesto lo carica l'hook `SessionStart`, il primo messaggio lo scrivi tu |
+| `status` | `^K` | `recap stato task <id>` — prompt diretto, nessuna skill |
+| `preflight` | `^P` | `/loom-works:preflight-task <id>` |
+| `run` | `^R` | `/loom-works:run-task <id>`, oppure `/loom-works:run-doc <id>` se l'id è una `D` |
+| `checkpoint` | — | `/loom-works:checkpoint-task <id>` |
 
 Il prompt iniziale è la scelta di **chi apre**, non una proprietà della task: lo
 stesso task file si apre per leggerne lo stato, per congelarne le decisioni, per
-eseguirlo o per entrarci a mani nude — e il tasto premuto *è* quell'intento.
-Prima esisteva il solo `⏎` col recap, quindi ogni altro ingresso passava per una
-sessione da correggere a mano.
+eseguirlo o per entrarci a mani nude — e l'azione scelta *è* quell'intento.
+
+Le due superfici sono complementari, non alternative. `⏎` apre il **detail** e lì
+si legge la Description *mentre* si decide: è il caso normale, perché la domanda
+«quale azione?» quasi sempre si risponde leggendo la task. I tre `CTRL` saltano
+il passaggio per chi lo sa già. Dentro il detail sono inerti — i bottoni sono lì.
+
+Col focus sul pane Sessions né `⏎` né i `CTRL` spawnano: l'oggetto dell'azione è
+la task selezionata, e senza quel pane a fuoco non ce n'è una (il deck lo dice
+nella riga di nota, invece di aprire qualcosa a caso).
+
+### `⏎` — il detail della task
+
+Overlay fullscreen a due zone: il **task file per intero**, scrollabile
+(`↑↓` riga, `PgUp`/`PgDn` pagina, `g`/`G` estremi), e una riga di **bottoni**
+navigabile con `←→`, con `open` a fuoco all'apertura. `⏎` esegue l'azione
+selezionata e chiude; `esc` chiude lasciando la lista con la stessa selezione.
+
+Le azioni non sono un catalogo nuovo: chiamano lo **stesso** percorso di spawn
+dei tasti diretti. Una superficie in più, zero percorsi di spawn in più.
+
+Sono bottoni affiancati e non voci di un menu verticale perché è la forma che
+sopravvive all'arrivo del mouse: un rettangolo ha già coordinate e area
+cliccabile, una lista di voci andrebbe rifatta.
 
-Col focus sul pane Sessions i tre `CTRL` non spawnano: l'oggetto dell'azione è la
-task selezionata, e senza quel pane a fuoco non ce n'è una (il deck lo dice nella
-riga di nota, invece di aprire qualcosa a caso).
+Dentro il detail `←→` non cambia più pane — il ramo `useInput` della modalità
+chiude prima di arrivare a quello di default. Ink non ha focus-trap: la cattura
+**è** l'ordine dei rami.
 
 Il catalogo dei prompt vive in `scripts/deck-run`, non nella TUI: è il primitive
 UI-agnostico, il deck gli passa un **simbolo** (`--prompt-kind`) e non una
@@ -298,7 +322,7 @@ npx @lamemind/loom-deck
 ```bash
 # dalla project dir con un tasks.md
 scripts/deck-run T18
-scripts/deck-run T18 --prompt-kind none|recap|preflight|run
+scripts/deck-run T18 --prompt-kind none|recap|preflight|run|checkpoint
 ```
 
 Apre una tab Ptyxis nella window attiva con `LOOM_TASK=T18 claude 'recap stato task T18'`.
@@ -320,7 +344,7 @@ alcun errore visibile. Override o disattivazione via `LOOM_DECK_STATE_PROFILE`
 
 ```bash
 npm install
-npm run dev      # tsx src/cli.tsx — lista tasks.md reale, ↑↓ naviga · ⏎/^K/^P/^R spawn · q esci
+npm run dev      # tsx src/cli.tsx — lista tasks.md reale, ↑↓ naviga · ⏎ detail · ^K/^P/^R spawn · q esci
 npm run build    # tsc → dist/
 npm test         # node:test sul core vista (src/view.ts), senza Ink né terminale
 ```

package/dist/cli.js

@@ -8,14 +8,15 @@ import { statSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, } from './tasks.js';
+import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, loadTaskFileText, } from './tasks.js';
 import { discoverProjectSessions } from './sessions.js';
+import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions, selectedRow, DEFAULT_OPTIONS, MIN_QUERY, } from './search.js';
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, loadSessionIndex, } from './task-index.js';
 import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, rowLabel, selectedSession, sessionTitle, stripProjectCore, } from './session-list.js';
 import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
 import { countArchivable, SCAN_INTERVAL_MS } from './archivable.js';
-import { assignListCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
+import { assignListCapacity, detailCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { caretWindow, cut, cutParts, pad, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, progressText, writeTaskEdit, PRI_GLYPH, PRI_LABEL, PROG_GLYPH, } from './task-edit.js';
@@ -136,6 +137,21 @@ function spawnOut(cmd, args, opts) {
     fake.unref = () => fake;
     return fake;
 }
+// T66 — le azioni del detail. Non sono un catalogo nuovo: ognuna è un
+// `--prompt-kind` già esistente più `checkpoint`, e tutte passano dallo stesso
+// `spawnForTask` dei CTRL della lista — una superficie in più, zero percorsi di
+// spawn in più.
+//
+// L'etichetta è distinta dal kind dove il kind è il nome del MECCANISMO e
+// l'etichetta quello dell'INTENZIONE: `none` è "aprire la task a mani nude",
+// `recap` è "vedere a che punto sta".
+const DETAIL_ACTIONS = [
+    { kind: 'none', label: 'open' },
+    { kind: 'preflight', label: 'preflight' },
+    { kind: 'run', label: 'run' },
+    { kind: 'recap', label: 'status' },
+    { kind: 'checkpoint', label: 'checkpoint' },
+];
 // Spawn detached: il deck spawna ma NON contiene la sessione (la possiede
 // ptyxis-agent). unref + stdio ignore → ritorna subito, la TUI resta viva.
 // sessionId pinnato (T27) → il binding sidecar è deterministico allo spawn.
@@ -379,6 +395,7 @@ function useSessions(projectRoot) {
         forkOf: new Map(),
         pinned: new Map(),
         notes: new Map(),
+        live: new Map(),
     });
     // T50 — pin/unpin scrive il sidecar e vuole feedback IMMEDIATO, non al
     // prossimo tick del poll (1.5s): la reload è esposta via ref così il toggle la
@@ -397,6 +414,18 @@ function useSessions(projectRoot) {
                 sessions = [];
                 index = { bindings: new Map(), forkOf: new Map(), pinned: new Map(), notes: new Map() };
             }
+            // T62 — le vive stanno sullo STESSO tick delle altre fonti, non su una
+            // scala propria come `useArchivable`: `status` cambia a ogni turno, quindi
+            // un refresh più lento mostrerebbe `idle` su una sessione che lavora.
+            // Il try è separato perché il registry è una fonte indipendente: se manca
+            // (versione del CLI che non lo scrive) la lista deve restare, senza vive.
+            let live;
+            try {
+                live = discoverLiveSessions(projectRoot);
+            }
+            catch {
+                live = new Map();
+            }
             const { bindings, forkOf, pinned, notes } = index;
             // La signature copre anche fork, pin e note: un record di lineage, un
             // toggle di pin o una nota appena scritta cambiano la lista renderizzata,
@@ -409,11 +438,13 @@ function useSessions(projectRoot) {
                 '#' +
                 [...pinned.entries()].map(([k, v]) => `${k}@${v}`).sort().join(',') +
                 '#' +
-                [...notes.entries()].map(([k, v]) => `${k}"${v}`).sort().join(',');
+                [...notes.entries()].map(([k, v]) => `${k}"${v}`).sort().join(',') +
+                '#' +
+                liveSig(live);
             if (sig === lastSig)
                 return;
             lastSig = sig;
-            setState({ sessions, bindings, forkOf, pinned, notes });
+            setState({ sessions, bindings, forkOf, pinned, notes, live });
         };
         reloadRef.current = reload;
         reload();
@@ -494,6 +525,18 @@ const SID_CHARS = 8;
  *  vuota di soli spazi lascerebbe un buco che si legge come "colonna finita",
  *  e la riga tornerebbe a sembrare disallineata pur non essendolo. */
 const TASK_EMPTY = '·';
+// T62 — colonna liveness, larga 1, incollata al sessionId senza gutter proprio:
+// il glifo qualifica QUELL'id, e uno spazio in mezzo lo farebbe leggere come una
+// colonna a sé. Entrambi Ambiguous (EAW) → 1 colonna per il terminale e 1 cella
+// per Ink, quindi concordi (invariante ① di width.ts): il pieno/vuoto del
+// cerchio è l'unico asse che varia, e resta scandibile in verticale.
+//
+// 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.
+const LIVE_IDLE = '●';
+const LIVE_BUSY = '◍';
+const LIVE_NONE = ' ';
 // Marker Done per il DISPLAY. `task.prog` resta il `✔️` letto da tasks.md —
 // `isDone()` e le lookup di `view.ts` ci confrontano sopra, e `task-edit` lo
 // riscrive sul file: è una chiave semantica, non testo. Qui `sanitize` lo
@@ -550,7 +593,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // già la riga di STATO in fondo al frame (il feedback di un'azione). Due
     // concetti diversi a una lettera di distanza sarebbero una trappola di
     // lettura — e di scrittura, visto che `setNote` compare in quasi ogni ramo.
-    const { sessions, bindings, forkOf, pinned, notes: sessionNotes, reload: reloadSessions, } = useSessions(cwd);
+    const { sessions, bindings, forkOf, pinned, notes: sessionNotes, live, reload: reloadSessions, } = useSessions(cwd);
     const [focus, setFocus] = useState('tasks');
     // T39 — selezione KEYED SU ID, non su indice. Con una vista trasformata
     // (filtro/sort) l'indice non identifica più la stessa task: leggere l'array
@@ -609,6 +652,19 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const [assignSid, setAssignSid] = useState(null);
     const [assignFilter, setAssignFilter] = useState('');
     const [assignSel, setAssignSel] = useState(null);
+    // T66 — la task aperta nel detail, FOTOGRAFATA all'apertura: id, titolo e
+    // testo integrale del task file (`text` null = file assente). Non si rilegge
+    // da `selTask` per la stessa ragione di `assignSid`: l'overlay copre la lista,
+    // quindi l'oggetto dell'azione deve restare quello che si è scelto anche se un
+    // tick del poll spostasse la selezione sotto.
+    //
+    // Si chiama `sheet` e non `detail` perché `detail` in questo componente è già
+    // il `TaskDetail` del blocco preview sotto i pane: due cose vicine con lo
+    // stesso nome sono una trappola di lettura (stesso motivo di
+    // `note`/`sessionNotes`).
+    const [sheet, setSheet] = useState(null);
+    const [sheetTop, setSheetTop] = useState(0);
+    const [sheetAction, setSheetAction] = useState(0);
     // Dimensioni vive del terminale: sono l'input del budget d'altezza sotto.
     const { rows, columns } = useTerminalSize();
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
@@ -669,6 +725,10 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const assembled = useMemo(() => assembleSessionList(childSessions, sessions, pinned, isAll ? MAX_SESSIONS_ALL : MAX_SESSIONS), [childSessions, sessions, pinned, isAll]);
     const sessionRows = assembled.rows;
     const selSessionObj = selectedSession(sessionRows, selSessionId);
+    // T62 — contato sulla lista INTERA (stessa ragione delle larghezze di colonna
+    // qui sotto): derivarlo dalla finestra visibile lo farebbe cambiare a ogni
+    // scroll, cioè un contatore che conta lo schermo invece della lista.
+    const liveCount = useMemo(() => sessionRows.filter((r) => r.kind !== 'separator' && live.has(r.sessionId)).length, [sessionRows, live]);
     // T60 — larghezze delle colonne fisse della lista sessioni, misurate sulla
     // lista INTERA e non sulla finestra visibile: derivarle dalle sole righe a
     // schermo le farebbe cambiare a ogni scroll, cioè l'opposto di una tabella.
@@ -722,6 +782,19 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const readerLines = useMemo(() => (readerRow?.kind === 'hit' ? wrapWithOffsets(readerRow.hit.text, readerWidth) : []), [readerRow, readerWidth]);
     const readerCap = readerCapacity(rows);
     const readerMaxTop = Math.max(0, readerLines.length - readerCap);
+    // T66 — testo del task file wrappato per il detail. `wrapWithOffsets` e non
+    // `wrapLines`: quest'ultimo appiattisce gli a-capo in un flusso unico, che per
+    // una preview di 4 righe va bene e per un task file — titoli, bullet, tabelle,
+    // blocchi di codice — significa renderlo illeggibile. Memoizzato per (testo,
+    // larghezza), o ogni pressione di freccia rifarebbe l'a-capo di 9KB.
+    //
+    // Cornici da scalare: box esterno (2 bordi + 2 padding) + box testo (2 bordi +
+    // 2 padding) = 8. Sottostimare tronca un carattere, sovrastimare manda a capo
+    // una riga che il budget d'altezza non ha contato.
+    const sheetWidth = Math.max(20, (columns || 80) - 8);
+    const sheetLines = useMemo(() => (sheet?.text ? wrapWithOffsets(sheet.text, sheetWidth).map((l) => l.text) : []), [sheet, sheetWidth]);
+    const sheetCap = detailCapacity(rows);
+    const sheetMaxTop = Math.max(0, sheetLines.length - sheetCap);
     // T57 — righe del modale assegnazione: `null` (detach) in testa, poi le task
     // della VISTA corrente (D4 — filtri e sort inclusi, coerenza con ciò che si
     // stava leggendo a sinistra; le escluse restano contate nell'header).
@@ -825,29 +898,71 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // è la task SELEZIONATA: senza il pane task a fuoco non ce n'è una. Per `⏎` il
     // ramo è irraggiungibile (ci arriva già dentro `focus === 'tasks'`); per i tre
     // CTRL, che il ramo `key.ctrl` intercetta globalmente, è l'unico posto.
-    function spawnTaskSession(kind, keyLabel) {
+    // T66 — la guardia, estratta perché ora ha due chiamanti: gli spawn dalla
+    // lista e l'apertura del detail. Le tre uscite sono le stesse (pane sbagliato,
+    // riga meta, task sparita), e duplicarle vorrebbe dire tenerne allineati i
+    // messaggi a mano. `verb` è l'unica cosa che cambia fra i due usi.
+    function selectedTaskOr(keyLabel, verb) {
         if (focus !== 'tasks') {
-            setNote(`${keyLabel} → spawn: seleziona una task (←→ per il pane)`);
-            return;
+            setNote(`${keyLabel} → ${verb}: seleziona una task (←→ per il pane)`);
+            return null;
         }
         // T59 — la guardia è "non è una task", non "è spot": le righe meta sono due
         // e nessuna delle due ha una task da aprire. Il messaggio dice quale delle
         // due, perché il motivo è diverso (vista di sola lettura vs sessioni libere).
         if (isAll || isSpot) {
             setNote(isAll
-                ? 'tutte: vista di sola lettura, nessuna task da spawnare'
-                : 'spot: sessioni libere, nessuna task da spawnare');
-            return;
+                ? `tutte: vista di sola lettura, nessuna task da ${verb}`
+                : `spot: sessioni libere, nessuna task da ${verb}`);
+            return null;
         }
-        if (!selTask)
-            return;
-        const task = selTask;
+        return selTask;
+    }
+    // Lo spawn vero, su una task GIÀ risolta. Separato dalla guardia perché il
+    // detail passa l'id fotografato all'apertura e non la selezione corrente: la
+    // lista lì sotto non è più a schermo, quindi non è più la fonte dell'oggetto.
+    function spawnForTask(id, kind, keyLabel) {
         const sid = randomUUID();
-        appendTaskBinding(cwd, sid, task.id);
-        const child = spawnDeck(task.id, cwd, sid, kind);
-        child.on('error', () => setNote(`⚠ spawn ${task.id} fallito (${DECK_RUN})`));
+        appendTaskBinding(cwd, sid, id);
+        const child = spawnDeck(id, cwd, sid, kind);
+        child.on('error', () => setNote(`⚠ spawn ${id} fallito (${DECK_RUN})`));
         const what = kind === 'none' ? '' : ` · ${kind}`;
-        setNote(`${keyLabel} spawn ${task.id}${what} → tab CC (sid ${sid.slice(0, 8)})`);
+        setNote(`${keyLabel} spawn ${id}${what} → tab CC (sid ${sid.slice(0, 8)})`);
+    }
+    function spawnTaskSession(kind, keyLabel) {
+        const task = selectedTaskOr(keyLabel, 'spawnare');
+        if (task)
+            spawnForTask(task.id, kind, keyLabel);
+    }
+    // T66 — `⏎` sul pane task apre il detail invece di spawnare. Il testo del task
+    // file si legge QUI e non a ogni cambio selezione: l'overlay è l'unico
+    // consumer, e leggerlo in anticipo pagherebbe un file a ogni pressione di
+    // freccia per una schermata che quasi sempre non si apre.
+    // File assente → `text` null: l'overlay si apre lo stesso, perché spawnare una
+    // sessione non richiede il file (lo risolve `deck-run` per id).
+    function openDetail() {
+        const task = selectedTaskOr('⏎', 'aprire');
+        if (!task)
+            return;
+        setSheet({
+            id: task.id,
+            // Il titolo del task file quando c'è (è l'H1, cioè la forma lunga), la
+            // riga di tasks.md altrimenti: il detail non deve restare senza intestazione
+            // solo perché il file manca.
+            title: detail?.title || task.desc,
+            text: loadTaskFileText(tasksDir, task.id),
+        });
+        setSheetTop(0);
+        setSheetAction(0);
+        setNote('');
+        setMode('detail');
+    }
+    function closeDetail() {
+        setMode('normal');
+        setSheet(null);
+    }
+    function scrollDetail(delta) {
+        setSheetTop((t) => Math.max(0, Math.min(sheetMaxTop, t + delta)));
     }
     // T53 — apertura del modale nota sulla conversazione selezionata. Come
     // `openEdit`, la bozza parte dal valore ATTUALE: annotare una seconda volta è
@@ -1428,6 +1543,58 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             return;
         }
+        // T66 — detail della task: due zone (testo scrollabile + barra azioni) e una
+        // selezione per ognuna. Sta PRIMA del ramo di default per la stessa ragione
+        // di reader e ricerca — Ink non ha focus-trap, quindi la cattura È l'ordine
+        // dei rami — e il `return` in fondo è ciò che impedisce a `←→` di cambiare
+        // pane mentre muove fra le azioni: qui quel binding non esiste più.
+        // È anche prima del ramo CTRL, quindi `^K`/`^P`/`^R` restano acceleratori
+        // della sola lista: chi è già nel detail ha i bottoni.
+        if (mode === 'detail') {
+            if (key.escape) {
+                // Nessun reset di `sel`: la selezione della lista non è mai stata
+                // toccata, quindi si ritrova esattamente dov'era.
+                closeDetail();
+            }
+            else if (key.return) {
+                // `⏎` esegue SEMPRE l'azione selezionata, mai "scrolla" o "chiudi": il
+                // testo non è un campo attivo (si scorre, non si edita), quindi nessuna
+                // competizione sul tasto.
+                const action = DETAIL_ACTIONS[sheetAction];
+                const id = sheet?.id;
+                closeDetail();
+                if (id)
+                    spawnForTask(id, action.kind, `⏎ ${action.label}`);
+            }
+            else if (key.leftArrow || key.rightArrow) {
+                // Scorrimento CICLICO come le righe di scelta del modale edit: cinque
+                // voci, arrivare in fondo e ripartire costa meno che invertire direzione.
+                const d = key.leftArrow ? -1 : 1;
+                setSheetAction((i) => (i + d + DETAIL_ACTIONS.length) % DETAIL_ACTIONS.length);
+            }
+            else if (key.upArrow) {
+                scrollDetail(-1);
+            }
+            else if (key.downArrow) {
+                scrollDetail(1);
+            }
+            else if (key.pageUp) {
+                scrollDetail(-sheetCap);
+            }
+            else if (key.pageDown) {
+                scrollDetail(sheetCap);
+            }
+            else if (input === 'g') {
+                // Estremi su lettera per lo stesso motivo del reader: Ink riconosce
+                // `Home`/`End` ma non le espone, e qui non c'è input di testo che
+                // contenda le lettere.
+                setSheetTop(0);
+            }
+            else if (input === 'G') {
+                setSheetTop(sheetMaxTop);
+            }
+            return;
+        }
         // T52/D1 — il ramo CTRL sta PRIMA di quelli su lettera nuda e li chiude
         // tutti. `CTRL+F` e `f` nudo arrivano con lo STESSO `input` ('f'),
         // distinguibili solo da `key.ctrl`: senza questa precedenza `CTRL+F`
@@ -1469,12 +1636,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         }
         else if (key.return) {
             if (focus === 'tasks') {
-                // T56 — ⏎ apre la sessione a MANI NUDE: bound alla task (LOOM_TASK,
-                // sessionId pinnato, binding) ma senza messaggio iniettato — il contesto
-                // lo carica l'hook SessionStart, il primo messaggio lo scrive l'utente.
-                // Il recap che ⏎ faceva prima è passato a ^K: resta a un tasto, ma smette
-                // di essere l'unico ingresso possibile nella task.
-                spawnTaskSession('none', '⏎');
+                // T66 — ⏎ apre il DETAIL, non più una sessione. Secondo rimappaggio in
+                // due task (T56 lo spostò da recap a sessione a mani nude), e la
+                // direzione è una sola: da azione singola a punto d'ingresso. Il tasto
+                // più battuto non è il posto dove inchiodare una scelta di prompt — le
+                // shortcut CTRL restano per chi sa già cosa vuole, `⏎` apre il ventaglio.
+                // Lo spawn a mani nude di prima è `open`, cioè `⏎ ⏎` (è il focus iniziale).
+                openDetail();
             }
             else {
                 // T49 — ⏎ su una sessione = resume in nuova tab. Il binding si rilegge
@@ -1665,7 +1833,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // l'indicatore `focus:` — il pane a fuoco si vede già dall'evidenziazione, e
     // ridirlo a parole costava colonne su una riga che tronca in silenzio.
     const keyLegend = sanitize([
-        ...(canSpawn ? ['⏎/^K/^P/^R spawn'] : canResume ? ['⏎ resume'] : []),
+        ...(canSpawn ? ['⏎ detail', '^K/^P/^R spawn'] : canResume ? ['⏎ resume'] : []),
         ...(canResume ? ['f fork'] : []),
         ...(canPin ? ['p pin', 'N nota', 'A assegna'] : []),
         '^F cerca',
@@ -1695,6 +1863,20 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             (s ? conversationLabel(s, projectCore, assignSid ? bindings.get(assignSid) : undefined) : '');
         return (_jsx(AssignScreen, { sessionId: assignSid ?? '', label: label, current: assignSid ? bindings.get(assignSid) ?? null : null, filter: assignFilter, rows: assignRows.slice(win.start, win.end), selected: assignSel, matched: assignRows.length - 1, hidden: hiddenTasks, above: win.start, below: assignRows.length - win.end, childCount: childCount, columns: columns, note: note }));
     }
+    // ── T66 · detail della task ─────────────────────────────────────────────
+    // Quarta schermata sostitutiva, stessa ragione delle altre tre: un task file
+    // non entra in un box sopra i due pane. Il budget dei pane non viene nemmeno
+    // calcolato — il render esce di qui prima.
+    if (mode === 'detail' && sheet) {
+        if (isCompact(sheetCap)) {
+            return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", sheet.id, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga \u00B7 esc chiude"] })] }));
+        }
+        // Niente `windowRange`: quella centra la finestra su una selezione, qui la
+        // posizione è lo scroll mosso a mano. Il clamp serve comunque — un resize
+        // può accorciare il testo sotto uno scroll già dato.
+        const start = Math.min(sheetTop, sheetMaxTop);
+        return (_jsx(DetailScreen, { id: sheet.id, title: sheet.title, missing: sheet.text === null, lines: sheetLines.slice(start, start + sheetCap), top: start, total: sheetLines.length, capacity: sheetCap, action: sheetAction, 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
@@ -1749,21 +1931,26 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // non dipende più da quante voci `launch` il progetto dichiara.
     const launchLine = mode === 'normal';
     const detailParts = detail ? detailMetaOf(detail) : null;
+    // T70 — un solo blocco preview, sotto i due pane, e il FOCUS decide cosa
+    // contiene: a sinistra la task selezionata, a destra la conversazione. È il
+    // focus e non la selezione perché il blocco è uno — averne due significava
+    // pagare due cornici per mostrare contemporaneamente il dettaglio di una cosa
+    // che si sta guardando e di una che non si sta guardando.
+    // `none` quando non c'è contenuto (riga meta selezionata, task file assente,
+    // pin stale): il blocco sparisce del tutto, non resta una cornice vuota.
+    const previewKind = focus === 'tasks' ? (detail ? 'task' : 'none') : selSessionObj ? 'session' : 'none';
     const budget = layoutBudget({
         rows,
         mode,
         launchLine,
         noteLine: Boolean(note),
-        hasDetail: Boolean(detail),
+        preview: previewKind,
         detailMetaLines: detailParts?.metaLines ?? 0,
-        // T49 — il detail pane sessione esiste solo con il focus sul pane: è
-        // l'hover, non uno stato persistente; navigando le task non ruba righe.
-        hasSessionDetail: canResume,
-        // Riservo righe di preview solo per i blocchi che davvero renderizzano: il
+        // Riservo righe di anteprima solo per i blocchi che davvero renderizzano: il
         // primo prompt aggiunge info solo con un titolo custom (senza, titolo ===
         // primo prompt); l'ultima risposta solo se il modello ha già risposto.
-        sessionHasFirstPreview: canResume && Boolean(selSessionObj?.customTitle),
-        sessionHasLastPreview: canResume && Boolean(selSessionObj?.lastReply),
+        sessionHasFirstPreview: previewKind === 'session' && Boolean(selSessionObj?.customTitle),
+        sessionHasLastPreview: previewKind === 'session' && Boolean(selSessionObj?.lastReply),
     });
     // Finestre di rendering. Le liste "logiche" (viewTasks, sessionRows)
     // restano intere: navigazione, selezione e spawn continuano a ragionare su
@@ -1779,7 +1966,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: [' ', "\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: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), 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: ["nota 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 === '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: editRow, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, archivable: archivable, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), 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: ["nota 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 === '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: editRow, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, archivable: archivable, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live, liveCount: liveCount })] }), 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 SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
 // Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
@@ -1971,6 +2158,45 @@ function ReaderLine({ line, from, to }) {
     }
     return (_jsxs(Text, { wrap: "truncate-end", children: [line.text.slice(0, a), _jsx(Text, { backgroundColor: "yellow", color: "black", children: line.text.slice(a, b) }), line.text.slice(b)] }));
 }
+/**
+ * Detail della task (T66): il task file scrollabile più la barra azioni.
+ *
+ * Unisce due gesti che erano due schermate — leggere la task e agire su di essa
+ * — perché convergono sullo stesso oggetto: si legge la Description proprio per
+ * decidere QUALE azione lanciare, e con due overlay separati quella decisione
+ * costava uscire dal viewer e ricordarsi la combo.
+ *
+ * Le azioni sono BOTTONI AFFIANCATI e non voci di un menu verticale: un
+ * rettangolo ha già coordinate e area cliccabile, quindi il layout sopravvive
+ * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione. La
+ * navigazione da tastiera ci si sovrappone senza conflitti.
+ */
+function DetailScreen({ id, title, missing, lines, top, total, capacity, action, columns, }) {
+    const last = Math.min(total, top + capacity);
+    // Il taglio lo fa il chiamante (invariante ③ di width.ts): la riga bottoni è
+    // ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso — ma
+    // la correttezza non deve dipendere dall'alfabeto che capita nella riga.
+    const width = Math.max(20, (columns || 80) - 4);
+    const segs = DETAIL_ACTIONS.map((a) => `[ ${a.label} ]`);
+    const parts = [];
+    segs.forEach((s, i) => {
+        if (i > 0)
+            parts.push('  ');
+        parts.push(s);
+    });
+    const dropped = (v) => segs.filter((s, i) => v[i * 2] !== s).length;
+    // Due passate: la seconda serve SOLO quando qualcosa cade, e riserva le
+    // colonne del contatore. Riservarle sempre costerebbe 6 colonne su ogni
+    // terminale largo per un avviso che lì non comparirà mai.
+    let shown = cutParts(parts, width);
+    if (dropped(shown) > 0)
+        shown = cutParts(parts, Math.max(0, width - 6));
+    const cutCount = dropped(shown);
+    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: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), _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: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (
+                // Riga vuota → uno spazio: un `<Text>` senza contenuto Ink non lo
+                // disegna, e il testo si compatterebbe perdendo la struttura del file.
+                lines.map((l, i) => (_jsx(Text, { wrap: "truncate-end", children: l || ' ' }, top + i)))) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] }) })] }));
+}
 /**
  * Larghezza del testo dentro la lista della schermata di assegnazione: box
  * esterno (2 bordi + 2 padding) + box lista (2 bordi + 2 padding).
@@ -2041,7 +2267,7 @@ function TasksHeader({ filtered, total, hidden, above, below, archivable, focuse
     const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns));
     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, children: shown[i] }, i)) : null) }));
 }
-function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, allCount, childCount, focused, loadError, detail, windowStart, above, below, detailLines, columns, archivable, }) {
+function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, archivable, }) {
     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, { filtered: filtered, total: total, hidden: hidden, above: above, below: below, archivable: archivable, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
@@ -2069,7 +2295,7 @@ function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount,
                 const tail = n > 0 ? ` (${n})` : '';
                 const desc = cut(task.desc, Math.max(4, paneTextWidth(columns) - termWidth(head) - termWidth(tail)));
                 return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, 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));
-            })), detail && detailLines > 0 ? (_jsx(DetailPane, { detail: detail, maxLines: detailLines, columns: columns })) : null] }));
+            }))] }));
 }
 /**
  * Header del pane sessioni, tagliato QUI e non da Ink.
@@ -2084,9 +2310,10 @@ function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount,
  * condiviso, `cutParts`), la resa è del pezzo. Il giallo su `📌N` distingue le
  * pinnate dal resto dell'header e non è decorazione.
  */
-function SessionsHeader({ parentLabel, total, pinnedCount, hidden, above, below, focused, columns, }) {
+function SessionsHeader({ parentLabel, total, pinnedCount, liveCount, hidden, above, below, focused, columns, }) {
     const segments = [
         { text: `Sessions · ${parentLabel} (${total})` },
+        ...(liveCount > 0 ? [{ text: ` · ${LIVE_IDLE}${liveCount} vive`, color: 'green' }] : []),
         ...(pinnedCount > 0 ? [{ text: ` · 📌${pinnedCount}`, color: 'yellow' }] : []),
         ...(hidden > 0 ? [{ text: ` · +${hidden} più vecchie`, dim: true }] : []),
         ...(above > 0 ? [{ text: ` · ↑${above}`, dim: true }] : []),
@@ -2095,8 +2322,8 @@ function SessionsHeader({ parentLabel, total, pinnedCount, hidden, above, below,
     const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns));
     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, children: shown[i] }, i)) : null) }));
 }
-function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows, total, pinnedCount, hidden, selectedId, focused, above, below, detail, firstLines, lastLines, columns, forkOf, sessionNotes, projectCore, }) {
-    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(SessionsHeader, { parentLabel: parentLabel, total: total, pinnedCount: pinnedCount, hidden: hidden, above: above, below: below, focused: focused, columns: columns }), total === 0 ? (_jsx(Text, { color: "yellow", wrap: "truncate-end", children: isAll
+function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows, total, pinnedCount, hidden, selectedId, focused, above, below, columns, forkOf, sessionNotes, projectCore, live, liveCount, }) {
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(SessionsHeader, { parentLabel: parentLabel, total: total, pinnedCount: pinnedCount, liveCount: liveCount, hidden: hidden, above: above, below: below, focused: focused, columns: columns }), total === 0 ? (_jsx(Text, { color: "yellow", wrap: "truncate-end", children: isAll
                     ? 'nessuna conversazione nel progetto'
                     : isSpot
                         ? 'nessuna sessione libera'
@@ -2141,6 +2368,10 @@ function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows,
                 // task accanto, che esiste solo in questa vista.
                 const bound = bindings.get(s.sessionId) ?? null;
                 const linked = isAll ? Boolean(bound) : !isSpot;
+                // T62 — liveness e binding sono ORTOGONALI: la cella marker dice a chi
+                // appartiene la conversazione (pin/task/spot), questa dice se è aperta
+                // adesso. Farle condividere una cella perderebbe una delle due.
+                const liveEntry = live.get(s.sessionId);
                 // Stesso motivo per cui la colonna esiste: una pinnata resta in lista
                 // qualunque sia il parent selezionato, quindi l'header non ne dice
                 // l'appartenenza e la cella va riempita anche fuori dalla vista
@@ -2163,6 +2394,7 @@ function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows,
                     (2 /* caret */ +
                         2 /* marker */ +
                         1 /* gutter */ +
+                        1 /* T62 · colonna liveness */ +
                         SID_CHARS +
                         1 /* gutter */ +
                         (taskW > 0 ? taskW + 1 : 0) +
@@ -2181,22 +2413,24 @@ function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows,
                 const used = (label.note ? termWidth(label.note) + 2 : 0) +
                     (label.note && label.rest ? 1 : 0) +
                     termWidth(label.rest);
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: pad('📌', 2) })) : linked ? (_jsx(Text, { color: "green", children: pad('🔗', 2) })) : (_jsx(Text, { dimColor: true, children: pad('○', 2) })), ' ', _jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', taskW > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: bound && taskCell ? 'green' : undefined, dimColor: !bound, children: pad(taskCell, taskW) }), ' '] })) : null, forkMark ? _jsx(Text, { color: "magenta", children: forkMark }) : null, label.note ? (_jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", label.note, "\u00BB"] })) : null, label.note && label.rest ? ' ' : null, label.rest ? _jsx(Text, { dimColor: Boolean(label.note), children: label.rest }) : null, ' '.repeat(Math.max(0, inner - used)), ' ', _jsx(Text, { dimColor: true, children: pad(age, ageW, 'right') })] }, s.sessionId));
-            })), detail ? (_jsx(SessionDetailPane, { s: detail, firstLines: firstLines, lastLines: lastLines, columns: columns, origin: forkOf.get(detail.sessionId) ?? null, note: sessionNotes.get(detail.sessionId) ?? '' })) : null] }));
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: pad('📌', 2) })) : linked ? (_jsx(Text, { color: "green", children: pad('🔗', 2) })) : (_jsx(Text, { dimColor: true, children: pad('○', 2) })), ' ', _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : undefined, children: liveEntry ? (liveEntry.status === 'busy' ? LIVE_BUSY : LIVE_IDLE) : LIVE_NONE }), _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : 'cyan', bold: Boolean(liveEntry), children: s.sessionId.slice(0, SID_CHARS) }), ' ', taskW > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: bound && taskCell ? 'green' : undefined, dimColor: !bound, children: pad(taskCell, taskW) }), ' '] })) : null, forkMark ? _jsx(Text, { color: "magenta", children: forkMark }) : null, label.note ? (_jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", label.note, "\u00BB"] })) : null, label.note && label.rest ? ' ' : null, label.rest ? _jsx(Text, { dimColor: Boolean(label.note), children: label.rest }) : null, ' '.repeat(Math.max(0, inner - used)), ' ', _jsx(Text, { dimColor: true, children: pad(age, ageW, 'right') })] }, s.sessionId));
+            }))] }));
+}
+function PreviewPane(p) {
+    return (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: p.kind === 'task' ? (_jsx(TaskPreview, { detail: p.detail, maxLines: p.maxLines, columns: p.columns })) : (_jsx(SessionPreview, { s: p.s, firstLines: p.firstLines, lastLines: p.lastLines, columns: p.columns, origin: p.origin, note: p.note, live: p.live })) }));
 }
-// T49 — detail pane della sessione selezionata (hover), gemello del DetailPane
-// task. Tutti i campi vengono dal parse già cached dell'adapter (mtime-keyed):
-// il pannello non costa I/O al movimento di selezione. Mostra "da dove parte,
-// dove è arrivata": il primo prompt utente (`» `) e l'ultima risposta del
-// modello (`« `). La preview del primo prompt compare SOLO con un titolo custom
-// — senza, il titolo È già il primo prompt e la riga lo duplicherebbe (D4
-// preflight). Le righe rese non superano mai il riservato dal budget
-// (`firstLines`/`lastLines`); renderne meno è sicuro (frame più corto).
-function SessionDetailPane({ s, firstLines, lastLines, columns, origin, note, }) {
-    const width = detailTextWidth(columns);
+// T49 — corpo della preview sessione. Tutti i campi vengono dal parse già
+// cached dell'adapter (mtime-keyed): non costa I/O al movimento di selezione.
+// Mostra "da dove parte, dove è arrivata": il primo prompt utente (`» `) e
+// l'ultima risposta del modello (`« `). L'anteprima del primo prompt compare
+// SOLO con un titolo custom — senza, il titolo È già il primo prompt e la riga
+// lo duplicherebbe (D4 preflight). Le righe rese non superano mai il riservato
+// dal budget (`firstLines`/`lastLines`); renderne meno è sicuro (frame più corto).
+function SessionPreview({ s, firstLines, lastLines, columns, origin, note, live, }) {
+    const width = previewTextWidth(columns);
     const first = s.customTitle && firstLines > 0 ? wrapLines(s.firstPrompt, width, firstLines) : [];
     const last = s.lastReply && lastLines > 0 ? wrapLines(s.lastReply, width, lastLines) : [];
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [note ? _jsxs(Text, { color: "yellow", children: ["\u00AB", note, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : ''] }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', note ? _jsxs(Text, { color: "yellow", children: ["\u00AB", note, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : '', live ? (_jsx(Text, { color: live.status === 'busy' ? 'yellow' : 'green', children: ` · ${live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE} viva pid ${live.pid} (${live.status})` })) : null] }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
 }
 /**
  * Righe non-wrappabili del dettaglio (titolo + meta + commit) e loro conteggio.
@@ -2211,15 +2445,16 @@ function detailMetaOf(detail) {
     return { meta, commit, metaLines: 1 + (meta ? 1 : 0) + (commit ? 1 : 0) };
 }
 /**
- * Larghezza utile del testo di descrizione, ricavata dalle colonne del
- * terminale: box esterno (2 bordi + 2 padding) → pane al 50% → box dettaglio
- * (2 bordi + 2 padding).
+ * T70 — larghezza utile del testo dentro il blocco preview, che è a PIENA
+ * larghezza: box esterno (2 bordi + 2 padding) → box preview (2 bordi + 2
+ * padding). Niente più `/2`: il blocco non vive più dentro un pane al 50%,
+ * quindi una riga di descrizione dispone del doppio delle colonne.
  *
  * Volutamente prudente: sottostimare tronca qualche carattere in più,
  * sovrastimare farebbe andare a capo una riga e sforare il tetto d'altezza.
  */
-function detailTextWidth(columns) {
-    return Math.max(10, Math.floor(((columns || 80) - 4) / 2) - 9);
+function previewTextWidth(columns) {
+    return Math.max(10, (columns || 80) - 8);
 }
 /**
  * Larghezza del TESTO dentro un pane al 50%: box esterno (2 bordi + 2 padding)
@@ -2235,14 +2470,15 @@ function detailTextWidth(columns) {
 function paneTextWidth(columns) {
     return Math.max(20, Math.floor(((columns || 80) - 4) / 2) - 4);
 }
-function DetailPane({ detail, maxLines, columns, }) {
+/** Corpo della preview task: titolo, meta, descrizione wrappata, commit. */
+function TaskPreview({ detail, maxLines, columns, }) {
     const { meta, commit } = detailMetaOf(detail);
     // Wrap calcolato qui, non delegato a `<Text wrap="wrap">`: il budget ha
     // riservato ESATTAMENTE `maxLines` righe, e un wrap deciso da Ink a runtime
     // ne produrrebbe un numero che il budget non conosce — cioè il frame torna a
     // sforare e il bug si riapre da questa singola casella di testo.
-    const lines = wrapLines(detail.description ?? '', detailTextWidth(columns), maxLines);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: detail.title || detail.id }), meta ? _jsx(Text, { dimColor: true, wrap: "truncate-end", children: meta }) : null, lines.map((line, i) => (_jsx(Text, { wrap: "truncate-end", children: line }, i))), commit ? _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", commit] }) : null] }));
+    const lines = wrapLines(detail.description ?? '', previewTextWidth(columns), maxLines);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: detail.title || detail.id }), meta ? _jsx(Text, { dimColor: true, wrap: "truncate-end", children: meta }) : null, lines.map((line, i) => (_jsx(Text, { wrap: "truncate-end", children: line }, i))), commit ? _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", commit] }) : null] }));
 }
 const cwd = process.cwd();
 render(_jsx(Deck, { cwd: cwd, tasksPath: resolveTasksPath(cwd), tasksDir: resolveTasksDir(cwd) }));

package/dist/live-sessions.js

@@ -0,0 +1,135 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+function liveSessionsRoot() {
+    return join(homedir(), '.claude', 'sessions');
+}
+/**
+ * Campo 22 (`starttime`) di `/proc/<pid>/stat`, o null se la riga non è
+ * parsabile.
+ *
+ * Il taglio è sull'ULTIMA `)` e non su uno split ingenuo: il campo 2 (`comm`) è
+ * il nome dell'eseguibile fra parentesi e può contenere spazi e parentesi a sua
+ * volta, quindi tokenizzare da inizio riga sfasa tutti i campi successivi. Dopo
+ * l'ultima `)` il primo token è il campo 3 → `starttime` è l'indice 19.
+ */
+export function procStartOf(statLine) {
+    const at = statLine.lastIndexOf(')');
+    if (at < 0)
+        return null;
+    const fields = statLine.slice(at + 1).trim().split(/\s+/);
+    return fields[19] ?? null;
+}
+/**
+ * Il processo `pid` è ANCORA quello che ha scritto il file di registry?
+ *
+ * Il registry è keyed su pid, e i pid si riciclano: senza questo confronto un
+ * pid riusato da un altro programma marcherebbe «aperta» una conversazione
+ * morta, e un'entry stale lasciata da un `kill -9` (il CLI non fa in tempo a
+ * ripulire) resterebbe viva per sempre. Il guard sta dentro il file stesso —
+ * `procStart` è esattamente il campo 22 di `/proc/<pid>/stat`, verificato — e
+ * quel campo è il tempo di avvio in tick dal boot: irripetibile per un pid
+ * riciclato, che parte per definizione dopo.
+ */
+function isAlive(pid, procStart) {
+    let stat;
+    try {
+        stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+    }
+    catch {
+        return false; // processo finito → nessun /proc/<pid>
+    }
+    return procStartOf(stat) === procStart;
+}
+/**
+ * Semantica di UNA entry del registry, separata dalla lettura del disco: qui
+ * c'è solo cosa rende un record utilizzabile, ed è l'unica parte che vale la
+ * pena testare (su una stringa, senza inventare un finto `~/.claude`).
+ *
+ * `pid` arriva dal NOME del file e non dal campo omonimo: è il nome che decide
+ * quale `/proc/<pid>/stat` interrogare, e far divergere le due cose renderebbe
+ * il guard verificabile su un processo diverso da quello controllato.
+ */
+export function parseLiveEntry(content, pid) {
+    let d;
+    try {
+        d = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    const sessionId = typeof d.sessionId === 'string' ? d.sessionId : '';
+    const procStart = typeof d.procStart === 'string' ? d.procStart : '';
+    const cwd = typeof d.cwd === 'string' ? d.cwd : '';
+    // Senza uno dei tre l'entry non è utilizzabile: `sessionId` è la chiave del
+    // join con la lista, `procStart` è il guard anti-pid-riciclato (assente →
+    // non si può stabilire la liveness, e assumerla sarebbe il falso positivo che
+    // il guard esiste per escludere), `cwd` è il filtro di progetto.
+    if (!sessionId || !procStart || !cwd)
+        return null;
+    return {
+        entry: {
+            sessionId,
+            pid,
+            status: d.status === 'busy' ? 'busy' : 'idle',
+            name: typeof d.name === 'string' ? d.name : '',
+            cwd,
+        },
+        procStart,
+    };
+}
+/**
+ * Le sessioni VIVE del solo progetto corrente, indicizzate per `sessionId` —
+ * la stessa chiave del sidecar `session-tasks.jsonl` e di `deck-run --resume`,
+ * quindi il join con la riga di lista è diretto.
+ *
+ * Il filtro per `cwd` è d'EFFICIENZA, non di correttezza: risparmia lo `stat`
+ * di `/proc` sui processi degli altri progetti (il registry è globale, non
+ * per-progetto). Il match resta sul `sessionId`.
+ *
+ * Nessuna cache mtime-keyed come in `sessions.ts`: le entry sono poche e di
+ * poche centinaia di byte, mentre `status` cambia a ogni turno — una cache qui
+ * mostrerebbe `idle` su una sessione che sta lavorando, cioè il difetto che la
+ * colonna esiste per non avere.
+ */
+export function discoverLiveSessions(projectRoot) {
+    const out = new Map();
+    let files;
+    try {
+        files = readdirSync(liveSessionsRoot()).filter((f) => f.endsWith('.json'));
+    }
+    catch {
+        return out; // registry assente (CLI mai avviato, o versione che non lo scrive)
+    }
+    for (const f of files) {
+        const pid = Number(basename(f, '.json'));
+        if (!Number.isInteger(pid) || pid <= 0)
+            continue;
+        let content;
+        try {
+            content = readFileSync(join(liveSessionsRoot(), f), 'utf8');
+        }
+        catch {
+            continue; // il processo può finire fra readdir e read
+        }
+        const parsed = parseLiveEntry(content, pid);
+        if (!parsed)
+            continue;
+        const { entry, procStart } = parsed;
+        if (entry.cwd !== projectRoot && !entry.cwd.startsWith(projectRoot + '/'))
+            continue;
+        if (!isAlive(pid, procStart))
+            continue;
+        out.set(entry.sessionId, entry);
+    }
+    return out;
+}
+/** Signature del poll: cambia quando cambia l'insieme delle vive O lo stato di
+ *  una di esse. Il `pid` ci sta dentro perché un `/clear` sposta lo stesso
+ *  `sessionId` su un processo diverso senza toccare né insieme né stato. */
+export function liveSig(live) {
+    return [...live.values()]
+        .map((l) => `${l.sessionId}:${l.pid}:${l.status}`)
+        .sort()
+        .join(',');
+}

package/dist/tasks.js

@@ -121,6 +121,29 @@ export function parseTaskDetail(id, content) {
         description: sanitize(descLines.join('\n').trim()),
     };
 }
+/**
+ * Testo INTEGRALE del task file (T66 · detail).
+ *
+ * Distinto da `loadTaskDetail`, che estrae header e Description per il blocco
+ * preview: qui si legge la task per intero — Acceptance, Deliverables,
+ * Implementation Notes — e un parse che tenesse solo le sezioni note
+ * nasconderebbe proprio ciò per cui si apre l'overlay.
+ *
+ * `sanitize` al confine come per il detail parsato: il task file è testo libero
+ * e porta glifi che Ink e il terminale misurano diversamente. Non torna mai su
+ * disco da qui, quindi la sostituzione non ha il rischio di `pri`/`prog`.
+ */
+export function loadTaskFileText(dir, id) {
+    const path = findTaskFile(dir, id);
+    if (!path)
+        return null;
+    try {
+        return sanitize(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
 export function loadTaskDetail(dir, id) {
     const path = findTaskFile(dir, id);
     if (!path)

package/dist/viewport.js

@@ -17,25 +17,25 @@
  *  basterebbe 1; ne teniamo 1 come margine per l'a-capo del cursore. */
 export const SLACK = 1;
 /** Sotto questa soglia la lista task non è più utilizzabile: meglio sacrificare
- *  il pannello di dettaglio che ridurre la lista a due righe. */
+ *  il blocco preview che ridurre la lista a due righe. */
 const MIN_TASK_ROWS = 3;
-/** Il dettaglio è secondario: non si prende mai più di così, anche con spazio. */
-const MAX_DETAIL_LINES = 4;
-/** Righe di "cornice" fisse dei tre contenitori a lunghezza variabile. */
+/** La preview è secondaria: non si prende mai più di così, anche con spazio.
+ *  A piena larghezza (T70) una riga contiene il doppio del testo di prima,
+ *  quindi il tetto sale insieme allo spazio: il blocco è uno solo e lo paga
+ *  una volta sola per entrambi i pane. */
+const MAX_DETAIL_LINES = 6;
+/** Righe di "cornice" fisse dei contenitori a lunghezza variabile. */
 // T59 — le righe meta sono DUE (`≡ tutte`, `○ spot`): ogni riga fissa aggiunta
 // a un pane va scalata qui, o il frame sfonda `rows` e Ink passa a
 // clearTerminal (frame-fantasma nello scrollback di VTE).
 const TASKS_PANE_CHROME = 6; // 2 bordi + header "Tasks (n)" + riga sort + 2 righe meta
 const SESSIONS_PANE_CHROME = 3; // 2 bordi + header "Sessions · …"
-const DETAIL_CHROME = 3; // marginTop + 2 bordi
-/** Detail pane sessione (T49): righe fisse = titolo + riga meta (size · turni ·
- *  ultima attività). Le preview (primo prompt + ultima risposta) sono variabili,
- *  ciascuna al più MAX_SESSION_PREVIEW righe. */
+const PREVIEW_CHROME = 3; // marginTop + 2 bordi
+/** Preview sessione: righe fisse = titolo + riga meta (size · turni · ultima
+ *  attività · branch). Le due anteprime (primo prompt + ultima risposta) sono
+ *  variabili, ciascuna al più MAX_SESSION_PREVIEW righe. */
 const SESSION_DETAIL_FIXED = 2;
-const MAX_SESSION_PREVIEW = 2;
-/** Gemello di MIN_TASK_ROWS: sotto questa soglia la lista sessioni non serve
- *  più — meglio sacrificare il detail pane. */
-const MIN_SESSION_ROWS = 3;
+const MAX_SESSION_PREVIEW = 3;
 /** Altezza di ciascuna modale, marginTop incluso. In flusso, non in overlay:
  *  spingono giù i pane, quindi il loro costo va scalato dal budget. */
 export const MODAL_HEIGHT = {
@@ -57,16 +57,28 @@ export const MODAL_HEIGHT = {
     // pagherebbe due volte (il suo costo + quello che toglie ai pane sotto, che
     // in quel momento non si stanno nemmeno guardando).
     assign: 0,
+    // T66 — il detail della task: task file scrollabile + barra azioni. Quarta
+    // sostitutiva, stesso motivo delle altre tre — un task file da 200 righe non
+    // entra in un box sopra i pane. La sua altezza la distribuisce
+    // `detailCapacity`.
+    detail: 0,
 };
 /**
- * Distribuisce le righe disponibili fra lista task, lista sessioni e dettaglio.
+ * Distribuisce le righe disponibili fra lista task, lista sessioni e preview.
  *
  * I due pane stanno affiancati (flexDirection row) → l'altezza del blocco è il
  * MAX delle due colonne, non la somma: ognuna riceve lo stesso tetto.
  *
+ * T70 — il blocco preview è UNO e sta SOTTO i due pane, non dentro uno di essi:
+ * il suo costo esce quindi da `avail` PRIMA della distribuzione, e ciò che
+ * resta va a entrambe le colonne. Con i due pannelli separati il costo gravava
+ * su una colonna sola, e siccome l'altezza del blocco è il max delle due, il
+ * pannello del pane meno alto era di fatto gratis: contabilità che qui non
+ * esiste più.
+ *
  * Ordine di sacrificio quando lo spazio stringe:
- *   1. righe di descrizione del dettaglio (fino a sparire col pannello),
- *   2. righe della lista task, mai sotto MIN_TASK_ROWS finché il dettaglio c'è.
+ *   1. righe variabili della preview (fino a sparire col blocco),
+ *   2. righe delle liste, mai sotto MIN_TASK_ROWS finché la preview c'è.
  */
 export function layoutBudget(input) {
     const outerChrome = 2 + // bordi del box esterno
@@ -86,58 +98,63 @@ export function layoutBudget(input) {
         return {
             taskRows: 0,
             sessionRows: 0,
+            preview: false,
             detailLines: 0,
-            sessionDetail: false,
             sessionFirstLines: 0,
             sessionLastLines: 0,
             compact: true,
         };
     }
-    // Detail pane sessione (T49): stesso schema del dettaglio task — prima la
-    // lista minima, poi la cornice, le preview solo con lo spazio che avanza.
-    // A differenza del dettaglio task il box regge anche senza righe variabili:
-    // titolo + meta sono il valore, le preview (primo prompt + ultima risposta)
-    // sono bonus. Priorità al primo prompt, poi l'ultima risposta prende ciò che
-    // resta: su terminale stretto cade prima l'ultima risposta, non il primo.
-    // Riservo righe solo per le preview che davvero renderizzeranno (i due
-    // `has…Preview`), così non sottraggo righe alla lista per un blocco vuoto.
-    let sessionDetail = false;
-    let sessionDetailCost = 0;
+    // Pavimento sotto cui la preview non si concede: la lista minima del pane
+    // TASK, cioè il più caro in cornice dei due. Garantito lui, il pane sessioni
+    // (3 di cornice contro 6) sta comodo per costruzione — un secondo controllo
+    // sul suo minimo sarebbe una condizione che non può mai scattare.
+    const floor = TASKS_PANE_CHROME + MIN_TASK_ROWS;
+    let preview = false;
+    let previewCost = 0;
+    let detailLines = 0;
     let sessionFirstLines = 0;
     let sessionLastLines = 0;
-    if (input.hasSessionDetail) {
-        const fixed = DETAIL_CHROME + SESSION_DETAIL_FIXED;
-        const spare = avail - SESSIONS_PANE_CHROME - MIN_SESSION_ROWS - fixed;
+    if (input.preview === 'task') {
+        const fixed = PREVIEW_CHROME + input.detailMetaLines;
+        // Serve almeno 1 riga di descrizione per giustificare il blocco: titolo e
+        // meta sono già nella riga di lista, quindi una cornice senza descrizione
+        // ruberebbe righe alle liste per non aggiungere niente.
+        const spare = avail - floor - fixed;
+        if (spare >= 1) {
+            preview = true;
+            detailLines = Math.min(MAX_DETAIL_LINES, spare);
+            previewCost = fixed + detailLines;
+        }
+    }
+    else if (input.preview === 'session') {
+        const fixed = PREVIEW_CHROME + SESSION_DETAIL_FIXED;
+        const spare = avail - floor - fixed;
+        // A differenza della task il blocco regge anche a zero righe variabili:
+        // titolo e riga meta (size, turni, data, branch) non stanno da nessun'altra
+        // parte a schermo, quindi sono già il valore. Priorità al primo prompt, poi
+        // l'ultima risposta prende ciò che resta: quando lo spazio stringe cade
+        // prima l'ultima risposta, non il primo prompt. Le righe si riservano solo
+        // per le anteprime che davvero renderizzeranno (i due `has…Preview`), o si
+        // toglierebbero righe alle liste per un blocco vuoto.
         if (spare >= 0) {
-            sessionDetail = true;
+            preview = true;
             if (input.sessionHasFirstPreview)
                 sessionFirstLines = Math.min(MAX_SESSION_PREVIEW, spare);
             if (input.sessionHasLastPreview) {
                 sessionLastLines = Math.min(MAX_SESSION_PREVIEW, spare - sessionFirstLines);
             }
-            sessionDetailCost = fixed + sessionFirstLines + sessionLastLines;
-        }
-    }
-    const sessionRows = Math.max(0, avail - SESSIONS_PANE_CHROME - sessionDetailCost);
-    let detailLines = 0;
-    let detailChrome = 0;
-    if (input.hasDetail) {
-        const fixed = DETAIL_CHROME + input.detailMetaLines;
-        // Righe che avanzano dopo aver garantito la lista minima e la cornice del
-        // dettaglio. Serve almeno 1 riga di descrizione per giustificare il box:
-        // un pannello con la sola cornice ruberebbe 3+ righe per mostrare nulla.
-        const spare = avail - TASKS_PANE_CHROME - MIN_TASK_ROWS - fixed;
-        if (spare >= 1) {
-            detailChrome = fixed;
-            detailLines = Math.min(MAX_DETAIL_LINES, spare);
+            previewCost = fixed + sessionFirstLines + sessionLastLines;
         }
     }
-    const taskRows = Math.max(0, avail - TASKS_PANE_CHROME - detailChrome - detailLines);
+    // Ciò che resta va a ENTRAMBE le colonne: la preview sta sotto il blocco dei
+    // pane, quindi il suo costo lo pagano insieme una volta sola.
+    const listAvail = avail - previewCost;
     return {
-        taskRows,
-        sessionRows,
+        taskRows: Math.max(0, listAvail - TASKS_PANE_CHROME),
+        sessionRows: Math.max(0, listAvail - SESSIONS_PANE_CHROME),
+        preview,
         detailLines,
-        sessionDetail,
         sessionFirstLines,
         sessionLastLines,
         compact: false,
@@ -192,6 +209,25 @@ const READER_CHROME = 8;
 export function readerCapacity(rows) {
     return Math.max(0, (rows || 24) - SLACK - READER_CHROME);
 }
+// T66 — cornice del detail della task.
+//   2  bordi del box esterno
+//   1  titolo "loom-deck"
+//   1  riga meta (id · titolo · posizione nel testo)
+//   1  riga hint
+//   1  marginTop del box testo
+//   2  bordi del box testo
+//   1  marginTop della riga azioni
+//   1  riga azioni
+//
+// Le ultime due sono il motivo per cui il detail non può riusare READER_CHROME:
+// la barra bottoni è una riga FISSA in più dentro l'overlay, e ogni riga fissa
+// aggiunta va scalata dalla capienza del contenuto o il frame sfonda `rows`
+// (stessa invariante di TASKS_PANE_CHROME).
+const DETAIL_CHROME = 10;
+/** Righe di task file che entrano nel terminale. */
+export function detailCapacity(rows) {
+    return Math.max(0, (rows || 24) - SLACK - DETAIL_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.27.3",
+  "version": "0.29.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

@@ -11,7 +11,7 @@
 # Tre assi ORTOGONALI, da non confondere fra loro:
 #   binding task   <TaskID> ..... --no-task
 #   continuità     nuova ........ --resume [--fork]
-#   prompt         --prompt-kind none|recap|preflight|run
+#   prompt         --prompt-kind none|recap|preflight|run|checkpoint
 # Il terzo asse (T56) prima non esisteva: il prompt era una CONSEGUENZA degli
 # altri due (bound ⇒ recap, --no-task ⇒ niente, --resume ⇒ niente), quindi
 # "task-bound SENZA prompt" era inesprimibile e l'unico modo di non avere un
@@ -74,7 +74,7 @@ PROMPT_KIND=""
 # 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> (T56): sceglie il prompt iniziale fra
+# --prompt-kind <none|recap|preflight|run|checkpoint> (T56, T66): 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
@@ -125,6 +125,7 @@ USAGE="uso: deck-run <TaskID> [--prompt-kind <kind>] [--session-id <uuid>]
        recap       recap stato task <TaskID>
        preflight   /loom-works:preflight-task <TaskID>
        run         /loom-works:run-task <TaskID>  (run-doc sulle task D)
+       checkpoint  /loom-works:checkpoint-task <TaskID>
 
   --title-note   nota della conversazione, appesa al titolo tab come «nota»
                  (ridotta a lettere/cifre/spazi/-/_, cap 60 char)"
@@ -154,8 +155,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) ;;
-    *) echo "--prompt-kind ignoto: '${PROMPT_KIND}' (usa none|recap|preflight|run)" >&2
+    none|recap|preflight|run|checkpoint) ;;
+    *) echo "--prompt-kind ignoto: '${PROMPT_KIND}' (usa none|recap|preflight|run|checkpoint)" >&2
        echo "$USAGE" >&2
        exit 2 ;;
   esac
@@ -336,11 +337,12 @@ FORK_FLAG=""
 # Il prompt iniziale è la scelta di CHI APRE la sessione, non una proprietà della
 # task: lo stesso task file si apre per leggerne lo stato, per un preflight, per
 # eseguirlo o a mani nude. Il kind è quell'intento.
-#   none      → nessun prompt (≠ stringa vuota: PROMPT_ARG sparisce del tutto,
-#               come sul ramo --resume, altrimenti CC riceve un posizionale vuoto)
-#   recap     → prompt DIRETTO, no skill: l'utente rivede/steera prima di lanciare
-#   preflight → skill di preflight sulla task
-#   run       → skill di esecuzione sulla task
+#   none       → nessun prompt (≠ stringa vuota: PROMPT_ARG sparisce del tutto,
+#                come sul ramo --resume, altrimenti CC riceve un posizionale vuoto)
+#   recap      → prompt DIRETTO, no skill: l'utente rivede/steera prima di lanciare
+#   preflight  → skill di preflight sulla task
+#   run        → skill di esecuzione sulla task
+#   checkpoint → skill di checkpoint sulla task
 # Vincolo di quoting: nessun template deve contenere apici singoli (viaggia
 # dentro '...' nel comando in-tab). `/loom-works:...` passa intero proprio perché
 # è single-quoted — lo slash e i due punti non sono metacaratteri lì dentro.
@@ -355,16 +357,19 @@ FORK_FLAG=""
 # del contratto loom (`T` code, `D` doc) e le due hanno skill di esecuzione
 # diverse — `run-task` è dichiarata code-only, `run-doc` è la sua complementare.
 # Su una D il prompt `run-task` invocherebbe la skill sbagliata. Gli altri kind
-# non discriminano: `recap` è un prompt diretto (nessuna skill) e
-# `preflight-task` risolve il task file per id, indifferente al prefisso.
+# non discriminano, ma è una verifica da rifare per OGNI kind nuovo, non una
+# proprietà del catalogo: `recap` è un prompt diretto (nessuna skill),
+# `preflight-task` risolve il task file per id, e `checkpoint-task` estrae il
+# taskId con `T\d+|D\d+` — copre quindi entrambi i prefissi da sé.
 case "${PROMPT_KIND:-recap}" in
-  none)      PROMPT="" ;;
-  recap)     PROMPT="recap stato task ${TASK}" ;;
-  preflight) PROMPT="/loom-works:preflight-task ${TASK}" ;;
-  run)       case "$TASK" in
-               D*) PROMPT="/loom-works:run-doc ${TASK}" ;;
-               *)  PROMPT="/loom-works:run-task ${TASK}" ;;
-             esac ;;
+  none)       PROMPT="" ;;
+  recap)      PROMPT="recap stato task ${TASK}" ;;
+  preflight)  PROMPT="/loom-works:preflight-task ${TASK}" ;;
+  checkpoint) PROMPT="/loom-works:checkpoint-task ${TASK}" ;;
+  run)        case "$TASK" in
+                D*) PROMPT="/loom-works:run-doc ${TASK}" ;;
+                *)  PROMPT="/loom-works:run-task ${TASK}" ;;
+              esac ;;
 esac
 if [[ "${PROMPT_KIND:-}" != "none" && -n "${LOOM_DECK_ENTER_PROMPT:-}" ]]; then
   PROMPT="${LOOM_DECK_ENTER_PROMPT//\{TASK\}/${TASK}}"