@lamemind/loom-deck 0.28.0 → 0.30.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,15 +8,17 @@ 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 { scanText, sliceLine, topForOffset, } from './text-search.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';
 import { loadView, saveView, viewFilePath } from './view-store.js';
@@ -136,6 +138,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 +396,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 +415,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 +439,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 +526,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 +594,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 +653,26 @@ 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);
+    // T91 — ricerca dentro il detail. `open` distingue i due modi in cui la si
+    // lascia: `esc` butta via ciò che il modale ha prodotto (`find` a null,
+    // evidenziazione via), `⏎` lo congela e restituisce il controllo allo strato
+    // sotto — campo chiuso, occorrenze ancora colorate, scroll dov'era. Senza il
+    // flag i due gesti collasserebbero su uno solo.
+    const [find, setFind] = useState(null);
+    const [occIdx, setOccIdx] = 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 +733,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 +790,42 @@ 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);
+    // Le righe conservano i propri offset invece di essere appiattite a stringa
+    // (T66 le buttava con `.map((l) => l.text)`): è ciò che rende
+    // l'evidenziazione un'intersezione di intervalli invece di un caso speciale
+    // per il match spezzato dall'a-capo.
+    const sheetLines = useMemo(() => (sheet?.text ? wrapWithOffsets(sheet.text, sheetWidth) : []), [sheet, sheetWidth]);
+    const sheetCap = detailCapacity(rows, find?.open === true);
+    const sheetMaxTop = Math.max(0, sheetLines.length - sheetCap);
+    // Lo scan gira sulla STESSA stringa che si renderizza (`sheet.text`, già
+    // passata da `sanitize` in `loadTaskFileText`): una rilettura del file darebbe
+    // offset che indicizzano un documento diverso da quello a schermo, cioè
+    // un'evidenziazione spostata di N caratteri e nessun errore.
+    const findRes = useMemo(() => (find && sheet?.text ? scanText(sheet.text, find.q) : { occ: [], error: '' }), [find?.q, sheet]);
+    // L'indice si clampa qui invece di essere corretto a ogni `setOccIdx`: la
+    // lista si accorcia da sola mentre si digita, e un indice fuori range vivrebbe
+    // per il tempo di un render.
+    const occCur = findRes.occ.length > 0 ? Math.min(occIdx, findRes.occ.length - 1) : -1;
+    // Salto all'occorrenza corrente, centrata. Non dipende da `sheetTop`, quindi
+    // non si auto-rilancia; dipende da `sheetLines` e `sheetCap`, quindi un resize
+    // ricalcola la posizione senza toccare le occorrenze — che sono offset del
+    // sorgente e il resize non le sposta.
+    useEffect(() => {
+        const o = occCur >= 0 ? findRes.occ[occCur] : undefined;
+        if (!o)
+            return;
+        setSheetTop(topForOffset(sheetLines, o.start, sheetCap));
+    }, [findRes, occCur, sheetLines, 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 +929,87 @@ 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);
+        setFind(null);
+        setOccIdx(0);
+        setNote('');
+        setMode('detail');
+    }
+    function closeDetail() {
+        setMode('normal');
+        setSheet(null);
+        setFind(null);
+    }
+    function scrollDetail(delta) {
+        setSheetTop((t) => Math.max(0, Math.min(sheetMaxTop, t + delta)));
+    }
+    /** Modifica la query: l'insieme delle occorrenze cambia, quindi si riparte
+     *  dalla prima. Il movimento del caret NON passa di qui — sposta il cursore,
+     *  non i risultati. */
+    function editFind(next) {
+        setFind((f) => (f ? next(f) : f));
+        setOccIdx(0);
+    }
+    function moveOcc(d) {
+        const n = findRes.occ.length;
+        if (n === 0)
+            return;
+        setOccIdx((i) => (Math.min(i, n - 1) + d + n) % n);
     }
     // T53 — apertura del modale nota sulla conversazione selezionata. Come
     // `openEdit`, la bozza parte dal valore ATTUALE: annotare una seconda volta è
