@lamemind/loom-deck 0.67.0 → 0.69.0

package/dist/sane-note.js

@@ -0,0 +1,115 @@
+// T161 — il gemello TypeScript di `_sane_note`, la riduzione che `deck-run`
+// applica a ogni nota del titolo.
+//
+// Perché serve un gemello. La nota del titolo è l'UNICO ingresso di testo libero
+// nel titolo di una tab, quindi `deck-run` non la quota: la RIDUCE a una
+// whitelist chiusa di code point, e tutto ciò che non ci rientra sparisce senza
+// errore. Finché la nota nasceva da un campo scritto al volo, la divergenza fra
+// quello che si legge nel deck e quello che compare nella tab durava il tempo di
+// uno spawn. Da quando un TEMPLATE del titolo si scrive in una pagina e si salva
+// su disco, quella divergenza diventa permanente: il file direbbe una cosa e la
+// tab ne mostrerebbe un'altra, per sempre e senza un errore da nessuna parte.
+//
+// La riduzione si applica quindi QUI, al confine — al salvataggio e alla
+// lettura del blocco `spawn` — così quello che sta nel file è quello che la tab
+// mostrerà.
+//
+// L'ALLINEAMENTO fra i due lati non è assunto: `test/sane-note.test.ts` passa la
+// stessa batteria di input a questa funzione e a `deck-run` vero (via lo shim
+// `ptyxis` di `deck-run.test.ts`) e pretende l'uguaglianza. La whitelist non si
+// allarga — e se un giorno lo facesse, sono tre le sedi da toccare insieme
+// (`deck-run`, questo file, le emoji dei titoli in `spawn-catalog.ts`), col test
+// che fallisce se una resta indietro.
+/**
+ * L'alfabeto ammesso, negato: lettere, cifre, spazio, `_`, `-`, le accentate
+ * italiane e sei emoji.
+ *
+ * Whitelist e non blacklist, come in bash: il titolo finisce dentro apici
+ * singoli in `bash -lc "claude --name '…'"`, ed enumerare i caratteri pericolosi
+ * significa sbagliarne uno.
+ *
+ * Le sei emoji sono nominate una per una e NON come intervallo di code point,
+ * per due ragioni che valgono su entrambi i lati: un'emoji arriva nella tab solo
+ * se il deck la mostra identica in lista, cioè se `sanitize` (`src/width.ts`) la
+ * lascia passare invece di renderla `·`, e quel verdetto si verifica un glifo
+ * alla volta; e l'ordine di un intervallo dentro un bracket expression segue la
+ * collazione della locale, non i code point.
+ *
+ * Il flag `u` non è cosmetico: senza, le quattro emoji astrali entrerebbero
+ * nella classe come coppie di surrogati sciolti, e la riduzione lascerebbe
+ * passare mezzo carattere di qualunque altra emoji che ne condivida il primo.
+ */
+const OUT_OF_ALPHABET = /[^A-Za-z0-9 _àèéìòùÀÈÉÌÒÙ📐🚀📊🏁🧹📏-]/gu;
+/** Cap in CARATTERI (code point), non in byte: a byte un taglio a metà di una
+ *  `à` lascerebbe UTF-8 rotto nel titolo. Largo di proposito — una tab che sfora
+ *  tronca a destra da sola, e il limite serve solo a non spingere fuori vista la
+ *  parte del titolo che compass matcha. */
+export const SANE_CAP = 60;
+/** Un buco di template: `{TASK}`, `{slug}`, `{file}`, `{path}`. La cattura nel
+ *  gruppo è ciò che fa comparire i buchi nei dispari di `split`. */
+const HOLE = /(\{[A-Za-z]+\})/;
+/** Spazi collassati, estremi potati, cap: i tre passi che in bash sono `tr -s`,
+ *  i due `${s#/%}` e `${s:0:60}`. */
+function tidy(s) {
+    const squeezed = s.replace(/ +/g, ' ');
+    const trimmed = squeezed.replace(/^ /, '').replace(/ $/, '');
+    return [...trimmed].slice(0, SANE_CAP).join('');
+}
+/**
+ * La nota ridotta, esattamente come la ridurrebbe `deck-run`.
+ *
+ * Si applica al titolo GIÀ interpolato, cioè al testo che finisce nel sidecar e
+ * in `--title-note`: le due superfici che mostrano quel nome — la riga di lista
+ * del deck, che legge la nota grezza dal sidecar, e la tab Ptyxis — devono
+ * vedere la stessa stringa.
+ */
+export function saneNote(raw) {
+    return tidy(raw.replace(OUT_OF_ALPHABET, ''));
+}
+/**
+ * La stessa riduzione, coi BUCHI preservati.
+ *
+ * Le graffe non sono nell'alfabeto: passare un template da `saneNote` lo
+ * ridurrebbe a `📐 slug`, cioè a un titolo che nomina la parola «slug» invece di
+ * interpolare il nome della task. Il template si riduce comunque — è testo
+ * scritto a mano, e il resto della riga deve sopravvivere alla tab — ma i buchi
+ * attraversano intatti e vengono riempiti dopo.
+ *
+ * Fuori dai buchi il comportamento è identico a `saneNote`, compresi collasso
+ * degli spazi, potatura e cap: un template senza buchi passa dalle stesse regole
+ * di una nota qualunque.
+ */
+export function saneTemplate(raw) {
+    return tidy(raw
+        .split(HOLE)
+        .map((part, i) => (i % 2 === 1 ? part : part.replace(OUT_OF_ALPHABET, '')))
+        .join(''));
+}
+/**
+ * Riempie i buchi di un template. `null` quando un buco nominato non ha un
+ * valore da mettere.
+ *
+ * Il `null` non è difensivo, è il comportamento: un titolo `📐 {slug}` su una
+ * task il cui file non si trova diventerebbe `📐` — un prefisso solo, uguale per
+ * ogni task, che è peggio di nessun titolo. Chi chiama riceve `null` e apre la
+ * conversazione senza nota, che è ciò che faceva il vecchio `fallbackTitle`
+ * quando il task file mancava.
+ *
+ * I buchi non dichiarati dall'azione restano LETTERALI e non fanno fallire
+ * l'interpolazione: non sono un valore mancante, sono testo che l'utente ha
+ * scritto — e il giro di riduzione dopo l'interpolazione toglierà le graffe.
+ */
+export function interpolate(template, values) {
+    let missing = false;
+    const filled = template.replace(/\{([A-Za-z]+)\}/g, (whole, name) => {
+        if (!(name in values))
+            return whole;
+        const v = values[name];
+        if (!v) {
+            missing = true;
+            return '';
+        }
+        return v;
+    });
+    return missing ? null : filled;
+}

