@lamemind/loom-deck 0.60.0 → 0.61.1

package/dist/actions.js

@@ -21,7 +21,7 @@ import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, } from '
 import { neighborId } from './session-list.js';
 import { cut, cutMiddle } from './width.js';
 import { saveView, viewFilePath } from './view-store.js';
-import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
+import { onInTabCommand, runLaunch, spawnClaudeEmpty, spawnBare, spawnDeck, spawnDeckFork, spawnDeckResume, spawnTerminal, fallbackTitle, DECK_RUN, MODEL_DEFAULT, } from './spawn.js';
 import { useTaskOps } from './task-ops.js';
 export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNote, }) {
     // La riga di stato di OGNI spawn di sessione Claude: il comando esatto, come
@@ -104,12 +104,19 @@ export function useDeckActions({ cwd, tasksPath, tasksDir, columns, model, setNo
     // il campo è editabile: quello che l'utente legge è quello che parte. Assente
     // per gli acceleratori della lista, che non hanno un campo da cui prenderlo e
     // viaggiano col simbolo.
+    // T150 — il vuoto si riempie QUI, prima che i due canali si separino: il
+    // sidecar (`appendNote`, sotto) e il titolo tab (`--title-note`, dentro
+    // `spawnDeck`) devono vedere lo STESSO valore, o le due superfici mostrano
+    // nomi diversi per la stessa conversazione. Vale anche sugli acceleratori
+    // della lista (^K/^P/^R), che passano di qui con `spawnNote` sul proprio
+    // default '' (P1 preflight) — nascono quindi titolati anche loro.
     function spawnForTask(id, kind, modelKind, spawnNote = '', prompt) {
         const sid = randomUUID();
+        const note = spawnNote || fallbackTitle(tasksDir, id, kind) || '';
         appendTaskBinding(cwd, sid, id);
-        if (spawnNote)
-            appendNote(cwd, sid, spawnNote);
-        const spawned = spawnDeck(id, cwd, sid, kind, modelKind, spawnNote, prompt);
+        if (note)
+            appendNote(cwd, sid, note);
+        const spawned = spawnDeck(id, cwd, sid, kind, modelKind, note, prompt);
         spawned.child.on('error', () => setNote(`⚠ spawn ${id} fallito (${DECK_RUN})`));
         // Il modello resta SEMPRE visibile anche quando è il default, perché è un
         // argomento esplicito del comando (T108): gli acceleratori della lista non

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/dist/session-list.js

@@ -111,9 +111,11 @@ const MIN_NOTE = 14;
 export function rowLabel(text, note, budget) {
     if (!note)
         return { note: '', rest: cut(text, Math.max(0, budget)) };
-    // 2 colonne per i caporali « », 1 per lo spazio prima del residuo.
+    // 1 colonna per lo spazio prima del residuo (T150 — la nota non porta più i
+    // caporali « » che decoravano il render, quindi non riserva più le loro 2
+    // colonne).
     const rest = text;
-    const noteBudget = Math.max(0, budget - 2);
+    const noteBudget = Math.max(0, budget);
     if (!rest)
         return { note: cut(note, noteBudget), rest: '' };
     // Il `min` col budget totale non è ridondante: su un pane strettissimo

package/dist/spawn.js

@@ -3,7 +3,8 @@
 import { spawn } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
+import { findTaskFile } from './tasks.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.
 export const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'deck-run');
@@ -171,6 +172,43 @@ export const DETAIL_ACTIONS = [
 // DISTINTE fra loro. Due label con la stessa lettera renderebbero la seconda
 // irraggiungibile, e in silenzio — chi aggiunge una voce lo controlla qui.
 export const ACTION_HOTKEYS = Object.fromEntries(DETAIL_ACTIONS.map((a, i) => [a.label[0], i]));
+// T150 — titolo di fallback quando il campo nota è vuoto, derivato dall'AZIONE
+// e dal task. Mappa sul KIND, non sulla label (P2 preflight): alla sede del
+// fallback (`spawnForTask` in actions.ts) arriva il kind — già specializzato
+// quando la chiamata viene dal detail (`recap-task`/`recap-epic`) — mai la
+// label del catalogo.
+// D2/P7 — `none` (label "open") non ha una parola: è "nessuna azione", e
+// inventargliene una contraddirebbe l'intenzione dell'utente.
+// P3 — le tre varianti di recap condividono la parola: la specializzazione
+// sceglie quale skill parte, non cosa l'utente sta chiedendo.
+const ACTION_WORD = {
+    preflight: 'PREFL',
+    run: 'RUN',
+    recap: 'RECAP',
+    'recap-task': 'RECAP',
+    'recap-epic': 'RECAP',
+    checkpoint: 'CHKPOINT',
+};
+/**
+ * Titolo di fallback per una conversazione con nota vuota: `{AZIONE} {slug}`,
+ * o il solo slug per `none` (D1/D2 preflight). Lo slug viene dal NOME del
+ * task file (`findTaskFile`), non dalla descrizione di `tasks.md`: il nome è
+ * già dentro l'alfabeto di `_sane_note` per costruzione — minuscolo, separato
+ * da trattini, senza punteggiatura — mentre la descrizione porta apostrofi e
+ * `/` che la riduzione toglie senza sostituto, saldando le parole (D1
+ * razionale).
+ *
+ * `null` quando il task file non si trova: il chiamante decide se ripiegare
+ * su nota vuota o su un altro fallback.
+ */
+export function fallbackTitle(tasksDir, id, kind) {
+    const path = findTaskFile(tasksDir, id);
+    if (!path)
+        return null;
+    const slug = basename(path, '.md').slice(id.length + 1).replace(/-/g, ' ');
+    const word = ACTION_WORD[kind];
+    return word ? `${word} ${slug}` : slug;
+}
 // Spawn detached: il deck spawna ma NON contiene la sessione (la possiede
 // ptyxis-agent). unref + stdio ignore → ritorna subito, la TUI resta viva.
 // sessionId pinnato (T27) → il binding sidecar è deterministico allo spawn.

package/dist/ui/panes.js

@@ -181,8 +181,8 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                             termWidth(`${WARN} pin stale `) +
                             SID_CHARS +
                             (staleTask ? termWidth(staleTask) + 1 : 0) +
-                            3 /* spazio + caporali */));
-                    return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: true, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { color: "yellow", children: WARN }), " pin stale", ' ', _jsx(Text, { dimColor: true, children: row.sessionId.slice(0, SID_CHARS) }), staleTask ? _jsxs(Text, { color: "green", children: [" ", staleTask] }) : null, staleNote ? _jsxs(Text, { color: "yellow", children: [" \u00AB", cut(staleNote, staleW), "\u00BB"] }) : null] }, row.sessionId));
+                            1 /* spazio prima della nota */));
+                    return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: true, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { color: "yellow", children: WARN }), " pin stale", ' ', _jsx(Text, { dimColor: true, children: row.sessionId.slice(0, SID_CHARS) }), staleTask ? _jsxs(Text, { color: "green", children: [" ", staleTask] }) : null, staleNote ? _jsxs(Text, { color: "yellow", children: [" ", cut(staleNote, staleW)] }) : null] }, row.sessionId));
                 }
                 const s = row.session;
                 const isPinnedRow = row.pinned;
