@lamemind/loom-deck 0.27.0 → 0.27.3

package/README.md

@@ -308,6 +308,14 @@ senza flag resta `recap`, `none` apre la sessione bound **senza** alcun prompt.
 `LOOM_DECK_ENTER_PROMPT` (placeholder `{TASK}`) resta un override che vince sul
 kind — tranne su `none`, che è una richiesta esplicita di non averne.
 
+La tab porta anche `PTYXIS_PROFILE` forzata al profilo bindato al progetto nel
+registry (`bindings/claude`), letto da dconf: è la chiave con cui loom-compass
+associa a un progetto lo stato annunciato dagli hook (running/ask/done). Una tab
+`ptyxis --tab` nuda erediterebbe il profilo di default, e l'annuncio finirebbe
+keyed su un UUID che nessun progetto dichiara — pallino fermo su idle, senza
+alcun errore visibile. Override o disattivazione via `LOOM_DECK_STATE_PROFILE`
+(settata a vuoto → nessun annuncio); progetto non registrato → nessun prefisso.
+
 ## Sviluppo (TUI Ink)
 
 ```bash

package/dist/cli.js

@@ -16,7 +16,7 @@ import { assembleSessionList, firstSelectableId, moveSelection, neighborId, rowI
 import { cellWidth, launchLegend, loadArchivableDays, loadIdentity, loadLaunch, } from './config.js';
 import { countArchivable, SCAN_INTERVAL_MS } from './archivable.js';
 import { assignListCapacity, isCompact, layoutBudget, readerCapacity, searchListCapacity, searchPreviewCapacity, windowRange, } from './viewport.js';
-import { caretWindow, cut, pad, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
+import { caretWindow, cut, cutParts, pad, sanitize, termWidth, wrapLines, wrapWithOffsets, } from './width.js';
 import { applyView, cycleSort, describeSort, priName, progName, toggleHidden, PRI_ENTRIES, PROG_ENTRIES, } from './view.js';
 import { initialDetail, progressText, writeTaskEdit, PRI_GLYPH, PRI_LABEL, PROG_GLYPH, } from './task-edit.js';
 import { loadView, saveView, viewFilePath } from './view-store.js';
@@ -680,7 +680,11 @@ function Deck({ cwd, tasksPath, tasksDir }) {
         for (const r of sessionRows) {
             if (r.kind === 'separator')
                 continue;
-            if (isAll) {
+            // 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') {
                 const b = bindings.get(r.sessionId);
                 if (b)
                     task = Math.max(task, termWidth(b));
@@ -2013,15 +2017,43 @@ function AssignScreen({ sessionId, label, current, filter, rows, selected, match
                         return (_jsxs(Text, { inverse: sel, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
                     })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
 }
+/**
+ * Header del pane task, tagliato QUI e non da Ink — stesso motivo del gemello
+ * `SessionsHeader`, con una differenza di rischio: qui i segmenti sono tutti
+ * ASCII più le frecce `↑↓` (larghe 1), quindi `cli-truncate` oggi darebbe la
+ * riga giusta per caso. Il taglio resta del deck perché la correttezza non deve
+ * dipendere dall'alfabeto che capita nella riga: il primo glifo largo 2 che
+ * entrasse in un segmento nuovo riaprirebbe il difetto in silenzio, e a
+ * scoprirlo sarebbe il bordo del pane a schermo.
+ *
+ * `truncate-end` taglia dalla coda, e `cutParts` conserva l'ordine: l'ultimo
+ * segmento resta il primo a cedere il posto (vedi T61 sotto, `archiviabili` in
+ * coda ai contatori della vista corrente).
+ */
+function TasksHeader({ filtered, total, hidden, above, below, archivable, focused, columns, }) {
+    const segments = [
+        { text: `Tasks (${hidden > 0 ? `${filtered}/${total}` : filtered})` },
+        ...(hidden > 0 ? [{ text: ` · ${hidden} nascoste`, color: 'yellow' }] : []),
+        ...(above > 0 ? [{ text: ` · ↑${above}`, dim: true }] : []),
+        ...(below > 0 ? [{ text: ` · ↓${below}`, dim: true }] : []),
+        ...(archivable > 0 ? [{ text: ` · ${archivable} archiviabili`, dim: true }] : []),
+    ];
+    const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns));
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, children: shown[i] }, i)) : null) }));
+}
 function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount, allCount, childCount, focused, loadError, detail, windowStart, above, below, detailLines, columns, archivable, }) {
     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: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: ["Tasks (", hidden > 0 ? `${filtered}/${total}` : filtered, ")", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", hidden, " nascoste"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null, archivable > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 ", archivable, " archiviabili"] }) : null] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort: ", describeSort(view.sort), view.hiddenPri.length + view.hiddenProg.length > 0 ? (_jsxs(Text, { children: [' ', "\u00B7 filtri:", ' ', [
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(TasksHeader, { filtered: filtered, total: total, hidden: hidden, above: above, below: below, archivable: archivable, focused: focused, columns: columns }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cut(sanitize(`sort: ${describeSort(view.sort)}` +
+                    (view.hiddenPri.length + view.hiddenProg.length > 0
+                        ? ' · filtri: ' +
+                            [
                                 ...PRI_ENTRIES.filter((e) => view.hiddenPri.includes(e.name)),
                                 ...PROG_ENTRIES.filter((e) => view.hiddenProg.includes(e.name)),
                             ]
-                                .map((e) => `−${sanitize(e.glyph)}`)
-                                .join(' ')] })) : null] }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", allCount > 0 ? ` (${allCount})` : ''] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : (tasks.map((task, i) => {
+                                .map((e) => `−${e.glyph}`)
+                                .join(' ')
+                        : '')), paneTextWidth(columns)) }), _jsxs(Text, { inverse: allSelected && focused, bold: allSelected && !focused, wrap: "truncate-end", children: [allSelected ? CARET : CARET_OFF, "\u2261 tutte le sessioni", allCount > 0 ? ` (${allCount})` : ''] }), _jsxs(Text, { inverse: spotSelected && focused, bold: spotSelected && !focused, wrap: "truncate-end", children: [spotSelected ? CARET : CARET_OFF, "\u25CB spot  sessioni libere", spotCount > 0 ? ` (${spotCount})` : ''] }), loadError ? (_jsx(Text, { color: "red", wrap: "truncate-end", children: loadError })) : (tasks.map((task, i) => {
                 // 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.
@@ -2039,8 +2071,32 @@ function TasksPane({ tasks, filtered, total, hidden, view, selected, spotCount,
                 return (_jsxs(Text, { inverse: sel && focused, bold: sel && !focused, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
             })), detail && detailLines > 0 ? (_jsx(DetailPane, { detail: detail, maxLines: detailLines, columns: columns })) : null] }));
 }
+/**
+ * Header del pane sessioni, tagliato QUI e non da Ink.
+ *
+ * `📌{pinnedCount}` è un glifo largo 2 in mezzo alla riga: con
+ * `wrap="truncate-end"` il taglio passava da `cli-truncate`, che indicizza per
+ * code point con un budget in colonne e restituiva una riga larga 45 su un
+ * budget di 44 — la colonna in più finiva sopra il bordo destro del pane, che
+ * spariva dalla riga (invariante ③ di `width.ts`).
+ *
+ * I segmenti restano segmenti fino al render: il taglio è della RIGA (budget
+ * condiviso, `cutParts`), la resa è del pezzo. Il giallo su `📌N` distingue le
+ * pinnate dal resto dell'header e non è decorazione.
+ */
+function SessionsHeader({ parentLabel, total, pinnedCount, hidden, above, below, focused, columns, }) {
+    const segments = [
+        { text: `Sessions · ${parentLabel} (${total})` },
+        ...(pinnedCount > 0 ? [{ text: ` · 📌${pinnedCount}`, color: 'yellow' }] : []),
+        ...(hidden > 0 ? [{ text: ` · +${hidden} più vecchie`, dim: true }] : []),
+        ...(above > 0 ? [{ text: ` · ↑${above}`, dim: true }] : []),
+        ...(below > 0 ? [{ text: ` · ↓${below}`, dim: true }] : []),
+    ];
+    const shown = cutParts(segments.map((s) => s.text), paneTextWidth(columns));
+    return (_jsx(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: segments.map((seg, i) => shown[i] ? (_jsx(Text, { color: seg.color, dimColor: seg.dim, children: shown[i] }, i)) : null) }));
+}
 function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows, total, pinnedCount, hidden, selectedId, focused, above, below, detail, firstLines, lastLines, columns, forkOf, sessionNotes, projectCore, }) {
-    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsxs(Text, { bold: true, color: focused ? 'cyan' : undefined, wrap: "truncate-end", children: ["Sessions \u00B7 ", parentLabel, " (", total, ")", pinnedCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 \uD83D\uDCCC", pinnedCount] }) : null, hidden > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 +", hidden, " pi\u00F9 vecchie"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }), total === 0 ? (_jsx(Text, { color: "yellow", wrap: "truncate-end", children: isAll
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(SessionsHeader, { parentLabel: parentLabel, total: total, pinnedCount: pinnedCount, hidden: hidden, above: above, below: below, focused: focused, columns: columns }), total === 0 ? (_jsx(Text, { color: "yellow", wrap: "truncate-end", children: isAll
                     ? 'nessuna conversazione nel progetto'
                     : isSpot
                         ? 'nessuna sessione libera'
@@ -2059,8 +2115,17 @@ function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows,
                     // 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);
-                    const staleW = Math.max(0, paneTextWidth(columns) - (2 /* caret */ + termWidth(`${WARN} pin stale `) + SID_CHARS + 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) }), staleNote ? _jsxs(Text, { color: "yellow", children: [" \u00AB", cut(staleNote, staleW), "\u00BB"] }) : null] }, 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.
+                    const staleTask = bindings.get(row.sessionId) ?? null;
+                    const staleW = Math.max(0, paneTextWidth(columns) -
+                        (2 /* caret */ +
+                            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));
                 }
                 const s = row.session; // non-stale → session presente
                 const isPinnedRow = row.kind === 'pinned';
@@ -2076,6 +2141,13 @@ function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows,
                 // task accanto, che esiste solo in questa vista.
                 const bound = bindings.get(s.sessionId) ?? null;
                 const linked = isAll ? Boolean(bound) : !isSpot;
+                // 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) : '';
                 // 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:
@@ -2109,7 +2181,7 @@ function SessionsPane({ parentLabel, isSpot, isAll, bindings, taskW, ageW, rows,
                 const used = (label.note ? termWidth(label.note) + 2 : 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: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', taskW > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: bound ? 'green' : undefined, dimColor: !bound, children: pad(bound ?? TASK_EMPTY, 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: "cyan", children: s.sessionId.slice(0, SID_CHARS) }), ' ', 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));
             })), detail ? (_jsx(SessionDetailPane, { s: detail, firstLines: firstLines, lastLines: lastLines, columns: columns, origin: forkOf.get(detail.sessionId) ?? null, note: sessionNotes.get(detail.sessionId) ?? '' })) : null] }));
 }
 // T49 — detail pane della sessione selezionata (hover), gemello del DetailPane

package/dist/width.js

@@ -202,6 +202,61 @@ export function cut(s, cols) {
     // informazione, tolgono una colonna di testo.
     return out.trimEnd().replace(/…$/, '') + '…';
 }
+/**
+ * Taglio di una riga COMPOSTA da più pezzi, ognuno con la propria resa (colore,
+ * dim, bold). Restituisce un array della stessa lunghezza: i pezzi interi finché
+ * il budget regge, quello a cavallo del taglio accorciato, i successivi vuoti.
+ *
+ * Perché non basta `cut` chiamato pezzo per pezzo: il budget è della RIGA, non
+ * del singolo pezzo — un pezzo va tagliato in base a quanto hanno già consumato
+ * quelli prima di lui. E `cut` collassa il whitespace, quindi mangerebbe lo
+ * spazio che separa i segmenti (` · 📌3` diventerebbe `· 📌3`), disallineando la
+ * riga di una colonna per ogni giunzione.
+ *
+ * Perché non basta concatenare e tagliare una volta sola: il risultato sarebbe
+ * una stringa unica, e i pezzi tornerebbero renderizzabili solo tutti dello
+ * stesso colore. Un header che perde il giallo su `📌N` perde il segnale, non
+ * solo la vernice.
+ *
+ * Invariante ③ (§ in testa a questo file): serve a togliere l'ultima riga
+ * composita ancora tagliata da Ink. Gli header dei due pane sono l'ultimo posto
+ * dove `wrap="truncate-end"` era rimasto il meccanismo e non la rete: entrambi
+ * portano glifi larghi 2 (`📌` nelle sessioni, i glifi di priorità nei filtri
+ * delle task), cioè la condizione esatta in cui `cli-truncate` restituisce una
+ * riga più larga del budget e il bordo del pane sparisce.
+ */
+export function cutParts(parts, cols) {
+    const empty = parts.map(() => '');
+    if (cols <= 0)
+        return empty;
+    if (parts.reduce((w, p) => w + termWidth(p), 0) <= cols)
+        return [...parts];
+    const out = [...empty];
+    const budget = cols - 1; // -1 = la colonna dell'ellissi, che qui c'è di sicuro
+    let w = 0;
+    let full = false;
+    for (let i = 0; i < parts.length && !full; i++) {
+        let acc = '';
+        for (const ch of parts[i]) {
+            const cw = termWidth(ch);
+            if (w + cw > budget) {
+                full = true;
+                break;
+            }
+            acc += ch;
+            w += cw;
+        }
+        out[i] = acc;
+    }
+    // L'ellissi va sull'ultimo pezzo che ha davvero del testo: appiccicarla a un
+    // pezzo vuoto la staccherebbe dal punto di taglio, e il lettore la leggerebbe
+    // come un segmento a sé.
+    let last = out.length - 1;
+    while (last > 0 && out[last] === '')
+        last--;
+    out[last] = out[last].trimEnd().replace(/…$/, '') + '…';
+    return out;
+}
 /**
  * Cella di larghezza ESATTA `cols`: taglia se eccede, riempie di spazi se manca.
  *

package/package.json

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

@@ -40,6 +40,8 @@
 #   LOOM_DECK_WORKDIR      dir di lavoro della tab (default: $PWD)
 #   LOOM_DECK_ENTER_PROMPT override del prompt iniziale, {TASK}=TaskID (vince sul kind, tranne `none`)
 #   LOOM_DECK_INTAB_CMD    override comando in-tab (default: la sessione CC; usato per i test)
+#   LOOM_DECK_STATE_PROFILE  PTYXIS_PROFILE annunciata a compass (default: bindings/claude
+#                            del progetto, letto da dconf; settata a vuoto = nessun annuncio)
 #   LOOM_DECK_PERMISSION_MODE  override del permissionMode del file config (default: campo file, poi 'manual')
 #
 set -euo pipefail
@@ -271,6 +273,48 @@ case "${PERM_MODE:-}" in
 esac
 MODE_FLAG="--permission-mode ${PERM_MODE} "
 
+# ── Profilo di stato per compass ─────────────────────────────────────────────
+# Lo stato di una sessione (running/ask/done) viaggia verso compass via D-Bus
+# keyed su $PTYXIS_PROFILE (hook Claude → `compass <stato>`), e compass lo mappa
+# a un progetto SOLO se quell'UUID compare in `bindings/<surface>/profile` del
+# registry. Ma nel modo `inline` la tab nasce da `ptyxis --tab` nudo, che eredita
+# il profilo DEFAULT di Ptyxis: l'annuncio arriva keyed su un UUID che nessun
+# progetto dichiara → stato scartato, pallino fermo su idle per sempre. Il match
+# della FINESTRA non se ne accorge (passa dal titolo, non dal profilo), quindi il
+# progetto risulta presente ma senza stato — un guasto che non si manifesta come
+# errore, solo come pallino che non cambia mai.
+# Rimedio: forzare in-tab la PTYXIS_PROFILE del binding claude del progetto, così
+# l'annuncio è keyed sull'UUID che compass cerca davvero. Il profilo bindato NON
+# è usabile come profilo vero della tab (`--tab-with-profile`): ha
+# use-custom-command=true, che fa scartare il comando inline — vedi il ramo
+# `profile` sotto, che per questo deve riscrivere dconf.
+#
+# `${VAR+set}`, non `${VAR:-}`: env settata anche a VUOTO = "salta il lookup"
+# (deterministico per i test, che altrimenti leggerebbero il dconf della macchina
+# su cui gira la suite). Non settata = risolvi dal registry.
+# Assente/non risolvibile → nessun prefisso: si degrada al comportamento di prima
+# (stato orfano) invece di rompere lo spawn.
+if [[ -n "${LOOM_DECK_STATE_PROFILE+set}" ]]; then
+  STATE_PROFILE="${LOOM_DECK_STATE_PROFILE}"
+else
+  STATE_PROFILE=""
+  if [[ -n "$_cfg" ]] && command -v dconf >/dev/null 2>&1; then
+    _pid="$(jq -r '.id // empty' "$_cfg" 2>/dev/null || true)"
+    if [[ -n "$_pid" ]]; then
+      STATE_PROFILE="$(dconf read "/org/lamemind/loom/projects/${_pid}/bindings/claude/profile" 2>/dev/null | tr -d "'" || true)"
+    fi
+  fi
+fi
+# Whitelist come per la nota del titolo: il valore entra in `bash -lc "…"`, e un
+# registry è pur sempre un file editabile a mano. Un UUID Ptyxis è esadecimale;
+# accetto l'alfabeto id-safe e scarto il resto invece di quotare.
+if [[ -n "$STATE_PROFILE" && ! "$STATE_PROFILE" =~ ^[A-Za-z0-9_-]+$ ]]; then
+  echo "profilo di stato ignorato (caratteri non ammessi): '${STATE_PROFILE}'" >&2
+  STATE_PROFILE=""
+fi
+PROFILE_ENV=""
+[[ -n "$STATE_PROFILE" ]] && PROFILE_ENV="PTYXIS_PROFILE=${STATE_PROFILE} "
+
 # --session-id per la tab: pinna il sessionId della sessione CC (vuoto → CC ne
 # genera uno). Lo spazio finale tiene la concatenazione pulita quando è assente.
 SID_FLAG=""
@@ -344,10 +388,13 @@ PROMPT_ARG=""
 # agli altri elementi task-bound: nel fork di una sessione SPOT il sessionId
 # pinnato non serve a legare una task (non c'è) ma a rendere noto in anticipo
 # l'id del ramo, senza il quale il lineage non sarebbe registrabile.
+# PROFILE_ENV in testa a entrambi i rami: lo stato è una proprietà della SESSIONE
+# (esiste anche senza task), esattamente come la label del titolo — legarlo al
+# ramo task-bound ripeterebbe l'errore di layer già evitato per la titolazione.
 if [[ $NO_TASK -eq 1 ]]; then
-  _default_intab="claude --name '${TITLE}' ${MODE_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}"
+  _default_intab="${PROFILE_ENV}claude --name '${TITLE}' ${MODE_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}"
 else
-  _default_intab="LOOM_TASK=${TASK} claude --name '${TITLE}' ${MODE_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}${PROMPT_ARG}"
+  _default_intab="${PROFILE_ENV}LOOM_TASK=${TASK} claude --name '${TITLE}' ${MODE_FLAG}${SID_FLAG}${RES_FLAG}${FORK_FLAG}${PROMPT_ARG}"
 fi
 IN_TAB_CMD="${LOOM_DECK_INTAB_CMD:-$_default_intab}"