@lamemind/loom-deck 0.77.0 → 0.79.0

package/README.md

@@ -403,12 +403,13 @@ Le tab usano il profilo di Windows Terminal **`loom-deck`**, uno solo per tutti
   "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"
 }
 ```
 
-`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`).
+`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.
 

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/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/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/live-sessions.js

@@ -2,8 +2,10 @@ import { readFileSync, readdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { isWithin } from './project-path.js';
-function liveSessionsRoot() {
-    return join(homedir(), '.claude', 'sessions');
+/** La cartella del registry. `LOOM_DECK_LIVE_SESSIONS_ROOT` la sposta, per i
+ *  test che costruiscono un registro finto invece di leggere quello vero. */
+export function liveSessionsRoot(env = process.env) {
+    return env.LOOM_DECK_LIVE_SESSIONS_ROOT || join(homedir(), '.claude', 'sessions');
 }
 /**
  * Campo 22 (`starttime`) di `/proc/<pid>/stat`, o null se la riga non è
@@ -96,24 +98,16 @@ export function parseLiveEntry(content, pid) {
     };
 }
 /**
- * Le sessioni VIVE del solo progetto corrente, indicizzate per `sessionId` —
- * la stessa chiave del sidecar `session-tasks.jsonl` e di `deck-run --resume`,
- * quindi il join con la riga di lista è diretto.
- *
- * Il filtro per `cwd` è d'EFFICIENZA, non di correttezza: risparmia lo `stat`
- * di `/proc` sui processi degli altri progetti (il registry è globale, non
- * per-progetto). Il match resta sul `sessionId`.
+ * Le entry VIVE del registry, nell'ordine di `readdir`.
  *
- * Nessuna cache mtime-keyed come in `sessions.ts`: le entry sono poche e di
- * poche centinaia di byte, mentre `status` cambia a ogni turno — una cache qui
- * mostrerebbe `idle` su una sessione che sta lavorando, cioè il difetto che la
- * colonna esiste per non avere.
+ * `keep` scarta un'entry PRIMA del controllo di liveness: chi filtra per
+ * progetto risparmia così lo `stat` di `/proc` sui processi degli altri.
  */
-export function discoverLiveSessions(projectRoot) {
-    const out = new Map();
+function liveEntries(root, keep = () => true) {
+    const out = [];
     let files;
     try {
-        files = readdirSync(liveSessionsRoot()).filter((f) => f.endsWith('.json'));
+        files = readdirSync(root).filter((f) => f.endsWith('.json'));
     }
     catch {
         return out; // registry assente (CLI mai avviato, o versione che non lo scrive)
@@ -124,7 +118,7 @@ export function discoverLiveSessions(projectRoot) {
             continue;
         let content;
         try {
-            content = readFileSync(join(liveSessionsRoot(), f), 'utf8');
+            content = readFileSync(join(root, f), 'utf8');
         }
         catch {
             continue; // il processo può finire fra readdir e read
@@ -133,16 +127,101 @@ export function discoverLiveSessions(projectRoot) {
         if (!parsed)
             continue;
         const { entry, procStart } = parsed;
-        // T175 — `isWithin` regge le grafie di Windows: il registry scrive `C:\…`,
-        // e la root del deck può arrivare con la lettera del drive in un altro case.
-        if (!isWithin(entry.cwd, projectRoot))
+        if (!keep(entry))
             continue;
         if (!isAlive(pid, procStart))
             continue;
+        out.push(entry);
+    }
+    return out;
+}
+/**
+ * Le sessioni VIVE del solo progetto corrente, indicizzate per `sessionId` —
+ * la stessa chiave del sidecar `session-tasks.jsonl` e di `deck-run --resume`,
+ * quindi il join con la riga di lista è diretto.
+ *
+ * Il filtro per `cwd` è d'EFFICIENZA, non di correttezza: risparmia lo `stat`
+ * di `/proc` sui processi degli altri progetti (il registry è globale, non
+ * per-progetto). Il match resta sul `sessionId`.
+ *
+ * Nessuna cache mtime-keyed come in `sessions.ts`: le entry sono poche e di
+ * poche centinaia di byte, mentre `status` cambia a ogni turno — una cache qui
+ * mostrerebbe `idle` su una sessione che sta lavorando, cioè il difetto che la
+ * colonna esiste per non avere.
+ */
+export function discoverLiveSessions(projectRoot) {
+    const out = new Map();
+    // T175 — `isWithin` regge le grafie di Windows: il registry scrive `C:\…`,
+    // e la root del deck può arrivare con la lettera del drive in un altro case.
+    for (const entry of liveEntries(liveSessionsRoot(), (e) => isWithin(e.cwd, projectRoot))) {
         out.set(entry.sessionId, entry);
     }
     return out;
 }
+/**
+ * Il nome CHIESTO in un argv di `claude` — il valore di `--name` o del suo alias
+ * `-n`, staccato o con `=` — oppure `null` se l'argv non ne chiede uno.
+ *
+ * Non è il campo `name` del registry, ed è la ragione per cui serve: il registry
+ * porta il nome EFFETTIVO, e quando il nome chiesto è già preso il CLI rinomina
+ * la sessione (`🧵 loom-works` → `🧵 loom-works-cryptic-hopper`, con
+ * `nameSource: "collision"`), mentre il titolo della tab resta il nome chiesto.
+ *
+ * GEMELLA di `procRequestedName` in `loom-compass/compass@lamemind/model.js`:
+ * le due letture devono riconoscere le stesse quattro forme.
+ */
+export function requestedNameIn(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--name' || a === '-n')
+            return argv[i + 1] ?? null;
+        if (a.startsWith('--name='))
+            return a.slice('--name='.length);
+        if (a.startsWith('-n='))
+            return a.slice('-n='.length);
+    }
+    return null;
+}
+/** Gli argomenti del processo: `/proc/<pid>/cmdline` li separa con NUL e ne
+ *  mette uno anche in coda. Ogni argomento arriva intero, spazi compresi. */
+function procArgv(pid) {
+    let raw;
+    try {
+        raw = readFileSync(`/proc/${pid}/cmdline`, 'utf8');
+    }
+    catch {
+        return null; // processo finito fra la liveness e la lettura
+    }
+    const argv = raw.split('\0');
+    if (argv.length && argv[argv.length - 1] === '')
+        argv.pop();
+    return argv;
+}
+/**
+ * T182 — i nomi chiesti con `--name` dalle conversazioni vive di TUTTI i
+ * progetti: l'ingresso di `twinTitle` (`src/twin-title.ts`).
+ *
+ * Nessun filtro per `cwd`, al contrario di `discoverLiveSessions`: chi cerca la
+ * tab per titolo la cerca in tutte le finestre Ptyxis, quindi una conversazione
+ * dello stesso progetto aperta da un worktree di lane (altro `cwd`, stesso
+ * titolo) è un gemello a tutti gli effetti. Il titolo porta già la label del
+ * progetto, e il confronto per uguaglianza intera non scambia un progetto con
+ * un altro.
+ *
+ * Una viva senza `--name` non entra: il suo titolo di tab non è un nome
+ * chiesto. Dove `/proc` non esiste nessuna entry risulta viva, e la lista
+ * esce vuota: il lancio usa il nome base.
+ */
+export function liveRequestedNames(root = liveSessionsRoot()) {
+    const names = [];
+    for (const entry of liveEntries(root)) {
+        const argv = procArgv(entry.pid);
+        const name = argv ? requestedNameIn(argv) : null;
+        if (name !== null)
+            names.push(name);
+    }
+    return names;
+}
 /** Signature del poll: cambia quando cambia l'insieme delle vive O lo stato di
  *  una di esse. Il `pid` ci sta dentro perché un `/clear` sposta lo stesso
  *  `sessionId` su un processo diverso senza toccare né insieme né stato. */

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/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')
@@ -72,12 +75,16 @@ export function matchingDirNames(entries, name, platform = process.platform) {
 /**
  * T176 — la cartella in cui nasce la tab che riprende o forka una conversazione.
  *
- * Su Linux la root del progetto, come prima. Su win32 la cwd che la
- * conversazione ha registrato, in forma Windows (P7 preflight): `claude
- * --resume` cerca il transcript nella cartella che ricava dalla PROPRIA cwd, e
- * Claude Code non normalizza la lettera del drive (T174 verdetto 1) — una
- * conversazione nata da VS Code (`c:\…`) sta in `c--…`, e un `claude` partito in
- * `C:\…` la cercherebbe in `C--…`, senza trovarla.
+ * 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

package/dist/tab-compose.js

@@ -15,6 +15,7 @@
 import { saneNote } from './sane-note.js';
 import { MODEL_DEFAULT, MODELS } from './spawn-catalog.js';
 import { shellQuote } from './spawn.js';
+import { twinTitle } from './twin-title.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. */
@@ -173,6 +174,12 @@ export function posixQuote(text) {
 /**
  * La composizione intera.
  *
+ * Il titolo è `tabTitle` più, solo se una conversazione viva ha già chiesto lo
+ * stesso nome, il carattere del gemello (`twinTitle`, T182). Il carattere entra
+ * nel titolo intero — label, task, nota e fork compresi — perché due
+ * conversazioni della stessa task con note diverse hanno già titoli distinti e
+ * non sono gemelle. Lo stesso `title` alimenta `-T` di Ptyxis e `--name`.
+ *
  * 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
@@ -186,7 +193,7 @@ export function posixQuote(text) {
  */
 export function composeTab(req, ctx) {
     const warnings = [];
-    const title = tabTitle(req, projectLabel(ctx.config));
+    const title = twinTitle(tabTitle(req, projectLabel(ctx.config)), ctx.liveRequestedNames ?? []);
     const mode = permissionMode(ctx, warnings);
     const model = modelOf(req, ctx, warnings);
     const key = stateKey(ctx, warnings);

package/dist/tab-launch.js

@@ -21,6 +21,7 @@ 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 { liveRequestedNames, liveSessionsRoot } from './live-sessions.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
@@ -96,6 +97,9 @@ export async function runDeckRun(argv, io) {
         catalog: loadPromptCatalog(catalogPath),
         catalogPath,
         platform: io.platform,
+        // Su Windows niente `/proc`, quindi nessuna liveness (T177): il titolo
+        // resta quello base, cioè il comportamento di prima del gemello.
+        liveRequestedNames: io.platform === 'win32' ? [] : liveRequestedNames(liveSessionsRoot(io.env)),
     });
     for (const w of plan.warnings)
         io.stderr(`${w}\n`);

package/dist/twin-title.js

@@ -0,0 +1,63 @@
+// T182 — il titolo della conversazione GEMELLA: un carattere in coda al
+// `--name` quando una conversazione viva ha già chiesto lo stesso nome.
+//
+// Chi porta davanti la tab di una conversazione la cerca per titolo (coda via
+// AT-SPI, `sessionsByName` di compass), e il titolo della tab è il `--name`
+// passato a `claude`. Due conversazioni vive con lo stesso nome — tipico: il
+// preflight e il run della stessa task — hanno due tab con lo stesso titolo, e
+// chi cerca non può scegliere. Il lanciatore rende unico il secondo titolo; il
+// primo lancio resta senza carattere, quindi nel caso normale il titolo è quello
+// di sempre.
+//
+// Modulo PURO: i nomi chiesti dalle conversazioni vive arrivano già letti
+// (`liveRequestedNames` in `live-sessions.ts`).
+/**
+ * I caratteri del gemello, nell'ordine in cui si assegnano: il primo gemello
+ * prende `#`.
+ *
+ * GEMELLA di `TWIN_MARKS` in `loom-compass/compass@lamemind/model.js`, il
+ * secondo lanciatore di conversazioni: nessun codice confronta le due copie, e
+ * cambiarne una sola fa scegliere caratteri diversi ai due lanciatori senza
+ * errore. Si toccano insieme.
+ *
+ * Ogni carattere sta fuori da cinque classi, e ognuna rompe un consumer in
+ * silenzio:
+ *  - fuori dall'ASCII a una cella: un simbolo di larghezza ambigua (`§`, `†`)
+ *    occupa una o due celle a seconda della locale e sposta il taglio del
+ *    titolo nella tab;
+ *  - dentro l'alfabeto di `saneNote`: un carattere ammesso lì può arrivare da
+ *    una nota digitata, e il gemello non si distingue più dal testo;
+ *  - dentro `[A-Za-z0-9_-]`: il matcher di compass `titleKeyRe` riconosce una
+ *    finestra con `^<emoji> <name>(?![\w-])`;
+ *  - l'apice singolo: il titolo sta dentro `claude --name '…'` nella riga che
+ *    `bash -lc` analizza;
+ *  - i metacaratteri di shell (`; & $ \` | < >`): inerti fra apici, ma il test
+ *    di `saneNote` asserisce che nessun `[;&`$]` sopravviva in un titolo, e un
+ *    gemello della stessa classe renderebbe cieco quel test. Fuori anche la
+ *    punteggiatura che si legge come testo (`. , : /`) e le parentesi.
+ */
+export const TWIN_MARKS = ['#', '+', '=', '~', '^', '%', '@', '*', '?', '!'];
+/**
+ * Il titolo da usare: `base` se nessuna conversazione viva l'ha chiesto,
+ * altrimenti `base` + spazio + il primo carattere di `TWIN_MARKS` che nessuna
+ * conversazione viva porta già su quel nome.
+ *
+ * Lo spazio separa il carattere come ogni altro suffisso del titolo (` · T182`,
+ * ` <nota>`, ` · fork`): incollato all'ultima parola si leggerebbe come un
+ * refuso della nota. Il confronto è per uguaglianza intera, la stessa che fanno
+ * coda e `sessionsByName`.
+ *
+ * Insieme esaurito → `base`: il lancio parte comunque, e chi cerca la tab per
+ * titolo torna all'esito ambiguo che ha anche senza lanciatore.
+ */
+export function twinTitle(base, liveRequestedNames) {
+    const taken = new Set(liveRequestedNames);
+    if (!taken.has(base))
+        return base;
+    for (const mark of TWIN_MARKS) {
+        const candidate = `${base} ${mark}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+    return base;
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.77.0",
+  "version": "0.79.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": {