@lamemind/loom-deck 0.73.1 → 0.75.0

package/dist/actions.js

@@ -24,11 +24,21 @@ import { cut, cutMiddle } from './width.js';
 import { dropSessionFiles, sessionArtifacts } from './session-drop.js';
 import { saveView, viewFilePath } from './view-store.js';
 import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, DECK_RUN, } from './spawn.js';
+import { MODEL_DEFAULT } from './spawn-catalog.js';
+import { modelAlias } from './glyphs.js';
 import { resolveSpawnId } from './spawn-config.js';
 import { useTaskOps } from './task-ops.js';
 import { inboxPrompt, inboxWords } from './inbox.js';
 import { docTargetKind, docWords } from './doc-tree.js';
 import { wrapWords } from './wrap-scan.js';
+import { enterSession, focusSession } from './focus-session.js';
+/**
+ * T181 — l'attesa massima di un passo del restore prima di passare al
+ * successivo. Un `deck-run` esce appena `ptyxis --tab` ha consegnato la tab
+ * all'istanza già aperta, cioè ben sotto questa soglia: il timeout esiste per il
+ * figlio che non esce mai, non per scandire la serie.
+ */
+const RESTORE_STEP_TIMEOUT_MS = 3_000;
 export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overrides, catalog, setNote, }) {
     // La riga di stato di OGNI spawn di sessione Claude: il comando esatto, come
     // lo si scriverebbe in bash, invece di una parafrasi.
@@ -187,19 +197,108 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         const d = spawnDefaults(kind, taskHoles(task.id));
         spawnForTask(task.id, d.model, d.title ?? '', d.prompt ?? '');
     }
-    // T49 — resume di una conversazione in una nuova tab. Unico punto: lo chiamano
-    // il `⏎` della lista sessioni e quello sulla riga-sessione della ricerca, che
-    // devono restare la stessa azione.
+    // T49 — resume di una conversazione in una nuova tab. Unico punto dello spawn,
+    // con due chiamanti: `openSession` (il `⏎` della lista sessioni e quello
+    // sulla riga-sessione della ricerca) quando la conversazione NON è viva, e il
+    // restore di T181 (`restoreSessions`).
+    // T184 — riprende SEMPRE, e non chiede se la conversazione è viva: quella
+    // domanda è del chiamante, e i due chiamanti la pongono in modo diverso. Il
+    // `⏎` la pone a ogni pressione (`openSession`); il restore l'ha già posta
+    // per l'insieme intero, che `restoreSet` svuota appena una conversazione è
+    // viva. Il ramo di focus resta fuori da qui anche per il contratto di
+    // ritorno: il restore scandisce la serie sull'uscita del `deck-run` che
+    // questa funzione restituisce, e un focus non ha nessun figlio da aspettare.
     // T148 — il modello lo decide il CHIAMANTE, non questa funzione: la lista
     // principale passa il selettore della preview (`model.resumeModel`), la
