@lamemind/loom-deck 0.6.0 → 0.8.0

package/dist/cli.js

@@ -10,8 +10,9 @@ import { dirname, join } from 'node:path';
 import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskDetail, } from './tasks.js';
 import { discoverProjectSessions } from './sessions.js';
 import { appendTaskBinding, loadTaskBindings } from './task-index.js';
-import { loadLaunch } from './config.js';
-import { applyView, cycleSort, describeSort, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
+import { loadIdentity, loadLaunch } from './config.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';
 // scripts/deck-run è un sibling della dir del bundle: src/ (dev, tsx) e dist/
 // (build, node) stanno entrambi sotto la package root → risalita di un livello.
@@ -27,6 +28,13 @@ const SPOT = Symbol('spot');
 // Modale sort a grammatica libera: un tasto per chiave, pressioni successive
 // ciclano asc → desc → fuori dalla chain.
 const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id' };
+// T41 — ordine dei valori nel modale edit. Deliberatamente DIVERSO da
+// PRI_ENTRIES/PROG_ENTRIES (che seguono il rango di sort): qui si sceglie un
+// valore, non si ordina, quindi vince l'ordine del CICLO DI VITA — da fare →
+// in corso → chiusa → bloccata. La priorità resta alta→bassa, che è già
+// l'ordine naturale di lettura.
+const EDIT_PRI = ['high', 'med', 'low'];
+const EDIT_PROG = ['todo', 'wip', 'done', 'locked'];
 function isDone(prog) {
     return prog.includes('✔');
 }
@@ -59,6 +67,22 @@ function runLaunch(entry, cwd) {
     child.unref();
     return child;
 }
+// T37 — surface STANDARD LAUNCH `terminal`: built-in e universale (nessuna
+// dichiarazione in `launch[]`), ma di natura launch — fire-once, nessuno stato.
+// Il deck gira già DENTRO una tab Ptyxis → `--tab` mette il terminale accanto a
+// sé nella stessa finestra, invece di sparpagliare finestre.
+// Nessun `-- CMD`: l'azione È aprire la shell (differenza dalle launch custom,
+// che eseguono un comando dentro `bash -lic`).
+// `-T <title>` col core `<owner> <name>` tiene la finestra matchabile da compass
+// anche mentre la tab attiva è il terminale; senza identità nel file config si
+// spawna senza titolo (la surface resta funzionante, il progetto risulta assente
+// dal radar finché quella tab è in primo piano).
+function spawnTerminal(cwd, title) {
+    const args = title ? ['--tab', '-T', title, '-d', cwd] : ['--tab', '-d', cwd];
+    const child = spawn('ptyxis', args, { cwd, detached: true, stdio: 'ignore' });
+    child.unref();
+    return child;
+}
 // Comando claude (override per ambienti dove non è su PATH; loom-deck → NPM).
 const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
 // T30: create-task inline. Spawna CC HEADLESS (`-p`) con `--session-id` pinnato
@@ -109,6 +133,24 @@ function spawnCreateTask(text, cwd, sessionId, onResult) {
     });
     return child;
 }
+// T41 — Commit dell'edit. `git commit -- <paths>` committa lo stato working-tree
+// SOLO di quei path, ignorando l'index: se l'utente ha altro in stage (o altri
+// file sporchi) non finisce dentro per errore. NON detached: è un'operazione
+// veloce e il suo esito va riportato nella nota. stderr raccolto per dire perché
+// ha fallito (identità git assente, hook che rifiuta, …) invece di un generico ⚠.
+function commitTaskEdit(cwd, paths, message, onResult) {
+    const child = spawn('git', ['commit', '-m', message, '--', ...paths], {
+        cwd,
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let err = '';
+    child.stderr?.on('data', (c) => {
+        err += c.toString();
+    });
+    child.on('error', () => onResult(false, 'git non lanciabile'));
+    child.on('close', (code) => onResult(code === 0, err.trim().split('\n')[0] ?? ''));
+    return child;
+}
 // Carica tasks.md e lo ri-legge quando cambia sotto (poll su mtime). Poll
 // (non fs.watch) perché i writer di tasks.md — checkpoint-task/create-task —
 // riscrivono il file (probabile replace atomico), che rompe il watch sull'inode
@@ -255,8 +297,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const [view, setView] = useState(() => loadView(cwd));
     const [viewBackup, setViewBackup] = useState(null);
     const [filterCursor, setFilterCursor] = useState({ row: 0, col: 0 });
+    // T41 — bozza dell'edit (null fuori dal modale) e riga attiva della griglia.
+    const [edit, setEdit] = useState(null);
+    const [editRow, setEditRow] = useState(0);
     // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
     const launch = useMemo(() => loadLaunch(cwd), [cwd]);
+    // Identità (T37): titolo delle tab terminale spawnate col tasto `t`.
+    const identity = useMemo(() => loadIdentity(cwd), [cwd]);
     // La vista è una trasformazione DERIVATA, applicata a valle del load: il
     // polling di tasks.md continua a funzionare senza saperne nulla.
     const { visible: viewTasks, hidden: hiddenTasks } = useMemo(() => applyView(tasks, view), [tasks, view]);
@@ -338,6 +385,53 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         });
         child.on('error', () => setNote(`⚠ create-task: '${CLAUDE_CMD}' non lanciabile`));
     }
