@lamemind/loom-deck 0.33.0 → 0.34.1

package/dist/glyphs.js

@@ -0,0 +1,83 @@
+// Glifi letterali del frame e formatter di display. Fase VISTA, ma senza JSX:
+// tutto qui è puro e testabile, e nessun sito di render scrive un glifo nudo.
+import { sanitize } from './width.js';
+// Glifi LETTERALI del JSX. I dati passano dai loader, che sanificano al
+// confine; questi no — quindi passano da `sanitize` una volta qui, così nessun
+// sito di render scrive un glifo nudo. `↳ ○ ▸ ⏎ · − ↑ ↓` sono già concordi e
+// restano intatti; `▶` e `⚠` sono discordi e vengono sostituiti (`width.ts`).
+export const CARET = sanitize('▶ ');
+export const CARET_OFF = '  ';
+export const WARN = sanitize('⚠');
+// T50 — separatore leggero fra blocco pinnate e contestuali. `─` (box-drawing) è
+// largo 1 sia per string-width sia per il terminale. Corto +
+// wrap="truncate-end" così non va mai a capo nel pane al 50%.
+export const SESSION_SEP = '─'.repeat(16);
+// Prefisso del sessionId mostrato in lista: stesso dato e stessa lunghezza del
+// widget `⛓ <8 char>` della statusline, così le due superfici si confrontano a
+// occhio.
+export const SID_CHARS = 8;
+/** T60 — segnaposto della colonna task su una riga senza binding. Una cella
+ *  vuota di soli spazi lascerebbe un buco che si legge come "colonna finita",
+ *  e la riga tornerebbe a sembrare disallineata pur non essendolo. */
+export const TASK_EMPTY = '·';
+// T62 — colonna liveness, larga 1, incollata al sessionId senza gutter proprio:
+// il glifo qualifica QUELL'id, e uno spazio in mezzo lo farebbe leggere come una
+// colonna a sé. Entrambi Ambiguous (EAW) → 1 colonna per il terminale e 1 cella
+// per Ink, quindi concordi (invariante ① di width.ts): il pieno/vuoto del
+// cerchio è l'unico asse che varia, e resta scandibile in verticale.
+//
+// Sulla riga CHIUSA c'è uno spazio e non un terzo glifo: le chiuse sono la
+// maggioranza di ogni lista, e marcarle vorrebbe dire disegnare N volte «niente
+// da dire» — la colonna diventerebbe rumore invece di un segnale.
+export const LIVE_IDLE = '●';
+export const LIVE_BUSY = '◍';
+export const LIVE_NONE = ' ';
+// Marker Done per il DISPLAY. `task.prog` resta il `✔️` letto da tasks.md —
+// `isDone()` e le lookup di `view.ts` ci confrontano sopra, e `task-edit` lo
+// riscrive sul file: è una chiave semantica, non testo. Qui `sanitize` lo
+// traduce nel suo gemello concorde (`✅`) solo per finire nel frame.
+export function displayProg(prog) {
+    return sanitize(prog);
+}
+// T49 — size umana compatta per il detail pane sessione.
+export function fmtSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+// T49 — ultima attività ESTESA (giorno/mese ora:minuti) per il detail pane;
+// nella riga di lista resta il relTime compatto.
+export function fmtDateTime(ts) {
+    const d = new Date(ts);
+    const p = (n) => String(n).padStart(2, '0');
+    return `${p(d.getDate())}/${p(d.getMonth() + 1)} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+// Età relativa compatta (ms epoch → "2m"/"3h"/"5d") per il preview sessioni.
+export function relTime(ts) {
+    const sec = Math.max(0, Math.floor((Date.now() - ts) / 1000));
+    if (sec < 60)
+        return `${sec}s`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h`;
+    return `${Math.floor(hr / 24)}d`;
+}
+/**
+ * Ripulisce un chunk di stdin prima di scriverlo in un campo di testo.
+ *
+ * `useInput` consegna il CHUNK letto da stdin, non un tasto: un incollaggio — o
+ * una raffica piu' veloce di una read — arriva come stringa unica, byte di
+ * controllo compresi. Non si vedono a schermo, ma Ink li conta nella larghezza
+ * della riga, e in un campo che finisce su disco (la nota, T53) resterebbero
+ * li' per sempre. Le newline diventano SPAZIO invece di sparire: incollare due
+ * righe deve separare le parole, non fonderle.
+ */
+export function sanitizeTyped(s) {
+    return s.replace(/[\r\n]/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '');
+}
+export const META_KEYS = ['Priority', 'Size', 'Estimated Time', 'Progress'];

