@lamemind/loom-deck 0.76.0 → 0.78.0

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/ui/detail-screen.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 // Detail della task (T66): quarta schermata sostitutiva, col markdown reso in
 // span tipizzati (T75) e la ricerca interna (T91).
 import { Box, Text } from 'ink';
@@ -9,6 +9,7 @@ import { ChoiceRow, FieldText, LABEL_W } from './fields.js';
 import { DETAIL_ACTIONS, MODELS } from '../spawn-catalog.js';
 import { DROW, PRIORITY_CHOICES } from '../overlays/sheet.js';
 import { CARET, CARET_OFF, WARN } from '../glyphs.js';
+import { DlvArea } from './dlv-area.js';
 /** Resa di ogni costrutto markdown (T75 · D4): un solo livello di enfasi per
  *  costrutto, senza un secondo alfabeto da imparare. Heading uguali a ogni
  *  livello — la gerarchia la porta già il testo. `code` e `fence` condividono
@@ -79,7 +80,7 @@ const ACTION_KEYS = DETAIL_ACTIONS.map((a) => a.label[0]).join(' ');
  * rettangolo ha già coordinate e area cliccabile, quindi il layout sopravvive
  * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione.
  */
-export function DetailScreen({ id, title, missing, lines, spans, top, total, capacity, action, model, spawnNote, prompt, priority, cursor, columns, find, occ, occCur, }) {
+export function DetailScreen({ id, title, missing, lines, spans, top, total, capacity, action, model, spawnNote, prompt, priority, cursor, columns, find, occ, occCur, dlv, dlvRows, }) {
     const last = Math.min(total, top + capacity);
     // Il taglio lo fa il chiamante (invariante ③ di width.ts): le righe bottoni
     // sono ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso
@@ -91,5 +92,9 @@ export function DetailScreen({ id, title, missing, lines, spans, top, total, cap
     // campo vuoto): riservarle sempre toglierebbe testo visibile a un titolo lungo
     // per un avviso assente.
     const textW = (extra) => Math.max(10, width - LABEL_W - CARET_OFF.length - extra);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " testo \u00B7", ' ', _jsx(Text, { color: "yellow", children: ACTION_KEYS }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota campo \u00B7 ", _jsx(Text, { color: "yellow", children: "^F" }), " cerca"] })), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: occ, current: occCur }, top + i)))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(FieldText, { value: find.q, caret: find.caret, focused: true, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(ChoiceRow, { label: "azione", values: DETAIL_ACTIONS.map((a) => a.label), index: action, focused: cursor.row === DROW.action, width: width }), _jsxs(Text, { wrap: "truncate-end", children: [mark(DROW.prompt), _jsx(Text, { dimColor: true, children: 'prompt'.padEnd(LABEL_W) }), _jsx(FieldText, { value: prompt, caret: cursor.caret, focused: cursor.row === DROW.prompt, cols: textW(prompt ? 0 : PROMPT_HINT.length) }), prompt ? null : _jsx(Text, { dimColor: true, children: PROMPT_HINT })] }), _jsx(ChoiceRow, { label: "modello", values: MODELS, index: Math.max(0, MODELS.indexOf(model)), focused: cursor.row === DROW.model, width: width }), _jsxs(Text, { wrap: "truncate-end", children: [mark(DROW.title), _jsx(Text, { dimColor: true, children: 'titolo'.padEnd(LABEL_W) }), _jsx(FieldText, { value: spawnNote, caret: cursor.caret, focused: cursor.row === DROW.title, cols: textW(spawnNote ? 0 : NOTE_HINT.length) }), spawnNote ? null : _jsx(Text, { dimColor: true, children: NOTE_HINT })] }), _jsx(ChoiceRow, { label: "priorit\u00E0", values: PRIORITY_CHOICES, index: priority ? 1 : 0, focused: cursor.row === DROW.priority, width: width })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : dlv.active ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [dlv.gate.kind === 'ready' ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " DLV aperti \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "seleziona \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " run \u00B7", ' '] })) : null, _jsx(Text, { color: "yellow", children: "tab" }), " campi \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " testo \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^F" }), " cerca"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " testo \u00B7", ' ', _jsx(Text, { color: "yellow", children: ACTION_KEYS }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota campo \u00B7 ", _jsx(Text, { color: "yellow", children: "^F" }), " cerca \u00B7", ' ', _jsx(Text, { color: "yellow", children: "tab" }), " DLV"] })), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: occ, current: occCur }, top + i)))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(FieldText, { value: find.q, caret: find.caret, focused: true, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, dlv.active ? (_jsx(DlvArea, { dlvs: dlv.dlvs, cursor: dlv.cursor, selected: dlv.selected, gate: dlv.gate, prompt: dlv.prompt, model: dlv.model, rows: dlvRows, width: width })) : (
+            /* Le quattro righe dell'area di compilazione, nell'ordine in cui si
+                decide: cosa lanciare, con quale prompt, con quale modello, sotto quale
+                titolo. */
+            _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(ChoiceRow, { label: "azione", values: DETAIL_ACTIONS.map((a) => a.label), index: action, focused: cursor.row === DROW.action, width: width }), _jsxs(Text, { wrap: "truncate-end", children: [mark(DROW.prompt), _jsx(Text, { dimColor: true, children: 'prompt'.padEnd(LABEL_W) }), _jsx(FieldText, { value: prompt, caret: cursor.caret, focused: cursor.row === DROW.prompt, cols: textW(prompt ? 0 : PROMPT_HINT.length) }), prompt ? null : _jsx(Text, { dimColor: true, children: PROMPT_HINT })] }), _jsx(ChoiceRow, { label: "modello", values: MODELS, index: Math.max(0, MODELS.indexOf(model)), focused: cursor.row === DROW.model, width: width }), _jsxs(Text, { wrap: "truncate-end", children: [mark(DROW.title), _jsx(Text, { dimColor: true, children: 'titolo'.padEnd(LABEL_W) }), _jsx(FieldText, { value: spawnNote, caret: cursor.caret, focused: cursor.row === DROW.title, cols: textW(spawnNote ? 0 : NOTE_HINT.length) }), spawnNote ? null : _jsx(Text, { dimColor: true, children: NOTE_HINT })] }), _jsx(ChoiceRow, { label: "priorit\u00E0", values: PRIORITY_CHOICES, index: priority ? 1 : 0, focused: cursor.row === DROW.priority, width: width })] }))] }));
 }