@@ -1428,6 +1590,110 @@ 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') {
+            // T91 — modale DENTRO il modale, e sta prima per la stessa ragione per cui
+            // il detail sta prima del ramo CTRL: Ink non ha focus-trap, quindi la
+            // cattura È l'ordine dei rami. Mentre il campo è aperto mangia ogni lettera
+            // nuda, `g`/`G` compresi.
+            if (find?.open) {
+                if (key.escape) {
+                    // Annulla: butta via ciò che il modale ha prodotto. Lo scroll resta
+                    // dove la ricerca l'ha portato — riavvolgerlo sarebbe una terza
+                    // semantica che nessun tasto ha chiesto.
+                    setFind(null);
+                }
+                else if (key.return) {
+                    // Congela: campo chiuso, occorrenze ancora colorate, scroll intatto.
+                    setFind((f) => (f ? { ...f, open: false } : f));
+                }
+                else if (key.upArrow) {
+                    moveOcc(-1);
+                }
+                else if (key.downArrow) {
+                    moveOcc(1);
+                }
+                else if (key.leftArrow || key.rightArrow) {
+                    const d = key.leftArrow ? -1 : 1;
+                    setFind((f) => f ? { ...f, caret: Math.max(0, Math.min(cpLen(f.q), f.caret + d)) } : f);
+                }
+                else if (key.backspace || key.delete) {
+                    editFind((f) => f.caret > 0 ? { ...f, q: removeAt(f.q, f.caret - 1), caret: f.caret - 1 } : f);
+                }
+                else if (key.ctrl) {
+                    // `^U` svuota, come il filtro del modale assegnazione; ogni altra combo
+                    // è no-op — `^F` incluso, siamo già dentro.
+                    if (input === 'u')
+                        editFind((f) => ({ ...f, q: '', caret: 0 }));
+                }
+                else if (input && !key.meta) {
+                    const ins = sanitizeTyped(input);
+                    editFind((f) => ({ ...f, q: insertAt(f.q, f.caret, ins), caret: f.caret + cpLen(ins) }));
+                }
+                return;
+            }
+            if (key.ctrl && input === 'f') {
+                // Fuori dal detail `^F` è la ricerca conversazioni; qui è la ricerca nel
+                // testo. La query sopravvive a una chiusura con `⏎`, quindi riaprire
+                // riprende da dov'era invece di ricominciare.
+                setFind((f) => (f ? { ...f, open: true } : { q: '', caret: 0, open: true }));
+                return;
+            }
+            if (key.escape) {
+                // Uno strato alla volta: se resta un'evidenziazione congelata, `esc`
+                // smonta quella; il detail lo chiude il secondo.
+                // Nessun reset di `sel`: la selezione della lista non è mai stata
+                // toccata, quindi si ritrova esattamente dov'era.
+                if (find)
+                    setFind(null);
+                else
+                    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 +1735,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 +1932,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 +1962,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, find: find, occ: findRes.occ, occCur: occCur }));
+    }
     // ── 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