package/dist/hooks.js

@@ -0,0 +1,192 @@
+// Fase ACQUISIZIONE DATI: i cinque hook che portano dentro il componente ciò
+// che sta fuori — dimensioni del terminale, tasks.md, sessioni del progetto,
+// task archiviabili, task file selezionato. Ognuno possiede la propria cadenza
+// di refresh e non sa nulla della vista che li consuma.
+import { useState, useEffect, useRef } from 'react';
+import { useStdout } from 'ink';
+import { statSync } from 'node:fs';
+import { loadTasks, loadTaskDetail } from './tasks.js';
+import { discoverProjectSessions } from './sessions.js';
+import { discoverLiveSessions, liveSig } from './live-sessions.js';
+import { loadSessionIndex } from './task-index.js';
+import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
+import { POLL_MS } from './model.js';
+// Dimensioni del terminale, live sul resize.
+//
+// Non è una comodità di layout: senza `rows` il frame non ha tetto, e un frame
+// più alto del terminale fa cadere Ink nel ramo `clearTerminal` (ink.js:121)
+// che su VTE/Ptyxis riversa ogni redraw nello scrollback.
+//
+// Il valore iniziale conta quanto il resize: una tab Ptyxis appena aperta parte
+// spesso a 24 righe e riceve il SIGWINCH subito dopo. Nella finestra fra i due
+// il deck disegnava già a piena altezza — motivo per cui lo scrollback risultava
+// sporco fin dall'avvio, prima ancora di toccare un tasto.
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({ rows: stdout.rows || 24, columns: stdout.columns || 80 });
+    useEffect(() => {
+        const onResize = () => setSize({ rows: stdout.rows || 24, columns: stdout.columns || 80 });
+        stdout.on('resize', onResize);
+        onResize(); // allinea se il resize è arrivato prima del mount
+        return () => {
+            stdout.off('resize', onResize);
+        };
+    }, [stdout]);
+    return size;
+}
+// Carica tasks.md e lo ri-legge quando cambia sotto (poll su mtime). Poll
+// (non fs.watch) perché i writer di tasks.md — checkpoint-task/create-task —
+// riscrivono il file (probabile replace atomico), che rompe il watch sull'inode
+// originale; statSync(path) segue sempre il file corrente al path.
+export function useTasks(tasksPath) {
+    const [tasks, setTasks] = useState([]);
+    const [loadError, setLoadError] = useState('');
+    useEffect(() => {
+        let lastMtime = -1;
+        const reload = () => {
+            try {
+                const mtime = statSync(tasksPath).mtimeMs;
+                if (mtime === lastMtime)
+                    return; // invariato → niente re-read
+                lastMtime = mtime;
+                setTasks(loadTasks(tasksPath));
+                setLoadError('');
+            }
+            catch {
+                lastMtime = -1; // così quando il file riappare viene ri-letto
+                setTasks([]);
+                setLoadError(`tasks.md non leggibile: ${tasksPath}`);
+            }
+        };
+        reload();
+        const id = setInterval(reload, POLL_MS);
+        return () => clearInterval(id);
+    }, [tasksPath]);
+    return { tasks, loadError };
+}
+// Poll delle sessioni del progetto + binding sidecar. discoverProjectSessions
+// ha cache mtime-keyed interna → il poll è economico; qui si evita comunque il
+// re-render inutile con una signature (sessionId:ts + binding entries): setState
+// solo quando cambia davvero qualcosa.
+export function useSessions(projectRoot) {
+    const [state, setState] = useState({
+        sessions: [],
+        bindings: new Map(),
+        forkOf: new Map(),
+        pinned: new Map(),
+        notes: new Map(),
+        live: new Map(),
+    });
+    // T50 — pin/unpin scrive il sidecar e vuole feedback IMMEDIATO, non al
+    // prossimo tick del poll (1.5s): la reload è esposta via ref così il toggle la
+    // richiama senza risottoscrivere l'intervallo.
+    const reloadRef = useRef(() => { });
+    useEffect(() => {
+        let lastSig = '';
+        const reload = () => {
+            let sessions;
+            let index;
+            try {
+                sessions = discoverProjectSessions(projectRoot);
+                index = loadSessionIndex(projectRoot);
+            }
+            catch {
+                sessions = [];
+                index = { bindings: new Map(), forkOf: new Map(), pinned: new Map(), notes: new Map() };
+            }
+            // T62 — le vive stanno sullo STESSO tick delle altre fonti, non su una
+            // scala propria come `useArchivable`: `status` cambia a ogni turno, quindi
+            // un refresh più lento mostrerebbe `idle` su una sessione che lavora.
+            // Il try è separato perché il registry è una fonte indipendente: se manca
+            // (versione del CLI che non lo scrive) la lista deve restare, senza vive.
+            let live;
+            try {
+                live = discoverLiveSessions(projectRoot);
+            }
+            catch {
+                live = new Map();
+            }
+            const { bindings, forkOf, pinned, notes } = index;
+            // La signature copre anche fork, pin e note: un record di lineage, un
+            // toggle di pin o una nota appena scritta cambiano la lista renderizzata,
+            // quindi devono forzare il re-render come farebbe un binding nuovo.
+            const sig = sessions.map((s) => `${s.sessionId}:${s.ts}`).join('|') +
+                '#' +
+                [...bindings.entries()].map(([k, v]) => `${k}=${v}`).sort().join(',') +
+                '#' +
+                [...forkOf.entries()].map(([k, v]) => `${k}<${v}`).sort().join(',') +
+                '#' +
+                [...pinned.entries()].map(([k, v]) => `${k}@${v}`).sort().join(',') +
+                '#' +
+                [...notes.entries()].map(([k, v]) => `${k}"${v}`).sort().join(',') +
+                '#' +
+                liveSig(live);
+            if (sig === lastSig)
+                return;
+            lastSig = sig;
+            setState({ sessions, bindings, forkOf, pinned, notes, live });
+        };
+        reloadRef.current = reload;
+        reload();
+        const id = setInterval(reload, POLL_MS);
+        return () => clearInterval(id);
+    }, [projectRoot]);
+    return { ...state, reload: () => reloadRef.current() };
+}
+// T61 — conteggio delle Done oltre soglia, su una scala di refresh TUTTA SUA.
+//
+// Non è appeso a POLL_MS (1,5s) come tasks.md e le sessioni: l'età di una task
+// cambia una volta al giorno, e ogni giro costa la lettura di N task file più
+// qualche spawn di git. Due trigger:
+//
+//   · quando cambia l'INSIEME delle task Done (`doneSig`) — copre l'avvio, dove
+//     il primo render ha `tasks` ancora vuoto, e la chiusura di una task, dove
+//     il numero deve muoversi senza aspettare ore;
+//   · ogni SCAN_INTERVAL_MS — copre il caso opposto, in cui non cambia nulla
+//     sul disco ed è il calendario a far scattare una task oltre soglia.
+//
+// `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.
+export function useArchivable(doneSig, tasksDir, projectRoot, days) {
+    const [ids, setIds] = useState(() => new Set());
+    useEffect(() => {
+        let alive = true;
+        const done = doneSig ? doneSig.split(',') : [];
+        const scan = () => {
+            archivableIds(done, { tasksDir, projectRoot, days })
+                .then((found) => {
+                if (alive)
+                    setIds(new Set(found));
+            })
+                // 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)
+                    setIds(new Set());
+            });
+        };
+        scan();
+        const id = setInterval(scan, SCAN_INTERVAL_MS);
+        return () => {
+            alive = false;
+            clearInterval(id);
+        };
+    }, [doneSig, tasksDir, projectRoot, days]);
+    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,
+// niente debounce serve per la tastiera. Il refresh del contenuto a file fermo
+// (es. checkpoint aggiorna Progress) è demandato al prossimo cambio selezione.
+export function useTaskDetail(tasksDir, id) {
+    const [detail, setDetail] = useState(null);
+    useEffect(() => {
+        setDetail(id ? loadTaskDetail(tasksDir, id) : null);
+    }, [tasksDir, id]);
+    return detail;
+}

