@lamemind/loom-deck 0.70.0 → 0.71.0

package/dist/frame.js

@@ -15,7 +15,7 @@
 // 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, inboxHeaderParts, sessionHeaderParts, taskHeaderParts } from './pane-header.js';
+import { docHeaderParts, 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';
@@ -23,6 +23,7 @@ import { sanitize, termWidth } from './width.js';
 import { MODEL_SHORT_LIST, WARN } from './glyphs.js';
 import { STATUS_MISSING } from './project-status.js';
 import { META_ROWS } from './model.js';
+import { TASK_MODE_LEGEND } from './input-modes.js';
 import { rowIndexOf } from './session-list.js';
 import { VERSION } from './version.js';
 // La surface built-in del cappello, in testa alla riga launch. Non sta fra i
@@ -79,6 +80,7 @@ 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;
+    const canOpenDoc = state.focus === 'doctree' && state.hasDoc;
     // 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;
@@ -87,7 +89,7 @@ export function deckLegend(state) {
             ? ['⏎ detail', '^K/^P/^R spawn']
             : canResume
                 ? ['⏎ resume']
-                : canOpenInbox
+                : canOpenInbox || canOpenDoc
                     ? ['⏎ apri']
                     : []),
         // T112 — la voce nomina il BERSAGLIO, che cambia di taglia senza che
@@ -112,21 +114,27 @@ export function deckLegend(state) {
         // T155 — la voce nomina il GESTO, come le due sopra: «gitlink» da solo
         // direbbe l'oggetto e non che il tasto lo allinea con un commit.
         ...(state.gitlink ? ['^U bumpa gitlink'] : []),
-        // 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',
+        // T160 — la voce nomina il MODO che il tasto monta, non quello montato:
+        // `^B` li scambia, 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.docMode ? '^B task' : '^B doc',
         // T161 — la voce nomina l'OGGETTO e non il gesto, al contrario di `^G`/
         // `^O`/`^U`: lì il tasto fa qualcosa (genera, bumpa) e il nome dell'oggetto
         // da solo sarebbe ambiguo, qui apre una pagina e basta.
         '^S azioni',
         '^F cerca',
-        'C nuova',
-        'E edit',
-        'S sort',
-        'F filtri',
-        'w salva',
+        // T160 — le voci dei tasti del mondo task vengono dall'ELENCO che governa
+        // anche il dispatch (`input-modes.ts` §TASK_MODE_KEYS), non da cinque
+        // stringhe scritte qui: due elenchi divergono al primo tasto aggiunto, e
+        // il tasto nuovo resterebbe annunciato mentre è inerte — cioè una legenda
+        // che descrive un deck che non esiste.
+        //
+        // In modo doc spariscono tutte. Le altre voci del mondo task (`⏎ detail`,
+        // `^K/^P/^R spawn`, `CANC elimina`) non sono qui perché sono già
+        // condizionate dal focus, che in modo doc non è mai `tasks`: spariscono da
+        // sé, senza una seconda guardia.
+        ...(state.docMode ? [] : TASK_MODE_LEGEND),
     ].join(' · '));
 }
 /**
@@ -191,17 +199,28 @@ export function launchRow(launch, columns) {
  */
 export const INDICATOR_SEP = '  ';
 /**
- * Il bottone che monta il pane inbox: `[ Inbox 📄 3/1/2 🚨2 ]`.
+ * Il bottone che monta il modo doc: `[ Doc 📄 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.
+ * T160/P4 — nomina il MODO, non più il solo pane inbox di T134, perché è quello
+ * che `^B` monta adesso. I contatori restano quelli dell'inbox e non ne
+ * guadagnano di doc: un contatore dei flag doc obbligherebbe a tenere lo scan da
+ * quattro secondi acceso anche in modo task, cioè a pagarlo quando nessuno
+ * guarda l'albero — l'opposto dell'interruttore di `useDocScan`.
  *
- * 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.
+ * SEMPRE ACCESO, mai grigio (D7 di T134): è un modo, 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.
+ *
+ * Il nome non si scambia col modo montato, a differenza della voce di legenda
+ * qui sopra: il bottone porta i contatori della coda inbox, che vive in modo
+ * doc, quindi è l'etichetta di quel mondo — e un `[ Task 📄 3/1/2 ]` leggerebbe
+ * quei tre numeri come se fossero delle task.
+ *
+ * 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
@@ -209,7 +228,7 @@ export function inboxButton(state) {
         : STATUS_MISSING;
     const siren = state.stale > 0 ? ` 🚨${state.stale}` : '';
     const warn = state.ok ? '' : ` ${WARN}`;
-    return sanitize(`[ Inbox 📄 ${numbers}${siren}${warn} ]`);
+    return sanitize(`[ Doc 📄 ${numbers}${siren}${warn} ]`);
 }
 /**
  * L'indicatore hard-wrap: `wrap 77`.
@@ -333,6 +352,9 @@ export function frameGeometry(input) {
     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);
+    const selDocIndex = input.docRows.findIndex((r) => r.path === input.selDocPath);
+    const docWin = windowRange(input.docRows.length, selDocIndex, budget.sessionRows);
+    const windowDoc = input.docRows.slice(docWin.start, docWin.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
@@ -345,12 +367,16 @@ export function frameGeometry(input) {
             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),
+            // Il pane doc occupa lo slot SINISTRO, quindi le sue regioni partono
+            // dallo span del pane task — la posizione è del lato, non del contenuto.
+            docHeader: inlineRegions(headerItems(docHeaderParts(input.docCounts, input.docViewId, docWin.start, input.docRows.length - docWin.end, input.columns, input.docHasDirs)), spans.tasks.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,
+            docRows: windowDoc.length,
+            mode: input.deckMode,
         };
     return {
         budget,
@@ -360,6 +386,8 @@ export function frameGeometry(input) {
         windowRows,
         inboxWin,
         windowInbox,
+        docWin,
+        windowDoc,
         listGeometry,
         // Dimensione del terminale in CELLE (colonne×righe, mai pixel — un processo
         // dentro un terminale vede solo la griglia di caratteri) e versione. La

package/dist/hooks.js

@@ -14,6 +14,7 @@ import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
 import { commitTimes } from './commit-times.js';
 import { scanEpicHierarchy, EMPTY_EPIC_HIERARCHY } from './epic-hierarchy.js';
 import { scanInbox, INBOX_SCAN_INTERVAL_MS } from './inbox.js';
+import { scanDocTree, DOC_SCAN_INTERVAL_MS } from './doc-tree.js';
 import { mixedCount, readWrapCache, runWrapScan, wrapCacheFile, wrapCount, } from './wrap-scan.js';
 import { purgeTargets } from './purge.js';
 import { loadSpawnOverrides, saveSpawnOverrides, } from './spawn-config.js';
@@ -381,6 +382,50 @@ export function useInboxScan(projectRoot, docsRoot) {
     }, []);
     return { ...state, scan };
 }
+export function useDocScan(projectRoot, docsRoot, enabled) {
+    const [state, setState] = useState({
+        files: [],
+        dirs: [],
+        hasDirs: false,
+        ok: true,
+        scanned: false,
+        scanning: false,
+    });
+    const [epoch, setEpoch] = useState(0);
+    const busy = useRef(false);
+    const alive = useRef(true);
+    useEffect(() => {
+        alive.current = true;
+        return () => {
+            alive.current = false;
+        };
+    }, []);
+    const run = useCallback(() => {
+        if (busy.current)
+            return;
+        busy.current = true;
+        setState((prev) => ({ ...prev, scanning: true }));
+        scanDocTree(projectRoot, docsRoot).then((res) => {
+            busy.current = false;
+            if (!alive.current)
+                return;
+            setState((prev) => res.ok
+                ? { files: res.files, dirs: res.dirs, hasDirs: res.hasDirs, ok: true, scanned: true, scanning: false }
+                : { ...prev, ok: false, scanned: true, scanning: false });
+        });
+    }, [projectRoot, docsRoot]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        run();
+        const id = setInterval(run, DOC_SCAN_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, [run, epoch, enabled]);
+    const scan = useCallback(() => {
+        setEpoch((e) => e + 1);
+    }, []);
+    return { ...state, scan };
+}
 export function useWrapScan(projectRoot) {
     const path = useMemo(() => wrapCacheFile(projectRoot), [projectRoot]);
     const [cache, setCache] = useState(() => readWrapCache(path));

package/dist/inbox.js

@@ -14,6 +14,7 @@ import { readFileSync } from 'node:fs';
 import { promisify } from 'node:util';
 import { basename, join } from 'node:path';
 import { pluginScript } from './plugin-cache.js';
+import { sanitize } from './width.js';
 const execFileAsync = promisify(execFile);
 export const INBOX_METRICS_SCRIPT = 'scripts/docs/doc-metrics.sh';
 /**
@@ -216,10 +217,18 @@ export function inboxWords(f) {
  * il detail lo dice e tiene l'azione attiva, come fa quello della task con un
  * task file mancante: la skill risolve il file per nome, non per il testo che
  * il deck è riuscito a leggere.
+ *
+ * `sanitize` AL CONFINE DI CARICAMENTO, come `loadTaskFileText` e il gemello
+ * `loadDocText`: la catena dichiarata in `markdown.ts` è `sanitize →
+ * parseMarkdown → wrapWithOffsets`, e la prima non conserva la lunghezza —
+ * applicarla più a valle sposterebbe gli offset degli span appena calcolati. Un
+ * file di nozioni è testo libero e porta glifi su cui Ink e il terminale
+ * divergono: senza la sanificazione il wrap conta una colonna in meno di quante
+ * Ink ne disegna, e la riga esce dal box mangiandone il bordo.
  */
 export function loadInboxText(projectRoot, relPath) {
     try {
-        return readFileSync(join(projectRoot, relPath), 'utf8');
+        return sanitize(readFileSync(join(projectRoot, relPath), 'utf8'));
     }
     catch {
         return null;

package/dist/input-modes.js

@@ -25,6 +25,7 @@ export const CAPTURING_MODES = [
     'detail',
     'status',
     'inbox',
+    'doc',
     'wrap',
     'spawn',
     'reader',
@@ -60,6 +61,42 @@ export function captures(mode) {
 export const CTRL_DEROGATIONS = {
     detail: ['f'],
 };
+export const TASK_MODE_KEYS = [
+    { chord: { kind: 'ctrl', input: 'k' }, label: '^K', legend: null },
+    { chord: { kind: 'ctrl', input: 'p' }, label: '^P', legend: null },
+    { chord: { kind: 'ctrl', input: 'r' }, label: '^R', legend: null },
+    { chord: { kind: 'delete' }, label: 'CANC', legend: null },
+    { chord: { kind: 'plain', input: 'C' }, label: 'C', legend: 'C nuova' },
+    { chord: { kind: 'plain', input: 'E' }, label: 'E', legend: 'E edit' },
+    { chord: { kind: 'plain', input: 'S' }, label: 'S', legend: 'S sort' },
+    { chord: { kind: 'plain', input: 'F' }, label: 'F', legend: 'F filtri' },
+    { chord: { kind: 'plain', input: 'w' }, label: 'w', legend: 'w salva' },
+];
+/** Le voci di legenda dei tasti del mondo task, nell'ordine dell'elenco: è ciò
+ *  che `deckLegend` emette in modo task e omette in modo doc. */
+export const TASK_MODE_LEGEND = TASK_MODE_KEYS.map((k) => k.legend).filter((v) => v !== null);
+/**
+ * Il nome del tasto del mondo task appena premuto, o `null` se non è uno di
+ * loro.
+ *
+ * I tre booleani arrivano dal chiamante invece del `Key` di Ink: questo modulo
+ * è un catalogo di dati e resta provabile senza montare nulla — la stessa
+ * ragione per cui `CAPTURING_MODES` è un array e non una proprietà di un hook.
+ */
+export function taskModeKey(input, ctrl, del) {
+    for (const k of TASK_MODE_KEYS) {
+        const c = k.chord;
+        if (c.kind === 'delete' ? del : c.kind === 'ctrl' ? ctrl && c.input === input : !ctrl && !del && c.input === input) {
+            return k.label;
+        }
+    }
+    return null;
+}
+/** La riga di stato di un tasto inerte: nomina il tasto, il modo in cui vive e
+ *  come tornarci. */
+export function inertNote(label) {
+    return `${label} → solo in modo task (^B)`;
+}
 /**
  * T21 (mandata 2) — i modi che SCORRONO un contenuto lungo, cioè gli unici in
  * cui la rotella del mouse fa qualcosa.
@@ -74,7 +111,7 @@ export const CTRL_DEROGATIONS = {
  * Il custode è `MODE_WHEEL` in `input.ts`, un `Record<ScrollingMode, …>` che non
  * compila se un modo entra qui senza uno scroll da chiamare.
  */
-export const SCROLLING_MODES = ['detail', 'status', 'inbox', 'wrap', 'reader'];
+export const SCROLLING_MODES = ['detail', 'status', 'inbox', 'doc', 'wrap', 'reader'];
 const SCROLLING = new Set(SCROLLING_MODES);
 /** `true` se la rotella scorre il contenuto del modo. */
 export function scrolls(mode) {

package/dist/input.js

@@ -22,11 +22,12 @@ import { useApp, useInput } from 'ink';
 import { hitRegion, isWheel, listHit, takeMouse, wheelDir, WHEEL_LINES, } from './mouse.js';
 import { HINT_ROW, LAUNCH_ROW } from './frame.js';
 import { moveSelection } from './session-list.js';
-import { captures, scrolls } from './input-modes.js';
-import { META_ROWS, QUIT_WINDOW_MS } from './model.js';
+import { captures, inertNote, scrolls, taskModeKey, } from './input-modes.js';
+import { LEFT_PANE, META_ROWS, QUIT_WINDOW_MS, RIGHT_PANE } from './model.js';
 import { TASK_VIEWS, taskView } from './pane-views.js';
 import { loadTaskFileText } from './tasks.js';
-import { loadInboxText } from './inbox.js';
+import { inboxPrompt, loadInboxText } from './inbox.js';
+import { dirListing, loadDocText } from './doc-tree.js';
 // T116 — l'avviso della prima pressione di `^C`. La durata è INTERPOLATA dalla
 // finestra, non ricopiata: un numero scritto a mano in un testo che promette un
 // comportamento diventa falso il giorno che la costante cambia, e nessuno
@@ -78,6 +79,7 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
         detail: overlays.sheet.onKey,
         status: overlays.status.onKey,
         inbox: overlays.inbox.onKey,
+        doc: overlays.doc.onKey,
         wrap: overlays.wrap.onKey,
         spawn: overlays.spawn.onKey,
         reader: overlays.search.onReaderKey,
@@ -98,6 +100,7 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
         detail: overlays.sheet.scroll,
         status: overlays.status.scroll,
         inbox: overlays.inbox.scroll,
+        doc: overlays.doc.scroll,
         wrap: overlays.wrap.scroll,
         reader: overlays.search.scrollReader,
     };
@@ -212,10 +215,24 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 model.selectTaskView(hit.key);
             else if (hit.pane === 'inbox')
                 model.selectInboxView(hit.key);
+            else if (hit.pane === 'doctree')
+                model.selectDocView(hit.key);
             else
                 model.selectSessionView(hit.key);
             return;
         }
+        if (hit.pane === 'doctree') {
+            const r = frame.windowDoc[hit.index];
+            if (!r)
+                return;
+            if (model.focus === 'doctree' && r.path === model.selDocPath) {
+                onKey('', { ...NO_MODIFIERS, return: true });
+                return;
+            }
+            model.setFocus('doctree');
+            model.selectDocRow(frame.docWin.start + hit.index);
+            return;
+        }
         if (hit.pane === 'inbox') {
             const f = frame.windowInbox[hit.index];
             if (!f)
@@ -270,6 +287,23 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
             MODE_KEYS[mode](input, key);
             return;
         }
+        // T160 — i tasti del mondo task sono INERTI in modo doc, e lo dicono
+        // (`input-modes.ts` §TASK_MODE_KEYS). Il gate sta QUI, sopra tutti i rami e
+        // sotto il dispatch dei modi: un tasto gated non deve raggiungere né il ramo
+        // `ctrl` né quello delle lettere nude, e dentro un modo capturing la
+        // domanda non si pone perché il modo ha già consumato l'input.
+        //
+        // Un ramo per tasto con la sua guardia avrebbe funzionato uguale e sarebbe
+        // stato il modo per farne dimenticare uno: il gate legge l'elenco, e un
+        // tasto aggiunto lì è gated e smette di essere annunciato senza toccare
+        // questo file.
+        if (model.deckMode === 'doc') {
+            const gated = taskModeKey(input, key.ctrl, key.delete);
+            if (gated) {
+                setNote(inertNote(gated));
+                return;
+            }
+        }
         // T52/D1 — il ramo CTRL sta PRIMA di quelli su lettera nuda e li chiude
         // tutti. `CTRL+F` e `f` nudo arrivano con lo STESSO `input` ('f'),
         // distinguibili solo da `key.ctrl`: senza questa precedenza `CTRL+F`
@@ -352,11 +386,13 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 overlays.spawn.openPage();
             }
             else if (input === 'b') {
-                // T134/D8 preflight — `^B` (box/bacheca) scambia i due pane dello slot
-                // destro. Non è un modale né una schermata: il pane resta uno dei due
-                // riquadri della vista normale, quindi `tab` continua a ciclare le
-                // viste DENTRO quello montato e `←→` a spostare il focus fra le colonne.
-                model.toggleInboxPane();
+                // T160 — `^B` scambia il MODO del deck, cioè entrambi gli slot insieme.
+                // Erede del tasto di T134, che scambiava il solo pane destro: la
+                // mnemonica (box/bacheca) resta, il bersaglio è salito di un livello.
+                // Non è un modale né una schermata — i due riquadri della vista normale
+                // restano al loro posto, quindi `tab` continua a ciclare le viste DENTRO
+                // il pane a fuoco e `←→` a spostare il fuoco fra le colonne.
+                model.toggleDeckMode();
             }
             return;
         }
@@ -372,25 +408,28 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
             model.cycleView(key.shift ? -1 : 1);
         }
         else if (key.escape) {
-            // T134/D8 preflight — `esc` in vista normale chiude il pane inbox e torna
-            // alle sessioni. Resta inerte quando le sessioni sono già montate: `esc`
-            // dice «esci da dove sei», e da lì non c'è niente da cui uscire.
-            model.closeInboxPane();
+            // T160 — `esc` in vista normale torna al modo task. Resta inerte quando il
+            // modo task è già montato: `esc` dice «esci da dove sei», e da lì non c'è
+            // niente da cui uscire.
+            model.closeDocMode();
         }
         else if (key.leftArrow || key.rightArrow) {
-            // Binding ASSOLUTO, non toggle: `←` porta sempre sui task e `→` sempre
-            // sul pane DESTRO, quindi ripremere lo stesso tasto non riporta indietro.
-            // È ciò che lo rende spaziale — la direzione indica una destinazione, e
-            // con due colonne un toggle sarebbe indistinguibile solo per caso.
-            // T134 — «destro» è il pane montato, non `sessions`: il tasto nomina una
-            // posizione, e quale dei due la occupi è un'altra decisione (`^B`).
-            model.setFocus(key.leftArrow ? 'tasks' : model.rightPane);
+            // Binding ASSOLUTO, non toggle: `←` porta sempre sul pane SINISTRO e `→`
+            // sempre sul destro, quindi ripremere lo stesso tasto non riporta
+            // indietro. È ciò che lo rende spaziale — la direzione indica una
+            // destinazione, e con due colonne un toggle sarebbe indistinguibile solo
+            // per caso.
+            // T160 — «sinistro» e «destro» sono posizioni, non contenuti: quale pane
+            // le occupi lo decide il modo, che è un'altra decisione (`^B`).
+            model.setFocus((key.leftArrow ? LEFT_PANE : RIGHT_PANE)[model.deckMode]);
         }
         else if (key.upArrow) {
             if (model.focus === 'tasks')
                 model.moveTaskSel(-1);
             else if (model.focus === 'inbox')
                 model.moveInboxSel(-1);
+            else if (model.focus === 'doctree')
+                model.moveDocSel(-1);
             else
                 model.setSelSessionId((id) => moveSelection(model.sessionRows, id, -1));
         }
