@lamemind/loom-deck 0.69.0 → 0.71.0

package/dist/overlays/file-sheet.js

@@ -0,0 +1,101 @@
+// Il DETAIL di un file: testo scorrevole più la riga che dichiara cosa partirà
+// su `⏎`.
+//
+// T134 nasce come `useInboxOverlay`, un hook per la sola coda inbox. T160/P11 lo
+// rende PARAMETRICO su cosa sta guardando, e lo instanzia due volte: una per il
+// file inbox, una per il bersaglio doc (file o cartella). Le due istanze restano
+// due voci distinte nei tre cataloghi dei modi (`CAPTURING_MODES`,
+// `SCROLLING_MODES`, `MODAL_HEIGHT`), perché sono due schermate diverse anche se
+// condividono la meccanica: `esc` da una torna al pane inbox, dall'altra al pane
+// doc, e un modo solo per entrambe obbligherebbe a ricordare da dove si era
+// entrati.
+//
+// Cosa è parametrico e cosa no. Parametrico: l'OGGETTO fotografato (`T`), il
+// testo, il prompt e la callback. Non parametrico: lo scorrimento, la capienza,
+// la chiusura prima dello spawn — cioè tutto ciò che è la meccanica dello sheet,
+// ed è la parte che non aveva senso duplicare.
+//
+// L'oggetto è FOTOGRAFATO all'apertura e non è una vista sulla selezione
+// corrente: l'overlay copre la lista, quindi il bersaglio dell'azione deve
+// restare quello che si è scelto anche se un tick dello scan spostasse la
+// selezione sotto.
+//
+// Lo spawn NON sta qui: arriva come callback, per lo stesso confine di
+// `useSheetOverlay` e `useSearchOverlay` — un hook di overlay non esce dal deck.
+import { useMemo, useState } from 'react';
+import { fileSheetCapacity, pageStep } from '../viewport.js';
+import { wrapWithOffsets } from '../width.js';
+import { parseMarkdown } from '../markdown.js';
+export function useFileSheet(deps) {
+    const { mode, rows, columns, setMode, setNote, onEnter } = 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 = fileSheetCapacity(rows);
+    const maxTop = Math.max(0, lines.length - capacity);
+    const prompt = sheet?.prompt ?? '';
+    const hint = sheet?.hint ?? '';
+    function open(next) {
+        setSheet(next);
+        setTop(0);
+        setNote('');
+        setMode(mode);
+    }
+    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;
+            if (s && !s.prompt) {
+                // Bersaglio senza azione: la schermata resta aperta e lo dice. Chiuderla
+                // senza fare niente sarebbe indistinguibile da uno spawn riuscito.
+                setNote(s.hint || '⏎ → nessuna azione su questo bersaglio');
+                return;
+            }
+            close();
+            if (s)
+                onEnter(s.item, s.prompt);
+        }
+        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, hint, open, onKey, scroll };
+}

package/dist/pane-header.js

@@ -13,6 +13,8 @@ import { cutParts } from './width.js';
 import { paneTextWidth } from './layout.js';
 import { SESSION_VIEWS, TASK_VIEWS, } from './pane-views.js';
 import { INBOX_VIEWS } from './inbox-views.js';
+import { DOC_VIEWS } from './doc-views.js';
+import { WARN } from './glyphs.js';
 function finish(parts, columns) {
     const shown = cutParts(parts.map((p) => p.text), paneTextWidth(columns), parts.findIndex((p) => p.active));
     return { parts, shown };
@@ -80,6 +82,46 @@ export function inboxHeaderParts(counts, active, above, below, columns) {
         { key: null, text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false },
     ], columns);
 }
