@lamemind/loom-deck 0.75.0 → 0.77.0

package/dist/tab-compose.js

@@ -0,0 +1,233 @@
+// T176 — la COMPOSIZIONE di una tab di conversazione: dai quattro assi di
+// `deck-run` (`tab-args.ts`) a titolo, flag di `claude`, env di sessione e
+// comando in-tab.
+//
+// Un composer solo per Linux e Windows (D1 preflight). Cambia per piattaforma
+// solo CHI riceve il risultato: su Linux una riga per `bash -lc` dentro una tab
+// Ptyxis, su Windows l'argv di `claude` in una variabile d'ambiente letta dal
+// wrapper della tab (`windows-terminal.ts`). Titolo, modello, permission mode e
+// prompt si risolvono qui una volta, per entrambe.
+//
+// Modulo PURO: il file di progetto, il catalogo dei prompt e l'env arrivano già
+// letti. Le regole e i messaggi sono quelli dello script bash che questo modulo
+// ha sostituito, e il gate di parità su Linux (`test/deck-run.test.ts`) li
+// misura sul comando in-tab.
+import { saneNote } from './sane-note.js';
+import { MODEL_DEFAULT, MODELS } from './spawn-catalog.js';
+import { shellQuote } from './spawn.js';
+export const PERMISSION_MODES = ['acceptEdits', 'auto', 'bypassPermissions', 'manual', 'dontAsk', 'plan'];
+/** L'alfabeto della chiave di stato: il valore entra in `bash -lc "…"` e il
+ *  file di progetto è editabile a mano, quindi si scarta invece di quotare. */
+const STATE_KEY_RE = /^[A-Za-z0-9_-]+$/;
+/**
+ * Un campo del file di progetto come lo leggeva `jq -r '.campo // empty'`:
+ * `null`, `false` o assente danno vuoto, una stringa passa com'è, ogni altro
+ * valore diventa il suo JSON (`jq -r` stampa così numeri e oggetti).
+ */
+function configField(config, key) {
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        return '';
+    const v = config[key];
+    if (v === undefined || v === null || v === false)
+        return '';
+    return typeof v === 'string' ? v : JSON.stringify(v);
+}
+/**
+ * La label del progetto, `{emoji} {name}`: la chiave con cui compass riconosce
+ * la finestra cercando nel titolo della tab attiva. Vuota se il file manca o
+ * non porta entrambi i campi, e il titolo ricade su `cc`.
+ */
+export function projectLabel(config) {
+    const emoji = configField(config, 'emoji');
+    const name = configField(config, 'name');
+    return emoji && name ? `${emoji} ${name}` : '';
+}
+/**
+ * Il titolo della tab: label + `· <task>` + nota + `· fork`.
+ *
+ * La label sta in TESTA perché il match di compass è un `.includes` sulla
+ * chiave, e tutto il resto va in coda per non spezzarla. Il suffisso task
+ * distingue le tab di più task, la nota (T64) quelle di più conversazioni sulla
+ * stessa task, `· fork` (T28) un ramo dalla sua origine. La nota è l'unico testo
+ * libero del titolo: non si quota, si RIDUCE (`saneNote`) — e ridotta a vuoto
+ * non lascia nessun suffisso.
+ */
+export function tabTitle(req, label) {
+    let title;
+    if (req.noTask)
+        title = label || 'cc';
+    else
+        title = label ? `${label} · ${req.task}` : `cc ${req.task}`;
+    if (req.titleNote) {
+        const note = saneNote(req.titleNote);
+        if (note)
+            title = `${title} ${note}`;
+    }
+    if (req.fork)
+        title = `${title} · fork`;
+    return title;
+}
+/**
+ * Il permission mode: env `LOOM_DECK_PERMISSION_MODE` > campo del file > `manual`.
+ *
+ * Passato SEMPRE al CLI, anche `manual`: lo spawn resta deterministico invece
+ * di dipendere da un default che cambia fra versioni. Un valore fuori elenco
+ * non arriva al CLI — produrrebbe una tab con un comando rotto — e degrada a
+ * `manual` con un avviso.
+ */
+function permissionMode(ctx, warnings) {
+    const raw = ctx.env.LOOM_DECK_PERMISSION_MODE || configField(ctx.config, 'permissionMode');
+    if (!raw)
+        return 'manual';
+    if (PERMISSION_MODES.includes(raw))
+        return raw;
+    warnings.push(`permissionMode ignoto: '${raw}' → fallback 'manual'`);
+    return 'manual';
+}
+/**
+ * Il kind di catalogo effettivo: solo sul ramo bound senza prompt letterale.
+ * `--no-task` e `--prompt` non hanno una riga di catalogo da consultare, né per
+ * il prompt né per il modello.
+ */
+function catalogKind(req) {
+    return !req.promptGiven && !req.noTask ? req.promptKind || 'recap' : '';
+}
+/**
+ * Il modello: `--model` > env `LOOM_DECK_MODEL` > modello del kind nel catalogo
+ * > `MODEL_DEFAULT`.
+ *
+ * Il deck TUI passa SEMPRE `--model` già risolto (T161), quindi dal deck la
+ * cascata si ferma al primo gradino: i tre sotto servono a chi invoca a mano.
+ * Le voci restano ALIAS fino dentro `claude --model`: un id versionato cablato
+ * qui diventerebbe un modello inesistente al primo cambio di generazione. Un
+ * valore ignoto degrada al default con un avviso — arriverebbe al CLI, che lo
+ * rifiuterebbe all'avvio.
+ */
+function modelOf(req, ctx, warnings) {
+    let model = req.model || ctx.env.LOOM_DECK_MODEL || '';
+    const kind = catalogKind(req);
+    if (!model && kind && kind !== 'none')
+        model = ctx.catalog.get(kind)?.model ?? '';
+    if (!model)
+        return MODEL_DEFAULT;
+    if (MODELS.includes(model))
+        return model;
+    warnings.push(`modello ignoto: '${model}' → fallback '${MODEL_DEFAULT}' (usa ${MODELS.join('|')})`);
+    return MODEL_DEFAULT;
+}
+/**
+ * Il prompt iniziale, vuoto = nessun prompt.
+ *
+ * `--prompt` vince su tutto ed è usato così com'è. Una sessione nuda senza
+ * `--prompt` non ha prompt: il default `recap` del catalogo non si applica,
+ * perché ogni template interpola `{TASK}` e con la task vuota sarebbe un
+ * comando monco. Sul ramo bound il kind sceglie il template; un catalogo che
+ * non ha la voce è un'installazione mutila, e la sessione parte senza prompt
+ * dicendolo. `LOOM_DECK_ENTER_PROMPT` vince sul kind, tranne su `none`.
+ */
+function promptOf(req, ctx, warnings) {
+    if (req.promptGiven)
+        return req.promptText;
+    if (req.noTask)
+        return '';
+    const kind = catalogKind(req);
+    if (kind === 'none')
+        return '';
+    const enter = ctx.env.LOOM_DECK_ENTER_PROMPT;
+    const template = ctx.catalog.get(kind)?.template;
+    if (template === undefined) {
+        warnings.push(`catalogo prompt non leggibile ('${ctx.catalogPath}'): sessione senza prompt iniziale`);
+    }
+    const text = enter || template || '';
+    return text.replaceAll('{TASK}', req.task);
+}
+/**
+ * La chiave di stato per compass, solo su Linux: env `LOOM_DECK_STATE_PROFILE`
+ * (anche vuota = nessun annuncio) > `id` del file di progetto.
+ *
+ * Lo stato di una sessione viaggia verso compass via D-Bus keyed su
+ * `PTYXIS_PROFILE`, e compass lo associa a un progetto solo se la chiave è l'`id`
+ * di un progetto del registry. Senza la variabile forzata in-tab, Ptyxis ne
+ * esporterebbe una col valore del profilo di default, e il badge resterebbe
+ * fermo senza nessun errore. Il nome della variabile è storico: non contiene
+ * l'UUID di un profilo. Su Windows compass non esiste, e la chiave non serve.
+ */
+function stateKey(ctx, warnings) {
+    if (ctx.platform === 'win32')
+        return '';
+    const raw = ctx.env.LOOM_DECK_STATE_PROFILE !== undefined
+        ? ctx.env.LOOM_DECK_STATE_PROFILE
+        : configField(ctx.config, 'id');
+    if (raw && !STATE_KEY_RE.test(raw)) {
+        warnings.push(`profilo di stato ignorato (caratteri non ammessi): '${raw}'`);
+        return '';
+    }
+    return raw;
+}
+/** Un testo come UN argomento di una shell POSIX: sempre fra apici singoli, con
+ *  l'apice stesso chiuso, escapato e riaperto (`'\''`). Dentro gli apici nessun
+ *  altro carattere resta speciale, newline compresi. */
+export function posixQuote(text) {
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * La composizione intera.
+ *
+ * Ordine degli argomenti di `claude`: nome, permission mode e modello prima dei
+ * flag di continuità, il prompt sempre ultimo. Il modello sta accanto al
+ * permission mode perché sono la stessa cosa — la scelta di chi apre la
+ * sessione — e non una proprietà della task né della ripresa.
+ *
+ * Su una ripresa il prompt salta anche sul ramo bound: riprendere significa
+ * continuare la conversazione, non iniettarle un messaggio nuovo; il fork è una
+ * ripresa con id nuovo e ricade nello stesso ramo. Il `--session-id` vale invece
+ * anche sul ramo nudo: nel fork di una sessione spot rende noto in anticipo
+ * l'id del ramo, senza il quale il lineage non sarebbe registrabile.
+ */
+export function composeTab(req, ctx) {
+    const warnings = [];
+    const title = tabTitle(req, projectLabel(ctx.config));
+    const mode = permissionMode(ctx, warnings);
+    const model = modelOf(req, ctx, warnings);
+    const key = stateKey(ctx, warnings);
+    const prompt = promptOf(req, ctx, warnings);
+    const withPrompt = prompt !== '' && !req.resumeId;
+    const flags = ['--permission-mode', mode, '--model', model];
+    if (req.sessionId)
+        flags.push('--session-id', req.sessionId);
+    if (req.resumeId)
+        flags.push('--resume', req.resumeId);
+    if (req.fork)
+        flags.push('--fork-session');
+    const sessionEnv = {};
+    if (key)
+        sessionEnv.PTYXIS_PROFILE = key;
+    if (!req.noTask)
+        sessionEnv.LOOM_TASK = req.task;
+    // La riga in-tab nella grafia storica dello script: ogni flag seguito da uno
+    // spazio, il prompt in coda fra apici. Il gate di parità su Linux confronta
+    // questa riga byte per byte, spazio finale compreso quando il prompt manca.
+    const envPrefix = Object.entries(sessionEnv)
+        .map(([k, v]) => `${k}=${shellQuote(v)} `)
+        .join('');
+    const flagText = flags.map((f) => `${f} `).join('');
+    const inTab = `${envPrefix}claude --name ${posixQuote(title)} ${flagText}` +
+        (withPrompt ? posixQuote(prompt) : '');
+    return {
+        title,
+        claudeArgs: ['--name', title, ...flags, ...(withPrompt ? [prompt] : [])],
+        sessionEnv,
+        inTab,
+        warnings,
+    };
+}
+/**
+ * L'argv di Ptyxis: una tab nella finestra attiva (quella col focus, cioè il
+ * deck), o una finestra nuova con `--new-window` (T162) per chi chiama da fuori
+ * dalla finestra del progetto. Il comando gira dentro `bash -lc`, e le env di
+ * sessione viaggiano DENTRO il comando: `ptyxis --tab` consegna la tab
+ * all'istanza già aperta, che non eredita l'env di chi la chiede.
+ */
+export function ptyxisArgv(newWindow, workdir, title, inTab) {
+    return [newWindow ? '--new-window' : '--tab', '-d', workdir, '-T', title, '--', 'bash', '-lc', inTab];
+}

package/dist/tab-launch.js

@@ -0,0 +1,169 @@
+// T176 — `deck-run` come programma: legge l'argv, compone la tab, la annuncia e
+// la apre nel terminale della piattaforma.
+//
+// Il contratto verso chi lo lancia è quello dello script bash che ha sostituito:
+//  - uscita 2 e messaggio su stderr per un errore d'uso, nessun annuncio;
+//  - prima di aprire la tab, su stdout, la riga `LOOM_DECK_INTAB <comando>` col
+//    comando che gira nella tab — il deck la legge e la mostra nella riga di
+//    stato (`onInTabCommand`), invece di ricomporla;
+//  - poi il terminale, e l'uscita è la sua: `ptyxis --tab` e `wt.exe new-tab`
+//    escono appena hanno consegnato la tab all'istanza già aperta.
+//
+// L'I/O verso l'esterno passa da `DeckRunIo`, così il test della composizione
+// completa non apre tab. Il filesystem no: file di progetto e catalogo si
+// leggono dal disco anche nei test, su cartelle temporanee.
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { constants } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isUsageError, parseTabArgs } from './tab-args.js';
+import { composeTab, ptyxisArgv } from './tab-compose.js';
+import { loadPromptCatalog, PROMPT_CATALOG } from './prompt-catalog.js';
+import { configFilePath } from './config.js';
+import { resolveGitBash } from './git-bash.js';
+import { semicolonArg, TAB_ARGV_ENV, windowsTabEnv, WT_CMD, wtNewTabArgs, wtProfile, } from './windows-terminal.js';
+/** Il wrapper che gira dentro una tab di Windows Terminal, nel build: lo esegue
+ *  il node del deck, e `src/` sotto `tsx` non ha un `.js` da dargli. */
+export const TAB_WRAPPER_JS = join(dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'tab-wrapper.js');
+/**
+ * La cartella di lavoro della tab: `LOOM_DECK_WORKDIR`, altrimenti la cartella
+ * corrente.
+ *
+ * Su Linux la cartella corrente è quella LOGICA, come il `$PWD` di bash: `PWD`
+ * se punta alla stessa cartella di `cwd` (un symlink resta un symlink nel
+ * titolo e nel `-d` di Ptyxis), `cwd` altrimenti. Su Windows `PWD` arriva da
+ * Git Bash in forma `/c/…`, che `wt -d` non capisce: vale solo `cwd`.
+ */
+export function workdirOf(io) {
+    if (io.env.LOOM_DECK_WORKDIR)
+        return io.env.LOOM_DECK_WORKDIR;
+    const pwd = io.env.PWD;
+    if (io.platform !== 'win32' && pwd) {
+        try {
+            const a = statSync(pwd);
+            const b = statSync(io.cwd);
+            if (a.dev === b.dev && a.ino === b.ino)
+                return pwd;
+        }
+        catch {
+            // PWD che non esiste più → la cartella vera
+        }
+    }
+    return io.cwd;
+}
+/** La cartella che contiene `.claude/loom-works.json`, risalendo da `start`
+ *  fino alla radice compresa; `null` fuori da un progetto loom. */
+export function findProjectRoot(start) {
+    let dir = resolve(start);
+    for (;;) {
+        if (existsSync(configFilePath(dir)))
+            return dir;
+        const up = dirname(dir);
+        if (up === dir)
+            return null;
+        dir = up;
+    }
+}
+/** Il file di progetto parsato, o `null` se manca o è malformato: il titolo
+ *  ricade su `cc`, il permission mode su `manual`, e lo spawn parte lo stesso. */
+function loadConfig(root) {
+    if (!root)
+        return null;
+    try {
+        return JSON.parse(readFileSync(configFilePath(root), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Un argv come una shell POSIX lo leggerebbe: per le diagnostiche. */
+function describe(cmd, args) {
+    return [cmd, ...args].map((a) => (/^[\w@%+=:,./\\-]+$/.test(a) ? a : JSON.stringify(a))).join(' ');
+}
+export async function runDeckRun(argv, io) {
+    const req = parseTabArgs(argv);
+    if (isUsageError(req)) {
+        for (const line of req.lines)
+            io.stderr(`${line}\n`);
+        return 2;
+    }
+    const workdir = workdirOf(io);
+    const catalogPath = io.env.LOOM_DECK_PROMPT_CATALOG || PROMPT_CATALOG;
+    const plan = composeTab(req, {
+        env: io.env,
+        config: loadConfig(findProjectRoot(workdir)),
+        catalog: loadPromptCatalog(catalogPath),
+        catalogPath,
+        platform: io.platform,
+    });
+    for (const w of plan.warnings)
+        io.stderr(`${w}\n`);
+    let cmd;
+    let args;
+    let env;
+    if (io.platform === 'win32') {
+        cmd = WT_CMD;
+        args = wtNewTabArgs({
+            newWindow: req.newWindow,
+            profile: wtProfile(io.env),
+            cwd: workdir,
+            title: plan.title,
+            command: [io.nodePath, TAB_WRAPPER_JS],
+        });
+        const bad = semicolonArg(args);
+        if (bad !== null) {
+            io.stderr(`argomento con ';' non passabile a ${WT_CMD}, che lo legge come separatore: '${bad}'\n`);
+            return 2;
+        }
+        env = {
+            ...windowsTabEnv(io.env, req.noTask ? null : req.task, resolveGitBash(io.env, existsSync)),
+            [TAB_ARGV_ENV]: JSON.stringify(plan.claudeArgs),
+        };
+        io.stdout(`LOOM_DECK_INTAB ${plan.inTab}\n`);
+    }
+    else {
+        // L'override esiste per i probe empirici (un comando non-CC nella tab): è
+        // una riga per bash, quindi vale solo dove la tab la esegue con bash.
+        const inTab = io.env.LOOM_DECK_INTAB_CMD || plan.inTab;
+        cmd = 'ptyxis';
+        args = ptyxisArgv(req.newWindow, workdir, plan.title, inTab);
+        io.stdout(`LOOM_DECK_INTAB ${inTab}\n`);
+    }
+    try {
+        return await io.launch(cmd, args, env);
+    }
+    catch (e) {
+        const code = e.code ?? String(e);
+        io.stderr(`deck-run: ${cmd} non lanciabile (${code}): ${describe(cmd, args)}\n`);
+        return 127;
+    }
+}
+/**
+ * Il lancio vero: stdio ereditato, così chi legge lo stdout di `deck-run` vede
+ * anche quello del terminale, come quando lo script finiva con `exec`.
+ *
+ * `windowsHide: false` e non il `true` degli altri spawn del deck: `wt.exe` è
+ * un'applicazione GUI, e con `true` la finestra di `-w new` partirebbe nascosta.
+ * Un processo GUI non apre console, quindi non c'è niente da nascondere.
+ */
+export function launchTerminal(cmd, args, env) {
+    return new Promise((resolveExit, reject) => {
+        const child = spawn(cmd, args, { stdio: 'inherit', env: env, windowsHide: false });
+        child.on('error', reject);
+        child.on('exit', (code, signal) => {
+            resolveExit(code ?? 128 + (signal ? (constants.signals[signal] ?? 0) : 0));
+        });
+    });
+}
+export function realIo() {
+    return {
+        env: process.env,
+        cwd: process.cwd(),
+        platform: process.platform,
+        nodePath: process.execPath,
+        stdout: (s) => process.stdout.write(s),
+        stderr: (s) => process.stderr.write(s),
+        launch: launchTerminal,
+    };
+}

package/dist/tab-wrapper.js

@@ -0,0 +1,44 @@
+// T176 — il programma che gira DENTRO una tab di Windows Terminal aperta dal
+// deck: legge l'argv di `claude` dalla variabile della tab e lo lancia.
+//
+// Esiste perché il prompt non deve passare da nessun parser: `wt.exe` legge `;`
+// come separatore di sottocomandi, cmd e PowerShell interpretano `' " & % ^ |`
+// (P3 preflight). L'argv arriva come JSON nell'env, che la tab eredita da chi
+// lancia `wt.exe`, e da qui va a `claude` come array, senza shell.
+//
+// La variabile si toglie dall'env PRIMA del lancio: è un canale verso questo
+// programma, e `claude` la passerebbe a ogni hook e a ogni comando della
+// sessione.
+//
+// `claude` è quello di `claudeLauncher` (T175): l'eseguibile nativo, lo shim npm
+// letto, o `LOOM_DECK_CLAUDE_CMD`.
+//
+// Ctrl+C appartiene a `claude`. In una console Windows il tasto arriva a ogni
+// processo attaccato, quindi anche qui: senza un handler questo processo
+// uscirebbe, e la tab si chiuderebbe sotto una sessione viva. Si esce solo
+// quando esce `claude`, col suo codice — e la tab si chiude o resta aperta
+// secondo il `closeOnExit` del profilo (D3 preflight).
+import { spawn } from 'node:child_process';
+import { claudeLauncher } from './claude-cmd.js';
+import { parseTabArgv, TAB_ARGV_ENV } from './windows-terminal.js';
+const raw = process.env[TAB_ARGV_ENV];
+delete process.env[TAB_ARGV_ENV];
+const args = parseTabArgv(raw);
+if (!args) {
+    process.stderr.write(`loom-deck: ${TAB_ARGV_ENV} assente o malformata — questa tab non sa quale conversazione aprire\n`);
+    process.exitCode = 2;
+}
+else {
+    process.on('SIGINT', () => { });
+    const claude = claudeLauncher();
+    // `windowsHide: false`: il figlio condivide la console della tab, che è
+    // proprio la finestra in cui deve comparire.
+    const child = spawn(claude.cmd, [...claude.prefix, ...args], { stdio: 'inherit', windowsHide: false });
+    child.on('error', (e) => {
+        process.stderr.write(`loom-deck: '${claude.cmd}' non lanciabile (${e.code ?? e.message})\n`);
+        process.exitCode = 127;
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 1);
+    });
+}

package/dist/tasks.js

@@ -8,29 +8,16 @@ import { sanitize } from './width.js';
  * divergano (uno accetterebbe righe che l'altro rifiuta).
  */
 export const TASK_ID_RE = /^T\d+$/;
-/**
- * Nome della cartella doc del progetto (`docs`, `runtime`, …).
- *
- * D1 (preflight T20): override via env `LOOM_DECK_DOCS_ROOT`, nessun
- * auto-detect e nessuna lettura del file config. Il deck non si lancia mai a
- * mano — nasce da compass, che legge `docsRoot` dal registry dconf e lo
- * antepone al comando, o dal custom-command del profilo Ptyxis, che ce l'ha
- * cablato — quindi l'env c'è sempre nei percorsi di avvio reali.
- *
- * T134 — funzione e non più letterale ripetuto: la legge anche lo scan della
- * coda inbox, e due copie della stessa cascata divergerebbero appena una delle
- * due imparasse a leggere il file config.
- */
-export function docsRootName() {
-    return process.env.LOOM_DECK_DOCS_ROOT || 'docs';
-}
-export function resolveTasksPath(cwd = process.cwd()) {
-    return join(cwd, docsRootName(), 'tasks.md');
+// La docs-root arriva dal chiamante, già risolta: la cascata che la sceglie
+// (`docsRootName` in `config.ts`) gira una volta per vita del deck, e i due path
+// qui sotto devono nascere dallo stesso valore che leggono gli scan del modo doc.
+export function resolveTasksPath(cwd, docsRoot) {
+    return join(cwd, docsRoot, 'tasks.md');
 }
 // I task file vivono in `<docsRoot>/tasks/` — sibling di tasks.md. Derivo la
-// dir dallo stesso path per rispettare l'override LOOM_DECK_DOCS_ROOT.
-export function resolveTasksDir(cwd = process.cwd()) {
-    return join(dirname(resolveTasksPath(cwd)), 'tasks');
+// dir dallo stesso path, così le due non possono puntare a docs-root diverse.
+export function resolveTasksDir(cwd, docsRoot) {
+    return join(dirname(resolveTasksPath(cwd, docsRoot)), 'tasks');
 }
 /**
  * Indici di colonna della Tasks Overview letti dall'HEADER, non cablati.
@@ -142,7 +129,7 @@ export function loadTasks(path) {
  * sciolti in spazi, cioè il buco `{slug}` dei template di titolo.
  *
  * Viene dal NOME del file e non dalla descrizione in `tasks.md` per una ragione
- * di alfabeto: il nome è già dentro quello di `_sane_note` per costruzione —
+ * di alfabeto: il nome è già dentro quello di `saneNote` per costruzione —
  * minuscolo, separato da trattini, senza punteggiatura — mentre la descrizione
  * porta apostrofi e `/`, che la riduzione toglie senza sostituto saldando le
  * parole (`l'epica/doc` → `lepicadoc`).

package/dist/ui/doc-pane.js

@@ -20,6 +20,7 @@ import { DOC_FLAG_W, flagCell } from '../doc-tree.js';
 import { docView } from '../doc-views.js';
 import { docHeaderParts } from '../pane-header.js';
 import { HeaderLine } from './header-line.js';
+import { offText } from '../platform.js';
 /**
  * Rientro di un livello dell'albero: UNA colonna, non due.
  *
@@ -53,14 +54,17 @@ export function DocHeader({ counts, active, above, below, focused, columns, hasD
     const { parts, shown } = docHeaderParts(counts, active, above, below, columns, hasDirs);
     return _jsx(HeaderLine, { parts: parts, shown: shown, focused: focused });
 }
-export function DocPane({ rows, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, scanning, hasDirs, }) {
+export function DocPane({ rows, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, scanning, hasDirs, available = true, }) {
     const width = paneTextWidth(columns);
     // Cella elastica per sottrazione dalle colonne fisse, come nel pane inbox e
     // nella lista sessioni. Pavimento 0 e non un minimo di cortesia: è un tetto,
     // non una preferenza, e alzarlo sopra lo spazio reale fa uscire la riga dal
     // pane mangiandone il bordo (invariante ③ di width.ts).
     const nameW = Math.max(0, width - (2 /* caret */ + DOC_FLAG_W + 1 /* gutter */));
-    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(DocHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns, hasDirs: hasDirs }), paneCount === 0 ? (
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", marginRight: 1, borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(DocHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns, hasDirs: hasDirs }), !available ? (
+            // T175 — gemello del pane inbox: la misura qui non esiste, e va detto
+            // per nome invece di restare su «albero non ancora misurato».
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(offText('pluginScripts', 'albero doc'), width) })) : paneCount === 0 ? (
             // Quattro vuoti diversi, e dirlo è il punto. Ai tre del pane inbox se ne
             // aggiunge uno che solo questo scan ha: «sto misurando». Quattro secondi
             // di wall clock sono abbastanza da vedersi, e un pane vuoto per quattro

package/dist/ui/inbox-pane.js

@@ -19,6 +19,7 @@ import { NATURA_SHORT, NATURA_W, inboxMark } from '../inbox.js';
 import { inboxView } from '../inbox-views.js';
 import { inboxHeaderParts } from '../pane-header.js';
 import { HeaderLine } from './header-line.js';
+import { offText } from '../platform.js';
 /**
  * Header del pane inbox: le parti e il loro taglio vengono da `pane-header.ts`,
  * lo stesso modulo da cui `frame.ts` ricava le colonne cliccabili — una fonte
@@ -43,7 +44,7 @@ export function InboxHeader({ counts, active, above, below, focused, columns, })
  * colonna fissa la paga la cella elastica del nome — che è l'unica cosa con cui
  * si riconosce un file.
  */
-export function InboxPane({ files, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, }) {
+export function InboxPane({ files, counts, activeView, paneCount, selectedPath, focused, above, below, columns, ok, scanned, available = true, }) {
     const width = paneTextWidth(columns);
     // La cella elastica si calcola per SOTTRAZIONE dalle colonne fisse, come il
     // titolo della lista sessioni: pavimento 0 e non un minimo di cortesia — è un
@@ -58,7 +59,11 @@ export function InboxPane({ files, counts, activeView, paneCount, selectedPath,
             1 /* gutter */ +
             1 /* gutter prima della data */ +
             ageW));
-    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(InboxHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), paneCount === 0 ? (
+    return (_jsxs(Box, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: focused ? 'cyan' : 'gray', paddingX: 1, children: [_jsx(InboxHeader, { counts: counts, active: activeView, above: above, below: below, focused: focused, columns: columns }), !available ? (
+            // T175 — un quarto vuoto, il solo che non è uno stato della coda: la
+            // misura qui non esiste. Va detto per nome, o si leggerebbe come «coda
+            // non ancora misurata» per sempre.
+            _jsx(Text, { color: "yellow", wrap: "truncate-end", children: cut(offText('pluginScripts', 'coda inbox'), width) })) : paneCount === 0 ? (
             // Tre vuoti diversi, e dirlo è il punto: «non ho ancora misurato» non è
             // «ho misurato e non c'è niente», e «la misura si è rotta» non è nessuno
             // dei due (D2 preflight). Una lista vuota che non dice quale dei tre è