@lamemind/loom-deck 0.74.0 → 0.76.0

package/dist/project-path.js

@@ -0,0 +1,71 @@
+// T175 — i confronti di path che il deck fa sulla root del progetto, per
+// piattaforma.
+//
+// Tre punti confrontavano path come stringhe POSIX: il filtro delle
+// conversazioni del progetto (`sessions.ts`), quello delle sessioni vive
+// (`live-sessions.ts`) e il nome del progetto (`deck-model.ts`). Su Linux la
+// stringa È il path; su Windows no, per tre ragioni misurate (verdetto 1 di T174):
+//
+//  - NTFS non distingue le maiuscole, e Claude Code non normalizza la grafia
+//    della cwd: VS Code passa `c:\…`, Windows Terminal `C:\…`, e lo stesso
+//    progetto ha due cartelle di transcript (`c--…` e `C--…`);
+//  - `\` e `/` sono entrambi separatori;
+//  - nei transcript `cwd` compare anche in forma MSYS (`/c/…`), quella di Git
+//    Bash.
+//
+// Modulo PURO. La piattaforma è un parametro con default quella VERA, e non
+// quella di `LOOM_DECK_PLATFORM` (`platform.ts`): qui si descrive il filesystem
+// su cui il deck gira, non una funzione che si può spegnere.
+import { posix, win32 } from 'node:path';
+/**
+ * La forma di un path su cui si confronta, mai quella che si mostra.
+ *
+ * Su win32: separatori portati a `\`, forma MSYS `/c/…` riportata a `C:\…`,
+ * tutto minuscolo, nessun separatore in coda (tranne la radice del drive, dove
+ * `C:` da solo vorrebbe dire «la cartella corrente di C:»). Altrove il path così
+ * com'è, senza il separatore in coda: il confronto resta case-sensitive come il
+ * filesystem.
+ */
+export function comparablePath(p, platform = process.platform) {
+    if (platform !== 'win32')
+        return p.length > 1 ? p.replace(/\/+$/, '') : p;
+    let s = p.replace(/\//g, '\\');
+    // `\c\Users\…` (la forma MSYS dopo la sostituzione dei separatori) →
+    // `c:\Users\…`. Un UNC (`\\server\…`) non matcha: il secondo carattere è `\`.
+    const msys = /^\\([a-zA-Z])(?:\\|$)/.exec(s);
+    if (msys)
+        s = `${msys[1]}:\\${s.slice(msys[0].length)}`;
+    s = s.replace(/\\+$/, '');
+    if (/^[a-zA-Z]:$/.test(s))
+        s += '\\';
+    return s.toLowerCase();
+}
+/** `path` è la root stessa o sta sotto di lei. Mai un prefisso di nome: la root
+ *  `C:\a\loom` non contiene `C:\a\loom-works`. */
+export function isWithin(path, root, platform = process.platform) {
+    const p = comparablePath(path, platform);
+    const r = comparablePath(root, platform);
+    if (p === r)
+        return true;
+    const sep = platform === 'win32' ? '\\' : '/';
+    return p.startsWith(r.endsWith(sep) ? r : r + sep);
+}
+/** Il nome della cartella del progetto: l'ultimo segmento della root, con i
+ *  separatori della piattaforma. Root senza segmenti (`/`, `C:\`) → la root. */
+export function projectBaseName(cwd, platform = process.platform) {
+    return (platform === 'win32' ? win32 : posix).basename(cwd) || cwd;
+}
+/**
+ * Le cartelle di transcript del progetto, fra i nomi di `~/.claude/projects/`.
+ *
+ * Su Linux una sola, il nome esatto. Su win32 ogni nome che coincide ignorando
+ * le maiuscole: la stessa root avviata da VS Code (`c:\…`) e da Windows
+ * Terminal (`C:\…`) scrive in `c--…` e in `C--…`, e leggerne una sola perde le
+ * conversazioni dell'altra.
+ */
+export function matchingDirNames(entries, name, platform = process.platform) {
+    if (platform !== 'win32')
+        return entries.filter((e) => e === name);
+    const want = name.toLowerCase();
+    return entries.filter((e) => e.toLowerCase() === want);
+}

package/dist/purge.js

@@ -80,6 +80,7 @@ export function folderSurvivors(projectRoot, folder) {
         const out = execFileSync('git', ['ls-files', '-o', '--', rel], {
             cwd: projectRoot,
             encoding: 'utf8',
+            windowsHide: true,
         });
         return out.split('\n').filter(Boolean);
     }

package/dist/sessions.js

@@ -2,6 +2,7 @@ import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { sanitize } from './width.js';
+import { isWithin, matchingDirNames } from './project-path.js';
 // CC codifica la project dir sostituendo ogni char non-alfanumerico con '-'
 // (verificato: `/home/lamemind/cc-host` → `-home-lamemind-cc-host`). È LOSSY
 // (un '-' nel path e un '/' collassano nello stesso char) → il forward è
@@ -308,51 +309,84 @@ export function compareSessions(a, b) {
         return b.lastReplyTs - a.lastReplyTs;
     return b.ts - a.ts;
 }
-// Discovery read-only delle sessioni del SOLO progetto corrente (D2 preflight
-// T27): legge la project dir calcolata dal forward-transform, filtra per cwd
-// (difesa contro le collisioni lossy del naming), ordina con `compareSessions`.
-export function discoverProjectSessions(projectRoot) {
-    const dir = join(claudeProjectsRoot(), projectDirName(projectRoot));
-    let files;
+/**
+ * T175 — le cartelle di transcript del progetto.
+ *
+ * Su Linux una sola, il nome esatto, e senza leggere la cartella madre: il poll
+ * gira ogni 1,5 s, e un `readdir` di `~/.claude/projects/` costerebbe a ogni
+ * tick per trovare un nome già noto. Su win32 tutte quelle che coincidono a
+ * meno delle maiuscole (`matchingDirNames`): Claude Code non normalizza la
+ * lettera del drive, e lo stesso progetto ne ha due.
+ */
+function transcriptDirs(projectRoot) {
+    const root = claudeProjectsRoot();
+    const name = projectDirName(projectRoot);
+    if (process.platform !== 'win32')
+        return [join(root, name)];
+    let entries;
     try {
-        files = readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
+        entries = readdirSync(root);
     }
     catch {
         return [];
     }
-    const out = [];
+    return matchingDirNames(entries, name).map((e) => join(root, e));
+}
+// Discovery read-only delle sessioni del SOLO progetto corrente (D2 preflight
+// T27): legge le project dir calcolate dal forward-transform, filtra per cwd
+// (difesa contro le collisioni lossy del naming), ordina con `compareSessions`.
+//
+// D1 preflight T175 — restano fuori le conversazioni AVVIATE in una
+// sottocartella, su ogni piattaforma: Claude Code ne scrive il transcript nella
+// cartella che codifica la cwd di avvio, cioè un'altra. Il filtro accetta una
+// cwd sotto la root perché non scarta niente di legittimo, non per raccoglierle.
+export function discoverProjectSessions(projectRoot) {
+    // Keyed sul sessionId: su win32 due cartelle dello stesso progetto potrebbero
+    // portare lo stesso transcript, e due righe con un id solo romperebbero la
+    // selezione. Vince il più recente.
+    const out = new Map();
     const seen = new Set();
-    for (const f of files) {
-        const path = join(dir, f);
-        seen.add(path);
-        let mtime;
-        let sizeBytes;
+    for (const dir of transcriptDirs(projectRoot)) {
+        let files;
         try {
-            const st = statSync(path);
-            mtime = st.mtimeMs;
-            sizeBytes = st.size;
+            files = readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
         }
         catch {
             continue;
         }
-        const cached = cache.get(path);
-        let session;
-        if (cached && cached.mtime === mtime) {
-            session = cached.session;
-        }
-        else {
-            session = parseSessionFile(path, mtime, sizeBytes);
-            cache.set(path, { mtime, session });
-        }
-        if (session && (session.cwd === projectRoot || session.cwd.startsWith(projectRoot + '/'))) {
-            out.push(session);
+        for (const f of files) {
+            const path = join(dir, f);
+            seen.add(path);
+            let mtime;
+            let sizeBytes;
+            try {
+                const st = statSync(path);
+                mtime = st.mtimeMs;
+                sizeBytes = st.size;
+            }
+            catch {
+                continue;
+            }
+            const cached = cache.get(path);
+            let session;
+            if (cached && cached.mtime === mtime) {
+                session = cached.session;
+            }
+            else {
+                session = parseSessionFile(path, mtime, sizeBytes);
+                cache.set(path, { mtime, session });
+            }
+            if (!session || !isWithin(session.cwd, projectRoot))
+                continue;
+            const prev = out.get(session.sessionId);
+            if (!prev || session.ts > prev.ts)
+                out.set(session.sessionId, session);
         }
     }
     for (const key of cache.keys())
         if (!seen.has(key))
             cache.delete(key);
-    out.sort(compareSessions);
-    return out;
+    return [...out.values()].sort(compareSessions);
 }
 // Raggruppa per gitBranch (D2: group-by-branch nel progetto corrente). Ordine
 // dei gruppi = la prima sessione di ciascuno, con `compareSessions`; dentro il

package/dist/spawn.js

@@ -8,6 +8,9 @@ import { dirname, join } from 'node:path';
 // è DATO PURO e non importa questo file: la dipendenza va in un verso solo.
 // Qui restano i soli effetti verso l'esterno — comporre un argv e lanciarlo.
 import { MODEL_DEFAULT, PROJECT_STATUS_MODEL } from './spawn-catalog.js';
+import { isAvailable } from './platform.js';
+import { claudeLauncher } from './claude-cmd.js';
+import { claudeEnv } from './git-bash.js';
 // scripts/deck-run è un sibling della dir del bundle: src/ (dev, tsx) e dist/
 // (build, node) stanno entrambi sotto la package root → risalita di un livello.
 export const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'deck-run');
@@ -27,9 +30,14 @@ export const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scr
  * test misura resta identico.
  */
 export const NO_SPAWN = process.env.LOOM_DECK_NO_SPAWN === '1';
+// T175 — `windowsHide` su OGNI figlio, qui e non a ogni chiamante: su Windows
+// un processo console lanciato senza apre una finestra (un `claude -p`, un
+// `git`), e ogni sede di spawn che la dimenticasse ne farebbe lampeggiare una a
+// ogni giro. Su Linux l'opzione non ha effetto. Un chiamante può ancora
+// sovrascriverla, perché `opts` viene dopo.
 export function spawnOut(cmd, args, opts) {
     if (!NO_SPAWN)
-        return spawn(cmd, args, opts);
+        return spawn(cmd, args, { windowsHide: true, ...opts });
     // Figlio inerte: emette nulla, quindi i `.on('error'|'close')` dei chiamanti
     // restano appesi senza mai scattare — che è esattamente "non è successo niente".
     const fake = new EventEmitter();
@@ -347,8 +355,11 @@ export function spawnTerminal(cwd, title) {
     child.unref();
     return child;
 }
-// Comando claude (override per ambienti dove non è su PATH; loom-deck → NPM).
-export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
+// Il NOME di claude nelle note della riga di stato: l'override se c'è,
+// `claude` altrimenti. Non è ciò che si esegue — quello lo risolve
+// `claudeLauncher` (`claude-cmd.ts`), che su Windows può arrivare a
+// `node …cli.js` da uno shim npm: nelle note resta il nome che l'utente conosce.
+export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD || 'claude';
 // T30: invocazione di una skill del plugin da CC HEADLESS (`-p`), con
 // `--session-id` pinnato. È la TERZA strada per eseguire uno script del plugin
 // da un consumer che non ha `CLAUDE_PLUGIN_ROOT`: il path version-pinned della
@@ -365,7 +376,12 @@ export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
 // ha funzionato" — che su un'operazione distruttiva non basta a sapere se
 // qualcosa è stato rimosso.
 function spawnSkill(prompt, cwd, sessionId, onResult, extraArgs = []) {
-    const child = spawnOut(CLAUDE_CMD, [
+    // T175 — il lanciatore risolto (shim npm compreso, mai una shell) e, su
+    // Windows, l'env col bash di Git: senza, un deck avviato da Git Bash passa al
+    // figlio il `PATH` che manda gli hook del plugin in PowerShell.
+    const claude = claudeLauncher();
+    const child = spawnOut(claude.cmd, [
+        ...claude.prefix,
         '-p',
         '--output-format',
         'stream-json',
@@ -374,7 +390,7 @@ function spawnSkill(prompt, cwd, sessionId, onResult, extraArgs = []) {
         sessionId,
         ...extraArgs,
         prompt,
-    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'], env: claudeEnv() });
     let buf = '';
     let isError = null;
     let detail = '';
@@ -491,7 +507,13 @@ export const NOTIFY_CMD = process.env.LOOM_DECK_NOTIFY_CMD ?? 'notify-send';
 // Agganciato, la degradazione è MUTA (D6): un binario assente è una proprietà
 // stabile della macchina, e dirlo a ogni generazione sarebbe lo stesso messaggio
 // a ogni giro su una funzione che non è il deliverable.
+//
+// T175 — dove le notifiche non ci sono, nessuno spawn e nessun avviso: non
+// hanno un tasto né un pane, e l'esito del project status è già nella riga di
+// stato. Il `null` dice al chiamante che niente è partito.
 export function notifyDone(title, body) {
+    if (!isAvailable('notify'))
+        return null;
     const child = spawnOut(NOTIFY_CMD, ['--app-name=loom-deck', title, body], {
         detached: true,
         stdio: 'ignore',

package/dist/tasks.js

@@ -8,29 +8,16 @@ import { sanitize } from './width.js';
  * divergano (uno accetterebbe righe che l'altro rifiuta).
  */
 export const TASK_ID_RE = /^T\d+$/;
-/**
- * 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()) {
-    return join(cwd, docsRootName(), 'tasks.md');
+// La docs-root arriva dal chiamante, già risolta: la cascata che la sceglie
+// (`docsRootName` in `config.ts`) gira una volta per vita del deck, e i due path
+// qui sotto devono nascere dallo stesso valore che leggono gli scan del modo doc.
+export function resolveTasksPath(cwd, docsRoot) {
+    return join(cwd, docsRoot, '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.
-export function resolveTasksDir(cwd = process.cwd()) {
-    return join(dirname(resolveTasksPath(cwd)), 'tasks');
+// dir dallo stesso path, così le due non possono puntare a docs-root diverse.
+export function resolveTasksDir(cwd, docsRoot) {
+    return join(dirname(resolveTasksPath(cwd, docsRoot)), 'tasks');
 }
 /**
  * Indici di colonna della Tasks Overview letti dall'HEADER, non cablati.

package/dist/ui/doc-pane.js

@@ -20,6 +20,7 @@ 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';
+import { offText } from '../platform.js';
 /**
  * Rientro di un livello dell'albero: UNA colonna, non due.
  *
@@ -53,14 +54,17 @@ export function DocHeader({ counts, active, above, below, focused, columns, hasD
     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, }) {
+export function DocPane({ rows, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, scanning, hasDirs, available = true, }) {
     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 ? (
+    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 }), !available ? (
+            // T175 — gemello del pane inbox: la misura qui non esiste, e va detto
+            // per nome invece di restare su «albero non ancora misurato».
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(offText('pluginScripts', 'albero doc'), width) })) : 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

package/dist/ui/inbox-pane.js

@@ -19,6 +19,7 @@ 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';
+import { offText } from '../platform.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
@@ -43,7 +44,7 @@ export function InboxHeader({ counts, active, above, below, focused, columns, })
  * 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, }) {
+export function InboxPane({ files, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, available = true, }) {
     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
@@ -58,7 +59,11 @@ export function InboxPane({ files, counts, activeView, paneCount, selectedPath,
             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 ? (
+    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 }), !available ? (
+            // T175 — un quarto vuoto, il solo che non è uno stato della coda: la
+            // misura qui non esiste. Va detto per nome, o si leggerebbe come «coda
+            // non ancora misurata» per sempre.
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(offText('pluginScripts', 'coda inbox'), width) })) : 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 è

package/dist/wrap-scan.js

@@ -145,7 +145,7 @@ export async function runWrapScan(projectRoot) {
     if (!script)
         return false;
     try {
-        const { stdout } = await execFileAsync('python3', [script, '--root', projectRoot, '--scan'], { cwd: projectRoot, maxBuffer: 16 * 1024 * 1024 });
+        const { stdout } = await execFileAsync('python3', [script, '--root', projectRoot, '--scan'], { cwd: projectRoot, maxBuffer: 16 * 1024 * 1024, windowsHide: true });
         const path = wrapCacheFile(projectRoot);
         mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
         writeFileSync(path, stdout, { mode: 0o600 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.74.0",
+  "version": "0.76.0",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
   "scripts": {
     "dev": "tsx src/cli.tsx",
     "build": "tsc",
-    "test": "tsx --test test/*.test.ts",
+    "test": "node test/run.mjs",
     "start": "node dist/cli.js",
     "prepare": "tsc"
   },

package/dist/overlays/inbox.js

@@ -1,90 +0,0 @@
-// 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 è `MODEL_DEFAULT` 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 };
-}

package/dist/ui/inbox-screen.js

@@ -1,21 +0,0 @@
-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)) })] }) })] }));
-}