@lamemind/loom-deck 0.22.0 → 0.23.0

package/dist/cli.js

@@ -12,9 +12,9 @@ import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, } from '.
 import { discoverProjectSessions } from './sessions.js';
 import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions, selectedRow, DEFAULT_OPTIONS, MIN_QUERY, } from './search.js';
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, loadSessionIndex, } from './task-index.js';
-import { assembleSessionList, firstSelectableId, moveSelection, rowIndexOf, rowLabel, selectedSession, stripProjectCore, } from './session-list.js';
+import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, rowLabel, selectedSession, stripProjectCore, } from './session-list.js';
 import { cellWidth, launchLegend, loadIdentity, loadLaunch } from './config.js';
-import { isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
+import { assignListCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { caretWindow, cut, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, progressText, writeTaskEdit, PRI_GLYPH, PRI_LABEL, PROG_GLYPH, } from './task-edit.js';
@@ -511,6 +511,17 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // trovando la lista esattamente com'era.
     const [readerRow, setReaderRow] = useState(null);
     const [readerTop, setReaderTop] = useState(0);
+    // T57 — stato del modale di assegnazione sessione → task.
+    //
+    // `assignSid` è la conversazione in assegnazione, FOTOGRAFATA all'apertura e
+    // non riletta da `selSessionId`: il modale è fullscreen (D3), quindi il pane
+    // sessioni non è più a schermo e l'oggetto dell'azione deve restare quello
+    // che si è scelto — anche se un tick del poll rimescolasse la lista sotto.
+    // `assignSel` è la task di destinazione: `null` è la riga `detach` (D2), che
+    // sta sempre in testa e scrive un binding vuoto.
+    const [assignSid, setAssignSid] = useState(null);
+    const [assignFilter, setAssignFilter] = useState('');
+    const [assignSel, setAssignSel] = useState(null);
     // Dimensioni vive del terminale: sono l'input del budget d'altezza sotto.
     const { rows, columns } = useTerminalSize();
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
@@ -587,6 +598,25 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const readerLines = useMemo(() => (readerRow?.kind === 'hit' ? wrapWithOffsets(readerRow.hit.text, readerWidth) : []), [readerRow, readerWidth]);
     const readerCap = readerCapacity(rows);
     const readerMaxTop = Math.max(0, readerLines.length - readerCap);
+    // T57 — righe del modale assegnazione: `null` (detach) in testa, poi le task
+    // della VISTA corrente (D4 — filtri e sort inclusi, coerenza con ciò che si
+    // stava leggendo a sinistra; le escluse restano contate nell'header).
+    //
+    // Il filtro è un substring case-insensitive su id + titolo grezzo (D5): un
+    // restringimento veloce, non una ricerca — quella è `^F` e ha il suo motore.
+    // Il solo id non basterebbe, perché il caso d'uso nasce proprio dal «ho
+    // capito ora che questa conversazione è la task del titolo X».
+    //
+    // `detach` NON si filtra: è l'azione di svuotamento, non una task, e sparire
+    // digitando la renderebbe raggiungibile solo a campo vuoto.
+    const assignRows = useMemo(() => {
+        const q = assignFilter.trim().toLowerCase();
+        const matched = q
+            ? viewTasks.filter((t) => t.id.toLowerCase().includes(q) || t.rawDesc.toLowerCase().includes(q))
+            : viewTasks;
+        return [null, ...matched];
+    }, [viewTasks, assignFilter]);
+    const assignCap = assignListCapacity(rows, Boolean(note));
     // T39 — selezione stabile sotto trasformazione. Se la task selezionata esce
     // dalla vista (filtro appena attivato, oppure sparita da tasks.md), si cade
     // sulla prima visibile — fallback deterministico, mai una posizione a caso.
@@ -613,6 +643,16 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setSearchSelKey(firstRowKey(searchRows));
         }
     }, [searchRows, searchSelKey]);
+    // T57 — la lista del modale si restringe a ogni carattere digitato: quando la
+    // task selezionata esce dal filtro si cade sulla PRIMA TASK, non su `detach`.
+    // Cadere su detach significherebbe che un `⏎` battuto di slancio dopo aver
+    // digitato staccherebbe la sessione invece di assegnarla — l'esatto opposto
+    // dell'intenzione. Senza match la selezione resta detach: è l'unica riga viva.
+    useEffect(() => {
+        if (assignSel !== null && !assignRows.some((t) => t?.id === assignSel)) {
+            setAssignSel(assignRows[1]?.id ?? null);
+        }
+    }, [assignRows, assignSel]);
     // T30: submit dell'input box. Il taskId nasce DOPO create-task (lo assegna la
     // skill scrivendo tasks.md) → non è noto allo spawn. Il sessionId invece è
     // pinnato qui: snapshot degli id PRIMA, poi al completamento re-leggo tasks.md
