@lamemind/loom-deck 0.50.0 → 0.52.0

package/dist/cli.js

@@ -8,7 +8,8 @@ import { rowIndexOfKey, selectedRow, } from './search.js';
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, } from './task-index.js';
 import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, selectedSession, unpinLandingId, } from './session-list.js';
 import { cellWidth, launchLegend, LAUNCH_SEP, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
-import { anchorFrame, enableMouse, FRAME_TEXT_COL, hitRegion, isWheel, LAUNCH_ROW, rowRegions, takeMouse, } from './mouse.js';
+import { anchorFrame, enableMouse, FRAME_TEXT_COL, hitRegion, inlineRegions, isWheel, LAUNCH_ROW, listHit, PANE_TEXT_PAD, paneSpans, rowRegions, takeMouse, WHEEL_LINES, wheelDir, } from './mouse.js';
+import { headerItems, sessionHeaderParts, taskHeaderParts } from './pane-header.js';
 import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, TASK_VIEWS, } from './pane-views.js';
 import { isCompact, layoutBudget, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { cut, cutMiddle, sanitize, termWidth } from './width.js';
@@ -33,7 +34,7 @@ import { useSearchOverlay } from './overlays/search.js';
 import { useSheetOverlay } from './overlays/sheet.js';
 import { useAssignOverlay } from './overlays/assign.js';
 import { useProjectStatus } from './overlays/status.js';
-import { captures } from './input-modes.js';
+import { captures, scrolls } from './input-modes.js';
 import { VERSION } from './version.js';
 // T116 — l'avviso della prima pressione di `^C`. La durata è INTERPOLATA dalla
 // finestra, non ricopiata: un numero scritto a mano in un testo che promette un
@@ -713,13 +714,17 @@ 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(paneTasks.length + META_ROWS - 1, selIndex + delta));
-        if (next === ROW_ALL)
+        selectTaskRow(Math.max(0, Math.min(paneTasks.length + META_ROWS - 1, selIndex + delta)));
+    }
+    /** Selezione per INDICE nella vista, riconvertita subito in sentinella o id.
+     *  T21 — la chiama anche il click su una riga del pane task. */
+    function selectTaskRow(index) {
+        if (index === ROW_ALL)
             setSel(ALL);
-        else if (next === ROW_SPOT)
+        else if (index === ROW_SPOT)
             setSel(SPOT);
         else
-            setSel(paneTasks[next - META_ROWS]?.id ?? SPOT);
+            setSel(paneTasks[index - META_ROWS]?.id ?? SPOT);
     }
     // T100 — `tab` naviga il catalogo viste del pane in focus. Il reset della
     // selezione è la regola letterale «prima riga in alto», senza eccezioni: sul
@@ -728,18 +733,28 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // 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)}`);
-        }
+        if (focus === 'tasks')
+            selectTaskView(cycleTaskView(taskViewId, delta));
+        else
+            selectSessionView(cycleSessionView(sessionViewId, delta));
+    }
+    // T21 — per VISTA e non per passo: il click sull'header nomina una voce, e
+    // `tab` la raggiunge ciclando. Sulla vista già attiva non si fa niente — un
+    // click che azzerasse la selezione alla riga in alto sarebbe un effetto che
+    // la tastiera non ha mai avuto, perché `tab` non può restare ferma.
+    function selectTaskView(next) {
+        if (next === taskViewId)
+            return;
+        setTaskViewId(next);
+        setSel(ALL);
+        setNote(`vista task: ${taskView(next).label(taskCounts)}`);
+    }
+    function selectSessionView(next) {
+        if (next === sessionViewId)
+            return;
+        setSessionViewId(next);
+        setSelSessionId(null);
+        setNote(`vista sessioni: ${sessionView(next).label(sessionCounts, parentLabel)}`);
     }
     // T49 — resume di una conversazione in una nuova tab. Unico punto: lo chiamano
     // il `⏎` della lista sessioni e quello sulla riga-sessione della ricerca, che
@@ -994,6 +1009,15 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         edit: onEditKey,
         purge: onPurgeKey,
     };
