@lamemind/loom-deck 0.25.0 → 0.27.0

package/dist/archivable.js

@@ -0,0 +1,139 @@
+// T61 — conteggio delle task Done potabili ("archiviabili").
+//
+// Il deck NON pota: mostra solo quante task Done hanno superato la soglia
+// d'età, così la policy di retention — manuale per scelta, nessuna GC
+// automatica — ha almeno un segnale che la renda esercitabile. La potatura
+// resta `loom-works:clean-tasks`, invocata da un umano.
+//
+// D1 (preflight) — la regola d'età è RICALCOLATA qui, non delegata a
+// `cleanup-done-tasks.sh`: il deck è un binario npm globale spawnato da Ptyxis,
+// fuori dal processo Claude Code, quindi non riceve `CLAUDE_PLUGIN_ROOT` e non
+// ha modo di ricavare il path dello script — che vive sotto
+// `~/.claude/plugins/cache/…/<version>/`, version-pinned e riscritto a ogni
+// `plugin update`. La duplicazione della regola fra i due è un costo accettato:
+// è una data meno un'altra. Il prezzo è che le due implementazioni devono
+// concordare sul confine — vedi `ageDays` e `DEFAULT_ARCHIVABLE_DAYS`.
+import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { promisify } from 'node:util';
+import { findTaskFile, parseTaskDetail } from './tasks.js';
+const execFileAsync = promisify(execFile);
+const MS_PER_DAY = 86_400_000;
+/**
+ * D3 (preflight) — metà della policy di purge (`cleanup-done-tasks.sh --days`
+ * ha default 60). Il contatore fa quindi da PREAVVISO, non da predizione: chi
+ * vede `N archiviabili` e lancia `clean-tasks` senza argomenti ne pota zero.
+ * I due numeri sono deliberatamente diversi.
+ */
+export const DEFAULT_ARCHIVABLE_DAYS = 30;
+/** Ogni 6 ore. L'età di una task cambia una volta al giorno: agganciare lo
+ *  scan al poll da 1,5s di `tasks.md` costerebbe N letture di file al secondo
+ *  per un dato che non si muove. Due scale di refresh distinte, stesso processo. */
+export const SCAN_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+/** Un SHA che iniziasse per `-` verrebbe letto da git come flag: qui non passa. */
+const SHA_RE = /^[0-9a-f]{7,40}$/i;
+const DONE_AT_RE = /Done at (\d{4}-\d{2}-\d{2})/;
+/**
+ * Età in giorni interi di una data ISO. `null` se non parsabile.
+ *
+ * D5 (preflight) — allineata a `cleanup-done-tasks.sh`, che fa
+ * `age_days=$(( (NOW_EPOCH - done_epoch) / 86400 ))` e poi `age_days < DAYS →
+ * skip`: divisione intera troncata, confronto `>=`. Due implementazioni della
+ * stessa regola (D1) devono almeno concordare su dove cade il confine.
+ *
+ * Una data NUDA (`2026-07-20`, la forma di `Done at`) si ancora alla mezzanotte
+ * LOCALE, non UTC: è ciò che fa `date -d 2026-07-20` nello script. `Date.parse`
+ * su una data nuda darebbe mezzanotte UTC, cioè fino a mezza giornata di
+ * scarto — abbastanza per spostare di 1 il conteggio proprio sul confine.
+ * I timestamp completi che arrivano da `git --format=%cI` portano l'offset e
+ * passano invece da `Date.parse`.
+ */
+export function ageDays(iso, now) {
+    let t;
+    if (DATE_ONLY_RE.test(iso)) {
+        const [y, m, d] = iso.split('-').map(Number);
+        t = new Date(y, m - 1, d).getTime();
+    }
+    else {
+        t = Date.parse(iso);
+    }
+    if (Number.isNaN(t))
+        return null;
+    return Math.floor((now - t) / MS_PER_DAY);
+}
+/**
+ * Data di chiusura di una task, per cascata a tre gradini + skip finale.
+ * Ordine e semantica IDENTICI a `cleanup-done-tasks.sh` (D2 del preflight):
+ * sul repo reale il solo gradino ① copriva 22 Done su 29, quindi un contatore
+ * fermo al primo gradino avrebbe sottostimato di un quarto senza dirlo.
+ *
+ * Il gradino ③ è un'approssimazione già accettata dallo script: `git log -1`
+ * dà la data dell'ULTIMO commit che tocca il file, non quella di chiusura —
+ * una ri-edit post-done ringiovanisce la task e la fa uscire dal conteggio.
+ * L'errore cade sempre dal lato sicuro (mai una task contata come più vecchia
+ * di quel che è), che è la stessa ragione per cui il gradino ④ è uno skip.
+ */
+async function resolveDoneDate(id, content, taskFile, projectRoot) {
+    // `fields` è first-match-wins come il `grep -m1` dello script: se un task
+    // file ripete `Progress` nel body (residuo di template) vince quello header.
+    const { fields } = parseTaskDetail(id, content);
+    // ① `- **Progress**: ✔️ Done at YYYY-MM-DD` — sorgente deterministica.
+    const doneAt = DONE_AT_RE.exec(fields['Progress'] ?? '');
+    if (doneAt)
+        return doneAt[1];
+    // ② `- **Last tracked commit**: <sha>` → data del commit.
+    // Primo token soltanto: il campo ammette un'annotazione inline dopo il valore.
+    const sha = (fields['Last tracked commit'] ?? '').split(/\s+/)[0];
+    if (SHA_RE.test(sha)) {
+        const d = await gitOut(['show', '-s', '--format=%cI', sha], projectRoot);
+        if (d)
+            return d;
+    }
+    // ③ ultimo commit che tocca il task file. `--` protegge il path da un nome
+    // che somigli a un flag.
+    return gitOut(['log', '-1', '--format=%cI', '--', taskFile], projectRoot);
+}
+/** git muto (repo assente, sha sconosciuto, git non installato) → `null`, mai
+ *  un throw: un contatore informativo non può rompere il deck. */
+async function gitOut(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', args, { cwd });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Quante fra le task Done passate sono oltre soglia. Le indeterminate (nessuno
+ * dei tre gradini risolve) e le righe orfane (Done in tasks.md ma task file
+ * assente) NON entrano nel conteggio: il deck non chiama "vecchia" una task di
+ * cui non sa l'età.
+ *
+ * Riceve gli id già filtrati sul glifo Done invece della lista completa: lo
+ * scan resta così proporzionale al vecchiume, non alla lunghezza della lista.
+ */
+export async function countArchivable(doneIds, opts) {
+    const now = opts.now ?? Date.now();
+    let n = 0;
+    for (const id of doneIds) {
+        const taskFile = findTaskFile(opts.tasksDir, id);
+        if (!taskFile)
+            continue;
+        let content;
+        try {
+            content = readFileSync(taskFile, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const iso = await resolveDoneDate(id, content, taskFile, opts.projectRoot);
+        if (!iso)
+            continue;
+        const age = ageDays(iso, now);
+        if (age !== null && age >= opts.days)
+            n++;
+    }
+    return n;
+}

package/dist/cli.js

@@ -13,7 +13,8 @@ import { discoverProjectSessions } from './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 { cellWidth, launchLegend, loadIdentity, loadLaunch } from './config.js';
+import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
+import { countArchivable, SCAN_INTERVAL_MS } from './archivable.js';
 import { assignListCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
 import { caretWindow, cut, pad, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
@@ -156,8 +157,19 @@ function spawnDeck(id, cwd, sessionId, kind) {
 // task). Spot → `--no-task --resume`: resume nudo, solo label progetto. Nessun
 // prompt iniziale in entrambi i casi: riprendere una conversazione significa
 // continuarla, non iniettarle un messaggio (lo salta deck-run).
-function spawnDeckResume(taskId, cwd, sessionId) {
+//
+// T64 — la NOTA della conversazione (se c'è) viaggia nel titolo della tab. Più
+// sessioni sulla stessa task hanno oggi titoli identici (`label · T81`): la nota
+// è già ciò con cui l'utente le distingue in lista, quindi è anche ciò che
+// distingue le tab. La passa il DECK e non la legge deck-run perché la nota vive
+// nel sidecar `session-tasks.jsonl`, che deck-run non tocca (legge solo
+// `.claude/loom-works.json`): tenerlo così evita di dare al primitive un secondo
+// file da conoscere. Il titolo si congela qui — `claude --name` lo setta una
+// volta sola, quindi una nota cambiata DOPO non ri-titola la tab già aperta.
+function spawnDeckResume(taskId, cwd, sessionId, note) {
     const args = taskId ? [taskId, '--resume', sessionId] : ['--no-task', '--resume', sessionId];
+    if (note)
+        args.push('--title-note', note);
     const child = spawnOut(DECK_RUN, args, { cwd, detached: true, stdio: 'ignore' });
     child.unref();
     return child;
@@ -170,6 +182,10 @@ function spawnDeckResume(taskId, cwd, sessionId) {
 // conoscerlo prima che la sessione esista, e senza conoscerlo non si possono
 // scrivere né il binding task né il record di lineage (il transcript del fork
 // non nomina da nessuna parte la sessione d'origine).
+// Nessun `--title-note` (T64): il ramo nasce con un sessionId proprio e SENZA
+// nota nel sidecar — ereditare quella dell'origine metterebbe nel titolo una
+// maniglia che nella lista non compare, cioè una promessa falsa. Il fork si
+// distingue col suo marcatore, `· fork`.
 function spawnDeckFork(taskId, cwd, originId, newId) {
     const args = [
         ...(taskId ? [taskId] : ['--no-task']),
@@ -406,6 +422,48 @@ function useSessions(projectRoot) {
     }, [projectRoot]);
     return { ...state, reload: () => reloadRef.current() };
 }
+// T61 — conteggio delle Done oltre soglia, su una scala di refresh TUTTA SUA.
+//
+// Non è appeso a POLL_MS (1,5s) come tasks.md e le sessioni: l'età di una task
+// cambia una volta al giorno, e ogni giro costa la lettura di N task file più
+// qualche spawn di git. Due trigger:
+//
+//   · quando cambia l'INSIEME delle task Done (`doneSig`) — copre l'avvio, dove
+//     il primo render ha `tasks` ancora vuoto, e la chiusura di una task, dove
+//     il numero deve muoversi senza aspettare ore;
+//   · ogni SCAN_INTERVAL_MS — copre il caso opposto, in cui non cambia nulla
+//     sul disco ed è il calendario a far scattare una task oltre soglia.
+//
+// `doneSig` è una stringa, non l'array: `tasks` cambia identità a ogni re-read
+// di tasks.md, e usarlo come dipendenza rimetterebbe lo scan sul tick da 1,5s
+// per la via di dietro.
+function useArchivable(doneSig, tasksDir, projectRoot, days) {
+    const [count, setCount] = useState(0);
+    useEffect(() => {
+        let alive = true;
+        const ids = doneSig ? doneSig.split(',') : [];
+        const scan = () => {
+            countArchivable(ids, { tasksDir, projectRoot, days })
+                .then((n) => {
+                if (alive)
+                    setCount(n);
+            })
+                // Scan fallito (task file illeggibili, git muto) → 0, cioè segmento
+                // omesso. Un contatore informativo non merita un errore a schermo.
+                .catch(() => {
+                if (alive)
+                    setCount(0);
+            });
+        };
+        scan();
+        const id = setInterval(scan, SCAN_INTERVAL_MS);
+        return () => {
+            alive = false;
+            clearInterval(id);
+        };
+    }, [doneSig, tasksDir, projectRoot, days]);
+    return count;
+}
 // Legge il task file della task selezionata (Q1+B T20). On-id-change: navigare
 // con ↑↓ ricarica il dettaglio; leggere un singolo file 4-9KB è I/O triviale,
 // niente debounce serve per la tastiera. Il refresh del contenuto a file fermo
@@ -569,6 +627,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // 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]);
+    // T61 — il conteggio guarda la lista GREZZA, non `viewTasks`: le Done fuori
+    // dai filtri della vista restano archiviabili, e un contatore che cambiasse
+    // filtrando direbbe qualcosa sulla vista invece che sulla task list.
+    const doneSig = useMemo(() => tasks.filter((t) => isDone(t.prog)).map((t) => t.id).join(','), [tasks]);
+    const archivableDays = useMemo(() => loadArchivableDays(cwd), [cwd]);
+    const archivable = useArchivable(doneSig, tasksDir, cwd, archivableDays);
     const isSpot = sel === SPOT;
     const isAll = sel === ALL;
     const projectName = cwd.split('/').pop() || cwd;
@@ -967,7 +1031,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         }
         if (row.kind === 'session') {
             const bound = bindings.get(row.session.sessionId) ?? null;
-            const child = spawnDeckResume(bound, cwd, row.session.sessionId);
+            const child = spawnDeckResume(bound, cwd, row.session.sessionId, sessionNotes.get(row.session.sessionId));
             child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
             setNote(`⏎ resume ${row.session.sessionId.slice(0, 8)} → tab CC${bound ? ` (${bound})` : ' (spot)'}`);
             return;
@@ -1417,7 +1481,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                 }
                 else {
                     const bound = bindings.get(s.sessionId) ?? null;
-                    const child = spawnDeckResume(bound, cwd, s.sessionId);
+                    const child = spawnDeckResume(bound, cwd, s.sessionId, sessionNotes.get(s.sessionId));
                     child.on('error', () => setNote(`⚠ resume fallito (${DECK_RUN})`));
                     setNote(`⏎ resume ${s.sessionId.slice(0, 8)} → tab CC${bound ? ` (${bound})` : ' (spot)'}`);
                 }
@@ -1711,7 +1775,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     if (budget.compact) {
         return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", viewTasks.length, " task \u00B7 sel ", selectedTaskId ?? parentLabel, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga"] })] }));
     }
