@lamemind/loom-deck 0.59.0 → 0.61.0

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/cli.js

@@ -245,7 +245,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
                     purgeBulk: model.purgeBulk,
                     inboxPane: model.rightPane === 'inbox',
                     hasInbox: model.selInbox !== null,
-                }), indicators: indicators, columns: columns }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData }), model.rightPane === 'inbox' ? (_jsx(InboxPane, { files: frame.windowInbox, counts: model.inboxCounts, activeView: model.inboxViewId, paneCount: model.inboxFiles.length, selectedPath: model.selInboxPath, focused: model.focus === 'inbox', above: frame.inboxWin.start, below: model.inboxFiles.length - frame.inboxWin.end, columns: columns, ok: model.inboxOk, scanned: model.inboxScanned })) : (_jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live }))] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'inbox' && model.selInbox ? (_jsx(PreviewPane, { kind: "inbox", file: model.selInbox, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null, resumeModel: model.resumeModel })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+                }), indicators: indicators, columns: columns }), frame.launchLine ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [launch.segments.map((s) => s.text).join(LAUNCH_SEP), launch.overflow > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 +", launch.overflow, " fuori riga"] })) : null, launch.unreachable > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 ", launch.unreachable, " oltre la 9\u00AA (non raggiungibili)"] })) : null] })) : null, mode === 'create' ? _jsx(TextBox, { glyph: "C", value: textModals.draft }) : null, mode === 'note' ? _jsx(TextBox, { glyph: "\u270E", value: textModals.noteDraft }) : null, mode === 'sort' ? _jsx(SortModal, { sort: model.view.sort }) : null, mode === 'filter' ? (_jsx(FilterModal, { view: model.view, cursor: viewModals.filterCursor })) : null, mode === 'edit' && textModals.edit && textModals.editTask ? (_jsx(EditModal, { id: textModals.editTask.id, draft: textModals.edit, row: textModals.editCursor.row, caret: textModals.editCursor.caret, columns: columns })) : null, mode === 'purge' && purge.draft ? (_jsx(PurgeModal, { draft: purge.draft, columns: columns })) : null, _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(TasksPane, { tasks: frame.windowTasks, counts: model.taskCounts, activeView: model.taskViewId, paneCount: model.paneTasks.length, view: model.view, selected: model.selIndex, spotCount: model.spotCount, allCount: model.sessions.length, idW: model.taskCols.id, tailW: model.taskCols.tail, focused: model.focus === 'tasks', loadError: model.loadError, windowStart: frame.taskWin.start, above: frame.taskWin.start, below: model.paneTasks.length - frame.taskWin.end, columns: columns, data: model.taskRowData, blockMark: model.blockMark }), model.rightPane === 'inbox' ? (_jsx(InboxPane, { files: frame.windowInbox, counts: model.inboxCounts, activeView: model.inboxViewId, paneCount: model.inboxFiles.length, selectedPath: model.selInboxPath, focused: model.focus === 'inbox', above: frame.inboxWin.start, below: model.inboxFiles.length - frame.inboxWin.end, columns: columns, ok: model.inboxOk, scanned: model.inboxScanned })) : (_jsx(SessionsPane, { parentLabel: model.parentLabel, isSpot: model.isSpot, isAll: model.isAll, bindings: model.bindings, taskW: model.sessionCols.task, ageW: model.sessionCols.age, rows: frame.windowRows, counts: model.sessionCounts, activeView: model.sessionViewId, paneCount: model.sessionRows.length, selectedId: model.selSessionId ?? undefined, focused: model.focus === 'sessions', above: frame.sessionWin.start, below: model.sessionRows.length - frame.sessionWin.end, columns: columns, forkOf: model.forkOf, sessionNotes: model.sessionNotes, projectCore: model.projectCore, live: model.live }))] }), frame.budget.preview && previewKind === 'task' && model.detail ? (_jsx(PreviewPane, { kind: "task", detail: model.detail, maxLines: frame.budget.detailLines, columns: columns })) : frame.budget.preview && previewKind === 'inbox' && model.selInbox ? (_jsx(PreviewPane, { kind: "inbox", file: model.selInbox, columns: columns })) : frame.budget.preview && previewKind === 'session' && model.selSessionObj ? (_jsx(PreviewPane, { kind: "session", s: model.selSessionObj, firstLines: frame.budget.sessionFirstLines, lastLines: frame.budget.sessionLastLines, columns: columns, origin: model.forkOf.get(model.selSessionObj.sessionId) ?? null, note: model.sessionNotes.get(model.selSessionObj.sessionId) ?? '', live: model.live.get(model.selSessionObj.sessionId) ?? null, resumeModel: model.resumeModel })) : null, note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
 const cwd = process.cwd();
 // T116 — `exitOnCtrlC: false` toglie a Ink l'uscita immediata su `^C`: senza,

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, useCommitTimes, useDirtyFolders, useInboxScan, useSessions, useTaskDetail, useTasks, } from './hooks.js';
+import { useArchivable, useCommitTimes, useDirtyFolders, useEpicHierarchy, 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';
@@ -23,7 +23,7 @@ import { TASK_EMPTY, modelAlias, relTime } from './glyphs.js';
 import { assembleSessionList, firstSelectableId, rowIndexOf, selectedSession, } from './session-list.js';
 import { cycleSessionView, cycleTaskView, selectSessionRows, selectTasks, sessionView, taskView, } from './pane-views.js';
 import { ALL, MAX_SESSIONS, MAX_SESSIONS_ALL, META_ROWS, ROW_ALL, ROW_SPOT, SPOT, } from './model.js';
-import { applyView, taskColumns } from './view.js';
+import { applyView, epicRollup, taskColumns } from './view.js';
 import { loadView } from './view-store.js';
 import { termWidth } from './width.js';
 import { MODELS, MODEL_DEFAULT } from './spawn.js';
@@ -169,9 +169,21 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // T136 — data dell'ultimo commit di ogni task file, per la chiave `commit`
     // della chain di sort.
     const commitAt = useCommitTimes(tasksDir, cwd);
+    // T67 — cappello/figlie (`**Parent Task**`, `Size: Epic`) per il grouping
+    // gerarchico del Tasks pane, sullo stesso poll di `commitAt`.
+    const epicHierarchy = useEpicHierarchy(tasksDir);
+    // T67/P9 — rollup {chiuse/totali} di ogni cappello: sulla lista GREZZA come
+    // `doneSig` più sotto, cieco a filtri e viste — altrimenti il numero
+    // cambierebbe filtrando senza che nessuna figlia sia davvero comparsa o
+    // sparita.
+    const epicRollupMap = useMemo(() => epicRollup(tasks, epicHierarchy.epicOf), [tasks, epicHierarchy]);
     // 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, { commitAt }), [tasks, view, commitAt]);
+    const { visible: viewTasks, hidden: hiddenTasks, blockMark: viewBlockMark, } = useMemo(() => applyView(tasks, view, {
+        commitAt,
+        epicOf: epicHierarchy.epicOf,
+        epics: epicHierarchy.epics,
+    }), [tasks, view, commitAt, epicHierarchy]);
     // 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.
@@ -207,9 +219,22 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         hidden: hiddenTasks,
         archivable: archivable.size,
     };