+    // T41 — apertura dell'edit: la bozza parte dai valori ATTUALI della task, non
+    // da default. La priorità arriva dal glifo di tasks.md (già in `selTask`), lo
+    // stato dal suo glifo Prog; il progresso arbitrario dal campo `Progress` del
+    // task file — ma solo se è davvero custom (vedi `initialDetail`).
+    function openEdit() {
+        if (!selTask)
+            return;
+        const prog = progName(selTask.prog) ?? 'todo';
+        setEdit({
+            pri: priName(selTask.pri) ?? 'med',
+            prog,
+            detail: initialDetail(detail?.fields['Progress'] ?? '', prog),
+        });
+        setEditRow(0);
+        setNote('');
+        setMode('edit');
+    }
+    // T41 — ⏎ nell'edit: scrive tasks.md + task file, poi committa. Il commit è
+    // immediato e non confermato (scelta esplicita: l'edit è una micro-modifica,
+    // la storia granulare vale più di un batch). Se nessuno dei due lati è stato
+    // scritto non si committa nulla — `paths` vuoto renderebbe `git commit --`
+    // un commit di TUTTO il working tree, che è l'opposto di ciò che vogliamo.
+    function submitEdit() {
+        const task = selTask;
+        const draft = edit;
+        setMode('normal');
+        setEdit(null);
+        if (!task || !draft)
+            return;
+        let res;
+        try {
+            res = writeTaskEdit({ tasksPath, tasksDir, id: task.id, ...draft });
+        }
+        catch (e) {
+            setNote(`⚠ ${task.id}: scrittura fallita (${e.message})`);
+            return;
+        }
+        if (res.paths.length === 0) {
+            setNote(`⚠ ${task.id}: nessun campo aggiornabile (riga o task file assenti)`);
+            return;
+        }
+        const summary = `${PRI_GLYPH[draft.pri]} ${PRI_LABEL[draft.pri]} · ${res.progress}`;
+        setNote(`⏳ ${task.id} → ${summary} · commit…`);
+        commitTaskEdit(cwd, res.paths, `chore(${task.id}): pri ${PRI_LABEL[draft.pri]} · stato ${res.progress}`, (ok, err) => {
+            setNote(ok ? `✔ ${task.id} → ${summary} · committato` : `⚠ ${task.id} salvato, commit fallito: ${err}`);
+        });
+    }
     // Chiusura di un modale di vista: `restore` rimette la fotografia scattata
     // all'apertura (esc = annulla), altrimenti tiene ciò che si è composto (⏎).
     function closeViewModal(restore) {
@@ -428,6 +522,48 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             return;
         }
+        // T41 — modale edit: griglia a 3 righe. Righe 0/1 = scelta a valore singolo
+        // (←→ scorre), riga 2 = testo libero (ogni carattere stampabile entra nel
+        // progresso). Come gli altri modali cattura tutto: `esc` annulla senza
+        // scrivere né uscire dal deck.
+        if (mode === 'edit') {
+            if (key.escape) {
+                setMode('normal');
+                setEdit(null);
+                setNote('E → edit annullato');
+            }
+            else if (key.return) {
+                submitEdit();
+            }
+            else if (key.upArrow) {
+                setEditRow((r) => ((r + 2) % 3));
+            }
+            else if (key.downArrow) {
+                setEditRow((r) => ((r + 1) % 3));
+            }
+            else if (key.leftArrow || key.rightArrow) {
+                const d = key.leftArrow ? -1 : 1;
+                // Scorrimento CICLICO (wrap) e non clampato: le liste sono di 3-4 voci,
+                // arrivare in fondo e ripartire costa meno di invertire direzione.
+                if (editRow === 0) {
+                    setEdit((e) => e ? { ...e, pri: EDIT_PRI[(EDIT_PRI.indexOf(e.pri) + d + EDIT_PRI.length) % EDIT_PRI.length] } : e);
+                }
+                else if (editRow === 1) {
+                    setEdit((e) => e
+                        ? { ...e, prog: EDIT_PROG[(EDIT_PROG.indexOf(e.prog) + d + EDIT_PROG.length) % EDIT_PROG.length] }
+                        : e);
+                }
+            }
+            else if (editRow === 2) {
+                if (key.backspace || key.delete) {
+                    setEdit((e) => (e ? { ...e, detail: e.detail.slice(0, -1) } : e));
+                }
+                else if (input && !key.ctrl && !key.meta) {
+                    setEdit((e) => (e ? { ...e, detail: e.detail + input } : e));
+                }
+            }
+            return;
+        }
         if (key.leftArrow || key.rightArrow || key.tab) {
             setFocus((f) => (f === 'tasks' ? 'sessions' : 'tasks'));
         }
