@lamemind/loom-deck 0.75.0 → 0.77.0

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-catalog.js

@@ -123,9 +123,9 @@ const UNWRAP_PROMPT = 'lancia md-wrap modo apply su {path} e backup in cartella
  * non per gusto: `sanitize` (`src/width.ts`) sostituisce con `·` ogni glifo su
  * cui le due contabilità di larghezza divergono, e le emoji del BMP a
  * presentazione testo divergono sempre. Le stesse SETTE (T160 aggiunge `🧭`)
- * stanno nella whitelist di `_sane_note` in `deck-run` e nel suo gemello
- * `src/sane-note.ts`: un'emoji cambiata qui e non là sparisce fra la tabella e
- * la tab, senza errore.
+ * stanno nella whitelist di `saneNote` (`src/sane-note.ts`), la riduzione del
+ * titolo: un'emoji cambiata qui e non là sparisce fra la tabella e la tab,
+ * senza errore.
  */
 export const SPAWN_ACTIONS = [
     {
@@ -276,7 +276,7 @@ export const SPAWN_ACTIONS = [
         // DUE buchi per lo stesso dato, e servono entrambi: `{target}` è il path
         // VERO, che la skill risolve contro la colonna `PATH` della misura, e
         // `{words}` lo stesso path reso a parole per il titolo. L'alfabeto di
-        // `_sane_note` non ha né `/` né `.`, quindi un `{target}` in un template di
+        // `saneNote` non ha né `/` né `.`, quindi un `{target}` in un template di
         // titolo uscirebbe con le parole saldate (`runtimereferencedoc-systemmd`) e
         // la tab mostrerebbe un nome diverso da quello che il deck legge dal
         // sidecar.

package/dist/spawn-config.js

@@ -4,7 +4,7 @@
 // ── La sede (P19 preflight) ─────────────────────────────────────────────────
 // Blocco `spawn` dentro `.claude/loom-works.json`, il file di progetto che il
 // deck già apre in tre loader (`launch`, `archivableDays`, `identity`) e che
-// `deck-run` legge con `jq`. Nessun file nuovo: sotto `.claude/` ci sono già tre
+// `deck-run` legge per label e permission mode. Nessun file nuovo: sotto `.claude/` ci sono già tre
 // file di loom, e le impostazioni di spawn sono decisioni di progetto che devono
 // viaggiare col repo — cioè committate, esattamente come `permissionMode` e
 // `order`, e a differenza della vista (`.claude/loom/deck-view.json`, che è
@@ -34,9 +34,9 @@
 // ── Chi legge cosa ──────────────────────────────────────────────────────────
 // Il blocco lo legge il SOLO deck, che risolve la terna e la passa a `deck-run`
 // sempre esplicita nell'argv (`--title-note`, `--model`, `--prompt`). `deck-run`
-// non lo legge e non deve: `jq` è dipendenza OPZIONALE di quello script, e
-// dargli un blocco JSON da consultare la renderebbe obbligatoria su un percorso
-// che oggi degrada senza. La cascata env → catalogo → `fable` di `deck-run`
+// non lo legge e non deve: la terna che parte è quella che il deck ha mostrato,
+// e una seconda risoluzione dall'altra parte del processo sarebbe una seconda
+// copia delle stesse regole. La cascata env → catalogo → `fable` di `deck-run`
 // resta intatta per chi lo invoca a mano.
 import { readFileSync, writeFileSync } from 'node:fs';
 import { configFilePath } from './config.js';

package/dist/spawn.js

@@ -8,9 +8,26 @@ 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, gitBash } from './git-bash.js';
+import { windowsTabEnv, WT_CMD, wtNewTabArgs, wtProfile } from './windows-terminal.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');
+// T176 — il punto d'ingresso che lo shim `scripts/deck-run` esegue, nel build.
+// Su Windows il deck lo lancia da sé: CreateProcess non esegue uno script bash
+// senza estensione.
+export const DECK_RUN_JS = join(dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'deck-run.js');
+/**
+ * Come il deck lancia `deck-run`: lo shim su Linux, il node del deck sul punto
+ * d'ingresso su Windows. Le due forme eseguono lo stesso programma — lo shim è
+ * una riga che fa `exec node dist/deck-run.js` —, e su Linux resta lo shim
+ * perché è il comando che la riga di stato mostra e che si ripete a mano.
+ */
+export function deckRunLauncher(platform = process.platform, nodePath = process.execPath) {
+    return platform === 'win32' ? { cmd: nodePath, prefix: [DECK_RUN_JS] } : { cmd: DECK_RUN, prefix: [] };
+}
 /**
  * Freno agli effetti VERSO L'ESTERNO (tab Ptyxis, sessioni Claude, git commit).
  *
@@ -27,9 +44,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();
@@ -70,13 +92,15 @@ export function shellCommand(cmd, args) {
 // comando in-tab (vedi `onInTabCommand`). Il figlio resta detached — la pipe
 // serve a leggere una riga, non a possedere il processo.
 function launchDeckRun(args, cwd) {
-    const child = spawnOut(DECK_RUN, args, {
+    const run = deckRunLauncher();
+    const argv = [...run.prefix, ...args];
+    const child = spawnOut(run.cmd, argv, {
         cwd,
         detached: true,
         stdio: ['ignore', 'pipe', 'ignore'],
     });
     child.unref();
-    return { child, cmd: shellCommand(DECK_RUN, args) };
+    return { child, cmd: shellCommand(run.cmd, argv) };
 }
 /** Prefisso della riga con cui `deck-run` annuncia il comando in-tab. */
 export const INTAB_MARKER = 'LOOM_DECK_INTAB ';
@@ -144,10 +168,9 @@ export function onInTabCommand(child, cb) {
 // acceleratori della lista passavano `--prompt-kind` e lasciavano risolvere il
 // testo a `deck-run`, che consultava il proprio catalogo; il detail passava già
 // il letterale. Con un override di progetto sui prompt la risoluzione deve
-// stare da una parte sola, e quella parte è il deck — che è l'unico dei due a
-// leggere `.claude/loom-works.json` per questo (`jq` è dipendenza opzionale di
-// `deck-run`). Un percorso solo, quindi, e ciò che parte è verificabile
-// sull'argv.
+// stare da una parte sola, e quella parte è il deck — l'unico dei due che legge
+// il blocco `spawn` di `.claude/loom-works.json`. Un percorso solo, quindi, e
+// ciò che parte è verificabile sull'argv.
 //
 // Due conseguenze dichiarate: `--prompt-kind` resta in `deck-run` per chi lo
 // invoca a mano, e `LOOM_DECK_ENTER_PROMPT` non ha più effetto sugli spawn dal
@@ -338,7 +361,36 @@ export function runLaunch(entry, cwd) {
 export function terminalArgs(cwd, title) {
     return title ? ['--tab', '-T', title, '-d', cwd] : ['--tab', '-d', cwd];
 }
+/**
+ * T176 — il tasto `t` su Windows (P10 preflight): una tab di Windows Terminal
+ * nella finestra attiva, col profilo del deck e il titolo bloccato, SENZA
+ * comando — la shell è il `commandline` del profilo, come `ptyxis --tab` apre
+ * quella del profilo di Ptyxis.
+ */
+export function windowsTerminalArgs(cwd, title, env = process.env) {
+    return wtNewTabArgs({ newWindow: false, profile: wtProfile(env), cwd, title });
+}
+/** Il terminale del tasto `t`, per nome: è ciò che la nota dice quando non parte. */
+export function terminalName(platform = process.platform) {
+    return platform === 'win32' ? WT_CMD : 'ptyxis';
+}
 export function spawnTerminal(cwd, title) {
+    if (process.platform === 'win32') {
+        // La tab eredita l'env del deck (T174 verdetto 5): senza i marker di
+        // sessione e senza `LOOM_TASK`, col bash di Git — come una conversazione
+        // `--no-task`, perché un `claude` lanciato da questa shell nascerebbe con
+        // l'env che riceve. `windowsHide: false`: `wt.exe` è un'app GUI, e con
+        // `true` una finestra nuova partirebbe nascosta.
+        const child = spawnOut(WT_CMD, windowsTerminalArgs(cwd, title), {
+            cwd,
+            detached: true,
+            stdio: 'ignore',
+            env: windowsTabEnv(process.env, null, gitBash()),
+            windowsHide: false,
+        });
+        child.unref();
+        return child;
+    }
     const child = spawnOut('ptyxis', terminalArgs(cwd, title), {
         cwd,
         detached: true,
@@ -347,8 +399,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 +420,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 +434,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 +551,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',

package/dist/tab-args.js

@@ -0,0 +1,141 @@
+/** I kind accettati da `--prompt-kind`. Enum e non stringa libera: un kind è un
+ *  simbolo interno del deck, e uno fuori elenco è un errore del chiamante. */
+export const PROMPT_KINDS = [
+    'none',
+    'recap',
+    'recap-task',
+    'recap-epic',
+    'preflight',
+    'run',
+    'checkpoint',
+];
+export const USAGE = `uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--session-id <uuid>]
+                                                   (es. deck-run T18)
+     | deck-run --no-task                          (sessione nuda, senza task)
+     | deck-run <TaskID> --resume <uuid>           (riprende sessione scoped)
+     | deck-run --no-task --resume <uuid>          (riprende sessione spot)
+     | deck-run <TaskID> --resume <uuid> --fork [--session-id <nuovo-uuid>]
+                                                   (forka: ramo con id NUOVO)
+
+  --prompt-kind  prompt iniziale della sessione bound (default: recap)
+       none        nessun prompt — sessione aperta sulla task, a mani nude
+       recap       /loom-works:recap-status <TaskID>       (dispatcher)
+       recap-task  /loom-works:recap-status-task <TaskID>  (task non cappello)
+       recap-epic  /loom-works:recap-status-epic <TaskID>  (Size: Epic)
+       preflight   /loom-works:preflight-task <TaskID>
+       run         /loom-works:run-task <TaskID>
+       checkpoint  /loom-works:checkpoint-task <TaskID>
+
+  --prompt       prompt LETTERALE, per chi lo ha già composto (o fatto
+                 modificare). Esclusivo con --prompt-kind; vuoto = nessun
+                 prompt. Ammesso anche con --no-task: un testo già scritto non
+                 ha una task da nominare, a differenza dei kind del catalogo
+
+  --model        modello della sessione: fable|opus|sonnet|haiku
+                 (default: il modello del kind in catalogo, o 'fable' fuori catalogo)
+                 valore ignoto → fallback sul default, con avviso su stderr
+
+  --title-note   nota della conversazione, appesa al titolo tab
+                 (ridotta a lettere/cifre/spazi/-/_, cap 60 char)
+
+  --new-window   apre una FINESTRA nuova invece di una tab nella finestra
+                 attiva. Per chi chiama da fuori dalla finestra del progetto`;
+/** I flag che portano un valore, nel campo della richiesta che lo riceve. */
+const VALUED = {
+    '--model': 'model',
+    '--title-note': 'titleNote',
+    '--prompt-kind': 'promptKind',
+    '--prompt': 'promptText',
+    '--session-id': 'sessionId',
+    '--resume': 'resumeId',
+};
+function usageError(...lines) {
+    return { lines: [...lines, USAGE] };
+}
+/**
+ * L'argv di `deck-run` come richiesta validata, o l'errore d'uso.
+ *
+ * Le due forme di un flag con valore (`--model x` e `--model=x`) valgono uguale;
+ * un argomento che non è un flag noto è il TaskID se il TaskID non c'è ancora,
+ * altrimenti un errore — anche `--qualcosa`, come nello script.
+ *
+ * L'ordine delle validazioni è quello dello script, perché è l'ordine in cui un
+ * chiamante riceve i messaggi quando più regole sono violate insieme.
+ */
+export function parseTabArgs(argv) {
+    const req = {
+        task: '',
+        noTask: false,
+        sessionId: '',
+        resumeId: '',
+        fork: false,
+        newWindow: false,
+        titleNote: '',
+        promptKind: '',
+        promptText: '',
+        promptGiven: false,
+        model: '',
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const eq = arg.indexOf('=');
+        const name = eq > 0 ? arg.slice(0, eq) : arg;
+        const field = VALUED[name];
+        if (field) {
+            let value;
+            if (eq > 0)
+                value = arg.slice(eq + 1);
+            else if (i + 1 < argv.length)
+                value = argv[++i];
+            else
+                return usageError(`${name} richiede un valore`);
+            req[field] = value;
+            if (field === 'promptText')
+                req.promptGiven = true;
+            continue;
+        }
+        if (arg === '--fork')
+            req.fork = true;
+        else if (arg === '--no-task')
+            req.noTask = true;
+        else if (arg === '--new-window')
+            req.newWindow = true;
+        else if (!req.task)
+            req.task = arg;
+        else
+            return { lines: [`argomento inatteso: '${arg}'`] };
+    }
+    if (req.noTask && req.task) {
+        return usageError('--no-task e <TaskID> sono mutuamente esclusivi');
+    }
+    if (!req.noTask && !req.task)
+        return usageError();
+    if (req.fork && !req.resumeId) {
+        return usageError('--fork richiede --resume <uuid>: si forka una conversazione esistente, non il nulla');
+    }
+    // Una ripresa nuda riscrive il transcript dell'id ripreso, quindi un id
+    // pinnato non ha senso; il fork apre un transcript NUOVO, che si può pinnare.
+    if (req.resumeId && req.sessionId && !req.fork) {
+        return usageError('--resume e --session-id sono mutuamente esclusivi (la sessione ripresa ha già il suo id)', 'usa --fork se vuoi un ramo con id nuovo');
+    }
+    // Un kind fuori catalogo è un errore del CHIAMANTE (simbolo interno, non
+    // configurazione utente): uscita, non fallback silenzioso come il modello.
+    if (req.promptKind && !PROMPT_KINDS.includes(req.promptKind)) {
+        return usageError(`--prompt-kind ignoto: '${req.promptKind}' (usa ${PROMPT_KINDS.join('|')})`);
+    }
+    // Ogni prompt del catalogo nomina il TaskID: senza task produrrebbe un
+    // comando monco (`/loom-works:run-task ` con l'id vuoto). Il testo letterale
+    // invece è ammesso con `--no-task` (T134/D9): non ha una task da nominare.
+    if (req.noTask && req.promptKind) {
+        return usageError('--prompt-kind richiede una task: una sessione --no-task non ha prompt iniziale');
+    }
+    // Due modi di dire la stessa cosa: accettarli insieme obbligherebbe a
+    // stabilire quale vince.
+    if (req.promptGiven && req.promptKind) {
+        return usageError('--prompt e --prompt-kind sono mutuamente esclusivi (il testo o il simbolo, non entrambi)');
+    }
+    return req;
+}
+export function isUsageError(r) {
+    return 'lines' in r;
+}