-    // ricerca passa il modello ereditato dalla sessione senza superficie di
-    // scelta (D1 preflight). I due chiamanti restano la stessa azione perché è
+    // ricerca e il restore il modello ereditato dalla sessione senza superficie
+    // di scelta (D1 preflight). I chiamanti restano la stessa azione perché è
     // lo spawn a essere identico, non la sorgente del valore.
     function resumeSession(sessionId, modelKind) {
         const bound = model.bindings.get(sessionId) ?? null;
         const spawned = spawnDeckResume(bound, cwd, sessionId, modelKind, model.sessionNotes.get(sessionId));
         spawned.child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
         noteSpawn(spawned);
+        return spawned;
+    }
+    /**
+     * T184 — `⏎` su una conversazione, dalla lista sessioni e dalla riga-sessione
+     * della ricerca: la stessa azione dai due posti, come chiede T49.
+     *
+     * Viva → compass porta davanti la sua tab, e nessun `deck-run` parte: un
+     * secondo resume aprirebbe un secondo processo `claude` sullo stesso
+     * transcript. Non viva → `resumeSession`, come prima di T184. La scelta e il
+     * canale vivono in `focus-session.ts`; qui si cablano coi valori del deck.
+     *
+     * Il nome della nota viene dal registro (`LiveSession.name`, il titolo della
+     * tab); senza nome, il prefisso del `sessionId` come nelle altre note.
+     */
+    function openSession(sessionId, modelKind) {
+        enterSession(sessionId, {
+            isLive: (id) => model.live.has(id),
+            nameOf: (id) => model.live.get(id)?.name || id.slice(0, 8),
+            focus: focusSession,
+            resume: (id) => resumeSession(id, modelKind),
+            note: setNote,
+        });
+    }
+    /**
+     * T181 — `^T` e il bottone in testata: riapre le conversazioni dell'ultimo
+     * insieme vivo, una tab per conversazione, ognuna col proprio binding di
+     * task, la propria nota e il modello con cui girava.
+     *
+     * Passa da `resumeSession` diretto, non da `openSession` come il `⏎` (T184):
+     * l'insieme è vuoto appena una conversazione è viva, quindi qui non c'è
+     * nessuna viva da portare davanti. Come la ricerca non ha una superficie di
+     * scelta del modello: lo eredita dalla conversazione
+     * (`modelAlias(session.model) ?? MODEL_DEFAULT`, T148/D1).
+     *
+     * IN SERIE, e non tutte insieme (P7 preflight): la tab successiva parte
+     * quando il `deck-run` della precedente è uscito, così le tab si aprono
+     * nell'ordine dell'insieme e la finestra riaperta ricalca da sinistra a
+     * destra quella chiusa. Il timeout per passo tiene la serie in moto anche se
+     * un figlio non esce mai — uno spawn inerte dei test, un `ptyxis` che resta
+     * appeso: una tab fuori ordine è meglio di un restore che si ferma a metà.
+     *
+     * La tenuta (`holdLive`) va due volte: su tutte all'avvio, perché il bottone
+     * sparisca subito e un secondo `^T` non riapra tutto di nuovo; su ognuna alla
+     * partenza della sua tab, perché la scadenza si conti da lì. Nessuna
+     * conferma (P6): ricostruisce uno stato che l'utente aveva, ed è reversibile
+     * chiudendo le tab.
+     */
+    function restoreSessions() {
+        const list = model.restorable;
+        if (list.length === 0) {
+            setNote(model.restoring ? '^T → restore già in corso' : '^T → nessuna conversazione da riaprire');
+            return;
+        }
+        model.holdLive(list.map((s) => s.sessionId));
+        const step = (i) => {
+            if (i >= list.length) {
+                // L'ultimo annuncio in-tab arriva asincrono e scriverebbe sopra il
+                // riepilogo: avanzare la sequenza lo rende vecchio prima che arrivi.
+                spawnSeq.current++;
+                setNote(`↻ restore: ${list.length} ${list.length === 1 ? 'conversazione riaperta' : 'conversazioni riaperte'}`);
+                return;
+            }
+            const s = list[i];
+            model.holdLive([s.sessionId]);
+            const { child } = resumeSession(s.sessionId, modelAlias(s.model) ?? MODEL_DEFAULT);
+            let done = false;
+            const next = () => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                step(i + 1);
+            };
+            // `unref`: il timer non deve tenere vivo il processo se il deck esce a
+            // metà serie — lo schermo sarebbe già restituito al terminale.
+            const timer = setTimeout(next, RESTORE_STEP_TIMEOUT_MS);
+            timer.unref();
+            child.once('exit', next);
+            child.once('error', next);
+        };
+        step(0);
     }
     /** T148/T154(P2,P3) — `m` col bersaglio RESUME: `input.ts` instrada qui solo
      *  quando il focus è sulle sessioni E una riga è selezionata (P2), quindi il
@@ -596,6 +695,8 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         spawnForTask,
         spawnTaskSession,
         resumeSession,
+        openSession,
+        restoreSessions,
         cycleResumeModel,
         cycleBareModel,
         writeNote,

package/dist/cli.js

@@ -23,7 +23,7 @@ import { MODEL_SHORT_LIST, modelAlias } from './glyphs.js';
 import { MODEL_DEFAULT, MODELS } from './spawn-catalog.js';
 import { loadPromptCatalog } from './prompt-catalog.js';
 import { resolveSpawnId } from './spawn-config.js';
-import { BARE_BUTTONS_WIDTH, BARE_LABEL, deckLegend, frameGeometry, headlineWidth, indicatorRow, launchRow, } from './frame.js';
+import { BARE_BUTTONS_WIDTH, BARE_LABEL, HEADER_BUTTON_SEP, deckLegend, frameGeometry, headlineWidth, indicatorRow, launchRow, } from './frame.js';
 import { choiceButtons } from './ui/fields.js';
 import { useDeckModel } from './deck-model.js';
 import { useDeckActions } from './actions.js';
@@ -111,7 +111,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         setNote,
         // T148/D1 — nessun selettore nella ricerca: il modello è quello ereditato
         // dalla conversazione, senza superficie di scelta.
-        onResume: (row) => actions.resumeSession(row.session.sessionId, modelAlias(row.session.model) ?? MODEL_DEFAULT),
+        // T184 — `openSession` come il `⏎` della lista: una viva va davanti, solo
+        // una non viva si riprende.
+        onResume: (row) => actions.openSession(row.session.sessionId, modelAlias(row.session.model) ?? MODEL_DEFAULT),
     });
     // T121 — il project status. Non è solo un overlay come i tre sopra: il suo
     // stato si legge in TESTATA a schermata chiusa, e il viewer è una delle sue
@@ -304,6 +306,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         docCounts: model.docCounts,
         docViewId: model.docViewId,
         docHasDirs: model.docHasDirs,
+        restoreCount: model.restorable.length,
     });
     useDeckInput({
         cwd,
@@ -343,7 +346,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     if (frame.budget.compact) {
         return (_jsx(CompactNotice, { dot: false, what: `v${VERSION} · ${model.viewTasks.length} task · sel ${model.selectedTaskId ?? model.parentLabel}`, rows: rows, columns: columns }));
     }
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(StatusHeadline, { name: model.projectCore ?? model.projectName, label: status.label, building: status.building, failed: status.failed, cols: headlineWidth(columns, frame.headerRight) }), _jsx(Text, { dimColor: true, children: frame.headerRight })] }), _jsx(HintBar, { mode: mode, purge: purge.draft, keyLegend: deckLegend({
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(StatusHeadline, { name: model.projectCore ?? model.projectName, label: status.label, building: status.building, failed: status.failed, cols: headlineWidth(columns, frame.headerBlock) }), frame.headerButton ? (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: "yellow", bold: true, children: frame.headerButton }), _jsxs(Text, { dimColor: true, children: [HEADER_BUTTON_SEP, frame.headerRight] })] })) : (_jsx(Text, { dimColor: true, children: frame.headerRight }))] }), _jsx(HintBar, { mode: mode, purge: purge.draft, keyLegend: deckLegend({
                     focus: model.focus,
                     hasTask: model.selTask !== null,
                     hasSession: model.selSessionObj !== null,
@@ -353,6 +356,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     hasInbox: model.selInbox !== null,
                     hasDoc: model.selDoc !== null,
                     gitlink: gitlink.enabled,
+                    restore: frame.headerButton !== 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, launch.filler, BARE_LABEL.text, ' ', bareButtons.nodes] })) : 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, mode === 'drop' && drop.draft ? _jsx(DropModal, { draft: drop.draft, columns: columns }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [model.deckMode === 'doc' ? (_jsx(DocPane, { rows: frame.windowDoc, counts: model.docCounts, activeView: model.docViewId, paneCount: model.docRows.length, selectedPath: model.selDocPath, focused: model.focus === 'doctree', above: frame.docWin.start, below: model.docRows.length - frame.docWin.end, columns: columns, ok: model.docOk, scanned: model.docScanned, scanning: model.docScanning, hasDirs: model.docHasDirs })) : (_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, blockMark: model.blockMark })), model.deckMode === 'doc' ? (_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, sessionPriority: model.sessionPriority, 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 === 'doc' && model.selDoc ? (_jsx(PreviewPane, { kind: "doc", row: model.selDoc, 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, resumeModel: model.resumeModel })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const cwd = process.cwd();

package/dist/deck-model.js

@@ -16,6 +16,7 @@ import { useEffect, useMemo, useState } from 'react';
 import { loadArchivableDays, loadIdentity, loadLaunch } from './config.js';
 import { useArchivable, useCommitTimes, useDirtyFolders, useDocScan, useEpicHierarchy, useInboxScan, useSessions, useTaskDetail, useTasks, } from './hooks.js';
 import { DEFAULT_INBOX_STALE_HOURS, staleCount } from './inbox.js';
+import { aliveIds, restoreSet } from './live-marks.js';
 import { cycleDocView, docCounts as deriveDocCounts, docView, selectDocRows, } from './doc-views.js';
 import { cycleInboxView, inboxCounts as deriveInboxCounts, inboxView, selectInboxRows, } from './inbox-views.js';
 import { docsRootName } from './tasks.js';
@@ -129,7 +130,7 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
     // di STATO in fondo al frame (il feedback di un'azione). Due concetti diversi
     // a una lettera di distanza sarebbero una trappola di lettura — e di
     // scrittura, visto che `setNote` compare in quasi ogni ramo.
-    const { sessions, bindings, forkOf, pinned, notes: sessionNotes, priority: sessionPriority, live, reload: reloadSessions, } = useSessions(cwd, projectCore);
+    const { sessions, bindings, forkOf, pinned, notes: sessionNotes, priority: sessionPriority, live, liveMarks, restoring, holdLive, reload: reloadSessions, } = useSessions(cwd, projectCore);
     const [focus, setFocus] = useState('tasks');
     // T39 — selezione KEYED SU ID, non su indice. Con una vista trasformata
     // (filtro/sort) l'indice non identifica più la stessa task: leggere l'array
@@ -317,6 +318,12 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
     // non quella a schermo: il contatore di una voce del catalogo non può
     // dipendere da quale voce è selezionata, o navigare muoverebbe i numeri.
     const liveCount = useMemo(() => assembled.rows.filter((r) => live.has(r.sessionId)).length, [assembled, live]);
+    // T181 — le conversazioni che il bottone di restore riapre, nell'ordine di
+    // riapertura. L'insieme vivo è lo stesso incrocio `live ∩ sessions` che la
+    // convergenza usa per scrivere la marca (`aliveIds`): due definizioni
+    // diverse farebbero comparire il bottone accanto a una conversazione che per
+    // la marca è viva, o il contrario.
+    const restorable = useMemo(() => restoreSet({ marked: liveMarks, sessions, alive: aliveIds(live, sessions), restoring }), [liveMarks, sessions, live, restoring]);
     const sessionCounts = {
         total: assembled.contextTotal,
         live: liveCount,
@@ -544,6 +551,10 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
         live,
         reloadSessions,
         detail,
+        // T181 — restore delle conversazioni dell'ultimo insieme vivo
+        restorable,
+        restoring,
+        holdLive,
         // progetto
         launch,
         identity,

package/dist/focus-session.js

@@ -0,0 +1,139 @@
+import { spawnOut } from './spawn.js';
+// Il binario del canale. L'override esiste per il collaudo del ramo «canale
+// assente», stesso schema di `LOOM_DECK_NOTIFY_CMD` (`spawn.ts`): su una
+// macchina dove `gdbus` c'è e compass è sul bus, quel ramo non è altrimenti
+// raggiungibile.
+export const FOCUS_CMD = process.env.LOOM_DECK_FOCUS_CMD ?? 'gdbus';
+/**
+ * Il timeout che `gdbus` applica alla risposta, in secondi.
+ *
+ * compass risponde DOPO il salto: l'helper AT-SPI e la ricerca della finestra
+ * costano qualche decimo di secondo ciascuno, quindi la soglia sta un ordine di
+ * grandezza sopra il caso normale e scatta solo su un compass appeso. Un compass
+ * assente non la aspetta: il bus risponde subito `ServiceUnknown`.
+ */
+export const FOCUS_TIMEOUT_S = 5;
+/**
+ * La rete sotto il timeout di `gdbus`: Node uccide il figlio se nemmeno quello
+ * esce, per esempio con un bus di sessione che non risponde alla connessione.
+ * Senza, un `⏎` resterebbe senza nota per sempre.
+ */
+const FOCUS_KILL_MS = (FOCUS_TIMEOUT_S + 1) * 1000;
+/** Gli esiti che portano alla conversazione: la tab era già davanti
+ *  (`esatta`) o il salto l'ha portata davanti (`tab`). Ogni altra parola del
+ *  vocabolario di compass dice perché non ci si è arrivati. */
+const REACHED = new Set(['esatta', 'tab']);
+/** L'argv di `gdbus` per chiedere a compass il focus di `sessionId`. Il
+ *  `sessionId` va nudo: `gdbus` legge il tipo `s` dall'introspezione del metodo
+ *  e un UUID non è testo GVariant valido, quindi lo prende come stringa. */
+export function focusSessionArgs(sessionId) {
+    return [
+        'call',
+        '--session',
+        '--dest',
+        'org.lamemind.Compass',
+        '--object-path',
+        '/org/lamemind/Compass',
+        '--method',
+        'org.lamemind.Compass.FocusSession',
+        '--timeout',
+        String(FOCUS_TIMEOUT_S),
+        sessionId,
+    ];
+}
+/**
+ * L'esito dentro la risposta testuale di `gdbus`, o `null` se la risposta non
+ * ha la forma attesa.
+ *
+ * Un metodo con firma `(s)` esce come tupla GVariant di un elemento:
+ * `('tab',)`. La parola non si confronta col vocabolario di compass: un esito
+ * che una versione futura aggiungesse deve arrivare nella nota così com'è,
+ * invece di confondersi con un canale rotto.
+ */
+export function parseFocusReply(stdout) {
+    const m = /^\('([^']*)',\)$/.exec(stdout.trim());
+    return m ? m[1] : null;
+}
+/**
+ * Chiede a compass il focus di `sessionId` e consegna l'esito a `onResult`,
+ * una volta sola.
+ *
+ * Il listener su `error` è OBBLIGATORIO e non difensivo: senza `gdbus` (su
+ * Windows, o su un Linux senza glib) lo spawn fallisce con un `error`
+ * asincrono, e un `error` non agganciato su un `ChildProcess` abbatte il deck.
+ * Agganciato, è il ramo «canale assente», ed è anche il solo gate di
+ * piattaforma che serve: nessun `process.platform` qui.
+ *
+ * Il codice d'uscita decide, lo stderr no: `gdbus` lo scrive nella lingua del
+ * sistema (`Errore: GDBus.Error:…ServiceUnknown`), e ne resta solo l'ultima
+ * riga come motivo, per chi legge il risultato in un test.
+ */
+export function focusSession(sessionId, onResult) {
+    const child = spawnOut(FOCUS_CMD, focusSessionArgs(sessionId), {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: FOCUS_KILL_MS,
+    });
+    let out = '';
+    let err = '';
+    child.stdout?.on('data', (c) => {
+        out += c.toString();
+    });
+    child.stderr?.on('data', (c) => {
+        err += c.toString();
+    });
+    // `error` e `close` possono arrivare entrambi per lo stesso spawn fallito:
+    // la nota è una sola.
+    let done = false;
+    const finish = (r) => {
+        if (done)
+            return;
+        done = true;
+        onResult(r);
+    };
+    child.on('error', (e) => finish({ unreachable: e.code ?? e.message }));
+    child.on('close', (code, signal) => {
+        if (code !== 0) {
+            const last = err.trim().split('\n').pop() ?? '';
+            finish({ unreachable: signal ? `timeout (${signal})` : last || `exit ${code}` });
+            return;
+        }
+        const outcome = parseFocusReply(out);
+        finish(outcome === null
+            ? { unreachable: `risposta inattesa: ${out.trim()}` }
+            : { reached: REACHED.has(outcome), outcome });
+    });
+    return child;
+}
+/**
+ * La nota di un `⏎` su una viva, a ogni esito, successo compreso.
+ *
+ * Sul successo la tab del deck va dietro, quindi la nota non la legge nessuno
+ * subito: si legge al ritorno, ed è l'unica traccia di cosa ha fatto il tasto —
+ * ogni spawn del deck lascia già la sua riga di stato, e un `⏎` muto sarebbe
+ * l'unica azione senza.
+ *
+ * `sconosciuta` (compass non trova il `sessionId` fra i vivi) cade nella forma
+ * di ogni esito fuori dalla tab, senza un resume: vuol dire che la
+ * conversazione è finita dopo l'ultimo tick del deck, e il `⏎` successivo, a
+ * tick avvenuto, la vede non viva e la riprende.
+ */
+export function focusNote(r, name) {
+    if ('unreachable' in r)
+        return `⚠ compass non raggiungibile — ${name}`;
+    return r.reached ? `→ ${name}` : `⚠ focus ${r.outcome} — ${name}`;
+}
+/**
+ * La scelta del `⏎`. Una viva non si riprende MAI, qualunque esito torni:
+ * né su `assente` (viva, ma senza una tab col suo nome — lanciata fuori da
+ * Ptyxis) né con compass irraggiungibile. In entrambi i casi il processo
+ * `claude` c'è, e un resume sarebbe il secondo scrittore.
+ */
+export function enterSession(sessionId, deps) {
+    if (!deps.isLive(sessionId)) {
+        deps.resume(sessionId);
+        return 'resume';
+    }
+    const name = deps.nameOf(sessionId);
+    deps.focus(sessionId, (r) => deps.note(focusNote(r, name)));
+    return 'focus';
+}