package/dist/input-modes.js

@@ -0,0 +1,52 @@
+// La PRECEDENZA fra i modi dell'handler input, dichiarata come dato.
+//
+// Prima di questo file la precedenza era l'ordine testuale di dieci `if` dentro
+// un `useInput` da 850 righe: un'informazione portante che nessun tipo esprimeva
+// e nessun test fissava. Ha già prodotto una correzione non ovvia — il ramo
+// `detail` anteposto a quello `key.ctrl` per rendere inerti gli acceleratori
+// dentro il detail, con `^F` come deroga *dentro* quel ramo.
+//
+// Il custode è `MODE_KEYS` in `cli.tsx`: un `Record<CapturingMode, Handler>`
+// che non compila se un modo nuovo resta senza handler. Il test gemello fissa
+// l'insieme e la deroga.
+/**
+ * I modi che CATTURANO l'input per intero.
+ *
+ * Mentre uno di questi è attivo sono inerti: gli acceleratori globali
+ * (`^K`/`^P`/`^R`/`^F`), i tasti nudi della lista, `tab`, `←→` e `q`. Il modo
+ * risponde di ogni tasto che riceve — anche solo per ignorarlo.
+ *
+ * `normal` è l'unico modo NON capturing, ed è il complemento esatto di questo
+ * insieme: è lì che vivono gli acceleratori.
+ */
+export const CAPTURING_MODES = [
+    'detail',
+    'reader',
+    'search',
+    'assign',
+    'create',
+    'note',
+    'sort',
+    'filter',
+    'edit',
+];
+const _MODES_ARE_EXHAUSTIVE = true;
+void _MODES_ARE_EXHAUSTIVE;
+const CAPTURING = new Set(CAPTURING_MODES);
+/** `true` se il modo intercetta l'input prima degli acceleratori globali. */
+export function captures(mode) {
+    return CAPTURING.has(mode);
+}
+/**
+ * Le DEROGHE: combinazioni `ctrl` che restano vive dentro un modo capturing,
+ * con un significato proprio.
+ *
+ * Oggi ce n'è una sola — `^F` dentro `detail`, che apre la ricerca nel testo
+ * invece di quella sulle conversazioni. Non è l'acceleratore globale che
+ * sopravvive: è un tasto diverso che porta lo stesso nome, e il modo se lo
+ * gestisce da sé. Sta scritto qui perché è l'eccezione a una regola dichiarata,
+ * e un'eccezione che vive solo dentro un `if` annidato è come non averla.
+ */
+export const CTRL_DEROGATIONS = {
+    detail: ['f'],
+};

