@lamemind/loom-deck 0.54.1 → 0.55.0

package/dist/cli.js

@@ -6,7 +6,7 @@ import { randomUUID } from 'node:crypto';
 import { resolveTasksPath, resolveTasksDir, loadTasks, loadTaskFileText, } from './tasks.js';
 import { rowIndexOfKey, selectedRow, } from './search.js';
 import { appendNote, appendPin, appendSessionRecord, appendTaskBinding, } from './task-index.js';
-import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, selectedSession, unpinLandingId, } from './session-list.js';
+import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowIndexOf, selectedSession, } from './session-list.js';
 import { cellWidth, launchLegend, LAUNCH_SEP, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
 import { anchorFrame, enableMouse, FRAME_TEXT_COL, hitRegion, inlineRegions, isWheel, LAUNCH_ROW, listHit, PANE_TEXT_PAD, paneSpans, rowRegions, takeMouse, WHEEL_LINES, wheelDir, } from './mouse.js';
 import { headerItems, sessionHeaderParts, taskHeaderParts } from './pane-header.js';
@@ -251,9 +251,9 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             const bound = bindings.get(s.sessionId);
             return selectedTaskId ? bound === selectedTaskId : !bound;
         }), [sessions, bindings, selectedTaskId, isAll]);
-    // T50 — lista a due gruppi: pinnate (sempre, in cima) + separatore +
-    // contestuali. Dedup, cap solo sulle contestuali, righe stale per le pinnate
-    // orfane. Core PURO in session-list.ts (testabile senza Ink).
+    // T133 — lista unica: le figlie del parent, `ts desc`, cap su tutte. Le
+    // pinnate del progetto escono a parte (`pinnedRows`), per la sola vista `📌`.
+    // Core PURO in session-list.ts (testabile senza Ink).
     const assembled = useMemo(() => assembleSessionList(childSessions, sessions, pinned, isAll ? MAX_SESSIONS_ALL : MAX_SESSIONS), [childSessions, sessions, pinned, isAll]);
     // T62 — contato sulla lista INTERA (stessa ragione delle larghezze di colonna
     // qui sotto): derivarlo dalla finestra visibile lo farebbe cambiare a ogni
