@vascend/talos 0.1.0

package/dist/tui/markdown.js

@@ -0,0 +1,257 @@
+import { fileLink, highlightDanilov, isDanilovLine } from "./branding.js";
+import { isImagePath, renderImageFile } from "./images.js";
+import { isAbsolute, resolve } from "node:path";
+import { wrapInline } from "./markdown-inline.js";
+import { isTableSeparator, renderTable, tableCells } from "./markdown-table.js";
+import { terminalWidth, wrapText } from "./terminal-text.js";
+export function renderMarkdown(text, opts) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const out = [];
+    let codeLang = null;
+    let codeLines = [];
+    const flushCode = () => {
+        if (codeLang === null)
+            return;
+        out.push(...renderCodeBlock(codeLines, codeLang, opts));
+        codeLang = null;
+        codeLines = [];
+    };
+    for (let index = 0; index < lines.length; index++) {
+        const raw = lines[index];
+        const fence = /^```\s*([\w-]+)?\s*$/.exec(raw);
+        if (fence) {
+            if (codeLang !== null) {
+                flushCode();
+            }
+            else {
+                codeLang = fence[1] ?? "text";
+                codeLines = [];
+            }
+            continue;
+        }
+        if (codeLang !== null) {
+            codeLines.push(raw);
+            continue;
+        }
+        if (raw.includes("|") && isTableSeparator(lines[index + 1] ?? "")) {
+            const header = tableCells(raw);
+            const separator = tableCells(lines[index + 1]);
+            if (header.length === separator.length) {
+                const rows = [];
+                index += 1;
+                while (lines[index + 1]?.trim() && lines[index + 1].includes("|")) {
+                    rows.push(tableCells(lines[++index]));
+                }
+                out.push(...renderTable(header, separator, rows, opts.width, opts.theme));
+                continue;
+            }
+        }
+        out.push(...renderMarkdownLine(raw, opts));
+    }
+    flushCode();
+    return out.length ? out : [""];
+}
+function renderMarkdownLine(raw, opts) {
+    const line = raw.trimEnd();
+    if (!line.trim())
+        return [""];
+    // Immagine markdown ![alt](path): se locale e il terminale supporta grafica,
+    // la disegna inline; altrimenti mostra una didascalia con link al file.
+    const image = /^!\[([^\]]*)]\(([^)]+)\)\s*$/.exec(line);
+    if (image) {
+        const alt = (image[1] ?? "").trim();
+        const src = (image[2] ?? "").trim();
+        const caption = opts.theme.dark(`[immagine]${alt ? ` ${alt}` : ""}`);
+        const ctx = opts.imageCtx;
+        const isRemote = /^https?:\/\//i.test(src);
+        if (ctx && !isRemote && isImagePath(src)) {
+            const abs = isAbsolute(src) ? src : resolve(ctx.cwd, src);
+            const seq = renderImageFile(abs, ctx.env);
+            if (seq)
+                return [caption, seq];
+            return [caption + opts.theme.dim(`  ${fileLink(abs, src)}`)];
+        }
+        return [caption + opts.theme.dim(`  ${src}`)];
+    }
+    const heading = /^(#{1,6})\s+(.+)$/.exec(line);
+    if (heading) {
+        const text = heading[2] ?? "";
+        return wrapInline(text, opts.width, opts.theme, 0, s => opts.theme.bold((opts.theme.markdownHeading ?? opts.theme.silver)(s)));
+    }
+    const quote = /^>\s?(.*)$/.exec(line);
+    if (quote) {
+        return wrapStyled(quote[1] ?? "", Math.max(8, opts.width - 2), (s) => opts.theme.dark(`│ ${s}`));
+    }
+    const task = /^\s*[-*+] \[([ xX])]\s+(.*)$/.exec(line);
+    if (task) {
+        const mark = task[1]?.toLowerCase() === "x" ? "[x] " : "[ ] ";
+        return wrapInline(`${mark}${task[2] ?? ""}`, opts.width, opts.theme, 4);
+    }
+    const list = /^(\s*)([-*+] |\d+[.)] )(.*)$/.exec(line);
+    if (list) {
+        const marker = (list[2] ?? "- ").trim();
+        const text = list[3] ?? "";
+        const bullet = /^\d/.test(marker) ? `${marker} ` : "• ";
+        const indent = " ".repeat(Math.min(list[1].length, Math.max(0, opts.width - 6)));
+        const prefix = indent + bullet;
+        return wrapInline(text, Math.max(2, opts.width - terminalWidth(prefix)), opts.theme).map((row, index) => (index === 0 ? (opts.theme.markdownBullet ?? opts.theme.accent)(prefix) : " ".repeat(terminalWidth(prefix))) + row);
+    }
+    const hr = /^\s*(-{3,}|_{3,}|\*{3,})\s*$/.exec(line);
+    if (hr)
+        return [opts.theme.dark("─".repeat(Math.min(opts.width, 60)))];
+    // Notazione Danilov (riga di sezione INDICE/.../OUTPUT, @tag, relazione ->):
+    // la coloriamo QUI con i ruoli cromatici del formato, PRIMA che renderInline
+    // la avvolga in ANSI (che disattiverebbe highlightDanilov a valle). Wrappa
+    // sul PLAIN (highlightDanilov inserisce ANSI che non si possono spezzare),
+    // poi colora ogni riga risultante. Le continuazioni hanno un hanging indent.
+    if (isDanilovLine(line)) {
+        const parts = wrapPlain(line, opts.width);
+        if (parts.length <= 1)
+            return [highlightDanilov(line, opts.theme)];
+        return parts.map((part, index) => index === 0
+            ? highlightDanilov(part, opts.theme)
+            : opts.theme.dark("  ") + highlightDanilov(part, opts.theme));
+    }
+    return wrapInline(line, opts.width, opts.theme, 0);
+}
+function renderCodeBlock(lines, lang, opts) {
+    if (lang.toLowerCase() === "mermaid")
+        return renderMermaid(lines, opts);
+    const label = lang && lang !== "text" ? ` ${lang} ` : " code ";
+    const width = opts.width;
+    const top = opts.theme.dark(`╭─${label}${"─".repeat(Math.max(0, width - visibleLength(label) - 2))}`);
+    const body = lines.length ? lines : [""];
+    return [
+        top,
+        ...body.flatMap((line) => wrapPlain(line || " ", Math.max(8, width - 2)).map((part) => opts.theme.dark("│ ") + opts.theme.silver(part))),
+        opts.theme.dark(`╰${"─".repeat(Math.max(0, width - 1))}`),
+    ];
+}
+function renderMermaid(lines, opts) {
+    const kind = detectMermaidKind(lines);
+    const width = opts.width;
+    const title = ` mermaid · ${kind} `;
+    // View renderizzata per i tipi supportati; altrimenti sorgente pulito.
+    const view = kind === "flowchart" ? renderFlowchartView(lines, opts) :
+        kind === "sequence" ? renderSequenceView(lines, opts) :
+            kind === "pie" ? renderPieView(lines, opts) :
+                null;
+    const body = view && view.length ? view : (lines.length ? lines.map((l) => opts.theme.accent(l)) : [opts.theme.dim("(vuoto)")]);
+    return [
+        opts.theme.dark(`╭─${title}${"─".repeat(Math.max(0, width - visibleLength(title) - 2))}`),
+        ...body.flatMap((line) => wrapPlain(line, Math.max(8, width - 4)).map((part) => opts.theme.dark("│ ") + part)),
+        opts.theme.dark(`╰${"─".repeat(Math.max(0, width - 1))}`),
+    ];
+}
+// --- Mermaid view (ASCII) ---------------------------------------------------
+// Estrae l'etichetta da una definizione nodo: A[Testo] / A(Testo) / A{Testo}
+// / A((Testo)). Aggiorna la mappa etichette.
+function harvestNodeLabels(token, labels) {
+    const m = /^([A-Za-z0-9_]+)\s*(?:\[([^\]]*)\]|\(\(([^)]*)\)\)|\(([^)]*)\)|\{([^}]*)\})?/.exec(token.trim());
+    if (!m)
+        return token.trim();
+    const id = m[1] ?? token.trim();
+    const label = (m[2] ?? m[3] ?? m[4] ?? m[5] ?? "").trim();
+    if (label)
+        labels.set(id, label);
+    return id;
+}
+function nodeLabel(id, labels) {
+    return labels.get(id) ?? id;
+}
+function renderFlowchartView(lines, opts) {
+    const labels = new Map();
+    const edges = [];
+    const edgeRe = /^(.+?)\s*(-->|---|-\.->|==>)\s*(?:\|([^|]*)\|\s*)?(.+)$/;
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line || /^(graph|flowchart)\b/i.test(line) || line.startsWith("%%"))
+            continue;
+        const m = edgeRe.exec(line);
+        if (m) {
+            const from = harvestNodeLabels(m[1] ?? "", labels);
+            const label = (m[3] ?? "").trim();
+            const to = harvestNodeLabels(m[4] ?? "", labels);
+            edges.push({ from, to, label });
+        }
+        else {
+            harvestNodeLabels(line, labels);
+        }
+    }
+    if (!edges.length)
+        return [];
+    return edges.map(({ from, to, label }) => {
+        const arrow = label ? opts.theme.dim(` ──(${label})──▶ `) : opts.theme.dim(" ──▶ ");
+        return opts.theme.accent(`[${nodeLabel(from, labels)}]`) + arrow + opts.theme.accent(`[${nodeLabel(to, labels)}]`);
+    });
+}
+function renderSequenceView(lines, opts) {
+    const out = [];
+    const msgRe = /^(.+?)\s*(->>|-->>|->|-->|-x|--x)\s*(.+?)\s*:\s*(.*)$/;
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line || /^sequenceDiagram\b/i.test(line) || line.startsWith("%%"))
+            continue;
+        const part = /^(participant|actor)\s+(.+)$/i.exec(line);
+        if (part) {
+            out.push(opts.theme.dim("• ") + opts.theme.accent((part[2] ?? "").trim()));
+            continue;
+        }
+        const m = msgRe.exec(line);
+        if (m) {
+            const dashed = (m[2] ?? "").includes("--");
+            const arrow = dashed ? " ┈┈▶ " : " ──▶ ";
+            out.push(opts.theme.accent((m[1] ?? "").trim()) + opts.theme.dim(arrow) + opts.theme.accent((m[3] ?? "").trim()) +
+                opts.theme.dim(`  : ${(m[4] ?? "").trim()}`));
+        }
+    }
+    return out;
+}
+function renderPieView(lines, opts) {
+    const slices = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        const m = /^"([^"]+)"\s*:\s*([\d.]+)$/.exec(line);
+        if (m)
+            slices.push({ label: m[1] ?? "", value: Number(m[2] ?? 0) });
+    }
+    if (!slices.length)
+        return [];
+    const total = slices.reduce((a, s) => a + s.value, 0) || 1;
+    const labelWidth = Math.min(20, Math.max(...slices.map((s) => s.label.length)));
+    return slices.map((s) => {
+        const pct = s.value / total;
+        const bars = Math.round(pct * 24);
+        const label = s.label.padEnd(labelWidth).slice(0, labelWidth);
+        return opts.theme.accent(label) + " " + opts.theme.silver("█".repeat(bars)) + opts.theme.dim(` ${Math.round(pct * 100)}%`);
+    });
+}
+function detectMermaidKind(lines) {
+    const first = lines.map((line) => line.trim()).find(Boolean) ?? "diagram";
+    if (/^(graph|flowchart)\b/i.test(first))
+        return "flowchart";
+    if (/^sequenceDiagram\b/i.test(first))
+        return "sequence";
+    if (/^classDiagram\b/i.test(first))
+        return "class";
+    if (/^stateDiagram/i.test(first))
+        return "state";
+    if (/^erDiagram\b/i.test(first))
+        return "er";
+    if (/^gantt\b/i.test(first))
+        return "gantt";
+    if (/^pie\b/i.test(first))
+        return "pie";
+    return "diagram";
+}
+function wrapStyled(text, width, style) {
+    return wrapPlain(text, width).map(style);
+}
+export function wrapPlain(text, width) {
+    if (width <= 0)
+        return [text];
+    return wrapText(text, width, true);
+}
+function visibleLength(value) {
+    return value.replace(/\x1b\[[0-9;]*m/g, "").length;
+}

package/dist/tui/mcp-transcript.d.ts

@@ -0,0 +1,7 @@
+import type { ToolCallPart } from "../core/types.js";
+import type { TuiTheme } from "./branding.js";
+export declare function mcpName(name: string): string | undefined;
+export type McpState = "running" | "ok" | "error" | "stopped";
+export declare function mcpHeader(state: McpState, t: TuiTheme, columns: number): string;
+export declare function mcpPreview(call: ToolCallPart, t: TuiTheme, columns: number, state?: McpState): string[];
+export declare function mcpOutput(output: string, isError: boolean | undefined, t: TuiTheme, columns: number): string[];

package/dist/tui/mcp-transcript.js

@@ -0,0 +1,40 @@
+import { fitLine, plainText, wrapText } from "./terminal-text.js";
+import { tr } from "./i18n.js";
+// MCP clients expose either mcp__server__tool or server.tool names.
+export function mcpName(name) {
+    const prefixed = /^mcp__(.+?)__(.+)$/.exec(name);
+    if (prefixed)
+        return `${prefixed[1]}.${prefixed[2]}`;
+    return /^[\w-]+\.[\w.-]+$/.test(name) ? name : undefined;
+}
+export function mcpHeader(state, t, columns) {
+    const color = state === "ok" ? t.green : state === "error" ? t.red : t.yellow;
+    const label = { running: tr("Esegue", "Calling"), ok: tr("Eseguito", "Called"),
+        error: tr("Errore", "Error"), stopped: tr("Fermato", "Stopped") }[state];
+    return fitLine("  " + color("● ") + t.bold(label), Math.max(1, columns - 1));
+}
+function previewRows(text, columns, limit) {
+    const width = Math.max(2, columns - 5);
+    const clean = plainText(text);
+    // Bound segmentation work even for multi-megabyte tool results.
+    const rows = wrapText(clean.slice(0, width * limit * 4), width);
+    const truncated = rows.length > limit || clean.length > width * limit * 4;
+    const visible = rows.slice(0, limit);
+    if (truncated)
+        visible.push(tr("… Ctrl+R dettagli", "… Ctrl+R details"));
+    return visible;
+}
+export function mcpPreview(call, t, columns, state = "running") {
+    const name = plainText(mcpName(call.name) ?? call.name);
+    const rows = previewRows(name + "(" + JSON.stringify(call.input) + ")", columns, 2);
+    let offset = 0;
+    return [mcpHeader(state, t, columns), ...rows.map((row, i) => {
+            const end = Math.max(0, Math.min(row.length, name.length - offset));
+            offset += row.length;
+            const cyan = t.markdownLink ?? t.accent;
+            return fitLine(t.dim(i === 0 ? "  └ " : "    ") + cyan(row.slice(0, end)) + t.dim(row.slice(end)), Math.max(1, columns - 1));
+        })];
+}
+export function mcpOutput(output, isError, t, columns) {
+    return previewRows(output || tr("(nessun output)", "(no output)"), columns, 2).map(row => fitLine("    " + (isError ? t.red : t.dim)(row), Math.max(1, columns - 1)));
+}

package/dist/tui/model-details.d.ts

@@ -0,0 +1,2 @@
+import type { CatalogModel } from "../providers/model-catalog.js";
+export declare function modelDetail(model: CatalogModel): string;

package/dist/tui/model-details.js

@@ -0,0 +1,21 @@
+import { modelEfforts } from "../providers/model-effort.js";
+export function modelDetail(model) {
+    const yes = (v) => v === undefined ? "?" : v ? "sì" : "no";
+    const count = (n) => n === undefined ? "?" : n.toLocaleString("en-US");
+    const efforts = modelEfforts(`${model.provider}/${model.id}`, model).filter(Boolean);
+    const controls = model.reasoningOptions?.map(o => o.type === "effort" ? `effort ${o.values.join(" / ")}`
+        : o.type === "toggle" ? "on/off" : `budget token ${o.min ?? "?"}–${o.max ?? "?"}`).join("; ");
+    return [model.name, model.description,
+        `Contesto ${count(model.context)} · output ${count(model.outputLimit)}${model.inputLimit ? ` · input ${count(model.inputLimit)}` : ""}`,
+        `Reasoning ${yes(model.reasoning)}${controls ? ` (${controls})` : ""}`,
+        `Effort in Talos: ${efforts.length ? efforts.join(" / ") : "predefinito"}`,
+        `Tool ${yes(model.toolCall)} · JSON strutturato ${yes(model.structuredOutput)} · temperatura ${yes(model.temperature)}`,
+        `Input: ${model.inputModalities.join(", ") || "?"} · output: ${model.outputModalities.join(", ") || "?"}`,
+        `Allegati ${yes(model.attachment)} · pesi aperti ${yes(model.openWeights)}`,
+        `USD/1M token: ${Object.entries(model.cost).map(([key, value]) => `${key} $${value}`).join(" · ") || "non disponibili"}`,
+        model.knowledge ? `Conoscenze: ${model.knowledge}` : "",
+        model.releaseDate ? `Rilasciato: ${model.releaseDate}` : "",
+        model.updatedAt ? `Dati aggiornati: ${model.updatedAt}` : "", model.status,
+        "Fonte: models.dev · prezzi API di base; fasce, modalità e abbonamenti possono differire",
+    ].filter(Boolean).join("\n");
+}

package/dist/tui/model-selection.d.ts

@@ -0,0 +1,7 @@
+import type { Harness } from "../core/bootstrap.js";
+import { type ModelEffort } from "../providers/model-effort.js";
+import type { InputControl } from "./repl.js";
+import type { TuiTheme } from "./branding.js";
+import { selectOption } from "./selector.js";
+export declare function pickEffort(fullModel: string, harness: Harness, ctl: InputControl, theme: TuiTheme, terminalColumns: () => number, select?: typeof selectOption): Promise<ModelEffort | null>;
+export declare function applyModelChoice(model: string, harness: Harness, ctl: InputControl, theme: TuiTheme, terminalColumns: () => number, select?: typeof selectOption): Promise<boolean>;

package/dist/tui/model-selection.js

@@ -0,0 +1,41 @@
+import { saveGlobalSettings } from "../core/settings.js";
+import { cachedModelCatalog, loadModelsDev } from "../providers/models-dev.js";
+import { modelEfforts } from "../providers/model-effort.js";
+import { selectOption } from "./selector.js";
+import { notifyStatus } from "./command-feedback.js";
+const descriptions = {
+    "": "Impostazione predefinita del provider", none: "Reasoning disattivato", minimal: "Ragionamento minimo",
+    low: "Ragionamento leggero", medium: "Ragionamento intermedio", high: "Ragionamento approfondito",
+    xhigh: "Ragionamento molto approfondito", max: "Massimo livello disponibile per questo modello",
+};
+export async function pickEffort(fullModel, harness, ctl, theme, terminalColumns, select = selectOption) {
+    const metadata = cachedModelCatalog(harness.env).get(fullModel);
+    const levels = modelEfforts(fullModel, metadata);
+    const selected = await select({
+        title: `${metadata?.name ?? fullModel.split("/").pop()} · effort`,
+        hint: levels.length > 1 ? "Un livello maggiore può richiedere più tempo e token. Esc annulla la scelta del modello."
+            : metadata?.reasoning === false ? "Questo modello non supporta reasoning."
+                : "Nessun controllo effort verificato per questo modello e provider: usa il predefinito.",
+        options: levels.map(level => ({ key: level, label: level || "default", detail: descriptions[level], value: level })),
+        currentKey: levels.includes(harness.config.effort) ? harness.config.effort : "",
+        ctl, theme, terminalColumns,
+    });
+    return selected?.value ?? null;
+}
+export async function applyModelChoice(model, harness, ctl, theme, terminalColumns, select = selectOption) {
+    const resolved = harness.providers.resolve(model);
+    if (!resolved) {
+        notifyStatus(ctl, `Provider non configurato per ${model}`, true);
+        return false;
+    }
+    const fullModel = `${resolved.provider.id}/${resolved.modelId}`;
+    await loadModelsDev(harness.env);
+    const effort = await pickEffort(fullModel, harness, ctl, theme, terminalColumns, select);
+    if (effort === null)
+        return false;
+    saveGlobalSettings(harness.env, { model: fullModel, effort });
+    harness.setModel(fullModel);
+    harness.config = { ...harness.config, effort };
+    ctl.refresh?.();
+    return true;
+}

package/dist/tui/native-scrollback.d.ts

@@ -0,0 +1,27 @@
+export interface ScrollbackLine {
+    readonly id: number;
+    readonly text: string;
+    readonly through?: number;
+}
+export interface ScrollbackInput {
+    readonly lines: readonly string[];
+    readonly cursorRow: number;
+    readonly cursorCol: number;
+}
+export declare class NativeScrollback {
+    private committedThrough;
+    private readonly history;
+    private frame;
+    private tail;
+    private cursorRow;
+    private cursorCol;
+    private width;
+    private height;
+    private invalidated;
+    private preamble;
+    isCommitted(id: number): boolean;
+    invalidate(): void;
+    reset(): string;
+    render(log: readonly ScrollbackLine[], input: ScrollbackInput, width: number, height: number, hideCursor?: boolean, preamble?: readonly string[]): string;
+    release(): string;
+}

package/dist/tui/native-scrollback.js

@@ -0,0 +1,134 @@
+import { fitLine } from "./terminal-text.js";
+const RESET = "\x1b[0m\x1b]8;;\x1b\\";
+const SYNC_ON = "\x1b[?2026h";
+const SYNC_OFF = "\x1b[?2026l";
+const move = (from, to) => from === to ? "\r"
+    : `\r\x1b[${Math.abs(from - to)}${to < from ? "A" : "B"}`;
+// Main-buffer renderer. Completed rows are written with real newlines and
+// remain in the terminal's native scrollback. Only a short recent tail and
+// the composer are mutable; cursor movement never targets archived rows.
+export class NativeScrollback {
+    committedThrough = 0;
+    history = [];
+    frame = [];
+    tail = [];
+    cursorRow = 0;
+    cursorCol = 1;
+    width = 0;
+    height = 0;
+    invalidated = false;
+    preamble = [];
+    isCommitted(id) { return id <= this.committedThrough; }
+    // Even a resize burst ending at the original size may have moved the frame.
+    invalidate() { this.invalidated = true; }
+    // A session change replaces both the visible frame and native scrollback.
+    reset() {
+        this.committedThrough = 0;
+        this.history.length = 0;
+        this.frame = [];
+        this.tail = [];
+        this.cursorRow = 0;
+        this.cursorCol = 1;
+        this.width = 0;
+        this.height = 0;
+        this.invalidated = false;
+        this.preamble = [];
+        return SYNC_ON + RESET + "\x1b[2J\x1b[3J\x1b[H" + SYNC_OFF;
+    }
+    render(log, input, width, height, hideCursor = false, preamble = []) {
+        if (width < 1 || height < 1)
+            return "";
+        const columns = Math.max(1, width);
+        const rows = Math.max(1, height);
+        const textWidth = Math.max(1, columns - 1);
+        const preambleChanged = preamble.length !== this.preamble.length || preamble.some((line, i) => line !== this.preamble[i]);
+        const resized = this.width !== 0 && (this.invalidated || this.width !== columns || this.height !== rows || preambleChanged);
+        // Reflow differs between xterm, ConPTY and restored/shared terminals. Once
+        // transient rows enter scrollback, relative cursor moves cannot erase them.
+        // Rebuild from the transcript instead of guessing where the old frame went.
+        if (resized) {
+            this.frame = [];
+            this.cursorRow = 0;
+            this.cursorCol = 1;
+        }
+        const capacity = Math.max(1, rows - 2);
+        const offset = Math.max(0, Math.min(input.cursorRow, input.lines.length - capacity));
+        const live = input.lines.slice(offset, offset + capacity).map(line => fitLine(line, textWidth));
+        // IDs are monotonic, including folded ranges. Skip archived history in
+        // logarithmic time instead of scanning thousands of rows every frame.
+        let low = 0;
+        let high = log.length;
+        while (low < high) {
+            const middle = low + Math.floor((high - low) / 2);
+            if (this.isCommitted(log[middle].id))
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        const pending = log.slice(low);
+        const keep = Math.max(0, Math.min(8, rows - live.length - 1));
+        const split = Math.max(0, pending.length - keep);
+        const committed = pending.slice(0, split);
+        const tail = pending.slice(split);
+        const frame = [...tail.map(line => fitLine(line.text, textWidth)), ...live];
+        const row = tail.length + Math.max(0, Math.min(input.cursorRow - offset, live.length - 1));
+        const col = Math.max(1, Math.min(input.cursorCol, textWidth));
+        let start = 0;
+        if (!committed.length && !resized) {
+            while (start < frame.length && start < this.frame.length && frame[start] === this.frame[start])
+                start++;
+        }
+        const changed = committed.length > 0 || resized || start < Math.max(frame.length, this.frame.length);
+        if (!changed && row === this.cursorRow && col === this.cursorCol)
+            return "";
+        let out = SYNC_ON;
+        if (resized)
+            out += RESET + "\x1b[2J\x1b[3J\x1b[H";
+        if (resized || this.width === 0) {
+            for (const line of preamble)
+                out += fitLine(line, textWidth) + RESET + "\r\n";
+            for (const line of this.history)
+                out += fitLine(line.text, textWidth) + RESET + "\r\n";
+        }
+        let current = this.cursorRow;
+        if (changed) {
+            out += move(current, start) + "\x1b[J";
+            for (const line of committed)
+                out += fitLine(line.text, textWidth) + RESET + "\r\n";
+            out += frame.slice(start).map(line => line + RESET).join("\r\n");
+            current = Math.max(start, frame.length - 1);
+        }
+        out += move(current, row) + `\x1b[${col}G` + (hideCursor ? "\x1b[?25l" : "\x1b[?25h") + SYNC_OFF;
+        if (committed.length)
+            this.committedThrough = Math.max(this.committedThrough, committed.at(-1).through ?? committed.at(-1).id);
+        for (const line of committed)
+            this.history.push(line);
+        this.frame = frame;
+        this.tail = tail;
+        this.cursorRow = row;
+        this.cursorCol = col;
+        this.width = columns;
+        this.height = rows;
+        this.invalidated = false;
+        this.preamble = preamble.slice();
+        return out;
+    }
+    // Yield stdout to a picker or return to the shell. Keep the conversation,
+    // remove the transient input/status area, and leave a clean new line.
+    release() {
+        if (!this.frame.length)
+            return "";
+        const out = SYNC_ON + move(this.cursorRow, 0) + "\x1b[J"
+            + this.tail.map(line => fitLine(line.text, Math.max(1, this.width - 1)) + RESET + "\r\n").join("")
+            + "\x1b[?25h" + SYNC_OFF;
+        if (this.tail.length)
+            this.committedThrough = Math.max(this.committedThrough, this.tail.at(-1).through ?? this.tail.at(-1).id);
+        for (const line of this.tail)
+            this.history.push(line);
+        this.frame = [];
+        this.tail = [];
+        this.cursorRow = 0;
+        this.cursorCol = 1;
+        return out;
+    }
+}

package/dist/tui/onboarding.d.ts

@@ -0,0 +1,72 @@
+import { type Language, type LanguagePreference } from "./locales.js";
+export type Lingua = Language;
+export declare const LINGUE: readonly [{
+    readonly id: "it";
+    readonly nome: "Italiano";
+}, {
+    readonly id: "en";
+    readonly nome: "English";
+}, {
+    readonly id: "es";
+    readonly nome: "Español";
+}, {
+    readonly id: "de";
+    readonly nome: "Deutsch";
+}];
+export declare const TERMINI_VERSIONE = "2026-08";
+export declare const LINK_TERMINI = "https://vascend.it/terms";
+export declare const LINK_PRIVACY = "https://vascend.it/privacy";
+export interface StatoOnboarding {
+    readonly lingua?: Lingua;
+    readonly languagePreference?: LanguagePreference;
+    readonly terminiVersione?: string;
+    readonly terminiQuando?: string;
+}
+export declare function leggiOnboarding(env: NodeJS.ProcessEnv): StatoOnboarding;
+export declare function salvaOnboarding(env: NodeJS.ProcessEnv, stato: StatoOnboarding): boolean;
+export declare function serveLingua(stato: StatoOnboarding): boolean;
+export declare function serveTermini(stato: StatoOnboarding): boolean;
+export declare function consensoAffermativo(risposta: string, lingua: Lingua): boolean;
+export interface TestiIngresso {
+    readonly byline: string;
+    readonly linguaTitolo: string;
+    readonly linguaPrompt: string;
+    readonly linguaNonValida: string;
+    readonly terminiTitolo: string;
+    readonly terminiCorpo: string;
+    readonly terminiStessiLink: string;
+    readonly terminiEtichetta: string;
+    readonly privacyEtichetta: string;
+    readonly terminiDomanda: string;
+    readonly terminiRifiutati: string;
+    readonly accessoTitolo: string;
+    readonly serveAccount: string;
+    readonly nessunaPassword: string;
+    readonly verificoAccesso: string;
+    readonly emailPrompt: string;
+    readonly serveEmail: string;
+    readonly contatto: (email: string) => string;
+    readonly accountNuovo: string;
+    readonly nomePrompt: string;
+    readonly cognomePrompt: string;
+    readonly registro: string;
+    readonly codiceInviato: string;
+    readonly codicePrompt: string;
+    readonly verifico: string;
+    readonly secondoFattore: string;
+    readonly totpPrompt: string;
+    readonly verifico2fa: string;
+    readonly identita: (chi: string) => string;
+    readonly tokenNonSalvabile: string;
+    readonly ritiroLicenza: string;
+    readonly licenzaPronta: string;
+    readonly licenzaNonDisponibile: string;
+    readonly benvenuto: (nome: string) => string;
+    readonly accessoNota: (chi: string) => string;
+    readonly ripartiamo: string;
+    readonly codiceNonValido: string;
+    readonly troppiTentativi: string;
+    readonly accessoAnnullato: string;
+    readonly uscireHint: string;
+}
+export declare const TESTI: Readonly<Record<Lingua, TestiIngresso>>;