@lamemind/loom-deck 0.54.1 → 0.56.0

package/dist/overlays/modals.js

@@ -0,0 +1,231 @@
+// I modali IN FLUSSO: quelli che si disegnano in un box dentro la cornice
+// invece di sostituirla. Sono due famiglie e stanno nello stesso file perché
+// hanno lo stesso mestiere — tenere una bozza mentre si digita — e perché il
+// loro gemello di vista esiste già e si chiama `ui/modals.tsx`. La simmetria
+// `ui/modals.tsx` (vista) ↔ `overlays/modals.ts` (stato e input) è essa stessa
+// un'informazione: chi cerca l'uno trova l'altro.
+//
+// `useViewModals` governa sort e filtri, che compongono la VISTA. Lo stato
+// `view` non è loro e vive nel modello (`deck-model.ts`): è ciò che `applyView`
+// consuma, è persistito su disco e lo rilegge il tasto `w`. Qui resta ciò che è
+// davvero del modale — la fotografia per l'annullamento e la posizione nella
+// griglia dei filtri.
+//
+// `useTextModals` governa create, nota ed edit, cioè i tre campi di testo. Le
+// scritture che ne conseguono escono come callback (deroga T104: un hook di
+// overlay non esce dal deck).
+import { useState } from 'react';
+import { caretAtEnd, fieldsKey } from '../fields.js';
+import { sanitizeTyped } from '../glyphs.js';
+import { EDIT_FIELDS, EDIT_PRI, EDIT_PROG, editTextField, SORT_TASTI, } from '../model.js';
+import { cycleSort, describeSort, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from '../view.js';
+export function useViewModals({ view, setView, hiddenTasks, setMode, setNote, }) {
+    // T39 — fotografia della vista all'apertura di un modale: la lista si
+    // aggiorna dal vivo, quindi `esc` deve poter ripristinare.
+    const [backup, setBackup] = useState(null);
+    const [filterCursor, setFilterCursor] = useState({ row: 0, col: 0 });
+    /** Chiusura: `restore` rimette la fotografia (esc = annulla), altrimenti tiene ciò che si è composto (⏎). */
+    function close(restore) {
+        if (restore && backup) {
+            const snapshot = backup;
+            setView(() => snapshot);
+        }
+        setBackup(null);
+        setMode('normal');
+    }
+    function openSort() {
+        setBackup(view);
+        setNote('');
+        setMode('sort');
+    }
+    function openFilter() {
+        setBackup(view);
+        setNote('');
+        setMode('filter');
+    }
+    function onSortKey(input, key) {
+        if (key.escape) {
+            close(true);
+            setNote('S → sort annullato');
+        }
+        else if (key.return) {
+            close(false);
+            setNote(`S → sort: ${describeSort(view.sort)}`);
+        }
+        else if (input) {
+            // useInput consegna il CHUNK letto da stdin, non un tasto: digitando
+            // veloce (o incollando) `ppi` arriva come stringa unica. Si cicla su
+            // ogni carattere, così la chain esce identica a battitura lenta.
+            const keys = [...input].map((ch) => SORT_TASTI[ch]).filter(Boolean);
+            if (keys.length > 0) {
+                setView((v) => ({ ...v, sort: keys.reduce(cycleSort, v.sort) }));
+            }
+        }
+    }
+    function onFilterKey(input, key) {
+        const rowLen = (r) => (r === 0 ? PRI_ENTRIES.length : PROG_ENTRIES.length);
+        if (key.escape) {
+            close(true);
+            setNote('F → filtri annullati');
+        }
+        else if (key.return) {
+            close(false);
+            setNote(hiddenTasks > 0 ? `F → ${hiddenTasks} task nascoste` : 'F → nessun filtro attivo');
+        }
+        else if (key.upArrow || key.downArrow) {
+            setFilterCursor((c) => {
+                const row = c.row === 0 ? 1 : 0;
+                return { row, col: Math.min(c.col, rowLen(row) - 1) };
+            });
+        }
+        else if (key.leftArrow) {
+            setFilterCursor((c) => ({ ...c, col: Math.max(0, c.col - 1) }));
+        }
+        else if (key.rightArrow) {
+            setFilterCursor((c) => ({ ...c, col: Math.min(rowLen(c.row) - 1, c.col + 1) }));
+        }
+        else if (input === ' ') {
+            const { row, col } = filterCursor;
+            setView((v) => row === 0
+                ? { ...v, hiddenPri: toggleHidden(v.hiddenPri, PRI_ENTRIES[col].name) }
+                : { ...v, hiddenProg: toggleHidden(v.hiddenProg, PROG_ENTRIES[col].name) });
+        }
+    }
+    return { filterCursor, openSort, openFilter, onSortKey, onFilterKey };
+}
+export function useTextModals({ setMode, setNote, onCreate, onNote, onEdit, editDraftFor, currentNote, }) {
+    const [draft, setDraft] = useState('');
+    // T53 — bozza della nota sulla conversazione selezionata. Si apre PRECARICATA
+    // con la nota esistente: annotare due volte è quasi sempre correggere, non
+    // riscrivere da zero, e un campo vuoto costringerebbe a ridigitare tutto per
+    // cambiare una parola. Confermare il campo vuoto cancella la nota.
+    const [noteDraft, setNoteDraft] = useState('');
+    const [noteSid, setNoteSid] = useState(null);
+    // T41 — bozza dell'edit (null fuori dal modale) e posizione nell'area di
+    // compilazione: riga in fuoco + caret dentro la riga di testo attiva.
+    const [edit, setEdit] = useState(null);
+    const [editTask, setEditTask] = useState(null);
+    const [editCursor, setEditCursor] = useState({ row: 0, caret: 0 });
+    function openCreate() {
+        setNote('');
+        setMode('create');
+    }
+    function openNote(sid) {
+        setNoteSid(sid);
+        setNoteDraft(currentNote(sid));
+        setNote('');
+        setMode('note');
+    }
+    function openEdit(task) {
+        setEditTask(task);
+        setEdit(editDraftFor(task));
+        // Si apre sulla riga 0 (priorità), che non è un campo di testo: il caret
+        // prende la sua posizione entrando in una riga di testo con ↑↓.
+        setEditCursor({ row: 0, caret: 0 });
+        setNote('');
+        setMode('edit');
+    }
+    function onCreateKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setDraft('');
+            setNote('C → create annullato');
+        }
+        else if (key.return) {
+            const text = draft.trim();
+            setMode('normal');
+            setDraft('');
+            onCreate(text);
+        }
+        else if (key.backspace || key.delete) {
+            setDraft((d) => d.slice(0, -1));
+        }
+        else if (input && !key.ctrl && !key.meta) {
+            setDraft((d) => d + input);
+        }
+    }
+    function onNoteKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setNoteDraft('');
+            setNote('N → titolo annullato');
+        }
+        else if (key.return) {
+            const sid = noteSid;
+            const text = noteDraft.trim();
+            setMode('normal');
+            setNoteDraft('');
+            if (sid)
+                onNote(sid, text);
+        }
+        else if (key.ctrl && input === 'u') {
+            // Svuota il campo in un colpo. NON è una scorciatoia di comodo: il
+            // backspace tenuto premuto cancella UN carattere per CHUNK letto da
+            // stdin, non per pressione (`useInput` consegna il chunk, e per una
+            // raffica di DEL Ink alza `key.backspace` una volta sola) — misurato,
+            // 30 pressioni → 2 caratteri. Siccome «campo vuoto» qui è l'unico modo
+            // di CANCELLARE una nota, dipendere dal backspace renderebbe
+            // l'operazione praticamente non eseguibile. `^U` è il kill-line delle
+            // shell, quindi il gesto è già nelle dita di chi usa un terminale.
+            setNoteDraft('');
+        }
+        else if (key.backspace || key.delete) {
+            setNoteDraft((d) => d.slice(0, -1));
+        }
+        else if (input && !key.ctrl && !key.meta) {
+            // Sanificazione dei byte di controllo, come `typeIntoField` della
+            // ricerca: `useInput` consegna il CHUNK letto da stdin, quindi un
+            // incollaggio porta dentro newline e control char. Invisibili a schermo
+            // ma contati da Ink nella larghezza della riga — e qui finirebbero
+            // scritti su disco, dove resterebbero a sporcare la riga per sempre.
+            // Le newline diventano spazio: incollare due righe deve separare le
+            // parole, non fonderle.
+            setNoteDraft((d) => d + sanitizeTyped(input));
+        }
+    }
+    // Il ponte fra le quattro righe del modale e la bozza. I valori restano
+    // tipizzati (`PriName`, `ProgName`) invece di finire in un record generico:
+    // `fields.ts` governa la grammatica dei tasti, non il modello dati.
+    const editIO = {
+        text: (row) => edit?.[editTextField(row)] ?? '',
+        setText: (row, next) => setEdit((e) => (e ? { ...e, [editTextField(row)]: next } : e)),
+        choice: (row) => row === 0
+            ? Math.max(0, EDIT_PRI.indexOf(edit?.pri ?? 'med'))
+            : Math.max(0, EDIT_PROG.indexOf(edit?.prog ?? 'todo')),
+        setChoice: (row, index) => setEdit((e) => e ? (row === 0 ? { ...e, pri: EDIT_PRI[index] } : { ...e, prog: EDIT_PROG[index] }) : e),
+    };
+    function onEditKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setEdit(null);
+            setNote('E → edit annullato');
+            return;
+        }
+        if (key.return) {
+            const task = editTask;
+            const current = edit;
+            setMode('normal');
+            setEdit(null);
+            if (task && current)
+                onEdit(task, current);
+            return;
+        }
+        // Tutto il resto è dell'area di compilazione, che è la STESSA del detail
+        // (T117): una grammatica sola, non due copie da tenere allineate a mano.
+        fieldsKey(input, key, EDIT_FIELDS, editCursor, setEditCursor, editIO);
+    }
+    return {
+        draft,
+        noteDraft,
+        edit,
+        editTask,
+        editCursor,
+        openCreate,
+        openNote,
+        openEdit,
+        onCreateKey,
+        onNoteKey,
+        onEditKey,
+    };
+}
+export { caretAtEnd };

