@lamemind/loom-deck 0.76.0 → 0.78.0

package/README.md

@@ -387,11 +387,34 @@ 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,
+  "colorScheme": "<nome dello schema, es. One Half Light>",
+  "commandline": "%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -NoLogo",
+  "closeOnExit": "graceful"
+}
+```
+
+`colorScheme` fissa i colori di tutte le tab del deck: è il nome di uno schema predefinito di Windows Terminal o di uno dichiarato sotto `schemes` nello stesso `settings.json`. `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/deliverables.js

@@ -0,0 +1,139 @@
+// T189 — i DELIVERABLE di un task file, e le due regole del plugin che il deck
+// replica per offrirli nel detail.
+//
+// Il deck non esegue niente qui: legge i DLV per mostrarli e per comporre il
+// perimetro di `run-task`. Ma il perimetro è un INDIRIZZO — `run-task T189 2,4`
+// esegue il secondo e il quarto DLV come li conta il plugin, non come li conta
+// chi ha composto il prompt. Se i due conteggi divergono l'umano seleziona DLV3
+// e `run-task` esegue un altro DLV, senza errore. Per questo le due regole sono
+// copie esatte, e la prima ha un test di parità contro lo script vero.
+//
+//  ① NUMERAZIONE — `loom-works-plugin/scripts/task/task-deliverables.sh`:
+//     posizionale 1-based sulle sole checkbox a COLONNA ZERO dentro
+//     `## Deliverables Checklist`; le righe indentate sono prosa della voce.
+//  ② GATE DI ESEGUIBILITÀ — `run-task` SKILL.md §3: Size L vuole un
+//     `### Preflight` in `## Decisions`, S e M no, Size assente = M; un ultimo
+//     `### Preflight` con `— premessa decaduta` blocca a ogni Size. Questa regola
+//     vive nella prosa di una skill e non ha un presidio eseguibile: se cambia
+//     lì, va cambiata qui a mano.
+//
+// D6 (preflight T189) — parser TypeScript e non lo script del plugin lanciato
+// dal deck: il deck gira anche su Windows, dove un `.sh` del plugin oggi non
+// parte (T178), e il detail si apre a ogni `⏎` — uno spawn di bash lì dentro
+// sarebbe un costo per tasto. La parità la garantisce il test, non la fonte
+// comune.
+//
+// Logica pura, zero React/Ink.
+import { parseTaskDetail } from './tasks.js';
+/** Un heading di livello 2 apre una sezione nuova; `###` e oltre no. */
+const SECTION_RE = /^## /;
+const DLV_SECTION_RE = /^## Deliverables Checklist/;
+/** Checkbox a colonna zero: `- [ ]`, `- [x]`, `- [X]`, e nient'altro. */
+const CHECKBOX_RE = /^- \[[ xX]\]/;
+/**
+ * I DLV del task file, nell'ordine del file.
+ *
+ * Copia riga per riga dell'`awk` di `task-deliverables.sh`, comprese le sue
+ * tolleranze: la sezione si riconosce per prefisso (`## Deliverables Checklist
+ * (…)` vale), un fence non sospende niente, e il testo è ciò che segue i sei
+ * caratteri della checkbox, spazi in testa tolti. Una «correzione» qui — saltare
+ * le checkbox dentro un fence, per dire — darebbe numeri diversi da quelli dello
+ * script sul primo task file che ne ha una.
+ *
+ * Testo assente (task file non trovato) → nessun DLV.
+ */
+export function parseDeliverables(text) {
+    if (!text)
+        return [];
+    const out = [];
+    let inSection = false;
+    for (const line of text.split('\n')) {
+        if (SECTION_RE.test(line)) {
+            inSection = DLV_SECTION_RE.test(line);
+            continue;
+        }
+        if (!inSection || !CHECKBOX_RE.test(line))
+            continue;
+        out.push({
+            n: out.length + 1,
+            done: line[3] !== ' ',
+            text: line.slice(6).replace(/^[ \t]+/, ''),
+        });
+    }
+    return out;
+}
+const DECISIONS_RE = /^## Decisions\b/;
+const PREFLIGHT_RE = /^### Preflight\b/;
+/** La dicitura che `preflight-task` mette nel heading quando si ferma davanti a
+ *  una premessa smentita (§0b della skill). */
+const DECAYED_RE = /premessa decaduta/i;
+/**
+ * L'ULTIMO blocco `### Preflight` di `## Decisions` decide: `preflight-task`
+ * appende in fondo alla sezione, quindi l'ultimo nel file è il più recente.
+ * Una premessa decaduta seguita da un preflight riuscito non blocca più; il
+ * contrario sì.
+ */
+export function preflightState(text) {
+    if (!text)
+        return 'none';
+    let inDecisions = false;
+    let last = 'none';
+    for (const line of text.split('\n')) {
+        if (SECTION_RE.test(line)) {
+            inDecisions = DECISIONS_RE.test(line);
+            continue;
+        }
+        if (inDecisions && PREFLIGHT_RE.test(line))
+            last = DECAYED_RE.test(line) ? 'decayed' : 'done';
+    }
+    return last;
+}
+/**
+ * La Size della task, ridotta alla sua prima parola maiuscola (`L`, `M`, `S`,
+ * `EPIC`). Assente o vuota → `M`, come in `run-task` §4: la mancanza del campo
+ * non deve far scattare il ramo più severo.
+ */
+export function taskSize(id, text) {
+    if (!text)
+        return 'M';
+    const raw = parseTaskDetail(id, text).fields['Size'] ?? '';
+    return /^\s*([A-Za-z]+)/.exec(raw)?.[1]?.toUpperCase() ?? 'M';
+}
+export const DLV_REASON = {
+    closed: 'task chiusa',
+    empty: 'nessun deliverable in ## Deliverables Checklist',
+    allDone: 'tutti i deliverable sono chiusi',
+    decayed: 'premessa decaduta — ricostruisci le premesse, poi preflight-task',
+    sizeL: 'preflight obbligatorio — Size L senza ### Preflight in ## Decisions',
+};
+/**
+ * Il gate di `run-task` §3 visto dal deck, più i due casi in cui non c'è niente
+ * da lanciare.
+ *
+ * L'ordine dei controlli è quello della domanda «cosa partirebbe?»: prima se c'è
+ * qualcosa da eseguire, poi se la skill lo eseguirebbe. Su una task chiusa con
+ * una premessa decaduta il motivo utile è «chiusa», non il preflight.
+ *
+ * `done` viene da `tasks.md` (la Prog ✔️ della lista, `isDone`) e non dal campo
+ * `Progress` del task file: è la stessa fonte che usa il resto del deck, e il
+ * testo che il detail ha in mano è già sanificato — il glifo di Done lì non è
+ * più quello scritto su disco.
+ *
+ * `Size: Epic` non esclude (D2): un'epica con DLV propri resta lanciabile, e se
+ * `run-task` si rifiuta il rifiuto è della skill, non del deck.
+ */
+export function dlvGate(id, text, dlvs, done) {
+    if (done)
+        return { kind: 'off', reason: DLV_REASON.closed };
+    if (dlvs.length === 0)
+        return { kind: 'off', reason: DLV_REASON.empty };
+    if (!dlvs.some((d) => !d.done))
+        return { kind: 'off', reason: DLV_REASON.allDone };
+    const preflight = preflightState(text);
+    if (preflight === 'decayed')
+        return { kind: 'blocked', reason: DLV_REASON.decayed };
+    if (taskSize(id, text) === 'L' && preflight === 'none') {
+        return { kind: 'blocked', reason: DLV_REASON.sizeL };
+    }
+    return { kind: 'ready' };
+}

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/glyphs.js

