@lamemind/loom-deck 0.74.0 → 0.76.0

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

@@ -26,6 +26,7 @@ import { META_ROWS } from './model.js';
 import { TASK_MODE_LEGEND } from './input-modes.js';
 import { rowIndexOf } from './session-list.js';
 import { VERSION } from './version.js';
+import { OFF_MARK } from './platform.js';
 // La surface built-in del cappello, in testa alla riga launch. Non sta fra i
 // tasti perché ha la stessa natura delle voci `launch` — fire-once, cwd =
 // project root, nessuno stato. Per il terminale compass usa 🖥️, che nel frame
@@ -230,6 +231,8 @@ export const INDICATOR_SEP = '  ';
  * dell'ultimo riuscito, che resta vero e ancora apribile.
  */
 export function inboxButton(state) {
+    if (state.available === false)
+        return sanitize(`[ Doc 📄 ${OFF_MARK} ]`);
     const numbers = state.scanned
         ? `${state.counts.nozioni}/${state.counts.derivazione}/${state.counts.sweep}`
         : STATUS_MISSING;
@@ -261,6 +264,8 @@ export function inboxButton(state) {
  * l'esito dell'ultimo riuscito resta vero e ancora apribile.
  */
 export function wrapIndicator(state) {
+    if (state.available === false)
+        return `wrap ${OFF_MARK}`;
     const body = state.scanning
         ? 'scan…'
         : state.mtime === null
@@ -289,6 +294,8 @@ export function wrapIndicator(state) {
  * nomina i membri.
  */
 export function gitlinkIndicator(state) {
+    if (state.available === false)
+        return `gitlink ${OFF_MARK}`;
     const body = !state.scanned
         ? STATUS_MISSING
         : !state.ok

package/dist/git-bash.js

@@ -0,0 +1,78 @@
+// T175 — il bash di Git for Windows: dove sta, e come lo riceve un `claude`
+// lanciato dal deck.
+//
+// Serve già qui e non solo a T178 (gli script `.sh` del plugin), per il verdetto
+// 9 di T174: un `claude` che eredita il `PATH` di Git Bash esegue gli hook del
+// plugin in PowerShell — `cat` diventa `Get-Content`, lo script `.sh` una
+// stringa stampata — e la task non arriva in contesto. Con
+// `CLAUDE_CODE_GIT_BASH_PATH` nell'env, la variabile con cui Claude Code sceglie
+// il proprio bash, gli hook tornano in bash. Un deck avviato da Git Bash non la
+// porta: la risolve lui.
+//
+// Modulo PURO nel cuore (`resolveGitBash` riceve il filesystem come funzione),
+// con un involucro che legge quello vero. Su Linux non fa niente.
+import { existsSync } from 'node:fs';
+import { win32 } from 'node:path';
+export const GIT_BASH_ENV = 'CLAUDE_CODE_GIT_BASH_PATH';
+/**
+ * Quanti livelli sopra la cartella di `git.exe` si cerca `bin\bash.exe`. Tre
+ * coprono le tre posizioni di `git.exe` in Git for Windows: `Git\cmd\` (quella
+ * del `PATH` di Windows), `Git\bin\` e `Git\mingw64\bin\` (la prima del `PATH`
+ * di Git Bash, dove accanto non c'è nessun bash).
+ */
+const MAX_UP = 3;
+/**
+ * Il bash di Git, o `null`.
+ *
+ * Cascata (P6 preflight): la variabile, se impostata — è la scelta esplicita di
+ * chi ha configurato Claude Code; poi ogni `git.exe` del `PATH`, nell'ordine,
+ * risalendo da lì fino a trovare `bin\bash.exe`. Mai `bash` dal `PATH`: Git
+ * aggiunge solo `Git\cmd`, e `C:\Windows\System32\bash.exe` è il lanciatore di
+ * WSL. Mai un path cablato: Git può stare fuori da `C:\Program Files\Git`
+ * (sulla macchina di T174 sta in `C:\Dev\Tools\Git`).
+ */
+export function resolveGitBash(env, exists) {
+    const explicit = env[GIT_BASH_ENV];
+    if (explicit)
+        return explicit;
+    const path = env.PATH ?? env.Path ?? '';
+    for (const dir of path.split(win32.delimiter)) {
+        if (!dir)
+            continue;
+        const git = win32.join(dir, 'git.exe');
+        if (!exists(git))
+            continue;
+        let at = win32.dirname(git);
+        for (let i = 0; i < MAX_UP; i++) {
+            const bash = win32.join(at, 'bin', 'bash.exe');
+            if (exists(bash))
+                return bash;
+            const up = win32.dirname(at);
+            if (up === at)
+                break;
+            at = up;
+        }
+    }
+    return null;
+}
+let cached;
+/** Il bash di Git di questa macchina, risolto una volta per vita del deck:
+ *  un'installazione di Git non si sposta mentre il deck è aperto. */
+export function gitBash() {
+    if (cached === undefined)
+        cached = resolveGitBash(process.env, existsSync);
+    return cached;
+}
+/**
+ * L'env di un `claude` lanciato dal deck.
+ *
+ * Su win32, quello del deck più `CLAUDE_CODE_GIT_BASH_PATH` quando non c'è già e
+ * il bash si trova; senza bash il figlio parte con l'env del deck, come prima.
+ * Altrove `undefined`, cioè l'env ereditato di `spawn`: nessun cambio su Linux.
+ */
+export function claudeEnv(platform = process.platform, env = process.env, bash = gitBash) {
+    if (platform !== 'win32' || env[GIT_BASH_ENV])
+        return undefined;
+    const found = bash();
+    return found ? { ...env, [GIT_BASH_ENV]: found } : undefined;
+}

package/dist/gitlink.js

@@ -187,6 +187,7 @@ async function run(projectRoot, args) {
         const { stdout } = await execFileAsync(script, args, {
             cwd: projectRoot,
             maxBuffer: 1024 * 1024,
+            windowsHide: true,
         });
         return { members: parseGitlinkTsv(stdout), ok: true };
     }

package/dist/hooks.js

@@ -20,6 +20,7 @@ import { mixedCount, readWrapCache, runWrapScan, wrapCacheFile, wrapCount, } fro
 import { purgeTargets } from './purge.js';
 import { loadSpawnOverrides, saveSpawnOverrides, } from './spawn-config.js';
 import { POLL_MS } from './model.js';
+import { isAvailable } from './platform.js';
 // Dimensioni del terminale, live sul resize.
 //
 // Non è una comodità di layout: senza `rows` il frame non ha tetto, e un frame
@@ -203,9 +204,12 @@ export function useSessions(projectRoot, core) {
             // un refresh più lento mostrerebbe `idle` su una sessione che lavora.
             // Il try è separato perché il registry è una fonte indipendente: se manca
             // (versione del CLI che non lo scrive) la lista deve restare, senza vive.
+            // T175 — dove la liveness manca non si interroga nemmeno il registry: la
+            // mappa vuota è il dato onesto, e chi ne dipende per una guardia (`CANC`)
+            // legge la mappa delle funzioni, non questa.
             let live;
             try {
-                live = discoverLiveSessions(projectRoot);
+                live = isAvailable('liveSessions') ? discoverLiveSessions(projectRoot) : new Map();
             }
             catch {
                 live = new Map();
@@ -400,7 +404,9 @@ export function useDirtyFolders(idsSig, tasksDir, projectRoot) {
     }, [idsSig, tasksDir, projectRoot]);
     return dirty;
 }
-export function useInboxScan(projectRoot, docsRoot) {
+/** T175 — `enabled` falso = la funzione è spenta su questa piattaforma: nessuno
+ *  spawn, né all'avvio né a richiesta, e lo stato resta quello di partenza. */
+export function useInboxScan(projectRoot, docsRoot, enabled = true) {
     const [state, setState] = useState({
         files: [],
         ok: true,
@@ -437,10 +443,12 @@ export function useInboxScan(projectRoot, docsRoot) {
         });
     }, [projectRoot, docsRoot]);
     useEffect(() => {
+        if (!enabled)
+            return;
         run();
         const id = setInterval(run, INBOX_SCAN_INTERVAL_MS);
         return () => clearInterval(id);
-    }, [run, epoch]);
+    }, [run, epoch, enabled]);
     // Lo scan a richiesta RESETTA il timer, come quello del wrap: senza,
     // l'intervallo continuerebbe a scorrere dall'ultimo tick automatico e potrebbe
     // rimisurare pochi istanti dopo un dato appena misurato.
@@ -493,7 +501,11 @@ export function useDocScan(projectRoot, docsRoot, enabled) {
     }, []);
     return { ...state, scan };
 }
-export function useWrapScan(projectRoot) {
+/** T175 — `enabled` falso = scan spento su questa piattaforma: niente periodico
+ *  e niente scan a richiesta. Il periodico sarebbe il peggiore dei due — uno
+ *  spawn di `python3` ogni sei ore che nessuno ha chiesto, e su Windows quel
+ *  nome risolve nell'alias dello Store. */
+export function useWrapScan(projectRoot, enabled = true) {
     const path = useMemo(() => wrapCacheFile(projectRoot), [projectRoot]);
     const [cache, setCache] = useState(() => readWrapCache(path));
     const [ok, setOk] = useState(true);
@@ -505,7 +517,7 @@ export function useWrapScan(projectRoot) {
     // secondo lancio.
     const busy = useRef(false);
     const run = useCallback(() => {
-        if (busy.current)
+        if (busy.current || !enabled)
             return;
         busy.current = true;
         setScanning(true);
@@ -518,11 +530,13 @@ export function useWrapScan(projectRoot) {
             if (good)
                 setCache(readWrapCache(path));
         });
-    }, [projectRoot, path]);
+    }, [projectRoot, path, enabled]);
     useEffect(() => {
+        if (!enabled)
+            return;
         const id = setInterval(run, SCAN_INTERVAL_MS);
         return () => clearInterval(id);
-    }, [run, epoch]);
+    }, [run, epoch, enabled]);
     const scan = useCallback(() => {
         setEpoch((e) => e + 1);
         run();

package/dist/inbox.js

@@ -248,7 +248,7 @@ export async function scanInbox(projectRoot, docsRoot) {
     if (!script)
         return { files: [], ok: false };
     try {
-        const { stdout } = await execFileAsync(script, ['--docs-root', docsRoot, '--inbox', '--format', 'tsv'], { cwd: projectRoot, maxBuffer: 4 * 1024 * 1024 });
+        const { stdout } = await execFileAsync(script, ['--docs-root', docsRoot, '--inbox', '--format', 'tsv'], { cwd: projectRoot, maxBuffer: 4 * 1024 * 1024, windowsHide: true });
         return { files: parseInboxTsv(stdout), ok: true };
     }
     catch {

package/dist/input.js

@@ -28,6 +28,7 @@ import { TASK_VIEWS, taskView } from './pane-views.js';
 import { loadTaskFileText } from './tasks.js';
 import { inboxPrompt, loadInboxText } from './inbox.js';
 import { dirListing, loadDocText } from './doc-tree.js';
+import { refuse } from './platform.js';
 // T116 — l'avviso della prima pressione di `^C`. La durata è INTERPOLATA dalla
 // finestra, non ricopiata: un numero scritto a mano in un testo che promette un
 // comportamento diventa falso il giorno che la costante cambia, e nessuno
@@ -461,6 +462,12 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                 model.setSelSessionId((id) => moveSelection(model.sessionRows, id, 1));
         }
         else if (key.return) {
+            // T175 — i due pane del modo doc li riempie uno script del plugin: dove non
+            // gira, `⏎` lo dice invece di rispondere «nessuna riga selezionata».
+            if ((model.focus === 'doctree' || model.focus === 'inbox') &&
+                refuse('pluginScripts', '⏎', setNote, model.focus === 'inbox' ? 'coda inbox' : 'albero doc')) {
+                return;
+            }
             if (model.focus === 'doctree') {
                 // T160 — `⏎` apre il DETAIL del bersaglio, non la sessione: la sessione
                 // la apre il `⏎` di dentro, come sul pane inbox. Il gesto è lo stesso su
@@ -523,6 +530,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 +540,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-sessions.js

@@ -1,6 +1,7 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
+import { isWithin } from './project-path.js';
 function liveSessionsRoot() {
     return join(homedir(), '.claude', 'sessions');
 }
@@ -132,7 +133,9 @@ export function discoverLiveSessions(projectRoot) {
         if (!parsed)
             continue;
         const { entry, procStart } = parsed;
-        if (entry.cwd !== projectRoot && !entry.cwd.startsWith(projectRoot + '/'))
+        // T175 — `isWithin` regge le grafie di Windows: il registry scrive `C:\…`,
+        // e la root del deck può arrivare con la lettera del drive in un altro case.
+        if (!isWithin(entry.cwd, projectRoot))
             continue;
         if (!isAlive(pid, procStart))
             continue;

package/dist/overlays/gitlink.js

@@ -7,6 +7,7 @@
 // preflight, D1/P12 — nessuno split dentro questa task).
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { attentionCount, bumpableCount, bumpGitlink, disalignedCount, gitlinkNote, GITLINK_SCAN_INTERVAL_MS, hasGitmodules, scanGitlink, } from '../gitlink.js';
+import { isAvailable, refuse } from '../platform.js';
 export function useGitlink(deps) {
     const { cwd, setNote } = deps;
     /**
@@ -21,6 +22,12 @@ export function useGitlink(deps) {
      * qui invece che scoperto dopo.
      */
     const enabled = useMemo(() => hasGitmodules(cwd), [cwd]);
+    /** T175 — il segmento esiste (c'è `.gitmodules`) ma lo script che lo misura
+     *  non gira su questa piattaforma: l'indicatore dice `n/d` al posto del
+     *  valore, nessun timer parte, `^U` lo spiega. Due gate e non uno, perché sono
+     *  due fatti diversi: un repo senza submodule e una piattaforma senza bash. */
+    const available = isAvailable('pluginScripts');
+    const active = enabled && available;
     const [members, setMembers] = useState([]);
     const [ok, setOk] = useState(true);
     /** Almeno un tentativo è stato fatto: distingue «non ho ancora misurato» da
@@ -65,12 +72,12 @@ export function useGitlink(deps) {
         });
     }, [cwd]);
     useEffect(() => {
-        if (!enabled)
+        if (!active)
             return;
         run();
         const id = setInterval(run, GITLINK_SCAN_INTERVAL_MS);
         return () => clearInterval(id);
-    }, [enabled, run, epoch]);
+    }, [active, run, epoch]);
     /**
      * Rimisura adesso e riparte col timer da zero.
      *
@@ -100,6 +107,8 @@ export function useGitlink(deps) {
             setNote('^U → questo progetto non ha submodule: nessun gitlink da bumpare');
             return;
         }
+        if (refuse('pluginScripts', '^U', setNote, 'bump del gitlink'))
+            return;
         if (busy.current || bumping) {
             setNote('^U → bump del gitlink già in corso');
             return;
@@ -140,6 +149,7 @@ export function useGitlink(deps) {
     }
     return {
         enabled,
+        available,
         members,
         ok,
         scanned,

package/dist/overlays/wrap.js

@@ -15,6 +15,7 @@ import { pageStep, wrapListCapacity } from '../viewport.js';
 import { cpLen, insertAt, removeAt } from '../layout.js';
 import { sanitizeTyped } from '../glyphs.js';
 import { WRAP_DEFAULT_PATH } from '../wrap-scan.js';
+import { isAvailable, refuse } from '../platform.js';
 export function useWrapOverlay(deps) {
     const { cwd, rows, setMode, setNote, onApply } = deps;
     // Lo stato dello scan vive QUI e non nel modello, sul precedente di
@@ -22,7 +23,10 @@ export function useWrapOverlay(deps) {
     // numeri si leggono in testata a schermata chiusa, e la lista è una delle sue
     // superfici invece che il suo contenuto. Tenerli in due posti significherebbe
     // che l'indicatore e la lista possono dire cose diverse dello stesso scan.
-    const measure = useWrapScan(cwd);
+    // T175 — su una piattaforma senza lo scan, nessun periodico e nessuno spawn:
+    // l'indicatore dice `n/d` e i due tasti lo spiegano.
+    const available = isAvailable('hardWrap');
+    const measure = useWrapScan(cwd, available);
     /** Le righe FOTOGRAFATE all'apertura: uno scan che finisse mentre la lista è
      *  a schermo la riscriverebbe sotto gli occhi, e la posizione di scroll non
      *  avrebbe più un riferimento. Stessa regola del viewer del project status. */
@@ -41,6 +45,8 @@ export function useWrapOverlay(deps) {
      * uno solo. È la stessa forma di `^O` senza cache.
      */
     function open() {
+        if (refuse('hardWrap', '^W', setNote, 'lista hard-wrap'))
+            return;
         if (measure.files.length === 0) {
             setNote(measure.mtime === null
                 ? '^W → hard-wrap non ancora misurato · ^E per lo scan'
@@ -117,6 +123,8 @@ export function useWrapOverlay(deps) {
      *  l'albero del progetto intero, quindi dura, e un tasto che non desse segno
      *  si leggerebbe come inerte. */
     function scan() {
+        if (refuse('hardWrap', '^E', setNote))
+            return;
         if (measure.scanning) {
             setNote('^E → scan hard-wrap già in corso');
             return;
@@ -136,6 +144,7 @@ export function useWrapOverlay(deps) {
         mtime: measure.mtime,
         ok: measure.ok,
         scanning: measure.scanning,
+        available,
         open,
         scan,
         onKey,

package/dist/pane-views.js

@@ -21,6 +21,7 @@
 //  - `↑N`/`↓N` non stanno qui: contano elementi fuori finestra per altezza del
 //    terminale, cioè una POSIZIONE, non un insieme.
 import { isVisible, groupHierarchy } from './view.js';
+import { isAvailable, offText, OFF_MARK } from './platform.js';
 export const TASK_VIEWS = [
     {
         id: 'tasks',
@@ -78,12 +79,21 @@ export const SESSION_VIEWS = [
         empty: null,
     },
     {
+        // T175 — dove la liveness manca, la voce resta nel catalogo (D1 create: le
+        // voci non spariscono) ma il numero no: `●0 vive` direbbe «ho guardato e
+        // nessuna è aperta», cioè uno stato misurato che non esiste. Etichetta e
+        // nota vuota si leggono alla chiamata, non all'import, così la piattaforma
+        // dei test si cambia fra un caso e l'altro.
         id: 'live',
-        label: (c) => `${LIVE_GLYPH}${c.live} vive`,
+        label: (c) => isAvailable('liveSessions') ? `${LIVE_GLYPH}${c.live} vive` : `${LIVE_GLYPH} vive ${OFF_MARK}`,
         count: (c) => c.live,
         rows: (ctx) => ctx.assembled.rows.filter((r) => ctx.isLive(r.sessionId)),
         color: 'green',
-        empty: 'nessuna conversazione viva in questa lista',
+        get empty() {
+            return isAvailable('liveSessions')
+                ? 'nessuna conversazione viva in questa lista'
+                : offText('liveSessions');
+        },
     },
     {
         // T133 D7 — sola vista che NON filtra la lista: il suo insieme è più largo

package/dist/platform.js

@@ -0,0 +1,94 @@
+// T175 — COSA il deck sa fare sulla piattaforma su cui gira.
+//
+// Un modulo solo e non un `process.platform` sparso nei file: la domanda «questa
+// funzione c'è qui?» ha una risposta sola, e la mappa di cosa è spento e perché
+// si legge in un posto invece che cercando dieci `if`. Le figlie di porting
+// dell'epica T173 riaccendono una funzione TOGLIENDO UNA VOCE da `UNAVAILABLE`:
+// i tasti, i pane e gli scan leggono la mappa, non la piattaforma.
+//
+// Modulo PURO: nessun React, nessun I/O. L'unico ingresso esterno è la
+// piattaforma stessa, letta a ogni chiamata (`platform()`), così un test può
+// cambiarla fra un caso e l'altro senza re-importare il modulo.
+/**
+ * LA MAPPA: per piattaforma, le funzioni spente. Una piattaforma assente le ha
+ * tutte — è il comportamento di prima di T175 su Linux e su macOS.
+ *
+ * Il commento accanto a ogni voce nomina la figlia di T173 che la riaccende.
+ */
+export const UNAVAILABLE = {
+    win32: [
+        'spawn', // T176 — tab di Windows Terminal al posto di ptyxis
+        'liveSessions', // T177 — liveness senza /proc
+        'pluginScripts', // T178 — .sh del plugin via Git Bash
+        'hardWrap', // T178 — python del wrap-scan
+        'launch', // T179 — comando per piattaforma nelle voci launch[]
+        'notify', // T180 — toast al posto di notify-send
+    ],
+};
+/** Come una funzione si nomina in un avviso, quando il chiamante non ne dà un
+ *  nome più preciso (il tasto che l'ha chiesta, per esempio). */
+const FEATURE_LABEL = {
+    spawn: 'apertura di tab e conversazioni',
+    liveSessions: 'sessioni vive',
+    pluginScripts: 'script del plugin',
+    hardWrap: 'scan hard-wrap',
+    launch: 'voci launch',
+    notify: 'notifiche',
+};
+const PLATFORM_NAME = {
+    win32: 'Windows',
+    linux: 'Linux',
+    darwin: 'macOS',
+};
+/**
+ * Il marcatore di una funzione spenta, al posto del valore: in un indicatore
+ * della testata (`gitlink n/d`), in un'etichetta di vista (`● vive n/d`).
+ *
+ * Il marcatore SOSTITUISCE il valore e non lo nasconde: un indicatore assente è
+ * già uno stato (il gitlink non disegnato vuol dire «repo senza `.gitmodules`»),
+ * e un `0` direbbe «ho misurato e non c'è niente».
+ */
+export const OFF_MARK = 'n/d';
+/**
+ * La piattaforma delle FUNZIONI. `LOOM_DECK_PLATFORM` la sostituisce, ed esiste
+ * per i test: rende verificabile su Linux il deck di Windows, avvisi compresi.
+ *
+ * Vale solo per la mappa delle funzioni. La semantica dei path (`project-path.ts`)
+ * legge la piattaforma vera, perché descrive il filesystem e non una scelta.
+ */
+export function platform() {
+    return process.env.LOOM_DECK_PLATFORM || process.platform;
+}
+export function platformName(p = platform()) {
+    return PLATFORM_NAME[p] ?? p;
+}
+/** La funzione c'è su questa piattaforma. */
+export function isAvailable(feature, p = platform()) {
+    return !(UNAVAILABLE[p] ?? []).includes(feature);
+}
+/** Il testo di una funzione spenta, per un pane o una vista: nomina la funzione
+ *  e la piattaforma. `n/d` e non «non disponibile»: resta invariato davanti a un
+ *  nome singolare o plurale. */
+export function offText(feature, what, p = platform()) {
+    return `${what ?? FEATURE_LABEL[feature]} ${OFF_MARK} su ${platformName(p)}`;
+}
+/** La riga di stato di un tasto spento: il tasto, la funzione, la piattaforma. */
+export function offNote(key, feature, what, p = platform()) {
+    return `⚠ ${key} → ${offText(feature, what, p)}`;
+}
+/**
+ * La GUARDIA di un tasto: `true` se la funzione è spenta, e in quel caso
+ * l'avviso è già nella riga di stato. Il chiamante esce e basta:
+ *
+ *     if (refuse('spawn', '^K', setNote)) return;
+ *
+ * Un tasto spento che non facesse niente in silenzio sarebbe indistinguibile da
+ * un binding mancante, e uno che arrivasse fino al processo esterno fallirebbe
+ * con un messaggio che non nomina la piattaforma («ptyxis non lanciabile»).
+ */
+export function refuse(feature, key, setNote, what) {
+    if (isAvailable(feature))
+        return false;
+    setNote(offNote(key, feature, what));
+    return true;
+}