@lamemind/loom-deck 0.57.2 → 0.58.0

package/dist/commit-times.js

@@ -0,0 +1,66 @@
+// T136 — data dell'ultimo commit che ha toccato ogni task file, in UNA
+// passata di `git log` invece di uno spawn per file (vedi Description T136).
+//
+// `--format=#%ct` mette un prefisso che nessun path porta: la riga vuota
+// compare anche FRA il timestamp e i path (non solo a fine blocco), quindi non
+// può fare da separatore, e «tutte cifre» sarebbe una regola che un path
+// potrebbe violare. Un merge commit senza `-m` non elenca path e produce un
+// blocco senza righe path: si salta da sé, nessun ramo dedicato serve.
+//
+// git log esce in ordine cronologico DISCENDENTE: il primo hit di un path è
+// già il suo ultimo commit, quindi si tiene solo il primo e si ignorano gli
+// hit successivi dello stesso id.
+import { execFile } from 'node:child_process';
+import { basename } from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const FORMAT_RE = /^#(\d+)$/;
+// Il basename del task file, non il path intero (che cambia con la docs-root)
+// e non `TASK_ID_RE` di tasks.ts (ancorata all'id nudo, non matcha `T136-x.md`).
+const TASK_FILE_RE = /^(T\d+)-.*\.md$/;
+/**
+ * Parsing puro dell'output `git log --format=#%ct --name-only`. Isolato da
+ * `commitTimes` perché è l'unica parte che vale la pena collaudare: invocare
+ * git davvero misurerebbe la storia di QUESTO repo, un valore che si muove a
+ * ogni commit.
+ */
+export function parseCommitLog(output) {
+    const out = new Map();
+    let epoch = null;
+    for (const raw of output.split('\n')) {
+        const line = raw.trim();
+        const m = FORMAT_RE.exec(line);
+        if (m) {
+            epoch = Number(m[1]);
+            continue;
+        }
+        if (!line || epoch === null)
+            continue;
+        const idm = TASK_FILE_RE.exec(basename(line));
+        if (!idm)
+            continue;
+        const id = idm[1];
+        if (!out.has(id))
+            out.set(id, epoch); // primo hit = il più recente
+    }
+    return out;
+}
+/**
+ * `Map<taskId, epoch>` dell'ultimo commit di ogni task file sotto `tasksDir`.
+ *
+ * git muto (repo assente, path fuori dal repo, git non installato) → mappa
+ * vuota, mai un throw, come `archivable.ts`: un dato di ordinamento non può
+ * rompere il deck. Nessun `--since`/`-n`: un cap renderebbe la mappa
+ * incompleta proprio per le task vecchie mai più toccate, quelle che sotto
+ * `desc` finiscono in coda — dove un timestamp assente e uno vecchio si
+ * confonderebbero.
+ */
+export async function commitTimes(tasksDir, projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['log', '--format=#%ct', '--name-only', '--', tasksDir], { cwd: projectRoot });
+        return parseCommitLog(stdout);
+    }
+    catch {
+        return new Map();
+    }
+}

package/dist/deck-model.js

@@ -14,7 +14,7 @@
 // la ragione per cui i loro conti di parametri restano leggibili.
 import { useEffect, useMemo, useState } from 'react';
 import { loadArchivableDays, loadIdentity, loadLaunch } from './config.js';
-import { useArchivable, useDirtyFolders, useInboxScan, useSessions, useTaskDetail, useTasks, } from './hooks.js';
+import { useArchivable, useCommitTimes, useDirtyFolders, useInboxScan, useSessions, useTaskDetail, useTasks, } from './hooks.js';
 import { DEFAULT_INBOX_STALE_HOURS, staleCount } from './inbox.js';
 import { cycleInboxView, inboxCounts as deriveInboxCounts, inboxView, selectInboxRows, } from './inbox-views.js';
 import { docsRootName } from './tasks.js';
@@ -159,9 +159,12 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // includeva l'owner.
     const projectCore = identity ? identity.name : null;
     const projectName = cwd.split('/').pop() || cwd;
+    // T136 — data dell'ultimo commit di ogni task file, per la chiave `commit`
+    // della chain di sort.
+    const commitAt = useCommitTimes(tasksDir, 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]);
+    const { visible: viewTasks, hidden: hiddenTasks } = useMemo(() => applyView(tasks, view, { commitAt }), [tasks, view, commitAt]);
     // 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.