-    const paneTasks = useMemo(() => taskViewId === 'tasks'
-        ? viewTasks
-        : selectTasks(tasks, taskViewId, { view, archivable, commitAt }), [taskViewId, viewTasks, tasks, view, archivable, commitAt]);
+    // T67 — la vista `tasks` riusa `viewTasks`/`viewBlockMark` già calcolati
+    // sopra (nessun ricalcolo sul cammino di default); le altre due passano da
+    // `selectTasks`, che raggruppa con lo STESSO livello gerarchico (un sito
+    // solo per il sort, come già per la sola chain prima di T67).
+    const { paneTasks, paneBlockMark } = useMemo(() => {
+        if (taskViewId === 'tasks')
+            return { paneTasks: viewTasks, paneBlockMark: viewBlockMark };
+        const selected = selectTasks(tasks, taskViewId, {
+            view,
+            archivable,
+            commitAt,
+            epicOf: epicHierarchy.epicOf,
+            epics: epicHierarchy.epics,
+        });
+        return { paneTasks: selected.tasks, paneBlockMark: selected.blockMark };
+    }, [taskViewId, viewTasks, viewBlockMark, tasks, view, archivable, commitAt, epicHierarchy]);
     const isSpot = sel === SPOT;
     const isAll = sel === ALL;
     // T112 — quando `CANC` pota in BLOCCO invece della sola task selezionata.