package/dist/frame.js

@@ -16,7 +16,7 @@
 // budget anche quando il render esce presto su una schermata sostitutiva:
 // aritmetica su array già in memoria, e `layoutBudget` accetta ogni `Mode`.
 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 { FRAME_TEXT_COL, HEADER_ROW, 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';
@@ -85,6 +85,10 @@ export function deckLegend(state) {
     // spinnarla); basta il focus sul pane e una selezione.
     const canPin = state.focus === 'sessions' && state.hasSessionId;
     return sanitize([
+        // T181/P5 — in TESTA alla legenda, perché la legenda tronca dalla coda e
+        // questa voce vale proprio nel momento in cui il deck si è appena
+        // riaperto: è il primo gesto che si vuole fare, non uno fra venti.
+        ...(state.restore ? ['^T restore'] : []),
         ...(canSpawn
             ? ['⏎ detail', '^K/^P/^R spawn']
             : canResume
@@ -316,6 +320,39 @@ export function indicatorRow(state, columns) {
     const start = FRAME_TEXT_COL + Math.max(0, (columns || 80) - 4) - width;
     return { segments, text, regions: rowRegions(segments, INDICATOR_SEP, start), width };
 }
+/**
+ * T181 — il bottone della testata: `[ restore 3 sessions ]`, a sinistra di
+ * risoluzione e versione.
+ *
+ * `key` come gli indicatori della riga legenda: la COMBO col prefisso `^`, e il
+ * click rientra dalla porta della tastiera premendola (`HEADER_ROW` in
+ * `mouse.ts`). La combo non sta nel testo del bottone (P5 preflight): la dice la
+ * legenda, come per gli indicatori di T134.
+ *
+ * Tre forme, dalla più lunga, e vince la prima che lascia al project status a
+ * sinistra almeno il pavimento di `headlineWidth`: il bottone entra nel budget
+ * della testata, e una forma che non ci sta spingerebbe la riga oltre il bordo.
+ * Nessuna delle tre ci sta → nessun bottone; `^T` resta valido, perché il
+ * tasto non dipende da cosa entra a schermo.
+ */
+/** Il pavimento del budget del project status: sotto, non resta niente di
+ *  leggibile. Il bottone di restore lo rispetta (`restoreButton`). */
+const HEADLINE_MIN = 4;
+export const RESTORE_KEY = '^t';
+export const HEADER_BUTTON_SEP = '  ';
+export function restoreButtonForms(n) {
+    return [`[ restore ${n} ${n === 1 ? 'session' : 'sessions'} ]`, `[ restore ${n} ]`, `[ ${n} ]`];
+}
+export function restoreButton(n, columns, headerRight) {
+    if (n <= 0)
+        return null;
+    for (const form of restoreButtonForms(n)) {
+        const block = termWidth(form) + termWidth(HEADER_BUTTON_SEP) + termWidth(headerRight);
+        if ((columns || 80) - 4 - block - 1 >= HEADLINE_MIN)
+            return form;
+    }
+    return null;
+}
 /**
  * Il budget d'altezza e le finestre di rendering.
  *
@@ -381,6 +418,21 @@ export function frameGeometry(input) {
             docRows: windowDoc.length,
             mode: input.deckMode,
         };
+    // Dimensione del terminale in CELLE (colonne×righe, mai pixel — un processo
+    // dentro un terminale vede solo la griglia di caratteri) e versione. La
+    // parte sinistra della testata riceve un budget derivato da questa stringa e
+    // non da una lunghezza fissa: la risoluzione cambia a ogni resize, quindi
+    // anche la larghezza che occupa.
+    const headerRight = `${input.columns}×${input.rows} · v${VERSION}`;
+    // T181 — il bottone sta a sinistra di `headerRight` nello stesso blocco
+    // ancorato a destra, quindi la sua prima colonna si ricava per sottrazione
+    // dal bordo, come per gli indicatori (`indicatorRow`).
+    const headerButton = restoreButton(input.restoreCount, input.columns, headerRight);
+    const headerBlock = headerButton ? headerButton + HEADER_BUTTON_SEP + headerRight : headerRight;
+    const blockStart = FRAME_TEXT_COL + Math.max(0, (input.columns || 80) - 4) - termWidth(headerBlock);
+    const headerRegions = headerButton
+        ? [{ key: RESTORE_KEY, start: blockStart, end: blockStart + termWidth(headerButton) - 1 }]
+        : [];
     return {
         budget,
         taskWin,
@@ -392,18 +444,16 @@ export function frameGeometry(input) {
         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
-        // parte sinistra della testata riceve un budget derivato da questa stringa e
-        // non da una lunghezza fissa: la risoluzione cambia a ogni resize, quindi
-        // anche la larghezza che occupa.
-        headerRight: `${input.columns}×${input.rows} · v${VERSION}`,
+        headerRight,
+        headerButton,
+        headerBlock,
+        headerRegions,
         launchLine,
     };
 }
-/** Il budget della testata sinistra, per sottrazione dal segmento destro. */
+/** Il budget della testata sinistra, per sottrazione dal blocco destro. */
 export function headlineWidth(columns, headerRight) {
-    return Math.max(4, columns - 4 - termWidth(headerRight) - 1);
+    return Math.max(HEADLINE_MIN, columns - 4 - termWidth(headerRight) - 1);
 }
 /**
  * T134 — il budget della legenda tasti, per sottrazione del blocco indicatori
@@ -418,4 +468,4 @@ export function headlineWidth(columns, headerRight) {
 export function legendWidth(columns, indicatorW) {
     return Math.max(4, (columns || 80) - 4 - indicatorW - termWidth(INDICATOR_SEP));
 }
-export { HINT_ROW, LAUNCH_ROW };
+export { HEADER_ROW, HINT_ROW, LAUNCH_ROW };

package/dist/hooks.js

@@ -10,6 +10,7 @@ import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { loadSessionIndex } from './task-index.js';
 import { fillSidecarGaps } from './session-meta.js';
+import { aliveIds, liveMarkPlan, writeLiveMarks, RESTORE_HOLD_MS } from './live-marks.js';
 import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
 import { commitTimes } from './commit-times.js';
 import { scanEpicHierarchy, EMPTY_EPIC_HIERARCHY } from './epic-hierarchy.js';
@@ -147,6 +148,9 @@ export function useEpicHierarchy(tasksDir) {
 // vive già nel modello (`projectCore`), e una seconda copia toglierebbe dal
 // titolo scritto nel sidecar una stringa diversa da quella che la lista toglie
 // dalle proprie righe.
+//
+// T181 — ed è il posto dove CONVERGE la marca `live` del sidecar, per la stessa
+// ragione: l'insieme vivo e la marca su disco sono in mano nello stesso giro.
 export function useSessions(projectRoot, core) {
     const [state, setState] = useState({
         sessions: [],
@@ -156,13 +160,24 @@ export function useSessions(projectRoot, core) {
         notes: new Map(),
         priority: new Set(),
         live: new Map(),
+        liveMarks: new Map(),
+        restoring: false,
     });
     // T50 — pin/unpin scrive il sidecar e vuole feedback IMMEDIATO, non al
     // prossimo tick del poll (1.5s): la reload è esposta via ref così il toggle la
     // richiama senza risottoscrivere l'intervallo.
     const reloadRef = useRef(() => { });
+    // T181 — le conversazioni che il restore sta riaprendo, con la scadenza della
+    // tenuta. In un ref e non nell'effect perché chi le scrive è un gesto
+    // (`holdLive`, dal restore), non il giro del poll.
+    const holds = useRef(new Map());
     useEffect(() => {
         let lastSig = '';
+        // T181 — l'isteresi del ritiro (P3 preflight): le marcate viste mancare al
+        // giro precedente. È l'unico stato in memoria della convergenza, e parte
+        // vuoto a ogni avvio: un deck che riparte senza vive non scrive niente, e
+        // con delle vive rimisura da capo — un ritiro ritardato di un tick, mai perso.
+        let missingOnce = new Set();
         const reload = () => {
             let sessions;
             let index;
@@ -180,6 +195,7 @@ export function useSessions(projectRoot, core) {
                     priority: new Set(),
                     titles: new Map(),
                     models: new Map(),
+                    liveMarks: new Map(),
                 };
             }
             // T62 — le vive stanno sullo STESSO tick delle altre fonti, non su una
@@ -222,6 +238,40 @@ export function useSessions(projectRoot, core) {
                 models: index.models,
                 core,
             });
+            // T181 — la marca `live`: il piano dei buchi, poi la scrittura. Fuori dal
+            // gate della signature come i campi derivati sopra, e per la stessa
+            // ragione: un append fallito si ritenta al giro dopo, e la signature
+            // invariata non lo farebbe mai ripartire.
+            //
+            // La tenuta del restore si pota qui, prima del piano: una conversazione
+            // tenuta che è già viva non ha più niente da cui essere protetta, e una
+            // tenuta scaduta torna sotto l'isteresi normale.
+            const alive = aliveIds(live, sessions);
+            const now = Date.now();
+            for (const [id, until] of holds.current) {
+                if (until <= now || alive.includes(id))
+                    holds.current.delete(id);
+            }
+            const plan = liveMarkPlan({
+                alive,
+                marked: index.liveMarks,
+                missingOnce,
+                held: new Set(holds.current.keys()),
+            });
+            missingOnce = plan.missing;
+            let liveMarks = index.liveMarks;
+            // Rilettura solo quando ha scritto, cioè a ogni cambio dell'insieme vivo e
+            // mai a regime: la mappa a schermo è quella su disco, rango compreso, e
+            // non una seconda derivazione del rango in memoria che potrebbe divergere.
+            if (writeLiveMarks(projectRoot, plan) > 0) {
+                try {
+                    liveMarks = loadSessionIndex(projectRoot).liveMarks;
+                }
+                catch {
+                    // rilettura fallita: resta la mappa di prima, il giro dopo la rifà.
+                }
+            }
+            const restoring = holds.current.size > 0;
             // La signature copre anche fork, pin, note e marca di priorità: un record
             // di lineage, un toggle di pin, una nota appena scritta o un 🚨 acceso
             // cambiano la lista renderizzata, quindi devono forzare il re-render come
@@ -238,18 +288,35 @@ export function useSessions(projectRoot, core) {
                 '#' +
                 [...priority].sort().join(',') +
                 '#' +
-                liveSig(live);
+                liveSig(live) +
+                // T181 — la marca e il restore in corso decidono il bottone in testata.
+                '#' +
+                [...liveMarks.entries()].map(([k, v]) => `${k}@${v}`).sort().join(',') +
+                (restoring ? '#restoring' : '');
             if (sig === lastSig)
                 return;
             lastSig = sig;
-            setState({ sessions, bindings, forkOf, pinned, notes, priority, live });
+            setState({ sessions, bindings, forkOf, pinned, notes, priority, live, liveMarks, restoring });
         };
         reloadRef.current = reload;
         reload();
         const id = setInterval(reload, POLL_MS);
         return () => clearInterval(id);
     }, [projectRoot, core]);
-    return { ...state, reload: () => reloadRef.current() };
+    /**
+     * T181 — tiene fuori dal ritiro le conversazioni che il restore sta per
+     * riaprire, per `RESTORE_HOLD_MS` da adesso. Il restore la chiama due volte:
+     * su tutte all'avvio, così il bottone sparisce subito e un secondo `^T` non
+     * riapre tutto una seconda volta; e su ognuna quando parte la sua tab, così la
+     * scadenza si conta da lì e non dall'inizio di una serie che può durare.
+     */
+    const holdLive = useCallback((ids) => {
+        const until = Date.now() + RESTORE_HOLD_MS;
+        for (const id of ids)
+            holds.current.set(id, until);
+        reloadRef.current();
+    }, []);
+    return { ...state, reload: () => reloadRef.current(), holdLive };
 }
 // T61 — conteggio delle Done oltre soglia, su una scala di refresh TUTTA SUA.
 //

package/dist/input.js

@@ -20,7 +20,7 @@
 import { useEffect, useRef } from 'react';
 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 { HEADER_ROW, HINT_ROW, LAUNCH_ROW } from './frame.js';
 import { moveSelection } from './session-list.js';
 import { captures, inertNote, scrolls, taskModeKey, } from './input-modes.js';
 import { LEFT_PANE, META_ROWS, QUIT_WINDOW_MS, RIGHT_PANE } from './model.js';
@@ -186,6 +186,14 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 onKey(hit.slice(1), { ...NO_MODIFIERS, ctrl: true });
             return;
         }
+        if (ev.row === HEADER_ROW) {
+            // T181 — il bottone di restore, stessa porta degli indicatori: la sua
+            // chiave è la combo `^t`, e il click la preme invece di chiamare l'azione.
+            const hit = hitRegion(frame.headerRegions, ev.col);
+            if (hit)
+                onKey(hit.slice(1), { ...NO_MODIFIERS, ctrl: true });
+            return;
+        }
         onListClick(ev);
     }
     /**
@@ -386,6 +394,14 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 // byte non arrivasse il test fallirebbe invece di lasciare il dubbio.
                 overlays.spawn.openPage();
             }
+            else if (input === 't') {
+                // T181/P4 preflight — `^T` riapre le conversazioni dell'ultimo insieme
+                // vivo. La `t` nuda apre un terminale: stesso schema «una lettera, due
+                // bersagli» di `^F`/`f`, che il ramo `ctrl` anteposto rende sicuro. Non
+                // è un tasto del mondo task (`TASK_MODE_KEYS`): il bottone sta in
+                // testata, visibile in entrambi i modi del deck.
+                actions.restoreSessions();
+            }
             else if (input === 'b') {
                 // T160 — `^B` scambia il MODO del deck, cioè entrambi gli slot insieme.
                 // Erede del tasto di T134, che scambiava il solo pane destro: la
@@ -507,6 +523,9 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
             else {
                 // T49 — ⏎ su una sessione = resume in nuova tab. Il binding si rilegge
                 // dal sidecar (non dal padre selezionato): vale anche per le spot.
+                // T184 — solo se NON è viva: su una viva compass porta davanti la sua
+                // tab, e nessun `deck-run` parte (`openSession`, la stessa azione del
+                // `⏎` nella ricerca).
                 const s = model.selSessionObj;
                 if (!s) {
                     setNote(model.selSessionId
@@ -514,7 +533,7 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                         : 'nessuna sessione da riprendere');
                 }
                 else {
-                    actions.resumeSession(s.sessionId, model.resumeModel);
+                    actions.openSession(s.sessionId, model.resumeModel);
                 }
             }
         }

package/dist/live-marks.js

@@ -0,0 +1,166 @@
+// T181 — la MARCA `live` del sidecar: quali conversazioni stavano nell'ultimo
+// insieme vivo del progetto, e quindi quali riapre il bottone di restore.
+//
+// Stesso schema di `session-meta.ts`: CONVERGENZA, non evento. A ogni tick del
+// poll il deck confronta la marca su disco con le vive del registro e appende
+// solo i buchi. Nessuno stato sul «giro precedente» a parte l'isteresi qui
+// sotto: un deck che riparte converge dal sidecar com'è, e un tick perso si
+// recupera al tick dopo.
+//
+// Il giudizio è separato dalla scrittura (`liveMarkPlan` decide,
+// `writeLiveMarks` scrive) per la stessa ragione di `sidecarGaps`: la parte non
+// ovvia è la convergenza, e un piano che non converge appenderebbe a ogni tick
+// del poll, per sempre, senza nessun errore a dirlo.
+//
+// Nessun import da ink/react: il chiamante è un hook, questo modulo no.
+import { NO_SPAWN } from './spawn.js';
+import { appendLive } from './task-index.js';
+/**
+ * L'insieme vivo della feature: le vive del registro che hanno anche una
+ * `Session` nel deck (P2 preflight), ordinate per avvio del processo.
+ *
+ * L'incrocio è lo stesso del contatore «vive» e del rollup (`rollupChildren` in
+ * `deck-model.ts`), ed è l'unico insieme che `resumeSession` sa riprendere: lo
+ * spawn parte con cwd = root del progetto e prende il modello dalla `Session`.
+ * Ne restano fuori due casi, entrambi di proposito:
+ *
+ *  - una conversazione aperta in una SOTTOCARTELLA del progetto — il registro
+ *    la include (filtro `cwd` per prefisso), ma il transcript sta sotto un altro
+ *    hash di progetto e il deck non ha una `Session` per lei. Non si marca, e la
+ *    sua presenza non azzera l'insieme da ripristinare;
+ *  - una conversazione appena nata, o appena passata da un `/clear` — il
+ *    registro la conosce prima del suo primo record di transcript. Entra al
+ *    primo prompt.
+ *
+ * L'ordine per `startedAt` decide il rango di chi entra nello stesso tick: è
+ * l'ordine in cui le tab sono state aperte, quindi quello che il restore deve
+ * ricalcare. A parità (registro senza il campo) decide il `sessionId`, perché un
+ * piano deve essere deterministico per essere testabile.
+ */
+export function aliveIds(live, sessions) {
+    const known = new Set(sessions.map((s) => s.sessionId));
+    return [...live.entries()]
+        .filter(([id]) => known.has(id))
+        .sort(([a, x], [b, y]) => x.startedAt - y.startedAt || (a < b ? -1 : a > b ? 1 : 0))
+        .map(([id]) => id);
+}
+/**
+ * Quanto a lungo una conversazione in riapertura resta tenuta, contato dalla
+ * partenza della SUA tab.
+ *
+ * Il conto che lo regge: il registro vivo scrive il file del processo
+ * nell'ordine del secondo dopo l'avvio di `claude` (`startedAt` contro
+ * `procStart` dello stesso file), più il tempo di `deck-run` e della tab. Dieci
+ * secondi coprono quel ritardo con un margine largo, e restano brevi abbastanza
+ * da ritirare in tempi
+ * umani la marca di una conversazione che non si riaccende — un `--resume` che
+ * fallisce, una tab chiusa subito. Scaduta la tenuta, vale l'isteresi normale.
+ */
+export const RESTORE_HOLD_MS = 10_000;
+/**
+ * Il piano di questo tick.
+ *
+ * **Insieme vivo VUOTO → nessun append, e l'isteresi riparte.** È la regola
+ * dell'utente, «la traccia si sovrascrive solo quando ci sono conversazioni
+ * vive»: è ciò che fa sopravvivere l'ultimo insieme alla chiusura del deck,
+ * della finestra o della macchina, e che il bottone di restore legge alla
+ * riapertura. Svuotare `missing` qui invece di portarlo avanti allunga il
+ * ritiro, mai lo accorcia: il prezzo di una scelta prudente è un tick di
+ * ritardo, il prezzo di quella opposta sarebbe ritirare al primo tick non vuoto
+ * una conversazione vista mancare una volta sola, magari molto prima.
+ *
+ * **Insieme vivo non vuoto:**
+ *  - ogni viva non marcata ENTRA, al primo tick in cui la si vede;
+ *  - ogni marcata assente ESCE solo al SECONDO tick consecutivo di assenza
+ *    (P3 preflight). Il primo la mette in `missing` e basta. Serve perché
+ *    chiudere una finestra Ptyxis con N tab fa uscire N processi con tempi
+ *    propri: un tick caduto in quella finestra vede un insieme non vuoto ma
+ *    dimagrito, e senza isteresi ritirerebbe la marca alle già morte proprio
+ *    mentre l'insieme stava per diventare vuoto — cioè l'insieme da salvare;
+ *  - una marcata TENUTA (`held`) non esce e non conta come assente: il restore
+ *    accende le tab una alla volta, e la prima viva non deve far ritirare le
+ *    altre che stanno ancora partendo.
+ *
+ * Una viva già marcata non produce niente: è la convergenza — un sidecar
+ * allineato dà un piano vuoto, e il giro dopo non trova niente da fare.
+ */
+export function liveMarkPlan(input) {
+    const { alive, marked, missingOnce, held } = input;
+    if (alive.length === 0)
+        return { enter: [], leave: [], missing: new Set() };
+    const aliveSet = new Set(alive);
+    const enter = alive.filter((id) => !marked.has(id));
+    const leave = [];
+    const missing = new Set();
+    for (const id of marked.keys()) {
+        if (aliveSet.has(id) || held.has(id))
+            continue;
+        if (missingOnce.has(id))
+            leave.push(id);
+        else
+            missing.add(id);
+    }
+    return { enter, leave, missing };
+}
+/**
+ * Scrive il piano. Ritorna quanti record ha appeso — zero è l'esito normale a
+ * regime, non un fallimento.
+ *
+ * `NO_SPAWN` frena anche questa scrittura, come `fillSidecarGaps` e per la
+ * stessa ragione: il gate su pseudo-terminale avvia il deck vero con cwd la
+ * project root del cappello, e senza freno ogni run della suite appenderebbe la
+ * marca nel sidecar reale di chi la lancia.
+ *
+ * Gli ingressi prima delle uscite: un tick che li porta entrambi è il passaggio
+ * da un insieme all'altro (`/clear`, una tab chiusa mentre un'altra si apre), e
+ * nell'ordine inverso un lettore che cade fra i due append vedrebbe per un
+ * istante un insieme più piccolo di entrambi.
+ *
+ * Un sidecar non scrivibile non è un errore da mostrare: il giro dopo trova gli
+ * stessi buchi e riprova.
+ */
+export function writeLiveMarks(projectRoot, plan) {
+    if (NO_SPAWN)
+        return 0;
+    let scritti = 0;
+    try {
+        for (const id of plan.enter) {
+            appendLive(projectRoot, id, true);
+            scritti++;
+        }
+        for (const id of plan.leave) {
+            appendLive(projectRoot, id, false);
+            scritti++;
+        }
+    }
+    catch {
+        // sidecar non scrivibile: si riprova al giro dopo, niente a schermo.
+    }
+    return scritti;
+}
+/**
+ * Le conversazioni che il bottone riapre, nell'ordine di riapertura (rango di
+ * entrata crescente, dalla più vecchia — P7 preflight). Vuoto = niente bottone.
+ *
+ * Vuoto in due casi oltre alla marca vuota: c'è almeno una viva (il bottone
+ * vale solo finché non ce n'è nessuna, e appena una è viva la marca si
+ * riallinea a lei), oppure un restore è già in corso — senza, un secondo
+ * `^T` nei secondi prima che la prima tab si accenda riaprirebbe tutto due
+ * volte.
+ *
+ * Solo le marcate che hanno una `Session` (P2): una marcata senza transcript —
+ * cancellato, o di un altro hash di progetto — non si conta e non si segnala.
+ * Il suo `live:false` arriva al primo tick con delle vive, come per ogni altra
+ * marcata che non lo è.
+ */
+export function restoreSet(input) {
+    if (input.alive.length > 0 || input.restoring || input.marked.size === 0)
+        return [];
+    const byId = new Map(input.sessions.map((s) => [s.sessionId, s]));
+    return [...input.marked.entries()]
+        .sort((a, b) => a[1] - b[1])
+        .flatMap(([id]) => {
+        const s = byId.get(id);
+        return s ? [s] : [];
+    });
+}

package/dist/live-sessions.js

@@ -89,6 +89,7 @@ export function parseLiveEntry(content, pid) {
             status: d.status === 'busy' ? 'busy' : 'idle',
             name: typeof d.name === 'string' ? d.name : '',
             cwd,
+            startedAt: typeof d.startedAt === 'number' ? d.startedAt : 0,
         },
         procStart,
     };

package/dist/mouse.js

@@ -207,6 +207,14 @@ export const LAUNCH_ROW = 4;
  * tastiera con la combo che l'indicatore rappresenta.
  */
 export const HINT_ROW = LAUNCH_ROW - 1;
+/**
+ * T181 — riga della TESTATA (project status a sinistra, risoluzione e versione
+ * a destra), subito sotto il bordo superiore. Entra nell'hit-test col bottone di
+ * restore, che le sta a sinistra di risoluzione e versione; come le altre due
+ * righe fisse è incondizionata in modalità normale, e il click rientra dalla
+ * porta della tastiera con la combo che il bottone rappresenta.
+ */
+export const HEADER_ROW = HINT_ROW - 1;
 /** Colonna (1-based) del primo carattere di testo dentro il box esterno:
  *  bordo + `paddingX={1}`. */
 export const FRAME_TEXT_COL = 3;

package/dist/task-index.js

@@ -62,6 +62,16 @@ export function appendSessionMeta(projectRoot, sessionId, fields) {
         return;
     appendSessionRecord(projectRoot, rec);
 }
+/**
+ * T181 — entrata (`true`) o uscita (`false`) di una conversazione dall'insieme
+ * vivo: stessa forma di `appendPin`. Il nome del campo è un contratto di
+ * formato come `priority`: i lettori esterni (compass, `announce-state.sh`) lo
+ * ignorano perché leggono i campi per nome, e rinominarlo dopo vorrebbe una
+ * migrazione dei file già scritti.
+ */
+export function appendLive(projectRoot, sessionId, live) {
+    appendSessionRecord(projectRoot, { sessionId, live });
+}
 // Una sola lettura del JSONL per entrambe le mappe: il deck poll-a l'indice a
 // ogni tick, leggere il file due volte raddoppierebbe l'I/O per nulla.
 // Last-wins per campo (un re-pin dello stesso sessionId sovrascrive), e i due
@@ -75,14 +85,16 @@ export function loadSessionIndex(projectRoot) {
     const priority = new Set();
     const titles = new Map();
     const models = new Map();
+    const liveMarks = new Map();
     let content;
     try {
         content = readFileSync(taskIndexPath(projectRoot), 'utf8');
     }
     catch {
-        return { bindings, forkOf, pinned, notes, priority, titles, models };
+        return { bindings, forkOf, pinned, notes, priority, titles, models, liveMarks };
     }
     let order = 0; // posizione crescente dei record pinned → rango di pin (D2)
+    let liveOrder = 0; // T181 — idem per i record live:true → rango di entrata
     for (const line of content.split('\n')) {
         if (!line.trim())
             continue;
@@ -157,10 +169,20 @@ export function loadSessionIndex(projectRoot) {
                 else
                     models.delete(d.sessionId);
             }
+            // T181 — stesso last-wins di `pinned`, rango compreso. Un `live:true` su
+            // una conversazione già marcata RIASSEGNA il rango: la convergenza non lo
+            // scrive mai (appende solo i buchi), quindi succede solo con due deck
+            // sullo stesso progetto, e l'effetto è spostarla in coda al restore.
+            if (typeof d.live === 'boolean') {
+                if (d.live)
+                    liveMarks.set(d.sessionId, liveOrder++);
+                else
+                    liveMarks.delete(d.sessionId);
+            }
         }
         catch {
             // riga corrotta → skip
         }
     }
-    return { bindings, forkOf, pinned, notes, priority, titles, models };
+    return { bindings, forkOf, pinned, notes, priority, titles, models, liveMarks };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.73.1",
+  "version": "0.75.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": {

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)) })] }) })] }));
-}