@vascend/talos 0.1.0

package/dist/tui/bottom-input.js

@@ -0,0 +1,1958 @@
+import { tr } from "./i18n.js";
+import { stdin, stdout } from "node:process";
+import { pulseGlyph, pulseToolName } from "./tool-style.js";
+import { fitLine, plainText, terminalWidth, wrapText } from "./terminal-text.js";
+import { PromptQueue } from "./prompt-queue.js";
+import { QueueScreen, queuePreview } from "./queue-screen.js";
+import { createAttachmentHighlighter } from "./attachment-highlight.js";
+import { NativeScrollback } from "./native-scrollback.js";
+import { QueuedQuestions } from "./queued-questions.js";
+const SYNC_ON = "\x1b[?2026h";
+const SYNC_OFF = "\x1b[?2026l";
+const ALT_ON = "\x1b[?1049h";
+const ALT_OFF = "\x1b[?1049l";
+// Lascia click e trascinamento al terminale per la selezione nativa.
+// Alternate scroll converte la rotella in frecce, gestite da onArrow.
+// Disabilita anche eventuali modalita' ereditate da altre applicazioni.
+export const NATIVE_SELECTION_MODE = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1007h";
+export const NATIVE_SCROLL_MODE = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1007l";
+// Bracketed paste (DEC 2004): il terminale racchiude il testo incollato tra
+// ESC[200~ ed ESC[201~. Cosi' distinguiamo un INCOLLO da una digitazione: un
+// path/data-URI incollato puo' diventare un allegato "img #N" invece di finire
+// crudo nel buffer (parita' Claude Code).
+const PASTE_ON = "\x1b[?2004h";
+const PASTE_OFF = "\x1b[?2004l";
+const SPINNER = ["✶", "✸", "✺", "✹", "✷", "✦"];
+const MAX_LOG = 5000;
+const SCROLL_FRAME_MS = 16;
+const RESIZE_SETTLE_MS = 80;
+const WHEEL_ARROW_LINES = 2;
+const WHEEL_MOUSE_LINES = 4;
+// Chiusura riga: reset SGR (colori/bold/underline) + chiusura hyperlink OSC 8.
+// Va appesa a OGNI riga renderizzata: se una riga apre un link (fileLink) e
+// viene troncata prima del terminatore, senza questo il sottolineato del link
+// "cola" su tutte le righe successive (bug delle linee orizzontali).
+const LINE_END = "\x1b[0m\x1b]8;;\x1b\\";
+// Helper puro: mantiene il confronto dei frame separato dall'I/O del terminale
+// e rende verificabile che uno spinner non ridisegni l'intera chat.
+export function changedFrameRows(previous, next, force = false) {
+    const changed = [];
+    for (let i = 0; i < next.length; i += 1) {
+        if (force || previous[i] !== next[i])
+            changed.push(i);
+    }
+    return changed;
+}
+export class BottomInput {
+    h;
+    buffer = "";
+    cursor = 0;
+    history = [];
+    histIdx = -1;
+    draft = "";
+    active = false;
+    paused = false;
+    ctrlCConfirmation = null;
+    ctrlCTimer;
+    running = false;
+    questions = new QueuedQuestions(() => this.refresh());
+    runAbort;
+    queue;
+    queueEditor = null;
+    // Log della chat (righe gia' formattate) + scroll del viewport (0 = in fondo).
+    log = [];
+    logIds = [];
+    logSeq = 0;
+    nativeOutput = new NativeScrollback();
+    conversationRenderer;
+    conversationColumns = 0;
+    nativeScroll;
+    alternateScreen = false;
+    renderedEntries = [];
+    scrollOffset = 0;
+    logRevision = 0;
+    renderedLogRevision = -1;
+    renderedLogCache = [];
+    // Fold: intervalli del log collassati in una riga di sintesi (ondate di tool,
+    // stile Claude Code "ran N shell commands"). Espandibili con /expand.
+    folds = [];
+    foldSeq = 0;
+    // Viewer dei vassalli (Kingdoms Mode): stream live per-castello, navigabile con
+    // Ctrl+G (entra/cicla) ed Esc (esci). vassals=null quando non c'e' un regno.
+    vassals = null;
+    vassalIdx = 0;
+    vassalOpen = false;
+    // Board del regno (Kingdoms Mode): righe gia' stilate dal repl, mostrate nella
+    // regione viva (sopra l'input) e aggiornate in place — niente spam nella chat.
+    kingdomBoard = null;
+    overlay = null;
+    screen = null;
+    // Domanda a risposta libera (tool ask_user): quando attiva, l'editing va alla
+    // risposta e Invio/Esc risolvono la promise invece di inviare un prompt.
+    modal = null;
+    statusLabel = null;
+    // Nome GREZZO del tool attualmente in corso (es. "read_file"): pilota colore e
+    // glyph animati nella status-line (pulse abbinato alla categoria). null quando
+    // l'attivita' non e' un singolo tool (es. "elaboro", ondata mista).
+    statusTool = null;
+    // Stato VIVO della stanza Danilov corrente (metodo Vascend): invece di
+    // sputare ogni mark/avvio in chat (rumoroso), la status-line mostra la stanza
+    // attiva e il suo esito, animata. running = punto che pulsa; l'esito
+    // (illuminata/fallita) resta per qualche secondo poi si autospegne.
+    roomStatus = null;
+    roomTimer;
+    startedAt = 0;
+    tokensNew = 0;
+    tokensCache = 0;
+    tokensOut = 0;
+    frame = 0;
+    spinnerTimer;
+    lastLayout;
+    liveStartRow = 1;
+    paintedRows = [];
+    paintedColumns = 0;
+    paintedHeight = 0;
+    paintedCursor = "";
+    lastPaintAt = 0;
+    scrollRenderTimer;
+    quitResolve;
+    dataListener;
+    resizeListener;
+    resizeTimer;
+    // Disambiguazione frecce vs scroll (rotella/touchpad): le frecce ravvicinate
+    // sono uno scroll, una singola e' una pressione vera (history/cursore).
+    pendingArrows = [];
+    arrowTimer;
+    // Dopo aver riconosciuto una raffica come wheel, le eventuali sequenze
+    // residue appartengono allo stesso gesto e non devono raggiungere la history.
+    arrowScrollUntil = 0;
+    // Accumulatore di un incollo (bracketed paste) arrivato su piu' frame: si
+    // riempie finche' non si incontra il terminatore ESC[201~.
+    pasteBuffer = null;
+    capturingImage = false;
+    deferredImageSubmit = null;
+    inputGeneration = 0;
+    escapePending = "";
+    escapeTimer;
+    constructor(h) {
+        this.h = h;
+        this.nativeScroll = h.nativeScroll !== false;
+        this.queue = this.createQueue();
+    }
+    createQueue() {
+        return new PromptQueue(this.h.prepareQueuedInput, () => this.render(), this.h.queuePersistence?.(), this.h.restoreQueuedInput);
+    }
+    restoreQueue() {
+        this.inputGeneration++;
+        this.queue = this.createQueue();
+        this.queueEditor = null;
+        if (this.screen instanceof QueueScreen)
+            this.screen = null;
+        this.render();
+    }
+    get review() { return this.h.review; }
+    get userInbox() { return this.queue.inbox; }
+    acceptQueuedMessage(id) {
+        const text = this.queue.acknowledge(id);
+        if (text)
+            this.history.push(text);
+        return text;
+    }
+    pauseQueuedMessages() { if (this.queue.length) {
+        this.queue.paused = true;
+        this.render();
+    } }
+    showQueue() {
+        if (this.modal || this.overlay || this.queueEditor)
+            return;
+        this.inputGeneration++;
+        if (this.arrowTimer) {
+            clearTimeout(this.arrowTimer);
+            this.arrowTimer = undefined;
+        }
+        this.pendingArrows = [];
+        this.queue.held = true;
+        this.screen = new QueueScreen(this.queue, id => this.editQueuedMessage(id), this.h.queueStyle);
+        this.render();
+    }
+    closeScreen() {
+        if (this.screen instanceof QueueScreen)
+            this.queue.held = false;
+        this.screen = null;
+        this.startNextQueued();
+        this.render();
+    }
+    editQueuedMessage(id) {
+        const entry = this.queue.get(id);
+        if (!entry || !(this.screen instanceof QueueScreen))
+            return;
+        this.inputGeneration++;
+        this.queueEditor = { id, screen: this.screen, draft: { buffer: this.buffer, cursor: this.cursor, histIdx: this.histIdx } };
+        this.screen = null;
+        this.buffer = entry.text;
+        this.cursor = this.buffer.length;
+        this.histIdx = -1;
+        this.render();
+    }
+    finishQueueEdit(save, immediate = false) {
+        const editor = this.queueEditor;
+        if (!editor)
+            return;
+        if (save) {
+            try {
+                if (!this.queue.update(editor.id, this.buffer))
+                    throw new Error("Il messaggio non è più in attesa.");
+            }
+            catch (error) {
+                this.reportFailure(error instanceof Error ? error.message : String(error));
+                return;
+            }
+        }
+        this.buffer = editor.draft.buffer;
+        this.cursor = editor.draft.cursor;
+        this.histIdx = editor.draft.histIdx;
+        this.queueEditor = null;
+        this.screen = editor.screen;
+        if (immediate && this.queue.sendNow(editor.id)) {
+            this.closeScreen();
+            return;
+        }
+        this.render();
+    }
+    showReview(section) {
+        if (!this.h.createReviewScreen || this.modal || this.overlay || this.queueEditor || this.queue.held)
+            return;
+        this.inputGeneration++;
+        if (this.arrowTimer) {
+            clearTimeout(this.arrowTimer);
+            this.arrowTimer = undefined;
+        }
+        this.pendingArrows = [];
+        this.screen = this.h.createReviewScreen(section);
+        this.render();
+    }
+    get screenVisible() { return this.screen !== null && !this.modal && !this.overlay; }
+    static supported() {
+        return Boolean(stdout.isTTY && stdin.isTTY && typeof stdin.setRawMode === "function");
+    }
+    start() {
+        if (!BottomInput.supported())
+            return Promise.resolve();
+        this.active = true;
+        this.alternateScreen = !this.nativeScroll;
+        stdout.write(this.nativeScroll ? "\x1b[2J\x1b[H" + NATIVE_SCROLL_MODE + PASTE_ON
+            : ALT_ON + "\x1b[2J\x1b[H" + NATIVE_SELECTION_MODE + PASTE_ON);
+        stdin.setRawMode(true);
+        stdin.resume();
+        // Parser RAW dello stdin: gestiamo noi mouse e tasti (readline spezzava le
+        // sequenze del mouse, facendone digitare i frammenti nell'input).
+        this.dataListener = (chunk) => this.feed(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+        stdin.on("data", this.dataListener);
+        this.resizeListener = () => this.queueResizeRender();
+        stdout.on("resize", this.resizeListener);
+        this.h.onReady?.();
+        this.render(true);
+        return new Promise((resolve) => { this.quitResolve = resolve; });
+    }
+    // Aggiunge contenuto alla CHAT (log) e mantiene il viewport in fondo.
+    write(text) {
+        this.conversationRenderer = undefined;
+        if (!this.active) {
+            stdout.write(text);
+            return;
+        }
+        const lines = text.replace(/\n+$/, "").split("\n");
+        for (const l of lines) {
+            this.log.push(l);
+            this.logIds.push(++this.logSeq);
+        }
+        this.touchLog();
+        // Se stai leggendo piu' in alto (scrollato), MANTIENI la posizione invece di
+        // strapparti in fondo; se eri in fondo, resti in fondo.
+        if (this.scrollOffset > 0)
+            this.scrollOffset += lines.length;
+        this.render();
+        this.trimLog();
+    }
+    // Forza un re-render del footer/status-line senza scrivere nel log.
+    // Usato per le viste LIVE (es. task in background che cambiano stato).
+    refresh() { if (this.active)
+        this.render(); }
+    // Rebuild a restored conversation from its source on terminal resize. A
+    // subsequent live write takes ownership of the transcript again.
+    replayConversation(renderer) {
+        const columns = this.cols();
+        this.write(renderer(columns));
+        this.conversationRenderer = renderer;
+        this.conversationColumns = columns;
+    }
+    resetConversationLog() {
+        this.log.length = 0;
+        this.logIds.length = 0;
+        this.logSeq = 0;
+        this.folds.length = 0;
+        this.renderedEntries = [];
+        this.renderedLogCache = [];
+        this.touchLog();
+        this.paintedRows = [];
+        this.paintedCursor = "";
+        return this.nativeOutput.reset();
+    }
+    // Forget the previous session's display and editor state before any replay.
+    clearConversation() {
+        this.questions.clear();
+        this.inputGeneration++;
+        this.buffer = "";
+        this.cursor = 0;
+        this.history.length = 0;
+        this.histIdx = -1;
+        this.draft = "";
+        this.conversationRenderer = undefined;
+        this.scrollOffset = 0;
+        this.lastLayout = undefined;
+        this.screen = null;
+        this.overlay = null;
+        this.vassals = null;
+        this.vassalIdx = 0;
+        this.vassalOpen = false;
+        this.kingdomBoard = null;
+        this.statusLabel = null;
+        this.statusTool = null;
+        this.roomStatus = null;
+        this.tokensNew = this.tokensCache = this.tokensOut = 0;
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = undefined;
+        }
+        if (this.roomTimer) {
+            clearTimeout(this.roomTimer);
+            this.roomTimer = undefined;
+        }
+        if (this.arrowTimer) {
+            clearTimeout(this.arrowTimer);
+            this.arrowTimer = undefined;
+        }
+        if (this.scrollRenderTimer) {
+            clearTimeout(this.scrollRenderTimer);
+            this.scrollRenderTimer = undefined;
+        }
+        this.pendingArrows = [];
+        this.arrowScrollUntil = 0;
+        const reset = this.resetConversationLog();
+        if (this.active) {
+            if (this.nativeScroll && this.alternateScreen) {
+                stdout.write(ALT_OFF + NATIVE_SCROLL_MODE);
+                this.alternateScreen = false;
+            }
+            stdout.write(reset);
+            this.render(true);
+        }
+    }
+    // Sostituisce le ULTIME `count` righe del log con `lines`, poi re-renderizza
+    // in place. Pensato per le animazioni dello scrollback (es. intro): si scrive
+    // una volta il blocco con write(), poi si aggiorna lo stesso blocco frame per
+    // frame senza accodare nuove righe. Se non e' attivo, scrive su stdout grezzo.
+    replaceTail(lines, count) {
+        if (!this.active) {
+            stdout.write(lines.join("\n") + "\n");
+            return;
+        }
+        const n = Math.min(count, this.log.length);
+        const ids = this.logIds.splice(this.log.length - n, n);
+        if (n > 0)
+            this.log.splice(this.log.length - n, n);
+        for (const [i, line] of lines.entries()) {
+            this.log.push(line);
+            this.logIds.push(ids[i] ?? ++this.logSeq);
+        }
+        this.touchLog();
+        this.render();
+        this.trimLog();
+    }
+    // Riscrive in place una SINGOLA riga del log (per indice assoluto), poi
+    // re-renderizza. Pensato per l'animazione del bullet ● del tool in corso nello
+    // scrollback: si conosce l'indice della riga "● Nome(arg)" e si aggiorna solo
+    // quella frame per frame, senza accodare nulla. No-op se l'indice e' fuori range.
+    setLogLine(index, text) {
+        if (index < 0 || index >= this.log.length)
+            return;
+        if (this.log[index] === text)
+            return;
+        this.log[index] = text;
+        this.touchLog();
+        if (this.active)
+            this.render();
+    }
+    setTokens(newInput, cache, outTok) {
+        this.tokensNew = newInput;
+        this.tokensCache = cache;
+        this.tokensOut = outTok;
+        if (this.active && this.statusLabel !== null)
+            this.render();
+    }
+    setStatus(label) {
+        this.statusLabel = label;
+        if (label !== null) {
+            if (!this.spinnerTimer)
+                this.spinnerTimer = setInterval(() => { this.frame += 1; this.render(); }, 140);
+        }
+        else if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = undefined;
+        }
+        if (this.active)
+            this.render();
+    }
+    getLogLine(index) { return this.log[index]; }
+    // Stato leggibile dall'host per evitare una seconda telemetria statica mentre
+    // la riga animata del run sta gia' mostrando token, tempo e coda.
+    isBusy() {
+        return this.running || this.statusLabel !== null;
+    }
+    // Nome del tool in corso per l'animazione della status-line. null = attivita'
+    // generica (spinner neutro). Non forza un timer: lo gestisce gia' setStatus.
+    setStatusTool(name) {
+        this.statusTool = name;
+        if (this.active && this.statusLabel !== null)
+            this.render();
+    }
+    // Stato della stanza Danilov (Vascend) per la status-line: niente piu' righe
+    // in chat per avvio/illuminazione. `running` resta finche' la stanza lavora;
+    // `done` si spegne dopo 3s; `failed` resta fino al prossimo invio o avviso.
+    // null lo rimuove subito.
+    setRoomStatus(label, state = "running") {
+        if (this.roomTimer) {
+            clearTimeout(this.roomTimer);
+            this.roomTimer = undefined;
+        }
+        if (!label) {
+            this.roomStatus = null;
+        }
+        else if (state === "running" || state === "failed") {
+            this.roomStatus = { label, state };
+        }
+        else {
+            this.roomStatus = { label, state, until: Date.now() + 3000 };
+            this.roomTimer = setTimeout(() => {
+                // Spegni solo se non e' arrivata nel frattempo una nuova stanza running.
+                if (this.roomStatus?.state === "done") {
+                    this.roomStatus = null;
+                    if (this.active)
+                        this.render();
+                }
+                this.roomTimer = undefined;
+            }, 3000);
+        }
+        // La status-line anima solo col timer dello spinner: se non c'e' un run in
+        // corso (statusLabel null) accendiamo un refresh leggero per il pulse della
+        // stanza running.
+        if (this.active)
+            this.render();
+    }
+    reportFailure(message) {
+        const detail = plainText(message).trim();
+        this.h.review?.record({ type: "error", message: detail });
+        this.setRoomStatus(detail, "failed");
+    }
+    setOverlay(lines) {
+        this.overlay = lines && lines.length
+            ? { lines, cursorRow: lines.length - 1, cursorCol: 1 }
+            : null;
+        if (!this.overlay)
+            this.startNextQueued();
+        if (this.active)
+            this.render();
+    }
+    // Lunghezza attuale del log (indice di inserimento): per delimitare un'ondata.
+    logLength() { return this.log.length; }
+    // Collassa [start, end) del log in una riga di sintesi. Ritorna l'id del fold.
+    fold(start, end, summary) {
+        const id = (this.foldSeq += 1);
+        this.folds.push({ id, start, end, summary, expanded: false, open: false });
+        this.touchLog();
+        if (this.active)
+            this.render();
+        return id;
+    }
+    // Fold APERTO: copre da `start` fino alla fine corrente del log e si estende da
+    // solo man mano che arrivano nuove righe (cosi' durante un'ondata di tool la
+    // chat mostra UNA riga di sintesi che si aggiorna, niente duplicati).
+    openFold(start, summary) {
+        const id = (this.foldSeq += 1);
+        this.folds.push({ id, start, end: start, summary, expanded: false, open: true });
+        this.touchLog();
+        if (this.active)
+            this.render();
+        return id;
+    }
+    updateFoldSummary(id, summary) {
+        const f = this.folds.find((x) => x.id === id);
+        if (!f)
+            return;
+        if (f.summary === summary)
+            return;
+        f.summary = summary;
+        this.touchLog();
+        if (this.active)
+            this.render();
+    }
+    // Aggiorna fine + sintesi di un fold (chiuso). Usato per collassare i tool
+    // GIA' finiti di un'ondata lasciando visibile quello in corso.
+    updateFold(id, end, summary) {
+        const f = this.folds.find((x) => x.id === id);
+        if (!f)
+            return;
+        f.end = end;
+        f.summary = summary;
+        f.open = false;
+        this.touchLog();
+        if (this.active)
+            this.render();
+    }
+    // Apre/chiude (toggle) un fold: per id, o il piu' recente. Ritorna true se
+    // c'era un fold su cui agire.
+    toggleFold(id) {
+        const target = id !== undefined ? this.folds.find((f) => f.id === id) : this.folds[this.folds.length - 1];
+        if (!target)
+            return false;
+        if (!target.expanded && this.reprintArchivedFold(target))
+            return true;
+        target.expanded = !target.expanded;
+        this.touchLog();
+        if (this.active)
+            this.render();
+        return true;
+    }
+    // Chiude un fold aperto: ne fissa la fine (cosi' il contenuto successivo, es.
+    // il testo dell'agente, non viene piu' nascosto).
+    closeFold(id, summary) {
+        const f = this.folds.find((x) => x.id === id);
+        if (!f)
+            return;
+        f.open = false;
+        f.end = this.log.length;
+        if (summary !== undefined)
+            f.summary = summary;
+        this.touchLog();
+        if (this.active)
+            this.render();
+    }
+    // Espande un fold (per id, o il piu' recente non espanso). Ritorna true se uno
+    // e' stato espanso.
+    expandFold(id) {
+        const target = id !== undefined
+            ? this.folds.find((f) => f.id === id && !f.expanded)
+            : [...this.folds].reverse().find((f) => !f.expanded);
+        if (!target)
+            return false;
+        if (this.reprintArchivedFold(target))
+            return true;
+        target.expanded = true;
+        this.touchLog();
+        if (this.active)
+            this.render();
+        return true;
+    }
+    // Rimuove DAVVERO un fold e le righe di log che copriva: il blocco sparisce
+    // dalla chat (niente segnaposto), come si aspetta l'utente quando chiude un
+    // output che non vuole piu' vedere. Gli start/end dei fold successivi vengono
+    // ricompattati. Ritorna true se il fold esisteva.
+    removeFold(id) {
+        const idx = this.folds.findIndex((f) => f.id === id);
+        if (idx < 0)
+            return false;
+        const f = this.folds[idx];
+        const start = f.start;
+        const end = f.open ? this.log.length : f.end;
+        const removed = Math.max(0, end - start);
+        this.folds.splice(idx, 1);
+        if (removed > 0) {
+            this.log.splice(start, removed);
+            this.logIds.splice(start, removed);
+            // Ricompatta gli intervalli dei fold rimasti che stavano dopo la regione.
+            for (const o of this.folds) {
+                if (o.start >= end)
+                    o.start -= removed;
+                if (o.end >= end)
+                    o.end -= removed;
+                else if (o.end > start)
+                    o.end = start;
+            }
+        }
+        this.touchLog();
+        if (this.active)
+            this.render();
+        return true;
+    }
+    // Espande tutti i fold. Ritorna quanti ne ha espansi.
+    expandAllFolds() {
+        let n = 0;
+        for (const f of [...this.folds])
+            if (!f.expanded) {
+                if (!this.reprintArchivedFold(f))
+                    f.expanded = true;
+                n += 1;
+            }
+        if (n)
+            this.touchLog();
+        if (n && this.active)
+            this.render();
+        return n;
+    }
+    reprintArchivedFold(fold) {
+        if (!this.nativeScroll || fold.open || !this.nativeOutput.isCommitted(this.logIds[fold.start] ?? Infinity))
+            return false;
+        const details = this.log.slice(fold.start, fold.end);
+        fold.expanded = true;
+        fold.start = this.log.length;
+        fold.end = fold.start + 1 + details.length;
+        this.write([fold.summary, ...details].join("\n"));
+        return true;
+    }
+    trimLog() {
+        // Native scrollback owns committed rows. The alternate viewport needs the
+        // complete session in memory so a resumed chat remains scrollable in full.
+        if (!this.nativeScroll)
+            return;
+        const count = this.log.length - MAX_LOG;
+        if (count <= 0 || (this.nativeScroll && (this.alternateScreen || this.paused)))
+            return;
+        this.log.splice(0, count);
+        this.logIds.splice(0, count);
+        for (let i = this.folds.length - 1; i >= 0; i--) {
+            const fold = this.folds[i];
+            fold.start = Math.max(0, fold.start - count);
+            fold.end = Math.max(0, fold.end - count);
+            if (!fold.open && fold.end <= fold.start)
+                this.folds.splice(i, 1);
+        }
+        this.touchLog();
+    }
+    // Log con i fold applicati: sostituisce gli intervalli collassati con la sintesi.
+    renderedLog() {
+        if (this.renderedLogRevision === this.logRevision)
+            return this.renderedLogCache;
+        const active = this.folds.filter((f) => !f.expanded).sort((a, b) => a.start - b.start);
+        if (!active.length) {
+            this.renderedEntries = this.log.map((text, index) => ({ text, id: this.logIds[index] }));
+            this.renderedLogRevision = this.logRevision;
+            this.renderedLogCache = this.log;
+            return this.renderedLogCache;
+        }
+        const out = [];
+        const entries = [];
+        let i = 0;
+        let fi = 0;
+        while (i < this.log.length) {
+            let f = active[fi];
+            while (f && f.start < i) {
+                fi += 1;
+                f = active[fi];
+            }
+            if (f && i === f.start) {
+                const end = f.open ? this.log.length : f.end; // fold aperto: fino alla fine
+                if (end > f.start) {
+                    out.push(f.summary);
+                    entries.push({ text: f.summary, id: this.logIds[i], through: this.logIds[Math.min(end, this.log.length) - 1] });
+                    i = end;
+                    fi += 1;
+                    continue;
+                }
+            }
+            out.push(this.log[i] ?? "");
+            entries.push({ text: this.log[i] ?? "", id: this.logIds[i] });
+            i += 1;
+        }
+        this.renderedLogRevision = this.logRevision;
+        this.renderedLogCache = out;
+        this.renderedEntries = entries;
+        return this.renderedLogCache;
+    }
+    touchLog() {
+        this.logRevision += 1;
+    }
+    pause() {
+        if (this.paused)
+            return;
+        this.paused = true;
+        this.inputGeneration++;
+        this.clearPendingEscape();
+        if (this.nativeScroll) {
+            if (this.alternateScreen) {
+                stdout.write(ALT_OFF);
+                this.alternateScreen = false;
+            }
+            stdout.write(this.nativeOutput.release());
+        }
+        this.cancelCtrlC();
+        if (this.dataListener)
+            stdin.off("data", this.dataListener);
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = undefined;
+        }
+        if (this.scrollRenderTimer) {
+            clearTimeout(this.scrollRenderTimer);
+            this.scrollRenderTimer = undefined;
+        }
+        this.paintedRows = [];
+        this.paintedCursor = "";
+    }
+    resume() {
+        if (!this.active)
+            return;
+        this.paused = false;
+        stdout.write(this.nativeScroll ? NATIVE_SCROLL_MODE : NATIVE_SELECTION_MODE);
+        if (this.dataListener)
+            stdin.on("data", this.dataListener);
+        if (typeof stdin.setRawMode === "function")
+            stdin.setRawMode(true);
+        stdin.resume();
+        if (this.statusLabel !== null && !this.spinnerTimer) {
+            this.spinnerTimer = setInterval(() => { this.frame += 1; this.render(); }, 140);
+        }
+        this.render(true);
+    }
+    // Dati dei vassalli per il viewer (Kingdoms Mode). null = nessun regno: chiude.
+    setKingdomVassals(data) {
+        if (!data || !data.length) {
+            this.vassals = null;
+            this.vassalOpen = false;
+        }
+        else {
+            this.vassals = data.map((d) => ({ slug: d.slug, lines: d.lines }));
+            if (this.vassalIdx >= this.vassals.length)
+                this.vassalIdx = 0;
+        }
+        if (this.active && (this.vassalOpen || !data))
+            this.render();
+    }
+    // Board live del regno: panoramica di tutti i vassalli, aggiornata in place
+    // nella regione viva. null = nessun regno (la rimuove). Le righe arrivano gia'
+    // stilate dal repl. Non si mostra mentre si e' dentro il viewer di un vassallo.
+    setKingdomBoard(lines) {
+        this.kingdomBoard = lines && lines.length ? lines.slice() : null;
+        if (this.active && !this.vassalOpen)
+            this.render();
+    }
+    // true se la board live del regno e' pinned ora: il chiamante puo' evitare di
+    // scrivere ANCHE il riquadro inline del piano, che duplicherebbe la vista.
+    hasKingdomBoard() {
+        return this.kingdomBoard !== null;
+    }
+    requestQuit() { this.quit(); }
+    cols() { return stdout.columns || 80; }
+    rows() { return stdout.rows || 24; }
+    queueResizeRender() {
+        this.nativeOutput.invalidate();
+        if (this.resizeTimer)
+            clearTimeout(this.resizeTimer);
+        this.resizeTimer = setTimeout(() => {
+            this.resizeTimer = undefined;
+            this.render(true);
+        }, RESIZE_SETTLE_MS);
+    }
+    // ── rendering full-frame ────────────────────────────────────────────────────
+    liveContent() {
+        if (this.overlay) {
+            return {
+                lines: this.overlay.lines, cursorRow: this.overlay.cursorRow, cursorCol: this.overlay.cursorCol,
+                inputStart: 0, inputRows: 0, textWidth: 0, prefixCols: 0, rowStarts: [], rowLengths: [],
+            };
+        }
+        // Viewer vassallo: occupa la regione viva con il tail dello stream del castello.
+        if (this.vassalOpen && this.vassals && this.vassals.length) {
+            const v = this.vassals[this.vassalIdx] ?? this.vassals[0];
+            const style = this.h.statusStyle ?? ((s) => s);
+            const maxLines = Math.max(3, this.rows() - 3);
+            const tail = v.lines.slice(-maxLines);
+            const header = `  ◆ collaboratore ${this.vassalIdx + 1}/${this.vassals.length} · ${v.slug} · Ctrl+G prossimo · Esc esci`;
+            const lines = [style(header), ...(tail.length ? tail : [style("  (in attesa di attività…)")])];
+            return { lines, cursorRow: 0, cursorCol: 1, inputStart: 0, inputRows: 0, textWidth: 0, prefixCols: 0, rowStarts: [], rowLengths: [] };
+        }
+        return this.layout();
+    }
+    render(force = false) {
+        if (!this.active || this.resizeTimer || (this.paused && !this.overlay))
+            return;
+        if (this.scrollRenderTimer) {
+            clearTimeout(this.scrollRenderTimer);
+            this.scrollRenderTimer = undefined;
+        }
+        const H = this.rows();
+        const W = this.cols();
+        const alternate = !this.nativeScroll || this.screenVisible || this.overlay !== null || this.vassalOpen || this.scrollOffset > 0;
+        if (alternate !== this.alternateScreen) {
+            stdout.write(alternate ? ALT_ON + "\x1b[2J\x1b[H" + NATIVE_SELECTION_MODE : ALT_OFF + NATIVE_SCROLL_MODE);
+            this.alternateScreen = alternate;
+            this.paintedRows = [];
+            this.paintedCursor = "";
+            force = true;
+        }
+        if (this.screenVisible) {
+            const content = this.screen.render(W, H);
+            const rows = Array.from({ length: H }, (_, i) => fitLine(content[i] ?? "", Math.max(1, W - 1)));
+            this.paint(rows, W, H, 1, 1, force, true);
+            return;
+        }
+        if (this.conversationRenderer && this.conversationColumns !== W && (!this.nativeScroll || !alternate)) {
+            const text = this.conversationRenderer(W);
+            const reset = this.resetConversationLog();
+            for (const line of text.replace(/\n+$/, "").split("\n")) {
+                this.log.push(line);
+                this.logIds.push(++this.logSeq);
+            }
+            this.conversationColumns = W;
+            if (this.nativeScroll)
+                stdout.write(reset);
+            force = true;
+        }
+        const lay = this.liveContent();
+        this.lastLayout = lay;
+        if (this.nativeScroll && !alternate) {
+            this.renderedLog();
+            const output = this.nativeOutput.render(this.renderedEntries, lay, W, H, false, this.h.startupLines?.() ?? this.h.headerLines?.() ?? []);
+            if (output)
+                stdout.write(output);
+            this.lastPaintAt = Date.now();
+            this.trimLog();
+            return;
+        }
+        const liveH = Math.min(lay.lines.length, H - 1);
+        const requestedHeader = this.h.headerLines?.() ?? [];
+        const headerH = Math.min(requestedHeader.length, Math.max(0, H - liveH - 1));
+        const header = requestedHeader.slice(0, headerH);
+        const chatRows = Math.max(1, H - liveH - headerH);
+        const rendered = this.renderedLog();
+        const total = rendered.length;
+        const maxOffset = Math.max(0, total - chatRows);
+        if (this.scrollOffset > maxOffset)
+            this.scrollOffset = maxOffset;
+        const startIdx = Math.max(0, total - chatRows - this.scrollOffset);
+        const visible = rendered.slice(startIdx, startIdx + chatRows);
+        const frameRows = Array.from({ length: H }, () => "");
+        for (let i = 0; i < headerH; i += 1)
+            frameRows[i] = clipVisible(header[i] ?? "", W);
+        for (let i = 0; i < chatRows; i += 1) {
+            let line = visible[i] ?? "";
+            // Indicatore "altro sopra/sotto" sulla prima/ultima riga del viewport.
+            if (i === 0 && this.scrollOffset < maxOffset)
+                line = scrollHint(line, "↑ altro sopra", W);
+            frameRows[headerH + i] = clipVisible(line, W);
+        }
+        this.liveStartRow = headerH + chatRows + 1;
+        for (let i = 0; i < liveH; i += 1) {
+            frameRows[headerH + chatRows + i] = clipVisible(lay.lines[i] ?? "", W);
+        }
+        const cursorRow = Math.max(1, Math.min(H, this.liveStartRow + Math.min(lay.cursorRow, Math.max(0, liveH - 1))));
+        const cursorCol = Math.max(1, Math.min(W, lay.cursorCol));
+        this.paint(frameRows, W, H, cursorRow, cursorCol, force, this.overlay !== null);
+    }
+    paint(frameRows, W, H, cursorRow, cursorCol, force, hideCursor = false) {
+        const dimensionsChanged = W !== this.paintedColumns || H !== this.paintedHeight;
+        const full = force || dimensionsChanged || this.paintedRows.length !== frameRows.length;
+        const changed = changedFrameRows(this.paintedRows, frameRows, full);
+        const cursor = `${cursorRow}:${cursorCol}:${hideCursor}`;
+        if (!changed.length && cursor === this.paintedCursor)
+            return;
+        let out = SYNC_ON;
+        for (const index of changed) {
+            out += `\x1b[${index + 1};1H\x1b[2K` + (frameRows[index] ?? "") + LINE_END;
+        }
+        out += `\x1b[${cursorRow};${cursorCol}H` + (hideCursor ? "\x1b[?25l" : "\x1b[?25h");
+        out += SYNC_OFF;
+        stdout.write(out);
+        this.paintedRows = frameRows;
+        this.paintedColumns = W;
+        this.paintedHeight = H;
+        this.paintedCursor = cursor;
+        this.lastPaintAt = Date.now();
+    }
+    scrollBy(delta) {
+        const next = Math.max(0, this.scrollOffset + delta);
+        if (next === this.scrollOffset)
+            return;
+        this.scrollOffset = next;
+        this.queueScrollRender();
+    }
+    // Touchpad e rotelle ad alta risoluzione possono inviare decine di eventi in
+    // pochi millisecondi. Lo stato avanza subito, ma il terminale riceve al massimo
+    // un frame per intervallo visivo: niente coda ANSI che continua a smaltirsi
+    // quando il gesto e' gia' terminato.
+    queueScrollRender() {
+        if (!this.active || this.scrollRenderTimer)
+            return;
+        const elapsed = Date.now() - this.lastPaintAt;
+        const delay = Math.max(0, SCROLL_FRAME_MS - elapsed);
+        this.scrollRenderTimer = setTimeout(() => {
+            this.scrollRenderTimer = undefined;
+            this.render();
+        }, delay);
+    }
+    layout() {
+        const cols = this.cols();
+        const lines = [];
+        if (this.statusLabel !== null)
+            lines.push(this.statusLine());
+        if (this.statusLabel === null && this.roomStatus?.state === "failed") {
+            const notice = this.roomSegment().replace(/\s+/g, " ").trim();
+            lines.push(...wrapText(notice, Math.max(8, cols - 3)).slice(0, 3).map(line => `  ${line}`));
+            lines.push(fitLine(tr("  Ctrl+R dettagli", "  Ctrl+R details"), cols - 1));
+        }
+        // La riga live descrive gia' il team; la board completa si consulta a parte.
+        if (this.kingdomBoard && this.statusLabel === null)
+            lines.push(fitLine(this.kingdomBoard[0] ?? "", cols - 1));
+        for (const f of this.h.footerLines())
+            lines.push(f);
+        if (!this.modal && !this.queueEditor)
+            lines.push(...queuePreview(this.queue, cols, this.h.queueStyle, !this.running));
+        const questionStart = lines.length;
+        const questions = !this.modal && !this.queueEditor
+            ? this.questions.render(cols, Math.max(5, this.rows() - lines.length - 6), this.h.queueStyle)
+            : { lines: [], cursorRow: 0, cursorCol: 1 };
+        lines.push(...questions.lines);
+        const box = this.h.boxStyle ?? ((s) => s);
+        // Etichetta della domanda a risposta libera (modal) sopra il box.
+        if (this.modal) {
+            const style = this.h.statusStyle ?? ((s) => s);
+            lines.push(...wrapText(this.modal.label, Math.max(2, cols - 3), true).map(line => style(`  ${line}`)));
+        }
+        else if (this.queueEditor) {
+            const label = tr("  Modifica in coda · Invio salva · Alt+S invia subito · Esc annulla", "  Edit queued message · Enter save · Alt+S send now · Esc cancel");
+            lines.push(fitLine(this.h.queueStyle?.heading(label) ?? label, cols - 1));
+        }
+        const prompt = this.h.promptText();
+        const pcols = visibleLength(prompt);
+        const cell = Math.max(8, cols - 3);
+        const badge = !this.modal ? (this.h.composerBadge?.() ?? "") : "";
+        const badgeSuffix = badge ? box(" │ ") + badge : "";
+        const badgeCols = visibleLength(badgeSuffix);
+        const tw = Math.max(4, cell - pcols - badgeCols);
+        // Badge artifact degli allegati immagine citati nel buffer: appaiono DENTRO
+        // la regione input (sopra il box), cosi' l'immagine incollata si vede come
+        // oggetto del prompt e NON come messaggio in chat.
+        if (!this.modal) {
+            const badges = this.h.imageBadges?.(this.buffer) ?? [];
+            if (badges.length)
+                lines.push(fitLine(badges.join(" ").replace(/\n/g, " "), cols - 1));
+        }
+        const { rows, crow, ccol, starts } = wrapInput(this.buffer, this.cursor, tw);
+        const inputCap = Math.max(1, Math.min(3, Math.floor(this.rows() / 4)));
+        const rowOffset = Math.max(0, Math.min(crow - Math.floor(inputCap / 2), rows.length - inputCap));
+        const visibleRows = rows.slice(rowOffset, rowOffset + inputCap);
+        const padding = !this.modal && !this.queueEditor && this.rows() >= 16 && this.h.composerPadding?.();
+        const blank = " " + (this.h.composerStyle?.(" ".repeat(cell)) ?? " ".repeat(cell));
+        if (padding)
+            lines.push(blank);
+        const inputStart = lines.length;
+        const highlight = createAttachmentHighlighter(this.buffer, this.modal ? undefined : this.h.attachmentStyle);
+        visibleRows.forEach((row, k) => {
+            const pre = k === 0 && rowOffset === 0 ? prompt : " ".repeat(pcols);
+            const placeholder = !this.buffer && !this.modal && !this.queueEditor ? this.h.placeholder?.() : undefined;
+            const highlighted = placeholder ? fitLine(placeholder, tw) : highlight(row, starts[rowOffset + k]);
+            const content = pre + padEnd(highlighted, tw) + (k === 0 ? badgeSuffix : " ".repeat(badgeCols));
+            lines.push(" " + (this.h.composerStyle?.(content) ?? content));
+        });
+        if (padding)
+            lines.push(blank);
+        if (this.roomStatus?.state === "done") {
+            const notice = `  ${this.roomStatus.label}`;
+            lines.push(fitLine(this.h.statusStyle?.(notice) ?? notice, cols - 1));
+        }
+        if (!this.modal) {
+            for (const row of this.h.belowInputLines?.() ?? [])
+                lines.push(fitLine(row, cols - 1));
+        }
+        const action = this.ctrlCConfirmation?.action;
+        const warning = action === "stop" ? tr("fermare il lavoro e mettere in pausa la coda", "stop work and pause the queue") : action === "clear" ? tr("svuotare la bozza", "clear the draft") : tr("uscire", "exit");
+        const hint = action
+            ? tr("  Ctrl+C ancora entro 2s per {warning}. Altro tasto annulla.", "  Ctrl+C again within 2s to {warning}. Any other key cancels.", { warning })
+            : this.capturingImage ? tr("  Lettura immagine dagli appunti...", "  Reading clipboard image...") : this.h.hint(this.buffer);
+        if (hint) {
+            const hints = action ? wrapText(hint, Math.max(8, cols - 1)) : [hint];
+            for (const row of hints)
+                lines.push(fitLine(this.h.statusStyle ? this.h.statusStyle(row) : row, cols - 1));
+        }
+        const prefixCols = 1 + pcols;
+        return {
+            lines,
+            cursorRow: this.questions.focused && questions.lines.length ? questionStart + questions.cursorRow : inputStart + crow - rowOffset,
+            cursorCol: this.questions.focused && questions.lines.length ? questions.cursorCol : prefixCols + ccol + 1,
+            inputStart, inputRows: this.questions.focused ? 0 : visibleRows.length, textWidth: tw, prefixCols,
+            rowStarts: starts.slice(rowOffset, rowOffset + inputCap),
+            rowLengths: visibleRows.map((r) => r.length),
+        };
+    }
+    // Segmento VIVO della stanza Danilov per la status-line: stato animato
+    // (running pulsa col frame, done/failed con glyph fisso). Vuoto se nessuna.
+    roomSegment() {
+        if (!this.roomStatus || this.roomStatus.state === "done")
+            return "";
+        const style = this.h.statusStyle ?? ((s) => s);
+        const { label, state } = this.roomStatus;
+        if (state === "running") {
+            const g = SPINNER[this.frame % SPINNER.length];
+            return `${g} ${label}`;
+        }
+        const glyph = state === "failed" ? "✗" : "✦";
+        return style(`${glyph} ${label}`);
+    }
+    statusLine() {
+        const elapsed = Math.round((Date.now() - this.startedAt) / 1000);
+        const style = this.h.statusStyle ?? ((s) => s);
+        const label = this.statusLabel ?? tr("Elaborazione", "Working");
+        const glyph = this.statusTool ? pulseGlyph(this.statusTool, this.frame) : SPINNER[this.frame % SPINNER.length];
+        const name = this.statusTool ? pulseToolName(this.statusTool, label, this.frame) : style(label);
+        const meta = [elapsed >= 1 ? fmtElapsed(elapsed) : "", this.h.runningHint?.() ?? "", this.roomSegment()].filter(Boolean);
+        const right = style(this.cols() >= 64 && (!this.queue.length || this.modal || this.queueEditor)
+            ? tr("Alt+S subito · Esc ferma", "Alt+S send now · Esc stop") : tr("Esc ferma", "Esc stop"));
+        const budget = Math.max(0, this.cols() - terminalWidth(right) - 5);
+        let left = `  ${glyph} ${name}`;
+        for (const segment of meta) {
+            const candidate = left + style(` · ${segment}`);
+            if (terminalWidth(candidate) > budget)
+                break;
+            left = candidate;
+        }
+        left = fitLine(left, budget);
+        return fitLine(left + " ".repeat(Math.max(2, this.cols() - 2 - terminalWidth(left) - terminalWidth(right))) + right, this.cols() - 1);
+    }
+    // ── input ─────────────────────────────────────────────────────────────────
+    // Parser RAW dello stdin: mouse (SGR), sequenze escape (frecce/Home/End/Page/
+    // Delete con modificatori), Alt+lettera, control char, caratteri stampabili.
+    clearPendingEscape() {
+        if (this.escapeTimer)
+            clearTimeout(this.escapeTimer);
+        this.escapeTimer = undefined;
+        this.escapePending = "";
+    }
+    feed(s, flushEscape = false) {
+        if (!this.active)
+            return;
+        s = this.escapePending + s;
+        this.clearPendingEscape();
+        if (s !== "\x03")
+            this.cancelCtrlC();
+        // Continuazione di un incollo (bracketed paste) iniziato in un frame precedente.
+        if (this.pasteBuffer !== null) {
+            const combined = this.pasteBuffer + s;
+            const endIdx = combined.indexOf("\x1b[201~");
+            if (endIdx >= 0) {
+                this.pasteBuffer = null;
+                this.handlePaste(combined.slice(0, endIdx));
+                s = combined.slice(endIdx + 6);
+            }
+            else {
+                this.pasteBuffer = combined;
+                return;
+            }
+        }
+        let i = 0;
+        while (i < s.length) {
+            const ch = s[i];
+            if (ch === "\x1b") {
+                const rest = s.slice(i);
+                // A terminal can split even the paste-start marker between stdin
+                // chunks. Preserve the escape prefix instead of typing "200~" and
+                // losing the first image paste. A lone Esc still acts after 30 ms.
+                if (rest === "\x1b" || /^\x1b(?:\[[0-9;:<=>?]*|O)$/.test(rest)) {
+                    if (!flushEscape && rest.length < 64) {
+                        this.escapePending = rest;
+                        this.escapeTimer = setTimeout(() => this.feed("", true), 30);
+                        return;
+                    }
+                    if (rest !== "\x1b")
+                        return;
+                }
+                // Bracketed paste: ESC[200~ <testo> ESC[201~. Catturiamo il blocco intero
+                // (puo' essere su piu' frame: bufferizziamo finche' non arriva 201~).
+                if (rest.startsWith("\x1b[200~")) {
+                    const body = rest.slice(6);
+                    const endIdx = body.indexOf("\x1b[201~");
+                    if (endIdx >= 0) {
+                        this.handlePaste(body.slice(0, endIdx));
+                        i += 6 + endIdx + 6;
+                    }
+                    else {
+                        // Fine non ancora arrivata: bufferizza il resto, attende il prossimo frame.
+                        this.pasteBuffer = body;
+                        i = s.length;
+                    }
+                    continue;
+                }
+                const mouse = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(rest);
+                if (mouse) {
+                    this.handleMouse(+mouse[1], +mouse[2], +mouse[3], mouse[4] === "M");
+                    i += mouse[0].length;
+                    continue;
+                }
+                const csi = /^\x1b[[O]([0-9;]*)([A-Za-z~])/.exec(rest);
+                if (csi) {
+                    this.handleEscape(csi[1] ?? "", csi[2]);
+                    i += csi[0].length;
+                    continue;
+                }
+                const alt = s[i + 1];
+                if (alt === "\r" || alt === "\n") {
+                    this.dispatchKey("", { meta: true, name: "return" });
+                    i += 2;
+                    continue;
+                }
+                if (alt && alt >= " " && alt !== "\x7f") {
+                    this.dispatchKey(alt, { meta: true, name: alt.toLowerCase() });
+                    i += 2;
+                    continue;
+                }
+                // Esc isolato (\x1b non seguito da una sequenza riconosciuta): risolve in
+                // ordine di priorita'. Mentre un run e' in corso, FERMA la generazione
+                // (come promette la status-line "esc ferma"); prima era gestito solo
+                // Ctrl+C, da cui il bug "Esc non interrompe".
+                if (this.screenVisible) {
+                    if (this.screen.key("", { name: "escape" }) === "close")
+                        this.closeScreen();
+                    this.render();
+                }
+                else if (this.questions.focused && !this.modal)
+                    this.questions.hide();
+                else if (this.modal)
+                    this.resolveModal(null); // annulla la domanda
+                else if (this.queueEditor)
+                    this.finishQueueEdit(false);
+                else if (this.vassalOpen) {
+                    this.vassalOpen = false;
+                    this.render();
+                } // esci dal viewer
+                else if (this.nativeScroll && this.scrollOffset > 0) {
+                    this.scrollOffset = 0;
+                    this.render();
+                }
+                else if (this.running) {
+                    this.stopRun();
+                }
+                i += 1; // ESC isolato
+                continue;
+            }
+            const code = ch.charCodeAt(0);
+            if (code === 13 || code === 10) {
+                this.dispatchKey("", { name: "return" });
+                i += 1;
+                continue;
+            }
+            if (code === 9) {
+                this.dispatchKey("\t", { name: "tab" });
+                i += 1;
+                continue;
+            }
+            if (code === 127) {
+                this.dispatchKey("", { name: "backspace" });
+                i += 1;
+                continue;
+            }
+            if (code === 8) {
+                this.dispatchKey("\x08", { name: "backspace", ctrl: true });
+                i += 1;
+                continue;
+            }
+            if (code < 32) {
+                this.dispatchKey(ch, { ctrl: true, name: String.fromCharCode(code + 96) });
+                i += 1;
+                continue;
+            }
+            this.dispatchKey(ch, {});
+            i += 1;
+        }
+    }
+    handleEscape(params, final) {
+        const parts = params.split(";");
+        const mod = parts.length > 1 ? Math.max(0, Number(parts[1]) - 1) : 0;
+        const shift = Boolean(mod & 1), meta = Boolean(mod & 2), ctrl = Boolean(mod & 4);
+        // Shift+Tab arriva come CSI Z (CBT): cicla la modalita' permessi.
+        if (final === "Z") {
+            this.dispatchKey("", { name: "tab", shift: true });
+            return;
+        }
+        if ((final === "u" && parts[0] === "13") || (final === "~" && parts[0] === "27" && parts[2] === "13")) {
+            this.dispatchKey("", { name: "return", shift, meta, ctrl });
+            return;
+        }
+        const codepoint = final === "u" ? parts[0] : final === "~" && parts[0] === "27" ? parts[2] : undefined;
+        if ((codepoint === "118" || codepoint === "86") && (ctrl || meta)) {
+            this.dispatchKey("", { name: "v", shift, meta, ctrl });
+            return;
+        }
+        const arrows = { A: "up", B: "down", C: "right", D: "left", H: "home", F: "end" };
+        let name = arrows[final];
+        if (final === "~") {
+            const tilde = { "1": "home", "7": "home", "4": "end", "8": "end", "5": "pageup", "6": "pagedown", "3": "delete" };
+            name = tilde[parts[0] ?? ""];
+        }
+        // Freccia su/giu' NUDA: disambigua scroll(touchpad) vs pressione (timer).
+        if ((name === "up" || name === "down") && !ctrl && !meta && !shift && !this.screenVisible
+            && !this.questions.focused && (!this.nativeScroll || this.scrollOffset > 0)) {
+            this.onArrow(name);
+            return;
+        }
+        if (name)
+            this.dispatchKey("", { name, ctrl, meta, shift });
+    }
+    // Una freccia isolata mantiene history/cursore; la seconda riconosce subito
+    // una raffica wheel. La finestra arrowScrollUntil include gli eventi residui,
+    // evitando sia il debounce dell'intero gesto sia richiami spurii alla history.
+    onArrow(dir) {
+        const now = Date.now();
+        if (now <= this.arrowScrollUntil || this.scrollOffset > 0) {
+            const step = now <= this.arrowScrollUntil ? WHEEL_ARROW_LINES : 1;
+            this.scrollBy(dir === "up" ? step : -step);
+            this.arrowScrollUntil = now + 140;
+            return;
+        }
+        this.pendingArrows.push(dir);
+        // Due eventi bastano a riconoscere il gesto. Non attendere il silenzio:
+        // un debounce continuamente rinnovato accumula tutta la corsa del touchpad.
+        // flushArrows apre la finestra wheel anche per il terzo evento e i residui.
+        if (this.pendingArrows.length >= 2) {
+            this.flushArrows();
+            return;
+        }
+        this.arrowTimer = setTimeout(() => this.flushArrows(), 80);
+    }
+    flushArrows() {
+        if (this.arrowTimer) {
+            clearTimeout(this.arrowTimer);
+            this.arrowTimer = undefined;
+        }
+        const arr = this.pendingArrows;
+        this.pendingArrows = [];
+        if (!arr.length)
+            return;
+        if (arr.length >= 2) {
+            this.arrowScrollUntil = Date.now() + 140;
+            const up = arr.filter((d) => d === "up").length;
+            this.scrollBy((up - (arr.length - up)) * WHEEL_ARROW_LINES);
+        }
+        else if (this.scrollOffset > 0) {
+            // Se la chat e' gia' scrollata, una freccia nuda continua a navigare il
+            // viewport. La history torna disponibile quando si e' di nuovo in fondo.
+            this.scrollBy(arr[0] === "up" ? 1 : -1);
+        }
+        else if (arr[0] === "up") {
+            this.onUp();
+        }
+        else {
+            this.onDown();
+        }
+    }
+    dispatchKey(s, k) {
+        if (!this.active)
+            return;
+        const seq = s;
+        if (!(k.ctrl && k.name === "c"))
+            this.cancelCtrlC();
+        if (this.screenVisible) {
+            if (this.screen.key(s, k) === "close")
+                this.closeScreen();
+            this.render();
+            return;
+        }
+        if (!this.modal && !this.overlay && !this.queueEditor) {
+            if (k.shift && k.name === "left" && this.questions.count) {
+                this.questions.open();
+                return;
+            }
+            if (this.questions.focused && !(k.ctrl && k.name === "c")) {
+                this.questions.key(s, k);
+                return;
+            }
+        }
+        if (k.meta && k.name === "q" && !this.modal) {
+            this.showQueue();
+            return;
+        }
+        if (k.meta && k.name === "t" && !this.modal && !this.overlay && !this.queueEditor) {
+            if (this.queue.sendToTeam())
+                this.startNextQueued();
+            else
+                this.showQueue();
+            this.render();
+            return;
+        }
+        if (k.ctrl && k.name === "c" && this.queueEditor && !this.modal) {
+            this.finishQueueEdit(false);
+            return;
+        }
+        if (k.ctrl && k.name === "r" && !this.modal) {
+            this.showReview();
+            return;
+        }
+        if (k.ctrl && k.name === "c")
+            return this.onCtrlC();
+        if (k.ctrl && k.name === "g") {
+            // Con un regno attivo: Ctrl+G entra nel viewer e cicla i vassalli (poi esce).
+            if (this.vassals && this.vassals.length) {
+                if (!this.vassalOpen) {
+                    this.vassalOpen = true;
+                    this.vassalIdx = 0;
+                }
+                else {
+                    this.vassalIdx += 1;
+                    if (this.vassalIdx >= this.vassals.length)
+                        this.vassalOpen = false;
+                }
+                this.render();
+                return;
+            }
+            this.h.onShowPlan?.();
+            return;
+        }
+        if (k.ctrl && k.name === "b") {
+            this.h.onBackground?.();
+            return;
+        }
+        // Ctrl+V (e Alt+V come alias): incolla un'immagine dalla clipboard di sistema
+        // (i terminali non mandano i byte binari via stdin, quindi li chiediamo
+        // direttamente all'OS). Nota: se il terminale gestisce Ctrl+V come incolla
+        // nativo, arriva invece come bracketed paste (handlePaste se ne occupa);
+        // questo ramo scatta quando Ctrl+V raggiunge l'app come control char (0x16).
+        if ((k.ctrl || k.meta) && k.name === "v") {
+            void this.captureImage();
+            return;
+        }
+        if (k.ctrl && k.name === "o" && !this.modal) {
+            this.showReview("modifiche");
+            return;
+        }
+        // Scroll della CHAT (input resta fisso): PageUp/Down, Shift+frecce.
+        if (k.name === "pageup")
+            return this.scrollBy(this.pageStep());
+        if (k.name === "pagedown")
+            return this.scrollBy(-this.pageStep());
+        if (k.shift && k.name === "up")
+            return this.scrollBy(1);
+        if (k.shift && k.name === "down")
+            return this.scrollBy(-1);
+        if (k.meta && k.name === "s")
+            return this.submit(true);
+        if (k.name === "return" || k.name === "enter")
+            return this.submit(Boolean(k.meta));
+        if (k.shift && k.name === "tab") {
+            this.h.onCycleMode?.();
+            this.render();
+            return;
+        }
+        if (k.name === "tab")
+            return this.complete();
+        if ((k.ctrl || k.meta) && k.name === "backspace")
+            return this.edit(() => this.deleteWord());
+        if ((k.ctrl || k.meta) && k.name === "delete")
+            return this.edit(() => this.deleteWordForward());
+        if (seq === "\x08" || seq === "\x17")
+            return this.edit(() => this.deleteWord());
+        if (k.name === "backspace")
+            return this.edit(() => {
+                if (this.cursor <= 0)
+                    return;
+                // Cancellazione ATOMICA del token "img #N": se il cursore tocca un
+                // riferimento immagine, lo rimuove per intero (l'allegato si scollega).
+                const span = this.h.onBackspaceToken?.(this.buffer, this.cursor);
+                if (span) {
+                    this.buffer = this.buffer.slice(0, span.start) + this.buffer.slice(span.end);
+                    this.cursor = span.start;
+                    return;
+                }
+                this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+                this.cursor -= 1;
+            });
+        if (k.name === "delete")
+            return this.edit(() => {
+                this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+            });
+        if ((k.ctrl || k.meta) && k.name === "left")
+            return this.edit(() => { this.cursor = wordLeft(this.buffer, this.cursor); });
+        if ((k.ctrl || k.meta) && k.name === "right")
+            return this.edit(() => { this.cursor = wordRight(this.buffer, this.cursor); });
+        if (k.name === "left")
+            return this.edit(() => { this.cursor = Math.max(0, this.cursor - 1); });
+        if (k.name === "right")
+            return this.edit(() => { this.cursor = Math.min(this.buffer.length, this.cursor + 1); });
+        if (k.name === "home" || (k.ctrl && k.name === "a"))
+            return this.edit(() => { this.cursor = 0; });
+        if (k.name === "end" || (k.ctrl && k.name === "e"))
+            return this.edit(() => { this.cursor = this.buffer.length; });
+        if (k.ctrl && k.name === "u")
+            return this.edit(() => { this.buffer = this.buffer.slice(this.cursor); this.cursor = 0; });
+        if (k.ctrl && k.name === "k")
+            return this.edit(() => { this.buffer = this.buffer.slice(0, this.cursor); });
+        if (k.ctrl && k.name === "w")
+            return this.edit(() => this.deleteWord());
+        if (k.name === "up")
+            return this.onUp();
+        if (k.name === "down")
+            return this.onDown();
+        if (s && !k.ctrl && !k.meta && !isControl(s)) {
+            return this.edit(() => {
+                const clean = s.replace(/[\r\n]+/g, " ");
+                this.buffer = this.buffer.slice(0, this.cursor) + clean + this.buffer.slice(this.cursor);
+                this.cursor += clean.length;
+            });
+        }
+    }
+    // Testo incollato (bracketed paste): l'hook onPaste puo' trasformarlo (es.
+    // un path/data-URI immagine -> "img #N"); altrimenti si inserisce com'e'.
+    // I newline si normalizzano a spazio: l'input e' una riga sola (Invio invia).
+    handlePaste(text) {
+        if (this.screenVisible) {
+            this.screen.paste?.(text);
+            this.render();
+            return;
+        }
+        if (this.questions.focused && !this.modal && !this.overlay) {
+            this.questions.paste(text);
+            return;
+        }
+        // Incollo di un'IMMAGINE con Ctrl+V: i terminali intercettano Ctrl+V come
+        // paste nativo, ma un'immagine non ha rappresentazione testuale, quindi il
+        // bracketed paste arriva vuoto (o con soli spazi/whitespace). In quel caso
+        // proviamo a leggere i byte dalla clipboard di sistema (stesso flusso di
+        // Alt+V). Solo fuori dai modali e con la sessione attiva.
+        if ((!text || !text.trim()) && !this.modal && this.active) {
+            void this.captureImage();
+            return;
+        }
+        if (!text)
+            return;
+        if (this.modal) {
+            // Nelle domande a risposta libera l'incollo va comunque nel buffer testuale.
+            const clean = text.replace(/[\r\n]+/g, " ");
+            this.edit(() => {
+                this.buffer = this.buffer.slice(0, this.cursor) + clean + this.buffer.slice(this.cursor);
+                this.cursor += clean.length;
+            });
+            return;
+        }
+        const transformed = this.h.onPaste?.(text);
+        const insert = (transformed ?? text).replace(/[\r\n]+/g, " ");
+        this.edit(() => {
+            this.buffer = this.buffer.slice(0, this.cursor) + insert + this.buffer.slice(this.cursor);
+            this.cursor += insert.length;
+        });
+    }
+    // Ctrl+V: chiede all'host i byte dell'immagine nella clipboard di sistema. Se
+    // c'e' un'immagine, l'host ritorna il riferimento "img #N" da inserire nel
+    // buffer (l'host stesso mostra eventuale feedback/anteprima). Async perche'
+    // la lettura della clipboard passa da un sottoprocesso di sistema.
+    async captureImage() {
+        if (!this.active || this.modal || this.screenVisible || this.capturingImage || !this.h.onCaptureImage)
+            return;
+        this.capturingImage = true;
+        const generation = this.inputGeneration;
+        const editor = this.queueEditor;
+        let inserted = false;
+        this.render();
+        try {
+            const ref = await this.h.onCaptureImage();
+            // Do not attach a late result to another draft, a modal or a closed UI.
+            if (!ref || !this.active || this.modal || this.screenVisible
+                || this.inputGeneration !== generation || this.queueEditor !== editor)
+                return;
+            const insert = ref.replace(/[\r\n]+/g, " ");
+            this.edit(() => {
+                this.buffer = this.buffer.slice(0, this.cursor) + insert + this.buffer.slice(this.cursor);
+                this.cursor += insert.length;
+            });
+            inserted = true;
+        }
+        catch (error) {
+            if (this.active && !this.modal && !this.screenVisible && this.inputGeneration === generation && this.queueEditor === editor) {
+                this.reportFailure(`${tr("Errore clipboard", "Clipboard error")}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        finally {
+            this.capturingImage = false;
+            const submit = this.deferredImageSubmit;
+            this.deferredImageSubmit = null;
+            this.render();
+            if (inserted && submit !== null)
+                this.submit(submit);
+        }
+    }
+    pageStep() {
+        const header = this.h.headerLines?.().length ?? 0;
+        return Math.max(1, this.rows() - this.liveContent().lines.length - header - 1);
+    }
+    handleMouse(button, x, y, press) {
+        if (this.screenVisible) {
+            if (press && (button & 0b1000000)) {
+                this.screen.scroll(button & 1 ? WHEEL_MOUSE_LINES : -WHEEL_MOUSE_LINES);
+                this.queueScrollRender();
+            }
+            return;
+        }
+        // Rotella (bit 6): SEMPRE scroll della CHAT, anche sul rilascio e ovunque sia
+        // il puntatore. L'input resta fisso: lo scroll NON "ruba" mai la posizione
+        // del cursore ne' digita nell'input. 64 = su, 65 = giu'.
+        if (button & 0b1000000) {
+            if (press)
+                this.scrollBy(button & 1 ? -WHEEL_MOUSE_LINES : WHEEL_MOUSE_LINES);
+            return;
+        }
+        // Da qui in giu' solo i CLICK veri: il rilascio (press=false) e i movimenti
+        // (bit 5, drag) non toccano l'input.
+        if (!press)
+            return;
+        if (button & 0b0100000)
+            return; // movimento/drag
+        if ((button & 0b11) !== 0)
+            return; // solo click sinistro (no middle/right)
+        const lay = this.lastLayout;
+        if (!lay || this.overlay || lay.inputRows === 0)
+            return;
+        // Il click sposta il cursore SOLO se cade DENTRO le righe del box input.
+        const within = (y - this.liveStartRow) - lay.inputStart;
+        if (within < 0 || within >= lay.inputRows)
+            return;
+        // Mappa colonna->offset usando lo start REALE della riga (word-wrap: righe
+        // di lunghezza variabile, non multipli fissi di textWidth).
+        const rowStart = lay.rowStarts[within] ?? this.buffer.length;
+        const rowLen = lay.rowLengths[within] ?? 0;
+        const col = Math.max(0, Math.min((x - 1) - lay.prefixCols, rowLen));
+        this.cursor = Math.max(0, Math.min(this.buffer.length, rowStart + col));
+        this.render();
+    }
+    onUp() {
+        const tw = this.lastLayout?.textWidth ?? this.buffer.length + 1;
+        if (this.cursor >= tw) {
+            this.edit(() => { this.cursor = Math.max(0, this.cursor - tw); });
+            return;
+        }
+        this.historyPrev();
+    }
+    onDown() {
+        const tw = this.lastLayout?.textWidth ?? this.buffer.length + 1;
+        if (this.buffer.length - this.cursor >= tw) {
+            this.edit(() => { this.cursor = Math.min(this.buffer.length, this.cursor + tw); });
+            return;
+        }
+        this.historyNext();
+    }
+    edit(mutate) { mutate(); this.render(); }
+    deleteWord() {
+        const left = this.buffer.slice(0, this.cursor).replace(/\s*\S+\s*$/, "");
+        this.buffer = left + this.buffer.slice(this.cursor);
+        this.cursor = left.length;
+    }
+    deleteWordForward() {
+        const right = this.buffer.slice(this.cursor).replace(/^\s*\S+\s*/, "");
+        this.buffer = this.buffer.slice(0, this.cursor) + right;
+    }
+    complete() {
+        const next = this.h.completion(this.buffer);
+        if (next === null || next === this.buffer)
+            return;
+        this.buffer = next;
+        this.cursor = next.length;
+        this.render();
+    }
+    historyPrev() {
+        if (!this.history.length)
+            return;
+        if (this.histIdx === -1)
+            this.draft = this.buffer;
+        this.histIdx = this.histIdx === -1 ? this.history.length - 1 : Math.max(0, this.histIdx - 1);
+        this.buffer = this.history[this.histIdx] ?? "";
+        this.cursor = this.buffer.length;
+        this.render();
+    }
+    historyNext() {
+        if (this.histIdx === -1)
+            return;
+        this.histIdx += 1;
+        if (this.histIdx >= this.history.length) {
+            this.histIdx = -1;
+            this.buffer = this.draft;
+        }
+        else
+            this.buffer = this.history[this.histIdx] ?? "";
+        this.cursor = this.buffer.length;
+        this.render();
+    }
+    onCtrlC() {
+        if (this.modal) {
+            this.resolveModal(null);
+            return;
+        }
+        const action = this.running ? "stop" : this.buffer ? "clear" : "quit";
+        if (this.ctrlCConfirmation?.action === action && Date.now() < this.ctrlCConfirmation.until) {
+            this.cancelCtrlC();
+            if (action === "stop") {
+                this.stopRun();
+                this.render();
+                return;
+            }
+            if (action === "clear") {
+                this.inputGeneration++;
+                this.buffer = "";
+                this.cursor = 0;
+                this.histIdx = -1;
+                this.render();
+                return;
+            }
+            this.quit();
+            return;
+        }
+        this.cancelCtrlC();
+        this.ctrlCConfirmation = { action, until: Date.now() + 2000 };
+        this.ctrlCTimer = setTimeout(() => { this.cancelCtrlC(); if (this.active)
+            this.render(); }, 2000);
+        this.render();
+    }
+    cancelCtrlC() {
+        if (this.ctrlCTimer)
+            clearTimeout(this.ctrlCTimer);
+        this.ctrlCTimer = undefined;
+        this.ctrlCConfirmation = null;
+    }
+    stopRun() {
+        this.cancelCtrlC();
+        const queued = this.queue.length;
+        this.queue.paused = true;
+        this.runAbort?.abort();
+        if (queued)
+            this.setRoomStatus(tr("Lavoro interrotto. {queued} messaggi conservati in pausa · Alt+Q o /queue per gestirli.", "Work interrupted. {queued} messages paused · Alt+Q or /queue to manage.", { queued }), "failed");
+    }
+    // Domanda a risposta libera: l'editing finisce nel buffer, Invio risolve.
+    queueQuestion(title, options, signal) {
+        if (!this.active)
+            return Promise.resolve(null);
+        return this.questions.enqueue(title, options, signal);
+    }
+    promptInput(label) {
+        if (!this.active)
+            return Promise.resolve(null);
+        this.inputGeneration++;
+        this.cancelCtrlC();
+        const labelRows = wrapText(label, Math.max(2, this.cols() - 3), true);
+        if (labelRows.length > Math.max(2, Math.floor(this.rows() / 3))) {
+            const style = this.h.statusStyle ?? ((s) => s);
+            this.write("\n" + labelRows.map(line => style("  " + line)).join("\n") + "\n");
+            label = tr("Rispondi qui · Invio conferma · Esc annulla", "Reply here · Enter confirm · Esc cancel");
+        }
+        const draft = { buffer: this.buffer, cursor: this.cursor, histIdx: this.histIdx };
+        this.buffer = "";
+        this.cursor = 0;
+        this.histIdx = -1;
+        return new Promise((resolve) => {
+            this.modal = { label, resolve, draft };
+            this.render();
+        });
+    }
+    resolveModal(value) {
+        const m = this.modal;
+        if (!m)
+            return;
+        this.modal = null;
+        this.buffer = m.draft.buffer;
+        this.cursor = m.draft.cursor;
+        this.histIdx = m.draft.histIdx;
+        this.render();
+        m.resolve(value);
+        this.startNextQueued();
+    }
+    submit(immediate = false) {
+        if (this.modal) {
+            this.resolveModal(this.buffer);
+            return;
+        }
+        // Enter during a clipboard read waits for the attachment. On failure the
+        // draft stays editable instead of sending a prompt with a missing image.
+        if (this.capturingImage) {
+            this.deferredImageSubmit = Boolean(this.deferredImageSubmit || immediate);
+            return;
+        }
+        if (this.queueEditor) {
+            this.finishQueueEdit(true, immediate);
+            return;
+        }
+        const line = this.buffer;
+        this.buffer = "";
+        this.cursor = 0;
+        this.histIdx = -1;
+        if (!line.trim()) {
+            if (immediate) {
+                const next = this.queue.items().find(entry => !entry.text.trimStart().startsWith("/"));
+                if (next)
+                    this.queue.sendNow(next.id);
+            }
+            else if (!this.running && this.queue.paused)
+                this.queue.paused = false;
+            this.startNextQueued();
+            this.render();
+            return;
+        }
+        if (/^\/(?:queue|coda)\s*$/i.test(line.trim())) {
+            this.showQueue();
+            return;
+        }
+        const review = /^\/(?:review|revisione)(?:\s+(\S+))?\s*$/i.exec(line.trim());
+        if (review && this.h.createReviewScreen) {
+            this.showReview(review[1]);
+            return;
+        }
+        this.dispatch(line, immediate);
+    }
+    dispatch(line, immediate = false) {
+        // Una coda ripristinata in pausa non deve bloccare /new, /resume, /help
+        // o /quit. A riposo i comandi controllano la UI senza riprendere la coda.
+        if (!this.running && line.trimStart().startsWith("/")) {
+            this.runLine(line);
+            return;
+        }
+        if (this.running || this.queue.length) {
+            try {
+                this.queue.add(line, immediate ? "immediate" : "after-turn");
+                // Aprire una chat non avvia lavoro da solo. Un nuovo Invio a riposo
+                // riprende invece la coda: il prompt appena scritto non resta bloccato
+                // dietro la pausa applicata durante il ripristino.
+                if (!this.running && !immediate)
+                    this.queue.paused = false;
+                this.h.onQueued?.(line);
+            }
+            catch (error) {
+                this.buffer = line;
+                this.cursor = line.length;
+                this.reportFailure(`${tr("Messaggio non accodato", "Message not queued")}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            this.startNextQueued();
+            this.render();
+            return;
+        }
+        this.queue.paused = false;
+        this.runLine(line);
+    }
+    startNextQueued() {
+        if (!this.active || this.running || this.modal || this.overlay || this.queueEditor)
+            return;
+        const next = this.queue.takeNext();
+        if (next) {
+            this.h.onDequeue?.(next.text);
+            this.runLine(next.text, true, next);
+        }
+    }
+    runLine(line, fromQueue = false, queued) {
+        this.setRoomStatus(null);
+        this.history.push(line);
+        this.running = true;
+        this.startedAt = Date.now();
+        this.tokensNew = 0;
+        this.tokensCache = 0;
+        this.tokensOut = 0;
+        const ac = new AbortController();
+        this.runAbort = ac;
+        this.render();
+        Promise.resolve().then(() => this.h.onSubmit(line, ac.signal, fromQueue, queued))
+            .catch(error => {
+            this.queue.paused = true;
+            this.reportFailure(`${tr("Errore", "Error")}: ${error instanceof Error ? error.message : String(error)}. ${tr("Coda in pausa.", "Queue paused.")}`);
+        })
+            .finally(() => {
+            this.cancelCtrlC();
+            this.runAbort = undefined;
+            this.running = false;
+            this.setStatus(null);
+            if (!this.active)
+                return;
+            this.startNextQueued();
+            this.render();
+        });
+    }
+    quit() {
+        if (!this.active)
+            return;
+        this.active = false;
+        this.questions.clear();
+        this.clearPendingEscape();
+        this.cancelCtrlC();
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = undefined;
+        }
+        if (this.arrowTimer) {
+            clearTimeout(this.arrowTimer);
+            this.arrowTimer = undefined;
+        }
+        if (this.roomTimer) {
+            clearTimeout(this.roomTimer);
+            this.roomTimer = undefined;
+        }
+        if (this.scrollRenderTimer) {
+            clearTimeout(this.scrollRenderTimer);
+            this.scrollRenderTimer = undefined;
+        }
+        if (this.dataListener)
+            stdin.off("data", this.dataListener);
+        if (this.resizeListener)
+            stdout.off("resize", this.resizeListener);
+        if (this.resizeTimer) {
+            clearTimeout(this.resizeTimer);
+            this.resizeTimer = undefined;
+        }
+        if (this.alternateScreen) {
+            stdout.write(ALT_OFF);
+            this.alternateScreen = false;
+        }
+        if (this.nativeScroll)
+            stdout.write(this.nativeOutput.release());
+        stdout.write(PASTE_OFF + NATIVE_SCROLL_MODE + "\x1b[?25h");
+        if (typeof stdin.setRawMode === "function")
+            stdin.setRawMode(false);
+        this.h.onQuit();
+        this.quitResolve?.();
+    }
+}
+// Word-wrap dell'input: manda a capo le PAROLE INTERE invece di spezzarle a
+// meta'. Ogni riga porta il suo offset di partenza nel buffer, cosi' la
+// posizione del cursore (crow/ccol) resta esatta. Una parola piu' lunga della
+// larghezza disponibile viene comunque spezzata (hard-cut), altrimenti non
+// entrerebbe mai.
+export function wrapInput(buffer, cursor, tw) {
+    const width = Math.max(1, tw);
+    // Ogni riga: { text, start } dove start = indice nel buffer del primo char.
+    const segs = wrapSegments(buffer, width);
+    const rows = segs.map((s) => s.text);
+    const starts = segs.map((s) => s.start);
+    // Mappa il cursore alla riga giusta: l'ultima riga il cui start <= cursor.
+    let crow = 0;
+    for (let r = 0; r < segs.length; r += 1) {
+        if (segs[r].start <= cursor)
+            crow = r;
+        else
+            break;
+    }
+    const seg = segs[crow];
+    let ccol = cursor - seg.start;
+    // Se il cursore cade oltre la fine del testo visibile di questa riga (lo
+    // spazio "mangiato" a fine riga dal wrap), tienilo a fine riga.
+    if (ccol > seg.text.length)
+        ccol = seg.text.length;
+    // Cursore in coda al buffer e l'ultima riga e' piena: apri una riga nuova
+    // cosi' il cursore non si sovrappone all'ultimo carattere.
+    const last = segs[segs.length - 1];
+    if (cursor === buffer.length && cursor > 0 && last.start + last.text.length === cursor && last.text.length >= width) {
+        rows.push("");
+        starts.push(cursor);
+        crow = rows.length - 1;
+        ccol = 0;
+    }
+    return { rows, crow, ccol, starts };
+}
+// Suddivide il buffer in righe larghe al massimo `width`, preferendo i confini
+// di parola (spazi). Ritorna per ogni riga il testo e l'offset di partenza.
+function wrapSegments(buffer, width) {
+    if (buffer.length === 0)
+        return [{ text: "", start: 0 }];
+    const segs = [];
+    let start = 0;
+    const n = buffer.length;
+    while (start < n) {
+        let end = Math.min(start + width, n);
+        if (end < n) {
+            // C'e' ancora testo dopo: cerca l'ultimo spazio entro [start, end] per
+            // spezzare su confine di parola.
+            let brk = -1;
+            for (let i = end; i > start; i -= 1) {
+                if (buffer[i] === " ") {
+                    brk = i;
+                    break;
+                }
+            }
+            if (brk > start) {
+                // Spezza dopo lo spazio: lo spazio resta in coda alla riga corrente,
+                // la riga successiva parte dalla parola.
+                end = brk + 1;
+            }
+            // Se nessuno spazio (brk<=start): parola piu' lunga di width -> hard-cut.
+        }
+        segs.push({ text: buffer.slice(start, end), start });
+        start = end;
+    }
+    if (segs.length === 0)
+        segs.push({ text: "", start: 0 });
+    return segs;
+}
+function wordLeft(buffer, cursor) {
+    let i = cursor;
+    while (i > 0 && /\s/.test(buffer[i - 1] ?? ""))
+        i -= 1;
+    while (i > 0 && !/\s/.test(buffer[i - 1] ?? ""))
+        i -= 1;
+    return i;
+}
+function wordRight(buffer, cursor) {
+    let i = cursor;
+    const n = buffer.length;
+    while (i < n && /\s/.test(buffer[i] ?? ""))
+        i += 1;
+    while (i < n && !/\s/.test(buffer[i] ?? ""))
+        i += 1;
+    return i;
+}
+function fmtElapsed(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+function isControl(s) {
+    return s.length === 1 && s.charCodeAt(0) < 0x20;
+}
+function padEnd(value, width) {
+    return value + " ".repeat(Math.max(0, width - visibleLength(value)));
+}
+function visibleLength(value) {
+    return value.replace(/\x1b\[[0-9;]*m/g, "").replace(/\x1b\][^\x07]*\x07/g, "").length;
+}
+// Tronca alla larghezza VISIBILE preservando le sequenze ANSI (colori, OSC 8).
+// Sul troncamento chiude SGR e hyperlink OSC 8 aperti (anti-bleed).
+export function clipVisible(s, max) {
+    if (max <= 0)
+        return "";
+    let out = "";
+    let vis = 0;
+    let i = 0;
+    while (i < s.length) {
+        if (s[i] === "\x1b") {
+            const rest = s.slice(i);
+            const sgr = /^\x1b\[[0-9;]*m/.exec(rest);
+            const osc = /^\x1b\][\s\S]*?(?:\x07|\x1b\\)/.exec(rest);
+            const csi = /^\x1b\[[0-9;?]*[A-Za-z]/.exec(rest);
+            const seq = sgr?.[0] ?? osc?.[0] ?? csi?.[0];
+            if (seq) {
+                out += seq;
+                i += seq.length;
+                continue;
+            }
+            i += 1; // ESC isolato: scartalo
+            continue;
+        }
+        if (vis >= max) {
+            out += "\x1b[0m\x1b]8;;\x1b\\";
+            return out;
+        }
+        out += s[i];
+        vis += 1;
+        i += 1;
+    }
+    return out;
+}
+function truncate(value, max) {
+    if (max <= 0)
+        return "";
+    if (visibleLength(value) <= max)
+        return value;
+    return value.slice(0, max - 1) + "…";
+}
+// Sovrappone un suggerimento a destra di una riga (per "altro sopra/sotto").
+function scrollHint(line, hint, width) {
+    const room = width - visibleLength(line) - hint.length - 2;
+    if (room < 1)
+        return line;
+    return line + " ".repeat(room) + hint;
+}