@lamemind/loom-deck 0.56.0 → 0.57.0

package/dist/overlays/wrap.js

@@ -0,0 +1,144 @@
+// T134 — la lista hard-wrap: settima schermata sostitutiva, apri-e-chiudi.
+//
+// Non è un pane e non è un catalogo: è un elenco di sola LETTURA più un campo
+// che nomina il perimetro dello srotolamento. Nessuna selezione di riga, e non
+// è una mancanza — l'azione non ha per oggetto un file ma un PATH, che può
+// essere una cartella intera; una selezione prometterebbe un'azione per riga
+// che non esiste. Da qui anche la rotella, che qui scorre il testo perché non
+// c'è nessuna selezione da muovere (D5 di T21 vale al contrario).
+//
+// Lo spawn NON sta qui: arriva come callback `onApply`, per lo stesso confine
+// degli altri overlay.
+import { useState } from 'react';
+import { useWrapScan } from '../hooks.js';
+import { pageStep, wrapListCapacity } from '../viewport.js';
+import { cpLen, insertAt, removeAt } from '../layout.js';
+import { sanitizeTyped } from '../glyphs.js';
+import { WRAP_DEFAULT_PATH, wrapPrompt } from '../wrap-scan.js';
+export function useWrapOverlay(deps) {
+    const { cwd, rows, setMode, setNote, onApply } = deps;
+    // Lo stato dello scan vive QUI e non nel modello, sul precedente di
+    // `useProjectStatus`: non è solo il contenuto di una schermata — i suoi
+    // numeri si leggono in testata a schermata chiusa, e la lista è una delle sue
+    // superfici invece che il suo contenuto. Tenerli in due posti significherebbe
+    // che l'indicatore e la lista possono dire cose diverse dello stesso scan.
+    const measure = useWrapScan(cwd);
+    /** Le righe FOTOGRAFATE all'apertura: uno scan che finisse mentre la lista è
+     *  a schermo la riscriverebbe sotto gli occhi, e la posizione di scroll non
+     *  avrebbe più un riferimento. Stessa regola del viewer del project status. */
+    const [files, setFiles] = useState(null);
+    const [top, setTop] = useState(0);
+    const [path, setPath] = useState(WRAP_DEFAULT_PATH);
+    const [caret, setCaret] = useState(cpLen(WRAP_DEFAULT_PATH));
+    const capacity = wrapListCapacity(rows);
+    const maxTop = Math.max(0, (files?.length ?? 0) - capacity);
+    /**
+     * Apre la lista, o dichiara perché non si apre.
+     *
+     * Rifiuta di aprirsi su una lista vuota, e i due modi di esserlo si dicono
+     * distinti: «non ho ancora misurato» e «ho misurato e non c'è niente» sono
+     * due stati del progetto diversi, e una schermata vuota li confonderebbe in
+     * uno solo. È la stessa forma di `^O` senza cache.
+     */
+    function open() {
+        if (measure.files.length === 0) {
+            setNote(measure.mtime === null
+                ? '^W → hard-wrap non ancora misurato · ^E per lo scan'
+                : '^W → nessun file con l\'a-capo rientrato: niente da srotolare');
+            return;
+        }
+        setFiles([...measure.files]);
+        setTop(0);
+        setPath(WRAP_DEFAULT_PATH);
+        setCaret(cpLen(WRAP_DEFAULT_PATH));
+        setNote('');
+        setMode('wrap');
+    }
+    function close() {
+        setMode('normal');
+        setFiles(null);
+    }
+    function scroll(delta) {
+        setTop((t) => Math.max(0, Math.min(maxTop, t + delta)));
+    }
+    function onKey(input, key) {
+        if (key.escape) {
+            close();
+            return;
+        }
+        if (key.return) {
+            const target = path.trim() || WRAP_DEFAULT_PATH;
+            close();
+            onApply(target, wrapPrompt(target));
+            return;
+        }
+        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 (key.leftArrow || key.rightArrow) {
+            const d = key.leftArrow ? -1 : 1;
+            setCaret((c) => Math.max(0, Math.min(cpLen(path), c + d)));
+        }
+        else if (key.backspace || key.delete) {
+            if (caret > 0) {
+                setPath((p) => removeAt(p, caret - 1));
+                setCaret((c) => c - 1);
+            }
+        }
+        else if (key.ctrl) {
+            // `^U` svuota, come il campo di ricerca e il filtro dell'assegnazione.
+            // Ogni altra combo è no-op: dentro un modo capturing gli acceleratori
+            // globali restano inerti.
+            if (input === 'u') {
+                setPath('');
+                setCaret(0);
+            }
+        }
+        else if (input && !key.meta) {
+            // `↑↓` sono già state consumate sopra: qui arrivano solo i caratteri, che
+            // vanno nel campo. Il testo si sanifica al confine come ogni altro campo
+            // del deck — un incollaggio porta byte di controllo che Ink conterebbe
+            // nella larghezza della riga.
+            const ins = sanitizeTyped(input);
+            setPath((p) => insertAt(p, caret, ins));
+            setCaret((c) => c + cpLen(ins));
+        }
+    }
+    /** Lo scan a richiesta, con la nota che dice cosa sta succedendo: cammina
+     *  l'albero del progetto intero, quindi dura, e un tasto che non desse segno
+     *  si leggerebbe come inerte. */
+    function scan() {
+        if (measure.scanning) {
+            setNote('^E → scan hard-wrap già in corso');
+            return;
+        }
+        setNote('⏳ scan hard-wrap sul progetto intero…');
+        measure.scan();
+    }
+    return {
+        files,
+        top,
+        capacity,
+        maxTop,
+        path,
+        caret,
+        count: measure.count,
+        mixed: measure.mixed,
+        mtime: measure.mtime,
+        ok: measure.ok,
+        scanning: measure.scanning,
+        open,
+        scan,
+        onKey,
+        scroll,
+    };
+}

