@lamemind/loom-deck 0.61.0 → 0.61.1

package/dist/commit-times.js

@@ -18,6 +18,32 @@ 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$/;
+const EMPTY_MAP = new Map();
+/**
+ * T153 — gate module-level: `git log` gira solo se lo sha di HEAD è cambiato
+ * dall'ultima chiamata su questa stessa coppia (tasksDir, projectRoot). Le
+ * date di ultimo commit cambiano SOLO se HEAD si muove (§Implementation
+ * Notes T153): un rev-parse fallito degrada come degradava il log, mai un
+ * throw. `key` tiene le due coppie separate — un test che passa tmpdir
+ * diversi a chiamate successive non deve leggere la cache dell'altro.
+ */
+let cache = null;
+let logSpawns = 0;
+/** T153/DLV6 — quante volte è partito lo spawn COSTOSO (`git log`), non il
+ *  gate. Il gate (`rev-parse`) gira a ogni chiamata per costruzione: contarlo
+ *  renderebbe il numero inutile a dimostrare il no-op. */
+export function commitLogSpawnCount() {
+    return logSpawns;
+}
+async function headSha(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: projectRoot });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Parsing puro dell'output `git log --format=#%ct --name-only`. Isolato da
  * `commitTimes` perché è l'unica parte che vale la pena collaudare: invocare