@@ -197,7 +200,9 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         hidden: hiddenTasks,
         archivable: archivable.size,
     };
-    const paneTasks = useMemo(() => taskViewId === 'tasks' ? viewTasks : selectTasks(tasks, taskViewId, { view, archivable }), [taskViewId, viewTasks, tasks, view, archivable]);
+    const paneTasks = useMemo(() => taskViewId === 'tasks'
+        ? viewTasks
+        : selectTasks(tasks, taskViewId, { view, archivable, commitAt }), [taskViewId, viewTasks, tasks, view, archivable, commitAt]);
     const isSpot = sel === SPOT;
     const isAll = sel === ALL;
     // T112 — quando `CANC` pota in BLOCCO invece della sola task selezionata.
@@ -361,6 +366,13 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         const next = rightPane === 'inbox' ? 'sessions' : 'inbox';
         setRightPane(next);
         setFocus((f) => (f === 'tasks' ? f : next));
+        // Montare il pane RIMISURA la coda. Il periodico resta, come rete per il
+        // deck lasciato aperto sul pane inbox, ma non è più l'unico canale: senza
+        // questa chiamata chi apre il pane guarda l'ultima misura, che può essere
+        // vecchia quanto l'intero intervallo. Non serve il verso opposto — tornare
+        // alle sessioni non guarda la coda, e uno scan lì si pagherebbe per nessuno.
+        if (next === 'inbox')
+            inbox.scan();
         setNote(next === 'inbox' ? '^B → pane inbox' : '^B → pane sessioni');
     }
     /** `esc` in vista normale: torna alle sessioni. Solo in quel verso — `esc`

package/dist/hooks.js

@@ -10,6 +10,7 @@ import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { loadSessionIndex } from './task-index.js';
 import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
+import { commitTimes } from './commit-times.js';
 import { scanInbox, INBOX_SCAN_INTERVAL_MS } from './inbox.js';
 import { mixedCount, readWrapCache, runWrapScan, wrapCacheFile, wrapCount, } from './wrap-scan.js';
 import { purgeTargets } from './purge.js';
@@ -67,6 +68,43 @@ export function useTasks(tasksPath) {
     }, [tasksPath]);
     return { tasks, loadError };
 }
+/**
+ * T136 — data dell'ultimo commit di ogni task file, per la chiave di sort
+ * `commit`. D1 (preflight): sullo STESSO poll di `tasks.md` (`POLL_MS`), non
+ * su una scala propria come `useArchivable` — una passata di `git log` costa
+ * ~33ms ed è UNA invocazione per tick, indipendentemente dal numero di task.
+ *
+ * P5 (preflight): `commitTimes` ritorna una `Map` nuova a ogni tick anche
+ * quando il contenuto non cambia; passata nuda a una `useMemo` a valle ne
+ * romperebbe la memoizzazione ogni 1,5s. Si confronta per FIRMA prima di
+ * aggiornare lo stato, come `lastMtime` in `useTasks` e `lastSig` in
+ * `useSessions`: l'identità della mappa cambia solo dopo un commit vero.
+ */
+export function useCommitTimes(tasksDir, projectRoot) {
+    const [commitAt, setCommitAt] = useState(() => new Map());
+    useEffect(() => {
+        let lastSig = '';
+        let alive = true;
+        const reload = () => {
+            commitTimes(tasksDir, projectRoot).then((next) => {
+                if (!alive)
+                    return;
+                const sig = [...next.entries()].map(([id, ts]) => `${id}:${ts}`).sort().join(',');
+                if (sig === lastSig)
+                    return;
+                lastSig = sig;
+                setCommitAt(next);
+            });
+        };
+        reload();
+        const id = setInterval(reload, POLL_MS);
+        return () => {
+            alive = false;
+            clearInterval(id);
+        };
+    }, [tasksDir, projectRoot]);
+    return commitAt;
+}
 // Poll delle sessioni del progetto + binding sidecar. discoverProjectSessions
 // ha cache mtime-keyed interna → il poll è economico; qui si evita comunque il
 // re-render inutile con una signature (sessionId:ts + binding entries): setState