+/**
+ * T160 — header del pane doc, quarto gemello: `Doc` nomina il pane e non si
+ * seleziona, poi le cinque viste del catalogo, poi l'avviso di misura parziale,
+ * poi `↑N`/`↓N`.
+ *
+ * L'attenuazione la decide il catalogo (`v.dim(counts)`) come per l'inbox: la
+ * voce `Tutti` conta ogni riga dell'albero ma si grigia su quante ne sono
+ * flaggate, perché è quello a dire se c'è qualcosa da lanciare.
+ *
+ * L'avviso `senza cartelle` copre il caso della cascata (P2): il deck esegue lo
+ * script dalla cache installata del plugin e può incontrare una versione che
+ * emette la sola tabella dei file. L'albero si costruisce lo stesso — le
+ * cartelle si deducono dai path — ma i flag di cartella non ci sono, e senza
+ * l'avviso un `REGROUP (0)` direbbe «nessuna cartella da riorganizzare» invece
+ * di «non l'ho potuto misurare». Sta PRIMA di `↑N`/`↓N` perché è
+ * un'informazione sulla misura, e i contatori di scroll sono i primi a cedere il
+ * posto su un terminale stretto.
+ */
+export function docHeaderParts(counts, active, above, below, columns, hasDirs) {
+    const views = DOC_VIEWS.map((v) => ({
+        key: v.id,
+        text: ` · ${v.label(counts)}`,
+        color: v.color,
+        dim: v.dim(counts),
+        active: v.id === active,
+    }));
+    return finish([
+        { key: null, text: 'Doc', dim: false, active: false },
+        ...views,
+        {
+            key: null,
+            text: hasDirs ? '' : ` · ${WARN} senza cartelle`,
+            color: 'yellow',
+            dim: false,
+            active: false,
+        },
+        { key: null, text: above > 0 ? ` · ↑${above}` : '', dim: true, active: false },
+        { key: null, text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false },
+    ], columns);
+}
 /** Le parti COME SONO A SCHERMO — testo tagliato, chiave intatta — nella forma
  *  che `inlineRegions` (`mouse.ts`) misura per l'hit-test. */
 export function headerItems(h) {

package/dist/sane-note.js

@@ -22,24 +22,24 @@
 // che fallisce se una resta indietro.
 /**
  * L'alfabeto ammesso, negato: lettere, cifre, spazio, `_`, `-`, le accentate
- * italiane e sei emoji.
+ * italiane e sette emoji.
  *
  * Whitelist e non blacklist, come in bash: il titolo finisce dentro apici
  * singoli in `bash -lc "claude --name '…'"`, ed enumerare i caratteri pericolosi
  * significa sbagliarne uno.
  *
- * Le sei emoji sono nominate una per una e NON come intervallo di code point,
+ * Le sette emoji sono nominate una per una e NON come intervallo di code point,
  * per due ragioni che valgono su entrambi i lati: un'emoji arriva nella tab solo
  * se il deck la mostra identica in lista, cioè se `sanitize` (`src/width.ts`) la
  * lascia passare invece di renderla `·`, e quel verdetto si verifica un glifo
  * alla volta; e l'ordine di un intervallo dentro un bracket expression segue la
  * collazione della locale, non i code point.
  *
- * Il flag `u` non è cosmetico: senza, le quattro emoji astrali entrerebbero
+ * Il flag `u` non è cosmetico: senza, le emoji astrali entrerebbero
  * nella classe come coppie di surrogati sciolti, e la riduzione lascerebbe
  * passare mezzo carattere di qualunque altra emoji che ne condivida il primo.
  */
-const OUT_OF_ALPHABET = /[^A-Za-z0-9 _àèéìòùÀÈÉÌÒÙ📐🚀📊🏁🧹📏-]/gu;
+const OUT_OF_ALPHABET = /[^A-Za-z0-9 _àèéìòùÀÈÉÌÒÙ📐🚀📊🏁🧹📏🧭-]/gu;
 /** Cap in CARATTERI (code point), non in byte: a byte un taglio a metà di una
  *  `à` lascerebbe UTF-8 rotto nel titolo. Largo di proposito — una tab che sfora
  *  tronca a destra da sola, e il limite serve solo a non spingere fuori vista la

package/dist/session-meta.js

@@ -8,14 +8,18 @@
 // lì da chi ce l'ha in mano, cioè il deck, che a ogni tick materializza le
 // `Session` complete di titolo e modello.
 //
-// Modulo PURO come `session-list.ts`: nessun I/O, nessun import da ink/react.
-// Decide COSA appendere e ritorna i record; il chiamante li scrive. La
-// separazione è ciò che rende testabile la parte non ovvia — la convergenza:
-// un derivato che non combacia mai col valore su disco produrrebbe un append a
-// ogni tick del poll, per sempre, senza nessun errore a dirlo.
+// Il giudizio è separato dalla scrittura: `sidecarGaps` decide e ritorna i
+// record, `fillSidecarGaps` li scrive. La separazione è ciò che rende testabile
+// la parte non ovvia — la convergenza: un derivato che non combacia mai col
+// valore su disco produrrebbe un append a ogni tick del poll, per sempre, senza
+// nessun errore a dirlo.
+//
+// Nessun import da ink/react: il chiamante è un hook, questo modulo no.
 import { modelAlias } from './glyphs.js';
 import { stripProjectCore, stripTaskId } from './session-list.js';
 import { NO_TITLE } from './sessions.js';
+import { NO_SPAWN } from './spawn.js';
+import { appendSessionMeta } from './task-index.js';
 /**
  * Cap del titolo scritto nel sidecar, in CODE POINT.
  *
@@ -62,28 +66,6 @@ export function sidecarTitle(s, core, taskId) {
         return s.title === NO_TITLE ? '' : capTitle(s.title);
     return capTitle(stripTaskId(stripProjectCore(s.title, core), taskId));
 }
-/**
- * I buchi da riempire in questo giro: per ogni conversazione PINNATA, i campi
- * derivati che nel sidecar mancano o non corrispondono più al valore corrente.
- *
- * Solo le pinnate, e non tutte le conversazioni del progetto, perché sono le
- * sole che un lettore esterno mostra: il resto sarebbe churn su un file
- * append-only, un record per conversazione per ogni deck che si apre.
- *
- * Tre cose che non producono un append, e nessuna delle tre è un errore:
- *  - una pinnata STALE (il transcript non c'è più) — nessuna `Session`, quindi
- *    nessun valore da cui derivare;
- *  - un titolo derivato VUOTO — è l'assenza di P1, e appenderlo scriverebbe la
- *    cancellazione di un campo che nessuno ha chiesto di cancellare;
- *  - un modello non riconducibile a un alias (`''` o fuori famiglia) — chi
- *    riprende cadrà sulla propria cascata, che è meglio di un alias inventato.
- *
- * La CONVERGENZA è l'invariante da tenere: il confronto avviene fra il valore
- * derivato e il valore letto dal sidecar senza riscritture in mezzo (nessuna
- * sanificazione in lettura, cap applicato da questo lato una volta sola),
- * quindi un buco riempito resta riempito e il giro successivo non trova niente
- * da fare.
- */
 export function sidecarGaps(input) {
     const { pinned, sessions, bindings, titles, models, core } = input;
     if (pinned.size === 0)
@@ -106,3 +88,39 @@ export function sidecarGaps(input) {
     }
     return out;
 }
+/**
+ * Scrive i buchi di questo giro. Ritorna quanti record ha appeso — zero è
+ * l'esito normale a regime, non un fallimento.
+ *
+ * `NO_SPAWN` frena anche questa scrittura, ed è lo stesso freno delle tab
+ * Ptyxis per la stessa ragione: il gate su pseudo-terminale avvia il DECK VERO
+ * con cwd la project root del cappello, quindi senza freno ogni run della suite
+ * appende record nel sidecar reale di chi la lancia. Il valore scritto sarebbe
+ * pure corretto — è quello che il deck scriverebbe comunque — ma è una
+ * scrittura fuori dalla sandbox del test, che è precisamente ciò che il freno
+ * esiste per impedire.
+ *
+ * Il freno sta QUI e non nel chiamante perché questa è l'unica sede della
+ * scrittura: nel chiamante sarebbe una guardia che il prossimo scrittore non
+ * vede.
+ *
+ * Un sidecar non scrivibile non è un errore da mostrare: il giro dopo riprova,
+ * e nel frattempo il deck funziona identico — questi campi li legge un altro
+ * processo, non lui.
+ */
+export function fillSidecarGaps(projectRoot, input) {
+    if (NO_SPAWN)
+        return 0;
+    let scritti = 0;
+    try {
+        for (const gap of sidecarGaps(input)) {
+            appendSessionMeta(projectRoot, gap.sessionId, gap);
+            scritti++;
+        }
+    }
+    catch {
+        // sidecar non scrivibile: si riprova al giro dopo, niente a schermo — è
+        // manutenzione di un campo di servizio, non un'azione che l'utente ha chiesto.
+    }
+    return scritti;
+}

package/dist/spawn-catalog.js

@@ -110,7 +110,7 @@ const UNWRAP_PROMPT = 'lancia md-wrap modo apply su {path} e backup in cartella
     'verifica risultato e fai rapporto. se le modifiche sono tutte chiaramente safe, ' +
     'puoi committare direttamente';
 /**
- * Le UNDICI azioni configurabili, nell'ordine in cui la pagina le elenca.
+ * Le DODICI azioni configurabili, nell'ordine in cui la pagina le elenca.
  *
  * Il perimetro è quello di D1: entra una riga se ha almeno una cella editabile.
  * Ne restano fuori resume e fork — lì il modello non è una preferenza ma
@@ -123,9 +123,10 @@ const UNWRAP_PROMPT = 'lancia md-wrap modo apply su {path} e backup in cartella
  * T156 — le emoji dei titoli sono ASTRALI (code point ≥ U+10000) per necessità,
  * non per gusto: `sanitize` (`src/width.ts`) sostituisce con `·` ogni glifo su
  * cui le due contabilità di larghezza divergono, e le emoji del BMP a
- * presentazione testo divergono sempre. Le stesse sei stanno nella whitelist di
- * `_sane_note` in `deck-run` e nel suo gemello `src/sane-note.ts`: un'emoji
- * cambiata qui e non là sparisce fra la tabella e la tab, senza errore.
+ * presentazione testo divergono sempre. Le stesse SETTE (T160 aggiunge `🧭`)
+ * stanno nella whitelist di `_sane_note` in `deck-run` e nel suo gemello
+ * `src/sane-note.ts`: un'emoji cambiata qui e non là sparisce fra la tabella e
+ * la tab, senza errore.
  */
 export const SPAWN_ACTIONS = [
     {
@@ -258,6 +259,35 @@ export const SPAWN_ACTIONS = [
         holes: ['path'],
         fixed: {},
     },
+    {
+        // T160 — il rebalance della topologia doc su un bersaglio (file o cartella).
+        //
+        // La cella MODELLO è fissa, e la ragione mostrata al posto del valore non è
+        // una scorciatoia: `rebalance-doc` dichiara `model: sonnet` nel frontmatter,
+        // e quel campo ri-timbra il modello della sessione per la durata della
+        // skill, qualunque `--model` sia stato passato allo spawn. Una cella
+        // editabile qui accetterebbe un valore che non sopravvive all'invocazione —
+        // cioè mentirebbe senza produrre nessun errore. Lo stesso vale per le altre
+        // tre skill doc (`drain-notions`, `derive-notions`, `align-doc`), che la
+        // riga `drain` non ha ancora recepito.
+        //
+        // DUE buchi per lo stesso dato, e servono entrambi: `{target}` è il path
+        // VERO, che la skill risolve contro la colonna `PATH` della misura, e
+        // `{words}` lo stesso path reso a parole per il titolo. L'alfabeto di
+        // `_sane_note` non ha né `/` né `.`, quindi un `{target}` in un template di
+        // titolo uscirebbe con le parole saldate (`runtimereferencedoc-systemmd`) e
+        // la tab mostrerebbe un nome diverso da quello che il deck legge dal
+        // sidecar.
+        id: 'rebalance',
+        label: 'rebalance della doc',
+        surface: 'pane doc ⏎⏎',
+        kind: null,
+        title: '🧭 {words}',
+        model: 'sonnet',
+        prompt: '/loom-works:rebalance-doc {target}',
+        holes: ['target', 'words'],
+        fixed: { model: 'lo impone il frontmatter della skill' },
+    },
     {
         // T121 — il recap di progetto, headless (`claude -p`): nessuna tab, quindi
         // nessun titolo da configurare.
@@ -289,6 +319,12 @@ export const EXAMPLE_HOLES = {
     slug: 'esempio di task',
     file: 'T42-nozioni',
     path: 'runtime reference',
+    // T160 — i due buchi della riga `rebalance`, che portano lo stesso dato in due
+    // alfabeti: il path vero per il prompt della skill, le parole per il titolo
+    // della tab. L'esempio li mostra entrambi nella forma in cui arrivano davvero,
+    // o chi scrive un template li scambierebbe senza accorgersene.
+    target: 'runtime/reference/doc-system',
+    words: 'runtime reference doc-system',
 };
 /**
  * I valori sono quelli che i FORNITORI dei buchi producono davvero, non testo

package/dist/ui/doc-pane.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// T160 — il pane dell'albero doc, che in modo doc occupa lo slot SINISTRO.
+//
+// Risponde a una domanda sola, ed è la ragione della sua forma: **vale la pena
+// lanciare `rebalance-doc` adesso, e su cosa?** Da qui la colonna dei flag in
+// testa, dove si scorre con l'occhio, e il nome come unica cella elastica.
+//
+// Le CIFRE non stanno in riga (P6): char, lunghezza del TLDR e conteggio file
+// vivono nel blocco preview, insieme ai nomi interi dei flag. Su un pane largo la
+// metà del terminale ogni colonna fissa la paga il nome, che è l'unica cosa con
+// cui si riconosce un file — la stessa scelta già fatta per il pane inbox.
+//
+// Presentazionale puro: riceve la vista già selezionata e le larghezze già
+// calcolate, non le deriva.
+import { Box, Text } from 'ink';
+import { cut } from '../width.js';
+import { paneTextWidth } from '../layout.js';
+import { CARET, CARET_OFF } from '../glyphs.js';
+import { DOC_FLAG_W, flagCell } from '../doc-tree.js';
+import { docView } from '../doc-views.js';
+import { docHeaderParts } from '../pane-header.js';
+import { HeaderLine } from './header-line.js';
+/**
+ * Rientro di un livello dell'albero: UNA colonna, non due.
+ *
+ * L'albero della doc arriva a quattro livelli (`runtime/reference/loom-deck/
+ * sessions/`), e a due colonne per livello il rientro mangerebbe otto colonne
+ * della cella nome proprio sulle righe più profonde — che su un pane a 80
+ * colonne sono la metà di ciò che resta. Una colonna basta a vedere la
+ * gerarchia, perché le cartelle stanno comunque prima dei loro file.
+ */
+const INDENT_W = 1;
+/** I flag che chiamano un'operazione di `rebalance-doc`: la riga che ne porta
+ *  almeno uno è quella per cui il pane esiste, e si legge accesa. */
+const ACTIONABLE = new Set(['SPLIT', 'MERGE?', 'REGROUP']);
+/** Quelli che chiamano `write-tldr`: un difetto vero, ma di un'altra skill. */
+const TLDR_FLAGS = new Set(['TLDR>CAP', 'NOTLDR', 'TLDR-ORFANA']);
+/** Il colore della cella flag, dal flag più urgente che la riga porta. Un colore
+ *  solo per cella e non uno per short: la cella è un `Text` unico, e stilarne i
+ *  pezzi costerebbe tre nodi annidati per riga su una lista lunga quanto la doc. */
+function flagColor(row) {
+    if (row.flags.some((f) => ACTIONABLE.has(f)))
+        return 'yellow';
+    if (row.flags.some((f) => TLDR_FLAGS.has(f)))
+        return 'cyan';
+    return undefined;
+}
+/**
+ * Header del pane doc: le parti e il loro taglio vengono da `pane-header.ts`, lo
+ * stesso modulo da cui `frame.ts` ricava le colonne cliccabili.
+ */
+export function DocHeader({ counts, active, above, below, focused, columns, hasDirs, }) {
+    const { parts, shown } = docHeaderParts(counts, active, above, below, columns, hasDirs);
+    return _jsx(HeaderLine, { parts: parts, shown: shown, focused: focused });
+}
+export function DocPane({ rows, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, scanning, hasDirs, }) {
+    const width = paneTextWidth(columns);
+    // Cella elastica per sottrazione dalle colonne fisse, come nel pane inbox e
+    // nella lista sessioni. Pavimento 0 e non un minimo di cortesia: è un tetto,
+    // non una preferenza, e alzarlo sopra lo spazio reale fa uscire la riga dal
+    // pane mangiandone il bordo (invariante ③ di width.ts).
+    const nameW = Math.max(0, width - (2 /* caret */ + DOC_FLAG_W + 1 /* gutter */));
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(DocHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns, hasDirs: hasDirs }), paneCount === 0 ? (
+            // Quattro vuoti diversi, e dirlo è il punto. Ai tre del pane inbox se ne
+            // aggiunge uno che solo questo scan ha: «sto misurando». Quattro secondi
+            // di wall clock sono abbastanza da vedersi, e un pane vuoto per quattro
+            // secondi si legge come una doc senza file.
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(scanning
+                    ? 'misura in corso…'
+                    : !scanned
+                        ? 'albero non ancora misurato'
+                        : !ok
+                            ? 'misura della doc fallita: plugin assente o script in errore'
+                            : docView(activeView).empty, width) })) : (rows.map((r) => {
+                const sel = r.path === selectedPath;
+                const indent = ' '.repeat(r.depth * INDENT_W);
+                // La barra finale distingue una cartella da un file senza spendere una
+                // colonna di marcatore: è la convenzione di `ls -F`, e su una riga che
+                // porta già una colonna di flag un glifo in più sarebbe la terza cosa
+                // da leggere prima del nome.
+                const label = r.kind === 'dir' ? `${r.name}/` : r.name;
+                const text = cut(indent + label, nameW);
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { color: flagColor(r), dimColor: r.flags.length === 0, children: flagCell(r.flags) }), ' ', _jsx(Text, { bold: r.kind === 'dir', dimColor: r.kind === 'file' && r.flags.length === 0, children: text })] }, r.path));
+            }))] }));
+}