@@ -235,7 +260,13 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
     // alla vista che sceglie l'header (D2 create).
     const parentLabel = isAll ? 'tutte' : isSpot ? 'spot' : selectedTaskId ?? '—';
     const { childCount, taskLive, spotCount } = rollupChildren(sessions, bindings, live);
-    const taskRowData = { childCount, live: taskLive, dirty: dirtyFolders };
+    const taskRowData = {
+        childCount,
+        live: taskLive,
+        dirty: dirtyFolders,
+        epics: epicHierarchy.epics,
+        epicRollup: epicRollupMap,
+    };
     // T118 — colonne fisse della lista task, misurate su `paneTasks` (la vista
     // attiva INTERA) e non sulla finestra visibile: gemelle di `sessionCols` e
     // per la stessa ragione, che una larghezza derivata dallo schermo si muove a
@@ -444,6 +475,7 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, setNote, }) {
         hiddenTasks,
         taskCounts,
         paneTasks,
+        blockMark: paneBlockMark,
         isSpot,
         isAll,
         purgeBulk,

package/dist/epic-hierarchy.js

@@ -0,0 +1,54 @@
+// T67 — mappa cappello/figlie per il grouping del Tasks pane, letta con UNA
+// passata sui task file sotto `tasksDir`, gemella di `commitTimes` ma dal
+// filesystem invece che da `git log`.
+//
+// P2 (preflight): sullo STESSO poll di `tasks.md` (`POLL_MS`), non su una scala
+// propria come `useArchivable` — read+parse di 106 task file costa 7,86 ms,
+// meno dei ~33 ms di `git log` che `useCommitTimes` paga già ogni tick. La
+// 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 { join } from 'node:path';
+import { taskEpicOf, taskIsEpic } from './tasks.js';
+// Stesso pattern di `TASK_FILE_RE` in commit-times.ts: il basename del task
+// file, non `TASK_ID_RE` di tasks.ts (ancorata all'id nudo, non matcha
+// `T142-nome.md`).
+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`.
+ */
+export function scanEpicHierarchy(tasksDir) {
+    let entries;
+    try {
+        entries = readdirSync(tasksDir);
+    }
+    catch {
+        return EMPTY_EPIC_HIERARCHY;
+    }
+    const epicOf = new Map();
+    const epics = new Set();
+    for (const file of entries) {
+        const m = TASK_FILE_RE.exec(file);
+        if (!m)
+            continue;
+        const id = m[1];
+        let content;
+        try {
+            content = readFileSync(join(tasksDir, file), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (taskIsEpic(id, content))
+            epics.add(id);
+        const parent = taskEpicOf(id, content);
+        if (parent)
+            epicOf.set(id, parent);
+    }
+    return { epicOf, epics };
+}

package/dist/glyphs.js

@@ -116,8 +116,13 @@ export const INBOX_MARK_W = 2;
 // `isDone()` e le lookup di `view.ts` ci confrontano sopra, e `task-edit` lo
 // riscrive sul file: è una chiave semantica, non testo. Qui `sanitize` lo
 // traduce nel suo gemello concorde (`✅`) solo per finire nel frame.
-export function displayProg(prog) {
-    return sanitize(prog);
+//
+// T67/D4 — `blank` spegne la cella su un'epica: il glifo di stato descrive il
+// cappello, che non si esegue, non le task che ne realizzano il piano. Due
+// spazi e non stringa vuota, o la colonna successiva slitterebbe di 2 sulle
+// sole righe cappello.
+export function displayProg(prog, blank = false) {
+    return blank ? '  ' : sanitize(prog);
 }
 /**
  * T118 — coda della riga task: marker dirty e contatore di conversazioni, nella
@@ -153,6 +158,42 @@ export function taskTail(live, total, dirty) {
         return count;
     return count ? `${WARN} ${count}` : WARN;
 }
+/**
+ * T67/P9 — coda della riga CAPPELLO: rollup delle figlie dichiarate, cieco a
+ * filtri e viste (come `total` di `taskTail` sopra) — cieco anche a quale
+ * cappello sta guardando la selezione, perché conta TUTTE le figlie dichiarate
+ * ovunque nel progetto, non solo quelle nella vista corrente.
+ *
+ * Graffa e non tonda, per non confondersi col contatore conversazioni che
+ * questa cella SOSTITUISCE sul cappello (D2 preflight). Nessuna chiusa, come
+ * `taskTail`: la colonna è ancorata a destra, il bordo del pane chiude già il
+ * gruppo. Un cappello senza figlie (`total === 0`) rende coda VUOTA — non
+ * `{0/0}`, che scriverebbe uno zero rumoroso su ogni epica ancora senza figlie
+ * (P9).
+ */
+export function epicTail(rollup) {
+    if (!rollup || rollup.total === 0)
+        return '';
+    return `{${rollup.closed}/${rollup.total}`;
+}
+/**
+ * T67/D3 — spina di blocco: connette visivamente cappello e figlie nel Tasks
+ * pane. Tratti di box (`┌ │ └`), non nell'alfabeto concorde dichiarato in testa
+ * al file ma verificati concordi a sé (`agrees()` vale per tutti e tre) —
+ * `sanitize` qui è quindi un no-op, applicato per la stessa disciplina delle
+ * altre costanti di questo file: nessun sito di render scrive un glifo nudo.
+ */
+const BLOCK_GLYPH = {
+    '┌': sanitize('┌ '),
+    '│': sanitize('│ '),
+    '└': sanitize('└ '),
+};
+/** Cella della spina per una riga: vuota per una task normale, che NON
+ *  riserva le 2 colonne (D3 — la lista ha due punti di partenza della
+ *  descrizione, uno per le righe di blocco e uno per le altre). */
+export function blockCell(mark) {
+    return mark ? BLOCK_GLYPH[mark] : '';
+}
 /** T124 — contatore di una riga META del pane task (`≡ tutte`, `○ spot`), che
  *  non è una colonna ancorata a niente. Prende comunque la grafia senza chiusa:
  *  due forme dello stesso oggetto a due righe di distanza si leggono come un

package/dist/hooks.js

@@ -11,6 +11,7 @@ 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 { scanEpicHierarchy, EMPTY_EPIC_HIERARCHY } from './epic-hierarchy.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';
@@ -105,6 +106,39 @@ export function useCommitTimes(tasksDir, projectRoot) {
     }, [tasksDir, projectRoot]);
     return commitAt;
 }
+/**
+ * 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.
+ *
+ * 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`).
+ */
+export function useEpicHierarchy(tasksDir) {
+    const [hierarchy, setHierarchy] = useState(EMPTY_EPIC_HIERARCHY);
+    useEffect(() => {
+        let lastSig = '';
+        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;
+            setHierarchy(next);
+        };
+        reload();
+        const id = setInterval(reload, POLL_MS);
+        return () => clearInterval(id);
+    }, [tasksDir]);
+    return hierarchy;
+}
 // 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