@@ -469,6 +605,13 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setNote('');
             setMode('create');
         }
+        else if (input === 'E') {
+            // L'edit ha senso solo su una task reale: la riga meta "spot" non ne è una.
+            if (isSpot || !selTask)
+                setNote('E → nessuna task selezionata');
+            else
+                openEdit();
+        }
         else if (input === 'S') {
             setViewBackup(view);
             setNote('');
@@ -479,6 +622,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             setNote('');
             setMode('filter');
         }
+        else if (input === 't') {
+            const title = identity ? `🖥️ ${identity.owner} ${identity.name} [term]` : null;
+            const child = spawnTerminal(cwd, title);
+            child.on('error', () => setNote('⚠ t → ptyxis non lanciabile'));
+            setNote(`t → terminale su ${projectName}`);
+        }
         else if (input === 'w') {
             // Salvataggio ESPLICITO: comporre una vista non tocca il disco, così
             // sperimentare non sporca lo stato persistito.
@@ -509,7 +658,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     const parentLabel = isSpot ? 'spot' : selectedTaskId ?? '—';
     const canSpawn = focus === 'tasks' && !isSpot;
     const launchHint = launch.length > 0 ? `1-${Math.min(9, launch.length)} launch · ` : '';
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : '—', " \u00B7 C nuova \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7", ' ', launchHint, "q esci \u00B7 focus: ", _jsx(Text, { color: "cyan", children: focus })] })), mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: viewTasks, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, sessions: visibleSessions, total: childSessions.length, hidden: hiddenSessions, selectedId: selSessionId, focused: focus === 'sessions' })] }), note ? _jsx(Text, { color: "green", children: note }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), mode === 'create' ? (_jsxs(Text, { dimColor: true, children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'sort' ? (_jsxs(Text, { dimColor: true, children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'filter' ? (_jsxs(Text, { dimColor: true, children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, children: ["\u2191\u2193 naviga \u00B7 \u2190\u2192 pane \u00B7 \u23CE ", canSpawn ? 'spawn' : '—', " \u00B7 C nuova \u00B7 E edit \u00B7 S sort \u00B7 F filtri \u00B7 w salva \u00B7 t term \u00B7 ", launchHint, "q esci \u00B7 focus: ", _jsx(Text, { color: "cyan", children: focus })] })), mode === 'create' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "C \u203A " }), _jsx(Text, { children: draft }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'sort' ? _jsx(SortModal, { sort: view.sort }) : null, mode === 'filter' ? _jsx(FilterModal, { view: view, cursor: filterCursor }) : null, mode === 'edit' && edit && selTask ? (_jsx(EditModal, { id: selTask.id, draft: edit, row: editRow })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: viewTasks, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, sessions: visibleSessions, total: childSessions.length, hidden: hiddenSessions, selectedId: selSessionId, focused: focus === 'sessions' })] }), note ? _jsx(Text, { color: "green", children: note }) : null] }));
 }
 const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
 // Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
@@ -531,6 +680,14 @@ function FilterModal({ view, cursor }) {
                         return (_jsxs(Text, { inverse: here, color: on ? 'green' : 'gray', dimColor: !on, children: ['  ', "[", on ? 'x' : ' ', "] ", forceEmojiWidth(e.glyph)] }, e.name));
                     })] }, row.label)))] }));
 }
