@lamemind/loom-deck 0.56.1 → 0.57.0

package/dist/actions.js

@@ -21,7 +21,7 @@ import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, } from '
 import { neighborId } from './session-list.js';
 import { cut, cutMiddle } from './width.js';
 import { saveView, viewFilePath } from './view-store.js';
-import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
+import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
 import { useTaskOps } from './task-ops.js';
 export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNote, }) {
     // La riga di stato di OGNI spawn di sessione Claude: il comando esatto, come
@@ -239,6 +239,37 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
         child.on('error', () => setNote('⚠ t → ptyxis non lanciabile'));
         setNote(`t → terminale su ${model.projectName}`);
     }
+    /**
+     * T134 — apre la sessione PRESIDIATA che drena un file inbox.
+     *
+     * Il prompt arriva già composto dall'overlay (`inboxPrompt`), che è l'unico
+     * posto in cui vive la mappa natura → skill: derivarlo qui una seconda volta
+     * darebbe due tabelle capaci di divergere, e la seconda si scoprirebbe solo
+     * il giorno in cui una natura nuova apre la skill sbagliata.
+     *
+     * Sessione NUDA e modello esplicito: il drain lavora sulla doc, non sulla
+     * task (D10 preflight), e `opus` passa nell'argv anche essendo il default,
+     * come `permissionMode`.
+     */
+    function drainInbox(file, prompt) {
+        const spawned = spawnBare(cwd, prompt, MODEL_DEFAULT);
+        spawned.child.on('error', () => setNote(`⚠ drain ${file.basename} fallito (${DECK_RUN})`));
+        noteSpawn(spawned);
+    }
+    /**
+     * T134 — apre la sessione che SROTOLA l'hard-wrap di un path.
+     *
+     * `sonnet` e non il default (D9): lo srotolamento è una passata meccanica con
+     * un verificatore deterministico dietro (`md-wrap --apply` confronta le due
+     * versioni normalizzate `\s+ → spazio` e rimette indietro il file se
+     * differiscono), quindi il giudizio richiesto al modello è leggere un diff e
+     * decidere se committarlo — non progettare niente.
+     */
+    function unwrapPath(path, prompt) {
+        const spawned = spawnBare(cwd, prompt, 'sonnet');
+        spawned.child.on('error', () => setNote(`⚠ srotolamento ${path} fallito (${DECK_RUN})`));
+        noteSpawn(spawned);
+    }
     /** `c` — sessione claude a mani nude, senza task e senza prompt. */
     function openClaude() {
         const spawned = spawnClaudeEmpty(cwd);
@@ -283,6 +314,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
         assignSession,
         forkSession,
         togglePin,
+        drainInbox,
+        unwrapPath,
         openTerminal,
         openClaude,
         saveCurrentView,

package/dist/cli.js

@@ -19,7 +19,7 @@ import { resolveTasksPath, resolveTasksDir } from './tasks.js';
 import { LAUNCH_SEP } from './config.js';
 import { anchorFrame, enableMouse } from './mouse.js';
 import { sanitize } from './width.js';
-import { deckLegend, frameGeometry, headlineWidth, launchRow } from './frame.js';
+import { deckLegend, frameGeometry, headlineWidth, indicatorRow, launchRow } from './frame.js';
 import { useDeckModel } from './deck-model.js';
 import { useDeckActions } from './actions.js';
 import { useDeckInput } from './input.js';
@@ -27,12 +27,14 @@ import { useSearchOverlay } from './overlays/search.js';
 import { useSheetOverlay } from './overlays/sheet.js';
 import { useAssignOverlay } from './overlays/assign.js';
 import { useProjectStatus } from './overlays/status.js';
+import { useInboxOverlay } from './overlays/inbox.js';
+import { useWrapOverlay } from './overlays/wrap.js';
 import { usePurgeOverlay } from './overlays/purge.js';
 import { useTextModals, useViewModals } from './overlays/modals.js';
 import { useTerminalSize } from './hooks.js';
 import { EditModal, FilterModal, PurgeModal, SortModal } from './ui/modals.js';
 import { StatusHeadline } from './ui/status-screen.js';
-import { SessionsPane, TasksPane } from './ui/panes.js';
+import { InboxPane, SessionsPane, TasksPane } from './ui/panes.js';
 import { PreviewPane, detailMetaOf } from './ui/preview.js';
 import { CompactNotice, HintBar, TextBox, screenFor } from './ui/screens.js';
 import { VERSION } from './version.js';
@@ -84,6 +86,25 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         setMode,
         setNote,
     });