@@ -241,9 +241,9 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                 // dicono già (progetto e task id): senza, la cella conterrebbe
                 // `🧵 loom-works · T59` accanto a una colonna che dice `T59`.
                 const label = rowLabel(sessionTitle(s, projectCore, bound), sessionNotes.get(s.sessionId), inner);
-                const used = (label.note ? termWidth(label.note) + 2 : 0) +
+                const used = (label.note ? termWidth(label.note) : 0) +
                     (label.note && label.rest ? 1 : 0) +
                     termWidth(label.rest);
-                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: pad('📌', 2) })) : linked ? (_jsx(Text, { color: "green", children: pad('🔗', 2) })) : (_jsx(Text, { dimColor: true, children: pad('○', 2) })), ' ', _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : undefined, children: liveEntry ? (liveEntry.status === 'busy' ? LIVE_BUSY : LIVE_IDLE) : LIVE_NONE }), _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : 'cyan', bold: Boolean(liveEntry), children: s.sessionId.slice(0, SID_CHARS) }), ' ', _jsx(Text, { dimColor: !s.model, children: pad(modelShort(s.model), MODEL_W) }), ' ', taskW > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: bound && taskCell ? 'green' : undefined, dimColor: !bound, children: pad(taskCell, taskW) }), ' '] })) : null, forkMark ? _jsx(Text, { color: "magenta", children: forkMark }) : null, label.note ? (_jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", label.note, "\u00BB"] })) : null, label.note && label.rest ? ' ' : null, label.rest ? _jsx(Text, { dimColor: Boolean(label.note), children: label.rest }) : null, ' '.repeat(Math.max(0, inner - used)), ' ', _jsx(Text, { dimColor: true, children: pad(age, ageW, 'right') })] }, s.sessionId));
+                return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, isPinnedRow ? (_jsx(Text, { color: "yellow", children: pad('📌', 2) })) : linked ? (_jsx(Text, { color: "green", children: pad('🔗', 2) })) : (_jsx(Text, { dimColor: true, children: pad('○', 2) })), ' ', _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : undefined, children: liveEntry ? (liveEntry.status === 'busy' ? LIVE_BUSY : LIVE_IDLE) : LIVE_NONE }), _jsx(Text, { color: liveEntry ? (liveEntry.status === 'busy' ? 'yellow' : 'green') : 'cyan', bold: Boolean(liveEntry), children: s.sessionId.slice(0, SID_CHARS) }), ' ', _jsx(Text, { dimColor: !s.model, children: pad(modelShort(s.model), MODEL_W) }), ' ', taskW > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: bound && taskCell ? 'green' : undefined, dimColor: !bound, children: pad(taskCell, taskW) }), ' '] })) : null, forkMark ? _jsx(Text, { color: "magenta", children: forkMark }) : null, label.note ? (_jsx(Text, { color: "yellow", bold: true, children: label.note })) : null, label.note && label.rest ? ' ' : null, label.rest ? _jsx(Text, { dimColor: Boolean(label.note), children: label.rest }) : null, ' '.repeat(Math.max(0, inner - used)), ' ', _jsx(Text, { dimColor: true, children: pad(age, ageW, 'right') })] }, s.sessionId));
             }))] }));
 }