package/dist/overlays/purge.js

@@ -0,0 +1,44 @@
+// T112 — l'overlay di conferma dell'eliminazione (`CANC`).
+//
+// T131 — è nato dentro `cli.tsx` e ci è rimasto per centosessantacinque righe,
+// pur avendo da subito la forma esatta degli altri overlay: un modo dichiarato
+// in `CAPTURING_MODES`, uno stato proprio, un handler proprio, un'apertura con
+// precondizioni. È la prova che `MODE_KEYS` non basta come custode — quel
+// `Record` obbliga un modo nuovo ad avere un handler, non a tenerlo fuori dal
+// componente. Il gate che lo pretende è `test/input-wiring.test.ts`.
+//
+// La deroga di T104 vale anche qui: l'hook non esce dal deck. Costruire la
+// bozza e ordinarne l'esecuzione sono due cose diverse — la prima arriva come
+// `draftFor`, la seconda parte come `onSubmit`, ed entrambe vivono in
+// `actions.ts`. Quello che resta qui è lo stato del modale e i suoi tasti.
+import { useState } from 'react';
+export function usePurgeOverlay({ setMode, setNote, draftFor, onSubmit, }) {
+    // La bozza della conferma (null fuori dal modale).
+    const [draft, setDraft] = useState(null);
+    function open() {
+        const next = draftFor();
+        if (!next)
+            return;
+        setDraft(next);
+        setNote('');
+        setMode('purge');
+    }
+    function onKey(_input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setDraft(null);
+            setNote('CANC → eliminazione annullata');
+        }
+        else if (key.return) {
+            const current = draft;
+            setMode('normal');
+            setDraft(null);
+            if (current)
+                onSubmit(current);
+        }
+        else if ((key.leftArrow || key.rightArrow) && draft?.ignored) {
+            setDraft((p) => (p ? { ...p, ignored: p.ignored === 'keep' ? 'purge' : 'keep' } : p));
+        }
+    }
+    return { draft, open, onKey };
+}