package/dist/session-meta.js

@@ -0,0 +1,108 @@
+// 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.
+//
+// Modulo PURO come `session-list.ts`: nessun I/O, nessun import da ink/react.
+// Decide COSA appendere e ritorna i record; il chiamante 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.
+import { modelAlias } from './glyphs.js';
+import { stripProjectCore, stripTaskId } from './session-list.js';
+import { NO_TITLE } from './sessions.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));
+}
+/**
+ * I buchi da riempire in questo giro: per ogni conversazione PINNATA, i campi
+ * derivati che nel sidecar mancano o non corrispondono più al valore corrente.
+ *
+ * Solo le pinnate, e non tutte le conversazioni del progetto, perché sono le
+ * sole che un lettore esterno mostra: il resto sarebbe churn su un file
+ * append-only, un record per conversazione per ogni deck che si apre.
+ *
+ * Tre cose che non producono un append, e nessuna delle tre è un errore:
+ *  - una pinnata STALE (il transcript non c'è più) — nessuna `Session`, quindi
+ *    nessun valore da cui derivare;
+ *  - un titolo derivato VUOTO — è l'assenza di P1, e appenderlo scriverebbe la
+ *    cancellazione di un campo che nessuno ha chiesto di cancellare;
+ *  - un modello non riconducibile a un alias (`''` o fuori famiglia) — chi
+ *    riprende cadrà sulla propria cascata, che è meglio di un alias inventato.
+ *
+ * La CONVERGENZA è l'invariante da tenere: il confronto avviene fra il valore
+ * derivato e il valore letto dal sidecar senza riscritture in mezzo (nessuna
+ * sanificazione in lettura, cap applicato da questo lato una volta sola),
+ * quindi un buco riempito resta riempito e il giro successivo non trova niente
+ * da fare.
+ */
+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;
+}

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/spawn-catalog.js