@@ -123,6 +123,22 @@ export const INBOX_MARK = {
  *  sessioni: la cella si riempie di spazi anche quando è vuota, o le righe
  *  `held` sposterebbero a sinistra tutto ciò che segue. */
 export const INBOX_MARK_W = 2;
+/**
+ * T189 — colonna di stato di un DLV nella lista del detail, larga 3 in tutte e
+ * tre le forme: il numero e il testo che seguono restano incolonnati.
+ *
+ * La selezione è `[•]` e non `[x]`: nel task file `[x]` vuol dire FATTO, e sulla
+ * stessa schermata il testo reso sopra la lista lo mostra proprio con quel
+ * significato. Un `[x]` che sotto vuol dire «scelto» sarebbe un falso amico. Il
+ * fatto porta la spunta del Done della lista task, lo stesso glifo per la
+ * stessa idea.
+ */
+export const DLV_MARK = {
+    done: sanitize('✔'),
+    open: '[ ]',
+    picked: '[•]',
+};
+export const DLV_MARK_W = 3;
 // Marker Done per il DISPLAY. `task.prog` resta il `✔️` letto da tasks.md —
 // `isDone()` e le lookup di `view.ts` ci confrontano sopra, e `task-edit` lo
 // riscrive sul file: è una chiave semantica, non testo. Qui `sanitize` lo

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/input.js

@@ -26,6 +26,7 @@ import { captures, inertNote, scrolls, taskModeKey, } from './input-modes.js';
 import { LEFT_PANE, META_ROWS, QUIT_WINDOW_MS, RIGHT_PANE } from './model.js';
 import { TASK_VIEWS, taskView } from './pane-views.js';
 import { loadTaskFileText } from './tasks.js';
+import { isDone } from './layout.js';
 import { inboxPrompt, loadInboxText } from './inbox.js';
 import { dirListing, loadDocText } from './doc-tree.js';
 import { refuse } from './platform.js';
@@ -524,6 +525,9 @@ export function useDeckInput({ cwd, tasksDir, mode, setMode, setNote, model, act
                         // restare senza intestazione solo perché il file manca.
                         title: model.detail?.title || task.desc,
                         text: loadTaskFileText(tasksDir, task.id),
+                        // T189 — la Prog della lista, non il campo del task file: è la
+                        // fonte che il resto del deck legge come «chiusa».
+                        done: isDone(task.prog),
                     });
                 }
             }