package/dist/pane-views.js

@@ -20,7 +20,7 @@
 //    navigando, e il catalogo tornerebbe dinamico per la via di dietro.
 //  - `↑N`/`↓N` non stanno qui: contano elementi fuori finestra per altezza del
 //    terminale, cioè una POSIZIONE, non un insieme.
-import { isVisible, compareTasks } from './view.js';
+import { isVisible, groupHierarchy } from './view.js';
 export const TASK_VIEWS = [
     {
         id: 'tasks',
@@ -49,16 +49,20 @@ export const TASK_VIEWS = [
     },
 ];
 /**
- * Le task della vista `id`, filtrate col predicato e ordinate con la chain
- * corrente. L'ordinamento vale per ogni vista, non solo la principale: una lista
- * di task ordinata in un modo e l'altra in un altro sarebbe un secondo asse che
- * si muove da solo.
+ * Le task della vista `id`, filtrate col predicato e raggruppate con la STESSA
+ * chain e lo stesso livello gerarchico di `applyView` (`groupHierarchy`): un
+ * sito solo per il sort, o una vista raggrupperebbe e l'altra no (T67). Vale
+ * per ogni vista, non solo la principale — una lista ordinata in un modo e
+ * l'altra in un altro sarebbe un secondo asse che si muove da solo.
  */
 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, ctx));