package/dist/ui/file-sheet-screen.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// T134/T160 — il detail di un FILE: testo scorrevole più la riga che dichiara
+// cosa partirà su `⏎`.
+//
+// Una schermata per le due istanze di `useFileSheet` (coda inbox e bersaglio
+// doc). Quello che cambia fra loro è la TESTATA — tre celle di testo, che i due
+// `…SheetHead` qui sotto compongono — e non la struttura: stesse righe fisse,
+// stessa cornice, stesso `FILE_SHEET_CHROME` nel budget d'altezza. Due
+// componenti avrebbero duplicato la cornice e il conteggio delle righe fisse,
+// che è esattamente ciò che fa sfondare `rows` quando una delle due copie
+// guadagna una riga e l'altra no.
+//
+// Riusa `DetailLine` del detail della task invece di ri-renderizzare il markdown
+// per conto proprio: sono lo stesso costrutto — un documento reso in span
+// tipizzati dentro un box — e due rese dello stesso markdown divergerebbero al
+// primo stile aggiunto. L'evidenziazione della ricerca non serve qui, quindi le
+// occorrenze arrivano vuote e il secondo taglio di `DetailLine` non gira nemmeno.
+import { Box, Text } from 'ink';
+import { cut } from '../width.js';
+import { DetailLine } from './detail-screen.js';
+import { INBOX_MARK, WARN, fmtDateTime, fmtSize } from '../glyphs.js';
+import { NATURA_SHORT, inboxMark } from '../inbox.js';
+import { flagNames } from '../doc-tree.js';
+export function inboxSheetHead(file) {
+    const mark = inboxMark(file);
+    return {
+        tag: NATURA_SHORT[file.natura],
+        name: file.basename,
+        meta: `${INBOX_MARK[mark] ? `${INBOX_MARK[mark]} ` : ''}${mark}` +
+            `${file.branch ? ` ⟨${file.branch}⟩` : ''}` +
+            `${file.cappello ? ` · ${file.cappello}` : ''} · ${file.nozioni} nozioni · ` +
+            `${file.aperte} aperte · ${fmtSize(file.chars)} · ${fmtDateTime(file.created * 1000)}`,
+    };
+}
+/**
+ * T160 — la testata del bersaglio doc.
+ *
+ * La meta cambia di natura fra file e cartella e non è un ramo di cortesia: il
+ * `char` di un file è la sua lunghezza, quello di una cartella la somma dei
+ * suoi, e le due si confrontano con due soglie diverse. Mostrarle sotto la
+ * stessa etichetta le farebbe leggere come la stessa misura.
+ */
+export function docSheetHead(row) {
+    const flags = flagNames(row.flags);
+    return {
+        tag: row.kind === 'dir' ? 'dir' : 'file',
+        name: row.path,
+        meta: (row.kind === 'dir'
+            ? `${row.files} file · ${fmtSize(row.chars)} in cartella`
+            : `${fmtSize(row.chars)} · TLDR ${row.tldr || 'assente'}`) +
+            ` · ${flags.length > 0 ? flags.join(' · ') : 'nessun flag'}`,
+    };
+}
+export function FileSheetScreen({ head, missing, lines, spans, top, total, capacity, prompt, hint, columns, }) {
+    const last = Math.min(total, top + capacity);
+    const width = Math.max(20, (columns || 80) - 4);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: head.tag }), " ", cut(head.name, Math.max(10, width - 8))] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [head.meta, missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193/PgUp/PgDn" }), " testo \u00B7 ", _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " apre la sessione \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " chiude"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " non leggibile \u00B7 l'azione resta attiva (la skill risolve il bersaglio per nome)"] })) : (lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: [], current: -1 }, top + i)))) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "\u23CE \u203A " }), _jsx(Text, { color: prompt ? 'green' : 'yellow', children: cut(prompt || hint || 'nessuna azione su questo bersaglio', Math.max(10, width - 4)) })] }) })] }));
+}