package/dist/overlays/dlv-mode.js

@@ -0,0 +1,123 @@
+// T189 — il MODO DLV del detail della task: la lista dei deliverable,
+// selezionabile, al posto dell'area di compilazione.
+//
+// È una variante dell'azione `run` del detail, non un'azione nuova (D3): stesso
+// spawn, stesso modello, stesso titolo, override di progetto compreso. Cambia
+// solo il prompt — il perimetro scelto in coda (`/loom-works:run-task T189 2,4`),
+// oppure `cosa fare ora [R0]` senza selezione (D4).
+//
+// Vive fuori da `sheet.ts` (D5) e non lo importa: il detail possiede il modo,
+// questo modulo ne possiede lo stato. Le regole del plugin che decide di
+// rispettare — numerazione e gate di `run-task` — stanno in `deliverables.ts`.
+import { useState } from 'react';
+import { dlvGate, parseDeliverables } from '../deliverables.js';
+/** D4 — il prompt di `⏎` senza nessun DLV selezionato. */
+export const DLV_IDLE_PROMPT = 'cosa fare ora [R0]';
+/**
+ * D3/D4 — il prompt che parte da `⏎` nel modo DLV.
+ *
+ * Con una selezione: il prompt dell'azione `run` GIÀ RISOLTO (default del deck ←
+ * override di progetto, buchi riempiti) con il perimetro in coda, in ordine
+ * crescente — `run-task` normalizza da sé, ma il prompt è anche ciò che l'umano
+ * legge nella riga di stato prima di premere. Lista semplice e non range: la
+ * grammatica `1,3-5` di `run-task` la accetta, e compattare non toglie ambiguità.
+ *
+ * Senza selezione: `cosa fare ora [R0]`, nella stessa sessione bound di `run`.
+ */
+export function dlvPrompt(runPrompt, selected) {
+    const scope = [...selected].sort((a, b) => a - b);
+    if (scope.length === 0)
+        return DLV_IDLE_PROMPT;
+    return `${(runPrompt ?? '').trim()} ${scope.join(',')}`.trim();
+}
+/**
+ * Il DLV aperto dopo (o prima di) `from`, in giro come le righe dell'area di
+ * compilazione: `↑↓` si fermano solo sui DLV da fare. `from` è un NUMERO di DLV
+ * e non un indice — resta valido comunque la lista venga finestrata a schermo.
+ * `from` fuori dagli aperti → il primo aperto; nessun DLV aperto → 0.
+ */
+export function stepOpen(dlvs, from, delta) {
+    const open = dlvs.filter((d) => !d.done).map((d) => d.n);
+    if (open.length === 0)
+        return 0;
+    const at = open.indexOf(from);
+    if (at < 0)
+        return open[0];
+    return open[(((at + delta) % open.length) + open.length) % open.length];
+}
+/** `spazio` sul DLV `n`: lo mette nella selezione o lo toglie. */
+export function toggleIn(selected, n) {
+    const next = new Set(selected);
+    if (next.has(n))
+        next.delete(n);
+    else
+        next.add(n);
+    return next;
+}
+const NONE = new Set();
+const CLOSED = { kind: 'off', reason: '' };
+export function useDlvMode() {
+    /** Il detail mostra la lista DLV (`true`) o l'area di compilazione. */
+    const [active, setActive] = useState(false);
+    const [dlvs, setDlvs] = useState([]);
+    const [gate, setGate] = useState(CLOSED);
+    const [cursor, setCursor] = useState(0);
+    const [selected, setSelected] = useState(NONE);
+    const [run, setRun] = useState(null);
+    /**
+     * Azzera tutto a ogni apertura del detail, come gli altri campi: una selezione
+     * che sopravvive alla chiusura farebbe partire un perimetro che a schermo non
+     * si vede più.
+     *
+     * Il modo di apertura è il gate: si apre sui DLV solo se `⏎` lì lancerebbe
+     * davvero qualcosa — su una task bloccata o chiusa l'area di compilazione resta
+     * quella di sempre, e la lista si raggiunge con `tab`.
+     */
+    function open(input) {
+        const list = parseDeliverables(input.text);
+        const g = dlvGate(input.id, input.text, list, input.done);
+        setDlvs(list);
+        setGate(g);
+        setRun(input.run);
+        setCursor(g.kind === 'ready' ? stepOpen(list, 0, 1) : 0);
+        setSelected(NONE);
+        setActive(g.kind === 'ready');
+    }
+    function toggle() {
+        setActive((a) => !a);
+    }
+    const prompt = dlvPrompt(run?.prompt ?? null, selected);
+    /** Lo spawn di `⏎`, o `null` se il gate non lo permette: la ragione è già a
+     *  schermo nella riga di stato della lista, quindi il tasto resta inerte. */
+    function launch() {
+        if (gate.kind !== 'ready' || !run)
+            return null;
+        return { model: run.model, title: (run.title ?? '').trim(), prompt };
+    }
+    /** I tasti della lista. Il chiamante gestisce prima i suoi (`tab`, `⏎`, `esc`,
+     *  `^F`, `PgUp`/`PgDn`); qui resta ciò che muove cursore e selezione. Fuori
+     *  da `ready` nessun DLV è selezionabile, quindi ogni tasto è inerte. */
+    function onKey(input, key) {
+        if (gate.kind !== 'ready')
+            return;
+        if (key.upArrow || key.downArrow) {
+            setCursor((c) => stepOpen(dlvs, c, key.upArrow ? -1 : 1));
+        }
+        else if (input === ' ' && !key.ctrl && !key.meta && cursor > 0) {
+            setSelected((s) => toggleIn(s, cursor));
+        }
+    }
+    return {
+        active,
+        dlvs,
+        gate,
+        cursor,
+        selected,
+        prompt,
+        model: run?.model ?? null,
+        open,
+        toggle,
+        launch,
+        onKey,
+    };
+}