@@ -399,11 +438,33 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 model.moveTaskSel(1);
             else if (model.focus === 'inbox')
                 model.moveInboxSel(1);
+            else if (model.focus === 'doctree')
+                model.moveDocSel(1);
             else
                 model.setSelSessionId((id) => moveSelection(model.sessionRows, id, 1));
         }
         else if (key.return) {
-            if (model.focus === 'inbox') {
+            if (model.focus === 'doctree') {
+                // T160 — `⏎` apre il DETAIL del bersaglio, non la sessione: la sessione
+                // la apre il `⏎` di dentro, come sul pane inbox. Il gesto è lo stesso su
+                // un file e su una cartella (P10) — cambia cosa si legge nel corpo, non
+                // cosa si preme: il testo del file, oppure l'elenco che dice perché la
+                // cartella è flaggata.
+                const r = model.selDoc;
+                if (!r) {
+                    setNote('nessuna riga doc selezionata');
+                }
+                else {
+                    const { prompt, hint } = actions.rebalanceSpawn(r);
+                    overlays.doc.open({
+                        item: r,
+                        text: r.kind === 'dir' ? dirListing(model.docData, r.path) : loadDocText(cwd, r.path),
+                        prompt,
+                        hint,
+                    });
+                }
+            }
+            else if (model.focus === 'inbox') {
                 // T134 — `⏎` apre il DETAIL del file, non la sessione: la sessione la
                 // apre il `⏎` di dentro. Stessa scala del pane task, dove `⏎` apre il
                 // detail e le combo restano per chi sa già cosa vuole — con la
@@ -413,7 +474,15 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 if (!f)
                     setNote('nessun file inbox selezionato');
                 else
-                    overlays.inbox.open({ file: f, text: loadInboxText(cwd, f.path) });
+                    overlays.inbox.open({
+                        item: f,
+                        text: loadInboxText(cwd, f.path),
+                        // T134 — la skill la decide la NATURA del file, e quella mappa vive
+                        // in un posto solo (`inboxPrompt`, `src/inbox.ts`): il prompt si
+                        // compone qui, dove si apre lo sheet, e non dentro l'hook — che da
+                        // T160 è condiviso con un bersaglio di tutt'altra natura.
+                        prompt: inboxPrompt(f),
+                    });
             }
             else if (model.focus === 'tasks') {
                 // T66 — ⏎ apre il DETAIL, non più una sessione. Secondo rimappaggio in

package/dist/model.js

@@ -31,6 +31,17 @@ export const ALL = Symbol('all');
 export const ROW_ALL = 0;
 export const ROW_SPOT = 1;
 export const META_ROWS = 2;
+/** Il pane SINISTRO di ciascun modo, e il destro. Tabelle e non due ternari
+ *  sparsi: `←→`, il toggle del modo e l'hit-test del mouse fanno tutti e tre la
+ *  stessa domanda, e tre risposte scritte a mano divergono al primo modo
+ *  aggiunto. */
+export const LEFT_PANE = { task: 'tasks', doc: 'doctree' };
+export const RIGHT_PANE = { task: 'sessions', doc: 'inbox' };
+/** Il fuoco è sul pane di sinistra? Serve al toggle del modo, che deve portare
+ *  chi guardava a sinistra sul pane sinistro dell'altro modo. */
+export function isLeftPane(focus) {
+    return focus === LEFT_PANE.task || focus === LEFT_PANE.doc;
+}
 // Modale sort a grammatica libera: un tasto per chiave, pressioni successive
 // ciclano asc → desc → fuori dalla chain.
 export const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id', c: 'commit' };

package/dist/mouse.js

@@ -19,6 +19,7 @@
 //    eventi che sotto render pesante si frammentano su stdin e leakano dentro
 //    i campi di testo. Con soli 1000+1006 gli eventi sono due per click.
 import { termWidth } from './width.js';
+import { LEFT_PANE, RIGHT_PANE } from './model.js';
 /**
  * Sequenza SGR: `ESC [ < b ; x ; y M|m`, con l'ESC opzionale (fatto ①).
  *
@@ -277,19 +278,28 @@ export function inlineRegions(parts, startCol) {
  *  riga sort, spazio vuoto sotto la lista o fuori dai pane. */
 export function listHit(ev, g) {
     const spans = paneSpans(g.columns);
-    const inTasks = ev.col >= spans.tasks.start && ev.col <= spans.tasks.end;
+    const inLeft = ev.col >= spans.tasks.start && ev.col <= spans.tasks.end;
     const inRight = ev.col >= spans.sessions.start && ev.col <= spans.sessions.end;
-    if (!inTasks && !inRight)
+    if (!inLeft && !inRight)
         return null;
-    const isInbox = g.rightPane === 'inbox';
-    const pane = inTasks ? 'tasks' : isInbox ? 'inbox' : 'sessions';
-    const rightHeader = isInbox ? g.inboxHeader : g.sessionHeader;
+    const isDoc = g.mode === 'doc';
+    const pane = inLeft ? LEFT_PANE[g.mode] : RIGHT_PANE[g.mode];
+    const leftHeader = isDoc ? g.docHeader : g.taskHeader;
+    const rightHeader = isDoc ? g.inboxHeader : g.sessionHeader;
     if (ev.row === PANE_HEADER_ROW) {
-        const key = hitRegion(inTasks ? g.taskHeader : rightHeader, ev.col);
+        const key = hitRegion(inLeft ? leftHeader : rightHeader, ev.col);
         return key ? { pane, target: 'view', key } : null;
     }
-    const first = inTasks ? TASK_LIST_ROW : PANE_BODY_ROW;
-    const count = inTasks ? g.taskRows : isInbox ? g.inboxRows : g.sessionRows;
+    // Fra header e lista il pane task porta la riga sort/filtri, che non si
+    // seleziona; il pane doc non ce l'ha e la sua lista comincia una riga prima.
+    const first = inLeft && !isDoc ? TASK_LIST_ROW : PANE_BODY_ROW;
+    const count = inLeft
+        ? isDoc
+            ? g.docRows
+            : g.taskRows
+        : isDoc
+            ? g.inboxRows
+            : g.sessionRows;
     const index = ev.row - first;
     if (index < 0 || index >= count)
         return null;