@lamemind/loom-deck 0.32.0 → 0.33.0

package/README.md

@@ -2,28 +2,19 @@
 
 Deck TUI (Ink) **per-progetto** della famiglia [loom](https://github.com/lamemind/loom-works).
 
-Legge il `tasks.md` del progetto e, con un tasto (poi un click), **spawna** una tab
-[Ptyxis](https://gitlab.gnome.org/chergert/ptyxis) che avvia una sessione Claude Code
-già bound alla task via `LOOM_TASK`.
+Legge il `tasks.md` del progetto e, con un tasto (poi un click), **spawna** una tab [Ptyxis](https://gitlab.gnome.org/chergert/ptyxis) che avvia una sessione Claude Code già bound alla task via `LOOM_TASK`.
 
 ```
 ↑↓ scegli la task  →  ⏎  →  tab CC di fianco  →  LOOM_TASK bound
 ```
 
-`⏎` apre il **detail** della task — task file scrollabile più una barra azioni —
-e da lì si sceglie con quale prompt entrare; `^K`/`^P`/`^R` restano acceleratori
-per chi lo sa già (vedi [I cinque modi di entrare in una
-task](#i-cinque-modi-di-entrare-in-una-task)).
+`⏎` apre il **detail** della task — task file scrollabile più una barra azioni — e da lì si sceglie con quale prompt entrare; `^K`/`^P`/`^R` restano acceleratori per chi lo sa già (vedi [I cinque modi di entrare in una task](#i-cinque-modi-di-entrare-in-una-task)).
 
-Entrambi i prefissi del contratto loom entrano in lista: **`T`** (code task) e
-**`D`** (doc task). Il trattamento è identico ovunque tranne che su `^R`, dove il
-prompt dispatcha sulla skill di esecuzione della rispettiva famiglia.
+Entrambi i prefissi del contratto loom entrano in lista: **`T`** (code task) e **`D`** (doc task). Il trattamento è identico ovunque tranne che su `^R`, dove il prompt dispatcha sulla skill di esecuzione della rispettiva famiglia.
 
 ## Ruolo nella famiglia loom
 
-`loom-deck` è un **client** con runtime proprio (TUI Ink) che **consuma** il contratto
-definito da `loom-works-plugin` (formato `tasks.md`, variabile `LOOM_TASK`) — non lo
-ridefinisce. Divisione dei ruoli con Compass:
+`loom-deck` è un **client** con runtime proprio (TUI Ink) che **consuma** il contratto definito da `loom-works-plugin` (formato `tasks.md`, variabile `LOOM_TASK`) — non lo ridefinisce. Divisione dei ruoli con Compass:
 
 | | scope | ruolo | domanda |
 |---|---|---|---|
@@ -32,8 +23,7 @@ ridefinisce. Divisione dei ruoli con Compass:
 
 ## Architettura di processo
 
-Il deck è **UN processo Node**: spawna ma **non contiene** le sessioni CC — le possiede
-Ptyxis. Chiudere il deck non uccide le sessioni. La tab nasce nella window *attiva*
+Il deck è **UN processo Node**: spawna ma **non contiene** le sessioni CC — le possiede Ptyxis. Chiudere il deck non uccide le sessioni. La tab nasce nella window *attiva*
 (quella col focus = il deck) → desktop isolation "gratis".
 
 ## Stato
@@ -50,8 +40,7 @@ Bootstrap + spike ① + **TUI ③** funzionante (legge `tasks.md`, `⏎` apre il
 
 ## Standard shortcut
 
-Regola unica, senza eccezioni — pensata per reggere l'aggiunta di nuove azioni
-senza collisioni:
+Regola unica, senza eccezioni — pensata per reggere l'aggiunta di nuove azioni senza collisioni:
 
 | Tasto | Semantica | Note |
 |---|---|---|
@@ -65,12 +54,7 @@ senza collisioni:
 | `1`…`9` | voce `launch` n-esima del progetto | da `.claude/loom-works.json` |
 | `q` `esc` | esce dal deck | in un modale `esc` annulla soltanto |
 
-`CTRL` è il terzo livello, aggiunto quando è arrivata la ricerca. Serve perché
-un modale con **campi di testo** mangia ogni lettera nuda: là dentro nessun
-comando può essere una lettera semplice. `CTRL+X` e `x` nudo condividono lo
-stesso `input` e si distinguono solo per `key.ctrl`, quindi in modalità normale
-il ramo `CTRL` è valutato **per primo** e chiude l'intera classe — senza,
-`CTRL+F` cadrebbe nel ramo `f` e forkerebbe una sessione invece di cercare.
+`CTRL` è il terzo livello, aggiunto quando è arrivata la ricerca. Serve perché un modale con **campi di testo** mangia ogni lettera nuda: là dentro nessun comando può essere una lettera semplice. `CTRL+X` e `x` nudo condividono lo stesso `input` e si distinguono solo per `key.ctrl`, quindi in modalità normale il ramo `CTRL` è valutato **per primo** e chiude l'intera classe — senza, `CTRL+F` cadrebbe nel ramo `f` e forkerebbe una sessione invece di cercare.
 
 Assegnazioni correnti:
 
@@ -98,39 +82,20 @@ Il footer è **due righe con due nature diverse**:
 t 💻 · c 🤖 · 1 📝 codium · 2 ☕ idea
 ```
 
-- **tasti** — cosa puoi fare *qui e ora*. Solo le voci attive: quelle contestuali
-  compaiono quando il pane a fuoco le rende possibili e altrimenti spariscono,
+- **tasti** — cosa puoi fare *qui e ora*. Solo le voci attive: quelle contestuali compaiono quando il pane a fuoco le rende possibili e altrimenti spariscono,
   invece di mostrarsi inerti. Fuori navigazione (`↑↓` `←→`), uscita (`q`) e
-  indicatore `focus:` — le prime due sono universali in qualunque TUI, il pane a
-  fuoco si vede già dall'evidenziazione.
-- **surface** — *dove* puoi aprire qualcosa: prima le due built-in (`t`/`c`), poi
-  le voci `launch` del progetto. Stanno insieme perché hanno la stessa natura —
-  fire-once, `cwd` = project root, nessuno stato — e differiscono solo per essere
-  universali invece che custom.
-
-L'indice da solo è opaco (le `launch` sono custom per-progetto, senza una lettera
-fissa per app), quindi la riga espone la mappa e non il conteggio. Se non entrano
-in larghezza, si ferma a voci intere e mostra il contatore di quelle fuori riga —
-mai un troncamento silenzioso; le celle delle due built-in sono riservate a monte,
-o le voci sfonderebbero il box di quel tanto. Il cap a `9` è imposto dai
-tasti-cifra, non dallo schema: un progetto può dichiarare più di 9 voci, quelle
-oltre la nona sono configurate ma non raggiungibili (e la riga lo dice).
-
-Le emoji sono quelle del menu compass. Per il terminale compass usa 🖥️, che nel
-frame Ink non sopravvive: `sanitize` lo sostituisce perché VTE lo disegna largo 1
-mentre `string-width` ne conta 2 (invariante ① di `src/width.ts`) — 💻 è il
-gemello concorde.
-
-`t` e `c` sono gemelle: entrambe aprono una surface del cappello nella stessa
-finestra Ptyxis, senza passare da un modale. `c` (minuscola, azione) e `C`
-(maiuscola, modale create-task) restano distinte per la regola sopra — così come
-`f` (fork) e `F` (filtri).
+  indicatore `focus:` — le prime due sono universali in qualunque TUI, il pane a fuoco si vede già dall'evidenziazione.
+- **surface** — *dove* puoi aprire qualcosa: prima le due built-in (`t`/`c`), poi le voci `launch` del progetto. Stanno insieme perché hanno la stessa natura — fire-once, `cwd` = project root, nessuno stato — e differiscono solo per essere universali invece che custom.
+
+L'indice da solo è opaco (le `launch` sono custom per-progetto, senza una lettera fissa per app), quindi la riga espone la mappa e non il conteggio. Se non entrano in larghezza, si ferma a voci intere e mostra il contatore di quelle fuori riga — mai un troncamento silenzioso; le celle delle due built-in sono riservate a monte, o le voci sfonderebbero il box di quel tanto. Il cap a `9` è imposto dai tasti-cifra, non dallo schema: un progetto può dichiarare più di 9 voci, quelle oltre la nona sono configurate ma non raggiungibili (e la riga lo dice).
+
+Le emoji sono quelle del menu compass. Per il terminale compass usa 🖥️, che nel frame Ink non sopravvive: `sanitize` lo sostituisce perché VTE lo disegna largo 1 mentre `string-width` ne conta 2 (invariante ① di `src/width.ts`) — 💻 è il gemello concorde.
+
+`t` e `c` sono gemelle: entrambe aprono una surface del cappello nella stessa finestra Ptyxis, senza passare da un modale. `c` (minuscola, azione) e `C` (maiuscola, modale create-task) restano distinte per la regola sopra — così come `f` (fork) e `F` (filtri).
 
 ### I cinque modi di entrare in una task
 
-Sulla task selezionata (focus sul pane Tasks) si apre una sessione **bound**:
-`LOOM_TASK` iniettata, `sessionId` pinnato, binding scritto nel sidecar. Fra i
-modi cambia **solo il prompt iniziale**.
+Sulla task selezionata (focus sul pane Tasks) si apre una sessione **bound**: `LOOM_TASK` iniettata, `sessionId` pinnato, binding scritto nel sidecar. Fra i modi cambia **solo il prompt iniziale**.
 
 | Azione (detail) | Tasto diretto | Prompt |
 |---|---|---|
@@ -140,18 +105,11 @@ modi cambia **solo il prompt iniziale**.
 | `run` | `^R` | `/loom-works:run-task <id>`, oppure `/loom-works:run-doc <id>` se l'id è una `D` |
 | `checkpoint` | — | `/loom-works:checkpoint-task <id>` |
 
-Il prompt iniziale è la scelta di **chi apre**, non una proprietà della task: lo
-stesso task file si apre per leggerne lo stato, per congelarne le decisioni, per
-eseguirlo o per entrarci a mani nude — e l'azione scelta *è* quell'intento.
+Il prompt iniziale è la scelta di **chi apre**, non una proprietà della task: lo stesso task file si apre per leggerne lo stato, per congelarne le decisioni, per eseguirlo o per entrarci a mani nude — e l'azione scelta *è* quell'intento.
 
-Le due superfici sono complementari, non alternative. `⏎` apre il **detail** e lì
-si legge la Description *mentre* si decide: è il caso normale, perché la domanda
-«quale azione?» quasi sempre si risponde leggendo la task. I tre `CTRL` saltano
-il passaggio per chi lo sa già. Dentro il detail sono inerti — i bottoni sono lì.
+Le due superfici sono complementari, non alternative. `⏎` apre il **detail** e lì si legge la Description *mentre* si decide: è il caso normale, perché la domanda «quale azione?» quasi sempre si risponde leggendo la task. I tre `CTRL` saltano il passaggio per chi lo sa già. Dentro il detail sono inerti — i bottoni sono lì.
 
-Col focus sul pane Sessions né `⏎` né i `CTRL` spawnano: l'oggetto dell'azione è
-la task selezionata, e senza quel pane a fuoco non ce n'è una (il deck lo dice
-nella riga di nota, invece di aprire qualcosa a caso).
+Col focus sul pane Sessions né `⏎` né i `CTRL` spawnano: l'oggetto dell'azione è la task selezionata, e senza quel pane a fuoco non ce n'è una (il deck lo dice nella riga di nota, invece di aprire qualcosa a caso).
 
 ### `⏎` — il detail della task
 
@@ -160,44 +118,25 @@ Overlay fullscreen a due zone: il **task file per intero**, scrollabile
 navigabile con `←→`, con `open` a fuoco all'apertura. `⏎` esegue l'azione
 selezionata e chiude; `esc` chiude lasciando la lista con la stessa selezione.
 
-Le azioni non sono un catalogo nuovo: chiamano lo **stesso** percorso di spawn
-dei tasti diretti. Una superficie in più, zero percorsi di spawn in più.
+Le azioni non sono un catalogo nuovo: chiamano lo **stesso** percorso di spawn dei tasti diretti. Una superficie in più, zero percorsi di spawn in più.
 
-Sono bottoni affiancati e non voci di un menu verticale perché è la forma che
-sopravvive all'arrivo del mouse: un rettangolo ha già coordinate e area
-cliccabile, una lista di voci andrebbe rifatta.
+Sono bottoni affiancati e non voci di un menu verticale perché è la forma che sopravvive all'arrivo del mouse: un rettangolo ha già coordinate e area cliccabile, una lista di voci andrebbe rifatta.
 
 Dentro il detail `←→` cicla i bottoni invece di cambiare la vista del pane — il
-ramo `useInput` della modalità chiude prima di arrivare a quello di default. Ink
-non ha focus-trap: la cattura **è** l'ordine dei rami, e cambiare cosa fa un
-tasto fuori dal detail non tocca cosa fa dentro.
+ramo `useInput` della modalità chiude prima di arrivare a quello di default. Ink non ha focus-trap: la cattura **è** l'ordine dei rami, e cambiare cosa fa un tasto fuori dal detail non tocca cosa fa dentro.
 
-Il catalogo dei prompt vive in `scripts/deck-run`, non nella TUI: è il primitive
-UI-agnostico, il deck gli passa un **simbolo** (`--prompt-kind`) e non una
-stringa. Così il testo sta in un posto solo, e con lui il suo vincolo di quoting
-— il prompt viaggia dentro apici singoli in `bash -lc`, quindi non può contenerne.
+Il catalogo dei prompt vive in `scripts/deck-run`, non nella TUI: è il primitive UI-agnostico, il deck gli passa un **simbolo** (`--prompt-kind`) e non una stringa. Così il testo sta in un posto solo, e con lui il suo vincolo di quoting — il prompt viaggia dentro apici singoli in `bash -lc`, quindi non può contenerne.
 
 ### `f` — forkare una conversazione
 
-Il fork rama la sessione selezionata: `claude --resume <origine> --fork-session`
-apre un **sessionId nuovo** con il transcript copiato, lasciando l'origine
-intatta. Serve quando vuoi ripartire da un certo stato senza perdere il ramo
-originale — e siccome i due id sono distinti, non esistono mai due processi che
-scrivono lo stesso file (il vincolo *single-writer* dello store di Claude Code).
+Il fork rama la sessione selezionata: `claude --resume <origine> --fork-session` apre un **sessionId nuovo** con il transcript copiato, lasciando l'origine intatta. Serve quando vuoi ripartire da un certo stato senza perdere il ramo originale — e siccome i due id sono distinti, non esistono mai due processi che scrivono lo stesso file (il vincolo *single-writer* dello store di Claude Code).
 
 Il nuovo id lo genera il deck e lo pinna con `--session-id`, per due ragioni:
 
-- il ramo **eredita la task** dell'origine (senza id noto in anticipo il fork
-  di una sessione scoped comparirebbe come spot);
-- il **lineage** finisce nel sidecar `.claude/loom/session-tasks.jsonl` come
-  campo `forkOf`. Serve perché il transcript del fork **non nomina** la sessione
-  d'origine da nessuna parte: è una copia verbatim (stessi uuid dei messaggi) e
-  `parentUuid` incatena i messaggi dentro un transcript, non le sessioni fra
-  loro. Senza quel record un ramo sarebbe una riga gemella dell'originale, di
-  cui eredita anche il titolo.
+- il ramo **eredita la task** dell'origine (senza id noto in anticipo il fork di una sessione scoped comparirebbe come spot);
+- il **lineage** finisce nel sidecar `.claude/loom/session-tasks.jsonl` come campo `forkOf`. Serve perché il transcript del fork **non nomina** la sessione d'origine da nessuna parte: è una copia verbatim (stessi uuid dei messaggi) e `parentUuid` incatena i messaggi dentro un transcript, non le sessioni fra loro. Senza quel record un ramo sarebbe una riga gemella dell'originale, di cui eredita anche il titolo.
 
-Un ramo si riconosce dal marker `⑂` nella lista e dalla riga `⑂ da <id>` nel
-pannello di dettaglio; la sua tab Ptyxis titola `<label> · <task> · fork`.
+Un ramo si riconosce dal marker `⑂` nella lista e dalla riga `⑂ da <id>` nel pannello di dettaglio; la sua tab Ptyxis titola `<label> · <task> · fork`.
 
 > **Nota di migrazione (0.6.0)**: `c` → **`C`** per creare una task, e le voci
 > `codium`/`idea` non hanno più una lettera dedicata (erano `C`/`I` hardcoded):
@@ -205,20 +144,14 @@ pannello di dettaglio; la sua tab Ptyxis titola `<label> · <task> · fork`.
 
 ### `^F` — cercare dentro le conversazioni
 
-Il navigator trova una conversazione per **metadati** (titolo, data, turni). `^F`
-la trova per **contenuto**: «l'IA me l'ha detto 150k di testo fa, ricordo mezza
-parola». Claude Code non ha un find-in-conversation, ma i transcript sono tutti
-su disco e il deck li legge già.
+Il navigator trova una conversazione per **metadati** (titolo, data, turni). `^F` la trova per **contenuto**: «l'IA me l'ha detto 150k di testo fa, ricordo mezza parola». Claude Code non ha un find-in-conversation, ma i transcript sono tutti su disco e il deck li legge già.
 
 Due campi, `tab` per passare dall'uno all'altro:
 
-- **hash** — prefisso del `sessionId` (gli 8 char della statusline bastano),
-  restringe a una conversazione. Vuoto = **tutte** quelle del progetto.
-- **chiave** — il termine cercato. La ricerca è **eager**: si aggiorna a ogni
-  carattere, da 3 in su.
+- **hash** — prefisso del `sessionId` (gli 8 char della statusline bastano), restringe a una conversazione. Vuoto = **tutte** quelle del progetto.
+- **chiave** — il termine cercato. La ricerca è **eager**: si aggiorna a ogni carattere, da 3 in su.
 
-Sei toggle, tutti su `CTRL` perché i campi di testo occupano le lettere nude.
-Lo stato si legge da `[x]`/`[ ]`, non dal solo colore:
+Sei toggle, tutti su `CTRL` perché i campi di testo occupano le lettere nude. Lo stato si legge da `[x]`/`[ ]`, non dal solo colore:
 
 | Tasto | Toggle | Default |
 |---|---|---|
@@ -229,42 +162,21 @@ Lo stato si legge da `[x]`/`[ ]`, non dal solo colore:
 | `^T` | cerca nei **tool** (`tool_use` / `tool_result`) | off |
 | `^U` | cerca nei prompt **umani** | off |
 
-Non esiste un toggle *thinking*: quei blocchi sono persistiti **senza testo**
-(il transcript porta la sola firma crittografica), quindi sarebbe una casella
-che non può mai produrre un risultato.
+Non esiste un toggle *thinking*: quei blocchi sono persistiti **senza testo** (il transcript porta la sola firma crittografica), quindi sarebbe una casella che non può mai produrre un risultato.
 
-Con l'hash vuoto la lista è **raggruppata per conversazione**; `⏎` è contestuale
-alla riga selezionata — su una riga-conversazione **riprende** la sessione
-(come dal pane Sessions), su una riga-occorrenza apre il **reader**. La selezione
-parte dalla prima *occorrenza*, non dalla riga di gruppo: quella è un segnaposto
-di navigazione, raggiungibile con le frecce ma non una destinazione.
+Con l'hash vuoto la lista è **raggruppata per conversazione**; `⏎` è contestuale alla riga selezionata — su una riga-conversazione **riprende** la sessione (come dal pane Sessions), su una riga-occorrenza apre il **reader**. La selezione parte dalla prima *occorrenza*, non dalla riga di gruppo: quella è un segnaposto di navigazione, raggiungibile con le frecce ma non una destinazione.
 
-L'estratto attorno al match **si allarga col terminale**: a 190 colonne sono
-~170 caratteri di contesto, non i 50 di un valore fisso — ed è il contesto la
-ragione per cui si legge la riga invece di aprire il reader.
+L'estratto attorno al match **si allarga col terminale**: a 190 colonne sono ~170 caratteri di contesto, non i 50 di un valore fisso — ed è il contesto la ragione per cui si legge la riga invece di aprire il reader.
 
-Sotto la lista, un **pannello di anteprima** mostra il contesto attorno
-all'occorrenza selezionata e si aggiorna navigando con le frecce. Prende solo le
-righe che la lista non usa: con pochi risultati riempie il terminale, con molti
-sparisce e la lista se le riprende — quando c'è tanto da scorrere la priorità è
-vedere più occorrenze, il contesto è il premio per una ricerca già stretta.
+Sotto la lista, un **pannello di anteprima** mostra il contesto attorno all'occorrenza selezionata e si aggiorna navigando con le frecce. Prende solo le righe che la lista non usa: con pochi risultati riempie il terminale, con molti sparisce e la lista se le riprende — quando c'è tanto da scorrere la priorità è vedere più occorrenze, il contesto è il premio per una ricerca già stretta.
 
 Il reader mostra il messaggio intero, aperto già **posizionato sull'occorrenza**
 col match evidenziato: `↑↓` riga, `PgUp`/`PgDn` pagina, `g`/`G` estremi, `esc`
-torna alla lista senza perdere query, toggle e selezione. (Gli estremi stanno su
-lettera e non su `Home`/`End` perché Ink non espone quei due tasti: arrivano
-indistinguibili da qualunque tasto ignoto.)
+torna alla lista senza perdere query, toggle e selezione. (Gli estremi stanno su lettera e non su `Home`/`End` perché Ink non espone quei due tasti: arrivano indistinguibili da qualunque tasto ignoto.)
 
-I toggle e la query sono **volatili**: sopravvivono alla chiusura del modale,
-non al riavvio del deck — comporre una ricerca non tocca il disco.
+I toggle e la query sono **volatili**: sopravvivono alla chiusura del modale, non al riavvio del deck — comporre una ricerca non tocca il disco.
 
-**Come fa a essere istantanea.** I corpi dei messaggi restano in RAM dentro la
-cache mtime-keyed che il deck usa già per la lista sessioni: quei file venivano
-comunque deserializzati per turni e titoli, e i corpi buttati. Trattenerli non
-aggiunge I/O, aggiunge memoria — e ne aggiunge poca, perché un JSONL è per l'85%
-overhead (misurato su un progetto reale: 57 MB su disco = 9,8 MB di testo
-cercabile). Cercarci dentro costa 1-9 ms; un prefiltro `grep` sugli stessi file
-ne costerebbe 26, perché rileggerebbe il volume pieno a ogni battuta.
+**Come fa a essere istantanea.** I corpi dei messaggi restano in RAM dentro la cache mtime-keyed che il deck usa già per la lista sessioni: quei file venivano comunque deserializzati per turni e titoli, e i corpi buttati. Trattenerli non aggiunge I/O, aggiunge memoria — e ne aggiunge poca, perché un JSONL è per l'85% overhead (misurato su un progetto reale: 57 MB su disco = 9,8 MB di testo cercabile). Cercarci dentro costa 1-9 ms; un prefiltro `grep` sugli stessi file ne costerebbe 26, perché rileggerebbe il volume pieno a ogni battuta.
 
 ## Vista: filtri e ordinamenti
 
@@ -281,24 +193,17 @@ p  priorità     s  stato     i  id
 Partendo da catena vuota, digitare `ppi` produce `[pri ↓, id ↑]`. Il ciclo parte
 sempre **dallo stato corrente**, che il modale mostra dal vivo mentre digiti.
 
-Sull'**id** il confronto è numerico (`T9` prima di `T10`, non lessicografico) e i
-due prefissi sono blocchi distinti — le `D` in coda alle `T`: i counter `T` e `D`
-sono separati nel contratto loom, quindi `T01` e `D01` non sono confrontabili
-come numeri soli.
-A parità su tutte le chiavi decide sempre l'`id` (confronto **numerico**: `T9`
+Sull'**id** il confronto è numerico (`T9` prima di `T10`, non lessicografico) e i due prefissi sono blocchi distinti — le `D` in coda alle `T`: i counter `T` e `D` sono separati nel contratto loom, quindi `T01` e `D01` non sono confrontabili come numeri soli. A parità su tutte le chiavi decide sempre l'`id` (confronto **numerico**: `T9`
 prima di `T10`) → l'ordine è deterministico, mai instabile fra un refresh e l'altro.
 
 **`F` — filtri.** Un toggle per ogni priorità e per ogni stato, componibili in AND.
 `↑↓` cambia riga, `←→` scorre i valori, `spazio` mostra/nasconde.
 
-In entrambi i modali la lista si aggiorna **dal vivo**; `⏎` conferma, `esc`
-ripristina la vista com'era all'apertura.
+In entrambi i modali la lista si aggiorna **dal vivo**; `⏎` conferma, `esc` ripristina la vista com'era all'apertura.
 
-Con un filtro attivo l'header dichiara sempre quanto sta nascondendo
-(`Tasks (9/25) · 16 nascoste`): il deck non finge mai una lista completa.
+Con un filtro attivo l'header dichiara sempre quanto sta nascondendo (`Tasks (9/25) · 16 nascoste`): il deck non finge mai una lista completa.
 
-**Persistenza.** La vista non si salva da sola — sperimentare non sporca nulla.
-`w` la scrive in `.claude/loom/deck-view.json` (macchina-locale, da gitignorare)
+**Persistenza.** La vista non si salva da sola — sperimentare non sporca nulla. `w` la scrive in `.claude/loom/deck-view.json` (macchina-locale, da gitignorare)
 e al riavvio viene ripristinata. File assente o corrotto → default puliti.
 
 ## L'header è un selettore di vista
@@ -317,23 +222,14 @@ Sessions · tutte (317) · ●2 vive · 📌4 · +213 più vecchie · ↑7 ·
 | Tasks | `Tasks (n/N)` (filtri applicati) · `N nascoste` (il complemento esatto di quei filtri) · `N archiviabili` (Done oltre `archivableDays`, cieca ai filtri) |
 | Sessions | `{parent} (N)` · `●N vive` · `📌N` · `+N più vecchie` (le contestuali che il cap `maxContext` tronca) |
 
-- **Il catalogo è fisso**, anche a contatore 0 (la voce si mostra dim). Un
-  catalogo che si accorcia sposta le voci sotto le dita, e la vista corrente può
-  svanire mentre la guardi — togliere un filtro mentre sei su `nascoste`.
+- **Il catalogo è fisso**, anche a contatore 0 (la voce si mostra dim). Un catalogo che si accorcia sposta le voci sotto le dita, e la vista corrente può svanire mentre la guardi — togliere un filtro mentre sei su `nascoste`.
 - **`↑N` `↓N` non sono viste**: contano elementi fuori finestra per altezza del
   terminale, cioè una posizione, non un insieme. Restano in coda, non selezionabili.
-- **Due assi ortogonali**: il pane task sceglie il *parent* delle conversazioni
-  (`≡ tutte` / `○ spot` / una task), l'header sceglie *quale sottoinsieme* di quel
-  parent. Cambiare parent non azzera la vista, che si ricalcola dentro il nuovo.
-- **`F` è inerte fuori dalla vista `Tasks`** e lo dice con una nota: su
-  `nascoste` riapplicare i filtri non ha senso, `archiviabili` è cieca per scelta.
-- **La vista è volatile**: non entra in `deck-view.json`, il deck riapre sempre
-  sulla voce 1. Un filtro salvato lo si è scelto; una vista non-default riaperta
-  a freddo si leggerebbe come la lista intera.
-- **Cambiare vista riporta la selezione in cima**, righe meta comprese: nessuna
-  regola di mantenimento, nessun tentativo di ritrovare l'elemento precedente.
-- Su un terminale stretto **la voce attiva è servita per prima** dal budget di
-  larghezza: sparisce un contatore, mai la voce che dice dove sei.
+- **Due assi ortogonali**: il pane task sceglie il *parent* delle conversazioni (`≡ tutte` / `○ spot` / una task), l'header sceglie *quale sottoinsieme* di quel parent. Cambiare parent non azzera la vista, che si ricalcola dentro il nuovo.
+- **`F` è inerte fuori dalla vista `Tasks`** e lo dice con una nota: su `nascoste` riapplicare i filtri non ha senso, `archiviabili` è cieca per scelta.
+- **La vista è volatile**: non entra in `deck-view.json`, il deck riapre sempre sulla voce 1. Un filtro salvato lo si è scelto; una vista non-default riaperta a freddo si leggerebbe come la lista intera.
+- **Cambiare vista riporta la selezione in cima**, righe meta comprese: nessuna regola di mantenimento, nessun tentativo di ritrovare l'elemento precedente.
+- Su un terminale stretto **la voce attiva è servita per prima** dal budget di larghezza: sparisce un contatore, mai la voce che dice dove sei.
 
 ## Installazione
 
@@ -346,9 +242,7 @@ 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) — **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`.
@@ -361,19 +255,9 @@ scripts/deck-run T18
 scripts/deck-run T18 --prompt-kind none|recap|preflight|run|checkpoint
 ```
 
-Apre una tab Ptyxis nella window attiva con `LOOM_TASK=T18 claude 'recap stato task T18'`.
-Il prompt iniziale è il terzo asse dello spawn, ortogonale al binding task
-(`<TaskID>` vs `--no-task`) e alla continuità (nuova vs `--resume`/`--fork`):
-senza flag resta `recap`, `none` apre la sessione bound **senza** alcun prompt.
-`LOOM_DECK_ENTER_PROMPT` (placeholder `{TASK}`) resta un override che vince sul
-kind — tranne su `none`, che è una richiesta esplicita di non averne.
-
-La tab porta anche `PTYXIS_PROFILE` forzata al profilo bindato al progetto nel
-registry (`bindings/claude`), letto da dconf: è la chiave con cui loom-compass
-associa a un progetto lo stato annunciato dagli hook (running/ask/done). Una tab
-`ptyxis --tab` nuda erediterebbe il profilo di default, e l'annuncio finirebbe
-keyed su un UUID che nessun progetto dichiara — pallino fermo su idle, senza
-alcun errore visibile. Override o disattivazione via `LOOM_DECK_STATE_PROFILE`
+Apre una tab Ptyxis nella window attiva con `LOOM_TASK=T18 claude 'recap stato task T18'`. Il prompt iniziale è il terzo asse dello spawn, ortogonale al binding task (`<TaskID>` vs `--no-task`) e alla continuità (nuova vs `--resume`/`--fork`): senza flag resta `recap`, `none` apre la sessione bound **senza** alcun prompt. `LOOM_DECK_ENTER_PROMPT` (placeholder `{TASK}`) resta un override che vince sul kind — tranne su `none`, che è una richiesta esplicita di non averne.
+
+La tab porta anche `PTYXIS_PROFILE` forzata al profilo bindato al progetto nel registry (`bindings/claude`), letto da dconf: è la chiave con cui loom-compass associa a un progetto lo stato annunciato dagli hook (running/ask/done). Una tab `ptyxis --tab` nuda erediterebbe il profilo di default, e l'annuncio finirebbe keyed su un UUID che nessun progetto dichiara — pallino fermo su idle, senza alcun errore visibile. Override o disattivazione via `LOOM_DECK_STATE_PROFILE`
 (settata a vuoto → nessun annuncio); progetto non registrato → nessun prefisso.
 
 ## Sviluppo (TUI Ink)
@@ -385,12 +269,9 @@ npm run build    # tsc → dist/
 npm test         # node:test sul core vista (src/view.ts), senza Ink né terminale
 ```
 
-Il core di filtri e ordinamenti (`src/view.ts`) è **puro**: nessun import da Ink o
-React, nessun I/O. È il motivo per cui è testabile con `node:test` su array
-fixture, mentre la TUI resta un guscio sottile che lo consuma.
+Il core di filtri e ordinamenti (`src/view.ts`) è **puro**: nessun import da Ink o React, nessun I/O. È il motivo per cui è testabile con `node:test` su array fixture, mentre la TUI resta un guscio sottile che lo consuma.
 
-Il deck cerca `tasks.md` in `$PWD/${LOOM_DECK_DOCS_ROOT:-docs}/tasks.md`. Progetti
-con docs-root non-standard esportano la variabile, es. `LOOM_DECK_DOCS_ROOT=runtime`.
+Il deck cerca `tasks.md` in `$PWD/${LOOM_DECK_DOCS_ROOT:-docs}/tasks.md`. Progetti con docs-root non-standard esportano la variabile, es. `LOOM_DECK_DOCS_ROOT=runtime`.
 
 La lista si **auto-aggiorna** quando `tasks.md` cambia sotto (poll su `mtime`, ~1.5s):
 crei/checkpoint una task da un'altra sessione → il deck la riflette senza riavvio.

package/dist/cli.js

@@ -20,6 +20,7 @@ import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessio
 import { assignListCapacity, detailCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { caretWindow, cut, cutParts, pad, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
 import { scanText, sliceLine, topForOffset, } from './text-search.js';
+import { parseMarkdown, sliceSpans, } from './markdown.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, progressText, writeTaskEdit, PRI_GLYPH, PRI_LABEL, PROG_GLYPH, } from './task-edit.js';
 import { loadView, saveView, viewFilePath } from './view-store.js';
@@ -840,18 +841,32 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // 2 padding) = 8. Sottostimare tronca un carattere, sovrastimare manda a capo
     // una riga che il budget d'altezza non ha contato.
     const sheetWidth = Math.max(20, (columns || 80) - 8);
+    // T75 — il markdown si rende PRIMA del wrap, e il resto della catena lavora
+    // sul testo reso: `**foo**` occupa 3 colonne rese e 7 grezze, quindi
+    // wrappare sui marker manderebbe a capo su un conteggio che il terminale non
+    // disegna. Memo separato dal wrap perché il parse dipende solo dal testo: un
+    // resize ri-wrappa 9KB, non li ri-parsa.
+    const sheetDoc = useMemo(() => (sheet?.text ? parseMarkdown(sheet.text) : null), [sheet]);
     // Le righe conservano i propri offset invece di essere appiattite a stringa
     // (T66 le buttava con `.map((l) => l.text)`): è ciò che rende
     // l'evidenziazione un'intersezione di intervalli invece di un caso speciale
-    // per il match spezzato dall'a-capo.
-    const sheetLines = useMemo(() => (sheet?.text ? wrapWithOffsets(sheet.text, sheetWidth) : []), [sheet, sheetWidth]);
+    // per il match spezzato dall'a-capo. Dopo T75 gli offset indicizzano il testo
+    // RESO, ed è l'unica coordinata coerente che resti — il sorgente non è più
+    // ciò che sta a schermo.
+    const sheetLines = useMemo(() => (sheetDoc ? wrapWithOffsets(sheetDoc.text, sheetWidth) : []), [sheetDoc, sheetWidth]);
     const sheetCap = detailCapacity(rows, find?.open === true);
     const sheetMaxTop = Math.max(0, sheetLines.length - sheetCap);
-    // Lo scan gira sulla STESSA stringa che si renderizza (`sheet.text`, già
-    // passata da `sanitize` in `loadTaskFileText`): una rilettura del file darebbe
-    // offset che indicizzano un documento diverso da quello a schermo, cioè
-    // un'evidenziazione spostata di N caratteri e nessun errore.
-    const findRes = useMemo(() => (find && sheet?.text ? scanText(sheet.text, find.q) : { occ: [], error: '' }), [find?.q, sheet]);
+    // Lo scan gira sulla STESSA stringa che si renderizza: cercare su un testo
+    // diverso da quello a schermo darebbe offset che indicizzano un altro
+    // documento, cioè un'evidenziazione spostata di N caratteri e nessun errore.
+    //
+    // Dopo T75 quella stringa è il testo RESO, non più il sorgente: si cerca ciò
+    // che si vede. Ne discende che `**` non è più cercabile — è la conseguenza
+    // voluta, perché a schermo non c'è; e `Priority`, che prima era `**Priority**`
+    // e si trovava lo stesso, continua a trovarsi.
+    const findRes = useMemo(() => find && sheetDoc
+        ? scanText(sheetDoc.text, find.q)
+        : { occ: [], error: '' }, [find?.q, sheetDoc]);
     // L'indice si clampa qui invece di essere corretto a ogni `setOccIdx`: la
     // lista si accorcia da sola mentre si digita, e un indice fuori range vivrebbe
     // per il tempo di un render.
@@ -2061,7 +2076,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         // 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(sheetTop, sheetMaxTop);
-        return (_jsx(DetailScreen, { id: sheet.id, title: sheet.title, missing: sheet.text === null, lines: sheetLines.slice(start, start + sheetCap), top: start, total: sheetLines.length, capacity: sheetCap, action: sheetAction, columns: columns, find: find, occ: findRes.occ, occCur: occCur }));
+        return (_jsx(DetailScreen, { id: sheet.id, title: sheet.title, missing: sheet.text === null, lines: sheetLines.slice(start, start + sheetCap), spans: sheetDoc?.spans ?? [], top: start, total: sheetLines.length, capacity: sheetCap, action: sheetAction, columns: columns, find: find, occ: findRes.occ, occCur: occCur }));
     }
     // ── T52 · schermate sostitutive ─────────────────────────────────────────
     // Ricerca e reader sono gli unici modali che NON stanno in flusso sopra i
@@ -2351,6 +2366,50 @@ function ReaderLine({ line, occ, current, }) {
         // mostrerebbe più dove sono le altre.
         _jsx(Text, { backgroundColor: s.current ? 'cyan' : 'yellow', color: "black", children: s.text }, i)) : (_jsx(Text, { children: s.text }, i))) }));
 }
+/** 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
+ *  il giallo perché sono lo stesso costrutto a due granularità: dargli due
+ *  colori direbbe che sono due cose. */
+const MD_STYLE = {
+    heading: { bold: true, color: 'cyan' },
+    bold: { bold: true },
+    code: { color: 'yellow' },
+    fence: { color: 'yellow' },
+};
+/**
+ * Una riga del detail (T75): markdown reso, con sopra l'evidenziazione della
+ * ricerca.
+ *
+ * Due segmentazioni sulla stessa riga, annidate e non fuse: prima si taglia sui
+ * costrutti markdown, poi ogni pezzo si ritaglia sulle occorrenze. L'ordine non
+ * è indifferente — così un match a cavallo di un `**grassetto**` resta
+ * evidenziato per intero e insieme conserva il grassetto sulla metà che ce
+ * l'ha, cosa che una segmentazione unica dovrebbe risolvere decidendo chi vince.
+ *
+ * Gli offset di `occ` e di `spans` indicizzano ENTRAMBI il testo reso: è ciò
+ * che permette di comporli senza rimappature. Vedi `sheetDoc` per il perché la
+ * ricerca del detail ha smesso di scandire il sorgente.
+ */
+function DetailLine({ line, spans, occ, current, }) {
+    const styled = sliceSpans(line, spans);
+    // Riga vuota → uno spazio: un `<Text>` senza contenuto Ink non lo disegna, e
+    // il testo si compatterebbe perdendo la struttura del file.
+    if (styled.length === 0)
+        return _jsx(Text, { wrap: "truncate-end", children: " " });
+    let off = line.start;
+    return (_jsx(Text, { wrap: "truncate-end", children: styled.map((seg, i) => {
+            const st = seg.kind ? MD_STYLE[seg.kind] : undefined;
+            const at = off;
+            off += seg.text.length;
+            // Senza ricerca aperta il secondo taglio non ha niente da tagliare, e
+            // saltarlo evita di allocare tre array per ogni riga a ogni freccia.
+            if (occ.length === 0) {
+                return (_jsx(Text, { bold: st?.bold, color: st?.color, children: seg.text }, i));
+            }
+            return (_jsx(Text, { bold: st?.bold, color: st?.color, children: sliceLine(seg.text, at, occ, current).map((p, j) => p.hit ? (_jsx(Text, { backgroundColor: p.current ? 'cyan' : 'yellow', color: "black", children: p.text }, j)) : (_jsx(Text, { children: p.text }, j))) }, i));
+        }) }));
+}
 /** Campo della ricerca nel detail: finestra ancorata al caret, cursore inverso
  *  sulla cella reale. Gemello di `EditTextField` senza la label, che qui sta
  *  fuori perché il campo vive in FLUSSO su una riga condivisa col contatore —
@@ -2372,7 +2431,7 @@ function DetailFindField({ value, caret, cols }) {
  * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione. La
  * navigazione da tastiera ci si sovrappone senza conflitti.
  */
-function DetailScreen({ id, title, missing, lines, top, total, capacity, action, columns, find, occ, occCur, }) {
+function DetailScreen({ id, title, missing, lines, spans, top, total, capacity, action, columns, find, occ, occCur, }) {
     const last = Math.min(total, top + capacity);
     // Il taglio lo fa il chiamante (invariante ③ di width.ts): la riga bottoni è
     // ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso — ma
@@ -2393,10 +2452,7 @@ function DetailScreen({ id, title, missing, lines, top, total, capacity, action,
     if (dropped(shown) > 0)
         shown = cutParts(parts, Math.max(0, width - 6));
     const cutCount = dropped(shown);
-    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: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^F" }), " cerca \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] })), _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)"] })) : (
-                // Riga vuota → uno spazio: un `<Text>` senza contenuto Ink non lo
-                // disegna, e il testo si compatterebbe perdendo la struttura del file.
-                lines.map((l, i) => _jsx(ReaderLine, { line: l, 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(DetailFindField, { value: find.q, caret: find.caret, 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, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] }) })] }));
+    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: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^F" }), " cerca \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] })), _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(DetailFindField, { value: find.q, caret: find.caret, 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, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] }) })] }));
 }
 /**
  * Larghezza del testo dentro la lista della schermata di assegnazione: box

package/dist/markdown.js

@@ -0,0 +1,260 @@
+// Rendering del markdown per il detail della task (T75): dal sorgente al
+// testo VISIBILE più gli intervalli da colorare.
+//
+// PERCHÉ IL PARSER PRODUCE TESTO E NON COLORE. La tentazione naturale è
+// restituire una stringa già colorata con escape ANSI dentro. Sarebbe il modo
+// più corto e il più sbagliato: `width.ts` misura CARATTERI per contare le
+// colonne del terminale, e una sequenza `ESC[1m` le violerebbe tutte —
+// `termWidth` conterebbe colonne che il terminale non disegna, quindi l'a-capo
+// cadrebbe nel posto sbagliato e il bordo del pane verrebbe mangiato.
+//
+// Da qui la separazione: qui si producono `(testo-visibile, span tipizzati)`,
+// il colore lo mette il render intersecando gli span con le righe wrappate.
+//
+// PERCHÉ I MARKER VANNO VIA PRIMA DEL WRAP, non dopo. `**foo**` occupa 3
+// colonne rese e 7 grezze. Wrappare sul testo con i marker manderebbe a capo
+// contando 7, cioè ogni riga uscirebbe più corta del budget di 4 colonne per
+// ogni `**` — un a-capo sbagliato, non un difetto estetico. La catena è quindi
+// obbligata:
+//
+//   sanitize(raw)  →  parseMarkdown  →  wrapWithOffsets  →  interseca
+//
+// `sanitize` sta PRIMA (T75 · D1) perché non conserva la lunghezza: timbra col
+// VS16 ogni glifo BMP largo 2 e sostituisce i discordi (`⚠`→`❗️`, `✔`→`✅️`),
+// quindi applicarla dopo sposterebbe gli offset appena calcolati. Applicarla
+// prima è sicuro perché i marker markdown sono ASCII e cadono fuori dal suo
+// insieme di rischio. Nel deck la sanificazione avviene già al confine di
+// caricamento (`loadTaskFileText`), quindi qui il testo arriva timbrato.
+//
+// GLI SPAN SONO PIATTI E DISGIUNTI. Il nesting del markdown (codice dentro un
+// heading, grassetto dentro un bullet) è risolto QUI, non al render: ogni
+// carattere del testo reso appartiene al più a uno span. Il render diventa
+// così una mappa `kind → attributi Ink` senza logica di merge, ed è la stessa
+// proprietà che permette di comporre questi span con quelli della ricerca
+// (`sliceLine` in `text-search.ts`) senza che le due segmentazioni si
+// contendano lo stesso carattere.
+/** Apertura o chiusura di un blocco di codice: almeno tre backtick a inizio
+ *  riga, eventualmente indentati. La info-string dopo i backtick (` ```bash `)
+ *  fa parte del delimitatore e sparisce con lui. */
+const FENCE = /^\s*```/;
+/** `# ` … `###### ` — lo spazio è obbligatorio, o `#tag` diventerebbe un
+ *  titolo. Il livello non si conserva: la resa è la stessa per tutti (D4). */
+const HEADING = /^(#{1,6})\s+(.*)$/;
+/** Voce di elenco: indentazione + marker + almeno uno spazio. Lo spazio
+ *  obbligatorio è ciò che tiene fuori `---` (riga orizzontale) e `**bold**` a
+ *  inizio riga, che altrimenti passerebbero per bullet. Indentazione e spazio
+ *  dopo il marker sono catturati per essere RIMESSI identici: il glifo occupa
+ *  una colonna come il marker che sostituisce, quindi conservare i due lati
+ *  conserva la colonna d'inizio del testo, che è ciò che tiene allineato un
+ *  elenco scritto a mano. */
+const BULLET = /^(\s*)[-*+](\s+)/;
+/** Il glifo del bullet. Concorde (`stringWidth` 1, `termWidth` 1), quindi si
+ *  può inserire DOPO `sanitize` senza violare l'invariante ① di `width.ts`. */
+const BULLET_GLYPH = '•';
+/**
+ * Testo reso e span di stile a partire dal markdown grezzo.
+ *
+ * Due livelli, e l'ordine fra loro non è negoziabile: il blocco decide se
+ * l'inline gira o è sospeso. Dentro un fence `**` e i backtick sono contenuto,
+ * non marcatura — una regex per riga non potrebbe saperlo, perché il fence ha
+ * stato multi-riga.
+ *
+ * Fuori scope per scelta (T75): tabelle — l'inline ci gira sopra come ovunque,
+ * ma le colonne non vengono allineate — corsivo e link.
+ */
+export function parseMarkdown(src) {
+    const out = [];
+    const spans = [];
+    /** Offset del reso a cui inizierà la prossima riga emessa. */
+    let base = 0;
+    let inFence = false;
+    const emit = (text, lineSpans) => {
+        for (const s of lineSpans) {
+            spans.push({ start: base + s.start, end: base + s.end, kind: s.kind });
+        }
+        out.push(text);
+        base += text.length + 1; // +1 = il '\n' che unirà questa riga alla prossima
+    };
+    for (const line of src.split('\n')) {
+        if (FENCE.test(line)) {
+            // D2 — il delimitatore è un marker quanto `**` e `#`, quindi sparisce
+            // come gli altri: il confine del blocco lo porta il colore uniforme.
+            // Conseguenza contabile: due righe in meno per fence nel totale che
+            // alimenta il contatore `righe N-M di T`.
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) {
+            emit(line, line.length > 0 ? [{ start: 0, end: line.length, kind: 'fence' }] : []);
+            continue;
+        }
+        const h = HEADING.exec(line);
+        if (h) {
+            const body = h[2];
+            const r = scanInline(body, 'heading');
+            emit(r.text, r.spans);
+            continue;
+        }
+        const b = BULLET.exec(line);
+        if (b) {
+            const r = scanInline(line.slice(b[0].length), null);
+            const prefix = b[1] + BULLET_GLYPH + b[2];
+            emit(prefix + r.text, r.spans.map((s) => ({ ...s, start: s.start + prefix.length, end: s.end + prefix.length })));
+            continue;
+        }
+        const r = scanInline(line, null);
+        emit(r.text, r.spans);
+    }
+    return { text: out.join('\n'), spans };
+}
+/**
+ * Livello inline: `**grassetto**` e `` `codice` `` su UNA riga.
+ *
+ * `base` è il costrutto che avvolge la riga (`heading`) o `null` per il testo
+ * normale, e serve a due cose: riempire i tratti non marcati con lo stile del
+ * blocco, e assorbire il grassetto quando il blocco è già enfatizzato — un
+ * `**` dentro un titolo non deve spezzarlo in un pezzo cyan e uno bianco.
+ *
+ * **Il perimetro è la riga, e questo è il presidio contro il marker spaiato.**
+ * Un `**` che non si chiude non può mangiare il resto del documento perché la
+ * ricerca del chiudente non esce dalla riga: resta letterale, il testo non si
+ * perde e il documento sotto è intatto.
+ *
+ * Precedenza al codice, come in CommonMark: dentro `` `**x**` `` gli asterischi
+ * sono contenuto. Ne discende l'ordine dei rami qui sotto.
+ */
+function scanInline(src, base) {
+    let text = '';
+    const spans = [];
+    /** Inizio del tratto corrente non ancora coperto da uno span inline. */
+    let plain = 0;
+    let i = 0;
+    const closePlain = () => {
+        if (base && text.length > plain)
+            spans.push({ start: plain, end: text.length, kind: base });
+        plain = text.length;
+    };
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === '`') {
+            // Delimitatore a N backtick: chiude su una sequenza di ESATTAMENTE N.
+            // Serve davvero, non è zelo — la doc di questo progetto cita i backtick
+            // scrivendo `` `code` ``, e un parser a un backtick solo la ridurrebbe a
+            // poltiglia.
+            let n = 0;
+            while (src[i + n] === '`')
+                n++;
+            const close = findFenceRun(src, i + n, n);
+            if (close >= 0) {
+                closePlain();
+                const start = text.length;
+                text += stripPadding(src.slice(i + n, close));
+                if (text.length > start)
+                    spans.push({ start, end: text.length, kind: 'code' });
+                plain = text.length;
+                i = close + n;
+                continue;
+            }
+            // Non si chiude entro la riga: i backtick sono testo.
+            text += src.slice(i, i + n);
+            i += n;
+            continue;
+        }
+        if (ch === '*' && src[i + 1] === '*') {
+            const close = src.indexOf('**', i + 2);
+            if (close >= 0) {
+                closePlain();
+                const start = text.length;
+                // Il contenuto si riparsa: `**testo con `codice`**` è legittimo, e il
+                // codice dentro vince sul grassetto perché è più specifico.
+                const inner = scanInline(src.slice(i + 2, close), base ?? 'bold');
+                text += inner.text;
+                for (const s of inner.spans) {
+                    spans.push({ start: start + s.start, end: start + s.end, kind: s.kind });
+                }
+                plain = text.length;
+                i = close + 2;
+                continue;
+            }
+            text += '**';
+            i += 2;
+            continue;
+        }
+        text += ch;
+        i++;
+    }
+    closePlain();
+    return { text, spans: coalesce(spans) };
+}
+/** Prima sequenza di ESATTAMENTE `n` backtick a partire da `from`; -1 se non
+ *  c'è. Una sequenza più lunga non chiude — è la regola CommonMark, ed è ciò
+ *  che permette a `` `` ` `` `` di contenere un backtick singolo. */
+function findFenceRun(s, from, n) {
+    for (let i = from; i < s.length; i++) {
+        if (s[i] !== '`')
+            continue;
+        let k = 0;
+        while (s[i + k] === '`')
+            k++;
+        if (k === n)
+            return i;
+        i += k - 1;
+    }
+    return -1;
+}
+/** Uno spazio di cortesia in testa e in coda si toglie: serve a scrivere
+ *  `` ` `` senza incollarlo ai delimitatori, non a spaziare il risultato. */
+function stripPadding(s) {
+    if (s.length > 1 && s.startsWith(' ') && s.endsWith(' ') && s.trim().length > 0) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+/** Fonde gli intervalli adiacenti dello stesso kind: il riempimento del tratto
+ *  base ne produce a raffica, e ognuno costerebbe un `<Text>` in più al
+ *  render. */
+function coalesce(spans) {
+    const out = [];
+    for (const s of spans) {
+        const last = out[out.length - 1];
+        if (last && last.kind === s.kind && last.end === s.start)
+            last.end = s.end;
+        else
+            out.push({ ...s });
+    }
+    return out;
+}
+/**
+ * Taglia una riga wrappata nei pezzi da colorare, intersecando gli offset.
+ *
+ * Gemello di `sliceLine` (`text-search.ts`), che fa lo stesso lavoro con un
+ * intervallo booleano invece che tipizzato: la riga è una fetta CONTIGUA del
+ * testo reso, quindi uno span a cavallo dell'a-capo si colora su entrambe le
+ * righe senza nessun caso speciale — entrambe lo intersecano.
+ *
+ * Restituisce sempre la copertura completa della riga, buchi inclusi come
+ * segmenti `kind: null`: chi renderizza concatena e basta, senza dover
+ * ricostruire ciò che è rimasto fuori.
+ */
+export function sliceSpans(line, spans) {
+    const out = [];
+    const { text, start } = line;
+    let pos = 0;
+    for (const s of spans) {
+        if (s.end <= start)
+            continue;
+        if (s.start >= start + text.length)
+            break; // `spans` è ordinato: il resto è oltre
+        const a = Math.max(0, Math.min(text.length, s.start - start));
+        const b = Math.max(0, Math.min(text.length, s.end - start));
+        if (b <= a || a < pos)
+            continue;
+        if (a > pos)
+            out.push({ text: text.slice(pos, a), kind: null });
+        out.push({ text: text.slice(a, b), kind: s.kind });
+        pos = b;
+    }
+    if (pos < text.length)
+        out.push({ text: text.slice(pos), kind: null });
+    return out;
+}

package/package.json

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