@@ -1784,7 +2065,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, 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 })] }), 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) ?? '' })) : 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: [_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:
@@ -1951,7 +2232,8 @@ function SearchScreen({ preview, hash, query, field, opts, result, rows, selecte
  */
 function SearchPreviewPane({ p }) {
     const last = Math.min(p.total, p.from + p.lines.length);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["record ", p.hit.idx, " \u00B7 ", KIND_LABEL[p.hit.kind], p.ts ? ` · ${fmtDateTime(p.ts)}` : '', " \u00B7 righe ", p.from + 1, "-", last, " di ", p.total, " \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " apre il reader"] }), p.lines.map((l, i) => (_jsx(ReaderLine, { line: l, from: p.hit.matchStart, to: p.hit.matchEnd }, p.from + i)))] }));
+    const occ = [{ start: p.hit.matchStart, end: p.hit.matchEnd }];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["record ", p.hit.idx, " \u00B7 ", KIND_LABEL[p.hit.kind], p.ts ? ` · ${fmtDateTime(p.ts)}` : '', " \u00B7 righe ", p.from + 1, "-", last, " di ", p.total, " \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " apre il reader"] }), p.lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, p.from + i)))] }));
 }
 /**
  * Reader fullscreen (T52 · D8).
@@ -1963,18 +2245,71 @@ function SearchPreviewPane({ p }) {
  */
 function ReaderScreen({ hit, lines, top, total, capacity, bound, }) {
     const last = Math.min(total, top + capacity);
-    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: ["reader \u00B7 ", _jsx(Text, { color: "cyan", children: hit.sessionId.slice(0, 8) }), " \u00B7 record ", hit.idx, " \u00B7", ' ', KIND_LABEL[hit.kind], bound ? ` · ${bound}` : '', " \u00B7 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" }), " inizio \u00B7 ", _jsx(Text, { color: "yellow", children: "G" }), " fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " torna alla lista"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: lines.map((l, i) => (_jsx(ReaderLine, { line: l, from: hit.matchStart, to: hit.matchEnd }, top + i))) })] }));
+    const occ = [{ start: hit.matchStart, end: hit.matchEnd }];
+    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: ["reader \u00B7 ", _jsx(Text, { color: "cyan", children: hit.sessionId.slice(0, 8) }), " \u00B7 record ", hit.idx, " \u00B7", ' ', KIND_LABEL[hit.kind], bound ? ` · ${bound}` : '', " \u00B7 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" }), " inizio \u00B7 ", _jsx(Text, { color: "yellow", children: "G" }), " fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " torna alla lista"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, top + i))) })] }));
 }
-/** Una riga del reader, con la sola porzione di match evidenziata. Gli offset
- *  sono quelli del testo sorgente, quindi un match a cavallo dell'a-capo si
- *  colora su entrambe le righe senza casi speciali. */
-function ReaderLine({ line, from, to }) {
-    const a = Math.max(0, Math.min(line.text.length, from - line.start));
-    const b = Math.max(0, Math.min(line.text.length, to - line.start));
-    if (b <= a) {
+/** Una riga con le porzioni di match evidenziate. Gli offset sono quelli del
+ *  testo sorgente, quindi un match a cavallo dell'a-capo si colora su entrambe
+ *  le righe senza casi speciali — entrambe intersecano il suo intervallo.
+ *
+ *  Regge N occorrenze perché il detail (T91) ne mostra tutte quelle visibili; il
+ *  reader (T52) ne passa una sola, che è il caso degenere dello stesso taglio. */
+function ReaderLine({ line, occ, current, }) {
+    const segs = sliceLine(line.text, line.start, occ, current);
+    if (segs.length === 0)
         return _jsx(Text, { wrap: "truncate-end", children: line.text || ' ' });
-    }
-    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)] }));
+    return (_jsx(Text, { wrap: "truncate-end", children: segs.map((s, i) => s.hit ? (
+        // La corrente si distingue dalle altre per COLORE di sfondo, non per
+        // presenza: tutte restano visibili, o navigare fra occorrenze non
+        // mostrerebbe più dove sono le altre.
+        _jsx(Text, { backgroundColor: s.current ? 'cyan' : 'yellow', color: "black", children: s.text }, i)) : (_jsx(Text, { children: s.text }, i))) }));
+}
+/** Campo della ricerca nel detail: finestra ancorata al caret, cursore inverso
+ *  sulla cella reale. Gemello di `EditTextField` senza la label, che qui sta
+ *  fuori perché il campo vive in FLUSSO su una riga condivisa col contatore —
+ *  non su una riga propria. */
+function DetailFindField({ value, caret, cols }) {
+    const win = caretWindow(value, caret, cols);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: sanitize(win.head) }), _jsx(Text, { inverse: true, children: sanitize(win.at) }), _jsx(Text, { children: sanitize(win.tail) })] }));
+}
+/**
+ * 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, find, occ, occCur, }) {
+    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}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_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: "^F" }), " cerca \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(ReaderLine, { line: l, occ: occ, current: occCur }, top + i))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(DetailFindField, { value: find.q, caret: find.caret, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, _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
@@ -2089,9 +2424,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 }] : []),
@@ -2100,8 +2436,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, 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'
@@ -2146,6 +2482,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
@@ -2168,6 +2508,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) +
@@ -2186,11 +2527,11 @@ 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));
+                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 })) }));
+    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 — corpo della preview sessione. Tutti i campi vengono dal parse già
 // cached dell'adapter (mtime-keyed): non costa I/O al movimento di selezione.
@@ -2199,11 +2540,11 @@ function PreviewPane(p) {
 // 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, }) {
+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(_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)}` : ''] }), 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.

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

@@ -58,8 +58,8 @@ function escapeLiteral(s) {
  * `(`) è la NORMA durante la digitazione, non un caso limite. Deve degradare a
  * lista vuota con segnalazione inline, mai a un crash della TUI.
  */