package/dist/pane-header.js

@@ -1,8 +1,8 @@
 // T21 (mandata 3) — le PARTI degli header dei due pane come DATO, non come JSX.
 //
-// Stesso principio della riga launch (`launchSegments` in `cli.tsx`): gli
+// Stesso principio della riga launch (`launchRow` in `frame.ts`): gli
 // stessi oggetti compongono la riga disegnata (`ui/panes.tsx`) e le colonne
-// dell'hit-test (`cli.tsx`). Chi li deriva dall'altro — ri-splittando la
+// dell'hit-test (`frame.ts`). Chi li deriva dall'altro — ri-splittando la
 // stringa renderizzata, o ricontando le voci del catalogo — tiene due conti
 // paralleli che divergono alla prima voce che cambia testo o ordine.
 //
@@ -12,6 +12,7 @@
 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';
 function finish(parts, columns) {
     const shown = cutParts(parts.map((p) => p.text), paneTextWidth(columns), parts.findIndex((p) => p.active));
     return { parts, shown };
@@ -55,6 +56,30 @@ export function sessionHeaderParts(parentLabel, counts, active, above, below, co
         { key: null, text: below > 0 ? ` · ↓${below}` : '', dim: true, active: false },
     ], columns);
 }
+/**
+ * T134 — header del pane inbox, terzo gemello: `Inbox` nomina il pane e non si
+ * seleziona, poi le quattro viste del catalogo, poi `↑N`/`↓N`.
+ *
+ * L'attenuazione la decide il catalogo (`v.dim(counts)`) e non il contatore
+ * della voce, a differenza dei due header storici: la voce `Tutti` conta ogni
+ * file in lista ma si grigia sulla somma delle tre nature (D7), perché è quella
+ * a dire se c'è lavoro da prendere.
+ */
+export function inboxHeaderParts(counts, active, above, below, columns) {
+    const views = INBOX_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: 'Inbox', dim: false, active: false },
+        ...views,
+        { 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/pane-views.js

@@ -61,7 +61,7 @@ export function selectTasks(tasks, id, ctx) {
     return picked;
 }
 /** Glifo della sessione viva, gemello di `LIVE_IDLE` del render. Duplicato qui
- *  perché il catalogo è puro e non può importare da `cli.tsx`; è un carattere
+ *  perché il catalogo è puro e non può importare da `ui/`; è un carattere
  *  concorde (largo 1 per entrambe le contabilità), quindi non passa da
  *  `sanitize`. */
 const LIVE_GLYPH = '●';

package/dist/spawn.js

@@ -267,6 +267,33 @@ export function spawnDeckFork(taskId, cwd, originId, newId) {
 export function spawnClaudeEmpty(cwd) {
     return launchDeckRun(['--no-task'], cwd);
 }
+/**
+ * T134 — sessione NUDA con un prompt letterale: `deck-run --no-task --prompt
+ * <testo> --model <alias>`.
+ *
+ * Il lavoro che apre — drenare un file inbox, srotolare l'hard-wrap di un path
+ * — sta sulla DOC, non su una task (D10 preflight). Legarlo a un cappello
+ * esporterebbe `LOOM_TASK`, farebbe scattare l'hook `SessionStart` che inietta
+ * in contesto il task file di un lavoro spesso già chiuso, e metterebbe
+ * `· T<n>` nel titolo della tab; per un file `sweep` senza cappello la strada
+ * non esisterebbe nemmeno.
+ *
+ * Presidiata, non headless (D11): `spawnSkill` resta dov'è e non si estende
+ * qui. Ne discendono due cose. Il confine presidiata / non presidiata delle
+ * skill di doc smette di essere un vincolo — anche `align-doc`, che apre un
+ * branch con PR, è offribile, perché c'è un umano nella tab che la guarda. E la
+ * guardia d'ingresso `doc-guard.sh worktree`, che esce 2 su worktree sporco
+ * sotto `inbox/`, `reference/` o `CLAUDE.md`, la incontra la sessione e la
+ * mostra a chi l'ha lanciata: il deck non deve replicarla per sapere in
+ * anticipo se l'azione morirebbe allo step 0.
+ *
+ * Il modello è passato SEMPRE, anche sul default, per la stessa ragione di
+ * `permissionMode`: lo spawn resta deterministico e leggibile nel process tree
+ * invece di dipendere da un default che può cambiare fra versioni.
+ */
+export function spawnBare(cwd, prompt, model) {
+    return launchDeckRun(['--no-task', '--prompt', prompt, '--model', model], cwd);
+}
 // 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

package/dist/tasks.js

@@ -8,11 +8,24 @@ import { sanitize } from './width.js';
  * divergano (uno accetterebbe righe che l'altro rifiuta).
  */
 export const TASK_ID_RE = /^T\d+$/;
-// D1 (preflight T20): default docs/tasks.md, override della docs-root via env
-// LOOM_DECK_DOCS_ROOT (es. questo progetto usa `runtime`). No auto-detect.
+/**
+ * Nome della cartella doc del progetto (`docs`, `runtime`, …).
+ *
+ * D1 (preflight T20): override via env `LOOM_DECK_DOCS_ROOT`, nessun
+ * auto-detect e nessuna lettura del file config. Il deck non si lancia mai a
+ * mano — nasce da compass, che legge `docsRoot` dal registry dconf e lo
+ * antepone al comando, o dal custom-command del profilo Ptyxis, che ce l'ha
+ * cablato — quindi l'env c'è sempre nei percorsi di avvio reali.
+ *
+ * T134 — funzione e non più letterale ripetuto: la legge anche lo scan della
+ * coda inbox, e due copie della stessa cascata divergerebbero appena una delle
+ * due imparasse a leggere il file config.
+ */
+export function docsRootName() {
+    return process.env.LOOM_DECK_DOCS_ROOT || 'docs';
+}
 export function resolveTasksPath(cwd = process.cwd()) {
-    const docsRoot = process.env.LOOM_DECK_DOCS_ROOT || 'docs';
-    return join(cwd, docsRoot, 'tasks.md');
+    return join(cwd, docsRootName(), 'tasks.md');
 }
 // I task file vivono in `<docsRoot>/tasks/` — sibling di tasks.md. Derivo la
 // dir dallo stesso path per rispettare l'override LOOM_DECK_DOCS_ROOT.

package/dist/ui/inbox-screen.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// T134 — il detail di un file inbox: testo scorrevole più la riga che dichiara
+// cosa partirà su `⏎`.
+//
+// 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 (nessuna ricerca dentro l'inbox), 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';
+export function InboxScreen({ file, missing, lines, spans, top, total, capacity, prompt, columns, }) {
+    const last = Math.min(total, top + capacity);
+    const width = Math.max(20, (columns || 80) - 4);
+    const mark = inboxMark(file);
+    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: NATURA_SHORT[file.natura] }), ' ', cut(file.basename, Math.max(10, width - 8))] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [INBOX_MARK[mark] ? `${INBOX_MARK[mark]} ` : '', mark, file.branch ? ` ⟨${file.branch}⟩` : '', file.cappello ? ` · ${file.cappello}` : '', " \u00B7 ", file.nozioni, " nozioni \u00B7 ", file.aperte, ' ', "aperte \u00B7 ", fmtSize(file.chars), " \u00B7 ", fmtDateTime(file.created * 1000), 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, " file non leggibile \u00B7 l'azione resta attiva (la skill risolve il file 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: "green", children: cut(prompt, Math.max(10, width - 4)) })] }) })] }));
+}

package/dist/ui/panes.js

@@ -5,12 +5,14 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from 'ink';
 import { cut, pad, sanitize, termWidth } from '../width.js';
 import { paneTextWidth } from '../layout.js';
-import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
+import { CARET, CARET_OFF, INBOX_MARK, INBOX_MARK_W, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
+import { NATURA_SHORT, NATURA_W, inboxMark } from '../inbox.js';
+import { inboxView, } from '../inbox-views.js';
 import { TaskRow } from './task-row.js';
 import { META_ROWS, ROW_ALL, ROW_SPOT } from '../model.js';
 import { rowLabel, sessionTitle } from '../session-list.js';
 import { sessionView, taskView, } from '../pane-views.js';
-import { sessionHeaderParts, taskHeaderParts } from '../pane-header.js';
+import { inboxHeaderParts, sessionHeaderParts, taskHeaderParts, } from '../pane-header.js';
 import { describeSort, PRI_ENTRIES, PROG_ENTRIES, } from '../view.js';
 /**
  * Header del pane task, tagliato QUI e non da Ink — stesso motivo del gemello
@@ -33,7 +35,7 @@ import { describeSort, PRI_ENTRIES, PROG_ENTRIES, } from '../view.js';
  */
 export function TasksHeader({ counts, active, above, below, focused, columns, }) {
     // T21 — le parti e il loro taglio vengono da `pane-header.ts`, lo stesso
-    // modulo da cui `cli.tsx` ricava le colonne cliccabili: una fonte sola.
+    // modulo da cui `frame.ts` ricava le colonne cliccabili: una fonte sola.
     const { parts, shown } = taskHeaderParts(counts, active, above, below, columns);
     return _jsx(HeaderLine, { parts: parts, shown: shown, focused: focused });
 }
@@ -83,6 +85,69 @@ export function SessionsHeader({ parentLabel, counts, active, above, below, focu
     const { parts, shown } = sessionHeaderParts(parentLabel, counts, active, above, below, columns);
     return _jsx(HeaderLine, { parts: parts, shown: shown, focused: focused });
 }
+/**
+ * T134 — header del pane inbox, terzo gemello dei due sopra: le parti e il loro
+ * taglio vengono da `pane-header.ts`, lo stesso modulo da cui `frame.ts` ricava
+ * le colonne cliccabili.
+ */
+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, alternativo a quello delle sessioni nello slot destro
+ * (D6). Uno dei due è montato e l'altro non esiste: `^B` li scambia.
+ *
+ * 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));
+            }))] }));
+}
 export 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