+    // T21 (mandata 2) — la ROTELLA, per i soli modi che scorrono un contenuto
+    // lungo (`SCROLLING_MODES`). Stessa forma di `MODE_KEYS`: un `Record` sul
+    // catalogo, quindi un modo dichiarato scorrevole senza uno scroll da chiamare
+    // non compila. Il delta è in righe, col segno del verso.
+    const MODE_WHEEL = {
+        detail: sheet.scroll,
+        status: status.scroll,
+        reader: search.scrollReader,
+    };
     /**
      * T21 — il MOUSE precede tutto, in ogni modo del deck.
      *
@@ -1019,22 +1043,72 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     });
     function onMouse(ev) {
         // Un click produce due eventi (pressione e rilascio): agire su entrambi
-        // spawnerebbe due volte. La rotella è mandata 2 — qui scartata, non
-        // silenziosamente equiparata a un click. Il bottone si legge sui due bit
-        // bassi, perché gli alti portano i modificatori (shift/meta/ctrl).
-        if (!ev.press || isWheel(ev.button) || (ev.button & 3) !== 0)
+        // spawnerebbe due volte. La rotella arriva come sola pressione, quindi il
+        // filtro su `press` la lascia passare e non la dedoppia.
+        if (!ev.press)
+            return;
+        if (isWheel(ev.button)) {
+            // La rotella NON rientra dalla porta della tastiera come il click: nel
+            // detail `↑↓` muovono il fuoco fra i campi (T117), non il testo, e il
+            // tasto che scorre — `PgUp`/`PgDn` — ha la granularità sbagliata per una
+            // tacca. Va quindi allo scroll del modo, in righe. Fuori dai modi
+            // scorrevoli è inerte: nelle liste la rotella non muove mai la
+            // selezione (D5), e una tacca mentre il deck è sulla lista non deve
+            // fare niente.
+            if (scrolls(mode))
+                MODE_WHEEL[mode](wheelDir(ev.button) * WHEEL_LINES);
+            return;
+        }
+        // Il bottone si legge sui due bit bassi, perché gli alti portano i
+        // modificatori (shift/meta/ctrl).
+        if ((ev.button & 3) !== 0)
             return;
         // Le superfici esistono solo nella lista: un modo capturing prende il
         // frame intero e a quella riga c'è dell'altro.
-        if (mode !== 'normal' || ev.row !== LAUNCH_ROW)
+        if (mode !== 'normal')
+            return;
+        if (ev.row === LAUNCH_ROW) {
+            const hit = hitRegion(launchRegions, ev.col);
+            // Il click NON chiama l'azione: rientra dalla porta della tastiera col
+            // tasto che la superficie annuncia. Un ramo nuovo su `t`/`c`/cifre nasce
+            // così già cliccabile, e non esiste un secondo posto in cui il click possa
+            // dire una cosa diversa dal tasto che gli sta scritto sopra.
+            if (hit)
+                onKey(hit, NO_MODIFIERS);
+            return;
+        }
+        onListClick(ev);
+    }
+    /**
+     * T21 (mandata 3) — click su un elemento di lista = SOLO FUOCO (D2): il pane
+     * prende il focus e la selezione va sull'elemento, nessuna azione parte. Qui
+     * il click non sintetizza un tasto, perché nessun tasto nomina una riga o una
+     * vista — `↑↓` e `tab` sono relativi — e chiama i setter che la tastiera
+     * usa a sua volta. Un click sulla vista già attiva si limita al focus.
+     */
+    function onListClick(ev) {
+        if (!listGeometry)
             return;
-        const hit = hitRegion(launchRegions, ev.col);
-        // Il click NON chiama l'azione: rientra dalla porta della tastiera col
-        // tasto che la superficie annuncia. Un ramo nuovo su `t`/`c`/cifre nasce
-        // così già cliccabile, e non esiste un secondo posto in cui il click possa
-        // dire una cosa diversa dal tasto che gli sta scritto sopra.
-        if (hit)
-            onKey(hit, NO_MODIFIERS);
+        const hit = listHit(ev, listGeometry);
+        if (!hit)
+            return;
+        setFocus(hit.pane);
+        if (hit.pane === 'tasks') {
+            if (hit.target === 'view')
+                selectTaskView(hit.key);
+            // Le due righe meta hanno indice fisso; le task riportano l'indice di
+            // finestra a quello della lista completa, su cui è keyata la selezione.
+            else
+                selectTaskRow(hit.index < META_ROWS ? hit.index : taskWin.start + hit.index);
+        }
+        else if (hit.target === 'view') {
+            selectSessionView(hit.key);
+        }
+        else {
+            const row = windowRows[hit.index];
+            if (row && row.kind !== 'separator')
+                setSelSessionId(row.sessionId);
+        }
     }
     function onKey(input, key) {
         // T116 — `^C` sta SOPRA il dispatch dei modi, unico tasto a scavalcarlo.
@@ -1520,6 +1594,22 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const selRowIndex = rowIndexOf(sessionRows, selSessionId);
     const sessionWin = windowRange(sessionRows.length, selRowIndex, budget.sessionRows);
     const windowRows = sessionRows.slice(sessionWin.start, sessionWin.end);
+    // T21 — geometria delle liste per l'hit-test del click, dalla STESSA
+    // aritmetica che disegna i pane: le parti degli header escono dal modulo che
+    // `ui/panes.tsx` consuma per renderle, le righe cliccabili sono le finestre
+    // appena calcolate. `null` in compatto: lì i pane non esistono.
+    const spans = paneSpans(columns);
+    const listGeometry = budget.compact
+        ? null
+        : {
+            columns,
+            taskHeader: inlineRegions(headerItems(taskHeaderParts(taskCounts, taskViewId, taskWin.start, paneTasks.length - taskWin.end, columns)), spans.tasks.start + PANE_TEXT_PAD),
+            sessionHeader: inlineRegions(headerItems(sessionHeaderParts(parentLabel, sessionCounts, sessionViewId, sessionWin.start, sessionRows.length - sessionWin.end, columns)), spans.sessions.start + PANE_TEXT_PAD),
+            // Con un errore di caricamento al posto delle task c'è la riga rossa:
+            // restano cliccabili le sole righe meta.
+            taskRows: META_ROWS + (loadError ? 0 : windowTasks.length),
+            sessionRows: windowRows.length,
+        };
     // Sotto la soglia minima il layout a box non entra a nessun costo: si scende
     // a una riga sola. Perdere il deck per un terminale basso è meglio che
     // sporcare la cronologia del terminale a ogni poll.

package/dist/input-modes.js

@@ -55,3 +55,23 @@ export function captures(mode) {
 export const CTRL_DEROGATIONS = {
     detail: ['f'],
 };
+/**
+ * T21 (mandata 2) — i modi che SCORRONO un contenuto lungo, cioè gli unici in
+ * cui la rotella del mouse fa qualcosa.
+ *
+ * La rotella scorre il TESTO, mai la selezione di una lista (D5): nelle liste
+ * la selezione è un'intenzione — la riga su cui si preme `⏎` — e una rotella
+ * che la muovesse trasformerebbe ogni sfioramento in una scelta. Nei tre modi
+ * qui sotto lo scroll non sceglie niente, è solo posizione di lettura. Non
+ * coincide con «ha un documento a schermo»: `search` mostra un'anteprima, ma
+ * il fuoco lì è sulla lista dei risultati, che è una selezione.
+ *
+ * Il custode è `MODE_WHEEL` in `cli.tsx`, un `Record<ScrollingMode, …>` che non
+ * compila se un modo entra qui senza uno scroll da chiamare.
+ */
+export const SCROLLING_MODES = ['detail', 'status', 'reader'];
+const SCROLLING = new Set(SCROLLING_MODES);
+/** `true` se la rotella scorre il contenuto del modo. */
+export function scrolls(mode) {
+    return SCROLLING.has(mode);
+}

package/dist/mouse.js

@@ -32,6 +32,28 @@ const SGR_MOUSE = /\x1b?\[<(\d+);(\d+);(\d+)([Mm])/g;
 export function isWheel(button) {
     return (button & 64) !== 0;
 }
+/**
+ * Verso della rotella: `-1` su (codice 64), `+1` giù (65), `0` se non è una
+ * rotella. Il verso sta nel bit 0, i modificatori nei bit 2-4 (shift/meta/
+ * ctrl): `66`/`67` sono le rotelle orizzontali, che qui valgono `0` perché il
+ * deck non ha nulla da scorrere in orizzontale.
+ *
+ * Un terminale manda la rotella come SOLA pressione (`M`), mai seguita da un
+ * rilascio: un tacca = un evento, e il chiamante non deve dedoppiare come fa
+ * per il click.
+ */
+export function wheelDir(button) {
+    if (!isWheel(button) || (button & 2) !== 0)
+        return 0;
+    return (button & 1) === 0 ? -1 : 1;
+}
+/**
+ * Righe scorse per tacca di rotella nei contenuti lunghi (detail, project
+ * status, reader). Tre è la convenzione dei terminali e dei browser: una tacca
+ * a riga singola costringe a girare la rotella quanto basta a stancare la mano,
+ * una a pagina salta il testo che si stava leggendo.
+ */
+export const WHEEL_LINES = 3;
 /**
  * Separa le sequenze mouse dal testo di un chunk di `useInput`.
  *
@@ -177,3 +199,87 @@ export const LAUNCH_ROW = 4;
 /** Colonna (1-based) del primo carattere di testo dentro il box esterno:
  *  bordo + `paddingX={1}`. */
 export const FRAME_TEXT_COL = 3;
+// ── Hit-test delle liste (mandata 3) ────────────────────────────────────────
+//
+// Click su un elemento di lista = SOLO FUOCO (D2): la selezione si sposta, non
+// parte nessuna azione. A differenza della riga launch il click qui non può
+// rientrare dalla porta della tastiera — non esiste un tasto che dica «vai alla
+// riga 7» o «vista `nascoste`»: `↑↓` e `tab` sono relativi alla posizione
+// corrente. Il chiamante chiama quindi il setter della selezione, come la
+// rotella chiama lo `scroll` del modo.
+/**
+ * Righe fisse dei due pane in modalità normale, contate dall'alto come
+ * `LAUNCH_ROW` e per la stessa ragione: sopra di loro non c'è niente di
+ * condizionale. Sotto la riga launch stanno il `marginTop` del blocco pane
+ * (riga 5), il bordo superiore (6), l'header con le viste (7) e il corpo (8+).
+ */
+export const PANE_HEADER_ROW = LAUNCH_ROW + 3;
+export const PANE_BODY_ROW = PANE_HEADER_ROW + 1;
+/** Nel pane task fra header e lista sta la riga sort/filtri, che non si
+ *  seleziona: la prima riga di lista (`≡ tutte`) è quella dopo. */
+export const TASK_LIST_ROW = PANE_BODY_ROW + 1;
+/** Colonne fra il bordo di un pane e il suo testo: bordo + `paddingX={1}`. */
+export const PANE_TEXT_PAD = 2;
+/**
+ * Colonne (1-based, estremi inclusi, bordi compresi) dei due pane affiancati.
+ *
+ * Entrambi dichiarano `width="50%"` dell'interno del box esterno (`columns - 4`)
+ * e il primo porta `marginRight={1}`: la somma sfora di una colonna e Yoga la
+ * toglie per shrink, metà a testa, poi arrotonda le posizioni. L'esito
+ * misurato sotto pty è che il pane task è largo `floor((columns - 4) / 2)` —
+ * lo stesso conto di `paneTextWidth` più i suoi 4 di cornice — e il pane
+ * sessioni comincia dopo la colonna di margine e arriva al padding del box
+ * esterno. La colonna di margine non appartiene a nessuno dei due.
+ */
+export function paneSpans(columns) {
+    const inner = (columns || 80) - 4;
+    const taskW = Math.floor(inner / 2);
+    const tasksEnd = FRAME_TEXT_COL + taskW - 1;
+    return {
+        tasks: { start: FRAME_TEXT_COL, end: tasksEnd },
+        sessions: { start: tasksEnd + 2, end: FRAME_TEXT_COL + inner - 1 },
+    };
+}
+/**
+ * Colonne delle parti di una riga che portano il proprio separatore IN TESTA
+ * (gli header dei pane: ` · 68 nascoste`). La regione di una parte keyed
+ * esclude il separatore: un click sul ` · ` fra due viste non deve sceglierne
+ * una. Le parti con `key` null (nome del pane, `↑N`/`↓N`) consumano colonne ma
+ * non producono regione; quelle vuote (cadute al taglio) non consumano niente.
+ */
+export function inlineRegions(parts, startCol) {
+    const out = [];
+    let col = startCol;
+    for (const p of parts) {
+        const w = termWidth(p.text);
+        if (w === 0)
+            continue;
+        if (p.key !== null) {
+            const lead = termWidth(p.text.match(/^[\s·]+/)?.[0] ?? '');
+            if (w > lead)
+                out.push({ key: p.key, start: col + lead, end: col + w - 1 });
+        }
+        col += w;
+    }
+    return out;
+}
+/** L'elemento di lista sotto il click, o `null` se il click cade su cornice,
+ *  riga sort, spazio vuoto sotto la lista o fuori dai pane. */
+export function listHit(ev, g) {
+    const spans = paneSpans(g.columns);
+    const inTasks = ev.col >= spans.tasks.start && ev.col <= spans.tasks.end;
+    const inSessions = ev.col >= spans.sessions.start && ev.col <= spans.sessions.end;
+    if (!inTasks && !inSessions)
+        return null;
+    const pane = inTasks ? 'tasks' : 'sessions';
+    if (ev.row === PANE_HEADER_ROW) {
+        const key = hitRegion(inTasks ? g.taskHeader : g.sessionHeader, ev.col);
+        return key ? { pane, target: 'view', key } : null;
+    }
+    const first = inTasks ? TASK_LIST_ROW : PANE_BODY_ROW;
+    const count = inTasks ? g.taskRows : g.sessionRows;
+    const index = ev.row - first;
+    if (index < 0 || index >= count)
+        return null;
+    return { pane, target: 'row', index };
+}

package/dist/overlays/search.js

@@ -255,5 +255,6 @@ export function useSearchOverlay(deps) {
         open,
         onReaderKey,
         onSearchKey,
+        scrollReader,
     };
 }

package/dist/overlays/sheet.js

@@ -286,5 +286,6 @@ export function useSheetOverlay(deps) {
         occCur,
         open,
         onKey,
+        scroll,
     };
 }

package/dist/overlays/status.js

@@ -155,5 +155,6 @@ export function useProjectStatus(deps) {
         generate,
         open,
         onKey,
+        scroll,
     };
 }

