@vascend/talos 0.1.0

package/dist/tui/branding.js

@@ -0,0 +1,750 @@
+import { renderVascendTerminalLogo } from "./logo.js";
+import { renderMarkdown } from "./markdown.js";
+import { tokenAnsi } from "./theme.js";
+import { fitLine, padLine, plainText, wrapText as wrapTerminalText } from "./terminal-text.js";
+import { createAttachmentHighlighter } from "./attachment-highlight.js";
+const RESET = "\x1b[0m";
+const SILVER = "\x1b[38;2;210;214;220m";
+const DARK_SILVER = "\x1b[38;2;104;111;122m";
+const CHAT_TEXT = "\x1b[38;2;232;235;239m";
+const CHAT_BG = "\x1b[48;2;29;41;56m";
+const ANSI = {
+    blue: "\x1b[34m",
+    cyan: "\x1b[36m",
+    dim: "\x1b[2m",
+    gray: "\x1b[90m",
+    green: "\x1b[32m",
+    magenta: "\x1b[35m",
+    red: "\x1b[31m",
+    white: "\x1b[37m",
+    yellow: "\x1b[33m",
+};
+function paint(color, s) {
+    return `${ANSI[color]}${s}${RESET}`;
+}
+// --- Palette "argento gelido" --------------------------------------------
+// Gradiente FREDDO usato dall'intro animata: dal bianco ghiaccio all'argento,
+// poi grafite, con una leggera punta di blu acciaio nei toni piu' scuri (cosi'
+// il metallo sembra "gelido" e non grigio neutro). t in [0,1]: 0 = scuro,
+// 1 = luce. Ritorna una tripla RGB.
+export function frostSilver(t) {
+    const x = clamp01(t);
+    // Punti di controllo (cool grays con bias blu nei bassi):
+    //   0.00 -> grafite blu-acciaio   (58, 66, 80)
+    //   0.45 -> argento freddo        (150, 160, 174)
+    //   0.80 -> argento chiaro        (208, 215, 224)
+    //   1.00 -> bianco ghiaccio       (238, 244, 252)
+    const stops = [
+        [0.0, 58, 66, 80],
+        [0.45, 150, 160, 174],
+        [0.8, 208, 215, 224],
+        [1.0, 238, 244, 252],
+    ];
+    for (let i = 1; i < stops.length; i += 1) {
+        const a = stops[i - 1];
+        const b = stops[i];
+        if (x <= b[0]) {
+            const span = b[0] - a[0] || 1;
+            const k = (x - a[0]) / span;
+            return [
+                Math.round(a[1] + (b[1] - a[1]) * k),
+                Math.round(a[2] + (b[2] - a[2]) * k),
+                Math.round(a[3] + (b[3] - a[3]) * k),
+            ];
+        }
+    }
+    const last = stops[stops.length - 1];
+    return [last[1], last[2], last[3]];
+}
+// Sequenza di escape per foreground RGB (truecolor).
+export function fgRgb(rgb) {
+    return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+}
+// Avvolge `s` nel colore argento-gelido al livello `t` (con reset finale).
+export function frostPaint(t, s) {
+    return `${fgRgb(frostSilver(t))}${s}${RESET}`;
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+// Quando e' presente uno ThemeSpec, le funzioni del tema TUI sono derivate dai
+// token del tema (parita' Pi); altrimenti si usa la palette argento/grafite
+// storica e i colori ANSI di accent/muted dal config.
+export function makeTheme(ui, spec) {
+    if (spec) {
+        const wrap = (code, s) => (code ? `${code}${s}${RESET}` : s);
+        const fg = (t) => tokenAnsi(spec, t);
+        const bg = (t) => tokenAnsi(spec, t, true);
+        const chatBg = tokenAnsi(spec, "userMessageBg", true);
+        const composerBg = spec.mode === "light" ? "\x1b[48;2;235;235;235m" : "\x1b[48;2;51;51;51m";
+        return {
+            markdownHeading: (s) => wrap(fg("mdHeading"), s),
+            markdownLink: (s) => wrap(fg("mdLink"), s),
+            markdownCode: (s) => wrap(fg("mdCode"), s),
+            markdownBullet: (s) => wrap(fg("mdListBullet"), s),
+            accent: (s) => wrap(fg("accent"), s),
+            bold: (s) => `\x1b[1m${s}${RESET}`,
+            chatBorder: (s) => wrap(fg("borderAccent"), s),
+            attachmentRef: (s) => wrap(fg("attachmentRef"), s),
+            chatText: (s) => {
+                const code = `${chatBg}${fg("userMessageText")}`;
+                return wrap(code, s.replace(/\x1b\[0m/g, RESET + code));
+            },
+            composerText: (s) => {
+                const code = `${composerBg}${fg("userMessageText")}`;
+                return wrap(code, s.replace(/\x1b\[0m/g, RESET + code));
+            },
+            selected: (s) => wrap(`${bg("selectedBg")}${fg("text")}\x1b[1m`, s),
+            dark: (s) => wrap(fg("muted"), s),
+            diffAdded: (s) => wrap(`${bg("toolDiffAddedBg")}${fg("toolDiffAdded")}`, s),
+            diffBorder: (s) => wrap(fg("toolDiffBorder"), s),
+            diffContext: (s) => wrap(`${bg("toolDiffContextBg")}${fg("toolDiffContext")}`, s),
+            diffHeader: (s) => wrap(`${bg("toolDiffHeaderBg")}${fg("toolTitle")}`, s),
+            diffRemoved: (s) => wrap(`${bg("toolDiffRemovedBg")}${fg("toolDiffRemoved")}`, s),
+            dim: (s) => wrap(fg("dim"), s),
+            frame: (s) => wrap(fg("border"), s),
+            green: (s) => wrap(fg("success"), s),
+            muted: (s) => wrap(fg("muted"), s),
+            red: (s) => wrap(fg("error"), s),
+            silver: (s) => wrap(fg("text"), s),
+            yellow: (s) => wrap(fg("warning"), s),
+            danTag: (s) => wrap(fg("syntaxFunction"), s),
+            danId: (s) => wrap(fg("syntaxType"), s),
+            danValue: (s) => wrap(fg("syntaxString"), s),
+            danArrow: (s) => wrap(fg("syntaxOperator"), s),
+            danNum: (s) => wrap(fg("syntaxNumber"), s),
+            danPunct: (s) => wrap(fg("syntaxPunctuation"), s),
+        };
+    }
+    return {
+        markdownHeading: (s) => paint("yellow", s),
+        markdownLink: (s) => paint("cyan", s),
+        markdownCode: (s) => paint("cyan", s),
+        markdownBullet: (s) => paint("blue", s),
+        accent: (s) => paint(ui.accentColor, s),
+        bold: (s) => `\x1b[1m${s}${RESET}`,
+        chatBorder: (s) => `${DARK_SILVER}${s}${RESET}`,
+        attachmentRef: (s) => paint("cyan", s),
+        chatText: (s) => `${CHAT_BG}${CHAT_TEXT}${s.replace(/\x1b\[0m/g, RESET + CHAT_BG + CHAT_TEXT)}${RESET}`,
+        composerText: (s) => `\x1b[48;2;51;51;51m${CHAT_TEXT}${s.replace(/\x1b\[0m/g, RESET + "\x1b[48;2;51;51;51m" + CHAT_TEXT)}${RESET}`,
+        selected: (s) => `\x1b[48;2;48;68;94m${CHAT_TEXT}\x1b[1m${s}${RESET}`,
+        dark: (s) => `${DARK_SILVER}${s}${RESET}`,
+        diffAdded: (s) => `\x1b[48;2;16;33;23m\x1b[38;2;127;185;138m${s}${RESET}`,
+        diffBorder: (s) => `\x1b[38;2;77;85;97m${s}${RESET}`,
+        diffContext: (s) => `\x1b[48;2;13;16;21m${DARK_SILVER}${s}${RESET}`,
+        diffHeader: (s) => `\x1b[48;2;21;25;35m${SILVER}${s}${RESET}`,
+        diffRemoved: (s) => `\x1b[48;2;37;19;20m\x1b[38;2;217;140;140m${s}${RESET}`,
+        dim: (s) => paint("dim", s),
+        frame: (s) => `${SILVER}${s}${RESET}`,
+        green: (s) => paint("green", s),
+        muted: (s) => paint(ui.mutedColor, s),
+        red: (s) => paint("red", s),
+        silver: (s) => `${SILVER}${s}${RESET}`,
+        yellow: (s) => paint("yellow", s),
+        danTag: (s) => `\x1b[38;2;169;194;217m${s}${RESET}`,
+        danId: (s) => `\x1b[38;2;134;178;198m${s}${RESET}`,
+        danValue: (s) => `\x1b[38;2;167;189;170m${s}${RESET}`,
+        danArrow: (s) => `\x1b[38;2;127;150;180m${s}${RESET}`,
+        danNum: (s) => `\x1b[38;2;200;189;156m${s}${RESET}`,
+        danPunct: (s) => `\x1b[38;2;107;116;128m${s}${RESET}`,
+    };
+}
+function startupLogo(ui, columns) {
+    if (ui.banner === "none" || ui.banner === "minimal")
+        return { lines: [], precolored: false };
+    if (ui.banner === "custom")
+        return { lines: ui.logoLines, precolored: false };
+    if (ui.logoLines.length)
+        return { lines: ui.logoLines, precolored: false };
+    return { lines: renderVascendTerminalLogo(logoSize(columns)), precolored: true };
+}
+export function renderStartup(config, meta = {}, options = {}, spec) {
+    return `${renderStartupLines(config, meta, options, spec).join("\n")}\n`;
+}
+// Come renderStartup ma ritorna le RIGHE separate (senza newline finale ne'
+// righe vuote di cornice). Serve all'intro animata, che riscrive le stesse N
+// righe ad ogni frame ricolorandole con il gradiente argento-gelido.
+export function renderStartupLines(config, meta = {}, options = {}, spec) {
+    const theme = makeTheme(config.ui, spec);
+    const columns = clamp(options.columns ?? 100, 36, 180);
+    const contentWidth = Math.max(30, columns - 2);
+    if (options.compact)
+        return [
+            fitLine(theme.silver(` ${config.ui.title}`) + theme.muted(` · ${config.model}`), columns - 1),
+            fitLine(" " + commandsHint(theme, columns - 2), columns - 1),
+        ];
+    const logo = startupLogo(config.ui, columns);
+    const logoLines = logo.lines.map((line) => `  ${logo.precolored ? line : theme.accent(line)}`);
+    const gap = columns >= 110 ? 6 : 4;
+    const logoWidth = Math.max(0, ...logoLines.map(visibleLength));
+    const sideCard = renderStartupCard(config, meta, theme, Math.max(30, contentWidth - logoWidth - gap));
+    const sideWidth = logoWidth + gap + Math.max(0, ...sideCard.map(visibleLength));
+    const canUseSideBySide = logoLines.length > 0 && columns >= 82 && sideWidth <= contentWidth;
+    const card = canUseSideBySide
+        ? sideCard
+        : renderStartupCard(config, meta, theme, Math.min(62, contentWidth));
+    const body = canUseSideBySide
+        ? beside(logoLines, card, gap)
+        : stack(logoLines, card);
+    return ["", ...body, ""];
+}
+export function renderAssistantTurnStart(_theme, _columns) {
+    return "";
+}
+export function renderAssistantSegment(text, theme, columns, imageCtx, _kind = "start", _sequence = 1) {
+    const contentWidth = Math.max(2, columns - 5);
+    const lines = renderMarkdown(text.trimEnd(), { width: contentWidth, theme, imageCtx });
+    const rows = lines.length ? lines : [""];
+    return [
+        "",
+        ...rows.map((line, index) => (index === 0 ? theme.dark("  • ") : "    ") + highlightDanilov(line, theme)),
+    ].join("\n") + "\n";
+}
+export function renderAssistantTurnEnd(theme, sequence, status = "completed") {
+    return status === "error" ? theme.red("  × Risposta interrotta\n") : "";
+}
+// Compatibilita' con i renderer esterni: una chat box isolata e' una risposta
+// completa, mentre il REPL usa renderAssistantSegment per la gerarchia live.
+export function renderChatBox(text, theme, columns, imageCtx) {
+    return renderAssistantSegment(text, theme, columns, imageCtx, "only", 1) +
+        renderAssistantTurnEnd(theme, 1);
+}
+// Colora la notazione Danilov nelle righe di chat dando un RUOLO CROMATICO
+// distinto a ciascun pezzo della sintassi, cosi' a colpo d'occhio si separano
+// marcatore, identificatore, contenuto e relazioni:
+//   INDICE/DEFINIZIONI/RELAZIONI/OUTPUT -> keyword (accent bold)
+//   @tag        -> danTag (acciaio-azzurro), il marcatore @ in danPunct
+//   [id]        -> parentesi in danPunct, id in danId (ciano-acciaio)
+//   : / = / · | -> danPunct (punteggiatura tenue)
+//   valore dopo : o = -> danValue (salvia) finche' non c'e' altra punteggiatura
+//   src -> tgt  -> freccia in danArrow (blu freddo)
+//   0x.. e numeri -> danNum (ottone)
+//   Tnn (id stanza) -> danId
+// Procede da SINISTRA a DESTRA su una riga PLAIN, costruendo l'output a pezzi:
+// cosi' non ricolora segmenti gia' processati (niente regex su testo con ANSI).
+// True se la riga e' notazione Danilov (da colorare con highlightDanilov):
+// una riga di SEZIONE (INDICE/DEFINIZIONI/RELAZIONI/OUTPUT), una DEFINIZIONE
+// (@tag...) o una RELAZIONE (contiene la freccia ->). Cosi' markdown.ts puo'
+// dipingere il formato alla fonte invece di lasciarlo a renderInline (che lo
+// avvolgerebbe in ANSI, disattivando highlightDanilov a valle).
+export function isDanilovLine(line) {
+    const body = line.replace(/^\s+/, "");
+    if (!body)
+        return false;
+    if (/^(INDICE|DEFINIZIONI|RELAZIONI|OUTPUT)\b/.test(body))
+        return true;
+    if (/^@[A-Za-z_]\w*(\[[^\]]*\])?\s*[:\[]/.test(body))
+        return true; // @tag: o @tag[
+    if (/\s->\s/.test(body))
+        return true; // relazione src -> tgt
+    return false;
+}
+export function highlightDanilov(line, theme) {
+    if (line.includes("\x1b"))
+        return line;
+    // Indentazione iniziale conservata.
+    const lead = /^(\s*)/.exec(line)?.[1] ?? "";
+    let body = line.slice(lead.length);
+    // 1) Riga di SEZIONE: INDICE/DEFINIZIONI/RELAZIONI/OUTPUT (eventuale ":" finale).
+    const sec = /^(INDICE|DEFINIZIONI|RELAZIONI|OUTPUT)(:?)(.*)$/.exec(body);
+    if (sec) {
+        const kw = `\x1b[1m${theme.accent(sec[1])}\x1b[22m`;
+        const colon = sec[2] ? theme.danPunct(sec[2]) : "";
+        return lead + kw + colon + colorizeDanilovRest(sec[3] ?? "", theme);
+    }
+    return lead + colorizeDanilovRest(body, theme);
+}
+// Colora il "corpo" di una riga Danilov pezzo per pezzo. Riconosce i token in
+// ordine di priorita' e avanza sull'input; il testo non riconosciuto passa
+// inalterato (riga di prosa normale resta normale).
+function colorizeDanilovRest(input, theme) {
+    let s = input;
+    let out = "";
+    // true subito dopo ":" o "=" finche' non si incontra altra punteggiatura:
+    // segna il "valore/contenuto" da dipingere in danValue.
+    let inValue = false;
+    while (s.length > 0) {
+        // @tag (con eventuale [id]) — il marcatore di definizione/relazione.
+        let m = /^@([A-Za-z_]\w*)(\[[^\]]*\])?/.exec(s);
+        if (m) {
+            out += theme.danPunct("@") + theme.danTag(m[1]);
+            if (m[2]) {
+                const id = m[2].slice(1, -1);
+                out += theme.danPunct("[") + theme.danId(id) + theme.danPunct("]");
+            }
+            s = s.slice(m[0].length);
+            inValue = false;
+            continue;
+        }
+        // Freccia di relazione src -> tgt.
+        m = /^\s*->\s*/.exec(s);
+        if (m) {
+            out += theme.danArrow(m[0]);
+            s = s.slice(m[0].length);
+            inValue = false;
+            continue;
+        }
+        // Maschera bit 0x.. o numero isolato.
+        m = /^0x[0-9a-fA-F]+|^\b\d+\b/.exec(s);
+        if (m) {
+            out += theme.danNum(m[0]);
+            s = s.slice(m[0].length);
+            continue;
+        }
+        // Id stanza Tnn.
+        m = /^T\d{2}\b/.exec(s);
+        if (m) {
+            out += theme.danId(m[0]);
+            s = s.slice(m[0].length);
+            continue;
+        }
+        // Punteggiatura della notazione: avvia (o chiude) la modalita' valore.
+        const ch = s[0];
+        if (ch === ":" || ch === "=") {
+            out += theme.danPunct(ch);
+            s = s.slice(1);
+            inValue = true;
+            continue;
+        }
+        if (ch === "·" || ch === "|" || ch === "," || ch === ";" || ch === "[" || ch === "]") {
+            out += theme.danPunct(ch);
+            s = s.slice(1);
+            inValue = false;
+            continue;
+        }
+        // Segmento di testo fino al prossimo token significativo.
+        m = /^[^@\-:=·|,;\[\]]+|^-(?!>)/.exec(s);
+        const chunk = m ? m[0] : ch;
+        out += inValue ? theme.danValue(chunk) : chunk;
+        s = s.slice(chunk.length);
+    }
+    return out;
+}
+export function renderUserMessage(text, theme, columns, label) {
+    const width = Math.max(1, columns - 2);
+    const source = plainText(text.trimEnd());
+    const highlight = createAttachmentHighlighter(source, theme.attachmentRef);
+    const lines = wrapTerminalText(source, Math.max(2, width - 3), true);
+    const rows = lines.length ? lines : [""];
+    const receipt = label ? wrapTerminalText(label, Math.max(2, width - 1), true).map(line => " " + theme.accent(line)).join("\n") + "\n" : "";
+    let offset = 0;
+    return "\n" + receipt + rows.map((line, index) => {
+        const start = source.indexOf(line, offset);
+        const highlighted = highlight(line, start);
+        offset = start + line.length;
+        return " " + theme.chatText(padLine((index === 0 ? "› " : "  ") + highlighted, width));
+    }).join("\n") + "\n";
+}
+// Badge di un'immagine allegata, stile artifact Claude Code: un riquadro con
+// RIEMPIMENTO BIANCO e TESTO NERO, cosi' si distingue subito come oggetto/
+// artifact (non testo normale). Una riga sola: " img #N · label ".
+export function renderImageArtifact(ref, label) {
+    const WHITE_BG = "\x1b[47m";
+    const BLACK_FG = "\x1b[30m";
+    const inner = ` ${ref} · ${label} `;
+    const body = `${WHITE_BG}${BLACK_FG}\x1b[1m${inner}${RESET}`;
+    return ` ${body}`;
+}
+export function renderVascendStatus(state, theme, columns) {
+    // Il riquadro compare SOLO se c'e' almeno un castello (avviato con /castle o
+    // pianificato dall'agente con vascend_plan). Niente box automatico sui prompt.
+    if (!state.kingdom.castles.length)
+        return "";
+    const width = clamp(columns - 8, 40, 96);
+    const contentWidth = width - 4;
+    const title = state.mode === "sticky" ? " lista attività · live " : " lista attività ";
+    const top = theme.chatBorder("  ╭─") + theme.silver(`\x1b[1m${title}${RESET}`) +
+        theme.chatBorder("─".repeat(Math.max(0, contentWidth + 1 - visibleLength(title))) + "╮");
+    const goal = truncate(state.goal ?? "nessun obiettivo", contentWidth - 6);
+    const line = (text, color = theme.dark) => theme.chatBorder("  │ ") + color(padRight(truncate(text, contentWidth), contentWidth)) + theme.chatBorder(" │");
+    const castles = state.kingdom.castles;
+    const totalRooms = castles.reduce((n, c) => n + c.tasks.length, 0);
+    // COMPATTO se il regno e' grande (multi-castello o tante stanze): solo sommari
+    // per castello, il dettaglio si apre con Ctrl+G. Cosi' il box non esplode.
+    const compact = castles.length > 1 || totalRooms > 6;
+    const rows = [line(`obiettivo  ${goal}`)];
+    if (!castles.length)
+        rows.push(line("nessuna attività presente"));
+    for (const castle of castles) {
+        const done = castle.tasks.filter((t) => t.status === "completed").length;
+        const failed = castle.tasks.filter((t) => t.status === "failed").length;
+        if (compact) {
+            const bar = `${done}/${castle.tasks.length} (${pctDone(castle.tasks)}%)${failed ? ` · ${failed} fallit${failed === 1 ? "a" : "e"}` : ""}`;
+            // Indicatore di stato del vassallo: glyph dedicato per attivo/in attesa/
+            // completato/errore, colore coerente con lo stato aggregato.
+            const vstatus = castleStatus(castle.tasks);
+            const color = vassalStatusColor(vstatus, theme);
+            rows.push(line(`${vassalGlyph(vstatus)} ${castle.slug} · ${truncate(castle.title, contentWidth - 18)}  ${bar}`, color));
+        }
+        else {
+            // Intestazione del castello (titolo) + stanze con numero in BOLD, glyph di
+            // stato colorato, token se noti e sotto-riga delle skill abbinate.
+            if ((castle.title || castle.slug) && castles.length > 0) {
+                rows.push(line(`◆ ${castle.title || castle.slug}`, theme.silver));
+            }
+            for (const task of castle.tasks) {
+                const color = taskStatusColor(task.status, theme);
+                const tok = task.tokens !== undefined ? theme.dark(` ↓${fmtTokShort(task.tokens)}`) : "";
+                const content = color(`${statusGlyph(task.status)} \x1b[1m${task.id}\x1b[22m`) +
+                    " " + theme.silver(truncate(task.title, contentWidth - 14)) + tok;
+                rows.push(theme.chatBorder("  │ ") + padRight(content, contentWidth) + theme.chatBorder(" │"));
+                const sub = [];
+                if (task.skills?.length)
+                    sub.push(`@skill ${task.skills.join(", ")}`);
+                if (task.notes?.length)
+                    sub.push(`${task.notes.length} note`);
+                if (sub.length) {
+                    rows.push(theme.chatBorder("  │ ") + padRight(theme.dark(`   └ ${truncate(sub.join(" · "), contentWidth - 6)}`), contentWidth) + theme.chatBorder(" │"));
+                }
+            }
+        }
+    }
+    if (compact)
+        rows.push(line("Ctrl+G per le attività", theme.dark));
+    const bottom = theme.chatBorder("  ╰" + "─".repeat(contentWidth + 2) + "╯");
+    return ["", top, ...rows, bottom].join("\n") + "\n";
+}
+// Status line del REGNO sotto la input bar: castelli e stanze in sintesi, con
+// l'hint del comando di gestione. "" se non c'e' nessun castello (niente rumore
+// sui prompt banali). Pensata come riga extra del footer ancorato in fondo.
+export function vascendFooterLine(state, theme, columns) {
+    const castles = state.kingdom.castles;
+    if (!castles.length)
+        return "";
+    const width = inputWidth(columns) + 2;
+    const allTasks = castles.flatMap((c) => c.tasks);
+    const done = allTasks.filter((t) => t.status === "completed").length;
+    const running = allTasks.filter((t) => t.status === "running").length;
+    const failed = allTasks.filter((t) => t.status === "failed").length;
+    const head = castles.length > 1
+        ? `lista attività · ${castles.length} gruppi`
+        : `lista «${truncate(castles[0]?.title ?? "", 28)}»`;
+    const bits = [`${done}/${allTasks.length} attività (${pctDone(allTasks)}%)`];
+    if (running)
+        bits.push(`${running} in corso`);
+    if (failed)
+        bits.push(`${failed} fallit${failed === 1 ? "a" : "e"}`);
+    const body = `◆ ${head} · ${bits.join(" · ")} · Ctrl+G dettagli`;
+    const summary = theme.silver(`  ${truncate(body, width)}`);
+    // Con piu' vassalli (multi-castello) aggiungo una riga di indicatori di stato
+    // per-vassallo: glyph colorato + slug, cosi' nella vista collassata si vede a
+    // colpo d'occhio chi e' attivo/in attesa/completato/in errore.
+    if (castles.length < 2)
+        return summary;
+    const indicators = castles.map((c) => vassalIndicator(c, theme)).join(theme.dark("  "));
+    return `${summary}\n${theme.dark("  ")}${truncate(indicators, width + 32)}`;
+}
+// Avviso di chat per gli eventi del regno (stanza avviata/illuminata/fallita):
+// riga marcata, leggibile, in notazione breve. La NASCITA del castello ha invece
+// un design dedicato (renderCastleBorn), per distinguerla nettamente.
+export function renderVascendNotice(kind, text, theme) {
+    // Colori DISTINTI per stato della stanza: avviata=accent (cyan), illuminata=
+    // giallo (luce accesa), fallita=rosso; nascita castello/regno=accent.
+    if (kind === "fail")
+        return theme.red(`\n  ✗ ${text}\n`);
+    if (kind === "done")
+        return theme.yellow(`\n  ✦ ${text}\n`);
+    if (kind === "start")
+        return theme.accent(`\n  ▸ ${text}\n`);
+    const glyph = "◆";
+    return theme.accent(`\n  ${glyph} ${text}\n`);
+}
+// Nascita di un castello: milestone compatta. Il dettaglio completo delle
+// stanze e' sempre raggiungibile con Ctrl+G, quindi non viene duplicato nella
+// chat consumando una riga per task.
+export function renderCastleBorn(opts, theme, columns) {
+    const isKingdom = opts.kingdomCount > 1;
+    const available = Math.max(30, columns - 34);
+    const title = truncate(opts.title || opts.slug, available);
+    const kingdom = isKingdom ? theme.dark(` · ${opts.kingdomCount} gruppi`) : "";
+    const slug = opts.slug && opts.slug !== "master" ? theme.dark(` · ${opts.slug}`) : "";
+    return "\n  " + theme.accent("◆ ") + theme.silver(`\x1b[1m${title}${RESET}`) +
+        theme.dark(` · ${opts.tasks.length} attività`) + slug + kingdom + theme.dark(" · Ctrl+G dettagli\n");
+}
+// Avviso di cambio modello: badge UI dedicato, scritto SOLO nello scrollback
+// (ctl.write), MAI nella sessione -> non entra nel context inviato al modello.
+// Mostra il modello nuovo + provider; se warn e' presente, una riga gialla.
+export function renderModelChanged(opts, theme) {
+    const badge = theme.accent(`\x1b[1m  ⇄ modello${RESET}`);
+    const name = theme.silver(`\x1b[1m${opts.model}${RESET}`);
+    const prov = opts.provider ? theme.dim(`  ·  ${opts.provider}`) : "";
+    const head = `${badge}  ${name}${prov}`;
+    if (opts.warn) {
+        return `\n${head}\n` + theme.yellow(`    ! ${opts.warn}`) + "\n";
+    }
+    return `\n${head}\n`;
+}
+// Blocco prompt unificato: una riga di meta (modello/contesto/cache) e la barra
+// "input", scritte INSIEME subito sopra il cursore. Il numero di righe e' fisso
+// e noto (vedi PROMPT_BLOCK_LINES) cosi' la TUI puo' cancellarlo per intero
+// all'invio, senza lasciare barre duplicate sullo schermo.
+export const PROMPT_BLOCK_LINES = 3; // spacer + footer + barra
+export function renderInputPrompt(config, meta, theme, columns) {
+    const footer = inputFooterLine(config, meta, theme, columns);
+    const bar = inputBarLine(theme, columns);
+    return ["", footer, bar].join("\n") + "\n";
+}
+// Righe del footer per la barra di input ANCORATA in fondo (dall'alto in
+// basso): meta (modello/contesto/cache) + barra "input". Niente spacer ne'
+// newline: le posiziona il chiamante a righe assolute.
+export function inputFooterRows(config, meta, theme, columns) {
+    return [inputFooterLine(config, meta, theme, columns), inputBarLine(theme, columns)];
+}
+function inputBarLine(theme, columns) {
+    const width = inputWidth(columns);
+    const title = " input ";
+    const left = Math.floor(Math.max(0, width - visibleLength(title)) / 2);
+    const right = Math.max(0, width - visibleLength(title) - left);
+    return theme.chatBorder(`  ${"─".repeat(left)}`) +
+        theme.silver(`\x1b[1m${title}${RESET}`) +
+        theme.chatBorder("─".repeat(right));
+}
+function inputFooterLine(config, meta, theme, columns) {
+    const width = inputWidth(columns) + 2;
+    const provider = meta.provider ?? providerFromModel(config.model);
+    const parts = [config.model, provider];
+    if (config.effort)
+        parts.push(`effort ${config.effort}`);
+    if (meta.contextTokens !== undefined && meta.contextWindow) {
+        const pct = Math.round((meta.contextTokens / meta.contextWindow) * 100);
+        parts.push(`ctx stimato ~${formatTokens(meta.contextTokens)}/${formatTokens(meta.contextWindow)} (${pct}%)`);
+    }
+    if (meta.cacheHitRate !== undefined) {
+        parts.push(`cache ${Math.round(meta.cacheHitRate * 100)}%`);
+    }
+    return theme.dark(`  ${truncate(parts.join(" · "), width)}`);
+}
+// Mantenuto per compatibilita': singola riga di meta con "\n" finale.
+export function renderInputFooter(config, meta, theme, columns) {
+    return inputFooterLine(config, meta, theme, columns) + "\n";
+}
+function formatTokens(n) {
+    if (n >= 1_000_000) {
+        const m = n / 1_000_000;
+        return `${Number.isInteger(m) ? m : m.toFixed(1)}M`;
+    }
+    return n >= 1000 ? `${Math.round(n / 1000)}k` : `${n}`;
+}
+function taskStatusColor(status, theme) {
+    if (status === "completed")
+        return theme.green;
+    if (status === "running")
+        return theme.yellow;
+    if (status === "failed")
+        return theme.red;
+    return theme.dark;
+}
+function statusGlyph(status) {
+    if (status === "completed")
+        return "✦";
+    if (status === "running")
+        return "▸";
+    if (status === "failed")
+        return "✗";
+    return "·";
+}
+export function castleStatus(tasks) {
+    if (tasks.some((t) => t.status === "failed"))
+        return "errore";
+    if (tasks.some((t) => t.status === "running"))
+        return "attivo";
+    if (tasks.length > 0 && tasks.every((t) => t.status === "completed"))
+        return "completato";
+    return "in_attesa";
+}
+// Indicatore visivo (glyph + colore) per lo stato di un vassallo nella vista
+// collassata. Riusa la palette dello stato stanza per coerenza visiva.
+function vassalGlyph(status) {
+    if (status === "completato")
+        return "✦";
+    if (status === "attivo")
+        return "▸";
+    if (status === "errore")
+        return "✗";
+    return "·";
+}
+function vassalStatusColor(status, theme) {
+    if (status === "completato")
+        return theme.green;
+    if (status === "attivo")
+        return theme.yellow;
+    if (status === "errore")
+        return theme.red;
+    return theme.dark;
+}
+// Indicatore compatto per un vassallo: glyph colorato + nome breve. Usato nella
+// vista collassata del regno per mostrare a colpo d'occhio lo stato di ciascuno.
+export function vassalIndicator(castle, theme, nameWidth = 14) {
+    const status = castleStatus(castle.tasks);
+    const color = vassalStatusColor(status, theme);
+    const pct = pctDone(castle.tasks);
+    // La percentuale e' muta (in attesa) finche' non c'e' progresso reale, cosi'
+    // la vista collassata non si riempie di "0%" su vassalli ancora fermi.
+    const suffix = status === "in_attesa" && pct === 0 ? "" : ` ${pct}%`;
+    return color(`${vassalGlyph(status)} ${truncate(castle.slug, nameWidth)}${suffix}`);
+}
+// Percentuale di avanzamento (stanze completate sul totale). 0 se non ci sono
+// stanze, cosi' il chiamante puo' decidere se mostrarla o tenerla muta.
+export function pctDone(tasks) {
+    if (!tasks.length)
+        return 0;
+    const done = tasks.filter((t) => t.status === "completed").length;
+    return Math.round((done / tasks.length) * 100);
+}
+function fmtTokShort(n) {
+    if (n >= 1_000_000) {
+        const v = n / 1_000_000;
+        return `${v >= 10 ? Math.round(v) : v.toFixed(1)}M`;
+    }
+    if (n >= 1000) {
+        const v = n / 1000;
+        return `${v >= 10 ? Math.round(v) : v.toFixed(1)}k`;
+    }
+    return `${n}`;
+}
+function inputWidth(columns) {
+    return clamp(columns - 8, 34, 78);
+}
+// Hyperlink OSC 8: rende `label` cliccabile verso `url` nei terminali che lo
+// supportano (parita' Pi clickable file hyperlinks). Negli altri appare come
+// testo normale.
+export function osc8(url, label) {
+    return `\x1b]8;;${url}\x1b\\${label}\x1b]8;;\x1b\\`;
+}
+// Costruisce un URL file:// assoluto (forward slash, prefisso / su Windows).
+export function fileUrl(absPath) {
+    const norm = absPath.replace(/\\/g, "/");
+    return norm.startsWith("/") ? `file://${norm}` : `file:///${norm}`;
+}
+// Avvolge un path in un hyperlink OSC 8 file://, mantenendo il testo originale.
+// Molti terminali sottolineano gli hyperlink OSC 8 (i "trattini sotto al
+// path"): forziamo no-underline (SGR 24) attorno alla label e lo ripristiniamo
+// (SGR 4) appena prima della chiusura del link, cosi' il path resta cliccabile
+// ma non appare sottolineato.
+export function fileLink(absPath, label) {
+    const text = label ?? absPath;
+    return osc8(fileUrl(absPath), `\x1b[24m${text}\x1b[24m`);
+}
+// Hint dei comandi reso come "tasti": ogni voce in un riquadro chiaro
+// [ /help ] separato da una sottile barra verticale, cosi' la riga finale
+// della card sembra una pulsantiera invece di testo piatto.
+function commandsHint(theme, width) {
+    const key = (s) => theme.silver(`\x1b[1m${s}${RESET}`);
+    // Forma piena se c'e' spazio, altrimenti solo i tasti separati dal punto
+    // mediano. Restiamo entro `width` colonne visibili (allineamento del bordo).
+    const full = `${key("Ctrl+R")}${theme.dark(" revisione  ·  ")}${key("/help")}${theme.dark(" guida")}`;
+    const compact = `${key("Ctrl+R")}${theme.dark(" revisione  ·  ")}${key("/help")}`;
+    return visibleLength(full) <= width ? full : compact;
+}
+function renderStartupCard(config, meta, theme, maxWidth) {
+    // Design APERTO, stessa lingua dell'avvio dev di Horizon: wordmark col rombo
+    // del marchio, sottotitolo in didascalia, righe dato allineate con marcatore
+    // pieno, pulsantiera dei comandi in coda. Il box che c'era prima appesantiva
+    // il banner e stringeva i valori dentro la cornice.
+    const width = Math.max(26, maxWidth);
+    const rows = config.ui.showMeta
+        ? [
+            ["modello", config.model, true],
+            ["provider", meta.provider ?? providerFromModel(config.model), false],
+            ["sessione", sessionLabel(meta), false],
+            ["cwd", compactPath(config.cwd, Math.min(46, width - 12)), false],
+        ]
+        : [];
+    const labelWidth = rows.length ? Math.max(...rows.map(([label]) => label.length)) : 0;
+    const out = [];
+    const brand = theme.silver(`\x1b[1m◆ ${truncate(config.ui.title, Math.max(8, width - 4))}${RESET}`);
+    const subtitle = config.ui.subtitle
+        ? theme.dark("  ·  ") + theme.dark(`\x1b[3m${truncate(config.ui.subtitle, Math.max(8, width - 2))}\x1b[23m`)
+        : "";
+    out.push(visibleLength(brand + subtitle) <= width + 6 ? brand + subtitle : brand);
+    if (rows.length) {
+        out.push("");
+        for (const [label, value, emphasis] of rows) {
+            const testo = truncate(value, Math.max(10, width - labelWidth - 4));
+            const valore = emphasis ? theme.accent(`\x1b[1m${testo}${RESET}`) : theme.silver(testo);
+            out.push(theme.accent("▪ ") + theme.dark(padRight(label, labelWidth)) + "  " + valore);
+        }
+    }
+    out.push("");
+    out.push(commandsHint(theme, width));
+    return out;
+}
+// Stessa taglia dell'avvio dev di Horizon (scripts/dev.js: 30x14) quando lo
+// spazio c'e': il marchio deve essere IDENTICO nei due avvii.
+function logoSize(columns) {
+    if (columns >= 92)
+        return { columns: 30, rows: 14, samples: 4, ansi: true };
+    if (columns >= 64)
+        return { columns: 20, rows: 10, samples: 4, ansi: true };
+    return { columns: 16, rows: 8, samples: 4, ansi: true };
+}
+function beside(left, right, gap) {
+    const width = Math.max(0, ...left.map(visibleLength));
+    const rows = Math.max(left.length, right.length);
+    const out = [];
+    for (let i = 0; i < rows; i += 1) {
+        const l = left[i] ?? "";
+        const r = right[i] ?? "";
+        out.push(`${padRight(l, width)}${" ".repeat(gap)}${r}`.replace(/\s+$/g, ""));
+    }
+    return out;
+}
+function stack(logo, card) {
+    if (!logo.length)
+        return card.map((line) => `  ${line}`);
+    return [...logo, "", ...card.map((line) => `  ${line}`)];
+}
+function providerFromModel(model) {
+    const index = model.indexOf("/");
+    return index > 0 ? model.slice(0, index) : "auto";
+}
+function sessionLabel(meta) {
+    const id = meta.sessionId ?? "nuova";
+    const nodes = meta.sessionNodes ?? 0;
+    const head = meta.headId ? ` · head ${meta.headId.slice(0, 8)}` : "";
+    return `${id} · ${nodes} nodi${head}`;
+}
+function compactPath(path, max) {
+    if (path.length <= max)
+        return path;
+    const parts = path.split(/[\\/]/).filter(Boolean);
+    const tail = parts.slice(-2).join("/");
+    const prefix = path.startsWith("\\\\") ? "\\\\" : path[1] === ":" ? `${path.slice(0, 2)}/` : ".../";
+    const compact = `${prefix}.../${tail}`;
+    return compact.length <= max ? compact : `.../${tail}`.slice(0, max);
+}
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    if (max <= 1)
+        return value.slice(0, max);
+    return `${value.slice(0, max - 1)}…`;
+}
+function wrapText(text, width) {
+    return text.split("\n").flatMap((line) => wrapLine(line, width));
+}
+function wrapLine(line, width) {
+    if (!line)
+        return [""];
+    const out = [];
+    let rest = line;
+    while (visibleLength(rest) > width) {
+        const slice = rest.slice(0, width + 1);
+        const breakAt = Math.max(slice.lastIndexOf(" "), slice.lastIndexOf("\t"));
+        const cut = breakAt > Math.floor(width * 0.55) ? breakAt : width;
+        out.push(rest.slice(0, cut).trimEnd());
+        rest = rest.slice(cut).trimStart();
+    }
+    out.push(rest);
+    return out;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function padRight(value, width) {
+    const pad = width - visibleLength(value);
+    return pad > 0 ? `${value}${" ".repeat(pad)}` : value;
+}
+export function visibleLength(value) {
+    return value.replace(/\x1b\[[0-9;]*m/g, "").length;
+}