package/dist/ui/preview.js

@@ -2,11 +2,41 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // Blocco preview a piena larghezza sotto i due pane: mostra la task o la
 // conversazione selezionata a seconda del pane a fuoco.
 import { Box, Text } from 'ink';
-import { wrapLines } from '../width.js';
+import { cut, wrapLines } from '../width.js';
 import { previewTextWidth } from '../layout.js';
 import { LIVE_BUSY, LIVE_IDLE, META_KEYS, SID_CHARS, fmtDateTime, fmtSize } from '../glyphs.js';
+import { NATURA_SHORT, inboxMark } from '../inbox.js';
+/** Colonne del prefisso delle due anteprime della preview sessione (`» `, `« `,
+ *  e i due spazi delle righe di continuazione). Costante perché entra nel
+ *  budget di wrap, che è il posto in cui dimenticarla non produce un errore ma
+ *  un bordo mangiato. */
+const PREVIEW_PREFIX_W = 2;
 export 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 })) }));
+    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 })) : p.kind === 'inbox' ? (_jsx(InboxPreview, { file: p.file, 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 })) }));
+}
+/**
+ * T134 — corpo della preview inbox: due righe FISSE, contate da
+ * `INBOX_DETAIL_FIXED`. Ogni riga aggiunta va scalata lì, o il frame sfonda
+ * `rows` e Ink passa a `clearTerminal` — che su VTE riversa un frame nello
+ * scrollback a ogni tick del poll.
+ *
+ * Porta ciò che la riga di lista non può: il nome INTERO (in lista si tronca
+ * su un pane largo la metà del terminale), le cifre del marker e il cappello.
+ * Il perché di uno stato — `branch:` che congela per chiunque, `drainable`
+ * assente che tiene fuori dalla coda ma non vieta l'esecuzione — è scritto per
+ * esteso, perché il glifo della lista dice solo QUALE stato, non cosa comporta.
+ */
+export function InboxPreview({ file, columns }) {
+    const mark = inboxMark(file);
+    const width = previewTextWidth(columns);
+    const state = mark === 'broken'
+        ? 'marker illeggibile: nessuna skill lo prende, va riparato'
+        : mark === 'branched'
+            ? `congelato su ${file.branch}: lo sblocca pull-repos quando il branch è su main`
+            : mark === 'held'
+                ? 'fuori dalla coda automatica (nessun drainable): eseguibile se lo nomini'
+                : 'in coda: una skill può prenderlo da sola';
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: NATURA_SHORT[file.natura] }), ' ', cut(file.basename, Math.max(10, width - 8))] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [file.nozioni, " nozioni \u00B7 ", file.aperte, " aperte \u00B7 ", fmtSize(file.chars), " \u00B7", ' ', fmtDateTime(file.created * 1000), file.cappello ? ` · ${file.cappello}` : '', file.indexed ? ' · indexed' : '', " \u00B7 ", state] })] }));
 }
 // 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.