package/dist/pane-header.js

@@ -0,0 +1,62 @@
+// T21 (mandata 3) — le PARTI degli header dei due pane come DATO, non come JSX.
+//
+// Stesso principio della riga launch (`launchSegments` in `cli.tsx`): gli
+// stessi oggetti compongono la riga disegnata (`ui/panes.tsx`) e le colonne
+// dell'hit-test (`cli.tsx`). Chi li deriva dall'altro — ri-splittando la
+// stringa renderizzata, o ricontando le voci del catalogo — tiene due conti
+// paralleli che divergono alla prima voce che cambia testo o ordine.
+//
+// Modulo PURO: nessun import da ink/react. Il taglio al budget (`cutParts`) sta
+// qui e non nel componente perché è il taglio a decidere quali parti esistono a
+// schermo, e una parte caduta non deve rispondere a un click.
+import { cutParts } from './width.js';
+import { paneTextWidth } from './layout.js';
+import { SESSION_VIEWS, TASK_VIEWS, } from './pane-views.js';
+function finish(parts, columns) {
+    const shown = cutParts(parts.map((p) => p.text), paneTextWidth(columns), parts.findIndex((p) => p.active));
+    return { parts, shown };
+}
+/**
+ * Header del pane task: le tre viste del catalogo, poi `↑N`/`↓N`.
+ * Le voci ci sono tutte anche a 0 (T100/D1) e l'attiva ha la precedenza sul
+ * budget (D6); i contatori di scroll stanno in coda perché sono i primi a
+ * cedere il posto su un terminale stretto.
+ */
+export function taskHeaderParts(counts, active, above, below, columns) {
+    const views = TASK_VIEWS.map((v, i) => ({
+        key: v.id,
+        text: `${i > 0 ? ' · ' : ''}${v.label(counts)}`,
+        color: v.color,
+        dim: Boolean(v.dim) || v.count(counts) === 0,
+        active: v.id === active,
+    }));
+    return finish([
+        ...views,
+        { key: null, text: above > 0 ? ` · ↑${above}` : '', dim: true, active: false },
+        { key: null, text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false },
+    ], columns);
+}
+/**
+ * Header del pane sessioni: `Sessions` nomina il pane e non è una voce del
+ * catalogo (non si seleziona), poi le quattro viste, poi `↑N`/`↓N`.
+ */
+export function sessionHeaderParts(parentLabel, counts, active, above, below, columns) {
+    const views = SESSION_VIEWS.map((v) => ({
+        key: v.id,
+        text: ` · ${v.label(counts, parentLabel)}`,
+        color: v.color,
+        dim: Boolean(v.dim) || v.count(counts) === 0,
+        active: v.id === active,
+    }));
+    return finish([
+        { key: null, text: 'Sessions', dim: false, active: false },
+        ...views,
+        { key: null, text: above > 0 ? ` · ↑${above}` : '', dim: true, active: false },
+        { key: null, text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false },
+    ], columns);
+}
+/** Le parti COME SONO A SCHERMO — testo tagliato, chiave intatta — nella forma
+ *  che `inlineRegions` (`mouse.ts`) misura per l'hit-test. */
+export function headerItems(h) {
+    return h.parts.map((p, i) => ({ key: p.key, text: h.shown[i] ?? '' }));
+}