@@ -712,6 +752,58 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             ? `✎ nota su ${sid.slice(0, 8)}: "${cut(text, 40)}"`
             : `✎ nota rimossa da ${sid.slice(0, 8)}`);
     }
+    // T57 — apertura del modale di assegnazione. La preselezione è la task a cui
+    // la sessione è GIÀ legata (riassegnare è quasi sempre correggere, e vedere da
+    // dove si parte è metà dell'informazione), altrimenti la prima della vista.
+    // Mai `detach`: è l'azione distruttiva della lista, e preselezionarla
+    // metterebbe un `⏎` battuto di slancio a un tasto dal cancellare un binding.
+    function openAssign() {
+        const sid = selSessionId;
+        if (!sid)
+            return;
+        const bound = bindings.get(sid);
+        setAssignSid(sid);
+        setAssignFilter('');
+        setAssignSel(bound && viewTasks.some((t) => t.id === bound) ? bound : viewTasks[0]?.id ?? null);
+        setNote('');
+        setMode('assign');
+    }
+    // Sposta la selezione del modale sulle righe (0 = detach, 1..N = task filtrate).
+    function moveAssign(delta) {
+        const at = assignRows.findIndex((t) => (t?.id ?? null) === assignSel);
+        const next = Math.max(0, Math.min(assignRows.length - 1, (at < 0 ? 0 : at) + delta));
+        setAssignSel(assignRows[next]?.id ?? null);
+    }
+    // T57 — ⏎ nel modale: riscrive il binding nel sidecar e ricarica subito.
+    //
+    // Il binding retroattivo governa il FUTURO della conversazione, non il suo
+    // passato: il titolo della tab è stato deciso allo spawn da `claude --name` e
+    // vive nel transcript, la `LOOM_TASK` di un processo già partito non si
+    // reinietta. Cambia cosa fa il prossimo `⏎ resume`, che rilegge il binding dal
+    // sidecar. La nota lo dice: senza, la promessa implicita è «ho spostato la
+    // conversazione» e il titolo che non cambia sembra un bug.
+    //
+    // Dove atterra la selezione (D6): il pane task non si muove, quindi la
+    // sessione appena assegnata esce dal gruppo contestuale → si scende alla riga
+    // SUCCESSIVA, catturata PRIMA della riscrittura (dopo, la riga non c'è più).
+    // Due eccezioni in cui invece resta dov'è, perché non sparisce affatto: una
+    // pinnata (esente dal contesto) e un'assegnazione al parent già selezionato.
+    function submitAssign() {
+        const sid = assignSid;
+        const target = assignSel;
+        setMode('normal');
+        setAssignFilter('');
+        if (!sid)
+            return;
+        const stays = pinned.has(sid) || target === selectedTaskId;
+        const next = stays ? sid : neighborId(sessionRows, sid);
+        appendTaskBinding(cwd, sid, target ?? '');
+        reloadSessions();
+        setSelSessionId(next);
+        setNote(target
+            ? `A ${sid.slice(0, 8)} → ${target} · vale dal prossimo ⏎ resume (titolo tab invariato)`
+            : `A ${sid.slice(0, 8)} → spot · binding rimosso`);
+    }
     // T41 — apertura dell'edit: la bozza parte dai valori ATTUALI della task, non
     // da default. La priorità arriva dal glifo di tasks.md (già in `selTask`), lo
     // stato dal suo glifo Prog; il progresso arbitrario dal campo `Progress` del
@@ -967,6 +1059,46 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             return;
         }