package/dist/ui/preview.js

@@ -64,7 +64,7 @@ export function SessionPreview({ s, firstLines, lastLines, columns, origin, note
     // non c'è una provenienza vera da dichiarare.
     const originAlias = modelAlias(s.model);
     const originIndex = originAlias ? MODELS.indexOf(originAlias) : undefined;
-    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', note ? _jsxs(Text, { color: "yellow", children: ["\u00AB", note, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', s.model ? ` · ${s.model}` : '', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : '', live ? (_jsx(Text, { color: live.status === 'busy' ? 'yellow' : 'green', children: ` · ${live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE} viva pid ${live.pid} (${live.status})` })) : null] }), _jsx(ChoiceRow, { label: "modello", values: MODELS, index: Math.max(0, MODELS.indexOf(resumeModel)), focused: false, width: previewTextWidth(columns), originIndex: originIndex }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', note ? _jsxs(Text, { color: "yellow", children: [note, " "] }) : null, _jsx(Text, { dimColor: Boolean(note), children: s.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [fmtSize(s.sizeBytes), " \u00B7 ", s.turns, " turni \u00B7 ", fmtDateTime(s.ts), " \u00B7 ", s.gitBranch || '-', s.model ? ` · ${s.model}` : '', origin ? ` · ⑂ da ${origin.slice(0, 8)}` : '', live ? (_jsx(Text, { color: live.status === 'busy' ? 'yellow' : 'green', children: ` · ${live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE} viva pid ${live.pid} (${live.status})` })) : null] }), _jsx(ChoiceRow, { label: "modello", values: MODELS, index: Math.max(0, MODELS.indexOf(resumeModel)), focused: false, width: previewTextWidth(columns), originIndex: originIndex }), first.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '» ' : '  ', line] }, `f${i}`))), last.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [i === 0 ? '« ' : '  ', line] }, `l${i}`)))] }));
 }
 /**
  * Righe non-wrappabili del dettaglio (titolo + meta + commit) e loro conteggio.

package/dist/ui/search-screen.js

@@ -55,13 +55,14 @@ export function SearchScreen({ preview, hash, query, field, opts, result, rows,
                             const bound = bindings.get(s.sessionId);
                             const rowNote = sessionNotes.get(s.sessionId);
                             const noteShown = rowNote ? cut(rowNote, 24) : '';
-                            // `+3` = i due caporali e lo spazio che li separa dall'etichetta.
-                            // Il pavimento non è cosmetico: senza, un terminale stretto manda
-                            // l'argomento di `cut` sotto zero, cioè un budget negativo.
-                            // La nota si misura con `termWidth`, non con `.length`: contiene
-                            // testo umano, emoji compresi.
-                            const restWidth = Math.max(8, searchTitleWidth(columns) - (noteShown ? termWidth(noteShown) + 3 : 0));
-                            return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, pinned.has(s.sessionId) ? _jsx(Text, { color: "yellow", children: "\uD83D\uDCCC" }) : _jsx(Text, { dimColor: true, children: "\u25CB" }), ' ', _jsx(Text, { color: "cyan", children: s.sessionId.slice(0, 8) }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), bound ?? _jsx(Text, { dimColor: true, children: "spot" }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), noteShown ? _jsxs(Text, { color: "yellow", bold: true, children: ["\u00AB", noteShown, "\u00BB "] }) : null, _jsx(Text, { dimColor: Boolean(noteShown), children: cut(conversationLabel(s, projectCore, bound), restWidth) }), _jsxs(Text, { dimColor: true, children: ['  ', "(", row.hitCount, row.hidden > 0 ? `+${row.hidden}` : '', ") ", fmtDateTime(s.ts)] })] }, row.key));
+                            // `+1` = lo spazio che separa la nota dall'etichetta (T150 — niente
+                            // più caporali « » a decorarla). Il pavimento non è cosmetico:
+                            // senza, un terminale stretto manda l'argomento di `cut` sotto
+                            // zero, cioè un budget negativo. La nota si misura con
+                            // `termWidth`, non con `.length`: contiene testo umano, emoji
+                            // compresi.
+                            const restWidth = Math.max(8, searchTitleWidth(columns) - (noteShown ? termWidth(noteShown) + 1 : 0));
+                            return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, pinned.has(s.sessionId) ? _jsx(Text, { color: "yellow", children: "\uD83D\uDCCC" }) : _jsx(Text, { dimColor: true, children: "\u25CB" }), ' ', _jsx(Text, { color: "cyan", children: s.sessionId.slice(0, 8) }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), bound ?? _jsx(Text, { dimColor: true, children: "spot" }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), noteShown ? _jsxs(Text, { color: "yellow", bold: true, children: [noteShown, " "] }) : null, _jsx(Text, { dimColor: Boolean(noteShown), children: cut(conversationLabel(s, projectCore, bound), restWidth) }), _jsxs(Text, { dimColor: true, children: ['  ', "(", row.hitCount, row.hidden > 0 ? `+${row.hidden}` : '', ") ", fmtDateTime(s.ts)] })] }, row.key));
                         }
                         const h = row.hit;
                         return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsx(Text, { dimColor: true, children: String(h.idx).padStart(4) }), ' ', _jsx(Text, { color: KIND_COLOR[h.kind], children: KIND_TAG[h.kind] }), ' ', cut(h.excerpt, searchExcerptWidth(columns))] }, row.key));

package/package.json

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

package/scripts/deck-run

@@ -183,7 +183,7 @@ USAGE="uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--sessio
   --model        modello della sessione: fable|opus|sonnet|haiku (default: opus)
                  valore ignoto → fallback sul default, con avviso su stderr
 
-  --title-note   nota della conversazione, appesa al titolo tab come «nota»
+  --title-note   nota della conversazione, appesa al titolo tab
                  (ridotta a lettere/cifre/spazi/-/_, cap 60 char)"
 
 if [[ $NO_TASK -eq 1 && -n "$TASK" ]]; then
@@ -317,15 +317,16 @@ if [[ -n "$_cfg" ]]; then
 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.
+# la nota è già la maniglia con cui l'utente le distingue in lista. In coda per
+# la solita ragione degli altri suffissi: il match compass è `.includes(label)`,
+# la label deve restare intatta in TESTA.
+# T150 — nudo, senza i caporali `«…»` che lo decoravano: la nota di fallback
+# generata dal deck quando il campo è vuoto passa dallo stesso alfabeto ridotto
+# e non ha bisogno di una cornice per distinguersi da un titolo scritto a mano.
+# Nota ridotta a vuoto (era tutta emoji/punteggiatura) → nessun suffisso.
 if [[ -n "$TITLE_NOTE" ]]; then
   _note="$(_sane_note "$TITLE_NOTE")"
-  [[ -n "$_note" ]] && TITLE="${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