@@ -54,13 +80,33 @@ export function parseCommitLog(output) {
  * 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.
+ *
+ * T153 — gate su `rev-parse HEAD` (un ordine di grandezza più economico
+ * dello spawn del log che sostituisce, cifre misurate nel Progress Log): a
+ * sha invariato torna la STESSA istanza di mappa, non una ricostruita — è
+ * ciò che rende inutile il confronto per firma in `useCommitTimes` (P1
+ * preflight).
  */
 export async function commitTimes(tasksDir, projectRoot) {
+    const key = `${projectRoot}\u0000${tasksDir}`;
+    const sha = await headSha(projectRoot);
+    if (sha !== null && cache && cache.key === key && cache.sha === sha) {
+        return cache.map;
+    }
+    let map;
     try {
+        // Il contatore sale PRIMA dell'await: conta gli spawn partiti, e uno
+        // spawn fallito costa comunque la fork del processo.
+        logSpawns++;
         const { stdout } = await execFileAsync('git', ['log', '--format=#%ct', '--name-only', '--', tasksDir], { cwd: projectRoot });
-        return parseCommitLog(stdout);
+        map = parseCommitLog(stdout);
     }
     catch {
-        return new Map();
+        map = EMPTY_MAP;
     }
+    // sha === null (git muto): non si cachea uno stato che il prossimo giro
+    // potrebbe smentire in silenzio (repo che ricompare) senza mai vedersi
+    // ricontrollato.
+    cache = sha !== null ? { key, sha, map } : null;
+    return map;
 }

package/dist/epic-hierarchy.js

@@ -8,7 +8,7 @@
 // parentela si edita anche a mano dentro un task file già in tabella, non solo
 // alla nascita di una riga: un trigger sulla sola firma degli id (come
 // `useArchivable`) lascerebbe quell'edit stale fino al prossimo giro largo.
-import { readdirSync, readFileSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { taskEpicOf, taskIsEpic } from './tasks.js';
 // Stesso pattern di `TASK_FILE_RE` in commit-times.ts: il basename del task
@@ -17,10 +17,23 @@ import { taskEpicOf, taskIsEpic } from './tasks.js';
 const TASK_FILE_RE = /^(T\d+)-.*\.md$/;
 export const EMPTY_EPIC_HIERARCHY = { epicOf: new Map(), epics: new Set() };
 /**
- * Lettura SINCRONA di tutti i task file sotto `tasksDir`: costo misurato in P2,
- * accettabile sul poll da 1,5s. Cartella illeggibile o singolo file non
- * apribile → entry saltata, mai un throw — un dato di rendering non può
- * rompere il deck, stessa regola di `archivableIds`/`commitTimes`.
+ * T153 — gate module-level: il read+parse dei task file gira solo se la mtime
+ * MASSIMA fra i file `T<N>-*.md` di `tasksDir` è cambiata da ultima chiamata
+ * (un ordine di grandezza più economico del parse pieno che sostituisce,
+ * cifre misurate nel Progress Log). Sulla SOLA mtime e non su una firma
+ * degli id: deve intercettare un edit a mano di
+ * `**Parent Task**` DENTRO un file già in tabella, che non aggiunge né toglie
+ * nessun id (Testing Notes T153). A gate scattato torna la STESSA istanza —
+ * `useEpicHierarchy` non ha più bisogno di una firma propria per lo stesso
+ * motivo di `useCommitTimes` (P1 preflight).
+ */
+let cache = null;
+/**
+ * Lettura SINCRONA di tutti i task file sotto `tasksDir`: costo del gate
+ * accettabile sul poll da 1,5s anche a scan pieno (mai il caso in regime).
+ * Cartella illeggibile o singolo file non apribile → entry saltata, mai un
+ * throw — un dato di rendering non può rompere il deck, stessa regola di
+ * `archivableIds`/`commitTimes`.
  */
 export function scanEpicHierarchy(tasksDir) {
     let entries;
@@ -28,15 +41,32 @@ export function scanEpicHierarchy(tasksDir) {
         entries = readdirSync(tasksDir);
     }
     catch {
+        cache = null;
         return EMPTY_EPIC_HIERARCHY;
     }
-    const epicOf = new Map();
-    const epics = new Set();
+    let maxMtime = 0;
+    const files = [];
     for (const file of entries) {
-        const m = TASK_FILE_RE.exec(file);
-        if (!m)
+        if (!TASK_FILE_RE.test(file))
             continue;
-        const id = m[1];
+        let mtime;
+        try {
+            mtime = statSync(join(tasksDir, file)).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        files.push(file);
+        if (mtime > maxMtime)
+            maxMtime = mtime;
+    }
+    if (cache && cache.key === tasksDir && cache.maxMtime === maxMtime) {
+        return cache.hierarchy;
+    }
+    const epicOf = new Map();
+    const epics = new Set();
+    for (const file of files) {
+        const id = TASK_FILE_RE.exec(file)[1];
         let content;
         try {
             content = readFileSync(join(tasksDir, file), 'utf8');
@@ -50,5 +80,7 @@ export function scanEpicHierarchy(tasksDir) {
         if (parent)
             epicOf.set(id, parent);
     }
-    return { epicOf, epics };
+    const hierarchy = { epicOf, epics };
+    cache = { key: tasksDir, maxMtime, hierarchy };
+    return hierarchy;
 }

package/dist/hooks.js

@@ -72,28 +72,26 @@ export function useTasks(tasksPath) {
 /**
  * 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.
+ * su una scala propria come `useArchivable`.
  *
- * 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.
+ * T153 — `commitTimes` gatea da sé su `rev-parse HEAD` (davanti allo spawn
+ * caro del log, vedi `commit-times.ts`) e a sha invariato torna la STESSA
+ * istanza di mappa. L'hook confronta quindi per IDENTITÀ, non più per firma
+ * ricostruita: la firma evitava solo il re-render, il gate a monte evita il
+ * lavoro. `lastMtime` in `useTasks` resta il gemello sullo stesso schema.
  */
 export function useCommitTimes(tasksDir, projectRoot) {
     const [commitAt, setCommitAt] = useState(() => new Map());
     useEffect(() => {
-        let lastSig = '';
+        let last = null;
         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;
+                if (next === last)
+                    return; // stessa istanza → il gate non è scattato
+                last = next;
                 setCommitAt(next);
             });
         };
@@ -108,29 +106,24 @@ export function useCommitTimes(tasksDir, projectRoot) {
 }
 /**
  * T67 — mappa cappello/figlie (`**Parent Task**`, `Size: Epic`), sullo STESSO
- * poll di `tasks.md` e non su una scala propria: P2 (preflight) misura 7,86 ms
- * per il read+parse di 106 task file, meno dei ~33 ms di `git log` che
- * `useCommitTimes` paga già ogni tick. La parentela si edita anche a mano su
- * un task file già in tabella — un trigger sulla sola firma degli id, come
- * `useArchivable`, non vedrebbe quell'edit e lo lascerebbe stale fino al
- * prossimo giro largo.
+ * poll di `tasks.md` e non su una scala propria.
  *
- * Firma prima di `setState`, gemella di `lastSig`/`lastMtime` degli altri
- * poll: senza, la mappa cambia identità a ogni tick e rompe le `useMemo` a
- * valle che la consumano (`applyView`, `selectTasks`).
+ * T153 — `scanEpicHierarchy` gatea da sé sulla mtime massima dei task file
+ * (davanti al read+parse caro, vedi `epic-hierarchy.ts`) e a mtime invariata
+ * torna la STESSA istanza: la parentela editata a mano dentro un file già in
+ * tabella resta vista, perché il gate è sulla mtime e non sugli id. L'hook
+ * confronta quindi per IDENTITÀ, non più per firma ricostruita, gemello di
+ * `useCommitTimes` per lo stesso motivo (P1 preflight).
  */
 export function useEpicHierarchy(tasksDir) {
     const [hierarchy, setHierarchy] = useState(EMPTY_EPIC_HIERARCHY);
     useEffect(() => {
-        let lastSig = '';
+        let last = null;
         const reload = () => {
             const next = scanEpicHierarchy(tasksDir);
-            const sig = [...next.epicOf.entries()].map(([c, p]) => `${c}<${p}`).sort().join(',') +
-                '#' +
-                [...next.epics].sort().join(',');
-            if (sig === lastSig)
-                return;
-            lastSig = sig;
+            if (next === last)
+                return; // stessa istanza → il gate non è scattato
+            last = next;
             setHierarchy(next);
         };
         reload();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.61.0",
+  "version": "0.61.1",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {