@lamemind/loom-deck 0.56.1 → 0.57.0

package/dist/hooks.js

@@ -2,7 +2,7 @@
 // che sta fuori — dimensioni del terminale, tasks.md, sessioni del progetto,
 // task archiviabili, task file selezionato. Ognuno possiede la propria cadenza
 // di refresh e non sa nulla della vista che li consuma.
-import { useState, useEffect, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useStdout } from 'ink';
 import { statSync } from 'node:fs';
 import { loadTasks, loadTaskDetail } from './tasks.js';
@@ -10,6 +10,8 @@ import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { loadSessionIndex } from './task-index.js';
 import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
+import { scanInbox } from './inbox.js';
+import { mixedCount, readWrapCache, runWrapScan, wrapCacheFile, wrapCount, } from './wrap-scan.js';
 import { purgeTargets } from './purge.js';
 import { POLL_MS } from './model.js';
 // Dimensioni del terminale, live sul resize.
@@ -216,6 +218,75 @@ export function useDirtyFolders(idsSig, tasksDir, projectRoot) {
     }, [idsSig, tasksDir, projectRoot]);
     return dirty;
 }
+export function useInboxScan(projectRoot, docsRoot) {
+    const [state, setState] = useState({ files: [], ok: true, scanned: false });
+    useEffect(() => {
+        let alive = true;
+        const scan = () => {
+            scanInbox(projectRoot, docsRoot).then((res) => {
+                if (!alive)
+                    return;
+                // Un tentativo fallito NON butta via l'esito dell'ultimo riuscito: la
+                // lista precedente resta vera e ancora apribile, e il guasto si dice
+                // col glifo di allerta accanto ai contatori. È la stessa regola già
+                // scritta per il project status (`finish` non riscrive la cache).
+                setState((prev) => res.ok ? { files: res.files, ok: true, scanned: true } : { ...prev, ok: false, scanned: true });
+            });
+        };
+        scan();
+        const id = setInterval(scan, SCAN_INTERVAL_MS);
+        return () => {
+            alive = false;
+            clearInterval(id);
+        };
+    }, [projectRoot, docsRoot]);
+    return state;
+}
+export function useWrapScan(projectRoot) {
+    const path = useMemo(() => wrapCacheFile(projectRoot), [projectRoot]);
+    const [cache, setCache] = useState(() => readWrapCache(path));
+    const [ok, setOk] = useState(true);
+    const [scanning, setScanning] = useState(false);
+    const [epoch, setEpoch] = useState(0);
+    // Il flag di corsa sta in un ref e non in stato: il ramo che lo legge gira
+    // NELLO STESSO tasto in cui potrebbe averlo scritto, e un valore di stato
+    // React arriverebbe al render dopo — cioè troppo tardi per impedire il
+    // secondo lancio.
+    const busy = useRef(false);
+    const run = useCallback(() => {
+        if (busy.current)
+            return;
+        busy.current = true;
+        setScanning(true);
+        runWrapScan(projectRoot).then((good) => {
+            busy.current = false;
+            setScanning(false);
+            setOk(good);
+            // La cache si rilegge SOLO su successo: un tentativo fallito lascia in
+            // piedi l'esito dell'ultimo riuscito, che resta vero e ancora apribile.
+            if (good)
+                setCache(readWrapCache(path));
+        });
+    }, [projectRoot, path]);
+    useEffect(() => {
+        const id = setInterval(run, SCAN_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, [run, epoch]);
+    const scan = useCallback(() => {
+        setEpoch((e) => e + 1);
+        run();
+    }, [run]);
+    const files = cache?.files ?? [];
+    return {
+        files,
+        count: wrapCount(files),
+        mixed: mixedCount(files),
+        mtime: cache?.mtime ?? null,
+        ok,
+        scanning,
+        scan,
+    };
+}
 // 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

package/dist/inbox-views.js

@@ -0,0 +1,67 @@
+// T134 — Catalogo delle viste del pane inbox.
+//
+// Gemello di `pane-views.ts` per forma e invarianti, MODULO SEPARATO per il
+// tipo: `SessionViewEntry.rows()` è tipizzata su `SessionRow[]` e ogni azione
+// del pane destro (`p` pin, `N` nota, `A` riassegna, resume, fork) è scritta
+// per una conversazione. Infilare una vista inbox in quel catalogo
+// obbligherebbe a un'unione discriminata e a rendere inerte ogni azione sulla
+// riga sbagliata (D6); con due cataloghi i tipi restano disgiunti per
+// costruzione.
+//
+// Modulo PURO: nessun import da ink/react, nessun I/O. Il calcolo dei conteggi
+// resta in `inbox.ts`, qui c'è solo la mappa di quali sottoinsiemi esistono,
+// come si chiamano e con che numero.
+//
+// Invarianti ereditate dal catalogo dei due pane storici:
+//  - catalogo FISSO: le voci ci sono tutte anche a contatore 0, o navigando si
+//    spostano sotto le dita;
+//  - navigazione CICLICA con `tab`;
+//  - il numero di una voce coincide col numero di righe che la voce mostra —
+//    un header che dice un numero e una lista che ne mostra un altro è un
+//    contatore che mente, e non c'è schermata che lo dica.
+import { NATURE, countByNatura, isQueued } from './inbox.js';
+/** La somma dei tre contatori: quanto lavoro una skill può prendere da sola. */
+export function queuedTotal(c) {
+    return c.nozioni + c.derivazione + c.sweep;
+}
+/** I contatori dell'header E del bottone di pane, da una fonte sola: i tre
+ *  numeri che il bottone mostra sono gli stessi che dimensionano le tre viste
+ *  di natura, quindi non possono dire cose diverse. */
+export function inboxCounts(files) {
+    return { total: files.length, ...countByNatura(files) };
+}
+const NATURA_VIEWS = NATURE.map((natura) => ({
+    id: natura,
+    label: (c) => `${natura} (${c[natura]})`,
+    count: (c) => c[natura],
+    dim: (c) => c[natura] === 0,
+    rows: (files) => files.filter((f) => isQueued(f) && f.natura === natura),
+    empty: `nessun file ${natura} in coda`,
+}));
+export const INBOX_VIEWS = [
+    {
+        id: 'all',
+        label: (c) => `Tutti (${c.total})`,
+        count: (c) => c.total,
+        dim: (c) => queuedTotal(c) === 0,
+        // Nessun filtro: `parseInboxTsv` consegna già l'ordine per età decrescente
+        // (D8 — i più vecchi in cima sono i più urgenti).
+        rows: (files) => [...files],
+        empty: 'inbox vuota: nessun file da collocare',
+    },
+    ...NATURA_VIEWS,
+];
+export function inboxView(id) {
+    return INBOX_VIEWS.find((v) => v.id === id) ?? INBOX_VIEWS[0];
+}
+export function selectInboxRows(id, files) {
+    return inboxView(id).rows(files);
+}
+/** Scorrimento ciclico, come i due cataloghi storici: `→` sull'ultima voce
+ *  torna alla prima. Id ignoto → prima voce, mai un indice negativo. */
+export function cycleInboxView(current, delta) {
+    const at = INBOX_VIEWS.findIndex((v) => v.id === current);
+    if (at < 0)
+        return INBOX_VIEWS[0].id;
+    return INBOX_VIEWS[(at + delta + INBOX_VIEWS.length) % INBOX_VIEWS.length].id;
+}

package/dist/inbox.js

@@ -10,8 +10,9 @@
 // Lettore puro + spawn: nessun React, nessuna resa. È l'unico modo di provarlo
 // senza pseudo-terminale.
 import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { promisify } from 'node:util';
-import { basename } from 'node:path';
+import { basename, join } from 'node:path';
 import { pluginScript } from './plugin-cache.js';
 const execFileAsync = promisify(execFile);
 export const INBOX_METRICS_SCRIPT = 'scripts/docs/doc-metrics.sh';
@@ -87,6 +88,32 @@ export function ageHours(created, now) {
 export function isQueued(f) {
     return f.drainable && !f.branch && f.natura !== 'malformato';
 }
+/**
+ * Abbreviazione a larghezza fissa della natura, per la colonna della riga.
+ *
+ * CHIESTE e non derivate con uno `slice(0,3)`, come le short dei modelli:
+ * `der` e `swp` non coincidono col troncamento (`der`/`swe`), e una regola che
+ * sbaglia su due voci su quattro non è una regola.
+ */
+export const NATURA_SHORT = {
+    nozioni: 'noz',
+    derivazione: 'der',
+    sweep: 'swp',
+    malformato: '???',
+};
+/** Larghezza COSTANTE della colonna natura: il dominio è chiuso e le short
+ *  sono tutte larghe 3, quindi misurarla a ogni render calcolerebbe un numero
+ *  già noto. */
+export const NATURA_W = 3;
+export function inboxMark(f) {
+    if (f.natura === 'malformato')
+        return 'broken';
+    if (f.branch)
+        return 'branched';
+    if (!f.drainable)
+        return 'held';
+    return 'queued';
+}
 /**
  * Un contatore per natura, sui soli file in coda. Un `malformato` non ha natura
  * e non entra in nessuno dei tre — ma resta in lista, perché nasconderlo
@@ -112,6 +139,61 @@ export const DEFAULT_INBOX_STALE_HOURS = 48;
 export function staleCount(files, hours, now) {
     return files.filter((f) => isQueued(f) && ageHours(f.created, now) >= hours).length;
 }
+/**
+ * La skill che consuma ogni natura (D8). Il file viaggia come BASENAME e non
+ * come path: la grammatica di matching è identica per le tre — path completo,
+ * basename con o senza `.md`, case-insensitive contro `{docs_root}/inbox/` —
+ * quindi il deck non deve conoscere il path, e non lo compone.
+ */
+const DRAIN_SKILL = {
+    nozioni: 'drain-notions',
+    derivazione: 'derive-notions',
+    sweep: 'align-doc',
+};
+/**
+ * Il prompt della sessione che il deck apre su un file inbox.
+ *
+ * Su un `malformato` NON è un drain ma una RIPARAZIONE: nessuna delle tre skill
+ * prende un file senza natura, quindi offrirgliene una significherebbe aprire
+ * una sessione destinata a fermarsi allo step 0.
+ *
+ * Nessuna guardia sul token `drainable` né sul branch (D5): le tre skill
+ * dichiarano tutte, con le stesse parole, che un file NOMINATO si esegue anche
+ * senza `drainable` — quel token governa la coda automatica del notturno, non
+ * il permesso di eseguire, e nominare un file È la decisione che il token
+ * dichiarerebbe. Il solo `branch:` lo rifiutano loro, e lo fanno per chiunque:
+ * replicarlo qui aggiungerebbe una seconda copia divergibile per impedire ciò
+ * che l'utente ha appena chiesto.
+ *
+ * Niente backtick nel testo: il prompt attraversa `--prompt` come argv singolo
+ * e poi `bash -lc` dentro `deck-run`, dove viene quotato ad apici singoli. Con
+ * quel quoting un backtick sarebbe inerte, ma il testo lo si legge anche in
+ * riga di stato e in un titolo di tab — un carattere che non serve non si
+ * spende.
+ */
+export function inboxPrompt(f) {
+    if (f.natura === 'malformato') {
+        return (`il file inbox ${f.basename} non ha un marker leggibile: nessuna delle tre skill di drain ` +
+            'lo prende. aprilo, stabilisci di che natura e (nozioni, derivazione o sweep) e riporta il ' +
+            'marker alla grammatica di scripts/docs/inbox.sh del plugin. non drenare niente finche il ' +
+            'marker non e valido.');
+    }
+    return `/loom-works:${DRAIN_SKILL[f.natura]} ${f.basename}`;
+}
+/**
+ * Il testo del file inbox, per il detail fullscreen. `null` = illeggibile —
+ * il detail lo dice e tiene l'azione attiva, come fa quello della task con un
+ * task file mancante: la skill risolve il file per nome, non per il testo che
+ * il deck è riuscito a leggere.
+ */
+export function loadInboxText(projectRoot, relPath) {
+    try {
+        return readFileSync(join(projectRoot, relPath), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Invoca la misura e ne parsa l'output.
  *

package/dist/input-modes.js

@@ -24,6 +24,8 @@
 export const CAPTURING_MODES = [
     'detail',
     'status',
+    'inbox',
+    'wrap',
     'reader',
     'search',
     'assign',
@@ -71,7 +73,7 @@ export const CTRL_DEROGATIONS = {
  * Il custode è `MODE_WHEEL` in `input.ts`, un `Record<ScrollingMode, …>` che non
  * compila se un modo entra qui senza uno scroll da chiamare.
  */
-export const SCROLLING_MODES = ['detail', 'status', 'reader'];
+export const SCROLLING_MODES = ['detail', 'status', 'inbox', 'wrap', 'reader'];
 const SCROLLING = new Set(SCROLLING_MODES);
 /** `true` se la rotella scorre il contenuto del modo. */
 export function scrolls(mode) {

package/dist/input.js

@@ -20,12 +20,13 @@
 import { useEffect, useRef } from 'react';
 import { useApp, useInput } from 'ink';
 import { hitRegion, isWheel, listHit, takeMouse, wheelDir, WHEEL_LINES, } from './mouse.js';
-import { LAUNCH_ROW } from './frame.js';
+import { HINT_ROW, LAUNCH_ROW } from './frame.js';
 import { moveSelection } from './session-list.js';
 import { captures, scrolls } from './input-modes.js';
 import { META_ROWS, QUIT_WINDOW_MS } from './model.js';
 import { TASK_VIEWS, taskView } from './pane-views.js';
 import { loadTaskFileText } from './tasks.js';
+import { loadInboxText } from './inbox.js';
 // T116 — l'avviso della prima pressione di `^C`. La durata è INTERPOLATA dalla
 // finestra, non ricopiata: un numero scritto a mano in un testo che promette un
 // comportamento diventa falso il giorno che la costante cambia, e nessuno
@@ -52,7 +53,7 @@ export const NO_MODIFIERS = {
     delete: false,
     meta: false,
 };
-export function useDeckInput({ tasksDir, mode, setMode, setNote, model, actions, overlays, frame, launchRegions, }) {
+export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, actions, overlays, frame, launchRegions, indicatorRegions, }) {
     // T116 — uscita a doppio `^C`. Il timer È lo stato dell'armamento: finché il
     // handle esiste la finestra è aperta, e non serve un secondo stato da tenere
     // in fase con lui. In un `useRef` e non in `useState` perché il ramo di uscita
@@ -76,6 +77,8 @@ export function useDeckInput({ tasksDir, mode, setMode, setNote, model, actions,
     const MODE_KEYS = {
         detail: overlays.sheet.onKey,
         status: overlays.status.onKey,
+        inbox: overlays.inbox.onKey,
+        wrap: overlays.wrap.onKey,
         reader: overlays.search.onReaderKey,
         search: overlays.search.onSearchKey,
         assign: overlays.assign.onKey,
@@ -93,6 +96,8 @@ export function useDeckInput({ tasksDir, mode, setMode, setNote, model, actions,
     const MODE_WHEEL = {
         detail: overlays.sheet.scroll,
         status: overlays.status.scroll,
+        inbox: overlays.inbox.scroll,
+        wrap: overlays.wrap.scroll,
         reader: overlays.search.scrollReader,
     };
     /**
@@ -167,6 +172,15 @@ export function useDeckInput({ tasksDir, mode, setMode, setNote, model, actions,
                 onKey(hit, NO_MODIFIERS);
             return;
         }
+        if (ev.row === HINT_ROW) {
+            // T134 — stessa porta, con i modificatori: gli indicatori rappresentano
+            // combo `ctrl`, e una chiave nuda le farebbe cadere nel ramo delle lettere
+            // (`b` non è legata a niente oggi, ma `w` salva la vista).
+            const hit = hitRegion(indicatorRegions, ev.col);
+            if (hit)
+                onKey(hit.slice(1), { ...NO_MODIFIERS, ctrl: true });
+            return;
+        }
         onListClick(ev);
     }
     /**
@@ -195,10 +209,24 @@ export function useDeckInput({ tasksDir, mode, setMode, setNote, model, actions,
             model.setFocus(hit.pane);
             if (hit.pane === 'tasks')
                 model.selectTaskView(hit.key);
+            else if (hit.pane === 'inbox')
+                model.selectInboxView(hit.key);
             else
                 model.selectSessionView(hit.key);
             return;
         }
+        if (hit.pane === 'inbox') {
+            const f = frame.windowInbox[hit.index];
+            if (!f)
+                return;
+            if (model.focus === 'inbox' && f.path === model.selInboxPath) {
+                onKey('', { ...NO_MODIFIERS, return: true });
+                return;
+            }
+            model.setFocus('inbox');
+            model.selectInboxRow(frame.inboxWin.start + hit.index);
+            return;
+        }
         if (hit.pane === 'tasks') {
             // Le due righe meta hanno indice fisso; le task riportano l'indice di
             // finestra a quello della lista completa, su cui è keyata la selezione.
@@ -274,6 +302,33 @@ export function useDeckInput({ tasksDir, mode, setMode, setNote, model, actions,
             else if (input === 'o') {
                 overlays.status.open();
             }
+            else if (input === 'w') {
+                // T134/D8 preflight — `^W` APRE la lista, `^E` ESEGUE lo scan: generare
+                // e aprire restano due tasti distinti per la stessa ragione di `^G`/`^O`
+                // — aprire un dato vecchio deve costare zero, e generare non deve essere
+                // un effetto collaterale del guardare. Qui la posta è più alta che sul
+                // project status: lo scan cammina l'albero del progetto intero,
+                // submodule compresi.
+                //
+                // `^S` sarebbe la mnemonica migliore per «scan» ed è scartata di
+                // proposito: nel repo esistono due commenti in contraddizione sul suo
+                // conto (`model.ts` dice che il raw mode di Ink disattiva il
+                // flow-control XON/XOFF e quindi passa pulito, `cli.tsx` dice che è
+                // stato evitato proprio perché il terminale lo intercetta). Finché la
+                // contraddizione non è risolta con una misura, un tasto nuovo non ci si
+                // appoggia.
+                overlays.wrap.open();
+            }
+            else if (input === 'e') {
+                overlays.wrap.scan();
+            }
+            else if (input === 'b') {
+                // T134/D8 preflight — `^B` (box/bacheca) scambia i due pane dello slot
+                // destro. Non è un modale né una schermata: il pane resta uno dei due
+                // riquadri della vista normale, quindi `tab` continua a ciclare le
+                // viste DENTRO quello montato e `←→` a spostare il focus fra le colonne.
+                model.toggleInboxPane();
+            }
             return;
         }
         if (key.tab) {
@@ -287,27 +342,51 @@ export function useDeckInput({ tasksDir, mode, setMode, setNote, model, actions,
             // voci risparmia quattro pressioni.
             model.cycleView(key.shift ? -1 : 1);
         }
+        else if (key.escape) {
+            // T134/D8 preflight — `esc` in vista normale chiude il pane inbox e torna
+            // alle sessioni. Resta inerte quando le sessioni sono già montate: `esc`
+            // dice «esci da dove sei», e da lì non c'è niente da cui uscire.
+            model.closeInboxPane();
+        }
         else if (key.leftArrow || key.rightArrow) {
             // Binding ASSOLUTO, non toggle: `←` porta sempre sui task e `→` sempre
-            // sulle sessioni, quindi ripremere lo stesso tasto non riporta indietro.
+            // sul pane DESTRO, 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.
-            model.setFocus(key.leftArrow ? 'tasks' : 'sessions');
+            // con due colonne un toggle sarebbe indistinguibile solo per caso.
+            // T134 — «destro» è il pane montato, non `sessions`: il tasto nomina una
+            // posizione, e quale dei due la occupi è un'altra decisione (`^B`).
+            model.setFocus(key.leftArrow ? 'tasks' : model.rightPane);
         }
         else if (key.upArrow) {
             if (model.focus === 'tasks')
                 model.moveTaskSel(-1);
+            else if (model.focus === 'inbox')
+                model.moveInboxSel(-1);
             else
                 model.setSelSessionId((id) => moveSelection(model.sessionRows, id, -1));
         }
         else if (key.downArrow) {
             if (model.focus === 'tasks')
                 model.moveTaskSel(1);
+            else if (model.focus === 'inbox')
+                model.moveInboxSel(1);
             else
                 model.setSelSessionId((id) => moveSelection(model.sessionRows, id, 1));
         }
         else if (key.return) {
-            if (model.focus === 'tasks') {
+            if (model.focus === 'inbox') {
+                // T134 — `⏎` apre il DETAIL del file, non la sessione: la sessione la
+                // apre il `⏎` di dentro. Stessa scala del pane task, dove `⏎` apre il
+                // detail e le combo restano per chi sa già cosa vuole — con la
+                // differenza che qui non esiste un acceleratore, perché la skill non è
+                // una scelta ma una conseguenza della natura del file.
+                const f = model.selInbox;
+                if (!f)
+                    setNote('nessun file inbox selezionato');
+                else
+                    overlays.inbox.open({ file: f, text: loadInboxText(cwd, f.path) });
+            }
+            else if (model.focus === 'tasks') {
                 // T66 — ⏎ apre il DETAIL, non più una sessione. Secondo rimappaggio in
                 // due task (T56 lo spostò da recap a sessione a mani nude), e la
                 // direzione è una sola: da azione singola a punto d'ingresso. Il tasto

package/dist/mouse.js

@@ -196,6 +196,16 @@ export function hitRegion(regions, col) {
  * dipende da quanto è popolato il progetto.
  */
 export const LAUNCH_ROW = 4;
+/**
+ * T134 — riga della legenda tasti, che ospita anche gli INDICATORI ancorati a
+ * destra (bottone inbox, contatore hard-wrap). Sta subito sopra la riga launch,
+ * e come lei è incondizionata: bordo superiore, testata, legenda.
+ *
+ * Gli indicatori sono cliccabili, quindi questa riga entra nell'hit-test come la
+ * launch — e come lei il click NON chiama l'azione: rientra dalla porta della
+ * tastiera con la combo che l'indicatore rappresenta.
+ */
+export const HINT_ROW = LAUNCH_ROW - 1;
 /** Colonna (1-based) del primo carattere di testo dentro il box esterno:
  *  bordo + `paddingX={1}`. */
 export const FRAME_TEXT_COL = 3;
@@ -268,16 +278,18 @@ export function inlineRegions(parts, startCol) {
 export function listHit(ev, g) {
     const spans = paneSpans(g.columns);
     const inTasks = ev.col >= spans.tasks.start && ev.col <= spans.tasks.end;
-    const inSessions = ev.col >= spans.sessions.start && ev.col <= spans.sessions.end;
-    if (!inTasks && !inSessions)
+    const inRight = ev.col >= spans.sessions.start && ev.col <= spans.sessions.end;
+    if (!inTasks && !inRight)
         return null;
-    const pane = inTasks ? 'tasks' : 'sessions';
+    const isInbox = g.rightPane === 'inbox';
+    const pane = inTasks ? 'tasks' : isInbox ? 'inbox' : 'sessions';
+    const rightHeader = isInbox ? g.inboxHeader : g.sessionHeader;
     if (ev.row === PANE_HEADER_ROW) {
-        const key = hitRegion(inTasks ? g.taskHeader : g.sessionHeader, ev.col);
+        const key = hitRegion(inTasks ? g.taskHeader : rightHeader, ev.col);
         return key ? { pane, target: 'view', key } : null;
     }
     const first = inTasks ? TASK_LIST_ROW : PANE_BODY_ROW;
-    const count = inTasks ? g.taskRows : g.sessionRows;
+    const count = inTasks ? g.taskRows : isInbox ? g.inboxRows : g.sessionRows;
     const index = ev.row - first;
     if (index < 0 || index >= count)
         return null;

package/dist/overlays/inbox.js

@@ -0,0 +1,90 @@
+// T134 — il DETAIL di un file inbox: sesta schermata sostitutiva.
+//
+// Stessa forma dello `sheet` della task e per la stessa ragione: il file è
+// FOTOGRAFATO all'apertura — nome, natura, testo — e non è una vista sulla
+// selezione corrente. L'overlay copre la lista, quindi l'oggetto dell'azione
+// deve restare quello che si è scelto anche se un tick dello scan spostasse la
+// selezione sotto.
+//
+// Molto più magro dello sheet: nessuna area di compilazione. Lo sheet ha
+// quattro righe perché quattro parametri dello spawn sono una scelta (azione,
+// prompt, modello, titolo); qui non ce n'è nessuna — la skill la decide la
+// natura (D8), il modello è `opus` per tutte e tre (D11 preflight), la sessione
+// nasce nuda (D10 preflight). Restano la lettura e un tasto.
+//
+// Lo spawn NON sta qui: arriva come callback `onDrain`, per lo stesso confine
+// di `useSheetOverlay` e `useSearchOverlay` — un hook di overlay non esce dal
+// deck.
+import { useMemo, useState } from 'react';
+import { inboxDetailCapacity, pageStep } from '../viewport.js';
+import { wrapWithOffsets } from '../width.js';
+import { parseMarkdown } from '../markdown.js';
+import { inboxPrompt } from '../inbox.js';
+export function useInboxOverlay(deps) {
+    const { rows, columns, setMode, setNote, onDrain } = deps;
+    const [sheet, setSheet] = useState(null);
+    const [top, setTop] = useState(0);
+    // Cornici da scalare: box esterno (2 bordi + 2 padding) + box testo (2 bordi
+    // + 2 padding) = 8, come il detail della task.
+    const width = Math.max(20, (columns || 80) - 8);
+    // Il markdown si rende PRIMA del wrap: `**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, non ri-parsa.
+    const doc = useMemo(() => (sheet?.text ? parseMarkdown(sheet.text) : null), [sheet]);
+    const lines = useMemo(() => (doc ? wrapWithOffsets(doc.text, width) : []), [doc, width]);
+    const capacity = inboxDetailCapacity(rows);
+    const maxTop = Math.max(0, lines.length - capacity);
+    /** Il prompt che partirà: derivato una volta e mostrato in fondo alla
+     *  schermata, così `⏎` non è mai un salto nel buio. */
+    const prompt = sheet ? inboxPrompt(sheet.file) : '';
+    function open(next) {
+        setSheet(next);
+        setTop(0);
+        setNote('');
+        setMode('inbox');
+    }
+    function close() {
+        setMode('normal');
+        setSheet(null);
+    }
+    function scroll(delta) {
+        setTop((t) => Math.max(0, Math.min(maxTop, t + delta)));
+    }
+    function onKey(input, key) {
+        if (key.escape) {
+            close();
+        }
+        else if (key.return) {
+            // Si chiude PRIMA di spawnare, come lo sheet della task: la schermata ha
+            // finito il suo lavoro, e lasciarla aperta sopra una tab appena nata
+            // farebbe credere che ci sia dell'altro da decidere.
+            const s = sheet;
+            close();
+            if (s)
+                onDrain(s.file, inboxPrompt(s.file));
+        }
+        else if (key.upArrow) {
+            scroll(-1);
+        }
+        else if (key.downArrow) {
+            scroll(1);
+        }
+        else if (key.pageUp) {
+            scroll(-pageStep(capacity));
+        }
+        else if (key.pageDown) {
+            scroll(pageStep(capacity));
+        }
+        else if (input === 'g') {
+            // `g`/`G` sugli estremi, come reader, detail e project status: anche
+            // questa schermata scorre testo, quindi eredita lo stesso alfabeto invece
+            // di inventarne un secondo.
+            setTop(0);
+        }
+        else if (input === 'G') {
+            setTop(maxTop);
+        }
+    }
+    return { sheet, doc, lines, top, capacity, maxTop, prompt, open, onKey, scroll };
+}