@lamemind/loom-deck 0.30.0 → 0.31.0

package/dist/cli.js

@@ -13,7 +13,7 @@ import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions, selectedRow, DEFAULT_OPTIONS, MIN_QUERY, } from './search.js';
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, loadSessionIndex, } from './task-index.js';
-import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, rowLabel, selectedSession, sessionTitle, stripProjectCore, } from './session-list.js';
+import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, rowLabel, selectedSession, sessionTitle, stripProjectCore, unpinLandingId, } from './session-list.js';
 import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
 import { countArchivable, SCAN_INTERVAL_MS } from './archivable.js';
 import { assignListCapacity, detailCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
@@ -1824,8 +1824,16 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             else {
                 const isPinned = pinned.has(selSessionId);
+                // Dove atterra la selezione: sul pin resta sulla sessione (sale in cima
+                // con lei, il caret la segue perché è l'oggetto dell'azione); sull'unpin
+                // resta IN PLACE nel gruppo pinnate — successiva, precedente, o prima
+                // contestuale se il gruppo si svuota. Calcolato PRIMA della riscrittura
+                // del sidecar, quando la riga pinnata esiste ancora.
+                const landing = isPinned ? unpinLandingId(sessionRows, selSessionId) : null;
                 appendPin(cwd, selSessionId, !isPinned);
                 reloadSessions();
+                if (landing)
+                    setSelSessionId(landing);
                 setNote(`${isPinned ? 'unpin' : '📌 pin'} ${selSessionId.slice(0, 8)}`);
             }
         }

package/dist/session-list.js

@@ -197,6 +197,34 @@ export function neighborId(rows, sessionId) {
         return null;
     return selectable[at + 1]?.sessionId ?? selectable[at - 1]?.sessionId ?? null;
 }
+/**
+ * Id su cui atterrare quando la riga pinnata `sessionId` viene SPINNATA: la
+ * pinnata successiva, la precedente se era l'ultima, la prima contestuale se il
+ * gruppo pinnate si svuota. `null` se `sessionId` non è pinnata o non resta
+ * nessuna riga.
+ *
+ * Non è `neighborId` ristretto al gruppo: quello attraversa il separatore,
+ * quindi sull'ULTIMA pinnata atterrerebbe sulla prima contestuale — il caret
+ * scavalcherebbe l'intero gruppo invece di risalire di una riga. Qui il confine
+ * fra i due gruppi è la regola, non un ostacolo.
+ *
+ * L'id va calcolato PRIMA di riscrivere il sidecar: dopo, la riga pinnata non
+ * c'è più e il vicino nel gruppo non è calcolabile. Serve perché una spinnata
+ * non sparisce necessariamente dalla lista — se appartiene al parent
+ * selezionato ricompare fra le contestuali, e la selezione keyed sull'id la
+ * seguirebbe fin laggiù, trascinando il caret.
+ */
+export function unpinLandingId(rows, sessionId) {
+    const pinnedRows = rows.filter((r) => r.kind === 'pinned');
+    const at = pinnedRows.findIndex((r) => r.sessionId === sessionId);
+    if (at < 0)
+        return null;
+    const inGroup = pinnedRows[at + 1]?.sessionId ?? pinnedRows[at - 1]?.sessionId;
+    if (inGroup)
+        return inGroup;
+    const firstContext = rows.find((r) => r.kind === 'context');
+    return firstContext && isSelectable(firstContext) ? firstContext.sessionId : null;
+}
 /** Session della riga selezionata; null se stale o nessuna selezione. */
 export function selectedSession(rows, sessionId) {
     const r = rows.find((row) => isSelectable(row) && row.sessionId === sessionId);

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.0",
+  "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}}"