@lamemind/loom-deck 0.30.1 → 0.32.0

package/README.md

@@ -56,7 +56,8 @@ senza collisioni:
 | Tasto | Semantica | Note |
 |---|---|---|
 | `↑` `↓` | naviga nella lista | |
-| `←` `→` `tab` | cambia pane | |
+| `tab` | cambia pane | l'unico tasto che sposta il focus |
+| `←` `→` | cambia **vista** del pane a fuoco | ciclico; il catalogo è l'header stesso |
 | `⏎` | 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 | |
@@ -166,9 +167,10 @@ 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.
 
-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.
+Dentro il detail `←→` cicla i bottoni invece di cambiare la vista del 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, e cambiare cosa fa un
+tasto fuori dal detail non tocca cosa fa dentro.
 
 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
@@ -299,6 +301,40 @@ Con un filtro attivo l'header dichiara sempre quanto sta nascondendo
 `w` la scrive in `.claude/loom/deck-view.json` (macchina-locale, da gitignorare)
 e al riavvio viene ripristinata. File assente o corrotto → default puliti.
 
+## L'header è un selettore di vista
+
+Ogni segmento dell'header nomina un sottoinsieme che il deck sa già calcolare.
+`←`/`→` lo rendono **raggiungibile**: la voce attiva si evidenzia in video
+inverso e la lista sotto mostra quel sottoinsieme.
+
+```
+Tasks (20/78) · 58 nascoste · 23 archiviabili · ↑7 · ↓9
+Sessions · tutte (317) · ●2 vive · 📌4 · +213 più vecchie · ↑7 · ↓9
+```
+
+| Pane | Viste |
+|---|---|
+| Tasks | `Tasks (n/N)` (filtri applicati) · `N nascoste` (il complemento esatto di quei filtri) · `N archiviabili` (Done oltre `archivableDays`, cieca ai filtri) |
+| Sessions | `{parent} (N)` · `●N vive` · `📌N` · `+N più vecchie` (le contestuali che il cap `maxContext` tronca) |
+
+- **Il catalogo è fisso**, anche a contatore 0 (la voce si mostra dim). Un
+  catalogo che si accorcia sposta le voci sotto le dita, e la vista corrente può
+  svanire mentre la guardi — togliere un filtro mentre sei su `nascoste`.
+- **`↑N` `↓N` non sono viste**: contano elementi fuori finestra per altezza del
+  terminale, cioè una posizione, non un insieme. Restano in coda, non selezionabili.
+- **Due assi ortogonali**: il pane task sceglie il *parent* delle conversazioni
+  (`≡ tutte` / `○ spot` / una task), l'header sceglie *quale sottoinsieme* di quel
+  parent. Cambiare parent non azzera la vista, che si ricalcola dentro il nuovo.
+- **`F` è inerte fuori dalla vista `Tasks`** e lo dice con una nota: su
+  `nascoste` riapplicare i filtri non ha senso, `archiviabili` è cieca per scelta.
+- **La vista è volatile**: non entra in `deck-view.json`, il deck riapre sempre
+  sulla voce 1. Un filtro salvato lo si è scelto; una vista non-default riaperta
+  a freddo si leggerebbe come la lista intera.
+- **Cambiare vista riporta la selezione in cima**, righe meta comprese: nessuna
+  regola di mantenimento, nessun tentativo di ritrovare l'elemento precedente.
+- Su un terminale stretto **la voce attiva è servita per prima** dal budget di
+  larghezza: sparisce un contatore, mai la voce che dice dove sei.
+
 ## Installazione
 
 ```bash

package/dist/archivable.js

@@ -106,17 +106,23 @@ async function gitOut(args, cwd) {
     }
 }
 /**
- * Quante fra le task Done passate sono oltre soglia. Le indeterminate (nessuno
+ * Quali fra le task Done passate sono oltre soglia. Le indeterminate (nessuno
  * dei tre gradini risolve) e le righe orfane (Done in tasks.md ma task file
- * assente) NON entrano nel conteggio: il deck non chiama "vecchia" una task di
- * cui non sa l'età.
+ * assente) NON entrano: il deck non chiama "vecchia" una task di cui non sa
+ * l'età.
  *
  * Riceve gli id già filtrati sul glifo Done invece della lista completa: lo
  * scan resta così proporzionale al vecchiume, non alla lunghezza della lista.
+ *
+ * T100 — ritorna gli ID e non più il solo conteggio: `archiviabili` è diventata
+ * una vista navigabile del pane task, e il numero da solo non basta più a
+ * disegnarne le righe. Il contatore dell'header è la lunghezza della lista, così
+ * ciò che si conta e ciò che si mostra restano lo stesso insieme per
+ * costruzione.
  */
-export async function countArchivable(doneIds, opts) {
+export async function archivableIds(doneIds, opts) {
     const now = opts.now ?? Date.now();
-    let n = 0;
+    const out = [];
     for (const id of doneIds) {
         const taskFile = findTaskFile(opts.tasksDir, id);
         if (!taskFile)
@@ -133,7 +139,7 @@ export async function countArchivable(doneIds, opts) {
             continue;
         const age = ageDays(iso, now);
         if (age !== null && age >= opts.days)
-            n++;
+            out.push(id);
     }
-    return n;
+    return out;
 }

package/dist/cli.js

@@ -15,7 +15,8 @@ import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, loadSessionIndex, } from './task-index.js';
 import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, rowLabel, selectedSession, sessionTitle, stripProjectCore, unpinLandingId, } from './session-list.js';
 import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
-import { countArchivable, SCAN_INTERVAL_MS } from './archivable.js';
+import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
+import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, SESSION_VIEWS, TASK_VIEWS, } from './pane-views.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';
@@ -469,22 +470,26 @@ function useSessions(projectRoot) {
 // `doneSig` è una stringa, non l'array: `tasks` cambia identità a ogni re-read
 // di tasks.md, e usarlo come dipendenza rimetterebbe lo scan sul tick da 1,5s
 // per la via di dietro.
+//
+// T100 — tiene gli ID e non più il conteggio: `archiviabili` è una vista del
+// pane, quindi servono le righe. Il contatore dell'header è `.size` dello stesso
+// insieme che disegna la lista — un numero e una lista che non possono divergere.
 function useArchivable(doneSig, tasksDir, projectRoot, days) {
-    const [count, setCount] = useState(0);
+    const [ids, setIds] = useState(() => new Set());
     useEffect(() => {
         let alive = true;
-        const ids = doneSig ? doneSig.split(',') : [];
+        const done = doneSig ? doneSig.split(',') : [];
         const scan = () => {
-            countArchivable(ids, { tasksDir, projectRoot, days })
-                .then((n) => {
+            archivableIds(done, { tasksDir, projectRoot, days })
+                .then((found) => {
                 if (alive)
-                    setCount(n);
+                    setIds(new Set(found));
             })
-                // Scan fallito (task file illeggibili, git muto) → 0, cioè segmento
-                // omesso. Un contatore informativo non merita un errore a schermo.
+                // Scan fallito (task file illeggibili, git muto) → insieme vuoto, cioè
+                // voce a 0. Un contatore informativo non merita un errore a schermo.
                 .catch(() => {
                 if (alive)
-                    setCount(0);
+                    setIds(new Set());
             });
         };
         scan();
@@ -494,7 +499,7 @@ function useArchivable(doneSig, tasksDir, projectRoot, days) {
             clearInterval(id);
         };
     }, [doneSig, tasksDir, projectRoot, days]);
-    return count;
+    return ids;
 }
 // Legge il task file della task selezionata (Q1+B T20). On-id-change: navigare
 // con ↑↓ ricarica il dettaglio; leggere un singolo file 4-9KB è I/O triviale,
@@ -622,6 +627,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // modale: la lista si aggiorna dal vivo, quindi `esc` deve poter ripristinare.
     const [view, setView] = useState(() => loadView(cwd));
     const [viewBackup, setViewBackup] = useState(null);
+    // T100 — vista attiva di ciascun pane, navigata con ←/→. VOLATILE per
+    // decisione (D3 create): non entra in `deck-view.json`, il deck riapre sempre
+    // su `Tasks` e su `{parent}`. Il criterio è il rischio di leggere una lista
+    // parziale credendola completa — un filtro salvato lo si è scelto, una vista
+    // riaperta a freddo si legge come la lista intera.
+    const [taskViewId, setTaskViewId] = useState('tasks');
+    const [sessionViewId, setSessionViewId] = useState('context');
     const [filterCursor, setFilterCursor] = useState({ row: 0, col: 0 });
     // T41 — bozza dell'edit (null fuori dal modale) e riga attiva della griglia.
     const [edit, setEdit] = useState(null);
@@ -697,15 +709,31 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const doneSig = useMemo(() => tasks.filter((t) => isDone(t.prog)).map((t) => t.id).join(','), [tasks]);
     const archivableDays = useMemo(() => loadArchivableDays(cwd), [cwd]);
     const archivable = useArchivable(doneSig, tasksDir, cwd, archivableDays);
+    // T100 — le task effettivamente a schermo: la vista principale coincide con
+    // `viewTasks` (nessun ricalcolo sul cammino di default), le altre due passano
+    // dal predicato del catalogo. I CONTATORI restano misurati sulla vista di
+    // default, o navigare cambierebbe i numeri che si sta navigando.
+    const taskCounts = {
+        filtered: viewTasks.length,
+        total: tasks.length,
+        hidden: hiddenTasks,
+        archivable: archivable.size,
+    };
+    const paneTasks = useMemo(() => taskViewId === 'tasks'
+        ? viewTasks
+        : selectTasks(tasks, taskViewId, { view, archivable }), [taskViewId, viewTasks, tasks, view, archivable]);
     const isSpot = sel === SPOT;
     const isAll = sel === ALL;
     const projectName = cwd.split('/').pop() || cwd;
     // Unica fonte della selezione: si legge SEMPRE dalla vista, mai dall'array
     // grezzo — è l'invariante che tiene allineati dettaglio mostrato e spawn.
-    const selTask = typeof sel === 'string' ? viewTasks.find((t) => t.id === sel) ?? null : null;
+    const selTask = typeof sel === 'string' ? paneTasks.find((t) => t.id === sel) ?? null : null;
     const selectedTaskId = selTask?.id ?? null;
-    const selIndex = selTask ? viewTasks.indexOf(selTask) + META_ROWS : isAll ? ROW_ALL : ROW_SPOT;
+    const selIndex = selTask ? paneTasks.indexOf(selTask) + META_ROWS : isAll ? ROW_ALL : ROW_SPOT;
     const detail = useTaskDetail(tasksDir, selectedTaskId ?? undefined);
+    // Il parent delle conversazioni: l'asse che sceglie il pane task, ortogonale
+    // alla vista che sceglie l'header (D2 create).
+    const parentLabel = isAll ? 'tutte' : isSpot ? 'spot' : selectedTaskId ?? '—';
     // Conteggio figli per task + spot (badge nel Tasks pane).
     const childCount = new Map();
     let spotCount = 0;
@@ -731,12 +759,24 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // contestuali. Dedup, cap solo sulle contestuali, righe stale per le pinnate
     // orfane. Core PURO in session-list.ts (testabile senza Ink).
     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]);
+    // T100 — «intera» ora vuol dire la lista della vista di DEFAULT (`assembled`),
+    // non quella a schermo: il contatore di una voce del catalogo non può
+    // dipendere da quale voce è selezionata, o navigare muoverebbe i numeri.
+    const liveCount = useMemo(() => assembled.rows.filter((r) => r.kind !== 'separator' && live.has(r.sessionId)).length, [assembled, live]);
+    const sessionCounts = {
+        total: assembled.pinnedCount + assembled.contextTotal,
+        live: liveCount,
+        pinned: assembled.pinnedCount,
+        older: assembled.contextHidden,
+    };
+    // T100 — le righe a schermo sono quelle della vista attiva. Fuori dalla vista
+    // di default il separatore non c'è: segna il confine fra pinnate e
+    // contestuali, e in un sottoinsieme quel confine non esiste più.
+    const sessionRows = useMemo(() => selectSessionRows(sessionViewId, { assembled, isLive: (id) => live.has(id) }), [sessionViewId, assembled, live]);
+    const selSessionObj = selectedSession(sessionRows, selSessionId);
     // 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.
@@ -849,10 +889,10 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // dalla vista (filtro appena attivato, oppure sparita da tasks.md), si cade
     // sulla prima visibile — fallback deterministico, mai una posizione a caso.
     useEffect(() => {
-        if (typeof sel === 'string' && !viewTasks.some((t) => t.id === sel)) {
-            setSel(viewTasks[0]?.id ?? ALL);
+        if (typeof sel === 'string' && !paneTasks.some((t) => t.id === sel)) {
+            setSel(paneTasks[0]?.id ?? ALL);
         }
-    }, [viewTasks, sel]);
+    }, [paneTasks, sel]);
     // T50 — la selezione (id) resta valida sotto la vista a due gruppi: se l'id
     // non è più una riga selezionabile (cambio parent, lista mutata, pin rimosso,
     // sessione sparita) cade sulla prima riga — fallback deterministico, mai una
@@ -935,7 +975,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // messaggi a mano. `verb` è l'unica cosa che cambia fra i due usi.
     function selectedTaskOr(keyLabel, verb) {
         if (focus !== 'tasks') {
-            setNote(`${keyLabel} → ${verb}: seleziona una task (←→ per il pane)`);
+            setNote(`${keyLabel} → ${verb}: seleziona una task (tab per il pane)`);
             return null;
         }
         // T59 — la guardia è "non è una task", non "è spot": le righe meta sono due
@@ -1178,13 +1218,33 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // 2..N+1 = task visibili) e la riconverte subito in sentinella o id: l'indice
     // non sopravvive a un cambio di filtro, l'id sì.
     function moveTaskSel(delta) {
-        const next = Math.max(0, Math.min(viewTasks.length + META_ROWS - 1, selIndex + delta));
+        const next = Math.max(0, Math.min(paneTasks.length + META_ROWS - 1, selIndex + delta));
         if (next === ROW_ALL)
             setSel(ALL);
         else if (next === ROW_SPOT)
             setSel(SPOT);
         else
-            setSel(viewTasks[next - META_ROWS]?.id ?? SPOT);
+            setSel(paneTasks[next - META_ROWS]?.id ?? SPOT);
+    }
+    // T100 — ←/→ navigano il catalogo viste del pane in focus. Il reset della
+    // selezione è la regola letterale «prima riga in alto», senza eccezioni: sul
+    // pane task è `ROW_ALL` (D2 preflight — le righe meta non si saltano, e il
+    // parent delle sessioni che torna a `tutte` è un effetto accettato); sul pane
+    // sessioni basta invalidare l'id, e l'effect di validità atterra sulla prima
+    // riga selezionabile della vista nuova.
+    function cycleView(delta) {
+        if (focus === 'tasks') {
+            const next = cycleTaskView(taskViewId, delta);
+            setTaskViewId(next);
+            setSel(ALL);
+            setNote(`vista task: ${taskView(next).label(taskCounts)}`);
+        }
+        else {
+            const next = cycleSessionView(sessionViewId, delta);
+            setSessionViewId(next);
+            setSelSessionId(null);
+            setNote(`vista sessioni: ${sessionView(next).label(sessionCounts, parentLabel)}`);
+        }
     }
     // T52 — `⏎` contestuale al TIPO di riga: la lista ne mescola due e l'azione
     // giusta dipende da quale è selezionata. Riga sessione → resume, identico al
@@ -1718,9 +1778,18 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             return;
         }
-        if (key.leftArrow || key.rightArrow || key.tab) {
+        if (key.tab) {
+            // T100 — `tab` resta l'unico tasto che sposta il focus fra i due pane. Le
+            // frecce orizzontali facevano lo stesso lavoro (due tasti per un'azione)
+            // mentre la navigazione DENTRO un pane non ne aveva nessuno: ora sono il
+            // selettore di vista dell'header. Il ramo `mode === 'detail'`, anteposto e
+            // chiuso da `return`, non è più l'eccezione a «cambia pane» ma a «cambia
+            // vista» — l'ordine dei rami non cambia, cambia cosa cattura.
             setFocus((f) => (f === 'tasks' ? 'sessions' : 'tasks'));
         }
+        else if (key.leftArrow || key.rightArrow) {
+            cycleView(key.leftArrow ? -1 : 1);
+        }
         else if (key.upArrow) {
             if (focus === 'tasks')
                 moveTaskSel(-1);
@@ -1775,9 +1844,20 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setMode('sort');
         }
         else if (input === 'F') {
-            setViewBackup(view);
-            setNote('');
-            setMode('filter');
+            // T100/D3 — i filtri valgono SOLO sulla vista principale: su `nascoste`
+            // riapplicarli non ha senso (quella vista È il loro complemento), su
+            // `archiviabili` non li si vuole (è cieca ai filtri per decisione). Stessa
+            // forma dell'inerzia di ^K/^P/^R dentro il detail, ma keyed sulla vista
+            // invece che sul modo — e come là, l'inerzia lo DICE invece di non fare
+            // niente in silenzio.
+            if (taskViewId !== 'tasks') {
+                setNote(`F → filtri: solo sulla vista ${TASK_VIEWS[0].label(taskCounts)} (ora: ${taskView(taskViewId).label(taskCounts)})`);
+            }
+            else {
+                setViewBackup(view);
+                setNote('');
+                setMode('filter');
+            }
         }
         else if (input === 'f') {
             // T28 — fork della sessione selezionata. Minuscola come `t`/`c` (T39):
@@ -1785,7 +1865,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // Vive solo sul pane sessioni: il fork ha per oggetto una conversazione,
             // e senza focus lì non ce n'è una selezionata su cui agire.
             if (focus !== 'sessions') {
-                setNote('f → fork: seleziona una sessione (←→ per il pane)');
+                setNote('f → fork: seleziona una sessione (tab per il pane)');
             }
             else {
                 const s = selSessionObj;
@@ -1817,7 +1897,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // pinnata STALE (l'unico modo di spinnarla). Scrive il sidecar e ricarica
             // subito, senza attendere il tick del poll.
             if (focus !== 'sessions') {
-                setNote('p → pin: seleziona una sessione (←→ per il pane)');
+                setNote('p → pin: seleziona una sessione (tab per il pane)');
             }
             else if (!selSessionId) {
                 setNote('p → nessuna sessione da pinnare');
@@ -1845,7 +1925,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // su una pinnata STALE, perché annotare «questa non c'è più, era X» è
             // proprio il caso in cui una nota serve.
             if (focus !== 'sessions') {
-                setNote('N → nota: seleziona una sessione (←→ per il pane)');
+                setNote('N → nota: seleziona una sessione (tab per il pane)');
             }
             else if (!selSessionId) {
                 setNote('N → nessuna sessione da annotare');
@@ -1863,7 +1943,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // il binding è nostro, il transcript è di CC — riassegnare una
             // conversazione il cui transcript non c'è più resta legittimo.
             if (focus !== 'sessions') {
-                setNote('A → assegna: seleziona una sessione (←→ per il pane)');
+                setNote('A → assegna: seleziona una sessione (tab per il pane)');
             }
             else if (!selSessionId) {
                 setNote('A → nessuna sessione da assegnare');
@@ -1912,7 +1992,6 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             exit();
         }
     });
-    const parentLabel = isAll ? 'tutte' : isSpot ? 'spot' : selectedTaskId ?? '—';
     const canSpawn = focus === 'tasks' && selTask !== null;
     const canResume = focus === 'sessions' && selSessionObj !== null;
     // T50 — il pin agisce su qualunque riga selezionata (anche stale, per
@@ -2062,8 +2141,8 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // Finestre di rendering. Le liste "logiche" (viewTasks, sessionRows)
     // restano intere: navigazione, selezione e spawn continuano a ragionare su
     // quelle, la finestra è solo ciò che finisce a schermo.
-    const taskWin = windowRange(viewTasks.length, selIndex - META_ROWS, budget.taskRows);
-    const windowTasks = viewTasks.slice(taskWin.start, taskWin.end);
+    const taskWin = windowRange(paneTasks.length, selIndex - META_ROWS, budget.taskRows);
+    const windowTasks = paneTasks.slice(taskWin.start, taskWin.end);
     const selRowIndex = rowIndexOf(sessionRows, selSessionId);
     const sessionWin = windowRange(sessionRows.length, selRowIndex, budget.sessionRows);
     const windowRows = sessionRows.slice(sessionWin.start, sessionWin.end);
@@ -2073,7 +2152,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, 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] }));
+    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, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
 // Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
@@ -2375,24 +2454,39 @@ function AssignScreen({ sessionId, label, current, filter, rows, selected, match
  * scoprirlo sarebbe il bordo del pane a schermo.
  *
  * `truncate-end` taglia dalla coda, e `cutParts` conserva l'ordine: l'ultimo
- * segmento resta il primo a cedere il posto (vedi T61 sotto, `archiviabili` in
- * coda ai contatori della vista corrente).
+ * segmento resta il primo a cedere il posto (`↑↓` in coda alle voci navigabili).
+ *
+ * T100 — la riga non è più informativa: le voci del catalogo sono SELEZIONABILI
+ * con ←/→, e l'attiva si distingue in video inverso (D5 — costa 0 colonne e non
+ * entra in gara con la semantica di colore già occupata). Le voci ci sono tutte
+ * anche a 0 (D1): un catalogo che si accorcia sposta le voci sotto le dita.
+ * L'ordine è vincolato — le navigabili PRIMA di `↑N`/`↓N`, che cadono per primi
+ * su un terminale stretto — e la voce attiva ha la precedenza sul budget (D6).
  */
-function TasksHeader({ filtered, total, hidden, above, below, archivable, focused, columns, }) {
+function TasksHeader({ counts, active, above, below, focused, columns, }) {
+    const views = TASK_VIEWS.map((v, i) => {
+        const n = v.count(counts);
+        return {
+            // Il separatore sta nel segmento, non fra i segmenti: `cutParts` misura la
+            // riga pezzo per pezzo e uno spazio fuori dai pezzi non verrebbe contato.
+            text: `${i > 0 ? ' · ' : ''}${v.label(counts)}`,
+            color: v.color,
+            dim: v.dim || n === 0,
+            active: v.id === active,
+        };
+    });
     const segments = [
-        { text: `Tasks (${hidden > 0 ? `${filtered}/${total}` : filtered})` },
-        ...(hidden > 0 ? [{ text: ` · ${hidden} nascoste`, color: 'yellow' }] : []),
-        ...(above > 0 ? [{ text: ` · ↑${above}`, dim: true }] : []),
-        ...(below > 0 ? [{ text: ` · ↓${below}`, dim: true }] : []),
-        ...(archivable > 0 ? [{ text: ` · ${archivable} archiviabili`, dim: true }] : []),
+        ...views,
+        { text: above > 0 ? ` · ↑${above}` : '', dim: true, active: false, color: undefined },
+        { text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false, color: undefined },
     ];
-    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) }));
+    const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns), segments.findIndex((s) => s.active));
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
 }
-function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, archivable, }) {
+function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, }) {
     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)}` +
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(TasksHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
                     (view.hiddenPri.length + view.hiddenProg.length > 0
                         ? ' · filtri: ' +
                             [
@@ -2401,7 +2495,12 @@ function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount,
                             ]
                                 .map((e) => `−${e.glyph}`)
                                 .join(' ')
-                        : '')), paneTextWidth(columns)) }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", allCount > 0 ? ` (${allCount})` : ''] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : (tasks.map((task, i) => {
+                        : '')), paneTextWidth(columns)) }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", allCount > 0 ? ` (${allCount})` : ''] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : paneCount === 0 ? (
+            // T100/D1 — una voce a contatore 0 resta navigabile, e selezionarla dà
+            // una lista vuota che DICE perché è vuota. Senza la nota il pane si
+            // legge come rotto: le righe meta restano, le task no, e niente spiega
+            // che è la vista scelta a non contenere nulla.
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(taskView(activeView).empty, paneTextWidth(columns)) })) : (tasks.map((task, i) => {
                 // windowStart riporta l'indice di finestra a quello della lista
                 // completa, su cui è keyata la selezione. +META_ROWS: le prime due
                 // righe sono le meta.
@@ -2432,24 +2531,39 @@ 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, liveCount, hidden, above, below, focused, columns, }) {
+function SessionsHeader({ parentLabel, counts, active, above, below, focused, columns, }) {
+    const views = SESSION_VIEWS.map((v) => {
+        const n = v.count(counts);
+        return {
+            text: ` · ${v.label(counts, parentLabel)}`,
+            color: v.color,
+            dim: v.dim || n === 0,
+            active: v.id === active,
+        };
+    });
     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 }] : []),