+    // T134 — il detail di un file inbox. Come lo sheet della task riceve lo spawn
+    // come callback: un hook di overlay non esce dal deck.
+    const inbox = useInboxOverlay({
+        rows,
+        columns,
+        setMode,
+        setNote,
+        onDrain: actions.drainInbox,
+    });
+    // T134 — l'hard-wrap. Come il project status non è solo un overlay: i suoi
+    // numeri si leggono in testata a schermata chiusa, e la lista è una delle sue
+    // superfici invece che il suo contenuto.
+    const wrap = useWrapOverlay({
+        cwd,
+        rows,
+        setMode,
+        setNote,
+        onApply: actions.unwrapPath,
+    });
     const purge = usePurgeOverlay({
         setMode,
         setNote,
@@ -106,7 +127,17 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         editDraftFor: actions.editDraftFor,
         currentNote: (sid) => model.sessionNotes.get(sid) ?? '',
     });
-    const overlays = { assign, sheet, search, status, purge, view: viewModals, text: textModals };
+    const overlays = {
+        assign,
+        sheet,
+        search,
+        status,
+        inbox,
+        wrap,
+        purge,
+        view: viewModals,
+        text: textModals,
+    };
     // T70 — un solo blocco preview, sotto i due pane, e il FOCUS decide cosa
     // contiene: a sinistra la task selezionata, a destra la conversazione. È il
     // focus e non la selezione perché il blocco è uno — averne due significava
@@ -118,11 +149,27 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         ? model.detail
             ? 'task'
             : 'none'
-        : model.selSessionObj
-            ? 'session'
-            : 'none';
+        : model.focus === 'inbox'
+            ? model.selInbox
+                ? 'inbox'
+                : 'none'
+            : model.selSessionObj
+                ? 'session'
+                : 'none';
     const detailParts = model.detail ? detailMetaOf(model.detail) : null;
     const launch = launchRow(model.launch, columns);
+    // T134 — gli indicatori ancorati a destra della riga legenda. Si compongono
+    // PRIMA della legenda perché è la loro larghezza a decidere quanto ne resta:
+    // hanno la precedenza sul budget (D5 preflight).
+    const indicators = indicatorRow({
+        inbox: {
+            counts: model.inboxCounts,
+            stale: model.inboxStale,
+            scanned: model.inboxScanned,
+            ok: model.inboxOk,
+        },
+        wrap: { count: wrap.count, mtime: wrap.mtime, ok: wrap.ok, scanning: wrap.scanning },
+    }, columns);
     const frame = frameGeometry({
         rows,
         columns,
@@ -142,8 +189,14 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         sessionViewId: model.sessionViewId,
         parentLabel: model.parentLabel,
         hasLoadError: Boolean(model.loadError),
+        rightPane: model.rightPane,
+        inboxFiles: model.inboxFiles,
+        selInboxPath: model.selInboxPath,
+        inboxCounts: model.inboxCounts,
+        inboxViewId: model.inboxViewId,
     });
     useDeckInput({
+        cwd,
         tasksDir,
         mode,
         setMode,
@@ -153,8 +206,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         overlays,
         frame,
         launchRegions: launch.regions,
+        indicatorRegions: indicators.regions,
     });