@@ -16,7 +46,15 @@ export function PreviewPane(p) {
 // lo duplicherebbe (D4 preflight). Le righe rese non superano mai il riservato
 // dal budget (`firstLines`/`lastLines`); renderne meno è sicuro (frame più corto).
 export function SessionPreview({ s, firstLines, lastLines, columns, origin, note, live, }) {
-    const width = previewTextWidth(columns);
+    // Il prefisso `» `/`« ` è largo 2 e sta SULLA riga: va tolto dal budget di
+    // wrap, o una riga piena esce dal box di quelle due colonne e a raccoglierla
+    // arriva `cli-truncate`, che sfora di una colonna per emoji e mangia il bordo
+    // (invariante ③ di width.ts). Il difetto si vede solo quando una riga cade
+    // esattamente sul budget, cioè su una risposta abbastanza lunga: da qui un
+    // gate che passa o fallisce a seconda delle conversazioni che trova sul
+    // disco. Le righe di continuazione portano due spazi, quindi il prefisso
+    // costa 2 su OGNI riga, non solo sulla prima.
+    const width = previewTextWidth(columns) - PREVIEW_PREFIX_W;
     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 || '-', s.model ? ` · ${s.model}` : '', 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}`)))] }));

package/dist/ui/screens.js

@@ -2,12 +2,13 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // Le SCHERMATE SOSTITUTIVE del deck e i due frammenti che le accompagnano.
 //
 // Una schermata sostitutiva prende il frame intero invece di stare in un box
-// sopra i due pane: assegnazione, detail della task, project status, ricerca e
-// reader. Il criterio è la taglia del contenuto — una lista di occorrenze o un
-// task file non entrano in quattro righe — e la conseguenza è che il budget
-// d'altezza dei pane non viene nemmeno calcolato, perché il render esce prima.
+// sopra i due pane: assegnazione, detail della task, project status, detail di
+// un file inbox, ricerca e reader. Il criterio è la taglia del contenuto — una
+// lista di occorrenze, un task file o un file di nozioni non entrano in quattro
+// righe — e la conseguenza è che il budget d'altezza dei pane non viene nemmeno
+// calcolato, perché il render esce prima.
 //
-// `screenFor` è il ROUTER: sceglie fra le cinque e restituisce `null` quando
+// `screenFor` è il ROUTER: sceglie fra le sei e restituisce `null` quando
 // nessuna è attiva, cioè quando si resta sulla lista. È una funzione e non un
 // componente proprio per questo — il chiamante deve poter distinguere «ecco la
 // schermata» da «non è il tuo turno», e un componente che rende `null` non gli
@@ -25,12 +26,16 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // primo file di `ui/` a farlo, quindi va detto invece che scoperto a grep.
 import { Box, Text } from 'ink';
 import { rowIndexOfKey, selectedRow } from '../search.js';
+import { cut } from '../width.js';
+import { legendWidth } from '../frame.js';
 import { isCompact, searchPreviewCapacity, windowRange } from '../viewport.js';
 import { conversationLabel } from '../layout.js';
 import { taskColumns } from '../view.js';
 import { AssignScreen } from './assign-screen.js';
 import { DetailScreen } from './detail-screen.js';
 import { StatusScreen } from './status-screen.js';
+import { InboxScreen } from './inbox-screen.js';
+import { WrapScreen } from './wrap-screen.js';
 import { ReaderScreen, SearchScreen } from './search-screen.js';
 /**
  * Il ripiego per un terminale troppo basso: una riga sola al posto della
@@ -51,11 +56,17 @@ export function CompactNotice({ what, esc, rows, columns, dot = true, }) {
  * flusso le sue istruzioni. I modali sostitutivi non arrivano qui — hanno già
  * preso il frame.
  *
- * La legenda di `normal` la calcola il chiamante (`deckLegend` in `frame.ts`),
- * perché dipende da cosa è selezionato; le sette righe dei modali sono testo
- * fisso e vivono qui, accanto alla forma che le rende.
+ * T134 — in `normal` la riga non è più tutta della legenda: divide lo spazio con
+ * gli INDICATORI ancorati a destra, e sono loro ad avere la precedenza sul
+ * budget (D5 preflight). `keyLegend` è già troncabile per costruzione e ciò che
+ * perde si ricorda; un contatore troncato invece mente.
+ *
+ * Dentro un modale in flusso gli indicatori non compaiono, e non è un
+ * nascondimento: la riga è dell'istruzione del modale, che sta a schermo per il
+ * tempo di una domanda. «Mai nascondibile» (D9) dice che non esiste un tasto per
+ * spegnerli, non che ogni riga del frame debba ospitarli.
  */
-export function HintBar({ mode, purge, keyLegend, }) {
+export function HintBar({ mode, purge, keyLegend, indicators, columns, }) {
     if (mode === 'create') {
         return (_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"] }));
     }
@@ -74,19 +85,29 @@ export function HintBar({ mode, purge, keyLegend, }) {
     if (mode === 'edit') {
         return (_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"] }));
     }
-    return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend }));
+    // Riga a piena larghezza nella stessa forma della testata: un `Box` con
+    // `justifyContent="space-between"` e due figli a stringa piatta. Il blocco
+    // indicatori arriva già unito (`indicators.text`) invece che come segmenti
+    // resi uno per uno — da cui il colore unico per il blocco.
+    //
+    // Il taglio della legenda resta del deck e non di Ink: la stringa porta emoji
+    // e frecce, e `cli-truncate` le conta con un budget in colonne indicizzando
+    // per code point — una colonna di troppo finisce sopra il bordo destro, che
+    // sparisce dalla riga (invariante ③ di width.ts).
+    return (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(keyLegend, legendWidth(columns, indicators.width)) }), _jsx(Text, { color: "cyan", children: indicators.text })] }));
 }
 /**
  * Sceglie la schermata sostitutiva attiva, o `null` per restare sulla lista.
  *
  * L'ordine dei rami è quello che avevano in `cli.tsx` e non è indifferente: i
- * modi si escludono a vicenda, ma `detail` e `status` chiedono anche che il
- * proprio contenuto esista (`sheet.sheet`, `status.view`) — un modo dichiarato
- * senza contenuto deve cadere alla lista, non a una schermata vuota.
+ * modi si escludono a vicenda, ma `detail`, `status` e `inbox` chiedono anche
+ * che il proprio contenuto esista (`sheet.sheet`, `status.view`, `inbox.sheet`)
+ * — un modo dichiarato senza contenuto deve cadere alla lista, non a una
+ * schermata vuota.
  */
 export function screenFor(input) {
     const { mode, rows, columns, note, overlays } = input;
-    const { assign, sheet, search, status } = overlays;
+    const { assign, sheet, search, status, inbox, wrap } = overlays;
     // ── T57 · schermata di assegnazione ─────────────────────────────────────
     // Sostitutiva come ricerca e reader (D3): la lista task non entra in un box
     // sopra i due pane, e prendendo l'intero frame non costa nulla al loro budget.
@@ -142,6 +163,28 @@ export function screenFor(input) {
         const start = Math.min(status.top, status.maxTop);
         return (_jsx(StatusScreen, { name: input.projectCore ?? input.projectName, label: status.label, building: status.building, failed: status.failed, view: status.view, lines: status.lines.slice(start, start + status.capacity), spans: status.doc?.spans ?? [], top: start, total: status.lines.length, capacity: status.capacity, columns: columns }));
     }
+    // ── T134 · detail di un file inbox ──────────────────────────────────────
+    // Sesta schermata sostitutiva, stessa ragione delle altre cinque: un file di
+    // nozioni supera i 28KB, cioè è più lungo di ogni task file del progetto.
+    if (mode === 'inbox' && inbox.sheet) {
+        if (isCompact(inbox.capacity)) {
+            return (_jsx(CompactNotice, { what: inbox.sheet.file.basename, esc: "chiude", rows: rows, columns: columns }));
+        }
+        // Il clamp serve anche qui: un resize può accorciare il testo sotto uno
+        // scroll già dato.
+        const start = Math.min(inbox.top, inbox.maxTop);
+        return (_jsx(InboxScreen, { file: inbox.sheet.file, missing: inbox.sheet.text === null, lines: inbox.lines.slice(start, start + inbox.capacity), spans: inbox.doc?.spans ?? [], top: start, total: inbox.lines.length, capacity: inbox.capacity, prompt: inbox.prompt, columns: columns }));
+    }
+    // ── T134 · lista hard-wrap ──────────────────────────────────────────────
+    // Settima schermata sostitutiva: sul cappello lo scan trova 77 `WRAP` e 147
+    // `misto`, cioè una lista che in un box sopra i pane non entrerebbe.
+    if (mode === 'wrap' && wrap.files) {
+        if (isCompact(wrap.capacity)) {
+            return _jsx(CompactNotice, { what: "hard-wrap", esc: "chiude", rows: rows, columns: columns });
+        }
+        const start = Math.min(wrap.top, wrap.maxTop);
+        return (_jsx(WrapScreen, { files: wrap.files.slice(start, start + wrap.capacity), count: wrap.count, mixed: wrap.mixed, mtime: wrap.mtime, top: start, capacity: wrap.capacity, path: wrap.path, caret: wrap.caret, columns: columns }));
+    }
     // ── T52 · ricerca e reader ──────────────────────────────────────────────
     // Gli unici modali che NON stanno in flusso sopra i pane: una lista di
     // occorrenze non entra in un box da 4 righe. Prendono l'intero frame, quindi

package/dist/ui/wrap-screen.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// T134 — la lista hard-wrap: i file con l'a-capo automatico rientrato, più il
+// campo che nomina il perimetro dello srotolamento.
+import { Box, Text } from 'ink';
+import { cut, pad, termWidth } from '../width.js';
+import { FieldText } from './fields.js';
+import { fmtTime } from '../glyphs.js';
+/** Larghezza della colonna verdetto: il dominio è chiuso (`WRAP`, `misto`) e la
+ *  più lunga è larga 5, quindi misurarla a ogni render calcolerebbe un numero
+ *  già noto. */
+const VERDICT_W = 5;
+export function WrapScreen({ files, count, mixed, mtime, top, capacity, path, caret, columns, }) {
+    const width = Math.max(20, (columns || 80) - 4);
+    const total = count + mixed;
+    const last = Math.min(total, top + capacity);
+    // Cella elastica per sottrazione, come ogni lista del deck: le colonne fisse
+    // sono note, quindi il path prende il resto. Pavimento 0 — è un tetto, non
+    // una preferenza, e alzarlo sopra lo spazio reale fa uscire la riga dal box
+    // mangiandone il bordo (invariante ③ di width.ts).
+    //
+    // Le due celle numeriche vanno contate INSIEME al loro separatore: `col=` è
+    // larga 8, `br=` 6, e fra loro c'è uno spazio. Sommarne solo due su tre è
+    // l'off-by-one che tronca la coda della riga.
+    const COL_W = 8;
+    const BREAKS_W = 6;
+    const numsW = COL_W + 1 + BREAKS_W;
+    // `- 4` = bordo + padding del box della lista, che sta DENTRO quello esterno.
+    const pathW = Math.max(0, width - 4 - VERDICT_W - 1 - numsW);
+    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: "hard-wrap" }), ' ', _jsxs(Text, { color: "red", children: [count, " WRAP"] }), ' ', _jsxs(Text, { dimColor: true, children: ["\u00B7 ", mixed, " misto"] }), ' ', _jsxs(Text, { dimColor: true, children: ["\u00B7 scan ", mtime === null ? 'mai' : fmtTime(mtime), " \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/PgUp/PgDn" }), " scorre \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota il path \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " srotola \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " chiude \u00B7 misto = falso allarme probabile, fuori dal contatore"] }), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: files.map((f) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: f.verdict === 'WRAP' ? 'red' : undefined, dimColor: f.verdict !== 'WRAP', children: pad(f.verdict, VERDICT_W) }), ' ', _jsx(Text, { dimColor: f.verdict !== 'WRAP', children: cut(f.path, pathW) }), ' '.repeat(Math.max(0, pathW - termWidth(cut(f.path, pathW)))), _jsxs(Text, { dimColor: true, children: [pad(`col=${f.column ?? '?'}`, COL_W, 'right'), ' ', pad(`br=${f.breaks}`, BREAKS_W, 'right')] })] }, f.path))) }), _jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "path \u203A " }), _jsx(FieldText, { value: path, caret: caret, focused: true, cols: Math.max(10, width - 12) })] })] }));
+}