package/dist/ui/dlv-area.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// T189 — la lista dei DLV nel detail della task, al posto dell'area di
+// compilazione quando il modo DLV è attivo.
+import { Box, Text } from 'ink';
+import { cut, cutParts, pad } from '../width.js';
+import { parseMarkdown } from '../markdown.js';
+import { windowRange } from '../viewport.js';
+import { CARET, CARET_OFF, DLV_MARK, DLV_MARK_W, WARN } from '../glyphs.js';
+/** Il testo di una voce come lo rende il detail sopra: senza `**` e backtick.
+ *  Il markdown resta grezzo nel task file, e una lista che mostrasse i marker
+ *  direbbe la stessa voce in due forme sulla stessa schermata. */
+function plain(text) {
+    return parseMarkdown(text).text;
+}
+/** La riga di stato: cosa parte su `⏎`, o perché non parte niente, più quante
+ *  righe della lista stanno fuori dalla finestra. Quattro pezzi, uno per
+ *  colore; il budget serve per primo il secondo, perché è quello che si legge
+ *  prima di premere. */
+function statusParts(gate, prompt, model, above, below) {
+    const overflow = above + below > 0 ? ` · ↑${above} ↓${below}` : '';
+    if (gate.kind === 'ready') {
+        return { parts: ['⏎ ', prompt, model ? ` · ${model}` : '', overflow], tone: 'ready' };
+    }
+    const lead = gate.kind === 'blocked' ? `${WARN} ` : '';
+    return { parts: [lead, gate.reason, ' · ⏎ inerte', overflow], tone: gate.kind };
+}
+/**
+ * La lista dei DLV numerata come la numera `run-task`, coi fatti in grigio e
+ * spuntati, più una riga di stato.
+ *
+ * Il cursore c'è solo quando il gate è `ready`: fuori da lì nessuna voce è
+ * selezionabile, e un caret su una riga inerte prometterebbe un gesto che non
+ * esiste. Sopra `rows` la lista si finestra sul cursore; senza cursore parte
+ * dall'inizio, e la riga di stato dice quante voci restano fuori.
+ */
+export function DlvArea({ dlvs, cursor, selected, gate, prompt, model, rows, width, }) {
+    const ready = gate.kind === 'ready';
+    const at = ready ? dlvs.findIndex((d) => d.n === cursor) : -1;
+    const { start, end } = windowRange(dlvs.length, at, rows);
+    const numW = String(dlvs.length).length;
+    // caret + marca + spazio + numero + spazio: tutto ciò che precede il testo.
+    const textW = Math.max(1, width - CARET_OFF.length - DLV_MARK_W - 1 - numW - 1);
+    const status = statusParts(gate, prompt, model, start, dlvs.length - end);
+    const [lead, body, tail, overflow] = cutParts(status.parts, width, 1);
+    return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [dlvs.slice(start, end).map((d) => {
+                const focused = ready && d.n === cursor;
+                const picked = selected.has(d.n);
+                const mark = d.done ? DLV_MARK.done : picked ? DLV_MARK.picked : DLV_MARK.open;
+                return (_jsxs(Text, { wrap: "truncate-end", children: [focused ? CARET : CARET_OFF, _jsx(Text, { color: picked ? 'cyan' : undefined, dimColor: d.done, children: pad(mark, DLV_MARK_W) }), ' ', _jsx(Text, { dimColor: true, children: pad(String(d.n), numW, 'right') }), ' ', _jsx(Text, { dimColor: d.done, color: picked ? 'cyan' : undefined, bold: focused, children: cut(plain(d.text), textW) })] }, d.n));
+            }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: status.tone === 'off' ? undefined : 'yellow', dimColor: status.tone === 'off', children: lead }), _jsx(Text, { color: status.tone === 'ready' ? 'cyan' : status.tone === 'blocked' ? 'yellow' : undefined, dimColor: status.tone === 'off', children: body }), _jsx(Text, { dimColor: true, children: tail }), _jsx(Text, { dimColor: true, children: overflow })] })] }));
+}