-    // Le cinque schermate sostitutive prendono il frame intero: se una è attiva
+    // Le sei schermate sostitutive prendono il frame intero: se una è attiva
     // il render finisce qui, e il budget dei pane resta calcolato ma inutilizzato.
     const screen = screenFor({
         mode,
@@ -169,7 +223,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         projectName: model.projectName,
         taskRowData: model.taskRowData,
         hiddenTasks: model.hiddenTasks,
-        overlays: { assign, sheet, search, status },
+        overlays: { assign, sheet, search, status, inbox, wrap },
     });
     if (screen)
         return screen;
@@ -185,7 +239,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     hasSession: model.selSessionObj !== null,
                     hasSessionId: model.selSessionId !== null,
                     purgeBulk: model.purgeBulk,
-                }) }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData }), _jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live })] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+                    inboxPane: model.rightPane === 'inbox',
+                    hasInbox: model.selInbox !== null,
+                }), indicators: indicators, columns: columns }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData }), model.rightPane === 'inbox' ? (_jsx(InboxPane, { files: frame.windowInbox, counts: model.inboxCounts, activeView: model.inboxViewId, paneCount: model.inboxFiles.length, selectedPath: model.selInboxPath, focused: model.focus === 'inbox', above: frame.inboxWin.start, below: model.inboxFiles.length - frame.inboxWin.end, columns: columns, ok: model.inboxOk, scanned: model.inboxScanned })) : (_jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live }))] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'inbox' && model.selInbox ? (_jsx(PreviewPane, { kind: "inbox", file: model.selInbox, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const cwd = process.cwd();
 // T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,

package/dist/deck-model.js

@@ -14,7 +14,10 @@
 // la ragione per cui i loro conti di parametri restano leggibili.
 import { useEffect, useMemo, useState } from 'react';
 import { loadArchivableDays, loadIdentity, loadLaunch } from './config.js';
-import { useArchivable, useDirtyFolders, useSessions, useTaskDetail, useTasks, } from './hooks.js';
+import { useArchivable, useDirtyFolders, useInboxScan, useSessions, useTaskDetail, useTasks, } from './hooks.js';
+import { DEFAULT_INBOX_STALE_HOURS, staleCount } from './inbox.js';
+import { cycleInboxView, inboxCounts as deriveInboxCounts, inboxView, selectInboxRows, } from './inbox-views.js';
+import { docsRootName } from './tasks.js';
 import { isDone } from './layout.js';
 import { TASK_EMPTY, relTime } from './glyphs.js';
 import { assembleSessionList, firstSelectableId, rowIndexOf, selectedSession, } from './session-list.js';
@@ -133,6 +136,15 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // riaperta a freddo si legge come la lista intera.
     const [taskViewId, setTaskViewId] = useState('tasks');
     const [sessionViewId, setSessionViewId] = useState('context');
+    // T134 — quale pane occupa lo slot destro, e la vista attiva di quello inbox.
+    // Volatili entrambi (D6 preflight): il deck riapre sempre sulle sessioni.
+    const [rightPane, setRightPane] = useState('sessions');
+    const [inboxViewId, setInboxViewId] = useState('all');
+    // Selezione KEYED SUL PATH, mai su indice: la lista si riordina sotto le
+    // viste e si accorcia a ogni scan, e un indice grezzo punterebbe alla riga
+    // sbagliata in silenzio (stessa trappola di T39 sulle task e T50 sulle
+    // conversazioni).
+    const [selInboxPath, setSelInboxPath] = useState(null);
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
     const launch = useMemo(() => loadLaunch(cwd), [cwd]);
     // Identità (T37): titolo delle tab terminale spawnate col tasto `t`.
@@ -162,6 +174,19 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // una task sola e il dato lo ricalcola al momento.
     const archivableSig = useMemo(() => [...archivable].sort().join(','), [archivable]);
     const dirtyFolders = useDirtyFolders(archivableSig, tasksDir, cwd);
+    // T134 — terzo scan della famiglia (D1): coda inbox per natura, età del più
+    // vecchio. La docs-root arriva dalla sola env, come `resolveTasksPath` — il
+    // limite si eredita invece di aprire qui una cascata che nessun percorso di
+    // avvio reale userebbe (D1 preflight).
+    const docsRoot = useMemo(() => docsRootName(), []);
+    const inbox = useInboxScan(cwd, docsRoot);
+    const inboxCounts = useMemo(() => deriveInboxCounts(inbox.files), [inbox.files]);
+    // Il numero accanto alla sirena: solo i file in coda oltre soglia. `Date.now()`
+    // letto a ogni render e non memoizzato — è una sottrazione, e congelarlo
+    // lascerebbe la sirena ferma sull'ora dello scan invece che sull'ora corrente.
+    const inboxStale = staleCount(inbox.files, DEFAULT_INBOX_STALE_HOURS, Date.now());
+    const inboxFiles = useMemo(() => selectInboxRows(inboxViewId, inbox.files), [inboxViewId, inbox.files]);
+    const selInbox = inboxFiles.find((f) => f.path === selInboxPath) ?? null;
     // T100 — le task effettivamente a schermo: la vista principale coincide con
     // `viewTasks` (nessun ricalcolo sul cammino di default), le altre due passano
     // dal predicato del catalogo. I CONTATORI restano misurati sulla vista di
@@ -245,6 +270,17 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
             setSelSessionId(firstSelectableId(sessionRows));
         }
     }, [sessionRows, selSessionId]);