package/dist/ui/panes.js

@@ -3,13 +3,14 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // header. Sono presentazionali puri: ricevono la vista già selezionata e le
 // larghezze già calcolate, non li derivano.
 import { Box, Text } from 'ink';
-import { cut, cutParts, pad, sanitize, termWidth } from '../width.js';
+import { cut, pad, sanitize, termWidth } from '../width.js';
 import { paneTextWidth } from '../layout.js';
 import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
 import { TaskRow } from './task-row.js';
 import { META_ROWS, ROW_ALL, ROW_SPOT } from '../model.js';
 import { rowLabel, sessionTitle } from '../session-list.js';
-import { sessionView, taskView, SESSION_VIEWS, TASK_VIEWS, } from '../pane-views.js';
+import { sessionView, taskView, } from '../pane-views.js';
+import { sessionHeaderParts, taskHeaderParts } from '../pane-header.js';
 import { describeSort, PRI_ENTRIES, PROG_ENTRIES, } from '../view.js';
 /**
  * Header del pane task, tagliato QUI e non da Ink — stesso motivo del gemello
@@ -31,24 +32,16 @@ import { describeSort, PRI_ENTRIES, PROG_ENTRIES, } from '../view.js';
  * su un terminale stretto — e la voce attiva ha la precedenza sul budget (D6).
  */
 export 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 = [
-        ...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), 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) }));
+    // T21 — le parti e il loro taglio vengono da `pane-header.ts`, lo stesso
+    // modulo da cui `cli.tsx` ricava le colonne cliccabili: una fonte sola.
+    const { parts, shown } = taskHeaderParts(counts, active, above, below, columns);
+    return _jsx(HeaderLine, { parts: parts, shown: shown, focused: focused });
+}
+/** Resa di un header già tagliato: ogni parte col suo stile, l'attiva in
+ *  video inverso (T100/D5 — costa 0 colonne e non entra in gara con la
+ *  semantica di colore già occupata). */
+function HeaderLine({ parts, shown, focused, }) {
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: parts.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
 }
 export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, idW, tailW, focused, loadError, windowStart, above, below, columns, data, }) {
     const allSelected = selected === ROW_ALL;
@@ -87,25 +80,8 @@ export function TasksPane({ tasks, counts, activeView, paneCount, view, selected
  * pinnate dal resto dell'header e non è decorazione.
  */
 export 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 = [
-        // `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), 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) }));
+    const { parts, shown } = sessionHeaderParts(parentLabel, counts, active, above, below, columns);
+    return _jsx(HeaderLine, { parts: parts, shown: shown, focused: focused });
 }
 export 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 ? (

package/package.json

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