-        ...(below > 0 ? [{ text: ` · ↓${below}`, dim: true }] : []),
+        // `Sessions` non è una voce del catalogo: nomina il pane, non un
+        // sottoinsieme, quindi non è raggiungibile con le frecce.
+        { text: 'Sessions', color: undefined, dim: false, active: false },
+        ...views,
+        { text: above > 0 ? ` · ↑${above}` : '', dim: true, active: false, color: undefined },
+        { text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false, color: undefined },
     ];
-    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) }));
+    const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns), segments.findIndex((s) => s.active));
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
 }
-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'
-                        : 'nessuna sessione legata a questa task' })) : (rows.map((row, i) => {
+function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows, counts, activeView, paneCount, selectedId, focused, above, below, columns, forkOf, sessionNotes, projectCore, live, }) {
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(SessionsHeader, { parentLabel: parentLabel, counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), paneCount === 0 ? (
+            // T100 — la nota della vista di default resta quella storica, che nomina
+            // il PARENT (task, spot o tutte); le altre tre viste portano la propria,
+            // che nomina il sottoinsieme. Sono due vuoti diversi: «questo parent non
+            // ha conversazioni» e «questo sottoinsieme del parent è vuoto».
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(sessionView(activeView).empty ??
+                    (isAll
+                        ? 'nessuna conversazione nel progetto'
+                        : isSpot
+                            ? 'nessuna sessione libera'
+                            : 'nessuna sessione legata a questa task'), paneTextWidth(columns)) })) : (rows.map((row, i) => {
                 // T50 — separatore leggero fra pinnate e contestuali: riga dim, non un
                 // box pesante (coerente con lo styling delle Done dimmate).
                 if (row.kind === 'separator') {

package/dist/pane-views.js

@@ -0,0 +1,135 @@
+// T100 — Catalogo delle viste dei due pane. L'header smette di essere una riga
+// di contatori e diventa un SELETTORE: ogni segmento che nomina un sottoinsieme
+// calcolabile (`nascoste`, `archiviabili`, `vive`, `📌`, `+più vecchie`) è una
+// vista raggiungibile con ←/→.
+//
+// Modulo PURO: nessun import da ink/react, nessun I/O. Il calcolo resta dove
+// stava — `view.ts` per i filtri task, `session-list.ts` per l'assemblaggio a
+// due gruppi — qui c'è solo la mappa di quali sottoinsiemi esistono, come si
+// chiamano e con che numero.
+//
+// Invarianti (decisioni congelate al create-task e al preflight):
+//  - D1 create — catalogo FISSO: le voci ci sono tutte anche a contatore 0. Un
+//    catalogo che si accorcia quando un numero va a zero sposta le voci sotto le
+//    dita e può far svanire la vista corrente mentre la guardi (togliere un
+//    filtro mentre sei su `nascoste`).
+//  - D1 preflight — navigazione CICLICA, come `DETAIL_ACTIONS` e le righe di
+//    scelta del modale edit.
+//  - Il numero di una voce si misura SEMPRE sulla vista di default, mai su
+//    quella attiva: altrimenti navigare cambierebbe i contatori che si sta
+//    navigando, e il catalogo tornerebbe dinamico per la via di dietro.
+//  - `↑N`/`↓N` non stanno qui: contano elementi fuori finestra per altezza del
+//    terminale, cioè una POSIZIONE, non un insieme.
+import { isVisible, compareTasks } from './view.js';
+export const TASK_VIEWS = [
+    {
+        id: 'tasks',
+        label: (c) => `Tasks (${c.hidden > 0 ? `${c.filtered}/${c.total}` : c.filtered})`,
+        count: (c) => c.filtered,
+        has: (t, ctx) => isVisible(t, ctx.view),
+        empty: 'nessuna task in vista: i filtri le escludono tutte',
+    },
+    {
+        // `yellow` come prima: avverte che la vista è distorta da un filtro.
+        id: 'hidden',
+        label: (c) => `${c.hidden} nascoste`,
+        count: (c) => c.hidden,
+        has: (t, ctx) => !isVisible(t, ctx.view),
+        color: 'yellow',
+        empty: 'nessuna task nascosta: nessun filtro ne esclude',
+    },
+    {
+        // T61 — dim: le Done oltre soglia non alterano ciò che stai guardando.
+        id: 'archivable',
+        label: (c) => `${c.archivable} archiviabili`,
+        count: (c) => c.archivable,
+        has: (t, ctx) => ctx.archivable.has(t.id),
+        dim: true,
+        empty: "nessuna Done oltre la soglia d'età",
+    },
+];
+/**
+ * Le task della vista `id`, filtrate col predicato e ordinate con la chain
+ * corrente. L'ordinamento vale per ogni vista, non solo la principale: una lista
+ * di task ordinata in un modo e l'altra in un altro sarebbe un secondo asse che
+ * si muove da solo.
+ */
+export function selectTasks(tasks, id, ctx) {
+    const entry = taskView(id);
+    const picked = tasks.filter((t) => entry.has(t, ctx));
+    picked.sort((a, b) => compareTasks(a, b, ctx.view.sort));
+    return picked;
+}
+/** Glifo della sessione viva, gemello di `LIVE_IDLE` del render. Duplicato qui
+ *  perché il catalogo è puro e non può importare da `cli.tsx`; è un carattere
+ *  concorde (largo 1 per entrambe le contabilità), quindi non passa da
+ *  `sanitize`. */
+const LIVE_GLYPH = '●';
+/** Righe selezionabili della lista assemblata (il separatore non è una riga di
+ *  contenuto: fuori dalla vista di default i due gruppi non ci sono più). */
+function selectable(rows) {
+    return rows.filter((r) => r.kind !== 'separator');
+}
+export const SESSION_VIEWS = [
+    {
+        id: 'context',
+        label: (c, parent) => `${parent} (${c.total})`,
+        count: (c) => c.total,
+        rows: (ctx) => ctx.assembled.rows,
+        empty: null,
+    },
+    {
+        id: 'live',
+        label: (c) => `${LIVE_GLYPH}${c.live} vive`,
+        count: (c) => c.live,
+        rows: (ctx) => selectable(ctx.assembled.rows).filter((r) => ctx.isLive(r.sessionId)),
+        color: 'green',
+        empty: 'nessuna conversazione viva in questa lista',
+    },
+    {
+        id: 'pinned',
+        label: (c) => `📌${c.pinned}`,
+        count: (c) => c.pinned,
+        rows: (ctx) => ctx.assembled.rows.filter((r) => r.kind === 'pinned'),
+        color: 'yellow',
+        empty: 'nessuna conversazione pinnata',
+    },
+    {
+        // D4 preflight — la coda troncata, non la lista intera senza cap: il numero
+        // dell'header e il numero di righe devono coincidere.
+        id: 'older',
+        label: (c) => `+${c.older} più vecchie`,
+        count: (c) => c.older,
+        rows: (ctx) => ctx.assembled.contextOverflow.map((s) => ({
+            kind: 'context',
+            sessionId: s.sessionId,
+            session: s,
+        })),
+        dim: true,
+        empty: 'nessuna conversazione oltre il cap',
+    },
+];
+export function selectSessionRows(id, ctx) {
+    return sessionView(id).rows(ctx);
+}
+// ── lookup e navigazione ───────────────────────────────────────────────────
+export function taskView(id) {
+    return TASK_VIEWS.find((v) => v.id === id) ?? TASK_VIEWS[0];
+}
+export function sessionView(id) {
+    return SESSION_VIEWS.find((v) => v.id === id) ?? SESSION_VIEWS[0];
+}
+/** Scorrimento ciclico del catalogo: `→` sull'ultima voce torna alla prima. Id
+ *  ignoto → prima voce, mai un indice negativo. */
+function cycle(catalog, current, delta) {
+    const at = catalog.findIndex((v) => v.id === current);
+    if (at < 0)
+        return catalog[0];
+    return catalog[(at + delta + catalog.length) % catalog.length];
+}
+export function cycleTaskView(current, delta) {
+    return cycle(TASK_VIEWS, current, delta).id;
+}
+export function cycleSessionView(current, delta) {
+    return cycle(SESSION_VIEWS, current, delta).id;
+}

package/dist/session-list.js

@@ -134,7 +134,9 @@ export function assembleSessionList(childSessions, allSessions, pinned, maxConte
     });
     const pinnedSet = new Set(pinnedIds);
     const dedupedContext = childSessions.filter((s) => !pinnedSet.has(s.sessionId));
-    const shownContext = dedupedContext.slice(0, Math.max(0, maxContext));
+    const cap = Math.max(0, maxContext);
+    const shownContext = dedupedContext.slice(0, cap);
+    const overflowContext = dedupedContext.slice(cap);
     const contextRows = shownContext.map((s) => ({
         kind: 'context',
         sessionId: s.sessionId,
@@ -150,7 +152,8 @@ export function assembleSessionList(childSessions, allSessions, pinned, maxConte
         rows,
         pinnedCount: pinnedRows.length,
         contextTotal: dedupedContext.length,
-        contextHidden: dedupedContext.length - shownContext.length,
+        contextHidden: overflowContext.length,
+        contextOverflow: overflowContext,
     };
 }
 function isSelectable(r) {

package/dist/task-edit.js

@@ -3,7 +3,7 @@
 // isolata in `writeTaskEdit`, così la grammatica delle sostituzioni è testabile
 // senza toccare il filesystem.
 import { readFileSync, writeFileSync } from 'node:fs';
-import { TASK_ID_RE, findTaskFile } from './tasks.js';
+import { TASK_ID_RE, findTaskFile, headerColumns } from './tasks.js';
 // Il task file scrive la priorità per NOME (`- **Priority**: Med`), tasks.md la
 // scrive come GLIFO (colonna Pri). Due rappresentazioni dello stesso valore →
 // due mappe, entrambe keyed sul nome canonico di view.ts (unica fonte del rango).
@@ -75,31 +75,38 @@ export function initialDetail(current, prog, date = today()) {
     return stripProgGlyph(s);
 }
 /**
- * Riscrive le celle Pri (col 2), Prog (col 4) e — se `desc` è passata — la
- * descrizione (col 5) della riga `| Tnn | … |` in tasks.md. Solo la PRIMA riga
- * con quell'id — l'overview è unica, un secondo match sarebbe un duplicato da
- * non propagare. Le celle non toccate restano i token grezzi originali: nessun
- * re-flow della tabella, il diff resta di una riga. `ok:false` = id assente →
- * il chiamante non scrive nulla.
+ * Riscrive le celle Pri, Prog e — se `desc` è passata — la descrizione della
+ * riga `| Tnn | … |` in tasks.md. Solo la PRIMA riga con quell'id — l'overview
+ * è unica, un secondo match sarebbe un duplicato da non propagare. Le celle non
+ * toccate restano i token grezzi originali: nessun re-flow della tabella, il
+ * diff resta di una riga. `ok:false` = id assente → il chiamante non scrive nulla.
+ *
+ * Le posizioni vengono dall'HEADER (`headerColumns`, stessa fonte di
+ * `parseTasks`), mai da un indice cablato: qui si SCRIVE su disco, quindi una
+ * colonna in più o in meno non produrrebbe una lettura sbagliata ma un titolo
+ * sovrascritto col glifo. Header assente → `ok:false`, non si tira a indovinare.
  *
  * `desc` undefined ≠ `desc` vuota: la prima non tocca la cella (chiamata
  * legacy, solo pri/prog), la seconda la svuota davvero.
  *
  * La descrizione è l'ULTIMA colonna e può contenere `|` — che in una tabella
  * markdown spezza la cella. Riscriverla significa quindi collassare tutte le
- * celle da 5 fino alla penultima in una sola (`splice`), altrimenti i pezzi
- * della vecchia descrizione resterebbero appesi in coda alla nuova.
+ * celle da `cols.desc` fino alla penultima in una sola (`splice`), altrimenti i
+ * pezzi della vecchia descrizione resterebbero appesi in coda alla nuova.
  *
  * L'id deve rispettare `TASK_ID_RE` (importato da tasks.ts — stesso gate di
  * `parseTasks`, non una copia): senza, un id arbitrario matcherebbe la riga di
- * HEADER (`| ID | Pri | K | Prog |`) o quella di separatore, riscrivendone le
- * celle e sfondando la tabella.
+ * separatore, riscrivendone le celle e sfondando la tabella.
  */
 export function updateTasksMdRow(content, id, priGlyph, progGlyph, desc) {
     if (!TASK_ID_RE.test(id))
         return { content, ok: false };
+    const lines = content.split('\n');
+    const cols = lines.reduce((found, l) => found ?? headerColumns(l), null);
+    if (!cols)
+        return { content, ok: false };
     let ok = false;
-    const lines = content.split('\n').map((line) => {
+    const out = lines.map((line) => {
         if (ok)
             return line;
         if (!line.trim().startsWith('|'))
@@ -107,20 +114,21 @@ export function updateTasksMdRow(content, id, priGlyph, progGlyph, desc) {
         const cells = line.split('|');
         if ((cells[1] ?? '').trim() !== id)
             return line;
-        if (cells.length < 6)
+        // Serve la cella desc PIÙ la coda dopo il `|` finale: senza la coda lo
+        // splice inserirebbe invece di sostituire.
+        if (cells.length < cols.desc + 2)
             return line; // riga malformata → non toccarla
         ok = true;
-        cells[2] = ` ${priGlyph} `;
-        cells[4] = ` ${progGlyph} `;
+        cells[cols.pri] = ` ${priGlyph} `;
+        cells[cols.prog] = ` ${progGlyph} `;
         if (desc !== undefined) {
-            // Da cells[5] fino alla penultima: l'ultima è la coda dopo il `|` finale
-            // (stringa vuota su una riga ben formata) e va conservata, o la riga
-            // perderebbe il proprio bordo destro.
-            cells.splice(5, cells.length - 6, ` ${sanitizeCell(desc)} `);
+            // L'ultima cella è la coda dopo il `|` finale (stringa vuota su una riga
+            // ben formata) e va conservata, o la riga perderebbe il bordo destro.
+            cells.splice(cols.desc, cells.length - cols.desc - 1, ` ${sanitizeCell(desc)} `);
         }
         return cells.join('|');
     });
-    return { content: ok ? lines.join('\n') : content, ok };
+    return { content: ok ? out.join('\n') : content, ok };
 }
 /**
  * Rende un testo scrivibile dentro una CELLA di tabella markdown. Due caratteri
@@ -139,11 +147,10 @@ function sanitizeCell(s) {
  * ricompare nel body (residuo template) vince quello dell'header — così ciò che
  * il deck mostra e ciò che scrive restano la stessa riga.
  *
- * L'H1 conserva il proprio CAPPELLO (`# Task: …` code, `# Doc Task: …` doc):
- * `parseTaskDetail` lo strippa in lettura, quindi il titolo che arriva dal
- * modale non ce l'ha e riscrivere la riga nuda perderebbe la categoria. Il
- * prefisso si rilegge dalla riga esistente e si ri-antepone tale e quale — così
- * una T resta `# Task:` e una D resta `# Doc Task:` senza doverlo sapere qui.
+ * L'H1 conserva il proprio CAPPELLO (`# Task: …`): `parseTaskDetail` lo strippa
+ * in lettura, quindi il titolo che arriva dal modale non ce l'ha e riscrivere la
+ * riga nuda lo perderebbe. Si rilegge dalla riga esistente e si ri-antepone tale
+ * e quale, così un file senza cappello resta senza.
  */
 export function updateTaskFileFields(content, priLabel, progress, title) {
     let priDone = false;
@@ -152,7 +159,7 @@ export function updateTaskFileFields(content, priLabel, progress, title) {
     const lines = content.split('\n').map((line) => {
         if (title !== undefined && !titleDone && /^#\s+/.test(line)) {
             titleDone = true;
-            const prefix = line.match(/^#\s+((?:Doc\s+)?Task:\s*)/)?.[1] ?? '';
+            const prefix = line.match(/^#\s+(Task:\s*)/)?.[1] ?? '';
             return `# ${prefix}${title.replace(/\s+/g, ' ').trim()}`;
         }
         if (!priDone && /^-\s*\*\*Priority\*\*:/.test(line)) {

package/dist/tasks.js

@@ -2,12 +2,12 @@ import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { sanitize } from './width.js';
 /**
- * Forma di un ID task: `T` (code) o `D` (doc) + numero. FONTE UNICA del gate —
- * `parseTasks` lo usa per scartare header/separatore della tabella, `task-edit`
- * per non riscrivere per sbaglio quelle stesse righe. Tenerlo in un posto solo
- * evita che i due gate divergano (uno accetterebbe righe che l'altro rifiuta).
+ * Forma di un ID task: `T` + numero. FONTE UNICA del gate — `parseTasks` lo usa
+ * per scartare header/separatore della tabella, `task-edit` per non riscrivere
+ * per sbaglio quelle stesse righe. Tenerlo in un posto solo evita che i due gate
+ * divergano (uno accetterebbe righe che l'altro rifiuta).
  */
-export const TASK_ID_RE = /^[TD]\d+$/;
+export const TASK_ID_RE = /^T\d+$/;
 // D1 (preflight T20): default docs/tasks.md, override della docs-root via env
 // LOOM_DECK_DOCS_ROOT (es. questo progetto usa `runtime`). No auto-detect.
 export function resolveTasksPath(cwd = process.cwd()) {
@@ -19,15 +19,50 @@ export function resolveTasksPath(cwd = process.cwd()) {
 export function resolveTasksDir(cwd = process.cwd()) {
     return join(dirname(resolveTasksPath(cwd)), 'tasks');
 }
-// Estrae le righe `| Tnn | Pri | K | Prog | Task |` della Tasks Overview.
-// Due prefissi ammessi (contratto plugin, counter separati): `T` = code task,
-// `D` = doc task. Le D entrano in lista come le T perché `deck-run` NON inietta
-// `run-task`: il prompt iniziale è un recap diretto ("recap stato task <id>"),
-// valido identico su una doc task. Righe header/separatore non matchano `^[TD]\d+$`
-// → scartate.
+/**
+ * Indici di colonna della Tasks Overview letti dall'HEADER, non cablati.
+ *
+ * Cablarli lega il parser al NUMERO di colonne invece che al loro nome: toglierne
+ * una fa scivolare tutto di uno e il deck legge la cella sbagliata **senza
+ * sollevare un errore** — la descrizione finisce dove si cerca il glifo di
+ * progresso, e `updateTasksMdRow` riscrive quella posizione su disco. È la stessa
+ * trappola già nota sull'indice di RIGA (selezione keyed su id, mai su posizione),
+ * applicata all'indice di colonna.
+ *
+ * Solo `pri` e `prog` si cercano per nome; la descrizione è per costruzione la
+ * colonna successiva a Prog, quindi rinominarla non rompe il parse. `null` = la
+ * riga non è l'header — l'header della tabella Lane (`| Lane | …`) cade qui.
+ */
+export function headerColumns(line) {
+    const t = line.trim();
+    if (!t.startsWith('|'))
+        return null;
+    const cells = t.split('|').map((c) => c.trim().toLowerCase());
+    if (cells[1] !== 'id')
+        return null;
+    const pri = cells.indexOf('pri');
+    const prog = cells.indexOf('prog');
+    if (pri < 0 || prog < 0)
+        return null;
+    return { pri, prog, desc: prog + 1 };
+}
+// Estrae le righe `| Tnn | Pri | Prog | Task |` della Tasks Overview. Righe
+// header/separatore non matchano `^T\d+$` → scartate.
+//
+// Le righe si parsano solo DOPO aver incontrato l'header: senza indici derivati
+// non si tira a indovinare, la lista resta vuota. Un fallimento visibile invece
+// di una cella letta al posto sbagliato.
 export function parseTasks(content) {
     const tasks = [];
+    let cols = null;
     for (const line of content.split('\n')) {
+        const header = headerColumns(line);
+        if (header) {
+            cols = header;
+            continue;
+        }
+        if (!cols)
+            continue;
         const t = line.trim();
         if (!t.startsWith('|'))
             continue;
@@ -36,12 +71,10 @@ export function parseTasks(content) {
         const id = cells[1];
         if (!TASK_ID_RE.test(id))
             continue;
-        // Colonne overview: | ID | Pri | K | Prog | Task | → cells[2]=Pri (icona
-        // priorità), cells[4]=Prog. K (Kind, cells[3]) non serve al deck.
-        const pri = cells[2] ?? '';
-        const prog = cells[4] ?? '';
+        const pri = cells[cols.pri] ?? '';
+        const prog = cells[cols.prog] ?? '';
         // desc = colonna finale; join per resistere a eventuali `|` nella descrizione.
-        const desc = cells.slice(5, -1).join('|').trim();
+        const desc = cells.slice(cols.desc, -1).join('|').trim();
         // Sanificazione AL CONFINE: tutto ciò che entra da tasks.md è testo
         // arbitrario e può contenere glifi che Ink e il terminale misurano in modo
         // diverso (vedi `width.ts`). Farlo qui invece che a ogni sito di render è
@@ -87,10 +120,9 @@ export function parseTaskDetail(id, content) {
     let inDesc = false;
     for (const line of content.split('\n')) {
         if (!title && line.startsWith('# ')) {
-            // I due template scrivono H1 diversi — `# Task: …` (code) e
-            // `# Doc Task: …` (doc): entrambi i cappelli vanno via, il titolo mostrato
-            // è la descrizione, non la sua categoria (già data dall'id).
-            title = line.replace(/^#\s+/, '').replace(/^(?:Doc\s+)?Task:\s*/, '').trim();
+            // Il cappello `Task:` del template va via: il titolo mostrato è la
+            // descrizione, non la categoria (già data dall'id).
+            title = line.replace(/^#\s+/, '').replace(/^Task:\s*/, '').trim();
             continue;
         }
         if (line.startsWith('## ')) {

package/dist/view.js

@@ -53,16 +53,11 @@ export function progRank(glyph) {
     return PROG_TABLE.find((e) => e.glyph === g)?.rank ?? UNKNOWN_RANK;
 }
 // `T10`.localeCompare(`T9`) mette T10 prima: l'ID va confrontato NUMERICO.
-// parseTasks ammette due prefissi con counter SEPARATI (`T` code, `D` doc) →
-// il solo numero non basta, T01 e D01 collidono. Il prefisso pesa quindi come
-// cifra più significativa (T prima di D, blocco doc in coda), il numero come
-// meno significativa: il rango resta un intero singolo, quindi il comparator
-// della chain non cambia forma. Il gap 1e6 è oltre qualunque counter reale.
+// Prefisso unico → il numero è già una chiave totale, e il rango è il numero.
 // Un id fuori forma non deve far esplodere il comparator → coda con MAX_SAFE.
-const ID_PREFIX_RANK = { T: 0, D: 1 };
 export function idNum(id) {
-    const m = /^([TD])(\d+)$/.exec(id);
-    return m ? ID_PREFIX_RANK[m[1]] * 1_000_000 + Number(m[2]) : Number.MAX_SAFE_INTEGER;
+    const m = /^T(\d+)$/.exec(id);
+    return m ? Number(m[1]) : Number.MAX_SAFE_INTEGER;
 }
 function rankOf(task, key) {
     if (key === 'pri')

package/dist/width.js

@@ -224,8 +224,16 @@ export function cut(s, cols) {
  * portano glifi larghi 2 (`📌` nelle sessioni, i glifi di priorità nei filtri
  * delle task), cioè la condizione esatta in cui `cli-truncate` restituisce una
  * riga più larga del budget e il bordo del pane sparisce.
+ *
+ * T100/D6 — `priority` è l'indice del pezzo che il budget serve PER PRIMO,
+ * quando la riga porta un segmento su cui si sta agendo (la vista attiva di un
+ * header-selettore). Gli altri si mostrano solo se avanza spazio, e cadono dalla
+ * coda come prima. L'ORDINE DI RESA non cambia — cambia chi paga il taglio: su
+ * un terminale stretto sparisce un contatore, mai la voce che dice dove sei.
+ * Riservare non allarga la riga: resta un tetto, e con `priority` da solo più
+ * largo del budget è lui a essere tagliato.
  */
-export function cutParts(parts, cols) {
+export function cutParts(parts, cols, priority = -1) {
     const empty = parts.map(() => '');
     if (cols <= 0)
         return empty;
@@ -234,10 +242,45 @@ export function cutParts(parts, cols) {
     const out = [...empty];
     const budget = cols - 1; // -1 = la colonna dell'ellissi, che qui c'è di sicuro
     let w = 0;
-    let full = false;
-    for (let i = 0; i < parts.length && !full; i++) {
+    const hasPriority = priority >= 0 && priority < parts.length;
+    if (hasPriority) {
+        // Il prioritario prende il suo spazio per primo, e se non ci sta intero è
+        // lui a essere tagliato: dev'esserci comunque, anche monco.
         let acc = '';
-        for (const ch of parts[i]) {
+        for (const ch of parts[priority]) {
+            const cw = termWidth(ch);
+            if (w + cw > budget)
+                break;
+            acc += ch;
+            w += cw;
+        }
+        out[priority] = acc;
+    }
+    for (let i = 0; i < parts.length; i++) {
+        if (hasPriority && i === priority)
+            continue;
+        const part = parts[i];
+        const pw = termWidth(part);
+        if (hasPriority) {
+            // Col prioritario già servito il taglio a metà di un altro segmento
+            // lascerebbe a schermo un moncone seguito da una voce intera, che si legge
+            // come due cose slegate invece che come una riga troncata: qui un pezzo o
+            // entra tutto o cede il posto.
+            //
+            // E chi cede si porta dietro tutti quelli dopo di lui, invece di lasciare
+            // passare il primo più corto: l'ordine dell'array È l'ordine di
+            // importanza (le voci navigabili prima dei contatori di scroll), e un
+            // riempimento a buchi lo scavalcherebbe — l'header mostrerebbe `↓46`
+            // avendo buttato la voce che si può selezionare.
+            if (w + pw > budget)
+                break;
+            out[i] = part;
+            w += pw;
+            continue;
+        }
+        let acc = '';
+        let full = false;
+        for (const ch of part) {
             const cw = termWidth(ch);
             if (w + cw > budget) {
                 full = true;
@@ -247,7 +290,15 @@ export function cutParts(parts, cols) {
             w += cw;
         }
         out[i] = acc;
+        if (full)
+            break;
     }
+    // Col prioritario servito per primo il primo pezzo a schermo può non essere il
+    // pezzo 0, e i segmenti portano il proprio separatore in testa: senza questa
+    // potatura la riga aprirebbe con un ` · ` appeso al nulla.
+    const first = out.findIndex((p) => p !== '');
+    if (first > 0)
+        out[first] = out[first].replace(/^[\s·]+/, '');
     // L'ellissi va sull'ultimo pezzo che ha davvero del testo: appiccicarla a un
     // pezzo vuoto la staccherebbe dal punto di taglio, e il lettore la leggerebbe
     // come un segmento a sé.

package/package.json

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

@@ -124,7 +124,7 @@ USAGE="uso: deck-run <TaskID> [--prompt-kind <kind>] [--session-id <uuid>]
        none        nessun prompt — sessione aperta sulla task, a mani nude
        recap       recap stato task <TaskID>
        preflight   /loom-works:preflight-task <TaskID>
-       run         /loom-works:run-task <TaskID>  (run-doc sulle task D)
+       run         /loom-works:run-task <TaskID>
        checkpoint  /loom-works:checkpoint-task <TaskID>
 
   --title-note   nota della conversazione, appesa al titolo tab come «nota»
@@ -353,23 +353,15 @@ FORK_FLAG=""
 # possa scavalcare. Il placeholder {TASK} vale solo per il valore dell'override;
 # i template del catalogo interpolano ${TASK} diretto (nel `${VAR:-...}` la `}`
 # di `{TASK}` chiuderebbe in anticipo l'espansione).
-# `run` DISPATCHA sul prefisso: la lista del deck contiene entrambe le famiglie
-# 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, 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é.
+# Ogni kind è un template diretto sull'id: la lista del deck è monofamiglia
+# (`T`, unico prefisso del contratto loom), quindi nessun prompt discrimina sulla
+# forma dell'id.
 case "${PROMPT_KIND:-recap}" in
   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 ;;
+  run)        PROMPT="/loom-works:run-task ${TASK}" ;;
 esac
 if [[ "${PROMPT_KIND:-}" != "none" && -n "${LOOM_DECK_ENTER_PROMPT:-}" ]]; then
   PROMPT="${LOOM_DECK_ENTER_PROMPT//\{TASK\}/${TASK}}"