+    // T134 — gemello dei due sopra: un file drenato sparisce dalla coda al primo
+    // scan successivo, e la selezione cade sulla prima riga della lista invece
+    // che su una posizione a caso.
+    useEffect(() => {
+        if (selInboxPath !== null && !inboxFiles.some((f) => f.path === selInboxPath)) {
+            setSelInboxPath(inboxFiles[0]?.path ?? null);
+        }
+        else if (selInboxPath === null && inboxFiles.length > 0) {
+            setSelInboxPath(inboxFiles[0].path);
+        }
+    }, [inboxFiles, selInboxPath]);
     /** Selezione per INDICE nella vista, riconvertita subito in sentinella o id.
      *  T21 — la chiama anche il click su una riga del pane task. */
     function selectTaskRow(index) {
@@ -285,12 +321,58 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // parent delle sessioni che torna a `tutte` è un effetto accettato); sul pane
     // sessioni basta invalidare l'id, e l'effect di validità atterra sulla prima
     // riga selezionabile della vista nuova.
+    function selectInboxView(next) {
+        if (next === inboxViewId)
+            return;
+        setInboxViewId(next);
+        setSelInboxPath(null);
+        setNote(`vista inbox: ${inboxView(next).label(inboxCounts)}`);
+    }
     function cycleView(delta) {
         if (focus === 'tasks')
             selectTaskView(cycleTaskView(taskViewId, delta));
+        else if (focus === 'inbox')
+            selectInboxView(cycleInboxView(inboxViewId, delta));
         else
             selectSessionView(cycleSessionView(sessionViewId, delta));
     }
+    /** Selezione per INDICE nella finestra visibile: la chiama il click. */
+    function selectInboxRow(index) {
+        const f = inboxFiles[index];
+        if (f)
+            setSelInboxPath(f.path);
+    }
+    function moveInboxSel(delta) {
+        const at = inboxFiles.findIndex((f) => f.path === selInboxPath);
+        if (inboxFiles.length === 0)
+            return;
+        const next = Math.max(0, Math.min(inboxFiles.length - 1, (at < 0 ? 0 : at) + delta));
+        setSelInboxPath(inboxFiles[next].path);
+    }
+    /**
+     * T134 — `^B` scambia i due pane dello slot destro (D8 preflight).
+     *
+     * Il FOCUS segue il pane: chi stava guardando a destra continua a guardare a
+     * destra, ma quello che c'è adesso è l'altro pane. Lasciarlo su `sessions`
+     * con l'inbox montato darebbe un focus su un pane che non è a schermo, e le
+     * azioni della lista sessioni resterebbero attive su una selezione invisibile.
+     */
+    function toggleInboxPane() {
+        const next = rightPane === 'inbox' ? 'sessions' : 'inbox';
+        setRightPane(next);
+        setFocus((f) => (f === 'tasks' ? f : next));
+        setNote(next === 'inbox' ? '^B → pane inbox' : '^B → pane sessioni');
+    }
+    /** `esc` in vista normale: torna alle sessioni. Solo in quel verso — `esc`
+     *  dice «esci da dove sei», e sulle sessioni non c'è più niente da cui uscire
+     *  (il tasto resta inerte, come è sempre stato). */
+    function closeInboxPane() {
+        if (rightPane !== 'inbox')
+            return false;
+        setRightPane('sessions');
+        setFocus((f) => (f === 'inbox' ? 'sessions' : f));
+        return true;
+    }
     return {
         // fonti
         tasks,
@@ -338,11 +420,26 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         sessionCounts,
         selSessionObj,
         sessionCols,
+        // derivazioni del pane inbox
+        rightPane,
+        inboxScanned: inbox.scanned,
+        inboxOk: inbox.ok,
+        inboxViewId,
+        inboxCounts,
+        inboxStale,
+        inboxFiles,
+        selInboxPath,
+        selInbox,
         // mutatori di navigazione
         selectTaskRow,
         moveTaskSel,
         selectTaskView,
         selectSessionView,
+        selectInboxView,
+        selectInboxRow,
+        moveInboxSel,
+        toggleInboxPane,
+        closeInboxPane,
         cycleView,
     };
 }