package/dist/overlays/sheet.js

@@ -12,7 +12,7 @@
 // Lo spawn della sessione dalla barra azioni NON sta qui: arriva come callback
 // `onAction`, per lo stesso confine di `useSearchOverlay`.
 import { useEffect, useMemo, useState } from 'react';
-import { detailCapacity, pageStep } from '../viewport.js';
+import { DETAIL_FIELD_ROWS, DLV_STATUS_ROWS, detailCapacity, dlvListRows, pageStep, } from '../viewport.js';
 import { wrapWithOffsets } from '../width.js';
 import { scanText, topForOffset } from '../text-search.js';
 import { parseMarkdown } from '../markdown.js';
@@ -21,6 +21,7 @@ import { sanitizeTyped } from '../glyphs.js';
 import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, specializeRecap, } from '../spawn-catalog.js';
 import { taskIsEpic } from '../tasks.js';
 import { fieldsKey } from '../fields.js';
+import { useDlvMode } from './dlv-mode.js';
 // T117 — le righe dell'area di compilazione del detail, nell'ordine in cui si
 // leggono dall'alto. Gli indici sono nominati perché li usano insieme l'handler
 // dei tasti e la resa, e un `2` nudo in due file diversi è la coordinata che
@@ -67,6 +68,9 @@ export function useSheetOverlay(deps) {
      *  riparserebbe l'intero task file per un campo dell'header. */
     const [epic, setEpic] = useState(false);
     const [cursor, setCursor] = useState({ row: DROW.action, caret: 0 });
+    // T189 — il secondo modo del detail: la lista dei DLV al posto dell'area di
+    // compilazione, alternata da `tab`.
+    const dlv = useDlvMode();
     // T91 — ricerca dentro il detail. `open` distingue i due modi in cui la si
     // lascia: `esc` butta via ciò che il modale ha prodotto (`find` a null,
     // evidenziazione via), `⏎` lo congela e restituisce il controllo allo strato
@@ -91,7 +95,11 @@ export function useSheetOverlay(deps) {
     // RESO, ed è l'unica coordinata coerente che resti — il sorgente non è più
     // ciò che sta a schermo.
     const lines = useMemo(() => (doc ? wrapWithOffsets(doc.text, width) : []), [doc, width]);
-    const capacity = detailCapacity(rows, find?.open === true);
+    // T189 — l'area sotto il testo cambia altezza col modo: cinque righe di campi,
+    // oppure la lista DLV più la sua riga di stato. Il testo prende il resto.
+    const searching = find?.open === true;
+    const dlvRows = dlvListRows(rows, searching, dlv.dlvs.length);
+    const capacity = detailCapacity(rows, searching, dlv.active ? dlvRows + DLV_STATUS_ROWS : DETAIL_FIELD_ROWS);
     const maxTop = Math.max(0, lines.length - capacity);
     // Lo scan gira sulla STESSA stringa che si renderizza: cercare su un testo
     // diverso da quello a schermo darebbe offset che indicizzano un altro
@@ -137,6 +145,9 @@ export function useSheetOverlay(deps) {
         setCursor({ row: DROW.action, caret: 0 });
         setFind(null);
         setOccIdx(0);
+        // T189/D3 — il modo DLV è una variante di `run`: la terna gli arriva già
+        // risolta, override di progetto compreso, come all'azione che replica.
+        dlv.open({ id: next.id, text: next.text, done: next.done === true, run: defaults('run', next.id) });
         setNote('');
         setMode('detail');
     }
@@ -264,6 +275,13 @@ export function useSheetOverlay(deps) {
             setFind((f) => (f ? { ...f, open: true } : { q: '', caret: 0, open: true }));
             return;
         }
+        if (key.tab) {
+            // T189 — `tab` alterna area di compilazione e lista DLV. Nel detail era
+            // inerte (`fieldsKey` non lo consuma), e il `tab` che cicla le viste vive
+            // solo nella lista: nessun significato tolto.
+            dlv.toggle();
+            return;
+        }
         if (key.escape) {
             // Uno strato alla volta: se resta un'evidenziazione congelata, `esc`
             // smonta quella; il detail lo chiude il secondo.
@@ -275,6 +293,19 @@ export function useSheetOverlay(deps) {
                 close();
             return;
         }
+        if (key.return && dlv.active) {
+            // T189 — nel modo DLV `⏎` lancia `run` col perimetro scelto. Gate non
+            // pronto → inerte: il motivo è già scritto sotto la lista, e chiudere il
+            // detail lo porterebbe via.
+            const launch = dlv.launch();
+            if (!launch)
+                return;
+            const id = sheet?.id;
+            close();
+            if (id)
+                onAction(id, launch.model, launch.title, launch.prompt, false);
+            return;
+        }
         if (key.return) {
             // `⏎` esegue SEMPRE l'azione selezionata, da qualunque riga: i campi sono
             // di una riga sola, quindi nessuno di loro ha da farci un a-capo.
@@ -297,6 +328,10 @@ export function useSheetOverlay(deps) {
             scroll(pageStep(capacity));
             return;
         }
+        if (dlv.active) {
+            dlv.onKey(input, key);
+            return;
+        }
         // Tutto il resto è dell'area di compilazione. Ciò che non consuma resta
         // inerte — dentro un modo capturing è la scelta giusta: gli acceleratori
         // globali non devono riattivarsi, e su una riga a scelta una lettera che
@@ -319,6 +354,8 @@ export function useSheetOverlay(deps) {
         maxTop,
         findRes,
         occCur,
+        dlv,
+        dlvRows,
         open,
         onKey,
         scroll,

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

@@ -7,8 +7,9 @@
 // stringa È il path; su Windows no, per tre ragioni misurate (verdetto 1 di T174):
 //
 //  - NTFS non distingue le maiuscole, e Claude Code non normalizza la grafia
-//    della cwd: VS Code passa `c:\…`, Windows Terminal `C:\…`, e lo stesso
-//    progetto ha due cartelle di transcript (`c--…` e `C--…`);
+//    della cwd: VS Code passa `c:\…`, Windows Terminal `C:\…`. La cartella di
+//    transcript del progetto è una sola, ma il suo nome porta la grafia di chi
+//    l'ha creata (`c--…` o `C--…`);
 //  - `\` e `/` sono entrambi separatori;
 //  - nei transcript `cwd` compare anche in forma MSYS (`/c/…`), quella di Git
 //    Bash.
@@ -59,9 +60,11 @@ export function projectBaseName(cwd, platform = process.platform) {
  * Le cartelle di transcript del progetto, fra i nomi di `~/.claude/projects/`.
  *
  * Su Linux una sola, il nome esatto. Su win32 ogni nome che coincide ignorando
- * le maiuscole: la stessa root avviata da VS Code (`c:\…`) e da Windows
- * Terminal (`C:\…`) scrive in `c--…` e in `C--…`, e leggerne una sola perde le
- * conversazioni dell'altra.
+ * le maiuscole: per NTFS `c--…` e `C--…` sono la stessa cartella, ma `readdir`
+ * ne restituisce il nome con la grafia di chi l'ha creata — `c--…` se la prima
+ * conversazione è nata da VS Code (`c:\…`) — mentre il nome cercato il deck lo
+ * ricava dalla propria root, che può avere l'altra grafia. Un confronto esatto
+ * non troverebbe la cartella.
  */
 export function matchingDirNames(entries, name, platform = process.platform) {
     if (platform !== 'win32')
@@ -69,3 +72,38 @@ 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 di avvio che la
+ * conversazione ha registrato, in forma Windows e con la grafia del drive
+ * d'origine (P7 preflight). La ragione non è trovare il transcript: per NTFS
+ * `c--…` e `C--…` sono la stessa cartella, e `claude --resume` lo trova da tutte
+ * e due le grafie (misurato in T176 con Claude Code 2.1.310, anche con
+ * `--fork-session`). La ragione è la fiducia della cartella: Claude Code la
+ * tiene in `~/.claude.json` per grafia esatta del path (`c:/…` e `C:/…` sono due
+ * voci), e una sessione interattiva in una grafia mai approvata si ferma sulla
+ * domanda di fiducia prima di caricare la conversazione. Una conversazione nata
+ * interattiva ha già la fiducia nella grafia in cui è nata.
+ *
+ * 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, '\\')}`;
+}