@lamemind/loom-deck 0.73.1 → 0.74.0

package/dist/actions.js

@@ -24,11 +24,20 @@ 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';
+/**
+ * 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.
@@ -200,6 +209,64 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         const spawned = spawnDeckResume(bound, cwd, sessionId, modelKind, model.sessionNotes.get(sessionId));
         spawned.child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
         noteSpawn(spawned);
+        return spawned;
+    }
+    /**
+     * 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`, terzo chiamante dopo la lista e la ricerca, e
+     * 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 +663,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         spawnForTask,
         spawnTaskSession,
         resumeSession,
+        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';
@@ -304,6 +304,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         docCounts: model.docCounts,
         docViewId: model.docViewId,
         docHasDirs: model.docHasDirs,
+        restoreCount: model.restorable.length,
     });
     useDeckInput({
         cwd,
@@ -343,7 +344,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 +354,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/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

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.74.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": {