package/dist/frame.js

@@ -15,11 +15,13 @@
 // leggeva dichiarata seicento righe più in basso. Il costo è calcolare il
 // budget anche quando il render esce presto su una schermata sostitutiva:
 // aritmetica su array già in memoria, e `layoutBudget` accetta ogni `Mode`.
-import { headerItems, sessionHeaderParts, taskHeaderParts } from './pane-header.js';
-import { FRAME_TEXT_COL, inlineRegions, LAUNCH_ROW, PANE_TEXT_PAD, paneSpans, rowRegions, } from './mouse.js';
+import { headerItems, inboxHeaderParts, sessionHeaderParts, taskHeaderParts } from './pane-header.js';
+import { FRAME_TEXT_COL, HINT_ROW, inlineRegions, LAUNCH_ROW, PANE_TEXT_PAD, paneSpans, rowRegions, } from './mouse.js';
 import { cellWidth, launchLegend, LAUNCH_SEP } from './config.js';
 import { layoutBudget, windowRange } from './viewport.js';
 import { sanitize, termWidth } from './width.js';
+import { WARN } from './glyphs.js';
+import { STATUS_MISSING } from './project-status.js';
 import { META_ROWS } from './model.js';
 import { rowIndexOf } from './session-list.js';
 import { VERSION } from './version.js';
