@lamemind/loom-deck 0.75.0 → 0.77.0

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

@@ -200,7 +200,7 @@ export function inboxPrompt(f) {
  * riscriverla.
  *
  * Il `.md` si toglie QUI e non lo si lascia cadere a valle: l'alfabeto di
- * `_sane_note` non ha il punto, quindi il titolo della tab uscirebbe con le due
+ * `saneNote` non ha il punto, quindi il titolo della tab uscirebbe con le due
  * lettere saldate al nome (`…-prioritariamd`) mentre la lista del deck, che
  * legge la nota grezza dal sidecar, mostrerebbe il nome intero — la stessa
  * conversazione con due nomi, senza errore.
@@ -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,93 @@
+// 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: [
+        'liveSessions', // T177 — liveness senza /proc; spegne anche resume e restore
+        '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,102 @@
+// 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);
+}
+/**
+ * T176 — la cartella in cui nasce la tab che riprende o forka una conversazione.
+ *
+ * Su Linux la root del progetto, come prima. Su win32 la cwd che la
+ * conversazione ha registrato, in forma Windows (P7 preflight): `claude
+ * --resume` cerca il transcript nella cartella che ricava dalla PROPRIA cwd, e
+ * Claude Code non normalizza la lettera del drive (T174 verdetto 1) — una
+ * conversazione nata da VS Code (`c:\…`) sta in `c--…`, e un `claude` partito in
+ * `C:\…` la cercherebbe in `C--…`, senza trovarla.
+ *
+ * Una cwd in forma MSYS (`/c/…`) non dice la grafia del drive: la dice il nome
+ * della cartella del transcript, che Claude Code ha derivato dalla cwd vera
+ * (`c--…` o `C--…`). Una cwd che non è un path assoluto Windows ricade sulla
+ * root.
+ */
+export function conversationCwd(sessionCwd, transcriptPath, root, platform = process.platform) {
+    if (platform !== 'win32')
+        return root;
+    if (/^[a-zA-Z]:[\\/]/.test(sessionCwd))
+        return sessionCwd.replace(/\//g, '\\');
+    if (sessionCwd.startsWith('\\\\'))
+        return sessionCwd;
+    const msys = /^\/([a-zA-Z])(?:\/(.*))?$/.exec(sessionCwd);
+    if (!msys)
+        return root;
+    const folder = win32.basename(win32.dirname(transcriptPath));
+    const letter = folder.length > 2 && folder.slice(1, 3) === '--' && folder[0].toLowerCase() === msys[1].toLowerCase()
+        ? folder[0]
+        : msys[1].toUpperCase();
+    return `${letter}:\\${(msys[2] ?? '').replace(/\//g, '\\')}`;
+}

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/sane-note.js

@@ -1,35 +1,29 @@
-// T161 — il gemello TypeScript di `_sane_note`, la riduzione che `deck-run`
-// applica a ogni nota del titolo.
+// La riduzione della nota del titolo di una tab: l'unica, per il deck e per
+// `deck-run`.
 //
-// Perché serve un gemello. La nota del titolo è l'UNICO ingresso di testo libero
-// nel titolo di una tab, quindi `deck-run` non la quota: la RIDUCE a una
-// whitelist chiusa di code point, e tutto ciò che non ci rientra sparisce senza
-// errore. Finché la nota nasceva da un campo scritto al volo, la divergenza fra
-// quello che si legge nel deck e quello che compare nella tab durava il tempo di
-// uno spawn. Da quando un TEMPLATE del titolo si scrive in una pagina e si salva
-// su disco, quella divergenza diventa permanente: il file direbbe una cosa e la
-// tab ne mostrerebbe un'altra, per sempre e senza un errore da nessuna parte.
+// La nota del titolo è l'UNICO ingresso di testo libero nel titolo di una tab,
+// quindi non si quota: si RIDUCE a una whitelist chiusa di code point, e tutto
+// ciò che non ci rientra sparisce senza errore. Da quando un TEMPLATE del titolo
+// si scrive in una pagina e si salva su disco (T161), la riduzione si applica
+// anche QUI, al confine — al salvataggio e alla lettura del blocco `spawn` —
+// così quello che sta nel file è quello che la tab mostrerà.
 //
-// La riduzione si applica quindi QUI, al confine — al salvataggio e alla
-// lettura del blocco `spawn` — così quello che sta nel file è quello che la tab
-// mostrerà.
-//
-// L'ALLINEAMENTO fra i due lati non è assunto: `test/sane-note.test.ts` passa la
-// stessa batteria di input a questa funzione e a `deck-run` vero (via lo shim
-// `ptyxis` di `deck-run.test.ts`) e pretende l'uguaglianza. La whitelist non si
-// allarga — e se un giorno lo facesse, sono tre le sedi da toccare insieme
-// (`deck-run`, questo file, le emoji dei titoli in `spawn-catalog.ts`), col test
-// che fallisce se una resta indietro.
+// T176 — fino a T176 questo modulo era il gemello di `_sane_note`, la stessa
+// riduzione scritta in bash dentro `deck-run`, e un test teneva uguali i due
+// lati. Il composer della tab ora è TypeScript (`src/tab-compose.ts`) e chiama
+// questa funzione: la whitelist ha due sedi da toccare insieme, questo file e le
+// emoji dei titoli in `spawn-catalog.ts`, e `test/deck-run.test.ts` fallisce se
+// un'emoji di un titolo del catalogo non passa.
 /**
  * L'alfabeto ammesso, negato: lettere, cifre, spazio, `_`, `-`, le accentate
  * italiane e sette emoji.
  *
- * Whitelist e non blacklist, come in bash: il titolo finisce dentro apici
- * singoli in `bash -lc "claude --name '…'"`, ed enumerare i caratteri pericolosi
- * significa sbagliarne uno.
+ * Whitelist e non blacklist: il titolo finisce in una riga di shell su Linux
+ * (`bash -lc "claude --name '…'"`) e nella riga di `wt.exe` su Windows, ed
+ * enumerare i caratteri pericolosi significa sbagliarne uno.
  *
  * Le sette emoji sono nominate una per una e NON come intervallo di code point,
- * per due ragioni che valgono su entrambi i lati: un'emoji arriva nella tab solo
+ * per due ragioni: un'emoji arriva nella tab solo
  * se il deck la mostra identica in lista, cioè se `sanitize` (`src/width.ts`) la
  * lascia passare invece di renderla `·`, e quel verdetto si verifica un glifo
  * alla volta; e l'ordine di un intervallo dentro un bracket expression segue la