package/dist/pane-views.js

@@ -4,8 +4,8 @@
 // vista raggiungibile con `tab`.
 //
 // 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
+// stava — `view.ts` per i filtri task, `session-list.ts` per l'assemblaggio
+// della lista — 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):
@@ -65,11 +65,6 @@ export function selectTasks(tasks, id, ctx) {
  *  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',
@@ -82,15 +77,19 @@ export const SESSION_VIEWS = [
         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)),
+        rows: (ctx) => ctx.assembled.rows.filter((r) => ctx.isLive(r.sessionId)),
         color: 'green',
         empty: 'nessuna conversazione viva in questa lista',
     },
     {
+        // T133 D7 — sola vista che NON filtra la lista: il suo insieme è più largo
+        // (le pinnate di ogni task, più le stale), quindi il core lo consegna a
+        // parte. Un filtro su `rows` mostrerebbe le sole pinnate del parent
+        // selezionato, cioè la risposta sbagliata alla domanda «quali ho pinnato».
         id: 'pinned',
         label: (c) => `📌${c.pinned}`,
         count: (c) => c.pinned,
-        rows: (ctx) => ctx.assembled.rows.filter((r) => r.kind === 'pinned'),
+        rows: (ctx) => ctx.assembled.pinnedRows,
         color: 'yellow',
         empty: 'nessuna conversazione pinnata',
     },