+        // T57 — modale di assegnazione: un campo di filtro più una lista. Come
+        // ricerca e nota, il campo mangia ogni lettera nuda → `^U` (kill-line delle
+        // shell) per svuotarlo, e la navigazione passa dalle frecce.
+        if (mode === 'assign') {
+            if (key.escape) {
+                setMode('normal');
+                setAssignFilter('');
+                setNote('A → assegnazione annullata');
+            }
+            else if (key.return) {
+                submitAssign();
+            }
+            else if (key.upArrow) {
+                moveAssign(-1);
+            }
+            else if (key.downArrow) {
+                moveAssign(1);
+            }
+            else if (key.pageUp) {
+                moveAssign(-Math.max(1, assignCap));
+            }
+            else if (key.pageDown) {
+                moveAssign(Math.max(1, assignCap));
+            }
+            else if (key.ctrl) {
+                // `^U` svuota; ogni altra combo è no-op. Il backspace tenuto premuto
+                // cancella un carattere per CHUNK letto da stdin, non per pressione
+                // (T53): senza `^U` ripulire un filtro digitato di getto sarebbe lento
+                // quanto riaprire il modale.
+                if (input === 'u')
+                    setAssignFilter('');
+            }
+            else if (key.backspace || key.delete) {
+                setAssignFilter((f) => f.slice(0, -1));
+            }
+            else if (input && !key.meta) {
+                setAssignFilter((f) => f + sanitizeTyped(input));
+            }
+            return;
+        }
         // T30: in modalità create l'handler cattura il testo e corto-circuita la
         // navigazione normale (incl. q/esc → quit: qui esc annulla, non esce).
         if (mode === 'create') {
@@ -1313,6 +1445,24 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 openNote();
             }
         }
+        else if (input === 'A') {
+            // T57 — assegna la conversazione selezionata a una task. MAIUSCOLA perché
+            // apre un modale (convenzione T39), e il modale è obbligatorio: il pane
+            // task non può fare da picker, perché spostare la selezione lì cambia il
+            // parent e la sessione da assegnare sparisce dalla lista sotto le mani.
+            // Vincolo di focus identico a `p`/`N`, e vale anche su una pinnata STALE:
+            // 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)');
+            }
+            else if (!selSessionId) {
+                setNote('A → nessuna sessione da assegnare');
+            }
+            else {
+                openAssign();
+            }
+        }
         else if (input === 't') {
             const title = identity ? `🖥️ ${identity.name} [term]` : null;
             const child = spawnTerminal(cwd, title);
@@ -1383,7 +1533,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const keyLegend = sanitize([
         ...(canSpawn ? ['⏎/^K/^P/^R spawn'] : canResume ? ['⏎ resume'] : []),
         ...(canResume ? ['f fork'] : []),
-        ...(canPin ? ['p pin', 'N nota'] : []),
+        ...(canPin ? ['p pin', 'N nota', 'A assegna'] : []),
         '^F cerca',
         'C nuova',
         'E edit',
@@ -1391,6 +1541,26 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         'F filtri',
         'w salva',
     ].join(' · '));
+    // ── T57 · schermata di assegnazione ─────────────────────────────────────
+    // Sostitutiva come ricerca e reader (D3): la lista task non entra in un box
+    // sopra i due pane, e prendendo l'intero frame non costa nulla al loro budget.
+    // Conseguenza obbligata della scelta: la sessione in assegnazione non è più
+    // visibile, quindi va RIPETUTA nel titolo — senza, non si sa più su cosa si
+    // sta agendo.
+    if (mode === 'assign') {
+        if (isCompact(assignCap)) {
+            return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 assegna \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga \u00B7 esc annulla"] })] }));
+        }
+        const at = assignRows.findIndex((t) => (t?.id ?? null) === assignSel);
+        const win = windowRange(assignRows.length, at, assignCap);
+        const s = assignSid ? sessions.find((x) => x.sessionId === assignSid) ?? null : null;
+        // Etichetta della conversazione: la nota umana se c'è (è il nome con cui la
+        // riconosci), altrimenti la stessa derivazione della ricerca. Su una pinnata
+        // stale non resta nulla: il titolo si accontenta dell'hash.
+        const label = (assignSid ? sessionNotes.get(assignSid) : '') ||
+            (s ? conversationLabel(s, projectCore, assignSid ? bindings.get(assignSid) : undefined) : '');
+        return (_jsx(AssignScreen, { sessionId: assignSid ?? '', label: label, current: assignSid ? bindings.get(assignSid) ?? null : null, filter: assignFilter, rows: assignRows.slice(win.start, win.end), selected: assignSel, matched: assignRows.length - 1, hidden: hiddenTasks, above: win.start, below: assignRows.length - win.end, childCount: childCount, columns: columns, note: note }));
+    }
     // ── T52 · schermate sostitutive ─────────────────────────────────────────
     // Ricerca e reader sono gli unici modali che NON stanno in flusso sopra i
     // pane: una lista di occorrenze non entra in un box da 4 righe. Prendono
@@ -1667,6 +1837,52 @@ function ReaderLine({ line, from, to }) {
     }
     return (_jsxs(Text, { wrap: "truncate-end", children: [line.text.slice(0, a), _jsx(Text, { backgroundColor: "yellow", color: "black", children: line.text.slice(a, b) }), line.text.slice(b)] }));
 }
