@lamemind/loom-deck 0.68.0 → 0.70.0

package/dist/deck-model.js

@@ -107,11 +107,28 @@ export function childSessionsOf(sessions, bindings, selectedTaskId, isAll) {
 }
 export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDefault, setNote, }) {
     const { tasks, loadError } = useTasks(tasksPath);
+    // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
+    const launch = useMemo(() => loadLaunch(cwd), [cwd]);
+    // Identità (T37): titolo delle tab terminale spawnate col tasto `t`.
+    const identity = useMemo(() => loadIdentity(cwd), [cwd]);
+    // T53 — il core che ogni titolo di tab porta, quindi la colonna costante da
+    // togliere quando serve spazio. Hoistato perché lo consumano DUE schermate
+    // (lista e ricerca): calcolarlo su ogni call site è il modo in cui le due
+    // smettono di togliere la stessa cosa.
+    // T58 — il core è il solo `name`, non `<emoji> <name>` come la chiave di match
+    // di compass: qui non serve entropia (è un taglio cosmetico, non un matcher) e
+    // il nome nudo ripulisce anche i titoli storici, scritti quando la formula
+    // includeva l'owner.
+    // T162 — sta SOPRA `useSessions` perché ora è anche un suo ingresso: il deck
+    // scrive nel sidecar il residuo del titolo, e quel residuo si ottiene
+    // togliendo questo stesso core (§Riempimento dei buchi in `hooks.ts`).
+    const projectCore = identity ? identity.name : null;
+    const projectName = cwd.split('/').pop() || cwd;
     // `notes` esce dall'indice come `sessionNotes`: nel deck `note` è già la riga
     // di STATO in fondo al frame (il feedback di un'azione). Due concetti diversi
     // a una lettera di distanza sarebbero una trappola di lettura — e di
     // scrittura, visto che `setNote` compare in quasi ogni ramo.
-    const { sessions, bindings, forkOf, pinned, notes: sessionNotes, priority: sessionPriority, live, reload: reloadSessions, } = useSessions(cwd);
+    const { sessions, bindings, forkOf, pinned, notes: sessionNotes, priority: sessionPriority, live, reload: reloadSessions, } = useSessions(cwd, projectCore);
     const [focus, setFocus] = useState('tasks');
     // T39 — selezione KEYED SU ID, non su indice. Con una vista trasformata
     // (filtro/sort) l'indice non identifica più la stessa task: leggere l'array
@@ -158,20 +175,6 @@ export function useDeckModel({ cwd, tasksPath, tasksDir, bareModel: bareModelDef
     // sbagliata in silenzio (stessa trappola di T39 sulle task e T50 sulle
     // conversazioni).
     const [selInboxPath, setSelInboxPath] = useState(null);
-    // Voci launch del progetto (T32): lette una volta, raggiunte per indice 1..9.
-    const launch = useMemo(() => loadLaunch(cwd), [cwd]);
-    // Identità (T37): titolo delle tab terminale spawnate col tasto `t`.
-    const identity = useMemo(() => loadIdentity(cwd), [cwd]);
-    // T53 — il core che ogni titolo di tab porta, quindi la colonna costante da
-    // togliere quando serve spazio. Hoistato perché lo consumano DUE schermate
-    // (lista e ricerca): calcolarlo su ogni call site è il modo in cui le due
-    // smettono di togliere la stessa cosa.
-    // T58 — il core è il solo `name`, non `<emoji> <name>` come la chiave di match
-    // di compass: qui non serve entropia (è un taglio cosmetico, non un matcher) e
-    // il nome nudo ripulisce anche i titoli storici, scritti quando la formula
-    // includeva l'owner.
-    const projectCore = identity ? identity.name : null;
-    const projectName = cwd.split('/').pop() || cwd;
     // T136 — data dell'ultimo commit di ogni task file, per la chiave `commit`
     // della chain di sort.
     const commitAt = useCommitTimes(tasksDir, cwd);

package/dist/hooks.js

@@ -9,6 +9,7 @@ import { loadTasks, loadTaskDetail } from './tasks.js';
 import { discoverProjectSessions } from './sessions.js';
 import { discoverLiveSessions, liveSig } from './live-sessions.js';
 import { loadSessionIndex } from './task-index.js';
+import { fillSidecarGaps } from './session-meta.js';
 import { archivableIds, SCAN_INTERVAL_MS } from './archivable.js';
 import { commitTimes } from './commit-times.js';
 import { scanEpicHierarchy, EMPTY_EPIC_HIERARCHY } from './epic-hierarchy.js';
@@ -137,7 +138,15 @@ export function useEpicHierarchy(tasksDir) {
 // ha cache mtime-keyed interna → il poll è economico; qui si evita comunque il
 // re-render inutile con una signature (sessionId:ts + binding entries): setState
 // solo quando cambia davvero qualcosa.
-export function useSessions(projectRoot) {
+//
+// T162 — è anche il posto dove il deck RIEMPIE I BUCHI dei campi derivati del
+// sidecar (`title`, `model`): qui le due fonti sono già in mano nello stesso
+// giro, la corrente (le `Session`) e quella su disco (l'indice). Il `core` del
+// progetto arriva per argomento e non si rilegge qui: la stessa derivazione
+// vive già nel modello (`projectCore`), e una seconda copia toglierebbe dal
+// titolo scritto nel sidecar una stringa diversa da quella che la lista toglie
+// dalle proprie righe.
+export function useSessions(projectRoot, core) {
     const [state, setState] = useState({
         sessions: [],
         bindings: new Map(),
@@ -168,6 +177,8 @@ export function useSessions(projectRoot) {
                     pinned: new Map(),
                     notes: new Map(),
                     priority: new Set(),
+                    titles: new Map(),
+                    models: new Map(),
                 };
             }
             // T62 — le vive stanno sullo STESSO tick delle altre fonti, non su una
@@ -183,6 +194,33 @@ export function useSessions(projectRoot) {
                 live = new Map();
             }
             const { bindings, forkOf, pinned, notes, priority } = index;
+            // T162 — i campi derivati delle PINNATE, allineati prima della signature.
+            //
+            // Gira a ogni giro e non solo al cambio di stato, perché il buco può
+            // nascere senza che nulla nel deck si muova: a pinnare può essere compass,
+            // dalla modale sulla conversazione in focus, e compass il titolo non lo
+            // conosce. Il deck è l'unico che ce l'ha, quindi è l'unico che può
+            // chiudere quel buco — e lo fa passando, non al momento del gesto.
+            //
+            // Costa solo quando c'è da scrivere: senza pinnate `sidecarGaps` esce
+            // subito, e con un sidecar già allineato ritorna una lista vuota (è
+            // l'invariante di convergenza del modulo — vedi `session-meta.ts`).
+            //
+            // Fuori dal gate della signature di proposito: un sidecar temporaneamente
+            // non scrivibile deve poter essere ritentato al giro dopo, e con lo stato
+            // invariato la signature non cambierebbe mai più.
+            //
+            // Gli append NON entrano nella signature e non producono un re-render: il
+            // deck il titolo lo ha dalla `Session`, che è la fonte. Questi campi
+            // esistono per un lettore che non può aprire un transcript, cioè compass.
+            fillSidecarGaps(projectRoot, {
+                pinned,
+                sessions,
+                bindings,
+                titles: index.titles,
+                models: index.models,
+                core,
+            });
             // La signature copre anche fork, pin, note e marca di priorità: un record
             // di lineage, un toggle di pin, una nota appena scritta o un 🚨 acceso
             // cambiano la lista renderizzata, quindi devono forzare il re-render come
@@ -209,7 +247,7 @@ export function useSessions(projectRoot) {
         reload();
         const id = setInterval(reload, POLL_MS);
         return () => clearInterval(id);
-    }, [projectRoot]);
+    }, [projectRoot, core]);
     return { ...state, reload: () => reloadRef.current() };
 }
 // T61 — conteggio delle Done oltre soglia, su una scala di refresh TUTTA SUA.

package/dist/session-meta.js

@@ -0,0 +1,126 @@
+// T162 — i campi DERIVATI del sidecar: cosa scrivere in `title`/`model` e
+// quando scriverlo.
+//
+// Esiste perché compass ha bisogno del titolo di una conversazione e non può
+// leggerne il transcript: l'estensione gira dentro il processo di gnome-shell,
+// e una lettura sincrona di qualche megabyte blocca il compositore. Il dato
+// deve quindi arrivargli da un file piccolo che già apre — il sidecar — messo
+// lì da chi ce l'ha in mano, cioè il deck, che a ogni tick materializza le
+// `Session` complete di titolo e modello.
+//
+// Il giudizio è separato dalla scrittura: `sidecarGaps` decide e ritorna i
+// record, `fillSidecarGaps` li scrive. La separazione è ciò che rende testabile
+// la parte non ovvia — la convergenza: un derivato che non combacia mai col
+// valore su disco produrrebbe un append a ogni tick del poll, per sempre, senza
+// nessun errore a dirlo.
+//
+// Nessun import da ink/react: il chiamante è un hook, questo modulo no.
+import { modelAlias } from './glyphs.js';
+import { stripProjectCore, stripTaskId } from './session-list.js';
+import { NO_TITLE } from './sessions.js';
+import { NO_SPAWN } from './spawn.js';
+import { appendSessionMeta } from './task-index.js';
+/**
+ * Cap del titolo scritto nel sidecar, in CODE POINT.
+ *
+ * È il `LABEL_MAX` del lettore (compass): oltre, Pango ellissizza comunque, e
+ * il file non deve portare una stringa che nessuno mostrerà per intero. Misura
+ * del preflight: col primo prompt come titolo il massimo osservato era 1.367
+ * caratteri, 36 conversazioni su 604 sopra 120, p90 a 61 — il cap morde su una
+ * minoranza e non tocca il caso normale.
+ *
+ * In code point e non in code unit perché il taglio va fatto senza spezzare una
+ * coppia surrogata: un'emoji tagliata a metà lascia nel file un surrogato
+ * spaiato, cioè un glifo rotto nel menu.
+ */
+export const SIDECAR_TITLE_MAX = 120;
+function capTitle(s) {
+    const cps = [...s];
+    return cps.length <= SIDECAR_TITLE_MAX ? s : cps.slice(0, SIDECAR_TITLE_MAX).join('');
+}
+/**
+ * Il valore da scrivere in `title`: il RESIDUO del titolo, non il titolo
+ * grezzo. `''` = non c'è niente da scrivere.
+ *
+ * I due casi non si trattano allo stesso modo, ed è il punto di questa
+ * funzione:
+ *
+ *  - **con titolo custom** → il titolo di una conversazione nata dal deck È la
+ *    label della tab (`🧵 loom-works · T32 revisione`), composta di tre pezzi
+ *    che il lettore ha già altrove: il progetto (la riga sotto cui la
+ *    conversazione compare), il task id (il campo `taskId` dello stesso
+ *    record) e la nota (il campo `note`). Copiare il grezzo obbligherebbe
+ *    compass a una seconda copia di `stripTaskId`, e a schermo ripeterebbe tre
+ *    volte quello che già si legge.
+ *  - **senza titolo custom** → `title` È il primo prompt, e vale intatto:
+ *    quella è l'unica cosa che dice di cosa si parlava.
+ *
+ * Non è `sessionTitle`: quella, con residuo vuoto, cade sul primo prompt —
+ * dentro il deck è giusto, perché una riga muta non serve a nessuno, ma qui il
+ * primo prompt di una sessione nata dal deck è l'invocazione di una skill
+ * (`/loom-works:recap-status-task T32`), che nel menu non aggiunge nulla. Qui
+ * il residuo vuoto è ASSENZA: non si scrive, e chi legge cade sulla nota.
+ */
+export function sidecarTitle(s, core, taskId) {
+    if (!s.customTitle)
+        return s.title === NO_TITLE ? '' : capTitle(s.title);
+    return capTitle(stripTaskId(stripProjectCore(s.title, core), taskId));
+}
+export function sidecarGaps(input) {
+    const { pinned, sessions, bindings, titles, models, core } = input;
+    if (pinned.size === 0)
+        return [];
+    const byId = new Map(sessions.map((s) => [s.sessionId, s]));
+    const out = [];
+    for (const sessionId of pinned.keys()) {
+        const session = byId.get(sessionId);
+        if (!session)
+            continue; // pinnata stale: niente da cui derivare
+        const gap = { sessionId };
+        const title = sidecarTitle(session, core, bindings.get(sessionId) ?? null);
+        if (title && titles.get(sessionId) !== title)
+            gap.title = title;
+        const model = modelAlias(session.model);
+        if (model && models.get(sessionId) !== model)
+            gap.model = model;
+        if (gap.title !== undefined || gap.model !== undefined)
+            out.push(gap);
+    }
+    return out;
+}
+/**
+ * Scrive i buchi di questo giro. Ritorna quanti record ha appeso — zero è
+ * l'esito normale a regime, non un fallimento.
+ *
+ * `NO_SPAWN` frena anche questa scrittura, ed è lo stesso freno delle tab
+ * Ptyxis per la stessa ragione: il gate su pseudo-terminale avvia il DECK VERO
+ * con cwd la project root del cappello, quindi senza freno ogni run della suite
+ * appende record nel sidecar reale di chi la lancia. Il valore scritto sarebbe
+ * pure corretto — è quello che il deck scriverebbe comunque — ma è una
+ * scrittura fuori dalla sandbox del test, che è precisamente ciò che il freno
+ * esiste per impedire.
+ *
+ * Il freno sta QUI e non nel chiamante perché questa è l'unica sede della
+ * scrittura: nel chiamante sarebbe una guardia che il prossimo scrittore non
+ * vede.
+ *
+ * Un sidecar non scrivibile non è un errore da mostrare: il giro dopo riprova,
+ * e nel frattempo il deck funziona identico — questi campi li legge un altro
+ * processo, non lui.
+ */
+export function fillSidecarGaps(projectRoot, input) {
+    if (NO_SPAWN)
+        return 0;
+    let scritti = 0;
+    try {
+        for (const gap of sidecarGaps(input)) {
+            appendSessionMeta(projectRoot, gap.sessionId, gap);
+            scritti++;
+        }
+    }
+    catch {
+        // sidecar non scrivibile: si riprova al giro dopo, niente a schermo — è
+        // manutenzione di un campo di servizio, non un'azione che l'utente ha chiesto.
+    }
+    return scritti;
+}

package/dist/sessions.js

@@ -54,6 +54,12 @@ const INTERRUPT_MARKER = '[Request interrupted by user';
 function isInterrupt(text) {
     return text.trimStart().startsWith(INTERRUPT_MARKER);
 }
+/** Titolo di una conversazione che non ne ha nessuno — né custom né un primo
+ *  prompt da cui derivarlo. È un SEGNAPOSTO di resa, non un titolo: chi copia
+ *  il titolo altrove (T162, il sidecar per compass) deve poterlo riconoscere e
+ *  trattarlo come assenza, invece di propagare la stringa. Esportato per quello
+ *  — una seconda copia del letterale divergerebbe al primo ritocco del testo. */
+export const NO_TITLE = '(senza titolo)';
 // T110 — valore che il CLI scrive nel campo modello dei record che fabbrica da
 // sé (osservato su `{"type":"text","text":"No response requested."}`). Restano
 // `type:assistant` a tutti gli effetti: chi si fida del campo etichetta la
@@ -248,7 +254,7 @@ export function parseTranscript(content, path, mtime, sizeBytes) {
         cwd,
         gitBranch,
         parentUuid,
-        title: sanitize(customTitle || firstUserText || '(senza titolo)'),
+        title: sanitize(customTitle || firstUserText || NO_TITLE),
         ts: mtime,
         path,
         sizeBytes,

package/dist/task-index.js

@@ -37,6 +37,31 @@ export function appendNote(projectRoot, sessionId, note) {
 export function appendPriority(projectRoot, sessionId, priority) {
     appendSessionRecord(projectRoot, { sessionId, priority });
 }
+/**
+ * T162 — scrive i campi DERIVATI (`title`, `model`) di una conversazione.
+ *
+ * I due vanno in UN record e non in due, anche se il lettore risolve last-wins
+ * per campo e due append darebbero lo stesso esito finale: due record lasciano
+ * un istante in cui su disco lo stato è a metà, e in quel mezzo ci sta il
+ * lettore di compass — che mostrerebbe il titolo nuovo e riprenderebbe col
+ * modello vecchio. È la stessa regola di `writeSessionMarks` lato compass.
+ *
+ * Il record porta SOLO i campi passati: uno che portasse anche l'altro col
+ * valore che aveva prima lo riscriverebbe, e il last-wins trasformerebbe quella
+ * riscrittura in una sovrascrittura di ciò che un altro scrittore ha messo nel
+ * frattempo. Un insieme vuoto non scrive niente, invece di appendere un record
+ * col solo `sessionId` che nessun lettore userebbe.
+ */
+export function appendSessionMeta(projectRoot, sessionId, fields) {
+    const rec = { sessionId };
+    if (fields.title !== undefined)
+        rec.title = fields.title;
+    if (fields.model !== undefined)
+        rec.model = fields.model;
+    if (rec.title === undefined && rec.model === undefined)
+        return;
+    appendSessionRecord(projectRoot, rec);
+}
 // Una sola lettura del JSONL per entrambe le mappe: il deck poll-a l'indice a
 // ogni tick, leggere il file due volte raddoppierebbe l'I/O per nulla.
 // Last-wins per campo (un re-pin dello stesso sessionId sovrascrive), e i due
@@ -48,12 +73,14 @@ export function loadSessionIndex(projectRoot) {
     const pinned = new Map();
     const notes = new Map();
     const priority = new Set();
+    const titles = new Map();
+    const models = new Map();
     let content;
     try {
         content = readFileSync(taskIndexPath(projectRoot), 'utf8');
     }
     catch {
-        return { bindings, forkOf, pinned, notes, priority };
+        return { bindings, forkOf, pinned, notes, priority, titles, models };
     }
     let order = 0; // posizione crescente dei record pinned → rango di pin (D2)
     for (const line of content.split('\n')) {
@@ -108,10 +135,32 @@ export function loadSessionIndex(projectRoot) {
                 else
                     priority.delete(d.sessionId);
             }
+            // T162 — stesso last-wins per campo di `note`, con una differenza che
+            // conta: NESSUNA sanificazione in lettura. `note` la paga perché il deck
+            // la mette nel frame e il file è editabile a mano; qui il valore non
+            // entra nel frame (il deck il titolo lo ha dalla `Session`) e chi lo
+            // rende — compass, sotto Pango — non fa contabilità di colonne.
+            //
+            // Sanificare qui avrebbe un costo suo: il deck decide se riempire il
+            // buco CONFRONTANDO il valore letto con quello derivato, e un valore
+            // riscritto in lettura non combacerebbe mai col derivato — un append a
+            // ogni tick del poll, per sempre, senza nessun errore a dirlo.
+            if (typeof d.title === 'string') {
+                if (d.title)
+                    titles.set(d.sessionId, d.title);
+                else
+                    titles.delete(d.sessionId);
+            }
+            if (typeof d.model === 'string') {
+                if (d.model)
+                    models.set(d.sessionId, d.model);
+                else
+                    models.delete(d.sessionId);
+            }
         }
         catch {
             // riga corrotta → skip
         }
     }
-    return { bindings, forkOf, pinned, notes, priority };
+    return { bindings, forkOf, pinned, notes, priority, titles, models };
 }

package/package.json

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

@@ -13,6 +13,8 @@
 #   continuità     nuova ........ --resume [--fork]
 #   prompt         --prompt-kind none|recap|preflight|run|checkpoint | --prompt <testo>
 #   modello        --model fable|opus|sonnet|haiku
+# Fuori dai quattro, e volutamente non un asse: --new-window, che cambia SOLO il
+# verbo dell'exec finale (tab nella finestra attiva → finestra nuova).
 # Il terzo asse (T56) prima non esisteva: il prompt era una CONSEGUENZA degli
 # altri due (bound ⇒ recap, --no-task ⇒ niente, --resume ⇒ niente), quindi
 # "task-bound SENZA prompt" era inesprimibile e l'unico modo di non avere un
@@ -78,6 +80,17 @@ SESSION_ID=""
 RESUME_ID=""
 NO_TASK=0
 FORK=0
+# T162 — finestra NUOVA invece di una tab nella finestra attiva.
+#
+# `ptyxis --tab` va sempre nella finestra col focus, e va bene per il deck, che
+# è già una tab della finestra del progetto. Un chiamante che vive FUORI da
+# quella finestra — compass, che riapre una conversazione pinnata di un
+# progetto chiuso — non ha una finestra attiva giusta: senza un verbo diverso
+# la tab finisce nella finestra di un altro progetto, o in una a caso.
+#
+# Non è un quinto asse: non cambia cosa gira nella tab, solo dove la tab nasce.
+# Vale identico nei due rami di spawn (inline e profile).
+NEW_WINDOW=0
 TITLE_NOTE=""
 # Vuoto = flag non passato (≠ un default già risolto): serve a distinguere
 # "kind implicito" da "kind chiesto", perché con --no-task il primo è legittimo
@@ -157,6 +170,8 @@ while [[ $# -gt 0 ]]; do
       FORK=1; shift ;;
     --no-task)
       NO_TASK=1; shift ;;
+    --new-window)
+      NEW_WINDOW=1; shift ;;
     *)
       if [[ -z "$TASK" ]]; then TASK="$1"; shift
       else echo "argomento inatteso: '$1'" >&2; exit 2; fi ;;
@@ -190,7 +205,10 @@ USAGE="uso: deck-run <TaskID> [--model <alias>] [--prompt-kind <kind>] [--sessio
                  valore ignoto → fallback sul default, con avviso su stderr
 
   --title-note   nota della conversazione, appesa al titolo tab
-                 (ridotta a lettere/cifre/spazi/-/_, cap 60 char)"
+                 (ridotta a lettere/cifre/spazi/-/_, cap 60 char)
+
+  --new-window   apre una FINESTRA nuova invece di una tab nella finestra
+                 attiva. Per chi chiama da fuori dalla finestra del progetto"
 
 if [[ $NO_TASK -eq 1 && -n "$TASK" ]]; then
   echo "--no-task e <TaskID> sono mutuamente esclusivi" >&2
@@ -669,19 +687,30 @@ IN_TAB_CMD="${LOOM_DECK_INTAB_CMD:-$_default_intab}"
 # vedono comunque quello che vedevano prima.
 printf 'LOOM_DECK_INTAB %s\n' "$IN_TAB_CMD"
 
+# Verbo di apertura (T162): tab nella finestra attiva, o finestra nuova. Una
+# variabile e non due rami duplicati per ogni modalità di spawn — `--new-window`
+# è l'unica differenza fra i due casi.
+if [[ $NEW_WINDOW -eq 1 ]]; then WIN_FLAG="--new-window"; else WIN_FLAG="--tab"; fi
+
 case "$MODE" in
   inline)
     # --tab: tab nella window attiva. -- <cmd>: comando inline nella tab.
     # LOOM_TASK viaggia dentro il comando → nessuna scrittura dconf.
-    exec ptyxis --tab -d "$WORKDIR" -T "${TITLE}" -- bash -lc "$IN_TAB_CMD"
+    exec ptyxis "$WIN_FLAG" -d "$WORKDIR" -T "${TITLE}" -- bash -lc "$IN_TAB_CMD"
     ;;
   profile)
     # --tab-with-profile: riusa il profilo (custom-command FISSO) → per iniettare
     # LOOM_TASK+task va riscritto il custom-command al volo via dconf (stato condiviso).
+    # Con --new-window i due flag convivono: la finestra nasce e il profilo
+    # decide cosa gira nella sua prima tab.
     dpath="/org/gnome/Ptyxis/Profiles/${PROFILE_UUID}/"
     dconf write "${dpath}use-custom-command" true
     dconf write "${dpath}custom-command" "'bash -lc \"${IN_TAB_CMD//\"/\\\"}\"'"
-    exec ptyxis --tab-with-profile="$PROFILE_UUID" -d "$WORKDIR" -T "${TITLE}"
+    if [[ $NEW_WINDOW -eq 1 ]]; then
+      exec ptyxis --new-window --tab-with-profile="$PROFILE_UUID" -d "$WORKDIR" -T "${TITLE}"
+    else
+      exec ptyxis --tab-with-profile="$PROFILE_UUID" -d "$WORKDIR" -T "${TITLE}"
+    fi
     ;;
   *)
     echo "LOOM_DECK_SPAWN_MODE ignoto: '$MODE' (usa 'inline' o 'profile')" >&2