package/dist/ui/screens.js

@@ -153,7 +153,7 @@ export function screenFor(input) {
         // posizione è lo scroll mosso a mano. Il clamp serve comunque — un resize
         // può accorciare il testo sotto uno scroll già dato.
         const start = Math.min(sheet.top, sheet.maxTop);
-        return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, model: sheet.model, spawnNote: sheet.spawnNote, prompt: sheet.prompt, priority: sheet.priority, cursor: sheet.cursor, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur }));
+        return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, model: sheet.model, spawnNote: sheet.spawnNote, prompt: sheet.prompt, priority: sheet.priority, cursor: sheet.cursor, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur, dlv: sheet.dlv, dlvRows: sheet.dlvRows }));
     }
     // ── T121 · viewer del project status ────────────────────────────────────
     // Quinta schermata sostitutiva, stessa ragione delle altre quattro: un recap

package/dist/viewport.js

@@ -74,7 +74,7 @@ export const MODAL_HEIGHT = {
     // Le quattro righe sono FISSE, non condizionali: la quarta ospita tanto gli
     // scarti del bulk quanto la scelta keep/purge della singola task sporca, e due
     // condizionali mutuamente esclusivi obbligherebbero il budget a sapere QUALE
-    // dei due è a schermo (stessa ragione della riga nota in DETAIL_CHROME, T111).
+    // dei due è a schermo (stessa ragione della riga nota in DETAIL_FIELD_ROWS, T111).
     purge: 7,
     // Conferma di eliminazione di una conversazione: marginTop + 2 bordi + 3
     // righe (domanda con l'id, titolo, effetto sul disco + tasti). Nessuna riga
@@ -278,30 +278,38 @@ const READER_CHROME = 8;
 export function readerCapacity(rows) {
     return Math.max(0, (rows || 24) - SLACK - READER_CHROME);
 }
-// T66 — cornice del detail della task.
+// T66 — cornice del detail della task, comune ai due modi (T189).
 //   2  bordi del box esterno
 //   1  titolo "loom-deck"
 //   1  riga meta (id · titolo · posizione nel testo)
 //   1  riga hint
 //   1  marginTop del box testo
 //   2  bordi del box testo
-//   1  marginTop dell'area di compilazione
+//   1  marginTop dell'area sotto il testo
+//
+// Il detail non può riusare READER_CHROME perché sotto il testo porta un'AREA
+// in più dentro l'overlay, e ogni riga di quell'area va scalata dalla capienza
+// del contenuto o il frame sfonda `rows` (stessa invariante di
+// TASKS_PANE_CHROME).
+const DETAIL_BASE_CHROME = 9;
+// L'area di compilazione: righe FISSE, una per campo.
 //   1  riga azione   (T66)
 //   1  riga prompt   (T117)
 //   1  riga modello  (T108)
 //   1  riga titolo   (T111)
 //   1  riga priorità (T158)
 //
-// Le ultime sei sono il motivo per cui il detail non può riusare READER_CHROME:
-// le cinque righe dell'area di compilazione sono righe FISSE in più dentro
-// l'overlay, e ogni riga fissa aggiunta va scalata dalla capienza del contenuto o
-// il frame sfonda `rows` (stessa invariante di TASKS_PANE_CHROME).
-//
-// Sono fisse e non `extra` condizionali di `detailCapacity` (T111 · D1): due
+// Fisse e non `extra` condizionali dei singoli campi (T111 · D1): due
 // condizionali mutuamente esclusivi obbligherebbero il parametro a dire QUALE è
 // a schermo — un solo booleano per entrambi sottostima quando quello aperto è il
 // più alto, e sommarli toglie righe al testo per un campo che non c'è.
-const DETAIL_CHROME = 14;
+export const DETAIL_FIELD_ROWS = 5;
+// T189 — il modo DLV mette al posto dei campi la lista dei deliverable più una
+// riga di stato (cosa parte su `⏎`, o perché non parte niente). È l'altezza che
+// `detailCapacity` riceve come `area` quando il modo è attivo: il chiamante
+// dice cosa c'è a schermo con un numero di righe, non con un flag, per la
+// stessa ragione scritta sopra sui condizionali.
+export const DLV_STATUS_ROWS = 1;
 // T91 — la ricerca dentro il detail: marginTop + riga del campo.
 //
 // `MODAL_HEIGHT` dice che il detail costa 0 ai due pane (li sostituisce), e da
@@ -312,10 +320,25 @@ const DETAIL_CHROME = 14;
 // frame nello scrollback a ogni tick del poll.
 const DETAIL_SEARCH_CHROME = 2;
 /** Righe di task file che entrano nel terminale; con la ricerca aperta il campo
- *  si paga qui, non altrove. */
-export function detailCapacity(rows, searching = false) {
+ *  si paga qui, non altrove. `area` = righe dell'area sotto il testo: i campi
+ *  per default, `dlvListRows(…) + DLV_STATUS_ROWS` nel modo DLV. */
+export function detailCapacity(rows, searching = false, area = DETAIL_FIELD_ROWS) {
+    const extra = searching ? DETAIL_SEARCH_CHROME : 0;
+    return Math.max(0, (rows || 24) - SLACK - DETAIL_BASE_CHROME - area - extra);
+}
+/**
+ * T189 — righe della lista DLV: tutte quelle che ci sono, ma mai più di METÀ
+ * dello spazio sotto la cornice. Il resto resta al testo della task, che è ciò
+ * per cui il detail si apre; una lista più lunga si finestra sul cursore
+ * (`windowRange`) e la riga di stato dice quante righe stanno fuori.
+ *
+ * Su un terminale basso può valere 0 anche con dei DLV: resta la sola riga di
+ * stato, e il frame non sfonda.
+ */
+export function dlvListRows(rows, searching, total) {
     const extra = searching ? DETAIL_SEARCH_CHROME : 0;
-    return Math.max(0, (rows || 24) - SLACK - DETAIL_CHROME - extra);
+    const free = (rows || 24) - SLACK - DETAIL_BASE_CHROME - DLV_STATUS_ROWS - extra;
+    return Math.max(0, Math.min(total, Math.floor(free / 2)));
 }
 // T121 — cornice del viewer del project status. Gemella di READER_CHROME: il
 // viewer scorre testo e basta, senza l'area di compilazione che rende caro il
@@ -383,7 +406,7 @@ const SPAWN_CHROME = 8;
 // si modificano. Un'altezza che dipendesse dalla riga selezionata farebbe
 // saltare la tabella di due righe a ogni movimento del caret, e il budget
 // dovrebbe sapere quale riga è aperta per non sottostimare — lo stesso motivo
-// per cui le cinque righe del detail sono dentro `DETAIL_CHROME` invece che
+// per cui le cinque righe del detail sono fisse in `DETAIL_FIELD_ROWS` invece che
 // condizionali (T111 · D1).
 const SPAWN_FIELDS_CHROME = 5;
 /**

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.78.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"