@lamemind/loom-deck 0.74.0 → 0.75.0

package/dist/actions.js

@@ -31,6 +31,7 @@ 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
@@ -196,13 +197,21 @@ 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;
@@ -211,14 +220,37 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         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`, 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).
+     * 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
@@ -663,6 +695,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         spawnForTask,
         spawnTaskSession,
         resumeSession,
+        openSession,
         restoreSessions,
         cycleResumeModel,
         cycleBareModel,

package/dist/cli.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

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/input.js

@@ -523,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
@@ -530,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.74.0",
+  "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)) })] }) })] }));
-}