@@ -261,16 +261,14 @@ function Deck({ cwd, tasksPath, tasksDir }) {
     // T100 — «intera» ora vuol dire la lista della vista di DEFAULT (`assembled`),
     // non quella a schermo: il contatore di una voce del catalogo non può
     // dipendere da quale voce è selezionata, o navigare muoverebbe i numeri.
-    const liveCount = useMemo(() => assembled.rows.filter((r) => r.kind !== 'separator' && live.has(r.sessionId)).length, [assembled, live]);
+    const liveCount = useMemo(() => assembled.rows.filter((r) => live.has(r.sessionId)).length, [assembled, live]);
     const sessionCounts = {
-        total: assembled.pinnedCount + assembled.contextTotal,
+        total: assembled.contextTotal,
         live: liveCount,
-        pinned: assembled.pinnedCount,
-        older: assembled.contextHidden,
+        pinned: assembled.pinnedRows.length,
+        older: assembled.overflowRows.length,
     };
-    // T100 — le righe a schermo sono quelle della vista attiva. Fuori dalla vista
-    // di default il separatore non c'è: segna il confine fra pinnate e
-    // contestuali, e in un sottoinsieme quel confine non esiste più.
+    // T100 — le righe a schermo sono quelle della vista attiva.
     const sessionRows = useMemo(() => selectSessionRows(sessionViewId, { assembled, isLive: (id) => live.has(id) }), [sessionViewId, assembled, live]);
     const selSessionObj = selectedSession(sessionRows, selSessionId);
     // T60 — larghezze delle colonne fisse della lista sessioni, misurate sulla
@@ -282,18 +280,15 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         let task = 0;
         let age = 2;
         for (const r of sessionRows) {
-            if (r.kind === 'separator')
-                continue;
-            // La colonna serve dove l'appartenenza NON è già scritta altrove sullo
-            // schermo: nella vista "tutte" (ogni riga ha un binding proprio) e su
-            // OGNI riga pinnata, in qualunque vista — una pinnata è sganciata dal
-            // parent selezionato, quindi l'header del pane non parla per lei.
-            if (isAll || r.kind === 'pinned') {
+            // T133 D10 — la colonna serve dove l'appartenenza NON è già scritta
+            // altrove sullo schermo, cioè nella sola vista "tutte": ogni altra lista
+            // contiene le figlie del parent selezionato, che l'header nomina.
+            if (isAll) {
                 const b = bindings.get(r.sessionId);
                 if (b)
                     task = Math.max(task, termWidth(b));
             }
-            if (r.session)
+            if (r.kind === 'session')
                 age = Math.max(age, termWidth(relTime(r.session.ts)));
         }
         // La cella vuota deve poter entrare nella colonna, o le righe spot
@@ -1122,7 +1117,7 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         }
         else {
             const row = windowRows[hit.index];
-            if (!row || row.kind === 'separator')
+            if (!row)
                 return;
             if (focus === 'sessions' && row.sessionId === selSessionId) {
                 onKey('', { ...NO_MODIFIERS, return: true });
@@ -1337,12 +1332,12 @@ function Deck({ cwd, tasksPath, tasksDir }) {
             }
             else {
                 const isPinned = pinned.has(selSessionId);
-                // Dove atterra la selezione: sul pin resta sulla sessione (sale in cima
-                // con lei, il caret la segue perché è l'oggetto dell'azione); sull'unpin
-                // resta IN PLACE nel gruppo pinnate — successiva, precedente, o prima
-                // contestuale se il gruppo si svuota. Calcolato PRIMA della riscrittura
-                // del sidecar, quando la riga pinnata esiste ancora.
-                const landing = isPinned ? unpinLandingId(sessionRows, selSessionId) : null;
+                // T133 D12 — il caret si sposta solo quando la riga ESCE dalla lista, e
+                // succede nella sola vista `📌` (spinnare toglie la riga dall'insieme che
+                // la vista mostra). Altrove pin e unpin non riordinano niente: la riga è
+                // in lista perché è figlia del parent, e ci resta al suo posto. Il vicino
+                // va calcolato PRIMA di riscrivere il sidecar, quando la riga c'è ancora.
+                const landing = isPinned && sessionViewId === 'pinned' ? neighborId(sessionRows, selSessionId) : null;
                 appendPin(cwd, selSessionId, !isPinned);
                 reloadSessions();
                 if (landing)

package/dist/glyphs.js

@@ -8,10 +8,6 @@ import { sanitize } from './width.js';
 export const CARET = sanitize('▶ ');
 export const CARET_OFF = '  ';
 export const WARN = sanitize('⚠');
-// T50 — separatore leggero fra blocco pinnate e contestuali. `─` (box-drawing) è
-// largo 1 sia per string-width sia per il terminale. Corto +
-// wrap="truncate-end" così non va mai a capo nel pane al 50%.
-export const SESSION_SEP = '─'.repeat(16);
 // Prefisso del sessionId mostrato in lista: stesso dato e stessa lunghezza del
 // widget `⛓ <8 char>` della statusline, così le due superfici si confrontano a
 // occhio.

package/dist/pane-views.js

@@ -4,8 +4,8 @@
 // vista raggiungibile con `tab`.
 //
 // Modulo PURO: nessun import da ink/react, nessun I/O. Il calcolo resta dove
-// stava — `view.ts` per i filtri task, `session-list.ts` per l'assemblaggio a
-// due gruppi — qui c'è solo la mappa di quali sottoinsiemi esistono, come si
+// stava — `view.ts` per i filtri task, `session-list.ts` per l'assemblaggio
+// della lista — qui c'è solo la mappa di quali sottoinsiemi esistono, come si
 // chiamano e con che numero.
 //
 // Invarianti (decisioni congelate al create-task e al preflight):
@@ -65,11 +65,6 @@ export function selectTasks(tasks, id, ctx) {
  *  concorde (largo 1 per entrambe le contabilità), quindi non passa da
  *  `sanitize`. */
 const LIVE_GLYPH = '●';
-/** Righe selezionabili della lista assemblata (il separatore non è una riga di
- *  contenuto: fuori dalla vista di default i due gruppi non ci sono più). */
-function selectable(rows) {
-    return rows.filter((r) => r.kind !== 'separator');
-}
 export const SESSION_VIEWS = [
     {
         id: 'context',
@@ -82,15 +77,19 @@ export const SESSION_VIEWS = [
         id: 'live',
         label: (c) => `${LIVE_GLYPH}${c.live} vive`,
         count: (c) => c.live,
-        rows: (ctx) => selectable(ctx.assembled.rows).filter((r) => ctx.isLive(r.sessionId)),
+        rows: (ctx) => ctx.assembled.rows.filter((r) => ctx.isLive(r.sessionId)),
         color: 'green',
         empty: 'nessuna conversazione viva in questa lista',
     },
     {
+        // T133 D7 — sola vista che NON filtra la lista: il suo insieme è più largo
+        // (le pinnate di ogni task, più le stale), quindi il core lo consegna a
+        // parte. Un filtro su `rows` mostrerebbe le sole pinnate del parent
+        // selezionato, cioè la risposta sbagliata alla domanda «quali ho pinnato».
         id: 'pinned',
         label: (c) => `📌${c.pinned}`,
         count: (c) => c.pinned,
-        rows: (ctx) => ctx.assembled.rows.filter((r) => r.kind === 'pinned'),
+        rows: (ctx) => ctx.assembled.pinnedRows,
         color: 'yellow',
         empty: 'nessuna conversazione pinnata',
     },
@@ -100,11 +99,7 @@ export const SESSION_VIEWS = [
         id: 'older',
         label: (c) => `+${c.older} più vecchie`,
         count: (c) => c.older,
-        rows: (ctx) => ctx.assembled.contextOverflow.map((s) => ({
-            kind: 'context',
-            sessionId: s.sessionId,
-            session: s,
-        })),
+        rows: (ctx) => ctx.assembled.overflowRows,
         dim: true,
         empty: 'nessuna conversazione oltre il cap',
     },

package/dist/session-list.js

@@ -1,19 +1,26 @@
-// T50 — Assemblaggio della lista sessioni a DUE gruppi: pinnate (sempre in
-// lista, in cima) + separatore + contestuali (figlie del parent selezionato).
+// T133 — Assemblaggio della lista sessioni: UNA lista sola, le figlie del parent
+// selezionato in ordine `ts desc`. Il pin è un ATTRIBUTO della riga (glifo, vista
+// dedicata), non una posizione privilegiata.
 // Modulo PURO: nessun import da ink/react, nessun I/O → testabile senza terminale
 // (il pacchetto non ha infrastruttura TUI di test, solo unit sui core puri).
 //
-// Invarianti (decisioni congelate al preflight):
-//  - D2: dentro il blocco pinnate l'ordine è di PIN stabile (ultima pinnata in
-//    cima), dato dal rango del sidecar `session-tasks.jsonl` — non `ts desc`.
-//  - Dedup: una sessione sia pinnata sia contestuale compare SOLO fra le pinnate.
-//  - Cap: `maxContext` limita SOLO le contestuali; le pinnate sono esenti. Il
-//    conteggio delle troncate (`contextHidden`) resta esposto (non-silenzioso).
-//  - D3: una pinnata il cui transcript non esiste più è una riga STALE (session
-//    null), navigabile e spinnabile — non sparisce in silenzio.
-//  - Trap T39: la selezione è KEYED SU sessionId, non su indice posizionale. La
-//    lista è una vista trasformata (due gruppi + separatore): un indice grezzo
-//    identificherebbe la riga sbagliata dopo un pin/cambio-contesto.
+// Invarianti (decisioni congelate al preflight T133):
+//  - D1/D3: una forma sola di lista qualunque sia il parent, vista «tutte»
+//    compresa. Nessun criterio speciale per le righe pinnate: nessun blocco in
+//    cima, nessun ordine proprio, nessuna esenzione dal cap (D6).
+//  - D4: una pinnata compare in lista se e solo se è figlia del parent
+//    selezionato. Le pinnate fuori contesto vivono nella sola vista `📌`.
+//  - D7: le righe pinnate escono in un CAMPO A PARTE (`pinnedRows`), non dentro
+//    `rows`: il loro insieme è più largo della lista (tutte le sessioni del
+//    progetto più le stale), quindi non è esprimibile come filtro di `rows`.
+//  - D8: `pinnedRows` conserva l'ordine per RANGO di pin desc (ultima pinnata in
+//    cima), dato dal sidecar `session-tasks.jsonl`. È l'unico lettore rimasto del
+//    rango.
+//  - D5: una pinnata il cui transcript non esiste più è una riga STALE, presente
+//    nelle sole `pinnedRows` — navigabile e spinnabile dalla vista `📌`.
+//  - Trap T39: la selezione è KEYED SU sessionId, non su indice posizionale. Le
+//    righe a schermo sono quelle della vista attiva, e un indice grezzo
+//    identificherebbe la riga sbagliata al primo cambio di vista o di parent.
 import { cut, termWidth } from './width.js';
 // ── T53 · etichetta di riga ────────────────────────────────────────────────
 /**
@@ -121,66 +128,50 @@ export function rowLabel(text, note, budget) {
     return { note: shownNote, rest: restBudget >= MIN_REST ? cut(rest, restBudget) : '' };
 }
 export function assembleSessionList(childSessions, allSessions, pinned, maxContext) {
-    // Le pinnate si risolvono contro TUTTE le sessioni del progetto, non solo le
-    // figlie del parent: una pinnata può appartenere a un'altra task. Assente
-    // dallo store → stale.
-    const byId = new Map(allSessions.map((s) => [s.sessionId, s]));
-    const pinnedIds = [...pinned.entries()]
-        .sort((a, b) => b[1] - a[1]) // rango desc → ultima pinnata in cima (D2)
-        .map(([id]) => id);
-    const pinnedRows = pinnedIds.map((id) => {
-        const session = byId.get(id) ?? null;
-        return { kind: 'pinned', sessionId: id, session, stale: session === null };
-    });
-    const pinnedSet = new Set(pinnedIds);
-    const dedupedContext = childSessions.filter((s) => !pinnedSet.has(s.sessionId));
     const cap = Math.max(0, maxContext);
-    const shownContext = dedupedContext.slice(0, cap);
-    const overflowContext = dedupedContext.slice(cap);
-    const contextRows = shownContext.map((s) => ({
-        kind: 'context',
+    const toRow = (s) => ({
+        kind: 'session',
         sessionId: s.sessionId,
         session: s,
-    }));
-    const rows = [...pinnedRows];
-    // Separatore SOLO fra due gruppi entrambi non vuoti: senza pinnate o senza
-    // contestuali non c'è confine da segnare.
-    if (pinnedRows.length > 0 && contextRows.length > 0)
-        rows.push({ kind: 'separator' });
-    rows.push(...contextRows);
-    return {
-        rows,
-        pinnedCount: pinnedRows.length,
-        contextTotal: dedupedContext.length,
-        contextHidden: overflowContext.length,
-        contextOverflow: overflowContext,
-    };
-}
-function isSelectable(r) {
-    return r.kind !== 'separator';
+        pinned: pinned.has(s.sessionId),
+    });
+    const rows = childSessions.slice(0, cap).map(toRow);
+    const overflowRows = childSessions.slice(cap).map(toRow);
+    // Le pinnate si risolvono contro TUTTE le sessioni del progetto, non solo le
+    // figlie del parent: una pinnata può appartenere a un'altra task, e la vista
+    // dedicata è l'unico posto dove resta raggiungibile. Assente dallo store →
+    // stale.
+    const byId = new Map(allSessions.map((s) => [s.sessionId, s]));
+    const pinnedRows = [...pinned.entries()]
+        .sort((a, b) => b[1] - a[1]) // rango desc → ultima pinnata in cima (D8)
+        .map(([id]) => {
+        const session = byId.get(id);
+        return session
+            ? { kind: 'session', sessionId: id, session, pinned: true }
+            : { kind: 'stale', sessionId: id };
+    });
+    return { rows, pinnedRows, contextTotal: childSessions.length, overflowRows };
 }
-/** Primo id selezionabile (salta il separatore); null = lista senza righe. */
+/** Primo id della lista; null = lista senza righe. */
 export function firstSelectableId(rows) {
-    return rows.find(isSelectable)?.sessionId ?? null;
+    return rows[0]?.sessionId ?? null;
 }
 /** Indice della riga con quel sessionId nell'ARRAY COMPLETO (per il windowing);
- *  -1 se assente o id null. Il separatore non ha id → mai matchato. */
+ *  -1 se assente o id null. */
 export function rowIndexOf(rows, sessionId) {
     if (sessionId === null)
         return -1;
-    return rows.findIndex((r) => isSelectable(r) && r.sessionId === sessionId);
+    return rows.findIndex((r) => r.sessionId === sessionId);
 }
-/** Sposta la selezione di `delta` fra le sole righe selezionabili (attraversa il
- *  separatore senza fermarcisi). Id perso → prima riga; lista vuota → null. */
+/** Sposta la selezione di `delta`. Id perso → prima riga; lista vuota → null. */
 export function moveSelection(rows, currentId, delta) {
-    const selectable = rows.filter(isSelectable);
-    if (selectable.length === 0)
+    if (rows.length === 0)
         return null;
-    const cur = selectable.findIndex((r) => r.sessionId === currentId);
+    const cur = rows.findIndex((r) => r.sessionId === currentId);
     if (cur < 0)
-        return selectable[0].sessionId;
-    const next = Math.max(0, Math.min(selectable.length - 1, cur + delta));
-    return selectable[next].sessionId;
+        return rows[0].sessionId;
+    const next = Math.max(0, Math.min(rows.length - 1, cur + delta));
+    return rows[next].sessionId;
 }
 /**
  * T57 — id su cui atterrare quando la riga `sessionId` sta per USCIRE dalla
@@ -192,44 +183,19 @@ export function moveSelection(rows, currentId, delta) {
  * assegnazione rimanderebbe la selezione in cima. L'id va catturato PRIMA di
  * riscrivere il sidecar — dopo, la riga non c'è più e il vicino non è
  * calcolabile.
- */
-export function neighborId(rows, sessionId) {
-    const selectable = rows.filter(isSelectable);
-    const at = selectable.findIndex((r) => r.sessionId === sessionId);
-    if (at < 0)
-        return null;
-    return selectable[at + 1]?.sessionId ?? selectable[at - 1]?.sessionId ?? null;
-}
-/**
- * Id su cui atterrare quando la riga pinnata `sessionId` viene SPINNATA: la
- * pinnata successiva, la precedente se era l'ultima, la prima contestuale se il
- * gruppo pinnate si svuota. `null` se `sessionId` non è pinnata o non resta
- * nessuna riga.
  *
- * Non è `neighborId` ristretto al gruppo: quello attraversa il separatore,
- * quindi sull'ULTIMA pinnata atterrerebbe sulla prima contestuale — il caret
- * scavalcherebbe l'intero gruppo invece di risalire di una riga. Qui il confine
- * fra i due gruppi è la regola, non un ostacolo.
- *
- * L'id va calcolato PRIMA di riscrivere il sidecar: dopo, la riga pinnata non
- * c'è più e il vicino nel gruppo non è calcolabile. Serve perché una spinnata
- * non sparisce necessariamente dalla lista — se appartiene al parent
- * selezionato ricompare fra le contestuali, e la selezione keyed sull'id la
- * seguirebbe fin laggiù, trascinando il caret.
+ * T133 D12 — stesso servizio per l'unpin dentro la vista `📌`, dove spinnare fa
+ * uscire la riga. Nella lista principale non serve: lì una pinnata è in lista
+ * perché è figlia del parent, e spinnarla non la fa uscire.
  */
-export function unpinLandingId(rows, sessionId) {
-    const pinnedRows = rows.filter((r) => r.kind === 'pinned');
-    const at = pinnedRows.findIndex((r) => r.sessionId === sessionId);
+export function neighborId(rows, sessionId) {
+    const at = rows.findIndex((r) => r.sessionId === sessionId);
     if (at < 0)
         return null;
-    const inGroup = pinnedRows[at + 1]?.sessionId ?? pinnedRows[at - 1]?.sessionId;
-    if (inGroup)
-        return inGroup;
-    const firstContext = rows.find((r) => r.kind === 'context');
-    return firstContext && isSelectable(firstContext) ? firstContext.sessionId : null;
+    return rows[at + 1]?.sessionId ?? rows[at - 1]?.sessionId ?? null;
 }
 /** Session della riga selezionata; null se stale o nessuna selezione. */
 export function selectedSession(rows, sessionId) {
-    const r = rows.find((row) => isSelectable(row) && row.sessionId === sessionId);
-    return r && isSelectable(r) ? r.session : null;
+    const r = rows.find((row) => row.sessionId === sessionId);
+    return r && r.kind === 'session' ? r.session : null;
 }

package/dist/ui/panes.js

@@ -5,7 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from 'ink';
 import { cut, pad, sanitize, termWidth } from '../width.js';
 import { paneTextWidth } from '../layout.js';
-import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SESSION_SEP, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
+import { CARET, CARET_OFF, LIVE_BUSY, LIVE_IDLE, LIVE_NONE, MODEL_W, SID_CHARS, TASK_EMPTY, WARN, metaCount, modelShort, relTime, } from '../glyphs.js';
 import { TaskRow } from './task-row.js';
 import { META_ROWS, ROW_ALL, ROW_SPOT } from '../model.js';
 import { rowLabel, sessionTitle } from '../session-list.js';
@@ -94,24 +94,22 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                         ? 'nessuna conversazione nel progetto'
                         : isSpot
                             ? 'nessuna sessione libera'
-                            : 'nessuna sessione legata a questa task'), paneTextWidth(columns)) })) : (rows.map((row, i) => {
-                // T50 — separatore leggero fra pinnate e contestuali: riga dim, non un
-                // box pesante (coerente con lo styling delle Done dimmate).
-                if (row.kind === 'separator') {
-                    return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: SESSION_SEP }, `sep${i}`));
-                }
+                            : 'nessuna sessione legata a questa task'), paneTextWidth(columns)) })) : (rows.map((row) => {
                 const sel = row.sessionId === selectedId;
                 // T50 — pin stale: transcript sparito, nessuna Session da mostrare.
-                // Riga navigabile e spinnabile (`p`), marcata, mai un crash.
-                if (row.kind === 'pinned' && row.stale) {
+                // Riga navigabile e spinnabile (`p`), marcata, mai un crash. T133 D5 —
+                // compare nella sola vista `📌`, dove non ha accanto nessuna griglia da
+                // rispettare: resta testo libero.
+                if (row.kind === 'stale') {
                     // T60 — anche qui la nota si taglia sul budget DERIVATO, non su un
                     // 30 inchiodato: su un pane stretto quel valore fisso mandava la
                     // riga oltre il bordo, e a ripararla arrivava `cli-truncate` (che
                     // sfora di una colonna per emoji e mangia il bordo stesso).
                     const staleNote = sessionNotes.get(row.sessionId);
                     // La riga stale è libera (niente colonne: non ha né titolo né
-                    // data), ma il binding va detto lo stesso — è una pinnata, quindi
-                    // l'header del pane non ne dice l'appartenenza.
+                    // data), ma il binding va detto lo stesso — vive nella vista `📌`,
+                    // che raccoglie le pinnate di ogni task e quindi non ne dice
+                    // l'appartenenza dall'header.
                     const staleTask = bindings.get(row.sessionId) ?? null;
                     const staleW = Math.max(0, paneTextWidth(columns) -
                         (2 /* caret */ +
@@ -121,8 +119,8 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                             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));
                 }
-                const s = row.session; // non-stale → session presente
-                const isPinnedRow = row.kind === 'pinned';
+                const s = row.session;
+                const isPinnedRow = row.pinned;
                 // T28 — un ramo eredita il titolo dell'origine: senza marcatore le due
                 // righe sarebbero identiche a occhio.
                 const forked = forkOf.has(s.sessionId);
@@ -139,13 +137,12 @@ export function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW
                 // appartiene la conversazione (pin/task/spot), questa dice se è aperta
                 // adesso. Farle condividere una cella perderebbe una delle due.
                 const liveEntry = live.get(s.sessionId);
-                // Stesso motivo per cui la colonna esiste: una pinnata resta in lista
-                // qualunque sia il parent selezionato, quindi l'header non ne dice
-                // l'appartenenza e la cella va riempita anche fuori dalla vista
-                // "tutte". Sulle contestuali, dove l'header parla già, resta vuota —
-                // ma la cella è comunque larga `taskW`, o le colonne a destra
-                // slitterebbero riga per riga.
-                const taskCell = isAll || isPinnedRow ? (bound ?? TASK_EMPTY) : '';
+                // T133 D10 — la colonna vive nella sola vista "tutte". Il ramo sulle
+                // pinnate esisteva perché una pinnata stava in lista anche sotto un
+                // parent che non era il suo; ora ogni riga è figlia del parent
+                // selezionato, quindi l'header parla già per tutte e la cella
+                // ripeterebbe N volte ciò che è scritto una riga sopra.
+                const taskCell = isAll ? (bound ?? TASK_EMPTY) : '';
                 // T60 — colonne VERE: ogni cella fissa è larga esattamente quanto
                 // dichiara, riempita di spazi con `pad` (che misura in colonne, non in
                 // caratteri). Il marker va portato a 2 anche quando è `○`, largo 1:

package/package.json

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