package/dist/layout.js

@@ -0,0 +1,121 @@
+// Funzioni pure di LARGHEZZA e di manipolazione testo che i componenti di vista
+// consumano. Stanno insieme perché condividono un'unica invariante: la cornice
+// da scalare va tolta in un posto solo, o due chiamanti tolgono cose diverse
+// dalla stessa larghezza e il bordo viene mangiato.
+import { stripProjectCore } from './session-list.js';
+export const EDIT_ROWS = 4;
+/** Le righe del modale edit che sono campi di TESTO (il resto è scelta ←→). */
+export function isTextRow(r) {
+    return r === 2 || r === 3;
+}
+/** Chiave della bozza scritta dalla riga di testo `r`. */
+export function editField(r) {
+    return r === 2 ? 'detail' : 'title';
+}
+/**
+ * Lunghezza in CODE POINT. Il caret ci indicizza sopra: `.length` conterebbe le
+ * code unit UTF-16 e un'emoji nel titolo varrebbe 2 posizioni, cioè un cursore
+ * che si ferma a metà glifo e un `slice` che lo spezza in due surrogati.
+ */
+export function cpLen(s) {
+    return [...s].length;
+}
+/** Inserisce `ins` alla posizione `at` (code point). */
+export function insertAt(s, at, ins) {
+    const cp = [...s];
+    return cp.slice(0, at).join('') + ins + cp.slice(at).join('');
+}
+/** Toglie il code point in posizione `at`; fuori range = stringa invariata. */
+export function removeAt(s, at) {
+    const cp = [...s];
+    if (at < 0 || at >= cp.length)
+        return s;
+    cp.splice(at, 1);
+    return cp.join('');
+}
+export function isDone(prog) {
+    return prog.includes('✔');
+}
+/**
+ * Larghezza dell'estratto, DERIVATA dalle colonne del terminale.
+ *
+ * Una costante qui è spazio buttato a ogni riga: su un terminale a 190 colonne
+ * un estratto fisso a 50 lascia il match con ~20 caratteri di contesto per lato
+ * quando potrebbe averne 80 — e il contesto attorno al match è l'unica ragione
+ * per cui si legge la riga invece di aprire il reader.
+ *
+ * Scomposizione delle colonne consumate dalla cornice e dal prefisso di riga:
+ *   4  box esterno (2 bordi + 2 padding)
+ *   4  box lista   (2 bordi + 2 padding)
+ *   2  caret
+ *   4  indice del record
+ *   4  spazio + tag del kind (2 caratteri) + spazio
+ * Prudente per costruzione: sottostimare tronca un carattere in più,
+ * sovrastimare manderebbe la riga a capo e sfonderebbe il budget d'altezza.
+ */
+export function searchExcerptWidth(columns) {
+    return Math.max(30, (columns || 80) - 18);
+}
+/** Titolo della conversazione sulla riga-gruppo: prende ciò che avanza dopo le
+ *  colonne a larghezza fissa (caret, pin, hash, task, conteggio, data). */
+export function searchTitleWidth(columns) {
+    return Math.max(24, (columns || 80) - 56);
+}
+/**
+ * Cosa scrivere sulla riga-gruppo per distinguere una conversazione dall'altra.
+ *
+ * Non basta `session.title`: quel titolo è la label della tab Ptyxis, cioè
+ * `<emoji> <name>` più un eventuale suffisso. Su una lista tutta dello
+ * stesso progetto (D3) è una COLONNA COSTANTE — tre righe su quattro
+ * identiche, che è esattamente il difetto che la riga-gruppo doveva evitare.
+ *
+ * Si toglie quindi il core `<name>` con tutto ciò che lo precede (noto dal file
+ * config), e se ciò
+ * che resta è vuoto o duplica la task già mostrata nella sua colonna, si
+ * ripiega sul primo prompt — l'unica cosa che davvero identifica quella
+ * conversazione e non un'altra.
+ */
+export function conversationLabel(s, core, bound) {
+    let t = stripProjectCore(s.title, core);
+    if (bound && t === bound)
+        t = '';
+    return t || s.firstPrompt || '(senza titolo)';
+}
+/**
+ * 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.
+ */
+export function assignTextWidth(columns) {
+    return Math.max(20, (columns || 80) - 8);
+}
+/**
+ * T70 — larghezza utile del testo dentro il blocco preview, che è a PIENA
+ * larghezza: box esterno (2 bordi + 2 padding) → box preview (2 bordi + 2
+ * padding). Niente più `/2`: il blocco non vive più dentro un pane al 50%,
+ * quindi una riga di descrizione dispone del doppio delle colonne.
+ *
+ * Volutamente prudente: sottostimare tronca qualche carattere in più,
+ * sovrastimare farebbe andare a capo una riga e sforare il tetto d'altezza.
+ */
+export function previewTextWidth(columns) {
+    return Math.max(10, (columns || 80) - 8);
+}
+/**
+ * Larghezza del TESTO dentro un pane al 50%: box esterno (2 bordi + 2 padding)
+ * → metà → bordo + padding del pane.
+ *
+ * Invariante ③ (`width.ts`): chi renderizza una riga a lunghezza libera la
+ * taglia PRIMA con questa larghezza. Delegarlo a `wrap="truncate-end"`
+ * significa passare da `cli-truncate`, che indicizza per code point e restituisce
+ * una riga più larga di quella chiesta — una colonna per ogni emoji astrale a
+ * sinistra del taglio. Quelle colonne finiscono sopra il bordo del pane, che
+ * sparisce dalla riga: è la sminchiatura visibile a schermo.
+ */
+export function paneTextWidth(columns) {
+    return Math.max(20, Math.floor(((columns || 80) - 4) / 2) - 4);
+}

