@lamemind/loom-deck 0.76.0 → 0.77.0

package/dist/tab-compose.js

@@ -0,0 +1,233 @@
+// T176 — la COMPOSIZIONE di una tab di conversazione: dai quattro assi di
+// `deck-run` (`tab-args.ts`) a titolo, flag di `claude`, env di sessione e
+// comando in-tab.
+//
+// Un composer solo per Linux e Windows (D1 preflight). Cambia per piattaforma
+// solo CHI riceve il risultato: su Linux una riga per `bash -lc` dentro una tab
+// Ptyxis, su Windows l'argv di `claude` in una variabile d'ambiente letta dal
+// wrapper della tab (`windows-terminal.ts`). Titolo, modello, permission mode e
+// prompt si risolvono qui una volta, per entrambe.
+//
+// Modulo PURO: il file di progetto, il catalogo dei prompt e l'env arrivano già
+// letti. Le regole e i messaggi sono quelli dello script bash che questo modulo
+// ha sostituito, e il gate di parità su Linux (`test/deck-run.test.ts`) li
+// misura sul comando in-tab.
+import { saneNote } from './sane-note.js';
+import { MODEL_DEFAULT, MODELS } from './spawn-catalog.js';
+import { shellQuote } from './spawn.js';
+export const PERMISSION_MODES = ['acceptEdits', 'auto', 'bypassPermissions', 'manual', 'dontAsk', 'plan'];
+/** L'alfabeto della chiave di stato: il valore entra in `bash -lc "…"` e il
+ *  file di progetto è editabile a mano, quindi si scarta invece di quotare. */
+const STATE_KEY_RE = /^[A-Za-z0-9_-]+$/;
+/**
+ * Un campo del file di progetto come lo leggeva `jq -r '.campo // empty'`:
+ * `null`, `false` o assente danno vuoto, una stringa passa com'è, ogni altro
+ * valore diventa il suo JSON (`jq -r` stampa così numeri e oggetti).
+ */
+function configField(config, key) {
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        return '';
+    const v = config[key];
+    if (v === undefined || v === null || v === false)
+        return '';
+    return typeof v === 'string' ? v : JSON.stringify(v);
+}
+/**
+ * La label del progetto, `{emoji} {name}`: la chiave con cui compass riconosce
+ * la finestra cercando nel titolo della tab attiva. Vuota se il file manca o
+ * non porta entrambi i campi, e il titolo ricade su `cc`.
+ */
+export function projectLabel(config) {
+    const emoji = configField(config, 'emoji');
+    const name = configField(config, 'name');
+    return emoji && name ? `${emoji} ${name}` : '';
+}
+/**
+ * Il titolo della tab: label + `· <task>` + nota + `· fork`.
+ *
+ * La label sta in TESTA perché il match di compass è un `.includes` sulla
+ * chiave, e tutto il resto va in coda per non spezzarla. Il suffisso task
+ * distingue le tab di più task, la nota (T64) quelle di più conversazioni sulla
+ * stessa task, `· fork` (T28) un ramo dalla sua origine. La nota è l'unico testo
+ * libero del titolo: non si quota, si RIDUCE (`saneNote`) — e ridotta a vuoto
+ * non lascia nessun suffisso.
+ */
+export function tabTitle(req, label) {
+    let title;
+    if (req.noTask)
+        title = label || 'cc';
+    else
+        title = label ? `${label} · ${req.task}` : `cc ${req.task}`;
+    if (req.titleNote) {
+        const note = saneNote(req.titleNote);
+        if (note)
+            title = `${title} ${note}`;
+    }
+    if (req.fork)
+        title = `${title} · fork`;
+    return title;
+}
+/**
+ * Il permission mode: env `LOOM_DECK_PERMISSION_MODE` > campo del file > `manual`.
+ *
+ * Passato SEMPRE al CLI, anche `manual`: lo spawn resta deterministico invece
+ * di dipendere da un default che cambia fra versioni. Un valore fuori elenco
+ * non arriva al CLI — produrrebbe una tab con un comando rotto — e degrada a
+ * `manual` con un avviso.
+ */
+function permissionMode(ctx, warnings) {
+    const raw = ctx.env.LOOM_DECK_PERMISSION_MODE || configField(ctx.config, 'permissionMode');
+    if (!raw)
+        return 'manual';
+    if (PERMISSION_MODES.includes(raw))
+        return raw;
+    warnings.push(`permissionMode ignoto: '${raw}' → fallback 'manual'`);
+    return 'manual';
+}
+/**
+ * Il kind di catalogo effettivo: solo sul ramo bound senza prompt letterale.
+ * `--no-task` e `--prompt` non hanno una riga di catalogo da consultare, né per
+ * il prompt né per il modello.
+ */
+function catalogKind(req) {
+    return !req.promptGiven && !req.noTask ? req.promptKind || 'recap' : '';
+}
+/**
+ * Il modello: `--model` > env `LOOM_DECK_MODEL` > modello del kind nel catalogo
+ * > `MODEL_DEFAULT`.
+ *
+ * Il deck TUI passa SEMPRE `--model` già risolto (T161), quindi dal deck la
+ * cascata si ferma al primo gradino: i tre sotto servono a chi invoca a mano.
+ * Le voci restano ALIAS fino dentro `claude --model`: un id versionato cablato
+ * qui diventerebbe un modello inesistente al primo cambio di generazione. Un
+ * valore ignoto degrada al default con un avviso — arriverebbe al CLI, che lo
+ * rifiuterebbe all'avvio.
+ */
+function modelOf(req, ctx, warnings) {
+    let model = req.model || ctx.env.LOOM_DECK_MODEL || '';
+    const kind = catalogKind(req);
+    if (!model && kind && kind !== 'none')
+        model = ctx.catalog.get(kind)?.model ?? '';
+    if (!model)
+        return MODEL_DEFAULT;
+    if (MODELS.includes(model))
+        return model;
+    warnings.push(`modello ignoto: '${model}' → fallback '${MODEL_DEFAULT}' (usa ${MODELS.join('|')})`);
+    return MODEL_DEFAULT;
+}
+/**
+ * Il prompt iniziale, vuoto = nessun prompt.
+ *
+ * `--prompt` vince su tutto ed è usato così com'è. Una sessione nuda senza
+ * `--prompt` non ha prompt: il default `recap` del catalogo non si applica,
+ * perché ogni template interpola `{TASK}` e con la task vuota sarebbe un
+ * comando monco. Sul ramo bound il kind sceglie il template; un catalogo che
+ * non ha la voce è un'installazione mutila, e la sessione parte senza prompt
+ * dicendolo. `LOOM_DECK_ENTER_PROMPT` vince sul kind, tranne su `none`.
+ */
+function promptOf(req, ctx, warnings) {
+    if (req.promptGiven)
+        return req.promptText;
+    if (req.noTask)
+        return '';
+    const kind = catalogKind(req);
+    if (kind === 'none')
+        return '';
+    const enter = ctx.env.LOOM_DECK_ENTER_PROMPT;
+    const template = ctx.catalog.get(kind)?.template;
+    if (template === undefined) {
+        warnings.push(`catalogo prompt non leggibile ('${ctx.catalogPath}'): sessione senza prompt iniziale`);
+    }
+    const text = enter || template || '';
+    return text.replaceAll('{TASK}', req.task);
+}
+/**
+ * La chiave di stato per compass, solo su Linux: env `LOOM_DECK_STATE_PROFILE`
+ * (anche vuota = nessun annuncio) > `id` del file di progetto.
+ *
+ * Lo stato di una sessione viaggia verso compass via D-Bus keyed su
+ * `PTYXIS_PROFILE`, e compass lo associa a un progetto solo se la chiave è l'`id`
+ * di un progetto del registry. Senza la variabile forzata in-tab, Ptyxis ne
+ * esporterebbe una col valore del profilo di default, e il badge resterebbe
+ * fermo senza nessun errore. Il nome della variabile è storico: non contiene
+ * l'UUID di un profilo. Su Windows compass non esiste, e la chiave non serve.
+ */
+function stateKey(ctx, warnings) {
+    if (ctx.platform === 'win32')
+        return '';
+    const raw = ctx.env.LOOM_DECK_STATE_PROFILE !== undefined
+        ? ctx.env.LOOM_DECK_STATE_PROFILE
+        : configField(ctx.config, 'id');
+    if (raw && !STATE_KEY_RE.test(raw)) {
+        warnings.push(`profilo di stato ignorato (caratteri non ammessi): '${raw}'`);
+        return '';
+    }
+    return raw;
+}
+/** Un testo come UN argomento di una shell POSIX: sempre fra apici singoli, con
+ *  l'apice stesso chiuso, escapato e riaperto (`'\''`). Dentro gli apici nessun
+ *  altro carattere resta speciale, newline compresi. */
+export function posixQuote(text) {
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * La composizione intera.
+ *
+ * Ordine degli argomenti di `claude`: nome, permission mode e modello prima dei
+ * flag di continuità, il prompt sempre ultimo. Il modello sta accanto al
+ * permission mode perché sono la stessa cosa — la scelta di chi apre la
+ * sessione — e non una proprietà della task né della ripresa.
+ *
+ * Su una ripresa il prompt salta anche sul ramo bound: riprendere significa
+ * continuare la conversazione, non iniettarle un messaggio nuovo; il fork è una
+ * ripresa con id nuovo e ricade nello stesso ramo. Il `--session-id` vale invece
+ * anche sul ramo nudo: nel fork di una sessione spot rende noto in anticipo
+ * l'id del ramo, senza il quale il lineage non sarebbe registrabile.
+ */
+export function composeTab(req, ctx) {
+    const warnings = [];
+    const title = tabTitle(req, projectLabel(ctx.config));
+    const mode = permissionMode(ctx, warnings);
+    const model = modelOf(req, ctx, warnings);
+    const key = stateKey(ctx, warnings);
+    const prompt = promptOf(req, ctx, warnings);
+    const withPrompt = prompt !== '' && !req.resumeId;
+    const flags = ['--permission-mode', mode, '--model', model];
+    if (req.sessionId)
+        flags.push('--session-id', req.sessionId);
+    if (req.resumeId)
+        flags.push('--resume', req.resumeId);
+    if (req.fork)
+        flags.push('--fork-session');
+    const sessionEnv = {};
+    if (key)
+        sessionEnv.PTYXIS_PROFILE = key;
+    if (!req.noTask)
+        sessionEnv.LOOM_TASK = req.task;
+    // La riga in-tab nella grafia storica dello script: ogni flag seguito da uno
+    // spazio, il prompt in coda fra apici. Il gate di parità su Linux confronta
+    // questa riga byte per byte, spazio finale compreso quando il prompt manca.
+    const envPrefix = Object.entries(sessionEnv)
+        .map(([k, v]) => `${k}=${shellQuote(v)} `)
+        .join('');
+    const flagText = flags.map((f) => `${f} `).join('');
+    const inTab = `${envPrefix}claude --name ${posixQuote(title)} ${flagText}` +
+        (withPrompt ? posixQuote(prompt) : '');
+    return {
+        title,
+        claudeArgs: ['--name', title, ...flags, ...(withPrompt ? [prompt] : [])],
+        sessionEnv,
+        inTab,
+        warnings,
+    };
+}
+/**
+ * L'argv di Ptyxis: una tab nella finestra attiva (quella col focus, cioè il
+ * deck), o una finestra nuova con `--new-window` (T162) per chi chiama da fuori
+ * dalla finestra del progetto. Il comando gira dentro `bash -lc`, e le env di
+ * sessione viaggiano DENTRO il comando: `ptyxis --tab` consegna la tab
+ * all'istanza già aperta, che non eredita l'env di chi la chiede.
+ */
+export function ptyxisArgv(newWindow, workdir, title, inTab) {
+    return [newWindow ? '--new-window' : '--tab', '-d', workdir, '-T', title, '--', 'bash', '-lc', inTab];
+}

package/dist/tab-launch.js

@@ -0,0 +1,169 @@
+// T176 — `deck-run` come programma: legge l'argv, compone la tab, la annuncia e
+// la apre nel terminale della piattaforma.
+//
+// Il contratto verso chi lo lancia è quello dello script bash che ha sostituito:
+//  - uscita 2 e messaggio su stderr per un errore d'uso, nessun annuncio;
+//  - prima di aprire la tab, su stdout, la riga `LOOM_DECK_INTAB <comando>` col
+//    comando che gira nella tab — il deck la legge e la mostra nella riga di
+//    stato (`onInTabCommand`), invece di ricomporla;
+//  - poi il terminale, e l'uscita è la sua: `ptyxis --tab` e `wt.exe new-tab`
+//    escono appena hanno consegnato la tab all'istanza già aperta.
+//
+// L'I/O verso l'esterno passa da `DeckRunIo`, così il test della composizione
+// completa non apre tab. Il filesystem no: file di progetto e catalogo si
+// leggono dal disco anche nei test, su cartelle temporanee.
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { constants } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isUsageError, parseTabArgs } from './tab-args.js';
+import { composeTab, ptyxisArgv } from './tab-compose.js';
+import { loadPromptCatalog, PROMPT_CATALOG } from './prompt-catalog.js';
+import { configFilePath } from './config.js';
+import { resolveGitBash } from './git-bash.js';
+import { semicolonArg, TAB_ARGV_ENV, windowsTabEnv, WT_CMD, wtNewTabArgs, wtProfile, } from './windows-terminal.js';
+/** Il wrapper che gira dentro una tab di Windows Terminal, nel build: lo esegue
+ *  il node del deck, e `src/` sotto `tsx` non ha un `.js` da dargli. */
+export const TAB_WRAPPER_JS = join(dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'tab-wrapper.js');
+/**
+ * La cartella di lavoro della tab: `LOOM_DECK_WORKDIR`, altrimenti la cartella
+ * corrente.
+ *
+ * Su Linux la cartella corrente è quella LOGICA, come il `$PWD` di bash: `PWD`
+ * se punta alla stessa cartella di `cwd` (un symlink resta un symlink nel
+ * titolo e nel `-d` di Ptyxis), `cwd` altrimenti. Su Windows `PWD` arriva da
+ * Git Bash in forma `/c/…`, che `wt -d` non capisce: vale solo `cwd`.
+ */
+export function workdirOf(io) {
+    if (io.env.LOOM_DECK_WORKDIR)
+        return io.env.LOOM_DECK_WORKDIR;
+    const pwd = io.env.PWD;
+    if (io.platform !== 'win32' && pwd) {
+        try {
+            const a = statSync(pwd);
+            const b = statSync(io.cwd);
+            if (a.dev === b.dev && a.ino === b.ino)
+                return pwd;
+        }
+        catch {
+            // PWD che non esiste più → la cartella vera
+        }
+    }
+    return io.cwd;
+}
+/** La cartella che contiene `.claude/loom-works.json`, risalendo da `start`
+ *  fino alla radice compresa; `null` fuori da un progetto loom. */
+export function findProjectRoot(start) {
+    let dir = resolve(start);
+    for (;;) {
+        if (existsSync(configFilePath(dir)))
+            return dir;
+        const up = dirname(dir);
+        if (up === dir)
+            return null;
+        dir = up;
+    }
+}
+/** Il file di progetto parsato, o `null` se manca o è malformato: il titolo
+ *  ricade su `cc`, il permission mode su `manual`, e lo spawn parte lo stesso. */
+function loadConfig(root) {
+    if (!root)
+        return null;
+    try {
+        return JSON.parse(readFileSync(configFilePath(root), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Un argv come una shell POSIX lo leggerebbe: per le diagnostiche. */
+function describe(cmd, args) {
+    return [cmd, ...args].map((a) => (/^[\w@%+=:,./\\-]+$/.test(a) ? a : JSON.stringify(a))).join(' ');
+}
+export async function runDeckRun(argv, io) {
+    const req = parseTabArgs(argv);
+    if (isUsageError(req)) {
+        for (const line of req.lines)
+            io.stderr(`${line}\n`);
+        return 2;
+    }
+    const workdir = workdirOf(io);
+    const catalogPath = io.env.LOOM_DECK_PROMPT_CATALOG || PROMPT_CATALOG;
+    const plan = composeTab(req, {
+        env: io.env,
+        config: loadConfig(findProjectRoot(workdir)),
+        catalog: loadPromptCatalog(catalogPath),
+        catalogPath,
+        platform: io.platform,
+    });
+    for (const w of plan.warnings)
+        io.stderr(`${w}\n`);
+    let cmd;
+    let args;
+    let env;
+    if (io.platform === 'win32') {
+        cmd = WT_CMD;
+        args = wtNewTabArgs({
+            newWindow: req.newWindow,
+            profile: wtProfile(io.env),
+            cwd: workdir,
+            title: plan.title,
+            command: [io.nodePath, TAB_WRAPPER_JS],
+        });
+        const bad = semicolonArg(args);
+        if (bad !== null) {
+            io.stderr(`argomento con ';' non passabile a ${WT_CMD}, che lo legge come separatore: '${bad}'\n`);
+            return 2;
+        }
+        env = {
+            ...windowsTabEnv(io.env, req.noTask ? null : req.task, resolveGitBash(io.env, existsSync)),
+            [TAB_ARGV_ENV]: JSON.stringify(plan.claudeArgs),
+        };
+        io.stdout(`LOOM_DECK_INTAB ${plan.inTab}\n`);
+    }
+    else {
+        // L'override esiste per i probe empirici (un comando non-CC nella tab): è
+        // una riga per bash, quindi vale solo dove la tab la esegue con bash.
+        const inTab = io.env.LOOM_DECK_INTAB_CMD || plan.inTab;
+        cmd = 'ptyxis';
+        args = ptyxisArgv(req.newWindow, workdir, plan.title, inTab);
+        io.stdout(`LOOM_DECK_INTAB ${inTab}\n`);
+    }
+    try {
+        return await io.launch(cmd, args, env);
+    }
+    catch (e) {
+        const code = e.code ?? String(e);
+        io.stderr(`deck-run: ${cmd} non lanciabile (${code}): ${describe(cmd, args)}\n`);
+        return 127;
+    }
+}
+/**
+ * Il lancio vero: stdio ereditato, così chi legge lo stdout di `deck-run` vede
+ * anche quello del terminale, come quando lo script finiva con `exec`.
+ *
+ * `windowsHide: false` e non il `true` degli altri spawn del deck: `wt.exe` è
+ * un'applicazione GUI, e con `true` la finestra di `-w new` partirebbe nascosta.
+ * Un processo GUI non apre console, quindi non c'è niente da nascondere.
+ */
+export function launchTerminal(cmd, args, env) {
+    return new Promise((resolveExit, reject) => {
+        const child = spawn(cmd, args, { stdio: 'inherit', env: env, windowsHide: false });
+        child.on('error', reject);
+        child.on('exit', (code, signal) => {
+            resolveExit(code ?? 128 + (signal ? (constants.signals[signal] ?? 0) : 0));
+        });
+    });
+}
+export function realIo() {
+    return {
+        env: process.env,
+        cwd: process.cwd(),
+        platform: process.platform,
+        nodePath: process.execPath,
+        stdout: (s) => process.stdout.write(s),
+        stderr: (s) => process.stderr.write(s),
+        launch: launchTerminal,
+    };
+}

package/dist/tab-wrapper.js

@@ -0,0 +1,44 @@
+// T176 — il programma che gira DENTRO una tab di Windows Terminal aperta dal
+// deck: legge l'argv di `claude` dalla variabile della tab e lo lancia.
+//
+// Esiste perché il prompt non deve passare da nessun parser: `wt.exe` legge `;`
+// come separatore di sottocomandi, cmd e PowerShell interpretano `' " & % ^ |`
+// (P3 preflight). L'argv arriva come JSON nell'env, che la tab eredita da chi
+// lancia `wt.exe`, e da qui va a `claude` come array, senza shell.
+//
+// La variabile si toglie dall'env PRIMA del lancio: è un canale verso questo
+// programma, e `claude` la passerebbe a ogni hook e a ogni comando della
+// sessione.
+//
+// `claude` è quello di `claudeLauncher` (T175): l'eseguibile nativo, lo shim npm
+// letto, o `LOOM_DECK_CLAUDE_CMD`.
+//
+// Ctrl+C appartiene a `claude`. In una console Windows il tasto arriva a ogni
+// processo attaccato, quindi anche qui: senza un handler questo processo
+// uscirebbe, e la tab si chiuderebbe sotto una sessione viva. Si esce solo
+// quando esce `claude`, col suo codice — e la tab si chiude o resta aperta
+// secondo il `closeOnExit` del profilo (D3 preflight).
+import { spawn } from 'node:child_process';
+import { claudeLauncher } from './claude-cmd.js';
+import { parseTabArgv, TAB_ARGV_ENV } from './windows-terminal.js';
+const raw = process.env[TAB_ARGV_ENV];
+delete process.env[TAB_ARGV_ENV];
+const args = parseTabArgv(raw);
+if (!args) {
+    process.stderr.write(`loom-deck: ${TAB_ARGV_ENV} assente o malformata — questa tab non sa quale conversazione aprire\n`);
+    process.exitCode = 2;
+}
+else {
+    process.on('SIGINT', () => { });
+    const claude = claudeLauncher();
+    // `windowsHide: false`: il figlio condivide la console della tab, che è
+    // proprio la finestra in cui deve comparire.
+    const child = spawn(claude.cmd, [...claude.prefix, ...args], { stdio: 'inherit', windowsHide: false });
+    child.on('error', (e) => {
+        process.stderr.write(`loom-deck: '${claude.cmd}' non lanciabile (${e.code ?? e.message})\n`);
+        process.exitCode = 127;
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 1);
+    });
+}

package/dist/tasks.js

@@ -129,7 +129,7 @@ export function loadTasks(path) {
  * sciolti in spazi, cioè il buco `{slug}` dei template di titolo.
  *
  * Viene dal NOME del file e non dalla descrizione in `tasks.md` per una ragione
- * di alfabeto: il nome è già dentro quello di `_sane_note` per costruzione —
+ * di alfabeto: il nome è già dentro quello di `saneNote` per costruzione —
  * minuscolo, separato da trattini, senza punteggiatura — mentre la descrizione
  * porta apostrofi e `/`, che la riduzione toglie senza sostituto saldando le
  * parole (`l'epica/doc` → `lepicadoc`).

package/dist/windows-terminal.js

@@ -0,0 +1,153 @@
+// T176 — le tab di WINDOWS TERMINAL: argv di `wt.exe`, env della tab, il canale
+// che porta l'argv di `claude` al wrapper.
+//
+// Su Windows una conversazione si apre con
+//
+//     wt.exe -w 0 new-tab -p loom-deck -d <root> --title <titolo>
+//            --suppressApplicationTitle -- <node> <tab-wrapper.js>
+//
+// e l'argv di `claude` (nome, flag, prompt) NON sta su quella riga: viaggia come
+// JSON nella variabile `LOOM_DECK_TAB_ARGV`, perché la tab eredita l'env del
+// processo che lancia `wt.exe` (T174 verdetto 5, rimisurato con `-p`). Il
+// wrapper la legge, la toglie e lancia `claude` senza shell (P3 preflight).
+// Così il prompt non passa né dal parser di `wt` né da una shell: `wt` legge `;`
+// come separatore di sottocomandi in QUALUNQUE argomento, anche dopo `--` e
+// anche escapato `\;` (misurato su Windows Terminal 1.24: la coda dopo il `;`
+// diventa una tab a sé, col proprio errore), e cmd o PowerShell
+// interpreterebbero `' " & % ^ |`.
+//
+// Modulo PURO: l'env arriva come valore, il bash di Git come stringa già
+// risolta.
+/** Il lanciatore di Windows Terminal: l'alias d'esecuzione in `WindowsApps`,
+ *  che `spawn` trova nel `PATH` e lancia senza shell (misurato). */
+export const WT_CMD = 'wt.exe';
+/** Il profilo delle tab del deck (P9 preflight): uno solo per tutti i
+ *  progetti, nascosto dal menu, creato a mano dall'utente nel `settings.json` di
+ *  Windows Terminal. Porta ciò che i flag non dicono — font, `closeOnExit`, la
+ *  shell del tasto `t`; titolo, cartella e comando li passa il deck. */
+export const WT_PROFILE_DEFAULT = 'loom-deck';
+/** La variabile con cui l'argv di `claude` arriva al wrapper della tab. */
+export const TAB_ARGV_ENV = 'LOOM_DECK_TAB_ARGV';
+/**
+ * I marker che una sessione Claude Code inietta nei processi figli (P4
+ * preflight, misurati nella shell di una sessione su Windows).
+ *
+ * La tab eredita tutto l'env del deck, e un deck avviato da una shell aperta
+ * dentro Claude Code li porterebbe nella conversazione nuova: con
+ * `CLAUDE_CODE_CHILD_SESSION` la sessione non salva il transcript («Transcript
+ * saving is off — inherited CLAUDE_CODE_CHILD_SESSION marker») e non compare
+ * nello storico del deck. Lista chiusa e non ogni `CLAUDE*`: un
+ * `CLAUDE_CONFIG_DIR` o un `CLAUDE_CODE_GIT_BASH_PATH` dell'utente sparirebbero
+ * senza segnale, mentre un marker nuovo di una versione futura si annuncia da
+ * sé, nel messaggio di avvio di `claude` che lo nomina.
+ */
+export const SESSION_MARKERS = [
+    'CLAUDECODE',
+    'CLAUDE_CODE_CHILD_SESSION',
+    'CLAUDE_CODE_SESSION_ID',
+    'CLAUDE_PID',
+    'CLAUDE_EFFORT',
+    'CLAUDE_CODE_MESSAGING_SOCKET',
+    'CLAUDE_CODE_MESSAGING_TOKEN',
+    'CLAUDE_CODE_ENTRYPOINT',
+    'CLAUDE_CODE_SESSION_ATTENDED',
+    'CLAUDE_CODE_EXECPATH',
+];
+const GIT_BASH_ENV = 'CLAUDE_CODE_GIT_BASH_PATH';
+/** Il profilo da passare a `-p`: `LOOM_DECK_WT_PROFILE` se impostata (vuota =
+ *  nessun `-p`, il profilo di default di Windows Terminal), altrimenti
+ *  `loom-deck`. Un profilo che non esiste non è un errore: Windows Terminal
+ *  apre la tab col profilo di default e non dice niente (misurato), quindi il
+ *  deck lo passa sempre senza verificarlo. */
+export function wtProfile(env) {
+    const v = env.LOOM_DECK_WT_PROFILE;
+    if (v === undefined)
+        return WT_PROFILE_DEFAULT;
+    return v || null;
+}
+/** Il titolo come lo riceve `wt`: senza `;`, che spezzerebbe il comando. Il
+ *  titolo è composto dal deck (label, TaskID, nota ridotta) e un `;` può
+ *  venire solo dal nome del progetto: si toglie invece di fallire. */
+export function wtTitle(title) {
+    return title.replace(/;/g, '');
+}
+/**
+ * L'argv di `wt.exe` per una tab nuova.
+ *
+ * `-w 0` è la finestra di Windows Terminal usata per ultima — quella da cui si
+ * lavora col deck —, `-w new` una finestra nuova (l'equivalente di
+ * `--new-window` di Ptyxis). `--suppressApplicationTitle` tiene il titolo del
+ * deck contro quello che il programma della tab imposta (misurato): è ciò che su
+ * Linux fa `-T` di Ptyxis contro l'OSC del prompt. Senza titolo il flag non si
+ * passa, e la tab prende quello della shell.
+ */
+export function wtNewTabArgs(tab) {
+    const args = ['-w', tab.newWindow ? 'new' : '0', 'new-tab'];
+    if (tab.profile)
+        args.push('-p', tab.profile);
+    args.push('-d', tab.cwd);
+    if (tab.title !== null)
+        args.push('--title', wtTitle(tab.title), '--suppressApplicationTitle');
+    if (tab.command)
+        args.push('--', ...tab.command);
+    return args;
+}
+/**
+ * Il primo argomento di `wt` che contiene un `;`, o `null`.
+ *
+ * Il titolo è già ripulito; restano i path (la cartella, node, il wrapper) e il
+ * nome del profilo. Un path col `;` è legale su NTFS e `wt` non lo sa portare:
+ * lo spawn si ferma dicendolo, invece di aprire una tab d'errore con metà
+ * comando.
+ */
+export function semicolonArg(args) {
+    return args.find((a) => a.includes(';')) ?? null;
+}
+/** Toglie una chiave ignorando le maiuscole: su Windows l'env non le distingue,
+ *  e una copia di `process.env` può portare `Path` invece di `PATH`. */
+function deleteKey(env, key) {
+    const want = key.toUpperCase();
+    for (const k of Object.keys(env))
+        if (k.toUpperCase() === want)
+            delete env[k];
+}
+function hasKey(env, key) {
+    const want = key.toUpperCase();
+    return Object.keys(env).some((k) => k.toUpperCase() === want && env[k]);
+}
+/**
+ * L'env di una tab aperta dal deck su Windows: quello del deck, meno i marker di
+ * sessione, con la task della conversazione e il bash di Git.
+ *
+ * `task` = `null` per le tab senza task (`--no-task`, il tasto `t`): una
+ * `LOOM_TASK` ereditata legherebbe a una task una sessione che non ne ha, e
+ * l'hook `SessionStart` ne inietterebbe il task file. `CLAUDE_CODE_GIT_BASH_PATH`
+ * entra quando manca e il bash si trova: la tab eredita anche il `PATH`, e col
+ * `PATH` di Git Bash `claude` eseguirebbe gli hook del plugin in PowerShell
+ * (T174 verdetto 9), cioè senza la task in contesto.
+ */
+export function windowsTabEnv(env, task, gitBash) {
+    const out = { ...env };
+    for (const marker of SESSION_MARKERS)
+        deleteKey(out, marker);
+    deleteKey(out, 'LOOM_TASK');
+    deleteKey(out, TAB_ARGV_ENV);
+    if (task)
+        out.LOOM_TASK = task;
+    if (gitBash && !hasKey(env, GIT_BASH_ENV))
+        out[GIT_BASH_ENV] = gitBash;
+    return out;
+}
+/** L'argv di `claude` letto dalla variabile della tab, o `null` se manca o non
+ *  è un array di stringhe. */
+export function parseTabArgv(raw) {
+    if (!raw)
+        return null;
+    try {
+        const v = JSON.parse(raw);
+        return Array.isArray(v) && v.every((a) => typeof a === 'string') ? v : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/wrap-scan.js

@@ -87,7 +87,7 @@ export const WRAP_DEFAULT_PATH = '.';
  * T161 — il buco `{path}` del titolo e del prompt di una sessione di
  * srotolamento: il path reso a parole.
  *
- * Le barre diventano spazi e l'estensione cade QUI, prima di `_sane_note`, il
+ * Le barre diventano spazi e l'estensione cade QUI, prima di `saneNote`, il
  * cui alfabeto non ha né `/` né `.`: lasciandoceli cadere le parole si
  * salderebbero (`runtimereferencedoc-systemmd`), e il titolo della tab
  * divergerebbe da quello che la lista del deck legge dal sidecar.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.76.0",
+  "version": "0.77.0",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
   "scripts": {
     "dev": "tsx src/cli.tsx",
     "build": "tsc",
+    "pretest": "tsc",
     "test": "node test/run.mjs",
     "start": "node dist/cli.js",
     "prepare": "tsc"