@lamemind/loom-deck 0.76.0 → 0.77.0

package/README.md

@@ -387,11 +387,33 @@ npx @lamemind/loom-deck
 ## Requisiti runtime
 
 - **Node.js ≥ 18** (dichiarato in `engines`).
-- **[Ptyxis](https://gitlab.gnome.org/chergert/ptyxis)** (terminale GNOME) — **dipendenza di runtime, non risolvibile da npm**. Lo spawn di una tab (`scripts/deck-run`) invoca il binario `ptyxis`: l'**install riesce anche senza**, ma al momento dello spawn il comando
+- **[Ptyxis](https://gitlab.gnome.org/chergert/ptyxis)** (terminale GNOME), su Linux — **dipendenza di runtime, non risolvibile da npm**. Lo spawn di una tab (`scripts/deck-run`) invoca il binario `ptyxis`: l'**install riesce anche senza**, ma al momento dello spawn il comando
   fallisce (gestito: handler `error` → la TUI resta viva, mostra la nota). Senza una GUI
   GNOME con Ptyxis installato, il deck naviga i task ma **non apre sessioni**.
 - **[Claude Code](https://claude.com/claude-code)** nel `PATH` — la tab spawnata avvia `claude`.
 
+### Su Windows
+
+Le tab si aprono in **Windows Terminal** (`wt.exe`, l'alias d'esecuzione che l'installazione dello Store mette nel `PATH`), nella finestra usata per ultima: `wt.exe -w 0 new-tab -p loom-deck -d <root> --title <titolo> --suppressApplicationTitle -- <node> <dist/tab-wrapper.js>`. L'argv di `claude` — nome, flag, prompt — non sta su quella riga: viaggia come JSON nella variabile `LOOM_DECK_TAB_ARGV`, che la tab eredita dal processo che lancia `wt.exe`, e il wrapper lo passa a `claude` senza shell. Il prompt non passa quindi né dal parser di `wt`, che legge `;` come separatore di sottocomandi in qualunque argomento, né da cmd o PowerShell.
+
+Le tab usano il profilo di Windows Terminal **`loom-deck`**, uno solo per tutti i progetti. Il deck non lo crea e non scrive `settings.json`: lo si aggiunge a mano in `%LOCALAPPDATA%\Packages\Microsoft.WindowsTerminal_8wekyb3d8bbwe\LocalState\settings.json`, sotto `profiles.list`, nascosto dal menu. Porta solo ciò che i flag di `wt` non sanno dire — titolo, cartella e comando li passa il deck, e battono quelli del profilo:
+
+```jsonc
+{
+  "name": "loom-deck",
+  "guid": "{<un GUID nuovo>}",
+  "hidden": true,
+  "commandline": "%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -NoLogo",
+  "closeOnExit": "graceful"
+}
+```
+
+`commandline` è la shell del tasto `t`; nelle conversazioni il comando del deck prende il suo posto. `closeOnExit` decide cosa resta della tab quando `claude` esce (il wrapper esce col suo codice). Senza il profilo la tab si apre comunque, col profilo di default. Il nome si cambia con `LOOM_DECK_WT_PROFILE` (vuota = nessun `-p`).
+
+La tab eredita tutto l'env del deck, tranne i marker che una sessione Claude Code inietta nei figli (`CLAUDECODE`, `CLAUDE_CODE_CHILD_SESSION`, …): con quelli una conversazione aperta da un deck lanciato dentro Claude Code non salverebbe il transcript. Se manca, il deck aggiunge `CLAUDE_CODE_GIT_BASH_PATH`: col `PATH` di Git Bash `claude` eseguirebbe gli hook del plugin in PowerShell, e la task non arriverebbe in contesto.
+
+Su Windows il resume di una conversazione e il restore (`^T`) restano spenti con un avviso finché il deck non sa quali conversazioni sono vive: senza quella informazione un resume può riaprire una conversazione già aperta in un'altra tab. Il fork resta acceso, perché apre un transcript nuovo.
+
 ## Uso (spike ①)
 
 ```bash

package/dist/actions.js

@@ -17,13 +17,15 @@
 // migliorano di passaggio.
 import { useRef } from 'react';
 import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { conversationCwd } from './project-path.js';
 import { taskSlug } from './tasks.js';
 import { appendNote, appendPin, appendPriority, appendSessionRecord, appendTaskBinding, } from './task-index.js';
 import { neighborId } from './session-list.js';
 import { cut, cutMiddle } from './width.js';
 import { dropSessionFiles, sessionArtifacts } from './session-drop.js';
 import { saveView, viewFilePath } from './view-store.js';
-import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, DECK_RUN, } from './spawn.js';
+import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, terminalName, DECK_RUN, } from './spawn.js';
 import { MODEL_DEFAULT } from './spawn-catalog.js';
 import { modelAlias } from './glyphs.js';
 import { resolveSpawnId } from './spawn-config.js';
@@ -103,7 +105,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     }
     /** I buchi di un'azione su task. Lo slug viene dal NOME del task file, non
      *  dalla descrizione di `tasks.md`: il nome è già dentro l'alfabeto di
-     *  `_sane_note` per costruzione — minuscolo, separato da trattini, senza
+     *  `saneNote` per costruzione — minuscolo, separato da trattini, senza
      *  punteggiatura — mentre la descrizione porta apostrofi e `/` che la riduzione
      *  toglie senza sostituto, saldando le parole. Task file assente → slug vuoto,
      *  e il titolo si spegne invece di ridursi al solo prefisso. */
@@ -220,9 +222,22 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     // ricerca e il restore il modello ereditato dalla sessione senza superficie
     // di scelta (D1 preflight). I chiamanti restano la stessa azione perché è
     // lo spawn a essere identico, non la sorgente del valore.
+    /**
+     * T176 — la cartella della tab di una ripresa o di un fork: la root su Linux,
+     * la cwd registrata dalla conversazione su Windows (`conversationCwd`, P7
+     * preflight). Una cartella che non esiste più ricade sulla root: lo spawn
+     * fallirebbe prima ancora di aprire la tab.
+     */
+    function tabCwdOf(sessionId) {
+        const s = model.sessions.find((x) => x.sessionId === sessionId);
+        if (!s)
+            return cwd;
+        const dir = conversationCwd(s.cwd, s.path, cwd);
+        return dir === cwd || existsSync(dir) ? dir : cwd;
+    }
     function resumeSession(sessionId, modelKind) {
         const bound = model.bindings.get(sessionId) ?? null;
-        const spawned = spawnDeckResume(bound, cwd, sessionId, modelKind, model.sessionNotes.get(sessionId));
+        const spawned = spawnDeckResume(bound, tabCwdOf(sessionId), sessionId, modelKind, model.sessionNotes.get(sessionId));
         spawned.child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
         noteSpawn(spawned);
         return spawned;
@@ -242,6 +257,12 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
     function openSession(sessionId, modelKind) {
         if (refuse('spawn', '⏎', setNote, 'resume'))
             return;
+        // T176 — il resume vuole sapere se la conversazione è viva, non solo poter
+        // aprire una tab (D4 preflight): senza liveness un `⏎` su una conversazione
+        // aperta in un'altra tab avvierebbe un secondo `claude` sullo stesso
+        // transcript. Spento finché la piattaforma non ha le sessioni vive.
+        if (refuse('liveSessions', '⏎', setNote, 'resume'))
+            return;
         enterSession(sessionId, {
             isLive: (id) => model.live.has(id),
             nameOf: (id) => model.live.get(id)?.name || id.slice(0, 8),
@@ -275,6 +296,12 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
      * chiudendo le tab.
      */
     function restoreSessions() {
+        // T176 — la guardia delle sessioni vive PRIMA di quella dello spawn (P8
+        // preflight): l'insieme da riaprire è l'ultimo insieme vivo, e senza
+        // liveness sarebbe vuoto — «nessuna conversazione da riaprire» direbbe uno
+        // stato dove manca una funzione.
+        if (refuse('liveSessions', '^T', setNote, 'restore delle conversazioni'))
+            return;
         if (refuse('spawn', '^T', setNote, 'restore delle conversazioni'))
             return;
         const list = model.restorable;
@@ -406,7 +433,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
         // T148 — il fork è l'altra continuità che condivide la stessa riga
         // selezionata: porta via lo stesso `model.resumeModel` del resume, non un
         // default fisso (P2 preflight).
-        const spawned = spawnDeckFork(bound, cwd, s.sessionId, newId, model.resumeModel);
+        const spawned = spawnDeckFork(bound, tabCwdOf(s.sessionId), s.sessionId, newId, model.resumeModel);
         spawned.child.on('error', () => setNote(`⚠ fork fallito (${DECK_RUN})`));
         noteSpawn(spawned);
     }
@@ -533,7 +560,7 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, overr
             return;
         const title = model.identity ? `🖥️ ${model.identity.name} [term]` : null;
         const child = spawnTerminal(cwd, title);
-        child.on('error', () => setNote('⚠ t → ptyxis non lanciabile'));
+        child.on('error', () => setNote(`⚠ t → ${terminalName()} non lanciabile`));
         setNote(`t → terminale su ${model.projectName}`);
     }
     /**

package/dist/config.js

@@ -115,7 +115,7 @@ export function launchLegend(entries, columns, reserved = 0) {
 // `identity` sopra sono strutture. La catena da percorrere si ferma qui: nessun
 // passaggio da `lib-config.sh`/`reg_pull`/dconf, perché il solo consumer è il
 // deck e il file ce l'ha sotto mano. Il precedente esatto è `permissionMode`,
-// che vive nel file, lo legge `deck-run` via jq e non è propagato al registry.
+// che vive nel file, lo legge anche `deck-run` e non è propagato al registry.
 /** Interi positivi soltanto: uno 0 spegnerebbe la soglia (tutte le Done
  *  archiviabili), un negativo o un decimale sono un typo. Valore fuori dominio
  *  → default, mai passaggio cieco di un numero senza senso al conteggio. */

package/dist/deck-run.js

@@ -0,0 +1,7 @@
+// T176 — il punto d'ingresso di `deck-run`: `scripts/deck-run` (lo shim bash
+// che compass e i test lanciano) e il deck su Windows eseguono questo file col
+// proprio node. La logica sta in `tab-launch.ts`, che si testa senza aprire tab.
+import { realIo, runDeckRun } from './tab-launch.js';
+runDeckRun(process.argv.slice(2), realIo()).then((code) => {
+    process.exitCode = code;
+});

package/dist/doc-tree.js

@@ -376,7 +376,7 @@ export function docTargetKind(row, docsRoot) {
  * T160 — il buco `{words}` del titolo di una sessione di rebalance: il path reso
  * a parole.
  *
- * Gemello di `wrapWords`, e per la stessa ragione: l'alfabeto di `_sane_note`
+ * Gemello di `wrapWords`, e per la stessa ragione: l'alfabeto di `saneNote`
  * non ha né `/` né `.`, quindi un path lasciato cadere lì dentro esce con le
  * parole saldate (`runtimereferencedoc-systemmd`) mentre la lista del deck, che
  * legge la nota grezza dal sidecar, mostrerebbe il path intero — la stessa

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.

package/dist/platform.js

@@ -17,8 +17,7 @@
  */
 export const UNAVAILABLE = {
     win32: [
-        'spawn', // T176 — tab di Windows Terminal al posto di ptyxis
-        'liveSessions', // T177 — liveness senza /proc
+        '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[]

package/dist/project-path.js

@@ -69,3 +69,34 @@ export function matchingDirNames(entries, name, platform = process.platform) {
     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/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

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

@@ -10,10 +10,24 @@ import { dirname, join } from 'node:path';
 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';
+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).
  *
@@ -78,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 ';
@@ -152,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
@@ -346,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,

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