+// T41 — modale edit, in flusso come gli altri (spinge giù i pane invece di
+// coprirli: la riga che stai modificando resta visibile sopra la lista).
+// La riga di anteprima mostra il testo ESATTO che finirà nel campo `Progress`
+// del task file — così il default (`✔️ Done at <oggi>`) non è una sorpresa.
+function EditModal({ id, draft, row }) {
+    const mark = (r) => (row === r ? '▶ ' : '  ');
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri  " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato" }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', forceEmojiWidth(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(Text, { dimColor: true, children: "prog " }), _jsxs(Text, { children: ['  ', draft.detail] }), row === 2 ? _jsx(Text, { inverse: true, children: " " }) : null, !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { dimColor: true, children: ["\u21B3 ", progressText(draft.prog, draft.detail)] })] }));
+}
 function TasksPane({ tasks, total, hidden, view, selected, spotCount, childCount, focused, loadError, detail, }) {
     const spotSelected = selected === 0;
     return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, children: ["Tasks (", hidden > 0 ? `${tasks.length}/${total}` : tasks.length, ")", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", hidden, " nascoste"] }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort: ", describeSort(view.sort), view.hiddenPri.length + view.hiddenProg.length > 0 ? (_jsxs(Text, { children: [' ', "\u00B7 filtri:", ' ', [

package/dist/config.js

@@ -39,3 +39,20 @@ export function loadLaunch(projectRoot) {
         return [];
     }
 }
+export function parseIdentity(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const { owner, name } = raw;
+    if (typeof owner !== 'string' || !owner || typeof name !== 'string' || !name)
+        return null;
+    return { owner, name };
+}
+/** File assente o malformato → nessuna identità. Mai un throw. */
+export function loadIdentity(projectRoot) {
+    try {
+        return parseIdentity(JSON.parse(readFileSync(configFilePath(projectRoot), 'utf8')));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/task-edit.js

@@ -0,0 +1,160 @@
+// T41 — Edit inline di priorità/stato dal deck.
+// Le funzioni di rewrite sono PURE (stringa → stringa): la scrittura su disco è
+// isolata in `writeTaskEdit`, così la grammatica delle sostituzioni è testabile
+// senza toccare il filesystem.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { findTaskFile } 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).
+export const PRI_LABEL = { high: 'High', med: 'Med', low: 'Low' };
+export const PRI_GLYPH = { high: '🔥', med: '⚡', low: '🔹' };
+// `✔️` CON VS16: è la forma usata nelle righe Done già presenti in tasks.md e nei
+// task file. view.ts normalizza via VS16 in lettura, quindi scrivere la forma
+// lunga resta riconosciuto da priName/progName/isDone.
+export const PROG_GLYPH = {
+    todo: '🔵',
+    wip: '🟡',
+    done: '✔️',
+    locked: '🔒',
+};
+// Testo di default per stato, usato quando l'utente non digita un progresso
+// arbitrario. Il campo `Progress` del task file è testo libero (`🟡 85%`,
+// `🔵 Todo`, `✔️ Done at 2026-07-20`) → il glifo è il prefisso, il resto è prosa.
+const PROG_DEFAULT = {
+    todo: 'Todo',
+    wip: 'In Progress',
+    done: 'Done',
+    locked: 'Locked',
+};
+/** Data locale `YYYY-MM-DD` (non UTC: `toISOString` sposterebbe il giorno la sera). */
+export function today(d = new Date()) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+/**
+ * Riga `Progress` del task file. `detail` è il progresso ARBITRARIO digitato
+ * dall'utente: se c'è vince sempre (anche su done/locked — nessuna forma è
+ * preclusa), se manca si cade sul default dello stato. Solo `done` senza detail
+ * data-stampa, coerente con le righe già presenti (`✔️ Done at YYYY-MM-DD`).
+ */
+export function progressText(prog, detail, date = today()) {
+    const glyph = PROG_GLYPH[prog];
+    const d = detail.trim();
+    if (d)
+        return `${glyph} ${d}`;
+    if (prog === 'done')
+        return `${glyph} Done at ${date}`;
+    return `${glyph} ${PROG_DEFAULT[prog]}`;
+}
+/**
+ * Toglie il glifo di testa da un valore `Progress` (`🟡 85%` → `85%`).
+ * Il glifo lo ri-deriva `progressText` dallo stato selezionato.
+ */
+export function stripProgGlyph(s) {
+    return s.replace(/^[\p{Extended_Pictographic}✔️\s]+/u, '').trim();
+}
+/**
+ * Valore iniziale del campo "progresso arbitrario" all'apertura del modale.
+ *
+ * NON è semplicemente il testo corrente spogliato del glifo: se quel testo è
+ * esattamente ciò che il default già produrrebbe (`🔵 Todo`, `🟡 In Progress`)
+ * non c'è nulla di custom da preservare, e pre-riempirlo lo renderebbe
+ * APPICCICOSO — cambiando stato la scritta vecchia resterebbe attaccata al
+ * glifo nuovo (`🔵 Todo` → wip → `🟡 Todo`). Si parte quindi da vuoto e il
+ * default segue lo stato scelto.
+ *
+ * Un testo che il default NON sa riprodurre è invece informazione dell'utente e
+ * va tenuta: `🟡 85%` → `85%`, e `✔️ Done at 2026-07-14` → `Done at 2026-07-14`
+ * (la data storica sopravvive, non viene ri-stampata a oggi).
+ */
+export function initialDetail(current, prog, date = today()) {
+    const s = current.trim();
+    if (!s || s === progressText(prog, '', date))
+        return '';
+    return stripProgGlyph(s);
+}
+/**
+ * Riscrive le celle Pri (col 2) e Prog (col 4) 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 altre celle (K, descrizione)
+ * 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.
+ *
+ * L'id deve rispettare `^T\d+$`, stesso gate di `parseTasks`: senza, un id
+ * arbitrario matcherebbe la riga di HEADER (`| ID | Pri | K | Prog |`) o quella
+ * di separatore, riscrivendone le celle e sfondando la tabella.
+ */
+const TASK_ID_RE = /^T\d+$/;
+export function updateTasksMdRow(content, id, priGlyph, progGlyph) {
+    if (!TASK_ID_RE.test(id))
+        return { content, ok: false };
+    let ok = false;
+    const lines = content.split('\n').map((line) => {
+        if (ok)
+            return line;
+        if (!line.trim().startsWith('|'))
+            return line;
+        const cells = line.split('|');
+        if ((cells[1] ?? '').trim() !== id)
+            return line;
+        if (cells.length < 6)
+            return line; // riga malformata → non toccarla
+        ok = true;
+        cells[2] = ` ${priGlyph} `;
+        cells[4] = ` ${progGlyph} `;
+        return cells.join('|');
+    });
+    return { content: ok ? lines.join('\n') : content, ok };
+}
+/**
+ * Riscrive i bullet header `- **Priority**:` e `- **Progress**:` del task file.
+ * First-match-wins per chiave, stessa regola di `parseTaskDetail`: se un campo
+ * ricompare nel body (residuo template) vince quello dell'header — così ciò che
+ * il deck mostra e ciò che scrive restano la stessa riga.
+ */
+export function updateTaskFileFields(content, priLabel, progress) {
+    let priDone = false;
+    let progDone = false;
+    const lines = content.split('\n').map((line) => {
+        if (!priDone && /^-\s*\*\*Priority\*\*:/.test(line)) {
+            priDone = true;
+            return `- **Priority**: ${priLabel}`;
+        }
+        if (!progDone && /^-\s*\*\*Progress\*\*:/.test(line)) {
+            progDone = true;
+            return `- **Progress**: ${progress}`;
+        }
+        return line;
+    });
+    const ok = priDone || progDone;
+    return { content: ok ? lines.join('\n') : content, ok };
+}
+/**
+ * Scrive i DUE lati della task: la riga di tasks.md (vista d'insieme) e i campi
+ * del task file (dettaglio). Sono due fonti che devono restare allineate — il
+ * deck legge la prima e mostra la seconda — quindi si toccano insieme.
+ * Un lato mancante (id fuori overview, o nessun task file) non blocca l'altro:
+ * si scrive ciò che esiste e il risultato dice cosa è stato toccato.
+ */
+export function writeTaskEdit(input) {
+    const { tasksPath, tasksDir, id, pri, prog, detail } = input;
+    const progress = progressText(prog, detail);
+    const paths = [];
+    const row = updateTasksMdRow(readFileSync(tasksPath, 'utf8'), id, PRI_GLYPH[pri], PROG_GLYPH[prog]);
+    if (row.ok) {
+        writeFileSync(tasksPath, row.content, 'utf8');
+        paths.push(tasksPath);
+    }
+    let fileUpdated = false;
+    const taskFile = findTaskFile(tasksDir, id);
+    if (taskFile) {
+        const upd = updateTaskFileFields(readFileSync(taskFile, 'utf8'), PRI_LABEL[pri], progress);
+        if (upd.ok) {
+            writeFileSync(taskFile, upd.content, 'utf8');
+            paths.push(taskFile);
+            fileUpdated = true;
+        }
+    }
+    return { paths, rowUpdated: row.ok, fileUpdated, progress };
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.6.0",
+  "version": "0.8.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": {
-    "loom-deck": "./dist/cli.js"
+    "loom-deck": "dist/cli.js"
   },
   "files": [
     "dist",