@lamemind/loom-deck 0.75.0 → 0.76.0

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

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;
+}

package/dist/project-path.js

@@ -0,0 +1,71 @@
+// T175 — i confronti di path che il deck fa sulla root del progetto, per
+// piattaforma.
+//
+// Tre punti confrontavano path come stringhe POSIX: il filtro delle
+// conversazioni del progetto (`sessions.ts`), quello delle sessioni vive
+// (`live-sessions.ts`) e il nome del progetto (`deck-model.ts`). Su Linux la
+// stringa È il path; su Windows no, per tre ragioni misurate (verdetto 1 di T174):
+//
+//  - NTFS non distingue le maiuscole, e Claude Code non normalizza la grafia
+//    della cwd: VS Code passa `c:\…`, Windows Terminal `C:\…`, e lo stesso
+//    progetto ha due cartelle di transcript (`c--…` e `C--…`);
+//  - `\` e `/` sono entrambi separatori;
+//  - nei transcript `cwd` compare anche in forma MSYS (`/c/…`), quella di Git
+//    Bash.
+//
+// Modulo PURO. La piattaforma è un parametro con default quella VERA, e non
+// quella di `LOOM_DECK_PLATFORM` (`platform.ts`): qui si descrive il filesystem
+// su cui il deck gira, non una funzione che si può spegnere.
+import { posix, win32 } from 'node:path';
+/**
+ * La forma di un path su cui si confronta, mai quella che si mostra.
+ *
+ * Su win32: separatori portati a `\`, forma MSYS `/c/…` riportata a `C:\…`,
+ * tutto minuscolo, nessun separatore in coda (tranne la radice del drive, dove
+ * `C:` da solo vorrebbe dire «la cartella corrente di C:»). Altrove il path così
+ * com'è, senza il separatore in coda: il confronto resta case-sensitive come il
+ * filesystem.
+ */
+export function comparablePath(p, platform = process.platform) {
+    if (platform !== 'win32')
+        return p.length > 1 ? p.replace(/\/+$/, '') : p;
+    let s = p.replace(/\//g, '\\');
+    // `\c\Users\…` (la forma MSYS dopo la sostituzione dei separatori) →
+    // `c:\Users\…`. Un UNC (`\\server\…`) non matcha: il secondo carattere è `\`.
+    const msys = /^\\([a-zA-Z])(?:\\|$)/.exec(s);
+    if (msys)
+        s = `${msys[1]}:\\${s.slice(msys[0].length)}`;
+    s = s.replace(/\\+$/, '');
+    if (/^[a-zA-Z]:$/.test(s))
+        s += '\\';
+    return s.toLowerCase();
+}
+/** `path` è la root stessa o sta sotto di lei. Mai un prefisso di nome: la root
+ *  `C:\a\loom` non contiene `C:\a\loom-works`. */
+export function isWithin(path, root, platform = process.platform) {
+    const p = comparablePath(path, platform);
+    const r = comparablePath(root, platform);
+    if (p === r)
+        return true;
+    const sep = platform === 'win32' ? '\\' : '/';
+    return p.startsWith(r.endsWith(sep) ? r : r + sep);
+}
+/** Il nome della cartella del progetto: l'ultimo segmento della root, con i
+ *  separatori della piattaforma. Root senza segmenti (`/`, `C:\`) → la root. */
+export function projectBaseName(cwd, platform = process.platform) {
+    return (platform === 'win32' ? win32 : posix).basename(cwd) || cwd;
+}
+/**
+ * Le cartelle di transcript del progetto, fra i nomi di `~/.claude/projects/`.
+ *
+ * Su Linux una sola, il nome esatto. Su win32 ogni nome che coincide ignorando
+ * le maiuscole: la stessa root avviata da VS Code (`c:\…`) e da Windows
+ * Terminal (`C:\…`) scrive in `c--…` e in `C--…`, e leggerne una sola perde le
+ * conversazioni dell'altra.
+ */
+export function matchingDirNames(entries, name, platform = process.platform) {
+    if (platform !== 'win32')
+        return entries.filter((e) => e === name);
+    const want = name.toLowerCase();
+    return entries.filter((e) => e.toLowerCase() === want);
+}

package/dist/purge.js

@@ -80,6 +80,7 @@ export function folderSurvivors(projectRoot, folder) {
         const out = execFileSync('git', ['ls-files', '-o', '--', rel], {
             cwd: projectRoot,
             encoding: 'utf8',
+            windowsHide: true,
         });
         return out.split('\n').filter(Boolean);
     }

package/dist/sessions.js

@@ -2,6 +2,7 @@ import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { sanitize } from './width.js';
+import { isWithin, matchingDirNames } from './project-path.js';
 // CC codifica la project dir sostituendo ogni char non-alfanumerico con '-'
 // (verificato: `/home/lamemind/cc-host` → `-home-lamemind-cc-host`). È LOSSY
 // (un '-' nel path e un '/' collassano nello stesso char) → il forward è
@@ -308,51 +309,84 @@ export function compareSessions(a, b) {
         return b.lastReplyTs - a.lastReplyTs;
     return b.ts - a.ts;
 }
-// Discovery read-only delle sessioni del SOLO progetto corrente (D2 preflight
-// T27): legge la project dir calcolata dal forward-transform, filtra per cwd
-// (difesa contro le collisioni lossy del naming), ordina con `compareSessions`.
-export function discoverProjectSessions(projectRoot) {
-    const dir = join(claudeProjectsRoot(), projectDirName(projectRoot));
-    let files;
+/**
+ * T175 — le cartelle di transcript del progetto.
+ *
+ * Su Linux una sola, il nome esatto, e senza leggere la cartella madre: il poll
+ * gira ogni 1,5 s, e un `readdir` di `~/.claude/projects/` costerebbe a ogni
+ * tick per trovare un nome già noto. Su win32 tutte quelle che coincidono a
+ * meno delle maiuscole (`matchingDirNames`): Claude Code non normalizza la
+ * lettera del drive, e lo stesso progetto ne ha due.
+ */
+function transcriptDirs(projectRoot) {
+    const root = claudeProjectsRoot();
+    const name = projectDirName(projectRoot);
+    if (process.platform !== 'win32')
+        return [join(root, name)];
+    let entries;
     try {
-        files = readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
+        entries = readdirSync(root);
     }
     catch {
         return [];
     }
-    const out = [];
+    return matchingDirNames(entries, name).map((e) => join(root, e));
+}
+// Discovery read-only delle sessioni del SOLO progetto corrente (D2 preflight
+// T27): legge le project dir calcolate dal forward-transform, filtra per cwd
+// (difesa contro le collisioni lossy del naming), ordina con `compareSessions`.
+//
+// D1 preflight T175 — restano fuori le conversazioni AVVIATE in una
+// sottocartella, su ogni piattaforma: Claude Code ne scrive il transcript nella
+// cartella che codifica la cwd di avvio, cioè un'altra. Il filtro accetta una
+// cwd sotto la root perché non scarta niente di legittimo, non per raccoglierle.
+export function discoverProjectSessions(projectRoot) {
+    // Keyed sul sessionId: su win32 due cartelle dello stesso progetto potrebbero
+    // portare lo stesso transcript, e due righe con un id solo romperebbero la
+    // selezione. Vince il più recente.
+    const out = new Map();
     const seen = new Set();
-    for (const f of files) {
-        const path = join(dir, f);
-        seen.add(path);
-        let mtime;
-        let sizeBytes;
+    for (const dir of transcriptDirs(projectRoot)) {
+        let files;
         try {
-            const st = statSync(path);
-            mtime = st.mtimeMs;
-            sizeBytes = st.size;
+            files = readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
         }
         catch {
             continue;
         }
-        const cached = cache.get(path);
-        let session;
-        if (cached && cached.mtime === mtime) {
-            session = cached.session;
-        }
-        else {
-            session = parseSessionFile(path, mtime, sizeBytes);
-            cache.set(path, { mtime, session });
-        }
-        if (session && (session.cwd === projectRoot || session.cwd.startsWith(projectRoot + '/'))) {
-            out.push(session);
+        for (const f of files) {
+            const path = join(dir, f);
+            seen.add(path);
+            let mtime;
+            let sizeBytes;
+            try {
+                const st = statSync(path);
+                mtime = st.mtimeMs;
+                sizeBytes = st.size;
+            }
+            catch {
+                continue;
+            }
+            const cached = cache.get(path);
+            let session;
+            if (cached && cached.mtime === mtime) {
+                session = cached.session;
+            }
+            else {
+                session = parseSessionFile(path, mtime, sizeBytes);
+                cache.set(path, { mtime, session });
+            }
+            if (!session || !isWithin(session.cwd, projectRoot))
+                continue;
+            const prev = out.get(session.sessionId);
+            if (!prev || session.ts > prev.ts)
+                out.set(session.sessionId, session);
         }
     }
     for (const key of cache.keys())
         if (!seen.has(key))
             cache.delete(key);
-    out.sort(compareSessions);
-    return out;
+    return [...out.values()].sort(compareSessions);
 }
 // Raggruppa per gitBranch (D2: group-by-branch nel progetto corrente). Ordine
 // dei gruppi = la prima sessione di ciascuno, con `compareSessions`; dentro il

package/dist/spawn.js

@@ -8,6 +8,9 @@ import { dirname, join } from 'node:path';
 // è DATO PURO e non importa questo file: la dipendenza va in un verso solo.
 // Qui restano i soli effetti verso l'esterno — comporre un argv e lanciarlo.
 import { MODEL_DEFAULT, PROJECT_STATUS_MODEL } from './spawn-catalog.js';
+import { isAvailable } from './platform.js';
+import { claudeLauncher } from './claude-cmd.js';
+import { claudeEnv } from './git-bash.js';
 // scripts/deck-run è un sibling della dir del bundle: src/ (dev, tsx) e dist/
 // (build, node) stanno entrambi sotto la package root → risalita di un livello.
 export const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'deck-run');
@@ -27,9 +30,14 @@ export const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scr
  * test misura resta identico.
  */
 export const NO_SPAWN = process.env.LOOM_DECK_NO_SPAWN === '1';
+// T175 — `windowsHide` su OGNI figlio, qui e non a ogni chiamante: su Windows
+// un processo console lanciato senza apre una finestra (un `claude -p`, un
+// `git`), e ogni sede di spawn che la dimenticasse ne farebbe lampeggiare una a
+// ogni giro. Su Linux l'opzione non ha effetto. Un chiamante può ancora
+// sovrascriverla, perché `opts` viene dopo.
 export function spawnOut(cmd, args, opts) {
     if (!NO_SPAWN)
-        return spawn(cmd, args, opts);
+        return spawn(cmd, args, { windowsHide: true, ...opts });
     // Figlio inerte: emette nulla, quindi i `.on('error'|'close')` dei chiamanti
     // restano appesi senza mai scattare — che è esattamente "non è successo niente".
     const fake = new EventEmitter();
@@ -347,8 +355,11 @@ export function spawnTerminal(cwd, title) {
     child.unref();
     return child;
 }
-// Comando claude (override per ambienti dove non è su PATH; loom-deck → NPM).
-export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
+// Il NOME di claude nelle note della riga di stato: l'override se c'è,
+// `claude` altrimenti. Non è ciò che si esegue — quello lo risolve
+// `claudeLauncher` (`claude-cmd.ts`), che su Windows può arrivare a
+// `node …cli.js` da uno shim npm: nelle note resta il nome che l'utente conosce.
+export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD || 'claude';
 // T30: invocazione di una skill del plugin da CC HEADLESS (`-p`), con
 // `--session-id` pinnato. È la TERZA strada per eseguire uno script del plugin
 // da un consumer che non ha `CLAUDE_PLUGIN_ROOT`: il path version-pinned della
@@ -365,7 +376,12 @@ export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
 // ha funzionato" — che su un'operazione distruttiva non basta a sapere se
 // qualcosa è stato rimosso.
 function spawnSkill(prompt, cwd, sessionId, onResult, extraArgs = []) {
-    const child = spawnOut(CLAUDE_CMD, [
+    // T175 — il lanciatore risolto (shim npm compreso, mai una shell) e, su
+    // Windows, l'env col bash di Git: senza, un deck avviato da Git Bash passa al
+    // figlio il `PATH` che manda gli hook del plugin in PowerShell.
+    const claude = claudeLauncher();
+    const child = spawnOut(claude.cmd, [
+        ...claude.prefix,
         '-p',
         '--output-format',
         'stream-json',
@@ -374,7 +390,7 @@ function spawnSkill(prompt, cwd, sessionId, onResult, extraArgs = []) {
         sessionId,
         ...extraArgs,
         prompt,
-    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'], env: claudeEnv() });
     let buf = '';
     let isError = null;
     let detail = '';
@@ -491,7 +507,13 @@ export const NOTIFY_CMD = process.env.LOOM_DECK_NOTIFY_CMD ?? 'notify-send';
 // Agganciato, la degradazione è MUTA (D6): un binario assente è una proprietà
 // stabile della macchina, e dirlo a ogni generazione sarebbe lo stesso messaggio
 // a ogni giro su una funzione che non è il deliverable.
+//
+// T175 — dove le notifiche non ci sono, nessuno spawn e nessun avviso: non
+// hanno un tasto né un pane, e l'esito del project status è già nella riga di
+// stato. Il `null` dice al chiamante che niente è partito.
 export function notifyDone(title, body) {
+    if (!isAvailable('notify'))
+        return null;
     const child = spawnOut(NOTIFY_CMD, ['--app-name=loom-deck', title, body], {
         detached: true,
         stdio: 'ignore',