package/dist/ui/header-line.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// La resa di un header di pane già tagliato: ogni parte col suo stile, l'attiva
+// in video inverso.
+//
+// T160 · D1 — esce da `ui/panes.tsx` insieme ai pane che ne uscivano, perché è
+// ciò che tutti e quattro condividono. Il vincolo di `coding-standards`
+// §Come si splitta un file ricresciuto è che nessun modulo estratto importi il
+// file da cui è stato estratto: lasciando `HeaderLine` in `panes.tsx`, il pane
+// inbox e il pane doc avrebbero dovuto importarlo da lì — cioè la dipendenza
+// circolare che il vincolo esiste per vietare. Sta quindi in un file proprio, e
+// la dipendenza va in un verso solo: i quattro pane importano questo, questo non
+// importa nessuno di loro.
+//
+// Il video inverso e non un colore (T100/D5): costa 0 colonne e non entra in
+// gara con la semantica di colore già occupata dalle voci del catalogo.
+import { Text } from 'ink';
+export function HeaderLine({ parts, shown, focused, }) {
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: parts.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
+}

package/dist/ui/inbox-pane.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// T134 — il pane della coda inbox, che in modo doc occupa lo slot DESTRO.
+//
+// T160 · D1 — estratto da `ui/panes.tsx` insieme al pane doc, per la ragione
+// scritta in `coding-standards` §Un criterio verificato una volta non è un
+// custode: quel file era già stato splittato e stava ricrescendo. L'asse dello
+// split è per PANE, non per livello — ogni pane porta il proprio header, la
+// propria riga e la propria nota di vuoto, e sono le tre cose che si toccano
+// insieme. Ciò che i quattro condividono (`HeaderLine`) sta in
+// `ui/header-line.tsx`, e nessuno dei moduli estratti importa `ui/panes.tsx`.
+//
+// Presentazionale puro: riceve la vista già selezionata e le larghezze già
+// calcolate, non le deriva.
+import { Box, Text } from 'ink';
+import { cut, pad, sanitize, termWidth } from '../width.js';
+import { paneTextWidth } from '../layout.js';
+import { CARET, CARET_OFF, INBOX_MARK, INBOX_MARK_W, relTime } from '../glyphs.js';
+import { NATURA_SHORT, NATURA_W, inboxMark } from '../inbox.js';
+import { inboxView } from '../inbox-views.js';
+import { inboxHeaderParts } from '../pane-header.js';
+import { HeaderLine } from './header-line.js';
+/**
+ * Header del pane inbox: le parti e il loro taglio vengono da `pane-header.ts`,
+ * lo stesso modulo da cui `frame.ts` ricava le colonne cliccabili — una fonte
+ * sola, non due conti paralleli che divergono alla prima voce che cambia testo.
+ */
+export function InboxHeader({ counts, active, above, below, focused, columns, }) {
+    const { parts, shown } = inboxHeaderParts(counts, active, above, below, columns);
+    return _jsx(HeaderLine, { parts: parts, shown: shown, focused: focused });
+}
+/**
+ * T134 — il pane inbox, montato nello slot destro dal modo doc (D6).
+ *
+ * Mostra SEMPRE TUTTO, senza filtro sulla task selezionata a sinistra (D7
+ * preflight, che supersede la clausola di D6 congelate): niente righe meta,
+ * nessun trattamento speciale per il cappello vuoto o per un cappello che nomina
+ * una task non più in `tasks.md`. Ne discende che la colonna `CAPPELLO` di
+ * `doc-metrics` non serve al filtro — resta nel blocco preview, dove dice
+ * qualcosa senza costare una colonna su ogni riga.
+ *
+ * La riga porta marcatori, branch e nome (D8). Non le cifre (nozioni, aperte,
+ * char): stanno nella preview, e su un pane largo la metà del terminale ogni
+ * colonna fissa la paga la cella elastica del nome — che è l'unica cosa con cui
+ * si riconosce un file.
+ */
+export function InboxPane({ files, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, }) {
+    const width = paneTextWidth(columns);
+    // La cella elastica si calcola per SOTTRAZIONE dalle colonne fisse, come il
+    // titolo della lista sessioni: pavimento 0 e non un minimo di cortesia — è un
+    // tetto, non una preferenza, e alzarlo sopra lo spazio reale fa uscire la riga
+    // dal pane mangiandone il bordo (invariante ③ di width.ts).
+    const ageW = 3;
+    const nameW = Math.max(0, width -
+        (2 /* caret */ +
+            NATURA_W +
+            1 /* gutter */ +
+            INBOX_MARK_W +
+            1 /* gutter */ +
+            1 /* gutter prima della data */ +
+            ageW));
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(InboxHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), paneCount === 0 ? (
+            // Tre vuoti diversi, e dirlo è il punto: «non ho ancora misurato» non è
+            // «ho misurato e non c'è niente», e «la misura si è rotta» non è nessuno
+            // dei due (D2 preflight). Una lista vuota che non dice quale dei tre è
+            // si legge come un pane rotto.
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(!scanned
+                    ? 'coda non ancora misurata'
+                    : !ok
+                        ? 'misura della coda fallita: plugin assente o script in errore'
+                        : inboxView(activeView).empty, width) })) : (files.map((f) => {
+                const sel = f.path === selectedPath;
+                const mark = inboxMark(f);
+                // Il branch sta DENTRO la cella del nome, non in una colonna propria:
+                // è raro, e una colonna dedicata costerebbe spazio vuoto su ogni riga
+                // non-branchata di un pane largo la metà del terminale. Stessa scelta
+                // del marcatore di fork nella lista sessioni.
+                const branchMark = f.branch ? `⟨${f.branch}⟩ ` : '';
+                const inner = Math.max(0, nameW - termWidth(sanitize(branchMark)));
+                const name = cut(f.basename.replace(/\.md$/, ''), inner);
+                const age = relTime(f.created * 1000);
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { color: mark === 'broken' ? 'red' : mark === 'queued' ? 'green' : undefined, dimColor: mark === 'held' || mark === 'branched', children: pad(NATURA_SHORT[f.natura], NATURA_W) }), ' ', _jsx(Text, { color: mark === 'branched' ? 'yellow' : undefined, children: pad(INBOX_MARK[mark], INBOX_MARK_W) }), ' ', branchMark ? _jsx(Text, { color: "yellow", children: sanitize(branchMark) }) : null, _jsx(Text, { dimColor: mark !== 'queued', children: name }), ' '.repeat(Math.max(0, inner - termWidth(name))), ' ', _jsx(Text, { dimColor: true, children: pad(age, ageW, 'right') })] }, f.path));
+            }))] }));
+}