-    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, wrap: "truncate-end", 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, wrap: "truncate-end", 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, wrap: "truncate-end", 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 === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nota conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${legend.shown}` : '', legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, 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 === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _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, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(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, wrap: "truncate-end", 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, wrap: "truncate-end", 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, wrap: "truncate-end", 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 === 'note' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nota conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : mode === 'edit' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend })), mode === 'normal' ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [surfaceLegend, legend.shown ? ` · ${legend.shown}` : '', legend.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", legend.overflow, " fuori riga"] })) : null, legend.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", legend.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, 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 === 'note' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "\u270E \u203A " }), _jsx(Text, { children: noteDraft }), _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, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: windowTasks, filtered: viewTasks.length, total: tasks.length, hidden: hiddenTasks, archivable: archivable, view: view, selected: selIndex, spotCount: spotCount, allCount: sessions.length, childCount: childCount, focused: focus === 'tasks', loadError: loadError, detail: detail, windowStart: taskWin.start, above: taskWin.start, below: viewTasks.length - taskWin.end, detailLines: budget.detailLines, columns: columns }), _jsx(SessionsPane, { parentLabel: parentLabel, isSpot: isSpot, isAll: isAll, bindings: bindings, taskW: sessionCols.task, ageW: sessionCols.age, rows: windowRows, total: assembled.pinnedCount + assembled.contextTotal, pinnedCount: assembled.pinnedCount, hidden: assembled.contextHidden, selectedId: selSessionId ?? undefined, focused: focus === 'sessions', above: sessionWin.start, below: sessionRows.length - sessionWin.end, detail: budget.sessionDetail ? selSessionObj : null, firstLines: budget.sessionFirstLines, lastLines: budget.sessionLastLines, columns: columns, forkOf: forkOf, sessionNotes: sessionNotes, projectCore: projectCore })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(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:
@@ -1949,10 +2013,10 @@ function AssignScreen({ sessionId, label, current, filter, rows, selected, match
                         return (_jsxs(Text, { inverse: sel, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
                     })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
-function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, allCount, childCount, focused, loadError, detail, windowStart, above, below, detailLines, columns, }) {
+function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, allCount, childCount, focused, loadError, detail, windowStart, above, below, detailLines, columns, archivable, }) {
     const allSelected = selected === ROW_ALL;
     const spotSelected = selected === ROW_SPOT;
-    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, wrap: "truncate-end", children: ["Tasks (", hidden > 0 ? `${filtered}/${total}` : filtered, ")", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", hidden, " nascoste"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : 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:", ' ', [
+    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, wrap: "truncate-end", children: ["Tasks (", hidden > 0 ? `${filtered}/${total}` : filtered, ")", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", hidden, " nascoste"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null, archivable > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 ", archivable, " archiviabili"] }) : 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:", ' ', [
                                 ...PRI_ENTRIES.filter((e) => view.hiddenPri.includes(e.name)),
                                 ...PROG_ENTRIES.filter((e) => view.hiddenProg.includes(e.name)),
                             ]

package/dist/config.js

@@ -6,6 +6,7 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { sanitize } from './width.js';
+import { DEFAULT_ARCHIVABLE_DAYS } from './archivable.js';
 export function configFilePath(projectRoot) {
     return join(projectRoot, '.claude', 'loom-works.json');
 }
@@ -99,6 +100,46 @@ export function launchLegend(entries, columns, reserved = 0) {
         taken = fit(10);
     return { shown: taken.join(' · '), overflow: parts.length - taken.length, unreachable };
 }
+// T61 — soglia d'età del contatore archiviabili, campo `archivableDays`.
+//
+// È il PRIMO scalare che il lato TypeScript legge dal file config: `launch` e
+// `identity` sopra sono strutture, e `docsRoot` arriva ancora dalla sola env
+// `LOOM_DECK_DOCS_ROOT` (vedi `tasks.ts`). La catena da percorrere si ferma
+// qui: nessun passaggio da `lib-config.sh`/`reg_pull`/dconf, perché il solo
+// consumer è il deck e il file ce l'ha sotto mano. Il precedente esatto è
+// `permissionMode`, che vive nel file, lo legge `deck-run` via jq e non è
+// propagato al registry.
+/** Interi positivi soltanto: uno 0 spegnerebbe la soglia (tutte le Done
+ *  archiviabili), un negativo o un decimale sono un typo. Valore fuori dominio
+ *  → default, mai passaggio cieco di un numero senza senso al conteggio. */
+export function parseArchivableDays(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const v = raw.archivableDays;
+    if (typeof v !== 'number' || !Number.isInteger(v) || v <= 0)
+        return null;
+    return v;
+}
+/**
+ * Precedenza `env → file → default`, la stessa che `deck-run` applica a
+ * `permissionMode`. L'env esiste per i test e per la verifica manuale (con la
+ * soglia reale il segmento resta invisibile per settimane su un progetto
+ * giovane): la configurazione vera è il campo nel file, che viaggia col repo.
+ */
+export function loadArchivableDays(projectRoot) {
+    const env = Number(process.env.LOOM_DECK_ARCHIVABLE_DAYS);
+    if (Number.isInteger(env) && env > 0)
+        return env;
+    try {
+        const fromFile = parseArchivableDays(JSON.parse(readFileSync(configFilePath(projectRoot), 'utf8')));
+        if (fromFile !== null)
+            return fromFile;
+    }
+    catch {
+        // file assente o malformato → default, come loadLaunch/loadIdentity
+    }
+    return DEFAULT_ARCHIVABLE_DAYS;
+}
 export function parseIdentity(raw) {
     if (!raw || typeof raw !== 'object')
         return null;

package/package.json

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

@@ -49,6 +49,7 @@ SESSION_ID=""
 RESUME_ID=""
 NO_TASK=0
 FORK=0
+TITLE_NOTE=""
 # Vuoto = flag non passato (≠ un default già risolto): serve a distinguere
 # "kind implicito" da "kind chiesto", perché con --no-task il primo è legittimo
 # (nessun prompt, come sempre) e il secondo è un errore d'uso.
@@ -76,8 +77,17 @@ PROMPT_KIND=""
 # dentro apici singoli in `bash -lc`, quindi il testo va tenuto in un posto solo
 # e verificato una volta, invece di spostare il rischio di quoting su ogni
 # chiamante. Assente → `recap`, così ogni invocazione preesistente è invariata.
+# --title-note <testo> (T64): appende la nota della conversazione al titolo della
+# tab. È l'UNICO ingresso di testo libero nel titolo — gli altri componenti
+# (emoji/name dal file committato, TaskID) sono controllati — quindi il testo non
+# si quota, si RIDUCE a un alfabeto sicuro (vedi _sane_note): tutto ciò che non
+# ci rientra sparisce, apici inclusi.
 while [[ $# -gt 0 ]]; do
   case "$1" in
+    --title-note)
+      TITLE_NOTE="${2:-}"; shift 2 ;;
+    --title-note=*)
+      TITLE_NOTE="${1#*=}"; shift ;;
     --prompt-kind)
       PROMPT_KIND="${2:-}"; shift 2 ;;
     --prompt-kind=*)
@@ -112,7 +122,10 @@ 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>  (run-doc sulle task D)
+
+  --title-note   nota della conversazione, appesa al titolo tab come «nota»
+                 (ridotta a lettere/cifre/spazi/-/_, cap 60 char)"
 
 if [[ $NO_TASK -eq 1 && -n "$TASK" ]]; then
   echo "--no-task e <TaskID> sono mutuamente esclusivi" >&2
@@ -167,6 +180,29 @@ WORKDIR="${LOOM_DECK_WORKDIR:-$PWD}"
 # suffisso "· <task>" per restare distinguibili fra più tab claude (il suffisso
 # non rompe il match: è .includes, non equals — stesso pattern del "· deck").
 # Fallback su "cc <task>" se manca il file o jq (progetto non loom-registered).
+
+# Riduzione della nota a un alfabeto sicuro (T64). Whitelist, non blacklist: il
+# titolo finisce dentro apici singoli in `bash -lc "claude --name '…'"`, e la
+# nota è testo digitato a mano — enumerare i caratteri pericolosi significa
+# sbagliarne uno, enumerare quelli ammessi no. Restano lettere, cifre, accentate
+# italiane, spazio, trattino, underscore; tutto il resto (apici, backslash,
+# `$`, backtick, `;`, emoji…) cade.
+# Il cap a 60 CHARACTER è largo di proposito: una tab che sfora tronca a destra
+# da sola, quindi il limite serve solo a non spingere fuori vista la parte del
+# titolo che compass matcha, non a far stare la nota nella tab.
+_sane_note() {  # <raw> → nota ridotta, spazi collassati, cap 60 char
+  # LC_ALL locale alla funzione: serve a bash per tagliare a 60 CARATTERI e non
+  # a 60 byte (a byte, un cap che cade a metà di una `à` lascia UTF-8 rotto nel
+  # titolo). L'assegnazione rifà setlocale, l'uscita dalla funzione lo ripristina.
+  local LC_ALL=C.UTF-8
+  local s
+  s="$(printf '%s' "$1" \
+       | sed 's/[^A-Za-z0-9 _àèéìòùÀÈÉÌÒÙ-]//g' \
+       | tr -s ' ')"
+  s="${s# }"; s="${s% }"
+  printf '%s' "${s:0:60}"
+}
+
 _find_project_root() {  # <start-dir> → dir con .claude/loom-works.json, o vuoto
   local d="${1%/}"
   while [[ -n "$d" && "$d" != "/" ]]; do
@@ -198,6 +234,18 @@ if [[ -n "$_cfg" ]]; then
     if [[ $NO_TASK -eq 1 ]]; then TITLE="${_label}"; else TITLE="${_label} · ${TASK}"; fi
   fi
 fi
+# Suffisso nota (T64): distingue fra loro le tab di più conversazioni sulla
+# STESSA task, che altrimenti condividono un titolo identico (`label · T81`) —
+# la nota è già la maniglia con cui l'utente le distingue in lista, e le stesse
+# `«…»` della lista la rendono riconoscibile a colpo d'occhio anche nella tab
+# bar. In coda per la solita ragione degli altri suffissi: il match compass è
+# `.includes(label)`, la label deve restare intatta in TESTA.
+# Nota ridotta a vuoto (era tutta emoji/punteggiatura) → nessun suffisso, non
+# `«»` a vuoto.
+if [[ -n "$TITLE_NOTE" ]]; then
+  _note="$(_sane_note "$TITLE_NOTE")"
+  [[ -n "$_note" ]] && TITLE="${TITLE} «${_note}»"
+fi
 # Suffisso fork (T28): un ramo eredita task e label dell'origine, quindi senza
 # marcatore le due tab risulterebbero omonime nella stessa window. Suffisso e
 # non prefisso perché il match compass è `.includes(label)` e la label deve