-export function buildMatcher(query, opts) {
-    if (query.length < MIN_QUERY)
+export function buildMatcher(query, opts, min = MIN_QUERY) {
+    if (query.length < min)
         return { re: null, error: '' };
     let source = opts.regex ? query : escapeLiteral(query);
     // Il gruppo non-catturante è obbligatorio: senza, `\b` si legherebbe al solo

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/text-search.js

@@ -0,0 +1,100 @@
+/**
+ * Ricerca dentro UN documento: occorrenze come offset del testo sorgente.
+ *
+ * Gemello di `search.ts` per il motore, opposto per forma. Lì il corpus è N
+ * conversazioni, quindi il risultato raggruppa per sessione, cappa le occorrenze
+ * e produce estratti; qui il corpus è una stringa sola e la risposta utile è la
+ * posizione, non l'estratto — il testo è già a schermo.
+ *
+ * Gli offset sono quelli del SORGENTE, mai coordinate riga/colonna del testo
+ * wrappato. Due proprietà ne discendono, ed è il motivo per cui il modulo esiste:
+ *
+ *  - **Immunità al re-wrap.** Un resize cambia larghezza e numero di righe ma non
+ *    sposta un match, perché il sorgente non cambia. Coordinate «riga 42,
+ *    colonna 7» andrebbero ricalcolate a ogni SIGWINCH.
+ *  - **Match a cavallo dell'a-capo senza casi speciali.** Ogni riga di
+ *    `wrapWithOffsets` è una fetta contigua del sorgente, quindi evidenziare è
+ *    intersecare due intervalli — e un match spezzato su due righe si colora su
+ *    entrambe perché entrambe intersecano.
+ *
+ * Puro: nessun Ink, nessun terminale, nessun filesystem.
+ */
+import { buildMatcher } from './search.js';
+export const LITERAL = { regex: false, caseSensitive: false, wholeWord: false };
+/**
+ * Minimo di caratteri più basso di `MIN_QUERY`.
+ *
+ * Su N conversazioni una query di 2 caratteri produce migliaia di occorrenze
+ * inutili, e la soglia a 3 protegge dall'indicizzazione a vuoto. Su un task file
+ * `T7` o `⏎` sono query legittime e frequenti: la soglia lì non protegge da
+ * niente, impedisce soltanto.
+ */
+export const MIN_DETAIL_QUERY = 1;
+const EMPTY = { occ: [], error: '' };
+/**
+ * Tutte le occorrenze di `query` in `text`, in ordine di posizione.
+ *
+ * Il testo deve essere **la stessa stringa che si renderizza**: passa da
+ * `sanitize` al confine di caricamento, e cercare su una rilettura del file
+ * produrrebbe offset che indicizzano un documento diverso da quello a schermo —
+ * evidenziazione spostata di N caratteri, senza nessun errore.
+ */
+export function scanText(text, query, opts = LITERAL) {
+    const { re, error } = buildMatcher(query, opts, MIN_DETAIL_QUERY);
+    if (!re)
+        return error ? { occ: [], error } : EMPTY;
+    const occ = [];
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        // Una regex può matchare la STRINGA VUOTA (`a*`, `^`, `\b`): `exec` non
+        // avanzerebbe `lastIndex` e il ciclo non terminerebbe mai. Un match di
+        // larghezza zero non è nemmeno evidenziabile, quindi si salta invece di
+        // registrarlo.
+        if (m[0].length === 0) {
+            re.lastIndex++;
+            continue;
+        }
+        occ.push({ start: m.index, end: m.index + m[0].length });
+    }
+    return { occ, error };
+}
+/**
+ * Taglia una riga wrappata nei pezzi da colorare, intersecando gli offset.
+ *
+ * `occ` è in ordine e senza sovrapposizioni (`exec` avanza monotono), quindi
+ * basta una passata. Il guard `a < pos` regge comunque il caso di intervalli
+ * sovrapposti passati da un chiamante futuro, senza produrre testo duplicato.
+ */
+export function sliceLine(lineText, lineStart, occ, current) {
+    const out = [];
+    let pos = 0;
+    for (let i = 0; i < occ.length; i++) {
+        const a = Math.max(0, Math.min(lineText.length, occ[i].start - lineStart));
+        const b = Math.max(0, Math.min(lineText.length, occ[i].end - lineStart));
+        if (b <= a || a < pos)
+            continue;
+        if (a > pos)
+            out.push({ text: lineText.slice(pos, a), hit: false, current: false });
+        out.push({ text: lineText.slice(a, b), hit: true, current: i === current });
+        pos = b;
+    }
+    if (pos < lineText.length) {
+        out.push({ text: lineText.slice(pos), hit: false, current: false });
+    }
+    return out;
+}
+/**
+ * Scroll che porta l'offset al CENTRO della finestra visibile.
+ *
+ * Stessa ricetta di `submitSearchRow` (T52). Centrare conta più che sembri:
+ * un'occorrenza portata in cima alla finestra arriva senza il contesto che la
+ * precede, ed è il contesto che dice se è quella giusta.
+ */
+export function topForOffset(lines, offset, capacity) {
+    const maxTop = Math.max(0, lines.length - capacity);
+    let i = lines.findIndex((l) => l.end > offset);
+    if (i < 0)
+        i = Math.max(0, lines.length - 1);
+    return Math.max(0, Math.min(maxTop, i - Math.floor(capacity / 2)));
+}

package/dist/viewport.js

@@ -57,6 +57,11 @@ 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 preview.
@@ -204,6 +209,36 @@ 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;
+// T91 — la ricerca dentro il detail: marginTop + riga del campo.
+//
+// `MODAL_HEIGHT` dice che il detail costa 0 ai due pane (li sostituisce), e da
+// lì è facile leggere «dentro l'overlay lo spazio è gratis». Le due contabilità
+// sono distinte: quella dice quanto l'overlay toglie ai PANE, questa quanto
+// toglie al PROPRIO contenuto. Una riga fissa aggiunta e non scalata è ciò che
+// fa sfondare `rows` e manda Ink nel ramo `clearTerminal`, che su VTE riversa un
+// frame nello scrollback a ogni tick del poll.
+const DETAIL_SEARCH_CHROME = 2;
+/** Righe di task file che entrano nel terminale; con la ricerca aperta il campo
+ *  si paga qui, non altrove. */
+export function detailCapacity(rows, searching = false) {
+    const extra = searching ? DETAIL_SEARCH_CHROME : 0;
+    return Math.max(0, (rows || 24) - SLACK - DETAIL_CHROME - extra);
+}
 // 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.28.0",
+  "version": "0.30.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}}"