package/dist/model.js

@@ -0,0 +1,55 @@
+export const POLL_MS = 1500;
+// Cap del pane sessioni: le più recenti (ts desc), le altre restano nell'indice
+// ma fuori vista. Non-silenzioso → l'header mostra quante sono nascoste.
+export const MAX_SESSIONS = 30;
+// T59 D3 — cap dedicato alla vista "tutte": a 30 su un progetto con ~170
+// conversazioni la lista sarebbe esaustiva solo sull'ultimo 17%, cioè
+// contraddirebbe lo scopo della riga. 100 copre la finestra temporale utile e
+// tiene comunque un tetto alle righe da attraversare con ↑↓.
+export const MAX_SESSIONS_ALL = 100;
+// Modello task-centrico: il Tasks pane ha, oltre alle task reali, DUE righe
+// meta in testa — `≡ tutte` (ogni conversazione del progetto) e `○ spot` (le
+// sole NON legate ad alcuna task). La selezione nel Tasks pane è il "padre"; il
+// Sessions pane mostra i suoi figli.
+//
+// T59 D1 — le sentinelle sono Symbol, non `null` né stringhe riservate: la
+// selezione è un ENUM a tre casi (task / spot / tutte), non un flag. Un Symbol
+// non può collidere con un task id e si confronta secco (`sel === ALL`); una
+// stringa sentinella farebbe invece circolare un id-fantasma dentro un tipo che
+// altrove significa "task id".
+export const SPOT = Symbol('spot');
+export const ALL = Symbol('all');
+// Le righe meta occupano le prime posizioni della lista: l'indice di una task
+// nella VISTA è quindi il suo indice in `viewTasks` + META_ROWS.
+export const ROW_ALL = 0;
+export const ROW_SPOT = 1;
+export const META_ROWS = 2;
+// Modale sort a grammatica libera: un tasto per chiave, pressioni successive
+// ciclano asc → desc → fuori dalla chain.
+export const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id' };
+// T52 — toggle del modale ricerca, tutti su CTRL (D2).
+//
+// I due campi di testo mangiano ogni lettera nuda, quindi un toggle non può
+// essere una lettera semplice: resterebbero i caratteri della query. CTRL è
+// l'unico livello che convive con la digitazione senza modi né navigazione.
+//
+// Le mnemoniche ovvie sono precluse dall'ASCII, non da una scelta di design:
+// `^I` È il Tab (0x09) e `^H` È il Backspace (0x08) — stesso byte, nessuna
+// distinzione possibile a valle. Quindi niente I=IA e niente H=human. Bruciati
+// per lo stesso motivo `^M` (Enter), `^J` (LF), `^[` (Esc). Tutto il resto passa
+// pulito, `^S`/`^Q` inclusi: il raw mode di Ink disattiva il flow-control XON/XOFF
+// che altrimenti se li mangerebbe il terminale.
+export const SEARCH_TOGGLE_KEYS = {
+    r: 'regex',
+    a: 'caseSensitive',
+    w: 'wholeWord',
+};
+export const SEARCH_KIND_KEYS = { b: 'ai', t: 'tool', u: 'human' };
+export const KIND_LABEL = { ai: 'IA', tool: 'tools', human: 'human' };
+// T41 — ordine dei valori nel modale edit. Deliberatamente DIVERSO da
+// PRI_ENTRIES/PROG_ENTRIES (che seguono il rango di sort): qui si sceglie un
+// valore, non si ordina, quindi vince l'ordine del CICLO DI VITA — da fare →
+// in corso → chiusa → bloccata. La priorità resta alta→bassa, che è già
+// l'ordine naturale di lettura.
+export const EDIT_PRI = ['high', 'med', 'low'];
+export const EDIT_PROG = ['todo', 'wip', 'done', 'locked'];