@@ -0,0 +1,338 @@
+// Il CATALOGO delle azioni di spawn: per ogni cosa che il deck sa aprire, un id
+// stabile e la terna titolo/modello/prompt con la sorgente di ciascun valore.
+//
+// Prima di questo modulo un'azione di spawn non era un'entità: era un tasto che
+// chiamava una funzione, e ogni funzione decideva da sé — nel proprio punto di
+// chiamata — quale modello e quale prompt passare. Il modello veniva da quattro
+// sorgenti diverse (il catalogo `prompt-catalog` per kind, il transcript per
+// resume e fork, un selettore vivo per la nuda, un letterale in `actions.ts` per
+// drain e srotolamento) e non esisteva nessun posto in cui leggerne l'elenco.
+// Senza quell'elenco non c'è nessuna tabella da mostrare, e nessuna riga che un
+// override di progetto possa indirizzare.
+//
+// DATO PURO: nessuna lettura di file, nessun React, nessun import di
+// `spawn.ts`. La dipendenza va in un verso solo (coding-standards: nessun modulo
+// estratto importa il file da cui è stato estratto) — `spawn.ts`, `actions.ts`,
+// `sheet.ts`, `glyphs.ts` e `prompt-catalog.ts` importano da qui.
+//
+// Chi COMPONE i default con gli override di progetto è `spawn-config.ts`: lì
+// vivono la lettura del file, la validazione al confine e la risoluzione della
+// terna. Qui ci sono solo i default del deck.
+/**
+ * `recap` → la sotto-skill giusta, quando chi spawna SA se la task è un cappello.
+ *
+ * `recap` resta il kind onesto per chi non lo sa: punta al dispatcher, che
+ * risolve la task e classifica da sé. È il caso degli acceleratori della lista,
+ * dove il deck ha in mano solo `tasks.md` — e lì il `Size` non c'è. Il DETAIL
+ * invece il task file l'ha già letto, quindi può saltare il giro e pagare un
+ * turno di modello in meno.
+ *
+ * Non è una classificazione duplicata: il criterio (`Size: Epic`) resta uno solo
+ * e sta in `taskIsEpic`, che legge lo stesso campo che leggerebbe il dispatcher.
+ * Quello che si evita è il RITARDO, non il giudizio.
+ *
+ * T161 — la stessa funzione è anche il ponte dal detail al catalogo: gli id
+ * delle sette azioni su task SONO i sette kind, quindi specializzare un kind
+ * significa già scegliere la riga di catalogo (e l'override che la indirizza).
+ *
+ * Ogni kind diverso da `recap` passa intatto: la specializzazione è un caso, non
+ * una trasformazione da applicare a tutti.
+ */
+export function specializeRecap(kind, epic) {
+    if (kind !== 'recap')
+        return kind;
+    return epic ? 'recap-epic' : 'recap-task';
+}
+// L'ordine È il giro di `tab` nel detail, non una preferenza di lettura:
+// cambiarlo sposta le voci sotto le dita di chi le ha imparate. Fino a T111 era
+// anche il binding delle cifre `1`-`4`, passate poi al campo nota.
+export const MODELS = ['fable', 'opus', 'sonnet', 'haiku'];
+/** Il valore è uno dei quattro alias? Guardia del confine: la usano il parser
+ *  del catalogo dati e quello del blocco `spawn` del file di progetto, che
+ *  leggono entrambi testo scritto a mano. */
+export function isModelKind(v) {
+    return typeof v === 'string' && MODELS.includes(v);
+}
+// Default del selettore e FALLBACK ultimo di ogni risoluzione. Duplicato del
+// default di deck-run e non letto da lì: il deck deve poter MOSTRARE la
+// selezione iniziale prima di spawnare alcunché, e un valore che si conosce solo
+// a spawn avvenuto non è mostrabile.
+//
+// T161 — non è più il default di nessuna azione in particolare: ogni riga del
+// catalogo porta il proprio (o lo prende dal catalogo dati), e qui si cade solo
+// quando nessuna delle due sorgenti ha una voce.
+export const MODEL_DEFAULT = 'fable';
+// T152 — `recap-status-project` non è una chiave di `prompt-catalog` (le chiavi
+// lì sono i valori di `--prompt-kind`, e lo spawn headless non ne passa mai
+// uno): il suo default vive nella riga `project-status` di questo catalogo.
+// Resta `opus` mentre i tre recap stanno su fable, ed è l'unico recap che gira
+// in headless (`-p`), senza nessuno che ne legga l'esito mentre si forma e possa
+// rilanciarlo — il testo prodotto è il deliverable, e viene riletto da disco
+// anche giorni dopo.
+export const PROJECT_STATUS_MODEL = 'opus';
+// T66 — le azioni del detail. Non sono un catalogo a parte: ognuna nomina una
+// riga di questo catalogo, per kind, e tutte passano dallo stesso `spawnForTask`
+// dei CTRL della lista — una superficie in più, zero percorsi di spawn in più.
+//
+// L'etichetta è distinta dal kind dove il kind è il nome del MECCANISMO e
+// l'etichetta quello dell'INTENZIONE: `none` è "aprire la task a mani nude",
+// `recap` è "vedere a che punto sta".
+export const DETAIL_ACTIONS = [
+    { kind: 'none', label: 'open' },
+    { kind: 'preflight', label: 'preflight' },
+    { kind: 'run', label: 'run' },
+    { kind: 'recap', label: 'status' },
+    { kind: 'checkpoint', label: 'checkpoint' },
+];
+// T117 — selezione DIRETTA di un'azione con la sua iniziale (`o p r s c`),
+// accanto allo scorrimento `←→`. Derivate dalle label e non cablate: una voce
+// aggiunta al catalogo porta con sé la propria lettera, invece di lasciare
+// indietro una seconda lista.
+// Il vincolo che la derivazione impone al catalogo: le iniziali devono restare
+// 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]));
+export const SPAWN_FIELDS = ['title', 'model', 'prompt'];
+/**
+ * Il prompt cablato della sessione che srotola l'hard-wrap di un path.
+ *
+ * Le tre cose che dice sono le tre che rendono l'operazione reversibile e
+ * verificabile — backup fuori dal repo, rapporto, commit solo se il diff è
+ * chiaramente innocuo. Era cablato in `wrap-scan.ts` e da T161 è il DEFAULT di
+ * una riga del catalogo: resta la stessa frase, ma ora è sovrascrivibile dal
+ * progetto invece che dal solo sorgente.
+ *
+ * Nessun apice singolo, come i template di `prompt-catalog`: il testo finisce
+ * dentro `'…'` nel comando passato a `bash -lc`, e `deck-run` lo quota, ma un
+ * apice qui sarebbe comunque una scrittura da rileggere due volte.
+ */
+const UNWRAP_PROMPT = 'lancia md-wrap modo apply su {path} e backup in cartella tmp dedicata. ' +
+    'verifica risultato e fai rapporto. se le modifiche sono tutte chiaramente safe, ' +
+    'puoi committare direttamente';
+/**
+ * Le UNDICI azioni configurabili, nell'ordine in cui la pagina le elenca.
+ *
+ * Il perimetro è quello di D1: entra una riga se ha almeno una cella editabile.
+ * Ne restano fuori resume e fork — lì il modello non è una preferenza ma
+ * un'EREDITÀ, letta dal transcript della conversazione d'origine, e un override
+ * sarebbe una cella che mente — insieme a `create-task` e `clean-tasks`, che non
+ * passano `--model` e girano sul default del CLI (dargliene una sarebbe un
+ * cambio di comportamento fatto per riempire una riga), al terminale e alle voci
+ * `launch`, che non sono sessioni Claude e non hanno né modello né prompt.
+ *
+ * T156 — le emoji dei titoli sono ASTRALI (code point ≥ U+10000) per necessità,
+ * non per gusto: `sanitize` (`src/width.ts`) sostituisce con `·` ogni glifo su
+ * cui le due contabilità di larghezza divergono, e le emoji del BMP a
+ * presentazione testo divergono sempre. Le stesse sei stanno nella whitelist di
+ * `_sane_note` in `deck-run` e nel suo gemello `src/sane-note.ts`: un'emoji
+ * cambiata qui e non là sparisce fra la tabella e la tab, senza errore.
+ */
+export const SPAWN_ACTIONS = [
+    {
+        id: 'none',
+        label: 'apri la task',
+        surface: 'detail o · ⏎⏎',
+        kind: 'none',
+        // D2 di T150 — nessun prefisso: `open` è "nessuna azione", e inventargliene
+        // uno contraddirebbe l'intenzione di chi la sceglie.
+        title: '{slug}',
+        model: null,
+        prompt: '',
+        holes: ['TASK', 'slug'],
+        fixed: {},
+    },
+    {
+        id: 'recap',
+        label: 'stato · dispatcher',
+        surface: 'lista ^K',
+        kind: 'recap',
+        // P3 di T150 — le tre varianti di recap condividono il prefisso: la
+        // specializzazione sceglie quale skill parte, non cosa si sta chiedendo.
+        title: '📊 {slug}',
+        model: null,
+        prompt: null,
+        holes: ['TASK', 'slug'],
+        fixed: {},
+    },
+    {
+        id: 'recap-task',
+        label: 'stato task',
+        surface: 'detail s',
+        kind: 'recap-task',
+        title: '📊 {slug}',
+        model: null,
+        prompt: null,
+        holes: ['TASK', 'slug'],
+        fixed: {},
+    },
+    {
+        id: 'recap-epic',
+        label: 'stato epica',
+        surface: 'detail s · cappello',
+        kind: 'recap-epic',
+        title: '📊 {slug}',
+        model: null,
+        prompt: null,
+        holes: ['TASK', 'slug'],
+        fixed: {},
+    },
+    {
+        id: 'preflight',
+        label: 'preflight',
+        surface: 'detail p · lista ^P',
+        kind: 'preflight',
+        title: '📐 {slug}',
+        model: null,
+        prompt: null,
+        holes: ['TASK', 'slug'],
+        fixed: {},
+    },
+    {
+        id: 'run',
+        label: 'run',
+        surface: 'detail r · lista ^R',
+        kind: 'run',
+        title: '🚀 {slug}',
+        model: null,
+        prompt: null,
+        holes: ['TASK', 'slug'],
+        fixed: {},
+    },
+    {
+        id: 'checkpoint',
+        label: 'checkpoint',
+        surface: 'detail c',
+        kind: 'checkpoint',
+        title: '🏁 {slug}',
+        model: null,
+        prompt: null,
+        holes: ['TASK', 'slug'],
+        fixed: {},
+    },
+    {
+        // T42/T154 — la sessione a mani nude. Configurabile sul solo modello (P12):
+        // non pinna un `sessionId` e non scrive nel sidecar, quindi un titolo
+        // comparirebbe nella tab e non in lista — la divergenza che `bareArgs`
+        // esiste per non avere — e un prompt la renderebbe non nuda.
+        id: 'bare',
+        label: 'sessione nuda',
+        surface: 'tasto c',
+        kind: null,
+        title: null,
+        model: MODEL_DEFAULT,
+        prompt: '',
+        holes: [],
+        fixed: {
+            title: 'nessun sessionId pinnato',
+            prompt: 'la renderebbe non nuda',
+        },
+    },
+    {
+        // T134 — il drain di un file inbox. Il prompt lo compone `inboxPrompt`
+        // (`src/inbox.ts`), che è l'unico posto in cui vive la mappa natura →
+        // skill: un template unico non saprebbe esprimerla, e spezzare la riga in
+        // una per natura contraddirebbe il perimetro di D1.
+        id: 'drain',
+        label: 'drain di un file inbox',
+        surface: 'pane inbox ⏎⏎',
+        kind: null,
+        title: '🧹 {file}',
+        model: MODEL_DEFAULT,
+        prompt: null,
+        holes: ['file'],
+        fixed: { prompt: 'natura del file' },
+    },
+    {
+        // T134 — lo srotolamento dell'hard-wrap. `sonnet` e non il default: è una
+        // passata meccanica con un verificatore deterministico dietro (`md-wrap
+        // --apply` confronta le due versioni normalizzate e rimette indietro il
+        // file se differiscono), quindi il giudizio chiesto al modello è leggere un
+        // diff e decidere se committarlo — non progettare niente.
+        id: 'unwrap',
+        label: 'srotolamento hard-wrap',
+        surface: 'lista ^W ⏎',
+        kind: null,
+        title: '📏 {path}',
+        model: 'sonnet',
+        prompt: UNWRAP_PROMPT,
+        holes: ['path'],
+        fixed: {},
+    },
+    {
+        // T121 — il recap di progetto, headless (`claude -p`): nessuna tab, quindi
+        // nessun titolo da configurare.
+        id: 'project-status',
+        label: 'project status',
+        surface: 'tasto ^G',
+        kind: null,
+        title: null,
+        model: PROJECT_STATUS_MODEL,
+        prompt: '/loom-works:recap-status-project',
+        holes: [],
+        fixed: { title: 'headless: nessuna tab' },
+    },
+];
+/**
+ * Valori d'esempio dei buchi, per l'ANTEPRIMA dell'area di compilazione.
+ *
+ * La cella della tabella mostra il template grezzo (`🚀 {slug}`), l'area mostra
+ * come verrebbe reso: senza l'esempio un template si scrive alla cieca, e
+ * l'effetto si scopre alla prima conversazione aperta.
+ *
+ * Sono valori FINTI e dichiarati tali dalla pagina, non la task selezionata: la
+ * pagina non ha una selezione — si apre da qualunque punto del deck — e legare
+ * l'anteprima a ciò che capita di avere sotto il caret la renderebbe diversa a
+ * ogni apertura, per la stessa configurazione.
+ */
+export const EXAMPLE_HOLES = {
+    TASK: 'T42',
+    slug: 'esempio di task',
+    file: 'T42-nozioni',
+    path: 'runtime reference',
+};
+/**
+ * I valori sono quelli che i FORNITORI dei buchi producono davvero, non testo
+ * grezzo: lo slug arriva dal nome del task file coi trattini già sciolti in
+ * spazi, il basename dell'inbox senza `.md`, il path già reso in parole. Un
+ * esempio con dentro un `/` o un `.` mostrerebbe l'effetto della riduzione — le
+ * parole saldate — su un caso che allo spawn non si presenta mai, e chi lo
+ * legge correggerebbe un titolo che non è rotto.
+ */
+const BY_ID = new Map(SPAWN_ACTIONS.map((a) => [a.id, a]));
+/** L'azione di un id, o `undefined` per un id che il catalogo non conosce — il
+ *  caso di un override scritto a mano per un'azione che non esiste più. */
+export function spawnAction(id) {
+    return BY_ID.get(id);
+}
+/** L'id è nel catalogo? Guardia del parser degli override. */
+export function isSpawnActionId(id) {
+    return typeof id === 'string' && BY_ID.has(id);
+}
+/** Le celle editabili di una riga: il complemento di `fixed`, derivato e mai
+ *  scritto a mano. */
+export function editableFields(action) {
+    return SPAWN_FIELDS.filter((f) => !(f in action.fixed));
+}
+/** Il segnaposto di una cella editabile ma a vuoto. Il vuoto è un valore
+ *  legittimo e distinto dall'assenza (P15): un titolo svuotato significa
+ *  «nessuna nota», un prompt svuotato «nessun prompt». */
+const EMPTY_LABEL = {
+    title: '(nessun titolo)',
+    model: '(nessun modello)',
+    prompt: '(nessun prompt)',
+};
+export function spawnCell(action, field, 
+/** Il valore risolto: `null` quando la cella non ne ha uno. */
+value, 
+/** Il valore viene da un override di progetto. */
+overridden) {
+    const reason = action.fixed[field];
+    if (reason !== undefined) {
+        return { text: `(${reason})`, editable: false, origin: 'fisso', placeholder: true };
+    }
+    const origin = overridden ? 'override' : 'default';
+    if (value === null || value === '') {
+        return { text: EMPTY_LABEL[field], editable: true, origin, placeholder: true };
+    }
+    return { text: value, editable: true, origin, placeholder: false };
+}