+/**
+ * Larghezza del testo dentro la lista della schermata di assegnazione: box
+ * esterno (2 bordi + 2 padding) + box lista (2 bordi + 2 padding).
+ *
+ * Invariante ③ (`width.ts`): il taglio lo fa il chiamante. Delegarlo a
+ * `wrap="truncate-end"` passerebbe da `cli-truncate`, che restituisce una riga
+ * più larga di quella chiesta di una colonna per emoji — e quelle colonne
+ * finiscono sopra il bordo, che sparisce dalla riga.
+ */
+function assignTextWidth(columns) {
+    return Math.max(20, (columns || 80) - 8);
+}
+/**
+ * Schermata di assegnazione di una conversazione a una task (T57).
+ *
+ * Fullscreen sostitutiva (D3) come la ricerca: la lista task non entra in un
+ * box sopra i due pane. Da lì discende che l'oggetto dell'azione — la sessione
+ * selezionata, che non è più a schermo — va ripetuto nel titolo.
+ *
+ * L'header della lista conta le task escluse dai filtri della vista (D4): la
+ * scelta di mostrare `viewTasks` e non tutte le task ha come prezzo noto che un
+ * filtro può nascondere proprio il bersaglio, e quel prezzo non deve essere
+ * silenzioso — stessa convenzione del `+N più vecchie` del pane sessioni.
+ */
+function AssignScreen({ sessionId, label, current, filter, rows, selected, matched, hidden, above, below, childCount, columns, note, }) {
+    const width = assignTextWidth(columns);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["assegna ", _jsx(Text, { color: "cyan", children: sessionId.slice(0, 8) }), label ? ` «${cut(sanitize(label), Math.max(10, Math.floor(width / 4)))}»` : '', " \u00B7 ora", ' ', current ? _jsx(Text, { color: "green", children: current }) : 'spot', " \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), ' ', "assegna \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " pulisci \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }), _jsx(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "filtro " }), _jsx(Text, { color: "yellow", children: cut(filter, Math.max(8, width - 24)) }), _jsx(Text, { inverse: true, children: " " }), !filter ? _jsx(Text, { dimColor: true, children: "  (id o titolo)" }) : null] }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [matched, " task", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", hidden, " fuori dai filtri"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }), rows.map((task) => {
+                        // T57/D2 — `detach` è una VOCE della lista, non un tasto a parte: un
+                        // solo gesto (`A`), un solo modale. Speculare alla riga meta `spot`
+                        // del pane task, e nominata con l'AZIONE («detach») invece che con lo
+                        // stato d'arrivo — è ciò che si sta per fare.
+                        if (!task) {
+                            const sel = selected === null;
+                            // Le colonne fisse (caret + `○ detach` + i due spazi) sono 12: solo
+                            // la glossa si taglia, così su un terminale stretto resta comunque
+                            // il nome dell'azione invece di un moncone di frase.
+                            return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, "\u25CB detach  ", cut('la sessione torna spot', width - 12)] }, "detach"));
+                        }
+                        const sel = selected === task.id;
+                        const n = childCount.get(task.id) ?? 0;
+                        const head = `${CARET_OFF}${task.id}  ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
+                        const tail = n > 0 ? ` (${n})` : '';
+                        const desc = cut(task.desc, Math.max(4, width - termWidth(head) - termWidth(tail)));
+                        return (_jsxs(Text, { inverse: sel, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
+                    })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+}
 function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, childCount, focused, loadError, detail, windowStart, above, below, detailLines, columns, }) {
     const spotSelected = selected === 0;
     return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: ["Tasks (", hidden > 0 ? `${filtered}/${total}` : filtered, ")", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", hidden, " nascoste"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort: ", describeSort(view.sort), view.hiddenPri.length + view.hiddenProg.length > 0 ? (_jsxs(Text, { children: [' ', "\u00B7 filtri:", ' ', [

package/dist/session-list.js

@@ -139,6 +139,24 @@ export function moveSelection(rows, currentId, delta) {
     const next = Math.max(0, Math.min(selectable.length - 1, cur + delta));
     return selectable[next].sessionId;
 }
+/**
+ * T57 — id su cui atterrare quando la riga `sessionId` sta per USCIRE dalla
+ * lista (riassegnata a un'altra task): la SUCCESSIVA, o la precedente se era
+ * l'ultima, null se era l'unica.
+ *
+ * Serve perché il fallback di `moveSelection` (id perso → prima riga) qui
+ * sarebbe sbagliato: smistare una spot dopo l'altra è il caso d'uso, e ogni
+ * 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;
+}
 /** 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);

package/dist/task-index.js

@@ -9,6 +9,11 @@ export function appendSessionRecord(projectRoot, rec) {
     mkdirSync(dirname(path), { recursive: true });
     appendFileSync(path, JSON.stringify({ ...rec, ts: new Date().toISOString() }) + '\n');
 }
+/**
+ * Lega una sessione a una task. T57 — vale sia alla nascita (spawn) sia dopo:
+ * un secondo record con un `taskId` diverso RIASSEGNA la conversazione, e
+ * `taskId` VUOTO la stacca (torna spot), come `note:''` cancella la nota.
+ */
 export function appendTaskBinding(projectRoot, sessionId, taskId) {
     appendSessionRecord(projectRoot, { sessionId, taskId });
 }
@@ -45,8 +50,16 @@ export function loadSessionIndex(projectRoot) {
             const d = JSON.parse(line);
             if (typeof d.sessionId !== 'string')
                 continue;
-            if (typeof d.taskId === 'string')
-                bindings.set(d.sessionId, d.taskId);
+            // T57 — last-wins con la stringa vuota come CANCELLAZIONE: `taskId:''`
+            // toglie la chiave, così chi legge non deve distinguere «mai legata» da
+            // «staccata» (sono la stessa cosa: spot). Il `typeof` esclude i record
+            // senza il campo, che non devono toccare un binding scritto prima.
+            if (typeof d.taskId === 'string') {
+                if (d.taskId)
+                    bindings.set(d.sessionId, d.taskId);
+                else
+                    bindings.delete(d.sessionId);
+            }
             if (typeof d.forkOf === 'string')
                 forkOf.set(d.sessionId, d.forkOf);
             // last-wins per campo: un `pinned:false` finale rimuove il pin, un

package/dist/viewport.js

@@ -49,6 +49,11 @@ export const MODAL_HEIGHT = {
     // distribuiscono `searchListCapacity`/`readerCapacity`.
     search: 0,
     reader: 0,
+    // T57 — assign è la terza schermata sostitutiva, per la stessa ragione della
+    // ricerca: la lista task non entra in un box sopra i due pane, e in flusso
+    // pagherebbe due volte (il suo costo + quello che toglie ai pane sotto, che
+    // in quel momento non si stanno nemmeno guardando).
+    assign: 0,
 };
 /**
  * Distribuisce le righe disponibili fra lista task, lista sessioni e dettaglio.
@@ -154,6 +159,24 @@ const SEARCH_CHROME = 14;
 export function searchListCapacity(rows, noteLine) {
     return Math.max(0, (rows || 24) - SLACK - SEARCH_CHROME - (noteLine ? 1 : 0));
 }
+// T57 — cornice della schermata di assegnazione. Gemella di SEARCH_CHROME, con
+// un box filtro di UNA riga invece di tre.
+//
+//   2  bordi del box esterno
+//   1  titolo "loom-deck"
+//   1  riga hint/legenda tasti
+//   1  marginTop del box filtro
+//   2  bordi del box filtro
+//   1  riga del filtro
+//   1  marginTop del box lista
+//   2  bordi del box lista
+//   1  header della lista (conteggi + escluse dai filtri)
+const ASSIGN_CHROME = 12;
+/** Righe di lista task che entrano nel terminale. Zero = nemmeno la cornice ci
+ *  sta → schermata sostituita dalla riga compatta (`isCompact`). */
+export function assignListCapacity(rows, noteLine) {
+    return Math.max(0, (rows || 24) - SLACK - ASSIGN_CHROME - (noteLine ? 1 : 0));
+}
 // T52 — cornice del reader fullscreen.
 //   2  bordi del box esterno
 //   1  titolo "loom-deck"

package/package.json

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