@lamemind/loom-deck 0.30.1 → 0.31.0

package/dist/task-edit.js

@@ -3,7 +3,7 @@
 // isolata in `writeTaskEdit`, così la grammatica delle sostituzioni è testabile
 // senza toccare il filesystem.
 import { readFileSync, writeFileSync } from 'node:fs';
-import { TASK_ID_RE, findTaskFile } from './tasks.js';
+import { TASK_ID_RE, findTaskFile, headerColumns } from './tasks.js';
 // Il task file scrive la priorità per NOME (`- **Priority**: Med`), tasks.md la
 // scrive come GLIFO (colonna Pri). Due rappresentazioni dello stesso valore →
 // due mappe, entrambe keyed sul nome canonico di view.ts (unica fonte del rango).
@@ -75,31 +75,38 @@ export function initialDetail(current, prog, date = today()) {
     return stripProgGlyph(s);
 }
 /**
- * Riscrive le celle Pri (col 2), Prog (col 4) e — se `desc` è passata — la
- * descrizione (col 5) della riga `| Tnn | … |` in tasks.md. Solo la PRIMA riga
- * con quell'id — l'overview è unica, un secondo match sarebbe un duplicato da
- * non propagare. Le celle non toccate restano i token grezzi originali: nessun
- * re-flow della tabella, il diff resta di una riga. `ok:false` = id assente →
- * il chiamante non scrive nulla.
+ * Riscrive le celle Pri, Prog e — se `desc` è passata — la descrizione della
+ * riga `| Tnn | … |` in tasks.md. Solo la PRIMA riga con quell'id — l'overview
+ * è unica, un secondo match sarebbe un duplicato da non propagare. Le celle non
+ * toccate restano i token grezzi originali: nessun re-flow della tabella, il
+ * diff resta di una riga. `ok:false` = id assente → il chiamante non scrive nulla.
+ *
+ * Le posizioni vengono dall'HEADER (`headerColumns`, stessa fonte di
+ * `parseTasks`), mai da un indice cablato: qui si SCRIVE su disco, quindi una
+ * colonna in più o in meno non produrrebbe una lettura sbagliata ma un titolo
+ * sovrascritto col glifo. Header assente → `ok:false`, non si tira a indovinare.
  *
  * `desc` undefined ≠ `desc` vuota: la prima non tocca la cella (chiamata
  * legacy, solo pri/prog), la seconda la svuota davvero.
  *
  * La descrizione è l'ULTIMA colonna e può contenere `|` — che in una tabella
  * markdown spezza la cella. Riscriverla significa quindi collassare tutte le
- * celle da 5 fino alla penultima in una sola (`splice`), altrimenti i pezzi
- * della vecchia descrizione resterebbero appesi in coda alla nuova.
+ * celle da `cols.desc` fino alla penultima in una sola (`splice`), altrimenti i
+ * pezzi della vecchia descrizione resterebbero appesi in coda alla nuova.
  *
  * L'id deve rispettare `TASK_ID_RE` (importato da tasks.ts — stesso gate di
  * `parseTasks`, non una copia): senza, un id arbitrario matcherebbe la riga di
- * HEADER (`| ID | Pri | K | Prog |`) o quella di separatore, riscrivendone le
- * celle e sfondando la tabella.
+ * separatore, riscrivendone le celle e sfondando la tabella.
  */
 export function updateTasksMdRow(content, id, priGlyph, progGlyph, desc) {
     if (!TASK_ID_RE.test(id))
         return { content, ok: false };
+    const lines = content.split('\n');
+    const cols = lines.reduce((found, l) => found ?? headerColumns(l), null);
+    if (!cols)
+        return { content, ok: false };
     let ok = false;
-    const lines = content.split('\n').map((line) => {
+    const out = lines.map((line) => {
         if (ok)
             return line;
         if (!line.trim().startsWith('|'))
@@ -107,20 +114,21 @@ export function updateTasksMdRow(content, id, priGlyph, progGlyph, desc) {
         const cells = line.split('|');
         if ((cells[1] ?? '').trim() !== id)
             return line;
-        if (cells.length < 6)
+        // Serve la cella desc PIÙ la coda dopo il `|` finale: senza la coda lo
+        // splice inserirebbe invece di sostituire.
+        if (cells.length < cols.desc + 2)
             return line; // riga malformata → non toccarla
         ok = true;
-        cells[2] = ` ${priGlyph} `;
-        cells[4] = ` ${progGlyph} `;
+        cells[cols.pri] = ` ${priGlyph} `;
+        cells[cols.prog] = ` ${progGlyph} `;
         if (desc !== undefined) {
-            // Da cells[5] fino alla penultima: l'ultima è la coda dopo il `|` finale
-            // (stringa vuota su una riga ben formata) e va conservata, o la riga
-            // perderebbe il proprio bordo destro.
-            cells.splice(5, cells.length - 6, ` ${sanitizeCell(desc)} `);
+            // L'ultima cella è la coda dopo il `|` finale (stringa vuota su una riga
+            // ben formata) e va conservata, o la riga perderebbe il bordo destro.
+            cells.splice(cols.desc, cells.length - cols.desc - 1, ` ${sanitizeCell(desc)} `);
         }
         return cells.join('|');
     });
-    return { content: ok ? lines.join('\n') : content, ok };
+    return { content: ok ? out.join('\n') : content, ok };
 }
 /**
  * Rende un testo scrivibile dentro una CELLA di tabella markdown. Due caratteri
@@ -139,11 +147,10 @@ function sanitizeCell(s) {
  * ricompare nel body (residuo template) vince quello dell'header — così ciò che
  * il deck mostra e ciò che scrive restano la stessa riga.
  *
- * L'H1 conserva il proprio CAPPELLO (`# Task: …` code, `# Doc Task: …` doc):
- * `parseTaskDetail` lo strippa in lettura, quindi il titolo che arriva dal
- * modale non ce l'ha e riscrivere la riga nuda perderebbe la categoria. Il
- * prefisso si rilegge dalla riga esistente e si ri-antepone tale e quale — così
- * una T resta `# Task:` e una D resta `# Doc Task:` senza doverlo sapere qui.
+ * L'H1 conserva il proprio CAPPELLO (`# Task: …`): `parseTaskDetail` lo strippa
+ * in lettura, quindi il titolo che arriva dal modale non ce l'ha e riscrivere la
+ * riga nuda lo perderebbe. Si rilegge dalla riga esistente e si ri-antepone tale
+ * e quale, così un file senza cappello resta senza.
  */
 export function updateTaskFileFields(content, priLabel, progress, title) {
     let priDone = false;
@@ -152,7 +159,7 @@ export function updateTaskFileFields(content, priLabel, progress, title) {
     const lines = content.split('\n').map((line) => {
         if (title !== undefined && !titleDone && /^#\s+/.test(line)) {
             titleDone = true;
-            const prefix = line.match(/^#\s+((?:Doc\s+)?Task:\s*)/)?.[1] ?? '';
+            const prefix = line.match(/^#\s+(Task:\s*)/)?.[1] ?? '';
             return `# ${prefix}${title.replace(/\s+/g, ' ').trim()}`;
         }
         if (!priDone && /^-\s*\*\*Priority\*\*:/.test(line)) {

package/dist/tasks.js

@@ -2,12 +2,12 @@ import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { sanitize } from './width.js';
 /**
- * Forma di un ID task: `T` (code) o `D` (doc) + numero. FONTE UNICA del gate —
- * `parseTasks` lo usa per scartare header/separatore della tabella, `task-edit`
- * per non riscrivere per sbaglio quelle stesse righe. Tenerlo in un posto solo
- * evita che i due gate divergano (uno accetterebbe righe che l'altro rifiuta).
+ * Forma di un ID task: `T` + numero. FONTE UNICA del gate — `parseTasks` lo usa
+ * per scartare header/separatore della tabella, `task-edit` per non riscrivere
+ * per sbaglio quelle stesse righe. Tenerlo in un posto solo evita che i due gate
+ * divergano (uno accetterebbe righe che l'altro rifiuta).
  */
-export const TASK_ID_RE = /^[TD]\d+$/;
+export const TASK_ID_RE = /^T\d+$/;
 // D1 (preflight T20): default docs/tasks.md, override della docs-root via env
 // LOOM_DECK_DOCS_ROOT (es. questo progetto usa `runtime`). No auto-detect.
 export function resolveTasksPath(cwd = process.cwd()) {
@@ -19,15 +19,50 @@ export function resolveTasksPath(cwd = process.cwd()) {
 export function resolveTasksDir(cwd = process.cwd()) {
     return join(dirname(resolveTasksPath(cwd)), 'tasks');
 }
-// Estrae le righe `| Tnn | Pri | K | Prog | Task |` della Tasks Overview.
-// Due prefissi ammessi (contratto plugin, counter separati): `T` = code task,
-// `D` = doc task. Le D entrano in lista come le T perché `deck-run` NON inietta
-// `run-task`: il prompt iniziale è un recap diretto ("recap stato task <id>"),
-// valido identico su una doc task. Righe header/separatore non matchano `^[TD]\d+$`
-// → scartate.
+/**
+ * Indici di colonna della Tasks Overview letti dall'HEADER, non cablati.
+ *
+ * Cablarli lega il parser al NUMERO di colonne invece che al loro nome: toglierne
+ * una fa scivolare tutto di uno e il deck legge la cella sbagliata **senza
+ * sollevare un errore** — la descrizione finisce dove si cerca il glifo di
+ * progresso, e `updateTasksMdRow` riscrive quella posizione su disco. È la stessa
+ * trappola già nota sull'indice di RIGA (selezione keyed su id, mai su posizione),
+ * applicata all'indice di colonna.
+ *
+ * Solo `pri` e `prog` si cercano per nome; la descrizione è per costruzione la
+ * colonna successiva a Prog, quindi rinominarla non rompe il parse. `null` = la
+ * riga non è l'header — l'header della tabella Lane (`| Lane | …`) cade qui.
+ */
+export function headerColumns(line) {
+    const t = line.trim();
+    if (!t.startsWith('|'))
+        return null;
+    const cells = t.split('|').map((c) => c.trim().toLowerCase());
+    if (cells[1] !== 'id')
+        return null;
+    const pri = cells.indexOf('pri');
+    const prog = cells.indexOf('prog');
+    if (pri < 0 || prog < 0)
+        return null;
+    return { pri, prog, desc: prog + 1 };
+}
+// Estrae le righe `| Tnn | Pri | Prog | Task |` della Tasks Overview. Righe
+// header/separatore non matchano `^T\d+$` → scartate.
+//
+// Le righe si parsano solo DOPO aver incontrato l'header: senza indici derivati
+// non si tira a indovinare, la lista resta vuota. Un fallimento visibile invece
+// di una cella letta al posto sbagliato.
 export function parseTasks(content) {
     const tasks = [];
+    let cols = null;
     for (const line of content.split('\n')) {
+        const header = headerColumns(line);
+        if (header) {
+            cols = header;
+            continue;
+        }
+        if (!cols)
+            continue;
         const t = line.trim();
         if (!t.startsWith('|'))
             continue;
@@ -36,12 +71,10 @@ export function parseTasks(content) {
         const id = cells[1];
         if (!TASK_ID_RE.test(id))
             continue;
-        // Colonne overview: | ID | Pri | K | Prog | Task | → cells[2]=Pri (icona
-        // priorità), cells[4]=Prog. K (Kind, cells[3]) non serve al deck.
-        const pri = cells[2] ?? '';
-        const prog = cells[4] ?? '';
+        const pri = cells[cols.pri] ?? '';
+        const prog = cells[cols.prog] ?? '';
         // desc = colonna finale; join per resistere a eventuali `|` nella descrizione.
-        const desc = cells.slice(5, -1).join('|').trim();
+        const desc = cells.slice(cols.desc, -1).join('|').trim();
         // Sanificazione AL CONFINE: tutto ciò che entra da tasks.md è testo
         // arbitrario e può contenere glifi che Ink e il terminale misurano in modo
         // diverso (vedi `width.ts`). Farlo qui invece che a ogni sito di render è
@@ -87,10 +120,9 @@ export function parseTaskDetail(id, content) {
     let inDesc = false;
     for (const line of content.split('\n')) {
         if (!title && line.startsWith('# ')) {
-            // I due template scrivono H1 diversi — `# Task: …` (code) e
-            // `# Doc Task: …` (doc): entrambi i cappelli vanno via, il titolo mostrato
-            // è la descrizione, non la sua categoria (già data dall'id).
-            title = line.replace(/^#\s+/, '').replace(/^(?:Doc\s+)?Task:\s*/, '').trim();
+            // Il cappello `Task:` del template va via: il titolo mostrato è la
+            // descrizione, non la categoria (già data dall'id).
+            title = line.replace(/^#\s+/, '').replace(/^Task:\s*/, '').trim();
             continue;
         }
         if (line.startsWith('## ')) {

package/dist/view.js

@@ -53,16 +53,11 @@ export function progRank(glyph) {
     return PROG_TABLE.find((e) => e.glyph === g)?.rank ?? UNKNOWN_RANK;
 }
 // `T10`.localeCompare(`T9`) mette T10 prima: l'ID va confrontato NUMERICO.
-// parseTasks ammette due prefissi con counter SEPARATI (`T` code, `D` doc) →
-// il solo numero non basta, T01 e D01 collidono. Il prefisso pesa quindi come
-// cifra più significativa (T prima di D, blocco doc in coda), il numero come
-// meno significativa: il rango resta un intero singolo, quindi il comparator
-// della chain non cambia forma. Il gap 1e6 è oltre qualunque counter reale.
+// Prefisso unico → il numero è già una chiave totale, e il rango è il numero.
 // Un id fuori forma non deve far esplodere il comparator → coda con MAX_SAFE.
-const ID_PREFIX_RANK = { T: 0, D: 1 };
 export function idNum(id) {
-    const m = /^([TD])(\d+)$/.exec(id);
-    return m ? ID_PREFIX_RANK[m[1]] * 1_000_000 + Number(m[2]) : Number.MAX_SAFE_INTEGER;
+    const m = /^T(\d+)$/.exec(id);
+    return m ? Number(m[1]) : Number.MAX_SAFE_INTEGER;
 }
 function rankOf(task, key) {
     if (key === 'pri')

package/package.json

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

package/scripts/deck-run

@@ -124,7 +124,7 @@ USAGE="uso: deck-run <TaskID> [--prompt-kind <kind>] [--session-id <uuid>]
        none        nessun prompt — sessione aperta sulla task, a mani nude
        recap       recap stato task <TaskID>
        preflight   /loom-works:preflight-task <TaskID>
-       run         /loom-works:run-task <TaskID>  (run-doc sulle task D)
+       run         /loom-works:run-task <TaskID>
        checkpoint  /loom-works:checkpoint-task <TaskID>
 
   --title-note   nota della conversazione, appesa al titolo tab come «nota»
@@ -353,23 +353,15 @@ FORK_FLAG=""
 # possa scavalcare. Il placeholder {TASK} vale solo per il valore dell'override;
 # i template del catalogo interpolano ${TASK} diretto (nel `${VAR:-...}` la `}`
 # di `{TASK}` chiuderebbe in anticipo l'espansione).
-# `run` DISPATCHA sul prefisso: la lista del deck contiene entrambe le famiglie
-# del contratto loom (`T` code, `D` doc) e le due hanno skill di esecuzione
-# diverse — `run-task` è dichiarata code-only, `run-doc` è la sua complementare.
-# Su una D il prompt `run-task` invocherebbe la skill sbagliata. Gli altri kind
-# non discriminano, ma è una verifica da rifare per OGNI kind nuovo, non una
-# proprietà del catalogo: `recap` è un prompt diretto (nessuna skill),
-# `preflight-task` risolve il task file per id, e `checkpoint-task` estrae il
-# taskId con `T\d+|D\d+` — copre quindi entrambi i prefissi da sé.
+# Ogni kind è un template diretto sull'id: la lista del deck è monofamiglia
+# (`T`, unico prefisso del contratto loom), quindi nessun prompt discrimina sulla
+# forma dell'id.
 case "${PROMPT_KIND:-recap}" in
   none)       PROMPT="" ;;
   recap)      PROMPT="recap stato task ${TASK}" ;;
   preflight)  PROMPT="/loom-works:preflight-task ${TASK}" ;;
   checkpoint) PROMPT="/loom-works:checkpoint-task ${TASK}" ;;
-  run)        case "$TASK" in
-                D*) PROMPT="/loom-works:run-doc ${TASK}" ;;
-                *)  PROMPT="/loom-works:run-task ${TASK}" ;;
-              esac ;;
+  run)        PROMPT="/loom-works:run-task ${TASK}" ;;
 esac
 if [[ "${PROMPT_KIND:-}" != "none" && -n "${LOOM_DECK_ENTER_PROMPT:-}" ]]; then
   PROMPT="${LOOM_DECK_ENTER_PROMPT//\{TASK\}/${TASK}}"