-    return picked;
+    return groupHierarchy(picked, ctx.view.sort, {
+        commitAt: ctx.commitAt,
+        epicOf: ctx.epicOf,
+        epics: ctx.epics,
+    });
 }
 /** Glifo della sessione viva, gemello di `LIVE_IDLE` del render. Duplicato qui
  *  perché il catalogo è puro e non può importare da `ui/`; è un carattere

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/tasks.js

@@ -190,6 +190,26 @@ export function taskIsEpic(id, text) {
         return false;
     return (parseTaskDetail(id, text).fields['Size'] ?? '').trim().toLowerCase() === 'epic';
 }
+/** Primo token `T\d+` dentro `**Parent Task**` — stessa tolleranza di
+ *  `lw_task_children` nel plugin, che ammette una maniglia dopo l'id
+ *  (`T142 (epica sistema documentale)`) e la ignora. */
+const PARENT_TOKEN_RE = /T\d+/;
+/**
+ * Il cappello dichiarato dalla FIGLIA via `**Parent Task**`, o `null` se il
+ * campo è assente/vuoto — il caso comune del template, dove significa «nessun
+ * cappello» e non un errore di lettura.
+ *
+ * Riusa `parseTaskDetail` come `taskIsEpic`: una grammatica sola per i bullet
+ * header. La validità del cappello (esiste ancora? è nella vista? non è un
+ * ciclo?) non è compito di questa funzione — la giudica il grouping, che ha la
+ * lista intera sotto gli occhi e questa non ce l'ha.
+ */
+export function taskEpicOf(id, text) {
+    if (!text)
+        return null;
+    const field = parseTaskDetail(id, text).fields['Parent Task'] ?? '';
+    return PARENT_TOKEN_RE.exec(field)?.[0] ?? null;
+}
 /**
  * Testo INTEGRALE del task file (T66 · detail).
  *

package/dist/ui/panes.js

@@ -45,7 +45,7 @@ export function TasksHeader({ counts, active, above, below, focused, columns, })
 function HeaderLine({ parts, shown, focused, }) {
     return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: parts.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, inverse: seg.active, children: shown[i] }, i)) : null) }));
 }
-export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, idW, tailW, focused, loadError, windowStart, above, below, columns, data, }) {
+export function TasksPane({ tasks, counts, activeView, paneCount, view, selected, spotCount, allCount, idW, tailW, focused, loadError, windowStart, above, below, columns, data, blockMark, }) {
     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: [_jsx(TasksHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
@@ -66,7 +66,7 @@ export function TasksPane({ tasks, counts, activeView, paneCount, view, selected
                 // windowStart riporta l'indice di finestra a quello della lista
                 // completa, su cui è keyata la selezione. +META_ROWS: le prime due
                 // righe sono le meta.
-                sel: windowStart + i + META_ROWS === selected, focused: focused, width: paneTextWidth(columns), idW: idW, tailW: tailW, data: data }, task.id))))] }));
+                sel: windowStart + i + META_ROWS === selected, focused: focused, width: paneTextWidth(columns), idW: idW, tailW: tailW, data: data, blockMark: blockMark }, task.id))))] }));
 }
 /**
  * Header del pane sessioni, tagliato QUI e non da Ink.
@@ -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/dist/ui/task-row.js

@@ -15,9 +15,9 @@ import { jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from 'ink';
 import { cut, pad, sanitize, termWidth } from '../width.js';
 import { isDone } from '../layout.js';
-import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, displayProg, taskTail, } from '../glyphs.js';
+import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, blockCell, displayProg, epicTail, taskTail, } from '../glyphs.js';
 import { padId } from '../view.js';
-export function TaskRow({ task, sel, focused, width, idW, tailW, data, }) {
+export function TaskRow({ task, sel, focused, width, idW, tailW, data, blockMark, }) {
     // T124 — il predicato è UNO e si valuta qui una volta sola: da lui dipendono
     // tutte e tre le evidenze (id in grassetto+colore, glifo, numeratore in coda).
     // Tre condizioni scritte in tre siti divergono alla prima modifica, e la riga
@@ -32,7 +32,13 @@ export function TaskRow({ task, sel, focused, width, idW, tailW, data, }) {
     // spazi verso Pri, quindi la riga non si allarga di una cella quando si
     // accende — `LIVE_NONE` è uno spazio, e tutti e tre sono larghi 1.
     const glyph = live ? (live.status === 'busy' ? LIVE_BUSY : LIVE_IDLE) : LIVE_NONE;
-    const tail = taskTail(live?.count ?? 0, data.childCount.get(task.id) ?? 0, data.dirty.has(task.id));
+    // T67/D4 — su un cappello la cella di stato descrive il cappello (non
+    // eseguibile) e non le figlie, quindi resta vuota; D2/P9 — la coda diventa il
+    // rollup delle figlie invece del contatore conversazioni.
+    const isEpic = data.epics.has(task.id);
+    const tail = isEpic
+        ? epicTail(data.epicRollup.get(task.id))
+        : taskTail(live?.count ?? 0, data.childCount.get(task.id) ?? 0, data.dirty.has(task.id));
     const id = padId(task.id, idW);
     // Invariante ③: la descrizione è l'unico pezzo a lunghezza libera, e si taglia
     // QUI sul budget che resta dopo le colonne fisse. Lasciarlo fare a
@@ -40,7 +46,7 @@ export function TaskRow({ task, sel, focused, width, idW, tailW, data, }) {
     // più larga del pane (una colonna per emoji) e quindi scrive sopra il bordo.
     // Le parti fisse si misurano con `termWidth`: i due glifi Pri/Prog valgono 2
     // ciascuno.
-    const head = `${CARET_OFF}${id}${glyph} ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
+    const head = `${CARET_OFF}${id}${glyph} ${sanitize(task.pri)}  ${displayProg(task.prog, isEpic)}  `;
     // T118 — la colonna della coda si riserva PRIMA di tagliare la descrizione, e
     // per la stessa larghezza su ogni riga: appesa dopo, entrava nel budget solo
     // dove c'era qualcosa da scrivere, e la descrizione si tagliava a una colonna
@@ -49,10 +55,17 @@ export function TaskRow({ task, sel, focused, width, idW, tailW, data, }) {
     // Pavimento `0` su tutte e tre le misure e non un minimo di cortesia: il
     // budget è un TETTO. Un pavimento sopra lo spazio reale fa uscire la riga dal
     // pane e le mangia il bordo. `reserve` si clampa su ciò che avanza, così
-    // `head + desc + coda` sta sempre dentro la sede.
+    // `head + spina + desc + coda` sta sempre dentro la sede.
     const avail = Math.max(0, width - termWidth(head));
     const reserve = Math.min(tailW, avail);
-    const descW = avail - reserve;
+    // T67/D3 — spina di blocco DAVANTI alla descrizione, non prima dell'id: `id`
+    // resta l'ancora di `padId`, e una task normale non riserva le 2 colonne (la
+    // cella è assente, non vuota — vedi `blockCell`). Un glifo atomico: su un
+    // pane troppo stretto per ospitarlo intero cade del tutto, non a metà — la
+    // stessa disciplina di `reserve` applicata a una cella che non si può tagliare.
+    const spinaFull = blockCell(blockMark?.get(task.id));
+    const spina = termWidth(spinaFull) <= avail - reserve ? spinaFull : '';
+    const descW = Math.max(0, avail - reserve - termWidth(spina));
     const desc = cut(task.desc, descW);
-    return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsxs(Text, { bold: Boolean(live), color: color, children: [id, glyph] }), ` ${sanitize(task.pri)}  ${displayProg(task.prog)}  ${desc}`, ' '.repeat(Math.max(0, descW - termWidth(desc))), pad(tail, reserve, 'right')] }));
+    return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, _jsxs(Text, { bold: Boolean(live), color: color, children: [id, glyph] }), ` ${sanitize(task.pri)}  ${displayProg(task.prog, isEpic)}  ${spina}${desc}`, ' '.repeat(Math.max(0, descW - termWidth(desc))), pad(tail, reserve, 'right')] }));
 }

package/dist/view.js

@@ -1,6 +1,6 @@
 // T39 — Core della vista: ordinali, sort chain multi-chiave, filtri.
 // Modulo PURO: nessun import da ink/react, nessun I/O → testabile senza terminale.
-import { taskTail } from './glyphs.js';
+import { epicTail, taskTail } from './glyphs.js';
 import { termWidth } from './width.js';
 // D2 (preflight T39): sort opinato, filtri off. La lista parte ordinata ma
 // completa — nessuna task sparisce senza che l'utente abbia toccato una leva.
@@ -112,7 +112,14 @@ export function padId(id, cols) {
 export function taskColumns(tasks, data) {
     let tail = 0;
     for (const t of tasks) {
-        tail = Math.max(tail, termWidth(taskTail(data.live.get(t.id)?.count ?? 0, data.childCount.get(t.id) ?? 0, data.dirty.has(t.id))));
+        // T67 — un cappello scrive il rollup ({chiuse/totali}) al posto del
+        // contatore conversazioni: due formattazioni diverse, quindi la colonna
+        // deve misurare quella che la riga disegna DAVVERO per quel task, non
+        // sempre `taskTail`.
+        const cell = data.epics.has(t.id)
+            ? epicTail(data.epicRollup.get(t.id))
+            : taskTail(data.live.get(t.id)?.count ?? 0, data.childCount.get(t.id) ?? 0, data.dirty.has(t.id));
+        tail = Math.max(tail, termWidth(cell));
     }
     return { id: idColumnWidth(tasks), tail: tail > 0 ? tail + 1 : 0 };
 }
@@ -178,11 +185,119 @@ export function isVisible(task, view) {
         return false;
     return true;
 }
-/** Filtra poi ordina. Non muta l'input: il polling di tasks.md resta ignaro. */
+/**
+ * Cappello → id normalizzati a un albero valido: entrate scartate quando il
+ * cappello non è NELLA LISTA passata (P6 — capo-blocco, non sparizione), punta
+ * a se stesso, o chiude un ciclo.
+ *
+ * Rilevamento ciclo sul grafo ORIGINALE (mai su una versione già potata): per
+ * ogni id si cammina la catena fino a `raw.size` passi. Se la catena rivede
+ * l'id di PARTENZA, quell'id è membro di un ciclo e perde il proprio arco — chi
+ * punta a lui da fuori il ciclo mantiene invece il proprio, e finisce agganciato
+ * a un capo-blocco valido (l'ex membro del ciclo, ora orfano). Implementation
+ * Notes: «i membri del ciclo diventano capi-blocco, nessuno sparisce».
+ */
+function resolveParents(tasks, epicOf) {
+    const byId = new Set(tasks.map((t) => t.id));
+    const raw = new Map();
+    for (const t of tasks) {
+        const p = epicOf.get(t.id);
+        if (p && p !== t.id && byId.has(p))
+            raw.set(t.id, p);
+    }
+    const cyclic = new Set();
+    for (const id of raw.keys()) {
+        let cur = raw.get(id);
+        let steps = 0;
+        while (cur !== undefined && steps <= raw.size) {
+            if (cur === id) {
+                cyclic.add(id);
+                break;
+            }
+            cur = raw.get(cur);
+            steps++;
+        }
+    }
+    const parentOf = new Map();
+    for (const [id, p] of raw)
+        if (!cyclic.has(id))
+            parentOf.set(id, p);
+    return parentOf;
+}
+/**
+ * Riordina `tasks` in blocchi cappello+figlie e li appiattisce in un unico
+ * array: i capi-blocco (cappelli + task senza cappello valido, P6) si ordinano
+ * fra loro con `sort`, poi le figlie di ognuno si ordinano fra loro con lo
+ * STESSO `sort` e si appiattiscono in preordine sotto la propria mamma —
+ * ricorsivo, non un livello solo (P7), così un'epica annidata porta le proprie
+ * figlie subito sotto di sé.
+ *
+ * `blockMark` marca SOLO le righe che fanno parte di un blocco: `┌` sul
+ * cappello (un capo-blocco con almeno una figlia in lista), `│`/`└` sulle
+ * figlie (`└` sull'ultima dell'INTERO sottoalbero, non della sola lista
+ * immediata — un'epica annidata non chiude il blocco, ci sono ancora le sue
+ * figlie sotto). Una task normale non compare nella mappa: niente cella (D3).
+ */
+export function groupHierarchy(tasks, sort, ctx) {
+    const parentOf = resolveParents(tasks, ctx.epicOf);
+    const childrenOf = new Map();
+    for (const t of tasks) {
+        const p = parentOf.get(t.id);
+        if (!p)
+            continue;
+        if (!childrenOf.has(p))
+            childrenOf.set(p, []);
+        childrenOf.get(p).push(t);
+    }
+    const roots = tasks.filter((t) => !parentOf.has(t.id));
+    roots.sort((a, b) => compareTasks(a, b, sort, ctx));
+    function flatten(task) {
+        const kids = [...(childrenOf.get(task.id) ?? [])].sort((a, b) => compareTasks(a, b, sort, ctx));
+        const sub = [task];
+        for (const kid of kids)
+            sub.push(...flatten(kid));
+        return sub;
+    }
+    const order = [];
+    const blockMark = new Map();
+    for (const root of roots) {
+        const block = flatten(root);
+        if (block.length > 1)
+            blockMark.set(root.id, '┌');
+        for (let i = 1; i < block.length; i++) {
+            blockMark.set(block[i].id, i === block.length - 1 ? '└' : '│');
+        }
+        order.push(...block);
+    }
+    return { tasks: order, blockMark };
+}
+/**
+ * Rollup {chiuse/totali} delle figlie DICHIARATE di ogni cappello — cieco a
+ * filtri e viste (P9): conta su TUTTE le task passate, non sulla vista
+ * corrente, o il numero cambierebbe filtrando senza che nessuna figlia sia
+ * davvero comparsa o sparita.
+ */
+export function epicRollup(tasks, epicOf) {
+    const parentOf = resolveParents(tasks, epicOf);
+    const rollup = new Map();
+    for (const t of tasks) {
+        const p = parentOf.get(t.id);
+        if (!p)
+            continue;
+        const entry = rollup.get(p) ?? { closed: 0, total: 0 };
+        entry.total++;
+        if (progName(t.prog) === 'done')
+            entry.closed++;
+        rollup.set(p, entry);
+    }
+    return rollup;
+}
+/** Filtra, ordina, raggruppa in blocchi. Non muta l'input: il polling di
+ *  tasks.md resta ignaro. */
 export function applyView(tasks, view, ctx) {
-    const visible = tasks.filter((t) => isVisible(t, view));
-    visible.sort((a, b) => compareTasks(a, b, view.sort, ctx));
-    return { visible, hidden: tasks.length - visible.length };
+    const filtered = tasks.filter((t) => isVisible(t, view));
+    const { tasks: visible, blockMark } = groupHierarchy(filtered, view.sort, ctx);
+    return { visible, hidden: tasks.length - filtered.length, blockMark };
 }
 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 }));

package/package.json

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

@@ -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