@@ -53,11 +55,18 @@ export const SURFACE_SEGMENTS = [
 export function deckLegend(state) {
     const canSpawn = state.focus === 'tasks' && state.hasTask;
     const canResume = state.focus === 'sessions' && state.hasSession;
+    const canOpenInbox = state.focus === 'inbox' && state.hasInbox;
     // T50 — il pin agisce su qualunque riga selezionata (anche stale, per
     // spinnarla); basta il focus sul pane e una selezione.
     const canPin = state.focus === 'sessions' && state.hasSessionId;
     return sanitize([
-        ...(canSpawn ? ['⏎ detail', '^K/^P/^R spawn'] : canResume ? ['⏎ resume'] : []),
+        ...(canSpawn
+            ? ['⏎ detail', '^K/^P/^R spawn']
+            : canResume
+                ? ['⏎ resume']
+                : canOpenInbox
+                    ? ['⏎ apri']
+                    : []),
         // T112 — la voce nomina il BERSAGLIO, che cambia di taglia senza che
         // cambi il tasto. Legge `purgeBulk`, la stessa condizione del ramo di
         // apertura: una legenda che annunciasse «tutte» dove il tasto ne pota una
@@ -74,6 +83,11 @@ export function deckLegend(state) {
         // cosa e sta a due voci di distanza.
         '^G genera status',
         '^O apri status',
+        // T134 — la voce nomina il pane che il tasto MONTA, non quello montato:
+        // `^B` scambia i due, e annunciare quello che si sta già guardando
+        // direbbe il contrario di ciò che il tasto fa. Stessa regola di `CANC
+        // elimina tutte`, che nomina il bersaglio e non il tasto.
+        state.inboxPane ? '^B sessioni' : '^B inbox',
         '^F cerca',
         'C nuova',
         'E edit',
@@ -105,6 +119,87 @@ export function launchRow(launch, columns) {
         unreachable: legend.unreachable,
     };
 }
+/**
+ * T134 — gli INDICATORI ancorati a destra della riga legenda: dato, non
+ * stringa, per la stessa ragione della riga launch (`launchRow`). Gli stessi
+ * segmenti compongono il testo disegnato e le colonne dell'hit-test, e chi
+ * derivasse le seconde ri-splittando il primo terrebbe due conti che divergono
+ * alla prima etichetta che contiene il separatore.
+ *
+ * `key` è la COMBO che l'indicatore rappresenta, col prefisso `^`: il click non
+ * chiama l'azione, rientra dalla porta della tastiera premendola. È lo stesso
+ * schema delle superfici launch, esteso ai `ctrl` — senza il prefisso il click
+ * sintetizzerebbe una lettera nuda, che su questa tastiera fa un'altra cosa.
+ */
+export const INDICATOR_SEP = '  ';
+/**
+ * Il bottone che monta il pane inbox: `[ Inbox 📄 3/1/2 🚨2 ]`.
+ *
+ * SEMPRE ACCESO, mai grigio (D7): è un pane, non un sottoinsieme che può essere
+ * vuoto. I tre numeri sono le tre nature nell'ordine del catalogo; la sirena e
+ * il suo contatore compaiono solo sopra la soglia.
+ *
+ * Prima del primo scan i numeri non esistono ancora, e stampare `0/0/0`
+ * direbbe «ho misurato e non c'è niente» — cioè la cosa sbagliata (D2
+ * preflight: `missing` e guasto sono stati distinti). Il glifo di allerta si
+ * AGGIUNGE ai numeri invece di sostituirli: un tentativo fallito lascia in
+ * piedi l'esito dell'ultimo riuscito, che resta vero e ancora apribile.
+ */
+export function inboxButton(state) {
+    const numbers = state.scanned
+        ? `${state.counts.nozioni}/${state.counts.derivazione}/${state.counts.sweep}`
+        : STATUS_MISSING;
+    const siren = state.stale > 0 ? ` 🚨${state.stale}` : '';
+    const warn = state.ok ? '' : ` ${WARN}`;
+    return sanitize(`[ Inbox 📄 ${numbers}${siren}${warn} ]`);
+}
+/**
+ * L'indicatore hard-wrap: `wrap 77`.
+ *
+ * Etichetta a PAROLA e non un glifo, dopo una misura sotto pty: `〰` (U+3030)
+ * passa il controllo di concordanza di `width.ts` — `string-width` e la nostra
+ * tabella EAW dicono entrambe 2 — ma dentro il frame Ink emette una colonna in
+ * meno di quante ne conta, e la riga esce larga `columns - 1` col bordo
+ * mangiato. È un terzo caso oltre alle due invarianti note: `agrees()` confronta
+ * due LIBRERIE, e un glifo può ingannarle entrambe insieme. Chi volesse
+ * rimettere un simbolo qui lo misuri sul frame vero, non su `agrees`.
+ *
+ * Conta i soli `WRAP` (D4). `misto` compare in lista con un marker proprio ma
+ * resta fuori: è la classe che ospita il falso allarme noto — i file di note
+ * scritte una riga per pensiero, che nessuno vuole srotolare — e sommarlo
+ * darebbe un numero che non si può portare a zero. Un contatore che non arriva
+ * mai a zero smette di essere letto.
+ *
+ * Tre stati distinti, come per il project status: `missing` quando lo scan non
+ * è mai stato eseguito (non parte all'avvio, D4), `scan…` mentre cammina
+ * l'albero, il numero altrimenti. Il glifo di allerta si AGGIUNGE al numero
+ * invece di sostituirlo — un tentativo fallito non riscrive la cache, quindi
+ * l'esito dell'ultimo riuscito resta vero e ancora apribile.
+ */
+export function wrapIndicator(state) {
+    const body = state.scanning
+        ? 'scan…'
+        : state.mtime === null
+            ? STATUS_MISSING
+            : String(state.count);
+    return sanitize(`wrap ${body}${state.ok ? '' : ` ${WARN}`}`);
+}
+export function indicatorRow(state, columns) {
+    // Ordine di lettura: l'indicatore, poi il bottone. Il bottone sta all'estremo
+    // destro perché è l'unico dei due che MONTA qualcosa restando in vista
+    // normale — la lista del wrap è una schermata che si apre e si chiude.
+    const segments = [
+        { key: '^w', text: wrapIndicator(state.wrap) },
+        { key: '^b', text: inboxButton(state.inbox) },
+    ];
+    const text = segments.map((s) => s.text).join(INDICATOR_SEP);
+    const width = termWidth(text);
+    // Ancorato al bordo destro del box esterno: il blocco è renderizzato da un
+    // `justifyContent="space-between"`, quindi la sua prima colonna si ricava per
+    // sottrazione e non da un accumulo da sinistra.
+    const start = FRAME_TEXT_COL + Math.max(0, (columns || 80) - 4) - width;
+    return { segments, text, regions: rowRegions(segments, INDICATOR_SEP, start), width };
+}
 /**
  * Il budget d'altezza e le finestre di rendering.
  *
@@ -139,6 +234,11 @@ export function frameGeometry(input) {
     const selRowIndex = rowIndexOf(input.sessionRows, input.selSessionId);
     const sessionWin = windowRange(input.sessionRows.length, selRowIndex, budget.sessionRows);
     const windowRows = input.sessionRows.slice(sessionWin.start, sessionWin.end);
+    // Stessa capienza del pane sessioni: i due hanno la stessa cornice e uno solo
+    // dei due è montato (vedi SESSIONS_PANE_CHROME in viewport.ts).
+    const selInboxIndex = input.inboxFiles.findIndex((f) => f.path === input.selInboxPath);
+    const inboxWin = windowRange(input.inboxFiles.length, selInboxIndex, budget.sessionRows);
+    const windowInbox = input.inboxFiles.slice(inboxWin.start, inboxWin.end);
     // T21 — geometria delle liste per l'hit-test del click, dalla STESSA
     // aritmetica che disegna i pane: le parti degli header escono dal modulo che
     // `ui/panes.tsx` consuma per renderle, le righe cliccabili sono le finestre
@@ -150,10 +250,13 @@ export function frameGeometry(input) {
             columns: input.columns,
             taskHeader: inlineRegions(headerItems(taskHeaderParts(input.taskCounts, input.taskViewId, taskWin.start, input.paneTasks.length - taskWin.end, input.columns)), spans.tasks.start + PANE_TEXT_PAD),
             sessionHeader: inlineRegions(headerItems(sessionHeaderParts(input.parentLabel, input.sessionCounts, input.sessionViewId, sessionWin.start, input.sessionRows.length - sessionWin.end, input.columns)), spans.sessions.start + PANE_TEXT_PAD),
+            inboxHeader: inlineRegions(headerItems(inboxHeaderParts(input.inboxCounts, input.inboxViewId, inboxWin.start, input.inboxFiles.length - inboxWin.end, input.columns)), spans.sessions.start + PANE_TEXT_PAD),
             // Con un errore di caricamento al posto delle task c'è la riga rossa:
             // restano cliccabili le sole righe meta.
             taskRows: META_ROWS + (input.hasLoadError ? 0 : windowTasks.length),
             sessionRows: windowRows.length,
+            inboxRows: windowInbox.length,
+            rightPane: input.rightPane,
         };
     return {
         budget,
@@ -161,6 +264,8 @@ export function frameGeometry(input) {
         windowTasks,
         sessionWin,
         windowRows,
+        inboxWin,
+        windowInbox,
         listGeometry,
         // Dimensione del terminale in CELLE (colonne×righe, mai pixel — un processo
         // dentro un terminale vede solo la griglia di caratteri) e versione. La
@@ -175,4 +280,17 @@ export function frameGeometry(input) {
 export function headlineWidth(columns, headerRight) {
     return Math.max(4, columns - 4 - termWidth(headerRight) - 1);
 }
-export { LAUNCH_ROW };
+/**
+ * T134 — il budget della legenda tasti, per sottrazione del blocco indicatori
+ * che le sta a destra sulla stessa riga.
+ *
+ * La legenda cede per prima (D5 preflight): è già troncabile per costruzione e
+ * ciò che perde si ricorda, mentre un contatore troncato mente. Pavimento a 4
+ * come la testata — sotto quella soglia non resta comunque niente di leggibile,
+ * e un budget negativo farebbe tornare `cut` una stringa vuota per il tramite
+ * di un numero che nessuno ha scelto.
+ */
+export function legendWidth(columns, indicatorW) {
+    return Math.max(4, (columns || 80) - 4 - indicatorW - termWidth(INDICATOR_SEP));
+}
+export { HINT_ROW, LAUNCH_ROW };

package/dist/glyphs.js

@@ -71,6 +71,30 @@ export function modelShort(id) {
 export const LIVE_IDLE = '●';
 export const LIVE_BUSY = '◍';
 export const LIVE_NONE = ' ';
+/**
+ * T134 — colonna di stato della riga inbox, larga 2 come la cella marker della
+ * lista sessioni.
+ *
+ * `held` non ha glifo, e non è una dimenticanza: un file senza il token
+ * `drainable` resta eseguibile se qualcuno lo nomina, quindi ogni simbolo di
+ * divieto direbbe una cosa più forte del vero. L'assenza dice «non è in coda»
+ * senza promettere altro, e la colonna natura accanto continua a nominarlo.
+ *
+ * Nessun glifo è riusato dalla lista sessioni con un significato spostato: là
+ * `●`/`◍` dicono la liveness di un processo e `📌`/`🔗`/`○` l'appartenenza,
+ * qui si parla di una coda di lavoro. Un falso amico costa più di un simbolo
+ * nuovo.
+ */
+export const INBOX_MARK = {
+    broken: WARN,
+    branched: sanitize('🔒'),
+    held: '',
+    queued: sanitize('⏳'),
+};
+/** Larghezza della cella marker della riga inbox, gemella dei 2 della lista
+ *  sessioni: la cella si riempie di spazi anche quando è vuota, o le righe
+ *  `held` sposterebbero a sinistra tutto ciò che segue. */
+export const INBOX_MARK_W = 2;
 // Marker Done per il DISPLAY. `task.prog` resta il `✔️` letto da tasks.md —
 // `isDone()` e le lookup di `view.ts` ci confrontano sopra, e `task-edit` lo
 // riscrive sul file: è una chiave semantica, non testo. Qui `sanitize` lo