@lamemind/loom-deck 0.33.0 → 0.34.1

package/dist/cli.js

@@ -1,598 +1,34 @@
 #!/usr/bin/env node
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { render, Box, Text, useApp, useInput, useStdout } from 'ink';
-import { useState, useEffect, useMemo, useRef } from 'react';
-import { spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { statSync } from 'node:fs';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, Box, Text, useApp, useInput } from 'ink';
+import { useState, useEffect, useMemo } from 'react';
 import { randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, loadTaskFileText, } from './tasks.js';
-import { discoverProjectSessions } from './sessions.js';
-import { discoverLiveSessions, liveSig } from './live-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, neighborId, rowIndexOf, rowLabel, selectedSession, sessionTitle, stripProjectCore, unpinLandingId, } from './session-list.js';
+import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskFileText, } from './tasks.js';
+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, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
-import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
-import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, SESSION_VIEWS, TASK_VIEWS, } from './pane-views.js';
-import { assignListCapacity, detailCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
-import { caretWindow, cut, cutParts, pad, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
-import { scanText, sliceLine, topForOffset, } from './text-search.js';
-import { parseMarkdown, sliceSpans, } from './markdown.js';
+import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, TASK_VIEWS, } from './pane-views.js';
+import { isCompact, layoutBudget, searchPreviewCapacity, windowRange, } from './viewport.js';
+import { cut, sanitize, termWidth } 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';
+import { initialDetail, writeTaskEdit, PRI_GLYPH, PRI_LABEL } from './task-edit.js';
+import { ALL, EDIT_PRI, EDIT_PROG, MAX_SESSIONS, MAX_SESSIONS_ALL, META_ROWS, ROW_ALL, ROW_SPOT, SORT_TASTI, SPOT, } from './model.js';
+import { conversationLabel, cpLen, editField, insertAt, isDone, isTextRow, removeAt, EDIT_ROWS, } from './layout.js';
+import { TASK_EMPTY, relTime, sanitizeTyped } from './glyphs.js';
+import { commitTaskEdit, runLaunch, spawnClaudeEmpty, spawnCreateTask, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, CLAUDE_CMD, DECK_RUN, } from './spawn.js';
+import { EditModal, FilterModal, SortModal } from './ui/modals.js';
+import { ReaderScreen, SearchScreen } from './ui/search-screen.js';
+import { DetailScreen } from './ui/detail-screen.js';
+import { AssignScreen } from './ui/assign-screen.js';
+import { SessionsPane, TasksPane } from './ui/panes.js';
+import { PreviewPane, detailMetaOf } from './ui/preview.js';
 import { loadView, saveView, viewFilePath } from './view-store.js';
-// scripts/deck-run è un sibling della dir del bundle: src/ (dev, tsx) e dist/
-// (build, node) stanno entrambi sotto la package root → risalita di un livello.
-const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'deck-run');
-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.
-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 ↑↓.
-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".
-const SPOT = Symbol('spot');
-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.
-const ROW_ALL = 0;
-const ROW_SPOT = 1;
-const META_ROWS = 2;
-const EDIT_ROWS = 4;
-/** Le righe del modale edit che sono campi di TESTO (il resto è scelta ←→). */
-function isTextRow(r) {
-    return r === 2 || r === 3;
-}
-/** Chiave della bozza scritta dalla riga di testo `r`. */
-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.
- */
-function cpLen(s) {
-    return [...s].length;
-}
-/** Inserisce `ins` alla posizione `at` (code point). */
-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. */
-function removeAt(s, at) {
-    const cp = [...s];
-    if (at < 0 || at >= cp.length)
-        return s;
-    cp.splice(at, 1);
-    return cp.join('');
-}
-// Modale sort a grammatica libera: un tasto per chiave, pressioni successive
-// ciclano asc → desc → fuori dalla chain.
-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.
-const SEARCH_TOGGLE_KEYS = {
-    r: 'regex',
-    a: 'caseSensitive',
-    w: 'wholeWord',
-};
-const SEARCH_KIND_KEYS = { b: 'ai', t: 'tool', u: 'human' };
-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.
-const EDIT_PRI = ['high', 'med', 'low'];
-const EDIT_PROG = ['todo', 'wip', 'done', 'locked'];
-function isDone(prog) {
-    return prog.includes('✔');
-}
-/**
- * Freno agli effetti VERSO L'ESTERNO (tab Ptyxis, sessioni Claude, git commit).
- *
- * Il gate di larghezza avvia il deck vero in uno pseudo-terminale e gli manda
- * tasti — e in questa TUI un tasto è un'azione: `⏎` su una riga sessione apre
- * una tab Ptyxis, `t` un terminale, `⏎` nel modale edit committa. Ogni run dei
- * test apriva quindi finestre reali sulla macchina di chi li lanciava, in
- * qualunque progetto avesse in focus.
- *
- * Il gate va tenuto sul deck VERO (è tutto il suo valore: misura il frame che
- * VTE disegna davvero), quindi il freno sta qui: `LOOM_DECK_NO_SPAWN=1` fa
- * restituire un figlio finto e inerte invece di lanciare il processo. Non è un
- * mock del comportamento — l'azione semplicemente non avviene, e il frame che il
- * test misura resta identico.
- */
-const NO_SPAWN = process.env.LOOM_DECK_NO_SPAWN === '1';
-function spawnOut(cmd, args, opts) {
-    if (!NO_SPAWN)
-        return spawn(cmd, args, opts);
-    // Figlio inerte: emette nulla, quindi i `.on('error'|'close')` dei chiamanti
-    // restano appesi senza mai scattare — che è esattamente "non è successo niente".
-    const fake = new EventEmitter();
-    fake.unref = () => fake;
-    return fake;
-}
-// T66 — le azioni del detail. Non sono un catalogo nuovo: ognuna è un
-// `--prompt-kind` già esistente più `checkpoint`, e tutte passano dallo stesso
-// `spawnForTask` dei CTRL della lista — una superficie in più, zero percorsi di
-// spawn in più.
-//
-// L'etichetta è distinta dal kind dove il kind è il nome del MECCANISMO e
-// l'etichetta quello dell'INTENZIONE: `none` è "aprire la task a mani nude",
-// `recap` è "vedere a che punto sta".
-const DETAIL_ACTIONS = [
-    { kind: 'none', label: 'open' },
-    { kind: 'preflight', label: 'preflight' },
-    { kind: 'run', label: 'run' },
-    { kind: 'recap', label: 'status' },
-    { kind: 'checkpoint', label: 'checkpoint' },
-];
-// Spawn detached: il deck spawna ma NON contiene la sessione (la possiede
-// ptyxis-agent). unref + stdio ignore → ritorna subito, la TUI resta viva.
-// sessionId pinnato (T27) → il binding sidecar è deterministico allo spawn.
-// Il kind è OBBLIGATORIO e non ha default qui: il default vive in deck-run (per
-// le invocazioni a mano), mentre dal deck ogni tasto dichiara il proprio intento
-// — un default silenzioso renderebbe indistinguibili `⏎` e `^K`.
-function spawnDeck(id, cwd, sessionId, kind) {
-    const child = spawnOut(DECK_RUN, [id, '--session-id', sessionId, '--prompt-kind', kind], {
-        cwd,
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    return child;
-}
-// T49 — resume di una sessione esistente come nuova tab Ptyxis. Scoped (taskId
-// presente) → `deck-run <task> --resume <sid>`: la ripresa eredita LOOM_TASK +
-// titolo `· <task>` (D2 preflight, l'hook SessionStart ricarica il contesto
-// task). Spot → `--no-task --resume`: resume nudo, solo label progetto. Nessun
-// prompt iniziale in entrambi i casi: riprendere una conversazione significa
-// continuarla, non iniettarle un messaggio (lo salta deck-run).
-//
-// T64 — la NOTA della conversazione (se c'è) viaggia nel titolo della tab. Più
-// sessioni sulla stessa task hanno oggi titoli identici (`label · T81`): la nota
-// è già ciò con cui l'utente le distingue in lista, quindi è anche ciò che
-// distingue le tab. La passa il DECK e non la legge deck-run perché la nota vive
-// nel sidecar `session-tasks.jsonl`, che deck-run non tocca (legge solo
-// `.claude/loom-works.json`): tenerlo così evita di dare al primitive un secondo
-// file da conoscere. Il titolo si congela qui — `claude --name` lo setta una
-// volta sola, quindi una nota cambiata DOPO non ri-titola la tab già aperta.
-function spawnDeckResume(taskId, cwd, sessionId, note) {
-    const args = taskId ? [taskId, '--resume', sessionId] : ['--no-task', '--resume', sessionId];
-    if (note)
-        args.push('--title-note', note);
-    const child = spawnOut(DECK_RUN, args, { cwd, detached: true, stdio: 'ignore' });
-    child.unref();
-    return child;
-}
-// T28 — FORK: `deck-run <task|--no-task> --resume <origine> --fork --session-id
-// <nuovo>`. Variante del resume, non una terza forma: cambia solo che CC apre un
-// id nuovo (`--fork-session`) invece di riprendere a scrivere sull'origine —
-// due writer sullo stesso JSONL non esistono mai, che è l'intero punto del fork.
-// Il nuovo id lo genera il DECK e lo pinna, come in spawnDeck: è l'unico modo di
-// conoscerlo prima che la sessione esista, e senza conoscerlo non si possono
-// scrivere né il binding task né il record di lineage (il transcript del fork
-// non nomina da nessuna parte la sessione d'origine).
-// Nessun `--title-note` (T64): il ramo nasce con un sessionId proprio e SENZA
-// nota nel sidecar — ereditare quella dell'origine metterebbe nel titolo una
-// maniglia che nella lista non compare, cioè una promessa falsa. Il fork si
-// distingue col suo marcatore, `· fork`.
-function spawnDeckFork(taskId, cwd, originId, newId) {
-    const args = [
-        ...(taskId ? [taskId] : ['--no-task']),
-        '--resume',
-        originId,
-        '--fork',
-        '--session-id',
-        newId,
-    ];
-    const child = spawnOut(DECK_RUN, args, { cwd, detached: true, stdio: 'ignore' });
-    child.unref();
-    return child;
-}
-// T42 — sessione Claude NUDA: nessuna task, nessun prompt iniziale, nessun
-// sessionId pinnato (quindi nessuna entry nel sidecar session-tasks.jsonl: senza
-// task non c'è nulla da legare). Funzione separata e non un parametro opzionale
-// di spawnDeck: i tre argomenti mancano tutti insieme, un `if` per ciascuno
-// sporcherebbe il percorso bound. Il titolo tab resta la label loom — lo mette
-// deck-run, perché il match compass è window-level e non sa nulla di task.
-function spawnClaudeEmpty(cwd) {
-    const child = spawnOut(DECK_RUN, ['--no-task'], {
-        cwd,
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    return child;
-}
-// T39/T32: voce `launch` custom del file config, eseguita con cwd = project root.
-// Spawn detached come spawnDeck: il deck lancia ma non possiede il processo.
-// Shell login+interattiva (bash -lic) perché i comandi tipici sono alias o
-// funzioni di ~/.bashrc (`codium`=alias flatpak, `idea`=funzione) — con `bash -c`
-// non risolverebbero. Il comando NON è input utente: viene dal file committato
-// `.claude/loom-works.json`, fidato quanto un custom-command Ptyxis (contratto
-// esplicito in project-config-architecture.md). La project root arriva via cwd,
-// non interpolata nella stringa.
-function runLaunch(entry, cwd) {
-    const child = spawnOut('bash', ['-lic', entry.command], {
-        cwd,
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    return child;
-}
-// T37 — surface STANDARD LAUNCH `terminal`: built-in e universale (nessuna
-// dichiarazione in `launch[]`), ma di natura launch — fire-once, nessuno stato.
-// Il deck gira già DENTRO una tab Ptyxis → `--tab` mette il terminale accanto a
-// sé nella stessa finestra, invece di sparpagliare finestre.
-// Nessun `-- CMD`: l'azione È aprire la shell (differenza dalle launch custom,
-// che eseguono un comando dentro `bash -lic`).
-// `-T <title>` con la chiave `🖥️ <name>` tiene la finestra matchabile da compass
-// anche mentre la tab attiva è il terminale; senza identità nel file config si
-// spawna senza titolo (la surface resta funzionante, il progetto risulta assente
-// dal radar finché quella tab è in primo piano).
-function spawnTerminal(cwd, title) {
-    const args = title ? ['--tab', '-T', title, '-d', cwd] : ['--tab', '-d', cwd];
-    const child = spawnOut('ptyxis', args, { cwd, detached: true, stdio: 'ignore' });
-    child.unref();
-    return child;
-}
-// Comando claude (override per ambienti dove non è su PATH; loom-deck → NPM).
-const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
-// T30: create-task inline. Spawna CC HEADLESS (`-p`) con `--session-id` pinnato
-// che invoca la skill create-task. Differenze da spawnDeck:
-//  - headless (`-p`), non una tab Ptyxis interattiva → il deck osserva l'esito;
-//  - `yolo` FORZATO: create-task è interattiva di default (AskUserQuestion) e in
-//    `-p` non può ricevere risposte → si impianterebbe. yolo = zero domande.
-//  - `--output-format stream-json` (richiede `--verbose`): l'ultima riga è
-//    `{type:"result", is_error}`, segnale di completamento robusto (> exit code).
-//  - detached (own process-group) → il create sopravvive alla chiusura del deck e
-//    completa commit+push da sé; stdout in pipe SOLO per leggere il result event.
-// Il prompt viaggia come singolo argv (no shell) → nessuna injection dal testo utente.
-function spawnCreateTask(text, cwd, sessionId, onResult) {
-    const child = spawnOut(CLAUDE_CMD, [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--session-id',
-        sessionId,
-        `/loom-works:create-task yolo ${text}`,
-    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
-    let buf = '';
-    let isError = null;
-    child.stdout?.on('data', (chunk) => {
-        buf += chunk.toString();
-        let nl;
-        while ((nl = buf.indexOf('\n')) >= 0) {
-            const line = buf.slice(0, nl).trim();
-            buf = buf.slice(nl + 1);
-            if (!line)
-                continue;
-            try {
-                const obj = JSON.parse(line);
-                if (obj.type === 'result')
-                    isError = obj.is_error ?? false;
-            }
-            catch {
-                // riga parziale / non-json → skip
-            }
-        }
-    });
-    // Drena stderr per non riempire il buffer pipe (deadlock del figlio).
-    child.stderr?.on('data', () => { });
-    child.on('error', () => onResult(false));
-    child.on('close', (code) => {
-        onResult(isError === null ? code === 0 : !isError);
-    });
-    return child;
-}
-// T41 — Commit dell'edit. `git commit -- <paths>` committa lo stato working-tree
-// SOLO di quei path, ignorando l'index: se l'utente ha altro in stage (o altri
-// file sporchi) non finisce dentro per errore. NON detached: è un'operazione
-// veloce e il suo esito va riportato nella nota. stderr raccolto per dire perché
-// ha fallito (identità git assente, hook che rifiuta, …) invece di un generico ⚠.
-function commitTaskEdit(cwd, paths, message, onResult) {
-    const child = spawnOut('git', ['commit', '-m', message, '--', ...paths], {
-        cwd,
-        stdio: ['ignore', 'ignore', 'pipe'],
-    });
-    let err = '';
-    child.stderr?.on('data', (c) => {
-        err += c.toString();
-    });
-    child.on('error', () => onResult(false, 'git non lanciabile'));
-    child.on('close', (code) => onResult(code === 0, err.trim().split('\n')[0] ?? ''));
-    return child;
-}
-// 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.
-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.
-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.
-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.
-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.
-function useTaskDetail(tasksDir, id) {
-    const [detail, setDetail] = useState(null);
-    useEffect(() => {
-        setDetail(id ? loadTaskDetail(tasksDir, id) : null);
-    }, [tasksDir, id]);
-    return detail;
-}
-// 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`).
-const CARET = sanitize('▶ ');
-const CARET_OFF = '  ';
-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%.
-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.
-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. */
-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.
-const LIVE_IDLE = '●';
-const LIVE_BUSY = '◍';
-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.
-function displayProg(prog) {
-    return sanitize(prog);
-}
-// T49 — size umana compatta per il detail pane sessione.
-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.
-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.
-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.
- */
-function sanitizeTyped(s) {
-    return s.replace(/[\r\n]/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '');
-}
-const META_KEYS = ['Priority', 'Size', 'Estimated Time', 'Progress'];
+import { useArchivable, useSessions, useTaskDetail, useTasks, useTerminalSize } from './hooks.js';
+import { useSearchOverlay } from './overlays/search.js';
+import { useSheetOverlay } from './overlays/sheet.js';
+import { useAssignOverlay } from './overlays/assign.js';
+import { captures } from './input-modes.js';
 function Deck({ cwd, tasksPath, tasksDir }) {
     const { exit } = useApp();
     const { tasks, loadError } = useTasks(tasksPath);
@@ -628,7 +64,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // modale: la lista si aggiorna dal vivo, quindi `esc` deve poter ripristinare.
     const [view, setView] = useState(() => loadView(cwd));
     const [viewBackup, setViewBackup] = useState(null);
-    // T100 — vista attiva di ciascun pane, navigata con ←/→. VOLATILE per
+    // T100 — vista attiva di ciascun pane, navigata con `tab`. VOLATILE per
     // decisione (D3 create): non entra in `deck-view.json`, il deck riapre sempre
     // su `Tasks` e su `{parent}`. Il criterio è il rischio di leggere una lista
     // parziale credendola completa — un filtro salvato lo si è scelto, una vista
@@ -639,53 +75,6 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // T41 — bozza dell'edit (null fuori dal modale) e riga attiva della griglia.
     const [edit, setEdit] = useState(null);
     const [editRow, setEditRow] = useState(0);
-    // T52 — stato del modale ricerca. VOLATILE per decisione (D4): vive in
-    // memoria, quindi riaprendo il modale ritrovi query e toggle come li avevi
-    // lasciati, ma un riavvio del deck riporta ai default. Niente schema nuovo su
-    // `deck-view.json` e nessuna scrittura implicita su disco — che
-    // contraddirebbe la regola T39 «il disco si tocca solo su `w`», qui non
-    // trasportabile perché dentro il modale `w` è un carattere digitabile.
-    const [searchHash, setSearchHash] = useState('');
-    const [searchQuery, setSearchQuery] = useState('');
-    const [searchField, setSearchField] = useState('query');
-    const [searchOpts, setSearchOpts] = useState(DEFAULT_OPTIONS);
-    const [searchSelKey, setSearchSelKey] = useState(null);
-    // Occorrenza aperta nel reader; null = reader chiuso. Tenerla separata dalla
-    // selezione della lista è ciò che permette a `esc` di tornare indietro
-    // 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);
-    // T66 — la task aperta nel detail, FOTOGRAFATA all'apertura: id, titolo e
-    // testo integrale del task file (`text` null = file assente). Non si rilegge
-    // da `selTask` per la stessa ragione di `assignSid`: l'overlay copre la lista,
-    // quindi l'oggetto dell'azione deve restare quello che si è scelto anche se un
-    // tick del poll spostasse la selezione sotto.
-    //
-    // Si chiama `sheet` e non `detail` perché `detail` in questo componente è già
-    // il `TaskDetail` del blocco preview sotto i pane: due cose vicine con lo
-    // stesso nome sono una trappola di lettura (stesso motivo di
-    // `note`/`sessionNotes`).
-    const [sheet, setSheet] = useState(null);
-    const [sheetTop, setSheetTop] = useState(0);
-    const [sheetAction, setSheetAction] = useState(0);
-    // T91 — ricerca dentro il detail. `open` distingue i due modi in cui la si
-    // lascia: `esc` butta via ciò che il modale ha prodotto (`find` a null,
-    // evidenziazione via), `⏎` lo congela e restituisce il controllo allo strato
-    // sotto — campo chiuso, occorrenze ancora colorate, scroll dov'era. Senza il
-    // flag i due gesti collasserebbero su uno solo.
-    const [find, setFind] = useState(null);
-    const [occIdx, setOccIdx] = useState(0);
     // 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.
@@ -805,101 +194,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // perderebbero il segnaposto e con lui l'allineamento.
         return { task: task > 0 ? Math.max(task, termWidth(TASK_EMPTY)) : 0, age };
     }, [sessionRows, bindings, isAll]);
-    // T52 — ricerca EAGER: rigira a ogni carattere digitato, non su ⏎. È
-    // sostenibile perché i corpi sono già in RAM dentro la cache mtime-keyed
-    // dell'adapter (D5): misurato su questo progetto, 0,8 ms sui soli corpi IA e
-    // ≤9 ms su tutti i tipi — sotto il tempo fra due battute. Il memo evita di
-    // rifarla sui re-render che non toccano né query né opzioni (il poll delle
-    // sessioni ogni 1,5s è già filtrato dalla signature in `useSessions`).
-    const searchResult = useMemo(() => searchSessions(sessions, searchHash, searchQuery, searchOpts, searchExcerptWidth(columns)), [sessions, searchHash, searchQuery, searchOpts, columns]);
-    // Con l'hash valorizzato la conversazione è una sola e già nominata nel campo:
-    // la riga-sessione ripeterebbe un dato costante rubando una riga per gruppo.
-    const searchFlat = searchHash.trim().length > 0;
-    const searchRows = useMemo(() => buildRows(searchResult, searchFlat), [searchResult, searchFlat]);
-    // T52 — riga selezionata e, se è un'occorrenza, il suo corpo wrappato per
-    // l'anteprima sotto la lista. Memoizzato per (testo, larghezza): navigando
-    // con le frecce si ri-wrappa solo quando cambia davvero l'occorrenza.
-    const searchSelRow = useMemo(() => selectedRow(searchRows, searchSelKey), [searchRows, searchSelKey]);
-    const searchPreviewWidth = Math.max(20, (columns || 80) - 8);
-    const searchPreviewBody = useMemo(() => searchSelRow?.kind === 'hit'
-        ? wrapWithOffsets(searchSelRow.hit.text, searchPreviewWidth)
-        : [], [searchSelRow, searchPreviewWidth]);
-    // T52 — corpo del messaggio aperto nel reader, wrappato UNA volta per (testo,
-    // larghezza). Senza memo ogni pressione di freccia rifarebbe l'a-capo di un
-    // messaggio che nella coda lunga arriva a 150k char.
-    const readerWidth = Math.max(20, (columns || 80) - 6);
-    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);
     // T66 — testo del task file wrappato per il detail. `wrapWithOffsets` e non
     // `wrapLines`: quest'ultimo appiattisce gli a-capo in un flusso unico, che per
     // una preview di 4 righe va bene e per un task file — titoli, bullet, tabelle,
-    // blocchi di codice — significa renderlo illeggibile. Memoizzato per (testo,
-    // larghezza), o ogni pressione di freccia rifarebbe l'a-capo di 9KB.
-    //
-    // Cornici da scalare: box esterno (2 bordi + 2 padding) + box testo (2 bordi +
-    // 2 padding) = 8. Sottostimare tronca un carattere, sovrastimare manda a capo
-    // una riga che il budget d'altezza non ha contato.
-    const sheetWidth = Math.max(20, (columns || 80) - 8);
-    // T75 — il markdown si rende PRIMA del wrap, e il resto della catena lavora
-    // sul testo reso: `**foo**` occupa 3 colonne rese e 7 grezze, quindi
-    // wrappare sui marker manderebbe a capo su un conteggio che il terminale non
-    // disegna. Memo separato dal wrap perché il parse dipende solo dal testo: un
-    // resize ri-wrappa 9KB, non li ri-parsa.
-    const sheetDoc = useMemo(() => (sheet?.text ? parseMarkdown(sheet.text) : null), [sheet]);
-    // Le righe conservano i propri offset invece di essere appiattite a stringa
-    // (T66 le buttava con `.map((l) => l.text)`): è ciò che rende
-    // l'evidenziazione un'intersezione di intervalli invece di un caso speciale
-    // per il match spezzato dall'a-capo. Dopo T75 gli offset indicizzano il testo
-    // RESO, ed è l'unica coordinata coerente che resti — il sorgente non è più
-    // ciò che sta a schermo.
-    const sheetLines = useMemo(() => (sheetDoc ? wrapWithOffsets(sheetDoc.text, sheetWidth) : []), [sheetDoc, sheetWidth]);
-    const sheetCap = detailCapacity(rows, find?.open === true);
-    const sheetMaxTop = Math.max(0, sheetLines.length - sheetCap);
-    // Lo scan gira sulla STESSA stringa che si renderizza: cercare su un testo
-    // diverso da quello a schermo darebbe offset che indicizzano un altro
-    // documento, cioè un'evidenziazione spostata di N caratteri e nessun errore.
-    //
-    // Dopo T75 quella stringa è il testo RESO, non più il sorgente: si cerca ciò
-    // che si vede. Ne discende che `**` non è più cercabile — è la conseguenza
-    // voluta, perché a schermo non c'è; e `Priority`, che prima era `**Priority**`
-    // e si trovava lo stesso, continua a trovarsi.
-    const findRes = useMemo(() => find && sheetDoc
-        ? scanText(sheetDoc.text, find.q)
-        : { occ: [], error: '' }, [find?.q, sheetDoc]);
-    // L'indice si clampa qui invece di essere corretto a ogni `setOccIdx`: la
-    // lista si accorcia da sola mentre si digita, e un indice fuori range vivrebbe
-    // per il tempo di un render.
-    const occCur = findRes.occ.length > 0 ? Math.min(occIdx, findRes.occ.length - 1) : -1;
-    // Salto all'occorrenza corrente, centrata. Non dipende da `sheetTop`, quindi
-    // non si auto-rilancia; dipende da `sheetLines` e `sheetCap`, quindi un resize
-    // ricalcola la posizione senza toccare le occorrenze — che sono offset del
-    // sorgente e il resize non le sposta.
-    useEffect(() => {
-        const o = occCur >= 0 ? findRes.occ[occCur] : undefined;
-        if (!o)
-            return;
-        setSheetTop(topForOffset(sheetLines, o.start, sheetCap));
-    }, [findRes, occCur, sheetLines, sheetCap]);
-    // 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.
@@ -917,25 +214,6 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setSelSessionId(firstSelectableId(sessionRows));
         }
     }, [sessionRows, selSessionId]);
-    // T52 — stessa invariante sulla lista occorrenze, dove è ancora più stretta:
-    // la lista si RICOSTRUISCE a ogni carattere digitato, quindi la chiave
-    // selezionata sparisce continuamente. Persa → prima riga, mai una posizione
-    // ereditata (che qui punterebbe a un'altra conversazione, non a un'altra riga).
-    useEffect(() => {
-        if (rowIndexOfKey(searchRows, searchSelKey) < 0) {
-            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
@@ -990,7 +268,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // messaggi a mano. `verb` è l'unica cosa che cambia fra i due usi.
     function selectedTaskOr(keyLabel, verb) {
         if (focus !== 'tasks') {
-            setNote(`${keyLabel} → ${verb}: seleziona una task (tab per il pane)`);
+            setNote(`${keyLabel} → ${verb}: seleziona una task (← per il pane)`);
             return null;
         }
         // T59 — la guardia è "non è una task", non "è spot": le righe meta sono due
@@ -1020,52 +298,6 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         if (task)
             spawnForTask(task.id, kind, keyLabel);
     }
-    // T66 — `⏎` sul pane task apre il detail invece di spawnare. Il testo del task
-    // file si legge QUI e non a ogni cambio selezione: l'overlay è l'unico
-    // consumer, e leggerlo in anticipo pagherebbe un file a ogni pressione di
-    // freccia per una schermata che quasi sempre non si apre.
-    // File assente → `text` null: l'overlay si apre lo stesso, perché spawnare una
-    // sessione non richiede il file (lo risolve `deck-run` per id).
-    function openDetail() {
-        const task = selectedTaskOr('⏎', 'aprire');
-        if (!task)
-            return;
-        setSheet({
-            id: task.id,
-            // Il titolo del task file quando c'è (è l'H1, cioè la forma lunga), la
-            // riga di tasks.md altrimenti: il detail non deve restare senza intestazione
-            // solo perché il file manca.
-            title: detail?.title || task.desc,
-            text: loadTaskFileText(tasksDir, task.id),
-        });
-        setSheetTop(0);
-        setSheetAction(0);
-        setFind(null);
-        setOccIdx(0);
-        setNote('');
-        setMode('detail');
-    }
-    function closeDetail() {
-        setMode('normal');
-        setSheet(null);
-        setFind(null);
-    }
-    function scrollDetail(delta) {
-        setSheetTop((t) => Math.max(0, Math.min(sheetMaxTop, t + delta)));
-    }
-    /** Modifica la query: l'insieme delle occorrenze cambia, quindi si riparte
-     *  dalla prima. Il movimento del caret NON passa di qui — sposta il cursore,
-     *  non i risultati. */
-    function editFind(next) {
-        setFind((f) => (f ? next(f) : f));
-        setOccIdx(0);
-    }
-    function moveOcc(d) {
-        const n = findRes.occ.length;
-        if (n === 0)
-            return;
-        setOccIdx((i) => (Math.min(i, n - 1) + d + n) % n);
-    }
     // T53 — apertura del modale nota sulla conversazione selezionata. Come
     // `openEdit`, la bozza parte dal valore ATTUALE: annotare una seconda volta è
     // quasi sempre correggere, e ripartire da vuoto costringerebbe a ridigitare
@@ -1098,58 +330,6 @@ 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
@@ -1241,7 +421,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         else
             setSel(paneTasks[next - META_ROWS]?.id ?? SPOT);
     }
-    // T100 — ←/→ navigano il catalogo viste del pane in focus. Il reset della
+    // T100 — `tab` naviga il catalogo viste del pane in focus. Il reset della
     // selezione è la regola letterale «prima riga in alto», senza eccezioni: sul
     // pane task è `ROW_ALL` (D2 preflight — le righe meta non si saltano, e il
     // parent delle sessioni che torna a `tutte` è un effetto accettato); sul pane
@@ -1261,512 +441,259 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setNote(`vista sessioni: ${sessionView(next).label(sessionCounts, parentLabel)}`);
         }
     }
-    // T52 — `⏎` contestuale al TIPO di riga: la lista ne mescola due e l'azione
-    // giusta dipende da quale è selezionata. Riga sessione → resume, identico al
-    // `⏎` della lista sessioni (stessa funzione, T49). Riga occorrenza → reader.
-    function submitSearchRow() {
-        const row = selectedRow(searchRows, searchSelKey);
-        if (!row) {
-            setNote(searchResult.error ? '⚠ regex non valida' : 'nessuna occorrenza selezionata');
-            return;
-        }
-        if (row.kind === 'session') {
-            const bound = bindings.get(row.session.sessionId) ?? null;
-            const child = spawnDeckResume(bound, cwd, row.session.sessionId, sessionNotes.get(row.session.sessionId));
-            child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
-            setNote(`⏎ resume ${row.session.sessionId.slice(0, 8)} → tab CC${bound ? ` (${bound})` : ' (spot)'}`);
-            return;
-        }
-        // D8 — il reader si apre POSIZIONATO sull'occorrenza, non in cima. Il 94%
-        // dei messaggi entra in una schermata e la differenza non si vede; è sul 6%
-        // lungo (p99 ≈ 88 righe, max ≈ 1547) che aprire in cima costringerebbe a
-        // rifare a mano la ricerca appena fatta — cioè proprio il lavoro che questa
-        // feature esiste per evitare.
-        const lines = wrapWithOffsets(row.hit.text, readerWidth);
-        const cap = readerCapacity(rows);
-        const matchLine = lines.findIndex((l) => l.end > row.hit.matchStart);
-        const maxTop = Math.max(0, lines.length - cap);
-        setReaderRow(row);
-        setReaderTop(Math.max(0, Math.min(maxTop, Math.max(0, matchLine) - Math.floor(cap / 2))));
-        setNote('');
-        setMode('reader');
-    }
-    function scrollReader(delta) {
-        setReaderTop((t) => Math.max(0, Math.min(readerMaxTop, t + delta)));
+    // 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
+    // devono restare la stessa azione.
+    function resumeSession(sessionId) {
+        const bound = bindings.get(sessionId) ?? null;
+        const child = spawnDeckResume(bound, cwd, sessionId, sessionNotes.get(sessionId));
+        child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
+        setNote(`⏎ resume ${sessionId.slice(0, 8)} → tab CC${bound ? ` (${bound})` : ' (spot)'}`);
     }
-    // T52 — toggle di tipo messaggio. Spegnerli tutti è uno stato lecito (lista
-    // vuota, nessun errore): è l'utente che ha chiuso ogni canale, non un guasto.
-    function toggleKind(kind) {
-        setSearchOpts((o) => ({ ...o, kinds: { ...o.kinds, [kind]: !o.kinds[kind] } }));
-    }
-    function editSearchField(fn) {
-        // La nota racconta l'esito di un'AZIONE su una lista che, con l'eager, si
-        // ricostruisce a ogni carattere: appena la query cambia è già scaduta.
-        // Lasciarla lì la fa leggere come se descrivesse lo stato corrente — nello
-        // specifico «nessuna occorrenza selezionata» sopra una lista con una riga
-        // visibilmente selezionata, cioè una contraddizione a schermo.
-        setNote('');
-        if (searchField === 'hash')
-            setSearchHash(fn);
-        else
-            setSearchQuery(fn);
-    }
-    // `useInput` consegna il CHUNK letto da stdin, non un tasto: un incollaggio —
-    // o una raffica di tasti piu' veloce di una read — arriva come stringa unica,
-    // byte di controllo compresi. Due conseguenze, entrambe verificate su pty:
-    //
-    //  1. I byte di controllo finiscono DENTRO il campo se non li si filtra. Non
-    //     si vedono, ma Ink li conta nella larghezza della riga e nessun match li
-    //     soddisfa -> la ricerca smette di trovare senza dire perche'. Le newline
-    //     diventano spazio invece di sparire: incollare due righe deve separare
-    //     le parole, non fonderle.
+    // T57 — ⏎ nel modale: riscrive il binding nel sidecar e ricarica subito.
     //
-    //  2. Un TAB digitato subito dopo una lettera (~60 ms, cioe' battitura veloce
-    //     normale) arriva incollato ad essa: `key.tab` resta falso e il ramo del
-    //     cambio campo non scatta mai. Trattarlo come testo lo renderebbe uno
-    //     spazio, per giunta nel campo sbagliato — e' cosi' che `70897aff` + Tab
-    //     + `congelat` finiva tutto quanto nel campo hash.
+    // 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.
     //
-    // Si spezza quindi il chunk SUL TAB applicando il cambio campo in mezzo: il
-    // risultato e' identico alla battitura lenta. Stessa lezione del modale sort
-    // (T39), che cicla sui caratteri del chunk invece di leggerlo intero.
-    function typeIntoField(chunk) {
-        setNote('');
-        const clean = sanitizeTyped;
-        const parts = chunk.split('\t');
-        let field = searchField;
-        const add = { hash: '', query: '' };
-        for (let k = 0; k < parts.length; k++) {
-            if (k > 0)
-                field = field === 'hash' ? 'query' : 'hash';
-            add[field] += clean(parts[k]);
+    // 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.
+    const assign = useAssignOverlay({
+        viewTasks,
+        rows,
+        hasNote: Boolean(note),
+        setMode,
+        setNote,
+        onSubmit: (sid, target) => {
+            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`);
+        },
+    });
+    const sheet = useSheetOverlay({
+        rows,
+        columns,
+        setMode,
+        setNote,
+        onAction: (id, kind, label) => spawnForTask(id, kind, label),
+    });
+    const search = useSearchOverlay({
+        sessions,
+        rows,
+        columns,
+        hasNote: Boolean(note),
+        setMode,
+        setNote,
+        onResume: (row) => resumeSession(row.session.sessionId),
+    });
+    function onCreateKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setDraft('');
+            setNote('C → create annullato');
+        }
+        else if (key.return) {
+            submitCreate();
+        }
+        else if (key.backspace || key.delete) {
+            setDraft((d) => d.slice(0, -1));
+        }
+        else if (input && !key.ctrl && !key.meta) {
+            setDraft((d) => d + input);
         }
-        if (add.hash)
-            setSearchHash((v) => v + add.hash);
-        if (add.query)
-            setSearchQuery((v) => v + add.query);
-        setSearchField(field);
     }
-    const searchCap = searchListCapacity(rows, Boolean(note));
-    useInput((input, key) => {
-        // T52 — MODALE DENTRO IL MODALE. `useInput` in Ink è globale e non ha
-        // focus-trap: non esiste un meccanismo che confini l'input a un componente.
-        // La cattura È l'ordine dei rami — quindi il reader va PRIMA della ricerca,
-        // e mentre è aperto il modale ricerca resta montato sotto con la sua
-        // selezione intatta, pronto a riprendere il controllo su `esc`.
-        if (mode === 'reader') {
-            if (key.escape) {
-                setMode('search');
-                setReaderRow(null);
-            }
-            else if (key.upArrow) {
-                scrollReader(-1);
-            }
-            else if (key.downArrow) {
-                scrollReader(1);
-            }
-            else if (key.pageUp) {
-                scrollReader(-readerCap);
-            }
-            else if (key.pageDown) {
-                scrollReader(readerCap);
-            }
-            else if (input === 'g') {
-                // Estremi su lettera e non su Home/End: Ink RICONOSCE quelle due (le
-                // mappa a 'home'/'end' nel parser) ma NON le espone — `nonAlphanumericKeys`
-                // azzera l'input e nessun flag le rappresenta, quindi arrivano
-                // indistinguibili da qualunque tasto ignoto. Verificato su pty reale.
-                // Nel reader non c'è input di testo, quindi le lettere sono libere.
-                setReaderTop(0);
-            }
-            else if (input === 'G') {
-                setReaderTop(readerMaxTop);
-            }
-            return;
+    function onNoteKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setNoteDraft('');
+            setNote('N → nota annullata');
         }
-        // T52 — modale ricerca. I due campi di testo mangiano ogni lettera nuda:
-        // ogni comando che deve restare vivo MENTRE si digita passa da CTRL, dai
-        // tasti freccia o da Tab. `esc` chiude il modale, non il deck.
-        if (mode === 'search') {
-            if (key.escape) {
-                setMode('normal');
-                setNote('');
-                return;
-            }
-            if (key.ctrl) {
-                const flag = SEARCH_TOGGLE_KEYS[input];
-                if (flag) {
-                    setSearchOpts((o) => ({ ...o, [flag]: !o[flag] }));
-                    return;
-                }
-                const kind = SEARCH_KIND_KEYS[input];
-                if (kind)
-                    toggleKind(kind);
-                return; // ogni altra combo ctrl (^F incluso: siamo già dentro) = no-op
-            }
-            if (key.tab) {
-                setSearchField((f) => (f === 'hash' ? 'query' : 'hash'));
-            }
-            else if (key.upArrow) {
-                setSearchSelKey((k) => moveRowSelection(searchRows, k, -1));
-            }
-            else if (key.downArrow) {
-                setSearchSelKey((k) => moveRowSelection(searchRows, k, 1));
-            }
-            else if (key.pageUp) {
-                setSearchSelKey((k) => moveRowSelection(searchRows, k, -Math.max(1, searchCap)));
-            }
-            else if (key.pageDown) {
-                setSearchSelKey((k) => moveRowSelection(searchRows, k, Math.max(1, searchCap)));
-            }
-            else if (key.return) {
-                submitSearchRow();
-            }
-            else if (key.backspace || key.delete) {
-                editSearchField((s) => s.slice(0, -1));
-            }
-            else if (input && !key.meta) {
-                typeIntoField(input);
-            }
-            return;
+        else if (key.return) {
+            submitNote();
         }
-        // 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;
+        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('');
         }
-        // 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') {
-            if (key.escape) {
-                setMode('normal');
-                setDraft('');
-                setNote('C → create annullato');
-            }
-            else if (key.return) {
-                submitCreate();
-            }
-            else if (key.backspace || key.delete) {
-                setDraft((d) => d.slice(0, -1));
-            }
-            else if (input && !key.ctrl && !key.meta) {
-                setDraft((d) => d + input);
-            }
-            return;
+        else if (key.backspace || key.delete) {
+            setNoteDraft((d) => d.slice(0, -1));
         }
-        // T53 — modale nota. Come create, cattura il testo e corto-circuita la
-        // navigazione (qui `q` è una lettera da scrivere, non il quit).
-        if (mode === 'note') {
-            if (key.escape) {
-                setMode('normal');
-                setNoteDraft('');
-                setNote('N → nota annullata');
-            }
-            else if (key.return) {
-                submitNote();
-            }
-            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));
-            }
-            return;
+        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));
         }
-        // T39 — modale sort a grammatica libera: la SEQUENZA di tasti È la chain.
-        // Digitare `ppi` = p(asc) p(desc) i(asc) → [pri desc, id asc]. La lista si
-        // riordina dal vivo a ogni pressione.
-        if (mode === 'sort') {
-            if (key.escape) {
-                closeViewModal(true);
-                setNote('S → sort annullato');
-            }
-            else if (key.return) {
-                closeViewModal(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) }));
-                }
-            }
-            return;
+    }
+    function onSortKey(input, key) {
+        if (key.escape) {
+            closeViewModal(true);
+            setNote('S → sort annullato');
         }
-        // T39 — modale filtri: griglia 2 righe (priorità / stato), un toggle per
-        // valore. Anche qui l'effetto è immediato sulla lista.
-        if (mode === 'filter') {
-            const rowLen = (r) => (r === 0 ? PRI_ENTRIES.length : PROG_ENTRIES.length);
-            if (key.escape) {
-                closeViewModal(true);
-                setNote('F → filtri annullati');
-            }
-            else if (key.return) {
-                closeViewModal(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;
+        else if (key.return) {
+            closeViewModal(false);
+            setNote(`S → sort: ${describeSort(view.sort)}`);
         }
-        // T41 — modale edit: griglia a 4 righe. Righe 0/1 = scelta a valore singolo
-        // (←→ scorre), righe 2/3 = testo libero (ogni carattere stampabile entra nel
-        // campo). Come gli altri modali cattura tutto: `esc` annulla senza
-        // scrivere né uscire dal deck.
-        if (mode === 'edit') {
-            if (key.escape) {
-                setMode('normal');
-                setEdit(null);
-                setNote('E → edit annullato');
-            }
-            else if (key.return) {
-                submitEdit();
-            }
-            else if (key.upArrow || key.downArrow) {
-                const next = ((editRow + EDIT_ROWS + (key.upArrow ? -1 : 1)) % EDIT_ROWS);
-                setEditRow(next);
-                // Il caret segue la riga attiva e atterra in CODA al nuovo campo: è la
-                // posizione da cui si continua a scrivere, ed è anche l'unica che non
-                // dipende da dove stava il cursore nel campo precedente.
-                setEdit((e) => (e && isTextRow(next) ? { ...e, caret: cpLen(e[editField(next)]) } : e));
-            }
-            else if ((key.leftArrow || key.rightArrow) && !isTextRow(editRow)) {
-                const d = key.leftArrow ? -1 : 1;
-                // Scorrimento CICLICO (wrap) e non clampato: le liste sono di 3-4 voci,
-                // arrivare in fondo e ripartire costa meno di invertire direzione.
-                if (editRow === 0) {
-                    setEdit((e) => e ? { ...e, pri: EDIT_PRI[(EDIT_PRI.indexOf(e.pri) + d + EDIT_PRI.length) % EDIT_PRI.length] } : e);
-                }
-                else if (editRow === 1) {
-                    setEdit((e) => e
-                        ? { ...e, prog: EDIT_PROG[(EDIT_PROG.indexOf(e.prog) + d + EDIT_PROG.length) % EDIT_PROG.length] }
-                        : e);
-                }
-            }
-            else if (isTextRow(editRow)) {
-                // Un solo ramo per i due campi di testo, la riga sceglie la chiave:
-                // duplicarlo significherebbe tenere allineate a mano due copie della
-                // stessa grammatica di input a ogni tasto aggiunto.
-                const field = editField(editRow);
-                if (key.ctrl) {
-                    // T54 — ramo CTRL ANTEPOSTO a quelli su carattere, come in modalità
-                    // normale: `^A` e `a` arrivano con lo stesso `input`, quindi senza
-                    // questa precedenza il `^A` finirebbe dentro il testo.
-                    //
-                    // `^A`/`^E` (convenzione readline) perché `Home`/`End` NON sono
-                    // esposte da `useInput`: arrivano come input vuoto, indistinguibili
-                    // da qualunque altro tasto senza nome.
-                    //
-                    // `^D` è il delete-forward, e anche qui il motivo è un limite di Ink:
-                    // il tasto Backspace fisico manda `\x7f` e il tasto Canc manda
-                    // `\x1b[3~`, ma `parseKeypress` li battezza ENTRAMBI `delete` e
-                    // svuota `input` — a valle sono lo stesso evento. `key.delete` va
-                    // quindi al backspace (il tasto che si usa davvero) e la
-                    // cancellazione in avanti prende il suo tasto readline.
-                    if (input === 'a')
-                        setEdit((e) => (e ? { ...e, caret: 0 } : e));
-                    else if (input === 'e')
-                        setEdit((e) => (e ? { ...e, caret: cpLen(e[field]) } : e));
-                    else if (input === 'd')
-                        setEdit((e) => (e ? { ...e, [field]: removeAt(e[field], e.caret) } : e));
-                }
-                else if (key.leftArrow || key.rightArrow) {
-                    // CLAMP agli estremi, non wrap: a inizio campo `←` non deve saltare in
-                    // fondo. Le liste di valori (righe 0/1) ciclano perché sono 3-4 voci;
-                    // un testo no — il salto sarebbe indistinguibile da uno sfarfallio.
-                    const d = key.leftArrow ? -1 : 1;
-                    setEdit((e) => e ? { ...e, caret: Math.max(0, Math.min(cpLen(e[field]), e.caret + d)) } : e);
-                }
-                else if (key.backspace || key.delete) {
-                    setEdit((e) => e ? { ...e, [field]: removeAt(e[field], e.caret - 1), caret: Math.max(0, e.caret - 1) } : e);
-                }
-                else if (input && !key.meta) {
-                    // `sanitizeTyped`: `useInput` consegna il CHUNK di stdin, quindi un
-                    // incollaggio porta dentro newline e byte di controllo — invisibili
-                    // nel campo ma contati da Ink nella larghezza della riga, e destinati
-                    // a finire tali e quali dentro tasks.md. Ed è per lo stesso motivo che
-                    // il caret avanza della LUNGHEZZA del chunk, non di uno: un incollaggio
-                    // entra tutto insieme.
-                    const ins = sanitizeTyped(input);
-                    setEdit((e) => e ? { ...e, [field]: insertAt(e[field], e.caret, ins), caret: e.caret + cpLen(ins) } : e);
-                }
+        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) }));
             }
-            return;
         }
-        // T66 — detail della task: due zone (testo scrollabile + barra azioni) e una
-        // selezione per ognuna. Sta PRIMA del ramo di default per la stessa ragione
-        // di reader e ricerca — Ink non ha focus-trap, quindi la cattura È l'ordine
-        // dei rami — e il `return` in fondo è ciò che impedisce a `←→` di cambiare
-        // pane mentre muove fra le azioni: qui quel binding non esiste più.
-        // È anche prima del ramo CTRL, quindi `^K`/`^P`/`^R` restano acceleratori
-        // della sola lista: chi è già nel detail ha i bottoni.
-        if (mode === 'detail') {
-            // T91 — modale DENTRO il modale, e sta prima per la stessa ragione per cui
-            // il detail sta prima del ramo CTRL: Ink non ha focus-trap, quindi la
-            // cattura È l'ordine dei rami. Mentre il campo è aperto mangia ogni lettera
-            // nuda, `g`/`G` compresi.
-            if (find?.open) {
-                if (key.escape) {
-                    // Annulla: butta via ciò che il modale ha prodotto. Lo scroll resta
-                    // dove la ricerca l'ha portato — riavvolgerlo sarebbe una terza
-                    // semantica che nessun tasto ha chiesto.
-                    setFind(null);
-                }
-                else if (key.return) {
-                    // Congela: campo chiuso, occorrenze ancora colorate, scroll intatto.
-                    setFind((f) => (f ? { ...f, open: false } : f));
-                }
-                else if (key.upArrow) {
-                    moveOcc(-1);
-                }
-                else if (key.downArrow) {
-                    moveOcc(1);
-                }
-                else if (key.leftArrow || key.rightArrow) {
-                    const d = key.leftArrow ? -1 : 1;
-                    setFind((f) => f ? { ...f, caret: Math.max(0, Math.min(cpLen(f.q), f.caret + d)) } : f);
-                }
-                else if (key.backspace || key.delete) {
-                    editFind((f) => f.caret > 0 ? { ...f, q: removeAt(f.q, f.caret - 1), caret: f.caret - 1 } : f);
-                }
-                else if (key.ctrl) {
-                    // `^U` svuota, come il filtro del modale assegnazione; ogni altra combo
-                    // è no-op — `^F` incluso, siamo già dentro.
-                    if (input === 'u')
-                        editFind((f) => ({ ...f, q: '', caret: 0 }));
-                }
-                else if (input && !key.meta) {
-                    const ins = sanitizeTyped(input);
-                    editFind((f) => ({ ...f, q: insertAt(f.q, f.caret, ins), caret: f.caret + cpLen(ins) }));
-                }
-                return;
-            }
-            if (key.ctrl && input === 'f') {
-                // Fuori dal detail `^F` è la ricerca conversazioni; qui è la ricerca nel
-                // testo. La query sopravvive a una chiusura con `⏎`, quindi riaprire
-                // riprende da dov'era invece di ricominciare.
-                setFind((f) => (f ? { ...f, open: true } : { q: '', caret: 0, open: true }));
-                return;
-            }
-            if (key.escape) {
-                // Uno strato alla volta: se resta un'evidenziazione congelata, `esc`
-                // smonta quella; il detail lo chiude il secondo.
-                // Nessun reset di `sel`: la selezione della lista non è mai stata
-                // toccata, quindi si ritrova esattamente dov'era.
-                if (find)
-                    setFind(null);
-                else
-                    closeDetail();
+    }
+    function onFilterKey(input, key) {
+        const rowLen = (r) => (r === 0 ? PRI_ENTRIES.length : PROG_ENTRIES.length);
+        if (key.escape) {
+            closeViewModal(true);
+            setNote('F → filtri annullati');
+        }
+        else if (key.return) {
+            closeViewModal(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) });
+        }
+    }
+    function onEditKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setEdit(null);
+            setNote('E → edit annullato');
+        }
+        else if (key.return) {
+            submitEdit();
+        }
+        else if (key.upArrow || key.downArrow) {
+            const next = ((editRow + EDIT_ROWS + (key.upArrow ? -1 : 1)) % EDIT_ROWS);
+            setEditRow(next);
+            // Il caret segue la riga attiva e atterra in CODA al nuovo campo: è la
+            // posizione da cui si continua a scrivere, ed è anche l'unica che non
+            // dipende da dove stava il cursore nel campo precedente.
+            setEdit((e) => (e && isTextRow(next) ? { ...e, caret: cpLen(e[editField(next)]) } : e));
+        }
+        else if ((key.leftArrow || key.rightArrow) && !isTextRow(editRow)) {
+            const d = key.leftArrow ? -1 : 1;
+            // Scorrimento CICLICO (wrap) e non clampato: le liste sono di 3-4 voci,
+            // arrivare in fondo e ripartire costa meno di invertire direzione.
+            if (editRow === 0) {
+                setEdit((e) => e ? { ...e, pri: EDIT_PRI[(EDIT_PRI.indexOf(e.pri) + d + EDIT_PRI.length) % EDIT_PRI.length] } : e);
+            }
+            else if (editRow === 1) {
+                setEdit((e) => e
+                    ? { ...e, prog: EDIT_PROG[(EDIT_PROG.indexOf(e.prog) + d + EDIT_PROG.length) % EDIT_PROG.length] }
+                    : e);
             }
-            else if (key.return) {
-                // `⏎` esegue SEMPRE l'azione selezionata, mai "scrolla" o "chiudi": il
-                // testo non è un campo attivo (si scorre, non si edita), quindi nessuna
-                // competizione sul tasto.
-                const action = DETAIL_ACTIONS[sheetAction];
-                const id = sheet?.id;
-                closeDetail();
-                if (id)
-                    spawnForTask(id, action.kind, `⏎ ${action.label}`);
+        }
+        else if (isTextRow(editRow)) {
+            // Un solo ramo per i due campi di testo, la riga sceglie la chiave:
+            // duplicarlo significherebbe tenere allineate a mano due copie della
+            // stessa grammatica di input a ogni tasto aggiunto.
+            const field = editField(editRow);
+            if (key.ctrl) {
+                // T54 — ramo CTRL ANTEPOSTO a quelli su carattere, come in modalità
+                // normale: `^A` e `a` arrivano con lo stesso `input`, quindi senza
+                // questa precedenza il `^A` finirebbe dentro il testo.
+                //
+                // `^A`/`^E` (convenzione readline) perché `Home`/`End` NON sono
+                // esposte da `useInput`: arrivano come input vuoto, indistinguibili
+                // da qualunque altro tasto senza nome.
+                //
+                // `^D` è il delete-forward, e anche qui il motivo è un limite di Ink:
+                // il tasto Backspace fisico manda `\x7f` e il tasto Canc manda
+                // `\x1b[3~`, ma `parseKeypress` li battezza ENTRAMBI `delete` e
+                // svuota `input` — a valle sono lo stesso evento. `key.delete` va
+                // quindi al backspace (il tasto che si usa davvero) e la
+                // cancellazione in avanti prende il suo tasto readline.
+                if (input === 'a')
+                    setEdit((e) => (e ? { ...e, caret: 0 } : e));
+                else if (input === 'e')
+                    setEdit((e) => (e ? { ...e, caret: cpLen(e[field]) } : e));
+                else if (input === 'd')
+                    setEdit((e) => (e ? { ...e, [field]: removeAt(e[field], e.caret) } : e));
             }
             else if (key.leftArrow || key.rightArrow) {
-                // Scorrimento CICLICO come le righe di scelta del modale edit: cinque
-                // voci, arrivare in fondo e ripartire costa meno che invertire direzione.
+                // CLAMP agli estremi, non wrap: a inizio campo `←` non deve saltare in
+                // fondo. Le liste di valori (righe 0/1) ciclano perché sono 3-4 voci;
+                // un testo no — il salto sarebbe indistinguibile da uno sfarfallio.
                 const d = key.leftArrow ? -1 : 1;
-                setSheetAction((i) => (i + d + DETAIL_ACTIONS.length) % DETAIL_ACTIONS.length);
-            }
-            else if (key.upArrow) {
-                scrollDetail(-1);
-            }
-            else if (key.downArrow) {
-                scrollDetail(1);
-            }
-            else if (key.pageUp) {
-                scrollDetail(-sheetCap);
-            }
-            else if (key.pageDown) {
-                scrollDetail(sheetCap);
+                setEdit((e) => e ? { ...e, caret: Math.max(0, Math.min(cpLen(e[field]), e.caret + d)) } : e);
             }
-            else if (input === 'g') {
-                // Estremi su lettera per lo stesso motivo del reader: Ink riconosce
-                // `Home`/`End` ma non le espone, e qui non c'è input di testo che
-                // contenda le lettere.
-                setSheetTop(0);
+            else if (key.backspace || key.delete) {
+                setEdit((e) => e ? { ...e, [field]: removeAt(e[field], e.caret - 1), caret: Math.max(0, e.caret - 1) } : e);
             }
-            else if (input === 'G') {
-                setSheetTop(sheetMaxTop);
+            else if (input && !key.meta) {
+                // `sanitizeTyped`: `useInput` consegna il CHUNK di stdin, quindi un
+                // incollaggio porta dentro newline e byte di controllo — invisibili
+                // nel campo ma contati da Ink nella larghezza della riga, e destinati
+                // a finire tali e quali dentro tasks.md. Ed è per lo stesso motivo che
+                // il caret avanza della LUNGHEZZA del chunk, non di uno: un incollaggio
+                // entra tutto insieme.
+                const ins = sanitizeTyped(input);
+                setEdit((e) => e ? { ...e, [field]: insertAt(e[field], e.caret, ins), caret: e.caret + cpLen(ins) } : e);
             }
+        }
+    }
+    // Il dispatch consulta il CATALOGO (`input-modes.ts`), non l'ordine di una
+    // catena di `if`. `MODE_KEYS` è il custode: essendo un `Record` su
+    // `CapturingMode`, un modo nuovo senza handler non compila.
+    const MODE_KEYS = {
+        detail: sheet.onKey,
+        reader: search.onReaderKey,
+        search: search.onSearchKey,
+        assign: assign.onKey,
+        create: onCreateKey,
+        note: onNoteKey,
+        sort: onSortKey,
+        filter: onFilterKey,
+        edit: onEditKey,
+    };
+    useInput((input, key) => {
+        // Un modo capturing consuma TUTTO — acceleratori globali compresi — e le
+        // deroghe se le gestisce da sé (`CTRL_DEROGATIONS`). Da qui in giù si è
+        // quindi in `normal`, l'unico modo che cede ai `key.ctrl`.
+        if (captures(mode)) {
+            MODE_KEYS[mode](input, key);
             return;
         }
         // T52/D1 — il ramo CTRL sta PRIMA di quelli su lettera nuda e li chiude
@@ -1794,16 +721,22 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             return;
         }
         if (key.tab) {
-            // T100 — `tab` resta l'unico tasto che sposta il focus fra i due pane. Le
-            // frecce orizzontali facevano lo stesso lavoro (due tasti per un'azione)
-            // mentre la navigazione DENTRO un pane non ne aveva nessuno: ora sono il
-            // selettore di vista dell'header. Il ramo `mode === 'detail'`, anteposto e
-            // chiuso da `return`, non è più l'eccezione a «cambia pane» ma a «cambia
-            // vista» — l'ordine dei rami non cambia, cambia cosa cattura.
-            setFocus((f) => (f === 'tasks' ? 'sessions' : 'tasks'));
+            // `tab` cicla la VISTA del pane a fuoco, `←→` spostano il focus fra i due
+            // pane: il criterio dell'assegnazione è spaziale. Una freccia orizzontale
+            // porta con sé una direzione e i pane sono affiancati (task a sinistra,
+            // sessioni a destra), quindi il tasto NOMINA il pane invece di limitarsi
+            // a scambiarlo; un catalogo ciclico non ha un verso da rispettare, e un
+            // tasto solo gli basta. `shift+tab` (backtab, `[Z`) scorre a rovescio — il
+            // verso che un tasto singolo non esprime sta nel modificatore, e su cinque
+            // voci risparmia quattro pressioni.
+            cycleView(key.shift ? -1 : 1);
         }
         else if (key.leftArrow || key.rightArrow) {
-            cycleView(key.leftArrow ? -1 : 1);
+            // Binding ASSOLUTO, non toggle: `←` porta sempre sui task e `→` sempre
+            // sulle sessioni, quindi ripremere lo stesso tasto non riporta indietro.
+            // È ciò che lo rende spaziale — la direzione indica una destinazione, e
+            // con due soli pane un toggle sarebbe indistinguibile solo per caso.
+            setFocus(key.leftArrow ? 'tasks' : 'sessions');
         }
         else if (key.upArrow) {
             if (focus === 'tasks')
@@ -1825,7 +758,19 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 // più battuto non è il posto dove inchiodare una scelta di prompt — le
                 // shortcut CTRL restano per chi sa già cosa vuole, `⏎` apre il ventaglio.
                 // Lo spawn a mani nude di prima è `open`, cioè `⏎ ⏎` (è il focus iniziale).
-                openDetail();
+                {
+                    const task = selectedTaskOr('⏎', 'aprire');
+                    if (task) {
+                        sheet.open({
+                            id: task.id,
+                            // Il titolo del task file quando c'è (è l'H1, cioè la forma
+                            // lunga), la riga di tasks.md altrimenti: il detail non deve
+                            // restare senza intestazione solo perché il file manca.
+                            title: detail?.title || task.desc,
+                            text: loadTaskFileText(tasksDir, task.id),
+                        });
+                    }
+                }
             }
             else {
                 // T49 — ⏎ su una sessione = resume in nuova tab. Il binding si rilegge
@@ -1835,10 +780,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     setNote(selSessionId ? 'pin stale: transcript non più presente' : 'nessuna sessione da riprendere');
                 }
                 else {
-                    const bound = bindings.get(s.sessionId) ?? null;
-                    const child = spawnDeckResume(bound, cwd, s.sessionId, sessionNotes.get(s.sessionId));
-                    child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
-                    setNote(`⏎ resume ${s.sessionId.slice(0, 8)} → tab CC${bound ? ` (${bound})` : ' (spot)'}`);
+                    resumeSession(s.sessionId);
                 }
             }
         }
@@ -1880,7 +822,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // Vive solo sul pane sessioni: il fork ha per oggetto una conversazione,
             // e senza focus lì non ce n'è una selezionata su cui agire.
             if (focus !== 'sessions') {
-                setNote('f → fork: seleziona una sessione (tab per il pane)');
+                setNote('f → fork: seleziona una sessione (→ per il pane)');
             }
             else {
                 const s = selSessionObj;
@@ -1912,7 +854,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // pinnata STALE (l'unico modo di spinnarla). Scrive il sidecar e ricarica
             // subito, senza attendere il tick del poll.
             if (focus !== 'sessions') {
-                setNote('p → pin: seleziona una sessione (tab per il pane)');
+                setNote('p → pin: seleziona una sessione (→ per il pane)');
             }
             else if (!selSessionId) {
                 setNote('p → nessuna sessione da pinnare');
@@ -1940,7 +882,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // su una pinnata STALE, perché annotare «questa non c'è più, era X» è
             // proprio il caso in cui una nota serve.
             if (focus !== 'sessions') {
-                setNote('N → nota: seleziona una sessione (tab per il pane)');
+                setNote('N → nota: seleziona una sessione (→ per il pane)');
             }
             else if (!selSessionId) {
                 setNote('N → nessuna sessione da annotare');
@@ -1958,13 +900,14 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             // il binding è nostro, il transcript è di CC — riassegnare una
             // conversazione il cui transcript non c'è più resta legittimo.
             if (focus !== 'sessions') {
-                setNote('A → assegna: seleziona una sessione (tab per il pane)');
+                setNote('A → assegna: seleziona una sessione (→ per il pane)');
             }
             else if (!selSessionId) {
                 setNote('A → nessuna sessione da assegnare');
             }
             else {
-                openAssign();
+                if (selSessionId)
+                    assign.open(selSessionId, bindings.get(selSessionId));
             }
         }
         else if (input === 't') {
@@ -2051,32 +994,32 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // visibile, quindi va RIPETUTA nel titolo — senza, non si sa più su cosa si
     // sta agendo.
     if (mode === 'assign') {
-        if (isCompact(assignCap)) {
+        if (isCompact(assign.capacity)) {
             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;
+        const at = assign.list.findIndex((t) => (t?.id ?? null) === assign.sel);
+        const win = windowRange(assign.list.length, at, assign.capacity);
+        const s = assign.sid ? sessions.find((x) => x.sessionId === assign.sid) ?? 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 }));
+        const label = (assign.sid ? sessionNotes.get(assign.sid) : '') ||
+            (s ? conversationLabel(s, projectCore, assign.sid ? bindings.get(assign.sid) : undefined) : '');
+        return (_jsx(AssignScreen, { sessionId: assign.sid ?? '', label: label, current: assign.sid ? bindings.get(assign.sid) ?? null : null, filter: assign.filter, rows: assign.list.slice(win.start, win.end), selected: assign.sel, matched: assign.list.length - 1, hidden: hiddenTasks, above: win.start, below: assign.list.length - win.end, childCount: childCount, columns: columns, note: note }));
     }
     // ── T66 · detail della task ─────────────────────────────────────────────
     // Quarta schermata sostitutiva, stessa ragione delle altre tre: un task file
     // non entra in un box sopra i due pane. Il budget dei pane non viene nemmeno
     // calcolato — il render esce di qui prima.
-    if (mode === 'detail' && sheet) {
-        if (isCompact(sheetCap)) {
-            return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", sheet.id, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga \u00B7 esc chiude"] })] }));
+    if (mode === 'detail' && sheet.sheet) {
+        if (isCompact(sheet.capacity)) {
+            return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", sheet.sheet.id, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga \u00B7 esc chiude"] })] }));
         }
         // Niente `windowRange`: quella centra la finestra su una selezione, qui la
         // posizione è lo scroll mosso a mano. Il clamp serve comunque — un resize
         // può accorciare il testo sotto uno scroll già dato.
-        const start = Math.min(sheetTop, sheetMaxTop);
-        return (_jsx(DetailScreen, { id: sheet.id, title: sheet.title, missing: sheet.text === null, lines: sheetLines.slice(start, start + sheetCap), spans: sheetDoc?.spans ?? [], top: start, total: sheetLines.length, capacity: sheetCap, action: sheetAction, columns: columns, find: find, occ: findRes.occ, occCur: occCur }));
+        const start = Math.min(sheet.top, sheet.maxTop);
+        return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur }));
     }
     // ── T52 · schermate sostitutive ─────────────────────────────────────────
     // Ricerca e reader sono gli unici modali che NON stanno in flusso sopra i
@@ -2085,42 +1028,42 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // serve nemmeno calcolarlo, e la loro altezza la distribuiscono
     // `searchListCapacity` / `readerCapacity`.
     if (mode === 'search' || mode === 'reader') {
-        const hit = mode === 'reader' && readerRow?.kind === 'hit' ? readerRow.hit : null;
+        const hit = mode === 'reader' && search.readerRow?.kind === 'hit' ? search.readerRow.hit : null;
         // Terminale sotto la cornice: riga singola invece del box, per lo stesso
         // motivo del `budget.compact` del deck — un frame più alto di `rows` fa
         // pulire lo schermo a Ink a ogni redraw, e il poll lo versa nello scrollback.
-        if (isCompact(hit ? readerCap : searchCap)) {
+        if (isCompact(hit ? search.readerCap : search.listCap)) {
             return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", hit ? 'reader' : 'ricerca', " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga \u00B7", ' ', "esc ", hit ? 'torna' : 'chiude'] })] }));
         }
         if (hit) {
             // Niente `windowRange`: quella centra la finestra su una SELEZIONE, qui
             // la posizione è lo scroll che l'utente muove a mano. Il clamp serve
             // comunque — un resize può accorciare il testo sotto uno scroll già dato.
-            const start = Math.min(readerTop, readerMaxTop);
-            return (_jsx(ReaderScreen, { hit: hit, lines: readerLines.slice(start, start + readerCap), top: start, total: readerLines.length, capacity: readerCap, bound: bindings.get(hit.sessionId) ?? null }));
+            const start = Math.min(search.readerTop, search.readerMaxTop);
+            return (_jsx(ReaderScreen, { hit: hit, lines: search.readerLines.slice(start, start + search.readerCap), top: start, total: search.readerLines.length, capacity: search.readerCap, bound: bindings.get(hit.sessionId) ?? null }));
         }
-        const selIdx = rowIndexOfKey(searchRows, searchSelKey);
-        const win = windowRange(searchRows.length, selIdx, searchCap);
+        const selIdx = rowIndexOfKey(search.rows, search.selKey);
+        const win = windowRange(search.rows.length, selIdx, search.listCap);
         // Anteprima dell'occorrenza selezionata: prende le righe che la lista non
         // usa. Con molti risultati `spare` è 0 e il pannello non esiste — la lista
         // se le riprende tutte, che è la priorità giusta quando c'è molto da
         // scorrere. La finestra si CENTRA sul match (`windowRange`), così il
         // contesto arriva da entrambi i lati.
-        const spare = searchPreviewCapacity(searchCap, win.end - win.start);
+        const spare = searchPreviewCapacity(search.listCap, win.end - win.start);
         let preview = null;
-        if (spare >= 1 && searchSelRow?.kind === 'hit') {
-            const h = searchSelRow.hit;
-            const mline = Math.max(0, searchPreviewBody.findIndex((l) => l.end > h.matchStart));
-            const pw = windowRange(searchPreviewBody.length, mline, spare);
+        if (spare >= 1 && search.selRow?.kind === 'hit') {
+            const h = search.selRow.hit;
+            const mline = Math.max(0, search.previewBody.findIndex((l) => l.end > h.matchStart));
+            const pw = windowRange(search.previewBody.length, mline, spare);
             preview = {
                 hit: h,
-                lines: searchPreviewBody.slice(pw.start, pw.end),
+                lines: search.previewBody.slice(pw.start, pw.end),
                 from: pw.start,
-                total: searchPreviewBody.length,
+                total: search.previewBody.length,
                 ts: sessions.find((s) => s.sessionId === h.sessionId)?.ts ?? 0,
             };
         }
-        return (_jsx(SearchScreen, { preview: preview, hash: searchHash, query: searchQuery, field: searchField, opts: searchOpts, result: searchResult, rows: searchRows.slice(win.start, win.end), selectedKey: searchSelKey, selectedKind: selectedRow(searchRows, searchSelKey)?.kind ?? null, above: win.start, below: searchRows.length - win.end, capacity: searchCap, bindings: bindings, pinned: pinned, sessionNotes: sessionNotes, projectCore: projectCore, columns: columns, note: note }));
+        return (_jsx(SearchScreen, { preview: preview, hash: search.hash, query: search.query, field: search.field, opts: search.opts, result: search.result, rows: search.rows.slice(win.start, win.end), selectedKey: search.selKey, selectedKind: selectedRow(search.rows, search.selKey)?.kind ?? null, above: win.start, below: search.rows.length - win.end, capacity: search.listCap, bindings: bindings, pinned: pinned, sessionNotes: sessionNotes, projectCore: projectCore, columns: columns, note: note }));
     }
     // ── Budget d'altezza ────────────────────────────────────────────────────
     // Il frame deve restare sotto `rows`, sempre: oltre quella soglia Ink smette
@@ -2169,608 +1112,5 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     }
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nota conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${legend.shown}` : '', legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, counts: taskCounts, activeView: taskViewId, paneCount: paneTasks.length, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, windowStart: taskWin.start, above: taskWin.start, below: paneTasks.length - taskWin.end, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, counts: sessionCounts, activeView: sessionViewId, paneCount: sessionRows.length, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore, live: live })] }), budget.preview && previewKind === 'task' && detail ? (_jsx(PreviewPane, { kind: "task", detail: detail, maxLines: budget.detailLines, columns: columns })) : budget.preview && previewKind === 'session' && selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: selSessionObj, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, origin: forkOf.get(selSessionObj.sessionId) ?? null, note: sessionNotes.get(selSessionObj.sessionId) ?? '', live: live.get(selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
-const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
-// Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
-// spingono giù i pane invece di coprirli, così la lista che stai filtrando
-// resta sempre visibile mentre la componi.
-function SortModal({ sort }) {
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "S \u203A sort chain" }), sort.length === 0 ? (_jsx(Text, { dimColor: true, children: "nessuna chiave \u00B7 resta l'ordine per id \u2191" })) : (_jsx(Text, { children: sort
-                    .map((e, i) => `${i + 1}. ${SORT_UI[e.key]} ${e.dir === 'asc' ? '↑' : '↓'}`)
-                    .join('    ') }))] }));
-}
-function FilterModal({ view, cursor }) {
-    const rows = [
-        { label: 'pri  ', entries: PRI_ENTRIES, hidden: new Set(view.hiddenPri) },
-        { label: 'stato', entries: PROG_ENTRIES, hidden: new Set(view.hiddenProg) },
-    ];
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "F \u203A filtri" }), rows.map((row, r) => (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: row.label }), row.entries.map((e, c) => {
-                        const on = !row.hidden.has(e.name);
-                        const here = cursor.row === r && cursor.col === c;
-                        return (_jsxs(Text, { inverse: here, color: on ? 'green' : 'gray', dimColor: !on, children: ['  ', "[", on ? 'x' : ' ', "] ", sanitize(e.glyph)] }, e.name));
-                    })] }, row.label)))] }));
-}
-/**
- * Campo di testo del modale edit: finestra ancorata al caret + cursore inverso
- * nella posizione REALE.
- *
- * Il cursore non è più uno spazio inverso appiccicato in coda ma la cella `at`
- * della finestra — cioè il carattere su cui il caret sta davvero. Fuori fuoco
- * (`focused` falso) il caret non si disegna e la finestra si ancora in fondo,
- * che è la vista utile per un campo che non si sta scrivendo.
- */
-function EditTextField({ label, value, caret, focused, cols, }) {
-    const win = caretWindow(value, focused ? caret : cpLen(value), cols);
-    return (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: label }), _jsxs(Text, { children: ['  ', sanitize(win.head)] }), focused ? _jsx(Text, { inverse: true, children: sanitize(win.at) }) : null, _jsx(Text, { children: sanitize(win.tail) })] }));
-}
-// T41 — modale edit, in flusso come gli altri (spinge giù i pane invece di
-// coprirli: la riga che stai modificando resta visibile sopra la lista).
-// La riga di anteprima mostra il testo ESATTO che finirà nel campo `Progress`
-// del task file — così il default (`✔️ Done at <oggi>`) non è una sorpresa.
-function EditModal({ id, draft, row, columns, }) {
-    const mark = (r) => (row === r ? CARET : CARET_OFF);
-    // Budget dei campi di testo, DERIVATO da `columns` (mai una costante): il box
-    // del modale è ANNIDATO nella cornice del deck, quindi le cornici da scalare
-    // sono due — root (bordo 2 + paddingX 2) e modale (bordo 2 + paddingX 2) — più
-    // caret 2, etichetta 6, gap 2 e cursore 1. Totale 19.
-    // Un titolo di tasks.md arriva a ~64 caratteri: senza taglio la riga va a capo
-    // dentro il box, che si alza di una riga e sfonda il budget verticale (invariante ③).
-    const fieldBudget = Math.max(8, columns - 19);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 titolo, priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri   " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', sanitize(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato " }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', sanitize(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(EditTextField, { label: "prog  ", value: draft.detail, caret: draft.caret, focused: row === 2, cols: fieldBudget }), !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { children: [mark(3), _jsx(EditTextField, { label: "titolo", value: draft.title, caret: draft.caret, focused: row === 3, cols: fieldBudget })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", sanitize(progressText(draft.prog, draft.detail))] })] }));
-}
-// T52 — marcatore compatto del tipo di corpo sulla riga-occorrenza. Due
-// caratteri ASCII e non un'emoji: con più toggle accesi la colonna deve
-// allinearsi, e i glifi BMP larghi 2 sono proprio la classe che Ink e il
-// terminale misurano diversamente (vedi width.ts).
-const KIND_TAG = { ai: 'ai', tool: 'tl', human: 'hu' };
-const KIND_COLOR = { ai: 'cyan', tool: 'gray', human: 'green' };
-/**
- * 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.
- */
-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). */
-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.
- */
-function conversationLabel(s, core, bound) {
-    let t = stripProjectCore(s.title, core);
-    if (bound && t === bound)
-        t = '';
-    return t || s.firstPrompt || '(senza titolo)';
-}
-/**
- * Riga di toggle del modale ricerca.
- *
- * La mappa tasto→significato è SEMPRE a schermo: `^R` da solo è opaco quanto lo
- * era il range `1-9` delle launch prima di T43.
- *
- * Lo stato acceso/spento passa da `[x]`/`[ ]`, non dal solo colore — stessa
- * convenzione del modale filtri. Il colore è ridondanza, non l'informazione: su
- * un terminale monocromo, o in una cattura di testo, sei toggle tutti uguali
- * non direbbero più quali sono attivi.
- */
-function ToggleHint({ opts }) {
-    const flag = (on, key, label) => (_jsxs(Text, { color: on ? 'green' : 'gray', dimColor: !on, bold: on, children: ['  ', key, "[", on ? 'x' : ' ', "] ", label] }, key));
-    return (_jsxs(Text, { wrap: "truncate-end", children: [flag(opts.regex, '^R', 'regex'), flag(opts.caseSensitive, '^A', 'Aa'), flag(opts.wholeWord, '^W', 'word'), _jsx(Text, { dimColor: true, children: '  │' }), flag(opts.kinds.ai, '^B', 'IA'), flag(opts.kinds.tool, '^T', 'tools'), flag(opts.kinds.human, '^U', 'human')] }));
-}
-/** Intestazione della lista: dice sempre quanto NON si sta vedendo (regex rotta,
- *  query troppo corta, occorrenze tagliate dal cap, righe fuori finestra). */
-function SearchListHeader({ result, query, above, below, }) {
-    if (result.error) {
-        return (_jsxs(Text, { color: "red", wrap: "truncate-end", children: [WARN, " regex non valida \u00B7 ", result.error] }));
-    }
-    if (result.idle) {
-        return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: query.length === 0
-                ? 'digita la chiave da cercare'
-                : `almeno ${MIN_QUERY} caratteri (${query.length})` }));
-    }
-    if (result.shown === 0) {
-        return (_jsx(Text, { color: "yellow", wrap: "truncate-end", children: "nessuna occorrenza" }));
-    }
-    return (_jsxs(Text, { bold: true, wrap: "truncate-end", children: [result.shown, " occorrenze in ", result.sessionCount, " conversazioni", result.hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", result.hidden, " oltre il cap"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }));
-}
-function SearchScreen({ preview, hash, query, field, opts, result, rows, selectedKey, selectedKind, above, below, capacity, bindings, pinned, sessionNotes, projectCore, columns, note, }) {
-    const enter = selectedKind === 'session' ? 'resume' : selectedKind === 'hit' ? 'leggi' : '—';
-    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: ["ricerca \u00B7 ", _jsx(Text, { color: "yellow", children: "tab" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " naviga \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " ", enter, " \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "hash   " }), _jsx(Text, { color: field === 'hash' ? 'yellow' : undefined, children: hash }), field === 'hash' ? _jsx(Text, { inverse: true, children: " " }) : null, !hash ? _jsx(Text, { dimColor: true, children: "  (vuoto = tutte le conversazioni)" }) : null] }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "chiave " }), _jsx(Text, { color: field === 'query' ? 'yellow' : undefined, children: query }), field === 'query' ? _jsx(Text, { inverse: true, children: " " }) : null] }), _jsx(ToggleHint, { opts: opts })] }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsx(SearchListHeader, { result: result, query: query, above: above, below: below }), rows.slice(0, Math.max(0, capacity)).map((row) => {
-                        const sel = row.key === selectedKey;
-                        if (row.kind === 'session') {
-                            const s = row.session;
-                            const bound = bindings.get(s.sessionId);
-                            const rowNote = sessionNotes.get(s.sessionId);
-                            const noteShown = rowNote ? cut(rowNote, 24) : '';
-                            // `+3` = i due caporali e lo spazio che li separa dall'etichetta.
-                            // Il pavimento non è cosmetico: senza, un terminale stretto manda
-                            // l'argomento di `cut` sotto zero, cioè un budget negativo.
-                            // La nota si misura con `termWidth`, non con `.length`: contiene
-                            // testo umano, emoji compresi.
-                            const restWidth = Math.max(8, searchTitleWidth(columns) - (noteShown ? termWidth(noteShown) + 3 : 0));
-                            return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, pinned.has(s.sessionId) ? _jsx(Text, { color: "yellow", children: "\uD83D\uDCCC" }) : _jsx(Text, { dimColor: true, children: "\u25CB" }), ' ', _jsx(Text, { color: "cyan", children: s.sessionId.slice(0, 8) }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), bound ?? _jsx(Text, { dimColor: true, children: "spot" }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), noteShown ? _jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", noteShown, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(noteShown), children: cut(conversationLabel(s, projectCore, bound), restWidth) }), _jsxs(Text, { dimColor: true, children: ['  ', "(", row.hitCount, row.hidden > 0 ? `+${row.hidden}` : '', ") ", fmtDateTime(s.ts)] })] }, row.key));
-                        }
-                        const h = row.hit;
-                        return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: String(h.idx).padStart(4) }), ' ', _jsx(Text, { color: KIND_COLOR[h.kind], children: KIND_TAG[h.kind] }), ' ', cut(h.excerpt, searchExcerptWidth(columns))] }, row.key));
-                    })] }), preview ? _jsx(SearchPreviewPane, { p: preview }) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
-}
-/**
- * Anteprima dell'occorrenza selezionata, sotto la lista.
- *
- * Riempie le righe che la lista non usa: con pochi risultati il terminale
- * resterebbe vuoto per tre quarti, e il contesto attorno al match è proprio
- * ciò che serve per decidere se è l'occorrenza giusta. Nel caso comune evita
- * del tutto di aprire il reader.
- *
- * Si aggiorna navigando con le frecce, e la finestra è centrata sul match:
- * stessa `windowRange` della lista, stessa evidenziazione del reader
- * (`ReaderLine`) — nessuna primitiva nuova.
- */
-function SearchPreviewPane({ p }) {
-    const last = Math.min(p.total, p.from + p.lines.length);
-    const occ = [{ start: p.hit.matchStart, end: p.hit.matchEnd }];
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["record ", p.hit.idx, " \u00B7 ", KIND_LABEL[p.hit.kind], p.ts ? ` · ${fmtDateTime(p.ts)}` : '', " \u00B7 righe ", p.from + 1, "-", last, " di ", p.total, " \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " apre il reader"] }), p.lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, p.from + i)))] }));
-}
-/**
- * Reader fullscreen (T52 · D8).
- *
- * Mostra il messaggio INTERO che contiene l'occorrenza, aperto già posizionato
- * sul match e con il match evidenziato. È un `mode` a sé, catturato prima del
- * ramo `search`: il modale ricerca resta montato sotto e su `esc` si ritrova
- * con query, toggle e selezione intatti.
- */
-function ReaderScreen({ hit, lines, top, total, capacity, bound, }) {
-    const last = Math.min(total, top + capacity);
-    const occ = [{ start: hit.matchStart, end: hit.matchEnd }];
-    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: ["reader \u00B7 ", _jsx(Text, { color: "cyan", children: hit.sessionId.slice(0, 8) }), " \u00B7 record ", hit.idx, " \u00B7", ' ', KIND_LABEL[hit.kind], bound ? ` · ${bound}` : '', " \u00B7 righe ", total === 0 ? 0 : top + 1, "-", last, " di ", total] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g" }), " inizio \u00B7 ", _jsx(Text, { color: "yellow", children: "G" }), " fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " torna alla lista"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: lines.map((l, i) => (_jsx(ReaderLine, { line: l, occ: occ, current: 0 }, top + i))) })] }));
-}
-/** Una riga con le porzioni di match evidenziate. Gli offset sono quelli del
- *  testo sorgente, quindi un match a cavallo dell'a-capo si colora su entrambe
- *  le righe senza casi speciali — entrambe intersecano il suo intervallo.
- *
- *  Regge N occorrenze perché il detail (T91) ne mostra tutte quelle visibili; il
- *  reader (T52) ne passa una sola, che è il caso degenere dello stesso taglio. */
-function ReaderLine({ line, occ, current, }) {
-    const segs = sliceLine(line.text, line.start, occ, current);
-    if (segs.length === 0)
-        return _jsx(Text, { wrap: "truncate-end", children: line.text || ' ' });
-    return (_jsx(Text, { wrap: "truncate-end", children: segs.map((s, i) => s.hit ? (
-        // La corrente si distingue dalle altre per COLORE di sfondo, non per
-        // presenza: tutte restano visibili, o navigare fra occorrenze non
-        // mostrerebbe più dove sono le altre.
-        _jsx(Text, { backgroundColor: s.current ? 'cyan' : 'yellow', color: "black", children: s.text }, i)) : (_jsx(Text, { children: s.text }, i))) }));
-}
-/** Resa di ogni costrutto markdown (T75 · D4): un solo livello di enfasi per
- *  costrutto, senza un secondo alfabeto da imparare. Heading uguali a ogni
- *  livello — la gerarchia la porta già il testo. `code` e `fence` condividono
- *  il giallo perché sono lo stesso costrutto a due granularità: dargli due
- *  colori direbbe che sono due cose. */
-const MD_STYLE = {
-    heading: { bold: true, color: 'cyan' },
-    bold: { bold: true },
-    code: { color: 'yellow' },
-    fence: { color: 'yellow' },
-};
-/**
- * Una riga del detail (T75): markdown reso, con sopra l'evidenziazione della
- * ricerca.
- *
- * Due segmentazioni sulla stessa riga, annidate e non fuse: prima si taglia sui
- * costrutti markdown, poi ogni pezzo si ritaglia sulle occorrenze. L'ordine non
- * è indifferente — così un match a cavallo di un `**grassetto**` resta
- * evidenziato per intero e insieme conserva il grassetto sulla metà che ce
- * l'ha, cosa che una segmentazione unica dovrebbe risolvere decidendo chi vince.
- *
- * Gli offset di `occ` e di `spans` indicizzano ENTRAMBI il testo reso: è ciò
- * che permette di comporli senza rimappature. Vedi `sheetDoc` per il perché la
- * ricerca del detail ha smesso di scandire il sorgente.
- */
-function DetailLine({ line, spans, occ, current, }) {
-    const styled = sliceSpans(line, spans);
-    // Riga vuota → uno spazio: un `<Text>` senza contenuto Ink non lo disegna, e
-    // il testo si compatterebbe perdendo la struttura del file.
-    if (styled.length === 0)
-        return _jsx(Text, { wrap: "truncate-end", children: " " });
-    let off = line.start;
-    return (_jsx(Text, { wrap: "truncate-end", children: styled.map((seg, i) => {
-            const st = seg.kind ? MD_STYLE[seg.kind] : undefined;
-            const at = off;
-            off += seg.text.length;
-            // Senza ricerca aperta il secondo taglio non ha niente da tagliare, e
-            // saltarlo evita di allocare tre array per ogni riga a ogni freccia.
-            if (occ.length === 0) {
-                return (_jsx(Text, { bold: st?.bold, color: st?.color, children: seg.text }, i));
-            }
-            return (_jsx(Text, { bold: st?.bold, color: st?.color, children: sliceLine(seg.text, at, occ, current).map((p, j) => p.hit ? (_jsx(Text, { backgroundColor: p.current ? 'cyan' : 'yellow', color: "black", children: p.text }, j)) : (_jsx(Text, { children: p.text }, j))) }, i));
-        }) }));
-}
-/** Campo della ricerca nel detail: finestra ancorata al caret, cursore inverso
- *  sulla cella reale. Gemello di `EditTextField` senza la label, che qui sta
- *  fuori perché il campo vive in FLUSSO su una riga condivisa col contatore —
- *  non su una riga propria. */
-function DetailFindField({ value, caret, cols }) {
-    const win = caretWindow(value, caret, cols);
-    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: sanitize(win.head) }), _jsx(Text, { inverse: true, children: sanitize(win.at) }), _jsx(Text, { children: sanitize(win.tail) })] }));
-}
-/**
- * Detail della task (T66): il task file scrollabile più la barra azioni.
- *
- * Unisce due gesti che erano due schermate — leggere la task e agire su di essa
- * — perché convergono sullo stesso oggetto: si legge la Description proprio per
- * decidere QUALE azione lanciare, e con due overlay separati quella decisione
- * costava uscire dal viewer e ricordarsi la combo.
- *
- * Le azioni sono BOTTONI AFFIANCATI e non voci di un menu verticale: un
- * rettangolo ha già coordinate e area cliccabile, quindi il layout sopravvive
- * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione. La
- * navigazione da tastiera ci si sovrappone senza conflitti.
- */
-function DetailScreen({ id, title, missing, lines, spans, top, total, capacity, action, columns, find, occ, occCur, }) {
-    const last = Math.min(total, top + capacity);
-    // Il taglio lo fa il chiamante (invariante ③ di width.ts): la riga bottoni è
-    // ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso — ma
-    // la correttezza non deve dipendere dall'alfabeto che capita nella riga.
-    const width = Math.max(20, (columns || 80) - 4);
-    const segs = DETAIL_ACTIONS.map((a) => `[ ${a.label} ]`);
-    const parts = [];
-    segs.forEach((s, i) => {
-        if (i > 0)
-            parts.push('  ');
-        parts.push(s);
-    });
-    const dropped = (v) => segs.filter((s, i) => v[i * 2] !== s).length;
-    // Due passate: la seconda serve SOLO quando qualcosa cade, e riserva le
-    // colonne del contatore. Riservarle sempre costerebbe 6 colonne su ogni
-    // terminale largo per un avviso che lì non comparirà mai.
-    let shown = cutParts(parts, width);
-    if (dropped(shown) > 0)
-        shown = cutParts(parts, Math.max(0, width - 6));
-    const cutCount = dropped(shown);
-    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: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^F" }), " cerca \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] })), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: occ, current: occCur }, top + i)))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(DetailFindField, { value: find.q, caret: find.caret, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] }) })] }));
-}
-/**
- * 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] }));
-}
-/**
- * Header del pane task, tagliato QUI e non da Ink — stesso motivo del gemello
- * `SessionsHeader`, con una differenza di rischio: qui i segmenti sono tutti
- * ASCII più le frecce `↑↓` (larghe 1), quindi `cli-truncate` oggi darebbe la
- * riga giusta per caso. Il taglio resta del deck perché la correttezza non deve
- * dipendere dall'alfabeto che capita nella riga: il primo glifo largo 2 che
- * entrasse in un segmento nuovo riaprirebbe il difetto in silenzio, e a
- * scoprirlo sarebbe il bordo del pane a schermo.
- *
- * `truncate-end` taglia dalla coda, e `cutParts` conserva l'ordine: l'ultimo
- * segmento resta il primo a cedere il posto (`↑↓` in coda alle voci navigabili).
- *
- * T100 — la riga non è più informativa: le voci del catalogo sono SELEZIONABILI
- * con ←/→, e l'attiva si distingue in video inverso (D5 — costa 0 colonne e non
- * entra in gara con la semantica di colore già occupata). Le voci ci sono tutte
- * anche a 0 (D1): un catalogo che si accorcia sposta le voci sotto le dita.
- * L'ordine è vincolato — le navigabili PRIMA di `↑N`/`↓N`, che cadono per primi
- * su un terminale stretto — e la voce attiva ha la precedenza sul budget (D6).
- */
-function TasksHeader({ 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) }));
-}
-function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, childCount, focused, loadError, windowStart, above, below, columns, }) {
-    const allSelected = selected === ROW_ALL;
-    const spotSelected = selected === ROW_SPOT;
-    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(TasksHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
-                    (view.hiddenPri.length + view.hiddenProg.length > 0
-                        ? ' · filtri: ' +
-                            [
-                                ...PRI_ENTRIES.filter((e) => view.hiddenPri.includes(e.name)),
-                                ...PROG_ENTRIES.filter((e) => view.hiddenProg.includes(e.name)),
-                            ]
-                                .map((e) => `−${e.glyph}`)
-                                .join(' ')
-                        : '')), paneTextWidth(columns)) }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", allCount > 0 ? ` (${allCount})` : ''] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : paneCount === 0 ? (
-            // T100/D1 — una voce a contatore 0 resta navigabile, e selezionarla dà
-            // una lista vuota che DICE perché è vuota. Senza la nota il pane si
-            // legge come rotto: le righe meta restano, le task no, e niente spiega
-            // che è la vista scelta a non contenere nulla.
-            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(taskView(activeView).empty, paneTextWidth(columns)) })) : (tasks.map((task, i) => {
-                // windowStart riporta l'indice di finestra a quello della lista
-                // completa, su cui è keyata la selezione. +META_ROWS: le prime due
-                // righe sono le meta.
-                const sel = windowStart + i + META_ROWS === selected;
-                const n = childCount.get(task.id) ?? 0;
-                // Invariante ③: la descrizione è l'unico pezzo a lunghezza libera, e
-                // si taglia QUI sul budget che resta dopo le colonne fisse. Lasciarlo
-                // fare a `truncate-end` significa passare da `cli-truncate`, che
-                // restituisce una riga più larga del pane (una colonna per emoji) e
-                // quindi scrive sopra il bordo. Le parti fisse si misurano con
-                // `termWidth`: `task.id` è `T9` o `T52`, i due glifi valgono 2 ciascuno.
-                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, paneTextWidth(columns) - termWidth(head) - termWidth(tail)));
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, 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));
-            }))] }));
-}
-/**
- * Header del pane sessioni, tagliato QUI e non da Ink.
- *
- * `📌{pinnedCount}` è un glifo largo 2 in mezzo alla riga: con
- * `wrap="truncate-end"` il taglio passava da `cli-truncate`, che indicizza per
- * code point con un budget in colonne e restituiva una riga larga 45 su un
- * budget di 44 — la colonna in più finiva sopra il bordo destro del pane, che
- * spariva dalla riga (invariante ③ di `width.ts`).
- *
- * I segmenti restano segmenti fino al render: il taglio è della RIGA (budget
- * condiviso, `cutParts`), la resa è del pezzo. Il giallo su `📌N` distingue le
- * pinnate dal resto dell'header e non è decorazione.
- */
-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) }));
-}
-function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows, counts, activeView, paneCount, selectedId, focused, above, below, columns, forkOf, sessionNotes, projectCore, live, }) {
-    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(SessionsHeader, { parentLabel: parentLabel, counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), paneCount === 0 ? (
-            // T100 — la nota della vista di default resta quella storica, che nomina
-            // il PARENT (task, spot o tutte); le altre tre viste portano la propria,
-            // che nomina il sottoinsieme. Sono due vuoti diversi: «questo parent non
-            // ha conversazioni» e «questo sottoinsieme del parent è vuoto».
-            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(sessionView(activeView).empty ??
-                    (isAll
-                        ? 'nessuna conversazione nel progetto'
-                        : isSpot
-                            ? 'nessuna sessione libera'
-                            : 'nessuna sessione legata a questa task'), paneTextWidth(columns)) })) : (rows.map((row, i) => {
-                // T50 — separatore leggero fra pinnate e contestuali: riga dim, non un
-                // box pesante (coerente con lo styling delle Done dimmate).
-                if (row.kind === 'separator') {
-                    return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: SESSION_SEP }, `sep${i}`));
-                }
-                const sel = row.sessionId === selectedId;
-                // T50 — pin stale: transcript sparito, nessuna Session da mostrare.
-                // Riga navigabile e spinnabile (`p`), marcata, mai un crash.
-                if (row.kind === 'pinned' && row.stale) {
-                    // T60 — anche qui la nota si taglia sul budget DERIVATO, non su un
-                    // 30 inchiodato: su un pane stretto quel valore fisso mandava la
-                    // riga oltre il bordo, e a ripararla arrivava `cli-truncate` (che
-                    // sfora di una colonna per emoji e mangia il bordo stesso).
-                    const staleNote = sessionNotes.get(row.sessionId);
-                    // La riga stale è libera (niente colonne: non ha né titolo né
-                    // data), ma il binding va detto lo stesso — è una pinnata, quindi
-                    // l'header del pane non ne dice l'appartenenza.
-                    const staleTask = bindings.get(row.sessionId) ?? null;
-                    const staleW = Math.max(0, paneTextWidth(columns) -
-                        (2 /* caret */ +
-                            termWidth(`${WARN} pin stale `) +
-                            SID_CHARS +
-                            (staleTask ? termWidth(staleTask) + 1 : 0) +
-                            3 /* spazio + caporali */));
-                    return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: true, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { color: "yellow", children: WARN }), " pin stale", ' ', _jsx(Text, { dimColor: true, children: row.sessionId.slice(0, SID_CHARS) }), staleTask ? _jsxs(Text, { color: "green", children: [" ", staleTask] }) : null, staleNote ? _jsxs(Text, { color: "yellow", children: [" \u00AB", cut(staleNote, staleW), "\u00BB"] }) : null] }, row.sessionId));
-                }
-                const s = row.session; // non-stale → session presente
-                const isPinnedRow = row.kind === 'pinned';
-                // T28 — un ramo eredita il titolo dell'origine: senza marcatore le due
-                // righe sarebbero identiche a occhio.
-                const forked = forkOf.has(s.sessionId);
-                // T59 D2 — nella vista "tutte" il marker è PER-SESSIONE (binding letto
-                // dal sidecar) e non deciso dal parent: la lista mescola scoped e spot,
-                // quindi un marker uniforme mentirebbe su metà delle righe. E il solo
-                // glifo direbbe *che* la conversazione è legata senza dire *a cosa* —
-                // informazione monca proprio qui, l'unica vista dove l'appartenenza
-                // non è scritta da nessun'altra parte dello schermo: da qui la colonna
-                // task accanto, che esiste solo in questa vista.
-                const bound = bindings.get(s.sessionId) ?? null;
-                const linked = isAll ? Boolean(bound) : !isSpot;
-                // T62 — liveness e binding sono ORTOGONALI: la cella marker dice a chi
-                // appartiene la conversazione (pin/task/spot), questa dice se è aperta
-                // adesso. Farle condividere una cella perderebbe una delle due.
-                const liveEntry = live.get(s.sessionId);
-                // Stesso motivo per cui la colonna esiste: una pinnata resta in lista
-                // qualunque sia il parent selezionato, quindi l'header non ne dice
-                // l'appartenenza e la cella va riempita anche fuori dalla vista
-                // "tutte". Sulle contestuali, dove l'header parla già, resta vuota —
-                // ma la cella è comunque larga `taskW`, o le colonne a destra
-                // slitterebbero riga per riga.
-                const taskCell = isAll || isPinnedRow ? (bound ?? TASK_EMPTY) : '';
-                // T60 — colonne VERE: ogni cella fissa è larga esattamente quanto
-                // dichiara, riempita di spazi con `pad` (che misura in colonne, non in
-                // caratteri). Il marker va portato a 2 anche quando è `○`, largo 1:
-                // era lui a far slittare a sinistra di una colonna tutta la riga di
-                // ogni sessione spot.
-                const age = relTime(s.ts);
-                // Il taglio del titolo è ciò che RESTA, calcolato per sottrazione: le
-                // colonne fisse sono note, quindi l'unica cella elastica prende il
-                // resto. Pavimento `0` e non un minimo di cortesia — è un tetto, non
-                // una preferenza: alzarlo sopra lo spazio reale fa uscire la riga dal
-                // pane e le mangia il bordo (invariante ③).
-                const titleW = Math.max(0, paneTextWidth(columns) -
-                    (2 /* caret */ +
-                        2 /* marker */ +
-                        1 /* gutter */ +
-                        1 /* T62 · colonna liveness */ +
-                        SID_CHARS +
-                        1 /* gutter */ +
-                        (taskW > 0 ? taskW + 1 : 0) +
-                        1 /* gutter prima della data */ +
-                        ageW));
-                // T28 — `⑂` sta DENTRO la cella titolo, non in una colonna sua: una
-                // colonna dedicata costerebbe 2 spazi vuoti su ogni riga non-fork, e
-                // metterlo fuori cella sposterebbe il bordo del titolo solo sui rami —
-                // cioè rimetterebbe lo slittamento che le colonne tolgono.
-                const forkMark = forked ? '⑂ ' : '';
-                const inner = Math.max(0, titleW - termWidth(forkMark));
-                // T60 — il testo arriva già ripulito di ciò che le colonne accanto
-                // dicono già (progetto e task id): senza, la cella conterrebbe
-                // `🧵 loom-works · T59` accanto a una colonna che dice `T59`.
-                const label = rowLabel(sessionTitle(s, projectCore, bound), sessionNotes.get(s.sessionId), inner);
-                const used = (label.note ? termWidth(label.note) + 2 : 0) +
-                    (label.note && label.rest ? 1 : 0) +
-                    termWidth(label.rest);
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: pad('📌', 2) })) : linked ? (_jsx(Text, { color: "green", children: pad('🔗', 2) })) : (_jsx(Text, { dimColor: true, children: pad('○', 2) })), ' ', _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : undefined, children: liveEntry ? (liveEntry.status === 'busy' ? LIVE_BUSY : LIVE_IDLE) : LIVE_NONE }), _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : 'cyan', bold: Boolean(liveEntry), children: s.sessionId.slice(0, SID_CHARS) }), ' ', taskW > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: bound && taskCell ? 'green' : undefined, dimColor: !bound, children: pad(taskCell, taskW) }), ' '] })) : null, forkMark ? _jsx(Text, { color: "magenta", children: forkMark }) : null, label.note ? (_jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", label.note, "\u00BB"] })) : null, label.note && label.rest ? ' ' : null, label.rest ? _jsx(Text, { dimColor: Boolean(label.note), children: label.rest }) : null, ' '.repeat(Math.max(0, inner - used)), ' ', _jsx(Text, { dimColor: true, children: pad(age, ageW, 'right') })] }, s.sessionId));
-            }))] }));
-}
-function PreviewPane(p) {
-    return (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: p.kind === 'task' ? (_jsx(TaskPreview, { detail: p.detail, maxLines: p.maxLines, columns: p.columns })) : (_jsx(SessionPreview, { s: p.s, firstLines: p.firstLines, lastLines: p.lastLines, columns: p.columns, origin: p.origin, note: p.note, live: p.live })) }));
-}
-// T49 — corpo della preview sessione. Tutti i campi vengono dal parse già
-// cached dell'adapter (mtime-keyed): non costa I/O al movimento di selezione.
-// Mostra "da dove parte, dove è arrivata": il primo prompt utente (`» `) e
-// l'ultima risposta del modello (`« `). L'anteprima del primo prompt compare
-// SOLO con un titolo custom — senza, il titolo È già il primo prompt e la riga
-// lo duplicherebbe (D4 preflight). Le righe rese non superano mai il riservato
-// dal budget (`firstLines`/`lastLines`); renderne meno è sicuro (frame più corto).
-function SessionPreview({ s, firstLines, lastLines, columns, origin, note, live, }) {
-    const width = previewTextWidth(columns);
-    const first = s.customTitle && firstLines > 0 ? wrapLines(s.firstPrompt, width, firstLines) : [];
-    const last = s.lastReply && lastLines > 0 ? wrapLines(s.lastReply, width, lastLines) : [];
-    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', note ? _jsxs(Text, { color: "yellow", children: ["\u00AB", note, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : '', live ? (_jsx(Text, { color: live.status === 'busy' ? 'yellow' : 'green', children: ` · ${live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE} viva pid ${live.pid} (${live.status})` })) : null] }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
-}
-/**
- * Righe non-wrappabili del dettaglio (titolo + meta + commit) e loro conteggio.
- * Estratto dal componente perché il budget deve saperlo PRIMA di renderizzare:
- * sono righe fisse che tolgono spazio alla descrizione.
- */
-function detailMetaOf(detail) {
-    const meta = META_KEYS.map((k) => detail.fields[k])
-        .filter(Boolean)
-        .join('  ·  ');
-    const commit = detail.fields['Last tracked commit'] ?? '';
-    return { meta, commit, metaLines: 1 + (meta ? 1 : 0) + (commit ? 1 : 0) };
-}
-/**
- * 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.
- */
-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.
- */
-function paneTextWidth(columns) {
-    return Math.max(20, Math.floor(((columns || 80) - 4) / 2) - 4);
-}
-/** Corpo della preview task: titolo, meta, descrizione wrappata, commit. */
-function TaskPreview({ detail, maxLines, columns, }) {
-    const { meta, commit } = detailMetaOf(detail);
-    // Wrap calcolato qui, non delegato a `<Text wrap="wrap">`: il budget ha
-    // riservato ESATTAMENTE `maxLines` righe, e un wrap deciso da Ink a runtime
-    // ne produrrebbe un numero che il budget non conosce — cioè il frame torna a
-    // sforare e il bug si riapre da questa singola casella di testo.
-    const lines = wrapLines(detail.description ?? '', previewTextWidth(columns), maxLines);
-    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: detail.title || detail.id }), meta ? _jsx(Text, { dimColor: true, wrap: "truncate-end", children: meta }) : null, lines.map((line, i) => (_jsx(Text, { wrap: "truncate-end", children: line }, i))), commit ? _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", commit] }) : null] }));
-}
 const cwd = process.cwd();
 render(_jsx(Deck, { cwd: cwd, tasksPath: resolveTasksPath(cwd), tasksDir: resolveTasksDir(cwd) }));