@@ -219,28 +257,53 @@ export function useDirtyFolders(idsSig, tasksDir, projectRoot) {
     return dirty;
 }
 export function useInboxScan(projectRoot, docsRoot) {
-    const [state, setState] = useState({ files: [], ok: true, scanned: false });
+    const [state, setState] = useState({
+        files: [],
+        ok: true,
+        scanned: false,
+    });
+    const [epoch, setEpoch] = useState(0);
+    // Il flag di corsa sta in un ref e non in stato, come in `useWrapScan`: due
+    // aperture ravvicinate del pane girano nello stesso tick di React, e un
+    // valore di stato arriverebbe al render dopo — cioè troppo tardi per
+    // impedire il secondo spawn.
+    const busy = useRef(false);
+    // `alive` vive fuori dall'effect perché `run` sopravvive al suo giro: la
+    // richiesta on-demand è scatenata da un gesto, non dall'effect che la ospita.
+    const alive = useRef(true);
     useEffect(() => {
-        let alive = true;
-        const scan = () => {
-            scanInbox(projectRoot, docsRoot).then((res) => {
-                if (!alive)
-                    return;
-                // Un tentativo fallito NON butta via l'esito dell'ultimo riuscito: la
-                // lista precedente resta vera e ancora apribile, e il guasto si dice
-                // col glifo di allerta accanto ai contatori. È la stessa regola già
-                // scritta per il project status (`finish` non riscrive la cache).
-                setState((prev) => res.ok ? { files: res.files, ok: true, scanned: true } : { ...prev, ok: false, scanned: true });
-            });
-        };
-        scan();
-        const id = setInterval(scan, INBOX_SCAN_INTERVAL_MS);
+        alive.current = true;
         return () => {
-            alive = false;
-            clearInterval(id);
+            alive.current = false;
         };
+    }, []);
+    const run = useCallback(() => {
+        if (busy.current)
+            return;
+        busy.current = true;
+        scanInbox(projectRoot, docsRoot).then((res) => {
+            busy.current = false;
+            if (!alive.current)
+                return;
+            // Un tentativo fallito NON butta via l'esito dell'ultimo riuscito: la
+            // lista precedente resta vera e ancora apribile, e il guasto si dice
+            // col glifo di allerta accanto ai contatori. È la stessa regola già
+            // scritta per il project status (`finish` non riscrive la cache).
+            setState((prev) => res.ok ? { files: res.files, ok: true, scanned: true } : { ...prev, ok: false, scanned: true });
+        });
     }, [projectRoot, docsRoot]);
-    return state;
+    useEffect(() => {
+        run();
+        const id = setInterval(run, INBOX_SCAN_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, [run, epoch]);
+    // Lo scan a richiesta RESETTA il timer, come quello del wrap: senza,
+    // l'intervallo continuerebbe a scorrere dall'ultimo tick automatico e potrebbe
+    // rimisurare pochi istanti dopo un dato appena misurato.
+    const scan = useCallback(() => {
+        setEpoch((e) => e + 1);
+    }, []);
+    return { ...state, scan };
 }
 export function useWrapScan(projectRoot) {
     const path = useMemo(() => wrapCacheFile(projectRoot), [projectRoot]);

package/dist/model.js

@@ -33,7 +33,7 @@ export const ROW_SPOT = 1;
 export const META_ROWS = 2;
 // Modale sort a grammatica libera: un tasto per chiave, pressioni successive
 // ciclano asc → desc → fuori dalla chain.
-export const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id' };
+export const SORT_TASTI = { p: 'pri', s: 'prog', i: 'id', c: 'commit' };
 // T52 — toggle del modale ricerca, tutti su CTRL (D2).
 //
 // I due campi di testo mangiano ogni lettera nuda, quindi un toggle non può

package/dist/pane-views.js

@@ -57,7 +57,7 @@ export const TASK_VIEWS = [
 export function selectTasks(tasks, id, ctx) {
     const entry = taskView(id);
     const picked = tasks.filter((t) => entry.has(t, ctx));
-    picked.sort((a, b) => compareTasks(a, b, ctx.view.sort));
+    picked.sort((a, b) => compareTasks(a, b, ctx.view.sort, ctx));
     return picked;
 }
 /** Glifo della sessione viva, gemello di `LIVE_IDLE` del render. Duplicato qui

package/dist/ui/modals.js

@@ -9,7 +9,7 @@ import { CARET, CARET_OFF, WARN } from '../glyphs.js';
 import { EDIT_PRI, EDIT_PROG } from '../model.js';
 import { PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
 import { progressText, PRI_GLYPH, PRI_LABEL, PROG_GLYPH } from '../task-edit.js';
-export const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
+export const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id', commit: 'commit' };
 // Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
 // spingono giù i pane invece di coprirli, così la lista che stai filtrando
 // resta sempre visibile mentre la componi.

package/dist/ui/screens.js

@@ -71,7 +71,7 @@ export function HintBar({ mode, purge, keyLegend, indicators, columns, }) {
         return (_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"] }));
     }
     if (mode === 'sort') {
-        return (_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"] }));
+        return (_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 ", _jsx(Text, { color: "yellow", children: "c" }), " commit (asc\u2192desc\u2192off) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
     }
     if (mode === 'filter') {
         return (_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"] }));

package/dist/view-store.js

@@ -10,7 +10,7 @@ import { DEFAULT_VIEW, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 export function viewFilePath(projectRoot) {
     return join(projectRoot, '.claude', 'loom', 'deck-view.json');
 }
-const SORT_KEYS = ['pri', 'prog', 'id'];
+const SORT_KEYS = ['pri', 'prog', 'id', 'commit'];
 const PRI_NAMES = PRI_ENTRIES.map((e) => e.name);
 const PROG_NAMES = PROG_ENTRIES.map((e) => e.name);
 // Il file è editabile a mano e sopravvive ai cambi di schema: si tiene solo ciò

package/dist/view.js

@@ -116,11 +116,16 @@ export function taskColumns(tasks, data) {
     }
     return { id: idColumnWidth(tasks), tail: tail > 0 ? tail + 1 : 0 };
 }
-function rankOf(task, key) {
+// La chiave `commit` non ha un glifo: il rango è l'epoch stesso. Assente →
+// UNKNOWN_RANK (0), sempre più basso di un epoch reale → coda sotto `desc`,
+// stessa semantica del glifo non riconosciuto per `pri`/`prog`.
+function rankOf(task, key, ctx) {
     if (key === 'pri')
         return priRank(task.pri);
     if (key === 'prog')
         return progRank(task.prog);
+    if (key === 'commit')
+        return ctx.commitAt.get(task.id) ?? UNKNOWN_RANK;
     return idNum(task.id);
 }
 /**
@@ -129,9 +134,9 @@ function rankOf(task, key) {
  * SEMPRE deterministico (mai instabile fra re-render). Se `id` è già una chiave
  * esplicita della chain il fallback non serve: l'id è unico, la parità è totale.
  */
-export function compareTasks(a, b, sort) {
+export function compareTasks(a, b, sort, ctx) {
     for (const entry of sort) {
-        const diff = rankOf(a, entry.key) - rankOf(b, entry.key);
+        const diff = rankOf(a, entry.key, ctx) - rankOf(b, entry.key, ctx);
         if (diff !== 0)
             return entry.dir === 'asc' ? diff : -diff;
     }
@@ -174,14 +179,14 @@ export function isVisible(task, view) {
     return true;
 }
 /** Filtra poi ordina. Non muta l'input: il polling di tasks.md resta ignaro. */
-export function applyView(tasks, view) {
+export function applyView(tasks, view, ctx) {
     const visible = tasks.filter((t) => isVisible(t, view));
-    visible.sort((a, b) => compareTasks(a, b, view.sort));
+    visible.sort((a, b) => compareTasks(a, b, view.sort, ctx));
     return { visible, hidden: tasks.length - visible.length };
 }
 export const PRI_ENTRIES = PRI_TABLE.map((e) => ({ name: e.name, glyph: e.glyph }));
 export const PROG_ENTRIES = PROG_TABLE.map((e) => ({ name: e.name, glyph: e.glyph }));
-const SORT_LABEL = { pri: 'pri', prog: 'stato', id: 'id' };
+const SORT_LABEL = { pri: 'pri', prog: 'stato', id: 'id', commit: 'commit' };
 /** Riassunto della chain per l'header ("pri↓ id↑"); vuota → "—". */
 export function describeSort(sort) {
     if (sort.length === 0)

package/package.json

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