package/dist/overlays/assign.js

@@ -0,0 +1,112 @@
+// Overlay ASSEGNAZIONE conversazione → task (T57): stato, lista filtrata e input.
+//
+// `sid` è la conversazione in assegnazione, FOTOGRAFATA all'apertura e non
+// riletta dalla selezione corrente: 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.
+//
+// `sel` è la task di destinazione: `null` è la riga `detach` (D2), che sta
+// sempre in testa e scrive un binding vuoto.
+//
+// La scrittura del sidecar NON sta qui: arriva come callback `onSubmit`.
+import { useEffect, useMemo, useState } from 'react';
+import { assignListCapacity } from '../viewport.js';
+import { sanitizeTyped } from '../glyphs.js';
+export function useAssignOverlay(deps) {
+    const { viewTasks, rows, hasNote, setMode, setNote, onSubmit } = deps;
+    const [sid, setSid] = useState(null);
+    const [filter, setFilter] = useState('');
+    const [sel, setSel] = useState(null);
+    // 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 list = useMemo(() => {
+        const q = filter.trim().toLowerCase();
+        const matched = q
+            ? viewTasks.filter((t) => t.id.toLowerCase().includes(q) || t.rawDesc.toLowerCase().includes(q))
+            : viewTasks;
+        return [null, ...matched];
+    }, [viewTasks, filter]);
+    const capacity = assignListCapacity(rows, hasNote);
+    // 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 (sel !== null && !list.some((t) => t?.id === sel)) {
+            setSel(list[1]?.id ?? null);
+        }
+    }, [list, sel]);
+    // T57 — apertura. 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 open(sessionId, bound) {
+        setSid(sessionId);
+        setFilter('');
+        setSel(bound && viewTasks.some((t) => t.id === bound) ? bound : viewTasks[0]?.id ?? null);
+        setNote('');
+        setMode('assign');
+    }
+    /** Sposta la selezione sulle righe (0 = detach, 1..N = task filtrate). */
+    function move(delta) {
+        const at = list.findIndex((t) => (t?.id ?? null) === sel);
+        const next = Math.max(0, Math.min(list.length - 1, (at < 0 ? 0 : at) + delta));
+        setSel(list[next]?.id ?? null);
+    }
+    function submit() {
+        const sessionId = sid;
+        const target = sel;
+        setMode('normal');
+        setFilter('');
+        if (!sessionId)
+            return;
+        onSubmit(sessionId, target);
+    }
+    // T57 — 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.
+    function onKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setFilter('');
+            setNote('A → assegnazione annullata');
+        }
+        else if (key.return) {
+            submit();
+        }
+        else if (key.upArrow) {
+            move(-1);
+        }
+        else if (key.downArrow) {
+            move(1);
+        }
+        else if (key.pageUp) {
+            move(-Math.max(1, capacity));
+        }
+        else if (key.pageDown) {
+            move(Math.max(1, capacity));
+        }
+        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')
+                setFilter('');
+        }
+        else if (key.backspace || key.delete) {
+            setFilter((f) => f.slice(0, -1));
+        }
+        else if (input && !key.meta) {
+            setFilter((f) => f + sanitizeTyped(input));
+        }
+    }
+    return { sid, filter, sel, list, capacity, open, onKey };
+}