@@ -100,11 +99,7 @@ export const SESSION_VIEWS = [
         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,
-        })),
+        rows: (ctx) => ctx.assembled.overflowRows,
         dim: true,
         empty: 'nessuna conversazione oltre il cap',
     },

package/dist/plugin-cache.js

@@ -0,0 +1,106 @@
+// T134 — dove sta il plugin loom-works su questa macchina, e quale versione.
+//
+// Terza volta che il deck incontra l'assenza di `CLAUDE_PLUGIN_ROOT`: è una env
+// che esiste solo dentro un processo Claude Code, e il deck è un binario npm
+// spawnato da Ptyxis. Le prime due volte (età delle task archiviabili in
+// `archivable.ts`, gate `--ignored-files` in `purge.ts`) hanno RIPLICATO un
+// criterio di poche righe. Qui si risolve invece di duplicare, perché la
+// superficie da replicare sarebbe troppo grande — la grammatica del marker
+// inbox da un lato, le tre euristiche tarate dello scanner di wrap dall'altro —
+// e una divergenza fra le due copie non si vedrebbe finché non conta i file
+// sbagliati.
+//
+// L'allow `Read(~/.claude/plugins/cache/…/**)` che `init` scrive in
+// `.claude/settings.json` non c'entra: è un permesso per gli agent di Claude
+// Code. Il deck non passa dal motore dei permessi e non ha niente da farsi
+// autorizzare — gli manca soltanto di sapere quale versione eseguire.
+import { readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const MARKETPLACE_OWNER = 'lamemind';
+const PLUGIN_NAME = 'loom-works';
+/** Radice delle cache version-pinned del plugin. */
+export function pluginCacheRoot() {
+    const env = process.env.LOOM_DECK_PLUGIN_CACHE_ROOT;
+    if (env)
+        return env;
+    return join(homedir(), '.claude', 'plugins', 'cache', MARKETPLACE_OWNER, PLUGIN_NAME);
+}
+const SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;
+/**
+ * Confronto semver NUMERICO per componente: `-1` se `a` precede `b`, `1` se lo
+ * segue, `0` se pari.
+ *
+ * È il punto di tutto il modulo. In ordine lessicografico `10.1.3` precede
+ * `7.9.1` — `'1' < '7'` al primo carattere — quindi un `sort()` ingenuo su
+ * questa cartella sceglierebbe `9.0.0` fra le quaranta presenti, cioè una cache
+ * di due major fa, e lo farebbe senza dare alcun segno di sbagliare: gli script
+ * ci sono, girano, e rispondono col contratto di allora.
+ */
+export function compareSemver(a, b) {
+    const pa = SEMVER_RE.exec(a);
+    const pb = SEMVER_RE.exec(b);
+    if (!pa || !pb)
+        return 0;
+    for (let i = 1; i <= 3; i++) {
+        const diff = Number(pa[i]) - Number(pb[i]);
+        if (diff !== 0)
+            return diff < 0 ? -1 : 1;
+    }
+    return 0;
+}
+/** La più alta fra le versioni passate; `null` se nessuna è un semver X.Y.Z. */
+export function pickLatestVersion(names) {
+    let best = null;
+    for (const name of names) {
+        if (!SEMVER_RE.test(name))
+            continue;
+        if (best === null || compareSemver(name, best) > 0)
+            best = name;
+    }
+    return best;
+}
+/**
+ * Cache installata più recente, o `null` se il plugin non è installato su questa
+ * macchina (radice assente, o presente ma senza una sola cartella semver).
+ *
+ * `null` non è un errore da riportare: un deck su una macchina senza il plugin
+ * deve restare muto sugli indicatori che ne dipendono, non rompersi.
+ */
+export function resolvePluginCache() {
+    const root = pluginCacheRoot();
+    let names;
+    try {
+        names = readdirSync(root, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return null;
+    }
+    const version = pickLatestVersion(names);
+    if (version === null)
+        return null;
+    return { root: join(root, version), version };
+}
+/**
+ * La versione si risolve UNA VOLTA e resta quella per tutta la vita del
+ * processo. La cache cambia solo a un `plugin update`, quindi un deck aperto
+ * durante l'update continua a leggere la versione di prima fino al riavvio.
+ * È il limite accettato, e sta scritto qui invece di essere scoperto dopo.
+ */
+let resolved;
+export function pluginCache() {
+    if (resolved === undefined)
+        resolved = resolvePluginCache();
+    return resolved;
+}
+/** Path assoluto di uno script del plugin, `null` se il plugin non c'è. */
+export function pluginScript(relative) {
+    const cache = pluginCache();
+    return cache ? join(cache.root, relative) : null;
+}
+/** Solo per i test: dimentica la versione risolta al primo accesso. */
+export function resetPluginCache() {
+    resolved = undefined;
+}

package/dist/session-list.js

@@ -1,19 +1,26 @@
-// T50 — Assemblaggio della lista sessioni a DUE gruppi: pinnate (sempre in
-// lista, in cima) + separatore + contestuali (figlie del parent selezionato).
+// T133 — Assemblaggio della lista sessioni: UNA lista sola, le figlie del parent
+// selezionato in ordine `ts desc`. Il pin è un ATTRIBUTO della riga (glifo, vista
+// dedicata), non una posizione privilegiata.
 // Modulo PURO: nessun import da ink/react, nessun I/O → testabile senza terminale
 // (il pacchetto non ha infrastruttura TUI di test, solo unit sui core puri).
 //
-// Invarianti (decisioni congelate al preflight):
-//  - D2: dentro il blocco pinnate l'ordine è di PIN stabile (ultima pinnata in
-//    cima), dato dal rango del sidecar `session-tasks.jsonl` — non `ts desc`.
-//  - Dedup: una sessione sia pinnata sia contestuale compare SOLO fra le pinnate.
-//  - Cap: `maxContext` limita SOLO le contestuali; le pinnate sono esenti. Il
-//    conteggio delle troncate (`contextHidden`) resta esposto (non-silenzioso).
-//  - D3: una pinnata il cui transcript non esiste più è una riga STALE (session
-//    null), navigabile e spinnabile — non sparisce in silenzio.
-//  - Trap T39: la selezione è KEYED SU sessionId, non su indice posizionale. La
-//    lista è una vista trasformata (due gruppi + separatore): un indice grezzo
-//    identificherebbe la riga sbagliata dopo un pin/cambio-contesto.
+// Invarianti (decisioni congelate al preflight T133):
+//  - D1/D3: una forma sola di lista qualunque sia il parent, vista «tutte»
+//    compresa. Nessun criterio speciale per le righe pinnate: nessun blocco in
+//    cima, nessun ordine proprio, nessuna esenzione dal cap (D6).
+//  - D4: una pinnata compare in lista se e solo se è figlia del parent
+//    selezionato. Le pinnate fuori contesto vivono nella sola vista `📌`.
+//  - D7: le righe pinnate escono in un CAMPO A PARTE (`pinnedRows`), non dentro
+//    `rows`: il loro insieme è più largo della lista (tutte le sessioni del
+//    progetto più le stale), quindi non è esprimibile come filtro di `rows`.
+//  - D8: `pinnedRows` conserva l'ordine per RANGO di pin desc (ultima pinnata in
+//    cima), dato dal sidecar `session-tasks.jsonl`. È l'unico lettore rimasto del
+//    rango.
+//  - D5: una pinnata il cui transcript non esiste più è una riga STALE, presente
+//    nelle sole `pinnedRows` — navigabile e spinnabile dalla vista `📌`.
+//  - Trap T39: la selezione è KEYED SU sessionId, non su indice posizionale. Le
+//    righe a schermo sono quelle della vista attiva, e un indice grezzo
+//    identificherebbe la riga sbagliata al primo cambio di vista o di parent.
 import { cut, termWidth } from './width.js';
 // ── T53 · etichetta di riga ────────────────────────────────────────────────
 /**
@@ -121,66 +128,50 @@ export function rowLabel(text, note, budget) {
     return { note: shownNote, rest: restBudget >= MIN_REST ? cut(rest, restBudget) : '' };
 }
 export function assembleSessionList(childSessions, allSessions, pinned, maxContext) {
-    // Le pinnate si risolvono contro TUTTE le sessioni del progetto, non solo le
-    // figlie del parent: una pinnata può appartenere a un'altra task. Assente
-    // dallo store → stale.
-    const byId = new Map(allSessions.map((s) => [s.sessionId, s]));
-    const pinnedIds = [...pinned.entries()]
-        .sort((a, b) => b[1] - a[1]) // rango desc → ultima pinnata in cima (D2)
-        .map(([id]) => id);
-    const pinnedRows = pinnedIds.map((id) => {
-        const session = byId.get(id) ?? null;
-        return { kind: 'pinned', sessionId: id, session, stale: session === null };
-    });
-    const pinnedSet = new Set(pinnedIds);
-    const dedupedContext = childSessions.filter((s) => !pinnedSet.has(s.sessionId));
     const cap = Math.max(0, maxContext);
-    const shownContext = dedupedContext.slice(0, cap);
-    const overflowContext = dedupedContext.slice(cap);
-    const contextRows = shownContext.map((s) => ({
-        kind: 'context',
+    const toRow = (s) => ({
+        kind: 'session',
         sessionId: s.sessionId,
         session: s,
-    }));
-    const rows = [...pinnedRows];
-    // Separatore SOLO fra due gruppi entrambi non vuoti: senza pinnate o senza
-    // contestuali non c'è confine da segnare.
-    if (pinnedRows.length > 0 && contextRows.length > 0)
-        rows.push({ kind: 'separator' });
-    rows.push(...contextRows);
-    return {
-        rows,
-        pinnedCount: pinnedRows.length,
-        contextTotal: dedupedContext.length,
-        contextHidden: overflowContext.length,
-        contextOverflow: overflowContext,
-    };
-}
-function isSelectable(r) {
-    return r.kind !== 'separator';
+        pinned: pinned.has(s.sessionId),
+    });
+    const rows = childSessions.slice(0, cap).map(toRow);
+    const overflowRows = childSessions.slice(cap).map(toRow);
+    // Le pinnate si risolvono contro TUTTE le sessioni del progetto, non solo le
+    // figlie del parent: una pinnata può appartenere a un'altra task, e la vista
+    // dedicata è l'unico posto dove resta raggiungibile. Assente dallo store →
+    // stale.
+    const byId = new Map(allSessions.map((s) => [s.sessionId, s]));
+    const pinnedRows = [...pinned.entries()]
+        .sort((a, b) => b[1] - a[1]) // rango desc → ultima pinnata in cima (D8)
+        .map(([id]) => {
+        const session = byId.get(id);
+        return session
+            ? { kind: 'session', sessionId: id, session, pinned: true }
+            : { kind: 'stale', sessionId: id };
+    });
+    return { rows, pinnedRows, contextTotal: childSessions.length, overflowRows };
 }
-/** Primo id selezionabile (salta il separatore); null = lista senza righe. */
+/** Primo id della lista; null = lista senza righe. */
 export function firstSelectableId(rows) {
-    return rows.find(isSelectable)?.sessionId ?? null;
+    return rows[0]?.sessionId ?? null;
 }
 /** Indice della riga con quel sessionId nell'ARRAY COMPLETO (per il windowing);
- *  -1 se assente o id null. Il separatore non ha id → mai matchato. */
+ *  -1 se assente o id null. */
 export function rowIndexOf(rows, sessionId) {
     if (sessionId === null)
         return -1;
-    return rows.findIndex((r) => isSelectable(r) && r.sessionId === sessionId);
+    return rows.findIndex((r) => r.sessionId === sessionId);
 }
-/** Sposta la selezione di `delta` fra le sole righe selezionabili (attraversa il
- *  separatore senza fermarcisi). Id perso → prima riga; lista vuota → null. */
+/** Sposta la selezione di `delta`. Id perso → prima riga; lista vuota → null. */
 export function moveSelection(rows, currentId, delta) {
-    const selectable = rows.filter(isSelectable);
-    if (selectable.length === 0)
+    if (rows.length === 0)
         return null;
-    const cur = selectable.findIndex((r) => r.sessionId === currentId);
+    const cur = rows.findIndex((r) => r.sessionId === currentId);
     if (cur < 0)
-        return selectable[0].sessionId;
-    const next = Math.max(0, Math.min(selectable.length - 1, cur + delta));
-    return selectable[next].sessionId;
+        return rows[0].sessionId;
+    const next = Math.max(0, Math.min(rows.length - 1, cur + delta));
+    return rows[next].sessionId;
 }
 /**
  * T57 — id su cui atterrare quando la riga `sessionId` sta per USCIRE dalla
@@ -192,44 +183,19 @@ export function moveSelection(rows, currentId, delta) {
  * assegnazione rimanderebbe la selezione in cima. L'id va catturato PRIMA di
  * riscrivere il sidecar — dopo, la riga non c'è più e il vicino non è
  * calcolabile.
- */
-export function neighborId(rows, sessionId) {
-    const selectable = rows.filter(isSelectable);
-    const at = selectable.findIndex((r) => r.sessionId === sessionId);
-    if (at < 0)
-        return null;
-    return selectable[at + 1]?.sessionId ?? selectable[at - 1]?.sessionId ?? null;
-}
-/**
- * Id su cui atterrare quando la riga pinnata `sessionId` viene SPINNATA: la
- * pinnata successiva, la precedente se era l'ultima, la prima contestuale se il
- * gruppo pinnate si svuota. `null` se `sessionId` non è pinnata o non resta
- * nessuna riga.
  *
- * Non è `neighborId` ristretto al gruppo: quello attraversa il separatore,
- * quindi sull'ULTIMA pinnata atterrerebbe sulla prima contestuale — il caret
- * scavalcherebbe l'intero gruppo invece di risalire di una riga. Qui il confine
- * fra i due gruppi è la regola, non un ostacolo.
- *
- * L'id va calcolato PRIMA di riscrivere il sidecar: dopo, la riga pinnata non
- * c'è più e il vicino nel gruppo non è calcolabile. Serve perché una spinnata
- * non sparisce necessariamente dalla lista — se appartiene al parent
- * selezionato ricompare fra le contestuali, e la selezione keyed sull'id la
- * seguirebbe fin laggiù, trascinando il caret.
+ * T133 D12 — stesso servizio per l'unpin dentro la vista `📌`, dove spinnare fa
+ * uscire la riga. Nella lista principale non serve: lì una pinnata è in lista
+ * perché è figlia del parent, e spinnarla non la fa uscire.
  */
-export function unpinLandingId(rows, sessionId) {
-    const pinnedRows = rows.filter((r) => r.kind === 'pinned');
-    const at = pinnedRows.findIndex((r) => r.sessionId === sessionId);
+export function neighborId(rows, sessionId) {
+    const at = rows.findIndex((r) => r.sessionId === sessionId);
     if (at < 0)
         return null;
-    const inGroup = pinnedRows[at + 1]?.sessionId ?? pinnedRows[at - 1]?.sessionId;
-    if (inGroup)
-        return inGroup;
-    const firstContext = rows.find((r) => r.kind === 'context');
-    return firstContext && isSelectable(firstContext) ? firstContext.sessionId : null;
+    return rows[at + 1]?.sessionId ?? rows[at - 1]?.sessionId ?? null;
 }
 /** Session della riga selezionata; null se stale o nessuna selezione. */
 export function selectedSession(rows, sessionId) {
-    const r = rows.find((row) => isSelectable(row) && row.sessionId === sessionId);
-    return r && isSelectable(r) ? r.session : null;
+    const r = rows.find((row) => row.sessionId === sessionId);
+    return r && r.kind === 'session' ? r.session : null;
 }