@vascend/talos 0.1.0

package/dist/tui/repl.js

@@ -0,0 +1,4130 @@
+import { reviewContinuation } from "../core/continuation-review.js";
+import * as readline from "node:readline";
+import { spawn } from "node:child_process";
+import { watch, existsSync, readFileSync } from "node:fs";
+import { stdin, stdout } from "node:process";
+import { repoRoot, currentBranch } from "../vascend/worktree.js";
+import { runTurn, compactNow } from "../core/agent.js";
+import { createUserInbox, pendingText } from "../core/user-inbox.js";
+import { renderDiff } from "./diff.js";
+import { renderMarkdown, wrapPlain } from "./markdown.js";
+import { SessionUsageState } from "./session-usage.js";
+import { ContextMeter, contextDetails } from "./context-meter.js";
+import { buildUsageFooter, subscriptionDetails, SESSION_USAGE_EXPLANATION } from "./usage-footer.js";
+import { copyText, lastAssistantText } from "./clipboard-text.js";
+import { withCommandFeedback, notifyStatus } from "./command-feedback.js";
+import { loadModelsDev, cachedModelCatalog } from "../providers/models-dev.js";
+import { modelEfforts } from "../providers/model-effort.js";
+import { modelDetail } from "./model-details.js";
+import { applyModelChoice, pickEffort } from "./model-selection.js";
+import { PROVIDER_CATALOG } from "../providers/catalog.js";
+import { fetchOpenRouterModels, openRouterDetail } from "../providers/openrouter.js";
+import { providerRows, actionsFor, rowStatusLabel, providerKeyHint, saveProviderKey, saveProviderBaseUrl, removeProvider, } from "./provider-menu.js";
+import { validateApiKey, looksLikeApiKey, startOAuthFlow, buildAuthUrlForPort, callbackUrlForPort } from "../providers/openrouter-auth.js";
+import { orchestrateOAuth } from "../providers/oauth-orchestrator.js";
+import { startCallbackServer } from "../providers/oauth-callback-server.js";
+import { openUrl } from "../providers/open-browser.js";
+import { runManualCodeFallback } from "../providers/openrouter-manual-fallback.js";
+import { frostPaint, makeTheme, renderAssistantSegment, renderAssistantTurnEnd, renderAssistantTurnStart, renderInputPrompt, renderStartup, renderUserMessage, renderVascendStatus, renderVascendNotice, renderCastleBorn, fileLink, osc8, } from "./branding.js";
+import { renderVascendTerminalLogo } from "./logo.js";
+import { enterAccount } from "./account-entry.js";
+import { tr } from "./i18n.js";
+import { LANGUAGES, normalizePreference } from "./locales.js";
+import { languagePreference, saveLanguagePreference } from "./language-preference.js";
+import { leggiOnboarding } from "./onboarding.js";
+import { buildTerminalHeader, buildTerminalWelcome } from "./status-line.js";
+import { buildTerminalStartup, buildStartupRuntime, permissionLabel } from "./startup.js";
+import { loadStatusExt, statusLineFiles } from "./status-line-loader.js";
+import { createCostTracker } from "./cost-binding.js";
+import { formatCost, formatTokenCount, promptTokens } from "./cost-tracker.js";
+import { BottomInput } from "./bottom-input.js";
+import { replaySession, sessionConversation } from "./session-replay.js";
+export { resumeReplay } from "./session-replay.js";
+import { PromptQueueFile, recoverableQueue } from "./prompt-queue-store.js";
+import { restoreQueuedInput } from "./restore-queued-input.js";
+import { ReviewStore } from "./review-store.js";
+import { ReviewScreen, reviewText } from "./review-screen.js";
+import { fitLine, oneLine, terminalWidth, wrapText } from "./terminal-text.js";
+import { livePreview, liveResultSummary } from "./live-output.js";
+import { commandSource, commandPreview, commandHeader, commandOutput, commandResultState } from "./command-transcript.js";
+import { mcpName, mcpHeader, mcpPreview, mcpOutput } from "./mcp-transcript.js";
+import { loadedSkill, skillHeader, skillPreview } from "./skill-transcript.js";
+import { selectOption } from "./selector.js";
+import { renderQuestion } from "./question.js";
+export { filterOptions, pickerPageSize } from "./selector.js";
+import { ImageRegistry, detectImageSource, imageTokenSpanAt } from "./image-attachments.js";
+import { PasteRegistry, pasteTokenSpanAt, shouldCollapsePaste, } from "./paste-collapse.js";
+import { readClipboardImage } from "./clipboard-image.js";
+import { queryBackgroundMode } from "./term-bg.js";
+import { runKingdomWarm, warmConcurrency, decomposeKingdom, looksBigGoal, collectConflicts, formatConflictList } from "../vascend/kingdom.js";
+import { worktreeMode } from "../vascend/worktree.js";
+import { runKingdomForHost } from "../vascend/kingdom-run.js";
+import { kingdomBus } from "../vascend/kingdom-bus.js";
+import { resolveKingdomBus } from "../vascend/kingdom-channel.js";
+import { completenessEnabled, completenessRounds, judgeCompleteness, buildCompletenessSteer } from "../vascend/completeness.js";
+import { selfImproveEnabled } from "../vascend/self-improve.js";
+import { runKingdomGate, formatKingdomGate } from "../vascend/kingdom-kpi.js";
+import { RoomMemory } from "../vascend/room-memory.js";
+import { renderArchitectureMap, scanArchitectureMap } from "../vascend/architecture-map.js";
+import { isAbsolute, resolve } from "node:path";
+import { defaultThemeName, findTheme, loadThemes, parseThemeFile, } from "./theme.js";
+import { findTemplate, loadTemplates, renderTemplate, } from "../prompts/templates.js";
+import { findSkill, renderSkillInvocation } from "../skills/skills.js";
+import { loginRows, loginStatusLabel } from "./login-menu.js";
+import { VascendRuntime, validateKingdom, buildValidationSteer } from "../vascend/runtime.js";
+import { VascendPlanStore } from "../vascend/plan-store.js";
+import { reviewOptions, shouldReview, buildRoomMetricsDigest, buildReviewerPrompt } from "../vascend/reviewer.js";
+import { Session, listSessions, sessionFilePath } from "../core/session.js";
+import { sessionTitle } from "../core/session-title.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { saveGlobalSettings } from "../core/settings.js";
+import { autoApproves, nextPermMode, permModeLabel } from "./perm-mode.js";
+import { backgroundManager } from "../core/background.js";
+import { BUILTIN_COMMANDS, visibleBuiltinNames, commandsByCategory, suggestCommands } from "./commands.js";
+import { TASK_STATUS_LABELS } from "./task-labels.js";
+import { rimuoviLicenzaLocale, rimuoviTokenVascend, revocaSessione, tokenVascend, } from "./vascend-login.js";
+import { paintToolName, paintCategoryName, pulseDot } from "./tool-style.js";
+import { listVibeModes, parseVibeMode } from "../core/vibe-modes.js";
+import { contextProjectKey, loadContextFrame, renderContextFrame, resetContextFrame, updateContextPins, } from "../vascend/context-fabric.js";
+// (BUILTIN_COMMANDS spostato in ./commands.ts con categorie: vedi import in testa.)
+// Sorgente dinamica dei nomi comando (builtin + estensioni + template + skill).
+function allCommandNames(harness, templates) {
+    return [
+        ...visibleBuiltinNames(),
+        ...[...harness.host.commands.keys()],
+        ...templates.map((t) => t.name),
+        ...harness.skills.map((s) => `skill:${s.name}`),
+    ];
+}
+// Modalita' Vascend di default nella TUI: sticky (nativo) salvo override.
+function vascendDefaultMode(env) {
+    const v = (env["TALOS_VASCEND"] ?? "").trim().toLowerCase();
+    if (v === "off" || v === "0" || v === "false" || v === "no")
+        return "off";
+    return "sticky";
+}
+// Casella del giro attualmente in esecuzione nella TUI. Vive qui, a livello di
+// modulo, perche' chi la riempie (il lettore di righe) e chi la consuma (il giro
+// dell'agente) sono su due percorsi diversi e non si conoscono.
+let activeTurnInbox = null;
+export function beginActiveTurnInbox() {
+    activeTurnInbox = createUserInbox();
+    return activeTurnInbox;
+}
+export function endActiveTurnInbox() {
+    activeTurnInbox = null;
+}
+// Consegna una riga al giro in corso. I comandi (che cambiano lo stato della
+// TUI, non il lavoro dell'agente) restano fuori: quelli aspettano il loro turno.
+export function deliverToActiveTurn(raw, parts) {
+    const text = String(raw ?? "").trim();
+    if (!activeTurnInbox || !text || text.startsWith("/"))
+        return false;
+    activeTurnInbox.push(parts ?? text);
+    return true;
+}
+// `readline.Interface` emette gli eventi `line` senza attendere le callback
+// async. Questa coda garantisce un solo turno agente alla volta, mantiene la
+// catena utilizzabile dopo un errore e centralizza prompt/quit/close per evitare
+// doppi prompt o righe eseguite dopo la chiusura.
+export function createSerialReadlineQueue(options) {
+    let tail = Promise.resolve();
+    let stopped = false;
+    let active = null;
+    const report = (error) => {
+        try {
+            options.onError?.(error);
+        }
+        catch {
+            // Anche un renderer d'errore difettoso non deve avvelenare la coda.
+        }
+    };
+    const runOne = async (raw) => {
+        if (stopped)
+            return;
+        const controller = new AbortController();
+        active = controller;
+        let removeAbort;
+        let result = undefined;
+        try {
+            try {
+                removeAbort = options.installAbort?.(() => controller.abort());
+            }
+            catch (error) {
+                report(error);
+            }
+            try {
+                result = await options.processLine(raw, controller.signal);
+            }
+            catch (error) {
+                // close() abortisce intenzionalmente il turno: non e' un errore da
+                // mostrare. Un errore ordinario, invece, viene riportato e la coda
+                // prosegue con la riga successiva.
+                if (!stopped && !controller.signal.aborted)
+                    report(error);
+            }
+        }
+        finally {
+            try {
+                removeAbort?.();
+            }
+            catch (error) {
+                report(error);
+            }
+            if (active === controller)
+                active = null;
+        }
+        if (stopped)
+            return;
+        if (result === "quit") {
+            stopped = true;
+            try {
+                options.requestClose();
+            }
+            catch (error) {
+                report(error);
+            }
+            return;
+        }
+        try {
+            options.prompt();
+        }
+        catch (error) {
+            report(error);
+        }
+    };
+    return {
+        enqueue(raw) {
+            if (stopped)
+                return tail;
+            // Turno in corso: se la riga puo' essere consegnata al giro che sta
+            // lavorando, ci va subito invece di aspettare in coda la fine della
+            // risposta. I comandi e tutto cio' che l'host non accetta restano in coda.
+            if (active && options.deliverToActive?.(raw))
+                return tail;
+            // `tail` viene sempre normalizzata a una Promise risolta: anche una
+            // callback inattesa che lanci non puo' bloccare le righe future.
+            const scheduled = tail.then(() => runOne(raw));
+            tail = scheduled.catch((error) => report(error));
+            return tail;
+        },
+        close() {
+            if (stopped)
+                return;
+            stopped = true;
+            active?.abort();
+        },
+        idle() {
+            return tail;
+        },
+    };
+}
+export async function startRepl(deps) {
+    if (deps.recoverQueue && !deps.harness.session.head) {
+        const recovered = recoverableQueue(deps.harness.config.sessionDir);
+        if (recovered)
+            deps.harness.loadSession(recovered);
+    }
+    const { harness } = deps;
+    const env = harness.env;
+    let commandNames = [];
+    // Superficie di commit: instrada l'output (incluse le notify delle estensioni)
+    // nella regione viva quando la TUI ancorata e' attiva, altrimenti su stdout.
+    // Riassegnata dopo la creazione del BottomInput.
+    let commit = (t) => stdout.write(t);
+    // Modalita' TUI per le estensioni + UI reale (notify nella regione viva).
+    harness.host.bind({
+        mode: "tui",
+        ui: {
+            confirm: async () => false,
+            select: async () => null,
+            input: async () => null,
+            notify: (m, t) => commit(`\n  ${t === "error" ? "✗" : t === "warn" ? "!" : "·"} ${m}\n`),
+            setStatus: () => { },
+            setWidget: () => { },
+        },
+    });
+    await harness.host.emit("session_start", { reason: "startup" });
+    // Tema: builtin + custom dalle dir; default da auto-detect background. Le
+    // dir di progetto richiedono project trust.
+    const store = loadThemes(harness.config.cwd, env, harness.projectTrusted, harness.packages.themeDirs);
+    let activeName = harness.config.ui.theme || defaultThemeName(env);
+    let activeSpec = findTheme(store.themes, activeName) ?? findTheme(store.themes, defaultThemeName(env));
+    let theme = makeTheme(harness.config.ui, activeSpec);
+    const themeCtl = {
+        available: store.themes,
+        activeName: () => activeName,
+        spec: () => activeSpec,
+        apply: (name) => {
+            const spec = findTheme(store.themes, name);
+            if (!spec)
+                return false;
+            activeName = name;
+            activeSpec = spec;
+            theme = makeTheme(harness.config.ui, spec);
+            // Persiste la scelta nel config globale: sopravvive al riavvio.
+            saveGlobalSettings(env, { ui: { theme: name } });
+            return true;
+        },
+    };
+    // Hot reload: aggiorna il tema attivo quando il suo file cambia. Niente
+    // stampa: una scrittura asincrona corromperebbe l'area di contenuto mentre
+    // l'utente digita; il footer riflette il nuovo tema al prossimo ridisegno.
+    for (const [name, path] of Object.entries(store.paths)) {
+        try {
+            watch(path, { persistent: false }, () => {
+                const fresh = parseThemeFile(path);
+                if (fresh && name === activeName) {
+                    activeSpec = fresh;
+                    theme = makeTheme(harness.config.ui, fresh);
+                }
+            });
+        }
+        catch {
+            // watch non disponibile: hot reload best-effort
+        }
+    }
+    // Theme auto-mode: se il tema non e' fissato (vuoto o "auto"), segue il
+    // background del terminale e si ri-rileva sui cambi (resize). Non persiste:
+    // resta una scelta automatica, non un override esplicito dell'utente.
+    const autoTheme = !harness.config.ui.theme || harness.config.ui.theme === "auto";
+    if (autoTheme && stdout.isTTY) {
+        stdout.on("resize", () => {
+            const want = defaultThemeName(env);
+            if (want === activeName)
+                return;
+            const spec = findTheme(store.themes, want);
+            if (spec) {
+                activeName = want;
+                activeSpec = spec;
+                theme = makeTheme(harness.config.ui, spec);
+            }
+        });
+    }
+    // Prompt templates: discovery dalle dir + path extra via --prompt-template.
+    const extraTemplatePaths = [
+        ...(env["TALOS_PROMPT_TEMPLATES"] ?? "").split(",").map((p) => p.trim()).filter(Boolean),
+        ...harness.packages.prompts,
+    ];
+    const templates = loadTemplates(harness.config.cwd, extraTemplatePaths, harness.projectTrusted);
+    // Vascend NATIVO: sticky attivo di default, senza dover digitare /vascend on.
+    // Si disattiva con TALOS_VASCEND=off|0|false oppure a runtime con /vascend off.
+    const vascend = new VascendRuntime(harness.config.cwd, vascendDefaultMode(env));
+    commandNames = allCommandNames(harness, templates);
+    // Modalita' permessi (Shift+Tab): normale -> accetta modifiche -> auto.
+    // Inizializzata dalla modalita' PERSISTITA nel config globale (ricaricata
+    // all'avvio): se l'ultima sessione era in "auto", riparte in "auto". Default
+    // "normal" come Claude Code.
+    let permMode = harness.config.permMode;
+    const getPermMode = () => permMode;
+    const terminalColumns = () => stdout.columns || 100;
+    // Ultimo usage per il tasso di cache mostrato nel footer.
+    const costTracker = createCostTracker(env);
+    const stats = new SessionUsageState(costTracker);
+    stats.restore(harness.config.sessionDir, harness.session.id, harness.session.tree().find(n => n.message.role === "assistant")?.ts);
+    const review = new ReviewStore();
+    review.reset(sessionConversation(harness.session));
+    const reviewContext = () => {
+        const cost = costTracker.snapshot(harness.config.model);
+        const tasks = vascend.state().kingdom.castles.flatMap(c => c.tasks);
+        return {
+            cwd: harness.config.cwd, model: harness.config.model,
+            permissions: permModeLabel(permMode), sessionId: harness.session.id,
+            usage: `Sessione · ${stats.incomplete || stats.missing ? "almeno " : ""}${formatTokenCount(cost.totalProviderTokens)} token · input ${formatTokenCount(cost.totalPromptTokens)} · output ${formatTokenCount(cost.totalOutputTokens)}` +
+                (cost.anyPriced ? ` · ${formatCost(cost.totalCost)}` : ""),
+            context: `~${formatTokenCount(stimaSessione().tokens)} ${tr("token stimati localmente · /context per i dettagli", "locally estimated tokens · /context for details")}`,
+            plan: tasks.length ? `${tasks.filter(t => t.status === "completed").length}/${tasks.length} attività completate · /piano per il dettaglio` : undefined,
+        };
+    };
+    const stimaSessione = () => {
+        const reading = stats.context.read(harness);
+        return { ...reading, nodi: reading.nodes };
+    };
+    const uiMeta = (status) => {
+        const current = harness.providers.resolve(harness.config.model);
+        const stima = stimaSessione();
+        const last = stats.last;
+        const cacheHitRate = last && last.cacheReadTokens !== undefined
+            ? last.cacheReadTokens / Math.max(1, last.inputTokens + last.cacheReadTokens)
+            : undefined;
+        return {
+            provider: current ? (current.provider.label ?? current.provider.id) : "non configurato",
+            sessionId: harness.session.id,
+            sessionNodes: stima.nodi,
+            headId: harness.session.head,
+            status,
+            contextTokens: stima.tokens,
+            contextWindow: stima.window,
+            contextArchive: stima.archived,
+            cacheHitRate,
+        };
+    };
+    // Hint dei parametri attesi da un comando (in grigio quando il comando e'
+    // gia' completo).
+    const argHintFor = (name) => {
+        const b = BUILTIN_COMMANDS.find((c) => c.name === name);
+        if (b)
+            return b.hint;
+        const t = templates.find((tp) => tp.name === name);
+        if (t)
+            return t.argumentHint;
+        if (name.startsWith("skill:"))
+            return "[argomenti]";
+        return "";
+    };
+    // Suggerimento slash: stringa stilizzata (senza newline) mostrata a destra
+    // del cursore dall'editor in fondo.
+    const slashHint = (line) => {
+        if (!line.startsWith("/"))
+            return "";
+        if (line.includes(" ")) {
+            const name = line.slice(1, line.indexOf(" "));
+            const typed = line.slice(line.indexOf(" ") + 1);
+            const ah = argHintFor(name);
+            return ah && !typed.trim() ? theme.dim(`  ${ah}`) : "";
+        }
+        const frag = line.slice(1).toLowerCase();
+        const matches = commandNames.filter((n) => n.toLowerCase().startsWith(frag));
+        if (!matches.length)
+            return "";
+        const exact = matches.find((m) => `/${m}` === line);
+        if (exact) {
+            const ah = argHintFor(exact);
+            const others = matches.filter((m) => `/${m}` !== line).slice(0, 6).map((m) => `/${m}`);
+            const parts = [ah ? `  ${ah}` : "", others.length ? `   ${others.join("  ")}` : ""].filter(Boolean).join("");
+            return parts ? theme.dim(parts) : "";
+        }
+        return theme.dim("   " + matches.slice(0, 8).map((m) => `/${m}`).join("  ") + "  · Tab");
+    };
+    // Completamento Tab: ritorna il nuovo buffer (miglior match) o null.
+    const completion = (line) => {
+        if (!line.startsWith("/") || line.includes(" "))
+            return null;
+        const frag = line.slice(1).toLowerCase();
+        const matches = commandNames.filter((c) => c.toLowerCase().startsWith(frag));
+        const best = matches[0];
+        if (!best)
+            return null;
+        const full = `/${best}`;
+        return full.toLowerCase() === line.toLowerCase() ? null : full;
+    };
+    const startupMeta = () => {
+        const resolved = harness.providers.resolve(harness.config.model);
+        return {
+            provider: resolved ? (resolved.provider.label ?? resolved.provider.id) : "non configurato",
+            sessionId: harness.session.id,
+            sessionNodes: harness.session.tree().length,
+            headId: harness.session.head,
+        };
+    };
+    const startupBanner = () => renderStartup(harness.config, startupMeta(), { columns: terminalColumns(), compact: true }, activeSpec);
+    // Nota d'accesso da mostrare nel banner (impostata dall'ingresso pre-TUI).
+    let accessoNota = "";
+    // Ingresso PRIMA di qualsiasi UI (stile Claude Code/Codex), in tre passi:
+    //   1) lingua;
+    //   2) termini d'uso, con i collegamenti ufficiali di vascend.it (gli stessi
+    //      mostrati nelle email e nella schermata di accesso di Horizon);
+    //   3) accesso con l'account Vascend (lo stesso di Horizon).
+    // Lingua e termini si chiedono UNA volta (persistiti e versionati in
+    // ~/.talos/onboarding.json); il login solo quando non c'e' una sessione
+    // valida. Dentro l'host Horizon l'utente e' GIA' autenticato dall'app;
+    // script/test saltano con TALOS_NO_LOGIN=1; senza TTY niente flusso
+    // interattivo. Rete giu': conta SOLO la prova offline firmata (Ed25519,
+    // chiave pubblica compilata, orologio ancorato): una "sessione" scritta a
+    // mano nel config non supera la firma.
+    const ingressoPrimaDellaTui = async () => {
+        const note = await enterAccount(env);
+        accessoNota = note ? theme.muted("  " + note) : "";
+    };
+    // Registro degli allegati immagine della sessione TUI: incollare un path/data
+    // URI immagine (o usare /img) crea un riferimento compatto "img #N" (stile
+    // Claude) e ne mostra l'anteprima inline quando il messaggio viene inviato.
+    const imageRegistry = new ImageRegistry();
+    // Stesso principio per il testo incollato: un blocco grande diventa "txt #N"
+    // e il contenuto vero resta qui fino all'invio. I riferimenti valgono per
+    // questa sessione soltanto: dopo /new, `txt #1` sarebbe un altro testo.
+    const pasteRegistry = new PasteRegistry();
+    const resetSessionUi = (ctl) => {
+        ctl.clearConversation?.();
+        review.reset(sessionConversation(harness.session));
+        imageRegistry.clear();
+        pasteRegistry.reset();
+        ctl.restoreQueue?.();
+        stats.restore(harness.config.sessionDir, harness.session.id, harness.session.tree().find(n => n.message.role === "assistant")?.ts);
+        for (const channel of collapsibleChannels.values())
+            ctl.removeFold(channel.foldId);
+        collapsibleChannels.clear();
+        ctl.setKingdomBoard(null);
+        ctl.setKingdomVassals(null);
+        ctl.setTokens(0, 0, 0);
+        ctl.refresh?.();
+    };
+    // Hook di incollo del BottomInput. Due trasformazioni, stessa idea: un
+    // allegato grande non deve invadere la riga di input.
+    //   - immagine (path esistente o data URI) -> "img #N";
+    //   - testo lungo -> "txt #N", col contenuto vero tenuto da parte e rimesso
+    //     al suo posto solo all'invio.
+    const onPasteInput = (text) => {
+        const src = detectImageSource(text, harness.config.cwd);
+        if (src)
+            return imageRegistry.add(src).ref;
+        if (!shouldCollapsePaste(text))
+            return null;
+        return pasteRegistry.add(text).ref;
+    };
+    // Hook Alt+V del BottomInput: legge i byte dell'immagine dalla CLIPBOARD DI
+    // SISTEMA (i terminali non mandano binari via stdin) e la registra come "img
+    // #N". L'allegato compare come riferimento evidenziato nel testo di input.
+    // Ritorna il riferimento da inserire nel
+    // buffer, o null se non c'era un'immagine (mostrando un avviso esplicativo).
+    const onCaptureImage = async (ctl) => {
+        const res = await readClipboardImage();
+        if (!res.ok) {
+            if (res.reason !== "empty") {
+                notifyStatus(ctl, theme.yellow(`\n  clipboard: ${res.detail}\n`));
+            }
+            else {
+                notifyStatus(ctl, theme.dim(`\n  clipboard: ${res.detail}\n`));
+            }
+            return null;
+        }
+        const att = imageRegistry.addData(res.bytes, res.mime, "clipboard");
+        return att.ref;
+    };
+    // Dispatch di una riga (slash o prompt). Ritorna "quit" per uscire. Tutto il
+    // corpo e' protetto: un errore non deve uccidere la sessione (era la causa di
+    // "sessione terminata (codice undefined)").
+    const processLine = async (raw, ctl, signal, fromQueue = false, queued) => {
+        const line = raw.trim();
+        if (!line)
+            return;
+        try {
+            if (!line.startsWith("/")) {
+                ctl.write(renderUserMessage(line, theme, terminalColumns(), fromQueue ? tr("Dalla coda · consegnato", "From queue · delivered") : undefined));
+                const imageParts = queued ? queued.parts.filter(part => part.type === "image") : imageRegistry.imagePartsFor(line);
+                // In chat resta il riferimento compatto (`txt #1`); al modello va il
+                // testo per intero. L'espansione avviene qui, dopo l'echo e prima del
+                // giro: e' l'ultimo punto in cui le due viste possono divergere.
+                const prepared = vascend.prepareUserInput(queued ? pendingText(queued) : pasteRegistry.expand(line));
+                await drive(deps, prepared.input, ctl, theme, terminalColumns, stats, signal, getPermMode, prepared.active ? vascend : undefined, line, imageParts);
+                return;
+            }
+            const reviewCommand = /^\/(?:review|revisione)(?:\s+(.*))?$/i.exec(line);
+            if (reviewCommand) {
+                const section = (reviewCommand[1] ?? "").trim();
+                if (ctl.showReview)
+                    ctl.showReview(section);
+                else
+                    ctl.write(reviewText(review, reviewContext(), theme, terminalColumns(), section));
+                return;
+            }
+            // /img <path>: allega esplicitamente un'immagine. La registra come "img #N"
+            // e ne mostra l'anteprima inline; non avvia un turno (e' solo l'allegato).
+            const imgCmd = /^\/img(?:\s+(.+))?$/i.exec(line);
+            if (imgCmd) {
+                const arg = (imgCmd[1] ?? "").trim();
+                if (!arg) {
+                    // Senza argomento: leggi l'immagine dalla CLIPBOARD DI SISTEMA. E' il
+                    // fallback affidabile ad Alt+V quando il terminale non inoltra la
+                    // combinazione (Windows Terminal/VS Code la intercettano spesso).
+                    const ref = await onCaptureImage(ctl);
+                    if (ref)
+                        notifyStatus(ctl, theme.accent(`\n  + ${ref}`) + theme.dim(" · citalo nel messaggio per usarlo\n"));
+                    return;
+                }
+                const src = detectImageSource(arg, harness.config.cwd);
+                if (!src) {
+                    notifyStatus(ctl, theme.yellow(`\n  non riconosciuta come immagine: ${truncate(arg, 60)}\n`) +
+                        theme.dim("  serve un path a un file immagine esistente (png/jpg/gif/webp/bmp) o un data URI.\n"));
+                    return;
+                }
+                const att = imageRegistry.add(src);
+                notifyStatus(ctl, theme.accent(`\n  + ${att.ref}`) + theme.dim(` · ${att.label} — citalo nel messaggio per usarlo\n`));
+                return;
+            }
+            // "/" da solo apre la palette dei comandi (stessa via di /commands).
+            const handled = await handleSlash(line === "/" ? "/commands" : line, deps, ctl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, () => resetSessionUi(ctl));
+            if (handled === "quit")
+                return "quit";
+            if (handled !== null) {
+                await drive(deps, handled.input, ctl, theme, terminalColumns, stats, signal, getPermMode, handled.vascend ? vascend : undefined);
+            }
+        }
+        catch (err) {
+            ctl.pauseQueuedMessages?.();
+            notifyStatus(ctl, `Errore: ${err.message}`, true);
+        }
+        finally {
+            // Fine del giro: da qui in poi le righe tornano a fare turni nuovi.
+            endActiveTurnInbox();
+        }
+    };
+    // L'ingresso viene PRIMA di qualsiasi UI: lingua, termini d'uso e accesso
+    // (schermata dedicata, stile Claude Code). Da qui in poi l'utente ha scelto
+    // la lingua, accettato i termini ed e' autenticato (o esente: host Horizon,
+    // script, no-TTY).
+    await ingressoPrimaDellaTui();
+    // Tema auto: rileva il background REALE del terminale via OSC 11 (piu'
+    // preciso dell'euristica env). Va fatto prima di avviare l'editor (che prende
+    // possesso di stdin). Fallback: l'euristica gia' applicata sopra.
+    if (autoTheme && BottomInput.supported() && env["TALOS_CLASSIC_INPUT"] !== "1") {
+        const mode = await queryBackgroundMode();
+        const want = mode === "light" ? "vascend-light" : mode === "dark" ? "vascend-dark" : null;
+        if (want && want !== activeName) {
+            const spec = findTheme(store.themes, want);
+            if (spec) {
+                activeName = want;
+                activeSpec = spec;
+                theme = makeTheme(harness.config.ui, spec);
+            }
+        }
+    }
+    // Barra di input ANCORATA in fondo (default in TTY): contenuto scrollabile
+    // sopra, footer + input fissi in basso, a tutto terminale.
+    if (BottomInput.supported() && env["TALOS_CLASSIC_INPUT"] !== "1") {
+        // Carica un eventuale regno persistito (sessione ripresa) cosi' la status
+        // line lo mostra gia' prima del primo turno.
+        vascend.loadPlan(harness.config.sessionDir, harness.session.id);
+        // Status line: ordine dei segmenti da config.json (statusLine) + estensione
+        // utente (.talos/status-line.js) per segmenti custom o override. Entrambi
+        // ricaricabili A CALDO via file watch.
+        let statusOrder = harness.config.statusLine;
+        let statusExt = await loadStatusExt(harness.config.cwd, harness.projectTrusted);
+        const statusOpts = () => ({ order: statusOrder, custom: statusExt.custom, render: statusExt.render });
+        // Hot reload del file estensione.
+        for (const f of statusLineFiles(harness.config.cwd, harness.projectTrusted)) {
+            try {
+                watch(f, { persistent: false }, () => {
+                    void loadStatusExt(harness.config.cwd, harness.projectTrusted).then((ext) => { statusExt = ext; });
+                });
+            }
+            catch {
+                // il file potrebbe non esistere ancora: watch best-effort
+            }
+        }
+        // Hot reload di statusLine da config.json (rilegge l'ordine dei segmenti).
+        for (const cf of harness.config.loadedConfigFiles) {
+            try {
+                watch(cf, { persistent: false }, () => {
+                    try {
+                        const raw = JSON.parse(readFileSync(cf, "utf8"));
+                        if (Array.isArray(raw.statusLine))
+                            statusOrder = raw.statusLine.map(String);
+                    }
+                    catch {
+                        // file in scrittura: ignora
+                    }
+                });
+            }
+            catch {
+                // best effort
+            }
+        }
+        const statusData = () => {
+            const m = uiMeta("pronto");
+            const castles = vascend.state().kingdom.castles;
+            const all = castles.flatMap((c) => c.tasks);
+            const regno = castles.length
+                ? { done: all.filter((t) => t.status === "completed").length, total: all.length, castles: castles.length }
+                : null;
+            return {
+                model: harness.config.model,
+                provider: m.provider,
+                cwd: harness.config.cwd,
+                effort: harness.config.effort || "default",
+                fast: Boolean(harness.config.fast && harness.providers.resolve(harness.config.model)?.provider.supportsFastMode),
+                vibeMode: harness.config.vibeMode,
+                permissions: permMode,
+                sessionLabel: harness.session.name || undefined,
+                contextTokens: m.contextTokens,
+                contextWindow: m.contextWindow,
+                contextArchive: m.contextArchive,
+                regno,
+                cost: costTracker.snapshot(harness.config.model),
+                bg: (() => {
+                    const l = backgroundManager.list();
+                    return l.length ? { running: l.filter((t) => t.status === "running").length, total: l.length } : null;
+                })(),
+                width: terminalColumns(),
+            };
+        };
+        const input = new BottomInput({
+            review,
+            createReviewScreen: (section) => new ReviewScreen(review, () => theme, reviewContext, section),
+            nativeScroll: env["TALOS_NATIVE_SCROLL"] !== "0",
+            headerLines: () => buildTerminalHeader(statusData(), theme),
+            startupLines: () => buildTerminalStartup(statusData(), theme),
+            promptText: () => theme.accent(harness.config.ui.prompt),
+            placeholder: () => theme.muted(tr("Chiedi a Talos di fare qualcosa", "Ask Talos to do anything")),
+            composerPadding: () => !harness.session.head,
+            composerStyle: (s) => theme.composerText?.(s) ?? theme.chatText(s),
+            attachmentStyle: (s) => theme.attachmentRef?.(s) ?? s,
+            belowInputLines: () => {
+                if (!harness.session.head)
+                    return [buildStartupRuntime(statusData(), theme)];
+                const providerId = harness.providers.resolve(harness.config.model)?.provider.id ?? "";
+                return buildUsageFooter(statusData(), theme, stats, providerId, statusOpts()).slice(1);
+            },
+            footerLines: () => {
+                if (!harness.session.head)
+                    return [];
+                const providerId = harness.providers.resolve(harness.config.model)?.provider.id ?? "";
+                return buildUsageFooter(statusData(), theme, stats, providerId, statusOpts()).slice(0, 1);
+            },
+            completion,
+            hint: slashHint,
+            statusStyle: (s) => theme.dark(s),
+            boxStyle: (s) => theme.chatBorder(s),
+            onHotkey: (name) => (name === "todo" || name === "regno" ? "/todo" : null),
+            // Ctrl+G in ogni momento: snapshot del piano con la stanza corrente
+            // evidenziata (funziona anche mentre l'agente lavora).
+            onShowPlan: () => {
+                vascend.loadPlan(harness.config.sessionDir, harness.session.id);
+                input.write(renderPlanSnapshot(vascend.state(), theme, terminalColumns()));
+            },
+            onCycleMode: () => {
+                permMode = nextPermMode(permMode);
+                // Persiste la scelta nel config globale: la modalita' (es. "auto")
+                // sopravvive al riavvio, come modello/effort/tema.
+                saveGlobalSettings(env, { permMode });
+                input.setRoomStatus(tr("Permessi: {mode}", "Permissions: {mode}", { mode: permissionLabel(permMode) }), "done");
+            },
+            // Ctrl+B: manda in background il comando shell in corso; se non ce n'e'
+            // uno, mostra la lista dei task in background.
+            onBackground: () => {
+                const task = backgroundManager.requestBackground();
+                if (task)
+                    input.write(theme.dim(`\n  ⤓ in background [${task.id}]: ${truncate(task.command, 60)}\n`));
+                else
+                    void showBackgroundPanel(input, theme, terminalColumns);
+            },
+            // Suffisso spinner: suggerisce Ctrl+B solo quando c'e' un comando in corso.
+            runningHint: () => backgroundManager.hasForeground() ? "Ctrl+B sfondo" : null,
+            prepareQueuedInput: text => [{ type: "text", text: pasteRegistry.expand(text) }, ...imageRegistry.imagePartsFor(text)],
+            queuePersistence: () => new PromptQueueFile(harness.config.sessionDir, harness.session.id),
+            restoreQueuedInput: entry => restoreQueuedInput(entry, imageRegistry),
+            queueStyle: { heading: s => theme.accent(s), muted: s => theme.muted(s), selected: s => theme.chatText(s), text: s => theme.silver(s) },
+            onSubmit: async (line, signal, fromQueue, queued) => {
+                const result = await processLine(line, input, signal, fromQueue, queued);
+                if (result === "quit")
+                    input.requestQuit();
+            },
+            // Incollo: un path/data-URI immagine diventa "img #N", un testo lungo
+            // diventa "txt #N", il resto si inserisce come testo normale.
+            onPaste: onPasteInput,
+            // Alt+V: cattura l'immagine dalla clipboard di sistema -> "img #N".
+            onCaptureImage: () => onCaptureImage(input),
+            // Backspace su un token "img #N" o "txt #N": cancellazione atomica (tolgo
+            // tutto il riferimento) cosi' l'allegato si scollega per intero in un colpo.
+            onBackspaceToken: (buffer, cursor) => {
+                const span = imageTokenSpanAt(buffer, cursor) ?? pasteTokenSpanAt(buffer, cursor);
+                return span ? { start: span.start, end: span.end } : null;
+            },
+            onReady: () => {
+                input.write(buildTerminalWelcome(terminalColumns(), theme));
+                if (accessoNota)
+                    input.write(wrapText(accessoNota, Math.max(2, terminalColumns() - 3), true).map((line) => theme.muted("  " + line.trim())).join("\n") + "\n");
+                input.write("\n");
+                if (harness.session.head)
+                    replaySession(harness.session, input, theme, terminalColumns());
+                if (deps.resumePicker)
+                    void processLine("/resume", input, new AbortController().signal);
+            },
+            onQuit: () => {
+                void harness.host.emit("session_shutdown", {});
+                stdout.write("\n");
+                process.exit(0);
+            },
+        });
+        // Le notify delle estensioni vanno nella regione viva (no corruzione).
+        commit = (t) => input.write(t);
+        // UI reale per le estensioni: confirm/select/input passano dalla TUI (cosi'
+        // un'estensione puo' fare domande in chat come il tool builtin ask_user).
+        harness.host.bind({
+            mode: "tui",
+            ui: {
+                confirm: async (title, message) => {
+                    const c = await selectOption({
+                        title,
+                        hint: message,
+                        options: [
+                            { key: "yes", label: "Sì", detail: "", value: true },
+                            { key: "no", label: "No", detail: "", value: false },
+                        ],
+                        currentKey: "yes",
+                        ctl: input, theme, terminalColumns,
+                    });
+                    return c?.value === true;
+                },
+                select: async (title, items) => {
+                    const c = await selectOption({
+                        title,
+                        hint: "↑/↓ scegli · Enter conferma · Esc annulla",
+                        options: items.map((it, i) => ({ key: String(i), label: it.label, detail: "", value: it.value })),
+                        ctl: input, theme, terminalColumns,
+                    });
+                    return c ? c.value : null;
+                },
+                input: async (title) => input.promptInput(title),
+                notify: (m, t) => commit(`\n  ${t === "error" ? "✗" : t === "warn" ? "!" : "·"} ${m}\n`),
+                setStatus: () => { },
+                setWidget: () => { },
+            },
+        });
+        // Vista LIVE: ad ogni cambio di stato dei task in background ridisegna la
+        // status-line (il segmento `bg` mostra running/totale aggiornato).
+        backgroundManager.onChange(() => input.refresh());
+        // Notifica quando un task STACCATO (Ctrl+B) termina, cosi' si puo' rivedere.
+        backgroundManager.onFinish((t) => {
+            if (!t.detached)
+                return; // i comandi in primo piano mostrano gia' il risultato inline
+            const mark = t.status === "done" ? theme.green("✓") : theme.red("✗");
+            input.write(`\n  ${mark} background ${t.id} ` +
+                theme.dim(`[${t.status}${t.exitCode != null ? ` · uscita ${t.exitCode}` : ""}] ${truncate(t.command, 50)} · /bg ${t.id} per l'output\n`));
+        });
+        await input.start();
+        return;
+    }
+    // Fallback (non-TTY o TALOS_CLASSIC_INPUT=1): loop readline classico inline.
+    stdout.write(startupBanner());
+    if (harness.session.head)
+        replaySession(harness.session, { write: text => stdout.write(text) }, theme, terminalColumns());
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    const ctl = {
+        review,
+        pause: () => rl.pause(),
+        resume: () => rl.resume(),
+        write: (t) => stdout.write(t),
+        clearConversation: () => { if (stdout.isTTY)
+            stdout.write("\x1b[0m\x1b[2J\x1b[3J\x1b[H"); },
+        setStatus: () => { },
+        setTokens: () => { },
+        setOverlay: () => { },
+        promptInput: (label) => new Promise((resolve) => {
+            rl.question(theme.silver(`  ${label} `), (ans) => resolve(ans.length ? ans : null));
+        }),
+        logLength: () => -1, // fold non supportato nel fallback classico
+        fold: () => -1,
+        openFold: () => -1,
+        updateFoldSummary: () => { },
+        updateFold: () => { },
+        closeFold: () => { },
+        expandFold: () => false,
+        expandAllFolds: () => 0,
+        removeFold: () => false,
+        setKingdomVassals: () => { },
+        setKingdomBoard: () => { },
+        hasKingdomBoard: () => false,
+    };
+    const prompt = () => {
+        stdout.write(renderInputPrompt(harness.config, uiMeta("pronto"), theme, terminalColumns()));
+        rl.setPrompt(theme.silver(`  ${harness.config.ui.prompt}`));
+        rl.prompt();
+    };
+    prompt();
+    const lineQueue = createSerialReadlineQueue({
+        processLine: (raw, signal) => processLine(raw, ctl, signal),
+        prompt,
+        requestClose: () => rl.close(),
+        onError: (error) => notifyStatus(ctl, theme.red(`\n  errore: ${error.message}\n`)),
+        installAbort: (abort) => {
+            const onSigint = () => abort();
+            process.once("SIGINT", onSigint);
+            return () => process.removeListener("SIGINT", onSigint);
+        },
+        // Scrivere mentre l'agente lavora non mette piu' la riga in fila dietro
+        // alla risposta: entra nel giro in corso al primo confine sicuro.
+        deliverToActive: (raw) => {
+            try {
+                return deliverToActiveTurn(raw, [{ type: "text", text: pasteRegistry.expand(raw) }, ...imageRegistry.imagePartsFor(raw)]);
+            }
+            catch (error) {
+                notifyStatus(ctl, theme.red(`\n  ${error instanceof Error ? error.message : String(error)}\n`));
+                return true;
+            }
+        },
+    });
+    rl.on("line", (raw) => {
+        void lineQueue.enqueue(raw);
+    });
+    rl.on("close", () => {
+        lineQueue.close();
+        harness.dispose?.();
+        void harness.host.emit("session_shutdown", {});
+        stdout.write("\n");
+        process.exit(0);
+    });
+}
+// Esegue un giro dell'agente con render degli eventi e steering via Ctrl+C.
+async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, getPermMode, vascend, rawGoal, imageParts) {
+    const env = deps.harness.env;
+    if (!deps.harness.providers.resolve(deps.harness.config.model)) {
+        ctl.write(theme.yellow(`\n  modello non configurato: ${deps.harness.config.model}\n`) +
+            theme.dim("  scegli un modello disponibile per continuare.\n"));
+        const selected = await pickModel(deps.harness, ctl, theme, terminalColumns);
+        if (!selected)
+            return;
+    }
+    // Gate permessi: selezione Sì/No dalla UI con le frecce (stile Claude Code),
+    // niente piu' digitazione di y/n. Le modalita' "accetta modifiche"/"auto"
+    // (Shift+Tab) saltano il prompt per le azioni che approvano.
+    const confirm = async (action, detail) => {
+        if (autoApproves(getPermMode(), action))
+            return true;
+        const choice = await selectOption({
+            title: `consenti: ${action}`,
+            hint: detail,
+            options: [
+                { key: "yes", label: "Sì, esegui", detail: "consenti questa azione", value: true },
+                { key: "no", label: "No, annulla", detail: "blocca l'azione", value: false },
+            ],
+            currentKey: "yes",
+            ctl,
+            theme,
+            terminalColumns,
+        });
+        return choice?.value === true;
+    };
+    // Domanda all'utente in chat (tool ask_user): opzioni -> picker; libera -> input.
+    const ask = async (question, options) => {
+        if (ctl.queueQuestion)
+            return ctl.queueQuestion(question, options, signal);
+        if (options && options.length) {
+            const choice = await selectOption({
+                title: question,
+                question: true,
+                options: options.map((o) => ({ label: o, detail: "", value: o })),
+                ctl,
+                theme,
+                terminalColumns,
+            });
+            return choice?.value ?? null;
+        }
+        ctl.write(renderQuestion(question, theme, terminalColumns()));
+        return ctl.promptInput("rispondi qui (Invio conferma · Esc annulla)");
+    };
+    // Kingdoms Mode invocabile dall'agente (tool kingdoms_warm): esegue i castelli
+    // in parallelo (vassalli) e ritorna i report. Il consenso e' gia' stato dato
+    // al gate del tool (ctx.confirm); qui i vassalli eseguono i tool in blocco.
+    const spawnKingdom = async (castles, kopts) => {
+        if (kopts?.detach)
+            return runKingdomForHost({
+                harness: deps.harness, castles, signal, sink: wrappedSink, confirm, ask, env, detach: true,
+                ...(kopts.baseBranch ? { baseBranch: kopts.baseBranch } : {}),
+            });
+        // Obiettivo complessivo del regno: esplicito > goal grezzo del turno.
+        const kingdomGoal = (kopts?.goal ?? rawGoal ?? "").trim();
+        const conc = warmConcurrency(env);
+        const total = castles.length;
+        const wt = worktreeMode(env);
+        // Bus pulito per il nuovo regno: sia in-memory sia il canale persistente
+        // file-based (cross-process, kingdoms granulari), se attivo.
+        kingdomBus.clear(`kw-${deps.harness.session.id}`);
+        resolveKingdomBus(env, deps.harness.config.sessionDir).clear(`kw-${deps.harness.session.id}`);
+        notifyStatus(ctl, `${total} gruppi · max ${conc} collaboratori`);
+        // Organizzazione del regno (decisa in progettazione): chi parte subito e chi
+        // dipende da chi. I dipendenti si coordinano/aspettano via i messaggi.
+        for (const c of castles) {
+            const dep = c.after && c.after.length ? theme.yellow(`  ⟸ dopo ${c.after.join(", ")}`) : theme.dim("  · base");
+            ctl.refresh?.();
+        }
+        // La panoramica live (avvii, attività, messaggi, completamenti) va nella
+        // BOARD della regione viva, NON nella chat: si aggiorna in place senza
+        // riempire lo scroll. Il dettaglio per-vassallo resta nel viewer (Ctrl+G).
+        const live = createKingdomLive(ctl, theme, castles);
+        const reports = await runKingdomWarm({
+            harness: deps.harness,
+            kingdomId: `kw-${deps.harness.session.id}`,
+            castles,
+            signal,
+            confirm,
+            concurrency: conc,
+            ask,
+            onEvent: live.onEvent,
+            worktree: wt,
+            ...(kopts?.baseBranch ? { baseBranch: kopts.baseBranch } : {}),
+            onNotice: (text) => notifyStatus(ctl, theme.accent("    ⎇ ") + theme.dim(text) + "\n"),
+        });
+        live.finish();
+        const isolated = reports.some((r) => r.branch);
+        const lines = reports
+            .map((r) => {
+            const mg = r.merge ? (r.merge.ok ? " · merge ✓" : ` · merge ✗ (${r.merge.conflict ? "conflitto" : "errore"}, ramo ${r.branch} conservato)`) : "";
+            return `[${r.slug}] ${r.ok ? "✓" : "✗"} (${r.rooms} attivita)${r.error ? ` errore: ${r.error}` : ""}${mg}: ${truncate(r.summary, 300)}`;
+        })
+            .join("\n");
+        // INDICE del contesto del regno per l'agente in chat: cosi' sa cosa hanno
+        // prodotto i vassalli e puo' recuperarne il dettaglio con recall.
+        let index = "";
+        try {
+            const mem = RoomMemory.open(deps.harness.config.sessionDir, `kw-${deps.harness.session.id}`);
+            const block = mem.indexBlock();
+            if (block.trim())
+                index = `\n\nATTIVITA DEL PIANO (recall per il dettaglio):\n${block}`;
+        }
+        catch { /* nessuna memoria */ }
+        const conflicts = collectConflicts(reports);
+        const stashList = formatConflictList(conflicts);
+        const gitNote = isolated
+            ? `\n\n[NOTA_GIT]
+@stato[rami]: ogni collaboratore in worktree isolato; rami merge-ati nel ramo base
+@conflitti[merge]: ${conflicts.length ? `${conflicts.map((r) => r.slug).join(", ")} NON merge-ati (rami conservati, risoluzione manuale)` : "nessuno"}
+@azione[consegna]: verifica diff e controlli nel ramo base; push solo se richiesto dall'utente`
+            : `\n\n[NOTA_GIT]
+@stato[modifiche]: nel working tree, NON committate (i collaboratori non fanno git: working dir condivisa)
+@azione[consegna]: verifica diff e controlli; commit e push solo se richiesti dall'utente`;
+        const stashNote = stashList ? `\n\n${stashList}` : "";
+        // GATE KPI DI REGNO (opt-in: solo se self-improve e' abilitato). Misura
+        // l'esecuzione (KPI di processo) e l'allineamento alla Vision/obiettivo
+        // finale, e produce un verdetto. Fail-open: in errore non blocca. Il
+        // verdetto viene mostrato all'utente senza innescare altri turni automatici.
+        if (selfImproveEnabled(env) && reports.length && !signal.aborted) {
+            ctl.setStatus(tr("verifica finale del piano", "final plan review"));
+            try {
+                const idxBlock = index ? index.replace(/^[\s\S]*?:\n/, "") : "";
+                const verdict = await runKingdomGate({
+                    harness: deps.harness,
+                    reports,
+                    goal: kingdomGoal,
+                    ...(idxBlock ? { roomIndex: idxBlock } : {}),
+                    signal,
+                });
+                ctl.setStatus(null);
+                ctl.write("\n  " + formatKingdomGate(verdict).split("\n").join("\n  ") + "\n");
+            }
+            catch {
+                ctl.setStatus(null); // fail-open: nessun gate
+            }
+        }
+        return `PIANO COMPLETATO · ${reports.length} gruppi\n${lines}${index}${gitNote}${stashNote}`;
+    };
+    const sdir = deps.harness.config.sessionDir;
+    const sid = deps.harness.session.id;
+    // Quando vascend e' attivo, il sink attribuisce i token alle stanze (delta
+    // cumulativo) e mostra il riepilogo per castello a castello completato.
+    const baseSink = makeSink(theme, terminalColumns, deps.harness.config.cwd, env, ctl, vascend ? { sdir, sid } : undefined);
+    ctl.review?.begin(rawGoal ?? input);
+    ctl.setStatus(tr("avvio", "starting"));
+    let turnFailed = false;
+    const wrappedSink = (event) => {
+        if (event.type === "error" || (event.type === "turn_end" && event.stopReason === "error"))
+            turnFailed = true;
+        ctl.review?.record(event);
+        if (event.type === "usage" && stats.observe)
+            stats.observe(event);
+        if (event.type === "context_window")
+            stats.context?.observe(deps.harness, event.ledger);
+        if (event.type === "turn_end" && event.usage && !stats.observe) {
+            stats.last = event.usage;
+            stats.cost?.record(deps.harness.config.model, event.usage);
+        }
+        baseSink(event);
+    };
+    // Casella dello STEERING: quello che l'utente scrive mentre questo giro
+    // lavora entra qui e viene preso in carico al primo confine sicuro. Resta
+    // registrata come casella attiva per tutta la durata del giro (la chiude
+    // processLine, che sa quando il giro e' finito).
+    const inbox = ctl.userInbox ?? beginActiveTurnInbox();
+    const mayContinue = async (trigger) => {
+        const resolved = deps.harness.providers.resolve(deps.harness.config.model);
+        if (!resolved)
+            return false;
+        const tasks = vascend?.state().kingdom.castles.flatMap(c => c.tasks.map(t => ({ ref: t.id, title: t.title, status: t.status }))) ?? [];
+        const decision = await reviewContinuation({ provider: resolved.provider, model: resolved.modelId,
+            sessionId: sid, userRequest: rawGoal ?? input, history: deps.harness.session.history(), openTasks: tasks,
+            trigger, signal, inbox });
+        if (decision?.decision === "continue")
+            return true;
+        if (decision)
+            notifyStatus(ctl, decision.reason, decision.decision === "unavailable");
+        return false;
+    };
+    const completionEvidence = () => {
+        const rows = deps.harness.session.history().slice(-24).flatMap((message) => message.content.flatMap((part) => {
+            if (part.type === "tool_call")
+                return [`TOOL ${part.name} input=${JSON.stringify(part.input).slice(0, 1_500)}`];
+            if (part.type === "tool_result")
+                return [`TOOL_RESULT ${part.callId} ${part.isError ? "ERROR" : "OK"}: ${part.output.slice(0, 2_500)}`];
+            if (part.type === "text" && message.role === "assistant")
+                return [`ASSISTANT: ${part.text.slice(0, 2_000)}`];
+            return [];
+        }));
+        return rows.join("\n").slice(-16_000);
+    };
+    try {
+        // Se ci sono immagini allegate (ref "img #N" risolti), il turno parte con
+        // parti miste testo+immagini, cosi' i bytes raggiungono il modello.
+        const turnInput = imageParts && imageParts.length
+            ? [{ type: "text", text: input }, ...imageParts]
+            : input;
+        await runTurn({ ...deps.harness.deps(confirm), ask, spawnKingdom, inbox }, turnInput, wrappedSink, signal);
+        if (turnFailed || signal.aborted)
+            return;
+        // REVISORE di team: per i task complessi (molte stanze) con stanze fatte e
+        // altre da fare, un agente separato analizza le metriche (token/durata) e
+        // riorganizza/aggiunge le stanze rimaste prima di proseguire.
+        if (vascend && !signal.aborted) {
+            const ro = reviewOptions(env);
+            vascend.loadPlan(sdir, sid);
+            if (ro.enabled && shouldReview(vascend.state(), ro.minRooms)) {
+                if (!await mayContinue("Review and reorganize unfinished tasks after the assistant finished."))
+                    return;
+                await runTeamReviewer(deps, vascend, sdir, sid, ctl, theme, terminalColumns, signal);
+            }
+        }
+        // VALIDAZIONE Danilov: se l'agente ha creato un castello ma ha lasciato
+        // stanze AL BUIO, svegliarlo per completarle (deterministico: il regno valida
+        // solo se tutte illuminate). Cap di wake-up per non ciclare/sprecare token.
+        if (vascend) {
+            const MAX_WAKE = 2;
+            for (let wake = 0; wake < MAX_WAKE && !signal.aborted; wake += 1) {
+                vascend.loadPlan(sdir, sid);
+                const v = validateKingdom(vascend.state());
+                if (v.ok || v.pending.length === 0)
+                    break; // tutte risolte (done o failed)
+                if (!await mayContinue("The TUI found unfinished plan tasks after the assistant finished."))
+                    return;
+                notifyStatus(ctl, theme.yellow(`\n  ⚠ validazione: ${v.done}/${v.total} attivita · da completare: ${v.pending.join(", ")} → riprendo il lavoro\n`));
+                ctl.setStatus(tr("verifica", "checking"));
+                await runTurn({ ...deps.harness.deps(confirm), ask, spawnKingdom, inbox }, buildValidationSteer(v), wrappedSink, signal);
+                if (turnFailed || signal.aborted)
+                    return;
+            }
+        }
+        // COMPLETEZZA: piano "validato" != goal consegnato. Per un obiettivo grande,
+        // un critico valuta se il GOAL REALE e' completo; se mancano pezzi essenziali
+        // l'agente continua (altri castelli/stanze). Cosi' non si ferma al primo piano.
+        if (vascend && rawGoal && completenessEnabled(env) && looksBigGoal(rawGoal)) {
+            const rounds = completenessRounds(env);
+            for (let r = 0; r < rounds && !signal.aborted; r += 1) {
+                vascend.loadPlan(sdir, sid);
+                const castles = vascend.state().kingdom.castles;
+                const planDigest = castles.map((c) => `${c.title}: ${c.tasks.map((t) => `${t.id} [${t.status}] ${t.title}${t.evidence?.length ? ` evidence=${t.evidence.join(" | ")}` : ""}`).join("; ")}`).join("\n");
+                const evidence = `${completionEvidence()}\n\nSTATO PIANO:\n${planDigest}`;
+                ctl.setStatus(tr("verifico la completezza del goal", "checking goal completion"));
+                const verdict = await judgeCompleteness({ harness: deps.harness, goal: rawGoal, evidence, signal });
+                ctl.setStatus(null);
+                if (verdict.uncertain) {
+                    notifyStatus(ctl, theme.red(`\n  ⚠ completezza non verificabile: ${verdict.reason || "evidenze insufficienti"}\n`));
+                    break;
+                }
+                if (verdict.complete)
+                    break;
+                if (!await mayContinue(`A completeness check suggests: ${verdict.missing.join("; ")}`))
+                    return;
+                notifyStatus(ctl, theme.yellow(`\n  ⚠ completezza: il goal non e' completo, mancano ${verdict.missing.length} pezzi → continuo\n`));
+                for (const m of verdict.missing)
+                    notifyStatus(ctl, theme.dim(`     · ${m}\n`));
+                await runTurn({ ...deps.harness.deps(confirm), ask, spawnKingdom, inbox }, buildCompletenessSteer(rawGoal, verdict.missing), wrappedSink, signal);
+                if (turnFailed || signal.aborted)
+                    return;
+            }
+        }
+    }
+    catch (err) {
+        ctl.review?.record({ type: "error", message: err.message });
+        notifyStatus(ctl, theme.red(`\n  errore: ${err.message}\n`));
+    }
+    finally {
+        ctl.review?.finish(signal.aborted);
+        ctl.setStatus(null);
+        if (vascend) {
+            // Ricarica il piano: mostra le stanze reali (e i loro stati) se l'agente
+            // ha pianificato durante il turno; altrimenti nessun riquadro.
+            vascend.loadPlan(sdir, sid);
+            // Niente riquadro inline se la board live del regno e' gia' pinned: si
+            // sovrapporrebbero (stessa vista del regno due volte).
+            const box = ctl.hasKingdomBoard() ? "" : renderVascendStatus(vascend.state(), theme, terminalColumns());
+            if (box.trim())
+                ctl.refresh?.();
+            // Verdetto deterministico del regno (validate == state==MASK_TARGET).
+            const v = validateKingdom(vascend.state());
+            if (v.total > 0) {
+                if (v.ok) {
+                    notifyStatus(ctl, theme.green(`\n  ✓ Lista verificata: ${v.done}/${v.total} attività completate\n`));
+                }
+                else {
+                    const pending = v.pending.map((p) => `${p} da completare`);
+                    const ko = v.failed.map((f) => `${f} fallita`);
+                    ctl.refresh?.();
+                }
+            }
+        }
+    }
+}
+// Revisore di team: agente isolato (sessione propria) instradato sullo STESSO
+// piano via roomStoreId, con tool ridotti (sola lettura + editing-piano sicuro,
+// niente bash/scrittura/mark). Analizza le metriche e migliora le stanze rimaste.
+async function runTeamReviewer(deps, vascend, sdir, sid, ctl, theme, terminalColumns, signal) {
+    const digest = buildRoomMetricsDigest(vascend.state());
+    notifyStatus(ctl, theme.accent("\n  ◳ revisore di team") + theme.dim(" · analizzo token/durata delle attivita fatte e riorganizzo le rimaste\n"));
+    const base = deps.harness.deps(async () => true); // revisore: auto-consenso (tool senza effetti pericolosi)
+    const allow = new Set(["recall", "read_file", "list_dir", "glob", "grep", "web_fetch", "vascend_note", "vascend_skill", "vascend_addtasks"]);
+    const tools = new ToolRegistry();
+    for (const name of base.tools.names()) {
+        if (allow.has(name)) {
+            const t = base.tools.get(name);
+            if (t)
+                tools.register(t);
+        }
+    }
+    const session = Session.create(base.config.sessionDir, `rev-${sid}-${Date.now()}`);
+    // roomStoreId=sid: il revisore EDITA lo stesso piano e puo' fare recall sulle
+    // stanze; perRoom=false: la sua sessione NON archivia nella memoria condivisa.
+    const config = { ...base.config, roomStoreId: sid, compaction: { ...base.config.compaction, perRoom: false } };
+    const rdeps = { ...base, tools, session, config };
+    let buf = "";
+    const revCalls = new Map();
+    const sink = (event) => {
+        ctl.review?.recordActor("revisore", event);
+        if (event.type === "text") {
+            buf += event.delta;
+            ctl.setStatus(tr("revisione", "reviewing"));
+        }
+        else if (event.type === "tool_call") {
+            if (buf.trim()) {
+                notifyStatus(ctl, theme.dim("  " + buf.trim().split("\n").join("\n  ")) + "\n");
+                buf = "";
+            }
+            revCalls.set(event.call.id, event.call);
+            notifyStatus(ctl, theme.dim(`  ◦ [revisore] ${toolLabel(event.call.name)}(${toolArg(event.call)})`));
+        }
+        else if (event.type === "tool_result") {
+            const rcall = revCalls.get(event.result.callId);
+            const rsum = event.result.isError ? firstLine(event.result.output) : (resultSummary(rcall, event.result.output) ?? firstLine(event.result.output));
+            notifyStatus(ctl, theme.dim(` ⎿ ${rsum}`));
+        }
+        else if (event.type === "done") {
+            if (buf.trim()) {
+                notifyStatus(ctl, theme.dim("  " + buf.trim().split("\n").join("\n  ")) + "\n");
+                buf = "";
+            }
+        }
+    };
+    try {
+        await runTurn(rdeps, buildReviewerPrompt(digest), sink, signal);
+    }
+    catch (err) {
+        notifyStatus(ctl, theme.dim(`  revisore interrotto: ${err.message}\n`));
+    }
+    vascend.loadPlan(sdir, sid);
+}
+export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
+    let textBuffer = "";
+    let assistantSegments = 0;
+    let assistantStarted = false;
+    let assistantClosed = false;
+    const writeNotice = (text, failed = false) => {
+        notifyStatus(ctl, text, failed);
+    };
+    // Correlazione call->risultato e contenuto PRE-scrittura, per gli avvisi del
+    // regno e per il diff dei tool di scrittura.
+    const calls = new Map();
+    const preContent = new Map();
+    const commandCards = new Map();
+    const wrappers = new Map();
+    const mcpCards = new Map();
+    const toolCards = new Map();
+    const skillCards = new Map();
+    let newInputTok = 0; // input non in cache del run (cumulativo)
+    let cacheTok = 0; // cache letta/scritta nel run (cumulativo)
+    let outTok = 0; // token generati nel run (cumulativi)
+    // Traccia se l'ultimo turno e' stato troncato (stop=max_tokens): se il run
+    // chiude (done) ancora in questo stato, l'auto-continuazione si e' esaurita
+    // e avvisiamo di spezzare il compito.
+    let lastTruncated = false;
+    // Attribuzione token per stanza: snapshot di outTok all'avvio (running) ->
+    // costo a stanza completata (delta). Castelli gia' riepilogati (per non
+    // ripetere il riepilogo a ogni mark successivo).
+    const roomStart = new Map();
+    const summarized = new Set();
+    const flushText = (phase = "progress") => {
+        // Rimuovi eventuale markup di tool-call emesso come testo (viene recuperato
+        // ed eseguito dal loop agente): non deve comparire in chat.
+        const text = stripToolMarkup(textBuffer).trimEnd();
+        if (text) {
+            const sequence = assistantSegments + 1;
+            const kind = !assistantStarted
+                ? (phase === "final" ? "only" : "start")
+                : phase === "final" ? "final" : "progress";
+            ctl.write(renderAssistantSegment(text, theme, terminalColumns(), { cwd, env }, kind, sequence));
+            assistantSegments = sequence;
+            assistantStarted = true;
+        }
+        textBuffer = "";
+    };
+    const closeAssistant = (status = "completed") => {
+        if (assistantClosed || !assistantStarted)
+            return;
+        const ending = renderAssistantTurnEnd(theme, assistantSegments, status);
+        if (ending)
+            ctl.write(ending);
+        assistantClosed = true;
+    };
+    const ensureAssistantStarted = () => {
+        if (assistantStarted)
+            return;
+        ctl.write(renderAssistantTurnStart(theme, terminalColumns()));
+        assistantStarted = true;
+    };
+    // Animazione del bullet ● accanto al tool IN CORSO nello scrollback: si tiene
+    // l'indice della sua riga di log, il nome del tool e la coda statica della riga
+    // (tutto cio' che segue il bullet, gia' renderizzato). Un timer riscrive solo
+    // quella riga col bullet pulsante (pulseDot) finche' non arriva il risultato.
+    let liveDot = null;
+    let liveFrame = 0;
+    let dotTimer;
+    const stopDot = (settle = true) => {
+        if (dotTimer) {
+            clearInterval(dotTimer);
+            dotTimer = undefined;
+        }
+        // Riposa il bullet allo stato statico (accent) come il resto dello scrollback.
+        if (settle && liveDot && ctl.setLogLine) {
+            ctl.setLogLine(liveDot.index, fitLine(theme.dark("  │ ") + theme.accent("● ") + liveDot.tail, terminalColumns() - 1));
+        }
+        liveDot = null;
+    };
+    const startDot = (index, name, tail) => {
+        stopDot(false); // chiudi l'eventuale precedente senza ridisegnare (verra' sovrascritto)
+        if (!ctl.setLogLine)
+            return; // fallback readline: niente animazione scrollback
+        liveDot = { index, name, tail };
+        liveFrame = 0;
+        dotTimer = setInterval(() => {
+            if (!liveDot || !ctl.setLogLine)
+                return;
+            liveFrame += 1;
+            ctl.setLogLine(liveDot.index, fitLine(theme.dark("  │ ") + pulseDot(liveDot.name, liveFrame) + " " + liveDot.tail, terminalColumns() - 1));
+        }, 140);
+    };
+    const beginCommand = () => {
+        flushText();
+        ensureAssistantStarted();
+        stopDot();
+        ctl.write("\n");
+    };
+    return (event) => {
+        switch (event.type) {
+            case "context_window":
+                ctl.refresh?.();
+                break;
+            case "turn_start":
+                if (assistantClosed) {
+                    assistantSegments = 0;
+                    assistantStarted = false;
+                    assistantClosed = false;
+                }
+                ctl.setStatus(tr("elaboro", "working"));
+                ctl.setStatusTool?.(null);
+                stopDot();
+                break;
+            case "turn_end":
+                // Token provider cumulativi del run, separati tra input nuovo, cache e
+                // output. Sono valori API, non la stima locale del contesto.
+                if (event.usage) {
+                    newInputTok += event.usage.inputTokens;
+                    cacheTok += (event.usage.cacheReadTokens ?? 0) + (event.usage.cacheWriteTokens ?? 0);
+                    outTok += event.usage.outputTokens;
+                    ctl.setTokens(newInputTok, cacheTok, outTok);
+                }
+                // Output troncato: il modello ha raggiunto il tetto di token. L'agente
+                // auto-continua (vedi runTurn); qui solo un avviso discreto che la
+                // risposta proseguira' nel turno seguente. Se l'auto-continuazione e'
+                // disabilitata o esaurita, il messaggio "output ancora troncato" arriva
+                // come evento status separato.
+                lastTruncated = event.stopReason === "max_tokens";
+                if (event.stopReason === "max_tokens") {
+                    notifyStatus(ctl, theme.dim("\n  ⟳ output al limite del modello: continuo automaticamente…\n"));
+                }
+                break;
+            case "status":
+                // Il contesto ha gia' barra e conteggi; non sostituisce l'attivita' viva.
+                if (event.category === "context")
+                    break;
+                // Attivita' del modello senza testo (es. streaming di un input grande).
+                ctl.setStatus(event.label);
+                break;
+            case "text":
+                ctl.setStatus(tr("risposta in corso", "responding"));
+                ctl.setStatusTool?.(null);
+                stopDot();
+                textBuffer += event.delta;
+                break;
+            case "tool_call": {
+                if (event.parentId) {
+                    const parent = wrappers.get(event.parentId);
+                    if (parent)
+                        parent.child = true;
+                }
+                calls.set(event.call.id, event.call);
+                // Compact protocol wrappers emit real child calls. Show those commands
+                // once, without a duplicate execute(args) envelope in the transcript.
+                if (event.call.name === "execute" || event.call.name === "tool_invoke" || event.call.name === "run_program") {
+                    if (textBuffer.trim()) {
+                        flushText();
+                    }
+                    wrappers.set(event.call.id, { child: false });
+                    ctl.setStatus(tr("avvio operazione", "starting operation"));
+                    break;
+                }
+                const skillName = loadedSkill(event.call);
+                if (skillName !== undefined) {
+                    beginCommand();
+                    const rows = skillPreview(skillName, theme, terminalColumns());
+                    const index = ctl.logLength();
+                    ctl.write(rows.join("\n") + "\n");
+                    skillCards.set(event.call.id, { index, header: rows[0], name: skillName });
+                    ctl.setStatus(tr("Lettura skill {name}", "Reading skill {name}", { name: skillName }));
+                    ctl.setStatusTool?.(event.call.name);
+                    break;
+                }
+                if (event.call.name === "ask_user" && ctl.queueQuestion) {
+                    flushText();
+                    ctl.setStatus(tr("Risposta in attesa", "Awaiting answer"));
+                    break;
+                }
+                if (mcpName(event.call.name)) {
+                    beginCommand();
+                    const rows = mcpPreview(event.call, theme, terminalColumns());
+                    const index = ctl.logLength();
+                    ctl.write(rows.join("\n") + "\n");
+                    mcpCards.set(event.call.id, { index, end: ctl.logLength(), header: rows[0] });
+                    ctl.setStatus(tr("Esegue {name}", "Calling {name}", { name: mcpName(event.call.name) ?? event.call.name }));
+                    ctl.setStatusTool?.(event.call.name);
+                    break;
+                }
+                // Shell commands have a short source/output preview; programs keep a
+                // compact header with their source available in review.
+                const source = event.call.name === "bash" ? commandSource(event.call) : undefined;
+                if (source !== undefined) {
+                    beginCommand();
+                    const columns = terminalColumns();
+                    const preview = commandPreview(source, theme, columns);
+                    ctl.write(preview.lines.join("\n") + "\n");
+                    commandCards.set(event.call.id, { index: ctl.logLength() - preview.lines.length,
+                        firstRow: preview.firstRow, columns, end: ctl.logLength(), header: preview.lines[0] });
+                    ctl.setStatus(tr("esegue comando terminale", "running terminal command"));
+                    ctl.setStatusTool?.(event.call.name);
+                    break;
+                }
+                // vascend_mark: NON scrive nulla in chat (ne' bullet ne' connettore) —
+                // lo stato della stanza vive solo nella status-line, animato. Registra
+                // la call per il tool_result e mostra subito l'esito sulla status-line.
+                if (event.call.name === "vascend_mark") {
+                    if (textBuffer.trim()) {
+                        flushText();
+                    }
+                    calls.set(event.call.id, event.call);
+                    const task = String(event.call.input["task"] ?? "");
+                    const slug = String(event.call.input["group"] ?? event.call.input["castle"] ?? "master");
+                    const st = String(event.call.input["status"] ?? "completed");
+                    const where = slug === "master" ? "" : `${slug}/`;
+                    if (st === "running")
+                        ctl.setRoomStatus?.(`attività ${where}${task} avviata`, "running");
+                    else if (st === "failed")
+                        ctl.setRoomStatus?.(`attività ${where}${task} non riuscita`, "failed");
+                    else
+                        ctl.setRoomStatus?.(`attività ${where}${task} completata`, "done");
+                    break;
+                }
+                // Each operation owns a small separate block. Full data stays in review.
+                flushText();
+                ensureAssistantStarted();
+                ctl.write("\n");
+                const gitSum = event.call.name === "bash" ? gitSummary(String(event.call.input["command"] ?? "")) : null;
+                ctl.setStatus(toolLabel(event.call.name));
+                ctl.setStatusTool?.(event.call.name);
+                calls.set(event.call.id, event.call);
+                // Cattura il contenuto PRIMA della scrittura, per il diff (il file non
+                // e' ancora stato toccato a questo punto del loop).
+                if (event.call.name === "write_file") {
+                    const p = event.call.input["path"];
+                    if (typeof p === "string" && p) {
+                        const abs = isAbsolute(p) ? p : resolve(cwd, p);
+                        preContent.set(event.call.id, existsSync(abs) ? safeRead(abs) : "");
+                    }
+                }
+                // Stile Claude Code: ● Etichetta(argomento). Se l'argomento E' un path,
+                // l'argomento STESSO diventa il link cliccabile (sottolineato dal
+                // terminale) — niente piu' path duplicato dopo le parentesi.
+                const pathArg = event.call.input["path"];
+                const label = gitSum ? "Git" : toolLabel(event.call.name);
+                const argText = livePreview(gitSum ?? toolArg(event.call), terminalColumns() - terminalWidth(label) - 9);
+                const argRendered = typeof pathArg === "string" && pathArg && argText === pathArg
+                    ? fileLink(isAbsolute(pathArg) ? pathArg : resolve(cwd, pathArg), theme.dim(pathArg))
+                    : theme.dim(argText);
+                // Nome del tool COLORATO per categoria (read/write/shell/search/...): a
+                // colpo d'occhio si distingue il tipo di azione. Git eredita la categoria
+                // shell (e' un comando bash).
+                const nameRendered = gitSum
+                    ? paintCategoryName("shell", "Git")
+                    : paintToolName(event.call.name, toolLabel(event.call.name));
+                // Coda statica della riga (tutto cio' che segue il bullet): la riusiamo
+                // sia per la scrittura iniziale sia per l'animazione del bullet.
+                const tail = nameRendered + theme.dim("(") + argRendered + theme.dim(")");
+                const header = fitLine(theme.dark("  │ ") + theme.accent("● ") + tail, terminalColumns() - 1);
+                ctl.write(header + "\n");
+                toolCards.set(event.call.id, { end: ctl.logLength(), header });
+                if (event.call.name === "ask_user")
+                    startDot(ctl.logLength() - 1, event.call.name, tail);
+                break;
+            }
+            case "tool_result": {
+                ctl.setStatus(tr("elaboro", "working"));
+                stopDot(); // ferma l'animazione del bullet: il tool e' finito
+                const call = calls.get(event.result.callId);
+                const toolCard = toolCards.get(event.result.callId);
+                toolCards.delete(event.result.callId);
+                if (event.parentId) {
+                    const parent = wrappers.get(event.parentId);
+                    if (parent) {
+                        parent.output = event.result.output;
+                        parent.isError = event.result.isError;
+                    }
+                }
+                const skillCard = skillCards.get(event.result.callId);
+                if (skillCard) {
+                    skillCards.delete(event.result.callId);
+                    const failed = Boolean(event.result.isError || /^(?:errore:|skill sconosciuta:)/i.test(event.result.output));
+                    const state = failed ? "error" : "ok";
+                    const retained = !ctl.getLogLine || ctl.getLogLine(skillCard.index) === skillCard.header;
+                    if (retained && ctl.setLogLine)
+                        ctl.setLogLine(skillCard.index, skillHeader(state, theme, terminalColumns()));
+                    else
+                        ctl.write("\n" + skillPreview(skillCard.name, theme, terminalColumns(), state).join("\n") + "\n");
+                    if (failed)
+                        ctl.write(commandOutput(event.result.output, theme, terminalColumns(), true).join("\n") + "\n");
+                    break;
+                }
+                const wrapper = wrappers.get(event.result.callId);
+                if (wrapper) {
+                    wrappers.delete(event.result.callId);
+                    // An identical child failure is already visible; a distinct wrapper
+                    // failure (validation, postprocessing) must still be shown.
+                    if (wrapper.child && (!event.result.isError || wrapper.isError && wrapper.output === event.result.output))
+                        break;
+                    flushText();
+                    ensureAssistantStarted();
+                    const source = call && commandSource(call);
+                    if (source !== undefined) {
+                        ctl.write("\n" + commandPreview(source, theme, terminalColumns(), commandResultState(event.result.output, event.result.isError)).lines.join("\n") + "\n");
+                    }
+                    else {
+                        ctl.write("\n" + fitLine((event.result.isError ? theme.red("  × ") : theme.green("  ● "))
+                            + toolLabel(call?.name ?? "execute"), terminalColumns() - 1) + "\n");
+                    }
+                    ctl.write(commandOutput(event.result.output, theme, terminalColumns(), event.result.isError).join("\n") + "\n");
+                    break;
+                }
+                const mcpCard = mcpCards.get(event.result.callId);
+                if (mcpCard && call) {
+                    flushText();
+                    const state = event.result.isError ? "error" : "ok";
+                    const retained = !ctl.getLogLine || ctl.getLogLine(mcpCard.index) === mcpCard.header;
+                    if (retained)
+                        ctl.setLogLine?.(mcpCard.index, mcpHeader(state, theme, terminalColumns()));
+                    if (!retained || !ctl.setLogLine || ctl.logLength() !== mcpCard.end) {
+                        ctl.write("\n" + mcpPreview(call, theme, terminalColumns(), state).join("\n") + "\n");
+                    }
+                    ctl.write(mcpOutput(event.result.output, event.result.isError, theme, terminalColumns()).join("\n") + "\n");
+                    mcpCards.delete(event.result.callId);
+                    break;
+                }
+                const card = commandCards.get(event.result.callId);
+                if (card && call) {
+                    const state = commandResultState(event.result.output, event.result.isError);
+                    const retained = !ctl.getLogLine || ctl.getLogLine(card.index) === card.header;
+                    if (retained)
+                        ctl.setLogLine?.(card.index, commandHeader(card.firstRow, state, theme, card.columns));
+                    // Parallel calls can complete in a different order. Repeat the
+                    // command above its result when another block intervened.
+                    if (ctl.logLength() !== card.end || !ctl.setLogLine || !retained) {
+                        flushText();
+                        ctl.write("\n" + commandPreview(commandSource(call), theme, terminalColumns(), state).lines.join("\n") + "\n");
+                    }
+                    ctl.write(commandOutput(event.result.output, theme, terminalColumns(), event.result.isError).join("\n") + "\n");
+                    commandCards.delete(event.result.callId);
+                    break;
+                }
+                if (call && !event.result.isError && call.name === "write_file") {
+                    ctl.review?.change(call.id, { before: call.input["append"] === true ? "" : preContent.get(call.id),
+                        after: String(call.input["content"] ?? ""), scope: call.input["append"] === true ? "append" : "file" });
+                }
+                // Token per stanza/castello (solo con vascend attivo). Snapshot a
+                // "running", costo a "completed"/"failed", riepilogo a castello completo.
+                if (plan && call && call.name === "vascend_mark" && !event.result.isError) {
+                    trackRoomTokens(plan, call, event.result.output, outTok, roomStart, summarized, ctl, theme, terminalColumns());
+                }
+                // Stanze Danilov (vascend_mark): NIENTE riga in chat (era rumoroso) —
+                // avvio/illuminazione/fallimento vanno nella status-line, animati.
+                if (call && call.name === "vascend_mark" && !event.result.isError) {
+                    const task = String(call.input["task"] ?? "");
+                    const slug = String(call.input["group"] ?? call.input["castle"] ?? "master");
+                    const st = String(call.input["status"] ?? "completed");
+                    const where = slug === "master" ? "" : `${slug}/`;
+                    if (st === "running")
+                        ctl.setRoomStatus?.(`attività ${where}${task} avviata`, "running");
+                    else if (st === "failed")
+                        ctl.setRoomStatus?.(`attività ${where}${task} non riuscita`, "failed");
+                    else
+                        ctl.setRoomStatus?.(`attività ${where}${task} completata`, "done");
+                    break;
+                }
+                // Detailed plans are available in the task panel.
+                const notice = call && !event.result.isError
+                    ? renderVascendToolNotice(call, event.result.output, theme, terminalColumns())
+                    : null;
+                if (notice) {
+                    notifyStatus(ctl, notice);
+                    break;
+                }
+                // Associate out-of-order results with their own operation rather than
+                // appending several anonymous result lines below the newest call.
+                if (toolCard && toolCard.end !== ctl.logLength())
+                    ctl.write("\n" + toolCard.header + "\n");
+                // Stile Claude Code: connettore ad albero col risultato sintetico. Il
+                // connettore e' in accent (ancora visivo della riga tool), il testo in
+                // muted (piu' leggibile del dim slavato, ma chiaramente secondario).
+                {
+                    const summary = liveResultSummary(event.result.output, event.result.isError ? null : resultSummary(call, event.result.output), terminalColumns());
+                    ctl.write(theme.dark("  │ ") + (event.result.isError ? theme.red("× ") : theme.dark("⎿ ")) +
+                        (event.result.isError ? theme.red(summary) : theme.dim(summary)) + "\n");
+                }
+                // Keep the change preview alongside its operation.
+                if (call && !event.result.isError) {
+                    const diff = diffForCall(call, preContent.get(event.result.callId), event.result.output, theme, terminalColumns());
+                    if (diff) {
+                        ctl.write(previewDiff(diff, theme, terminalColumns() - 1));
+                    }
+                }
+                break;
+            }
+            case "compacted":
+                stopDot();
+                flushText();
+                notifyStatus(ctl, `Contesto aggiornato: ~${formatTokenCount(event.tokensAfter)} token`);
+                break;
+            case "workspace_message":
+                flushText();
+                writeNotice(`sessione ${event.message.fromLabel}: ${oneLine(event.message.text)}`);
+                break;
+            case "user_message":
+                // Un messaggio scritto durante il lavoro e' appena entrato nel giro:
+                // l'agente lo legge adesso, non a fine risposta.
+                stopDot();
+                flushText();
+                closeAssistant();
+                ctl.write(renderUserMessage(ctl.acceptQueuedMessage?.(event.id) ?? event.text, theme, terminalColumns(), event.immediate ? tr("Inviato subito · preso in carico", "Sent immediately · received") : tr("Dalla coda · consegnato durante il lavoro", "From queue · delivered while working")));
+                assistantSegments = 0;
+                assistantStarted = false;
+                assistantClosed = false;
+                break;
+            case "error":
+                for (const card of mcpCards.values()) {
+                    if (!ctl.getLogLine || ctl.getLogLine(card.index) === card.header)
+                        ctl.setLogLine?.(card.index, mcpHeader("stopped", theme, terminalColumns()));
+                }
+                mcpCards.clear();
+                ctl.pauseQueuedMessages?.();
+                stopDot();
+                flushText("final");
+                closeAssistant("error");
+                for (const card of commandCards.values()) {
+                    if (!ctl.getLogLine || ctl.getLogLine(card.index) === card.header)
+                        ctl.setLogLine?.(card.index, commandHeader(card.firstRow, "stopped", theme, card.columns));
+                }
+                commandCards.clear();
+                writeNotice(`errore: ${event.message}`, true);
+                break;
+            case "done":
+                for (const card of mcpCards.values()) {
+                    if (!ctl.getLogLine || ctl.getLogLine(card.index) === card.header)
+                        ctl.setLogLine?.(card.index, mcpHeader("stopped", theme, terminalColumns()));
+                }
+                mcpCards.clear();
+                stopDot();
+                flushText("final");
+                closeAssistant();
+                for (const card of commandCards.values()) {
+                    if (!ctl.getLogLine || ctl.getLogLine(card.index) === card.header)
+                        ctl.setLogLine?.(card.index, commandHeader(card.firstRow, "stopped", theme, card.columns));
+                }
+                commandCards.clear();
+                // Auto-continuazione esaurita: il run finisce ancora troncato. Avvisa di
+                // spezzare il compito (o alzare TALOS_MAX_AUTOCONTINUE).
+                if (lastTruncated) {
+                    notifyStatus(ctl, theme.yellow("\n  ⚠ output ancora al limite del modello dopo le continuazioni automatiche: spezza il compito o alza TALOS_MAX_AUTOCONTINUE.\n"));
+                }
+                break;
+        }
+    };
+}
+// Attribuzione token alle stanze + riepilogo per castello (metodo Danilov).
+// All'avvio della stanza (running) salva lo snapshot di outTok; a stanza
+// completata/fallita calcola il delta (token generati), lo persiste nel piano e,
+// se il castello e' completo, mostra il riepilogo micro (per stanza) + totale.
+function trackRoomTokens(plan, call, output, outTok, roomStart, summarized, ctl, theme, columns) {
+    const slug = String(call.input["group"] ?? call.input["castle"] ?? "master");
+    const m = /\]\s+(T\d+)\s+0x[0-9a-f]+\s*->\s*(\w+)/i.exec(output);
+    if (!m)
+        return;
+    const id = m[1];
+    const status = (m[2] ?? "").toLowerCase();
+    const key = `${slug}/${id}`;
+    if (status === "running") {
+        roomStart.set(key, outTok);
+        summarized.delete(slug); // castello tornato in lavorazione
+        return;
+    }
+    if (status !== "completed" && status !== "failed")
+        return;
+    const start = roomStart.get(key);
+    const store = VascendPlanStore.open(plan.sdir, plan.sid);
+    if (start !== undefined) {
+        store.setRoomTokens(slug, id, Math.max(0, outTok - start));
+        roomStart.delete(key);
+    }
+    // Riepilogo se il castello e' completo (nessuna stanza pending/running).
+    const castle = store.castle(slug);
+    if (!castle || summarized.has(slug))
+        return;
+    const open = castle.tasks.some((t) => t.status === "pending" || t.status === "running");
+    if (open)
+        return;
+    summarized.add(slug);
+    notifyStatus(ctl, renderCastleTokens(castle, theme, columns));
+}
+// Riepilogo token di un castello su una sola riga. Le metriche per stanza sono
+// nel piano Ctrl+G: ripeterle qui rendeva il flusso molto rumoroso.
+function renderCastleTokens(castle, theme, columns) {
+    const total = castle.tasks.reduce((s, t) => s + (t.tokens ?? 0), 0);
+    const failed = castle.tasks.filter((task) => task.status !== "completed").length;
+    const available = Math.max(20, columns - 56);
+    const title = castle.title.length > available ? castle.title.slice(0, available - 1) + "…" : castle.title;
+    const result = failed ? theme.yellow(`${castle.tasks.length - failed}/${castle.tasks.length}`) : theme.green(`${castle.tasks.length}/${castle.tasks.length}`);
+    return theme.green(`\n  ◆ ${title}`) + theme.dim(" · completato · ") + result +
+        theme.dim(` attività · ↓${fmtTok(total)} · Ctrl+G dettagli\n`);
+}
+// Snapshot del piano (Ctrl+G): castelli, stanze e STANZA CORRENTE evidenziata.
+// Disponibile in ogni momento, anche durante un run.
+function renderPlanSnapshot(state, theme, columns) {
+    const castles = state.kingdom.castles;
+    if (!castles.length) {
+        return theme.dim("\n  lista delle attività vuota: comparirà quando Talos suddivide il lavoro.\n");
+    }
+    const width = Math.max(30, columns - 6);
+    const all = castles.flatMap((c) => c.tasks);
+    const done = all.filter((t) => t.status === "completed").length;
+    // Stanza corrente: la prima "running"; altrimenti la prima "pending".
+    let cur = null;
+    for (const c of castles) {
+        const r = c.tasks.find((t) => t.status === "running");
+        if (r) {
+            cur = { slug: c.slug, task: r };
+            break;
+        }
+    }
+    if (!cur)
+        for (const c of castles) {
+            const r = c.tasks.find((t) => t.status === "pending");
+            if (r) {
+                cur = { slug: c.slug, task: r };
+                break;
+            }
+        }
+    const out = [];
+    out.push(theme.accent(`\n  ◆ lista delle attività`) + theme.dim(` · ${castles.length} grupp${castles.length === 1 ? "o" : "i"} · ${done}/${all.length} attività`));
+    for (const c of castles) {
+        const cd = c.tasks.filter((t) => t.status === "completed").length;
+        const dep = c.after ? theme.dim(` · dopo ${c.after}`) : "";
+        out.push(theme.silver(`    ◆ ${c.title || c.slug}`) + theme.dim(` [${c.slug}] · ${cd}/${c.tasks.length}`) + dep);
+        for (const t of c.tasks) {
+            const isCur = cur && cur.slug === c.slug && cur.task.id === t.id;
+            const tok = t.tokens !== undefined ? theme.dim(` ↓${fmtTok(t.tokens)}`) : "";
+            const title = t.title.length > width - 18 ? t.title.slice(0, width - 21) + "…" : t.title;
+            const row = `      ${vascendRoomGlyph(t.status)} ${t.id} ${title}${tok}`;
+            out.push(isCur ? theme.accent(`    →`) + theme.silver(row.slice(5)) : theme.dim(row));
+        }
+    }
+    if (cur) {
+        out.push(theme.accent(`  → attività corrente: `) + theme.silver(`[${cur.slug}] ${cur.task.id} — ${cur.task.title}`));
+    }
+    else {
+        out.push(theme.green("  ✓ tutte le attività completate"));
+    }
+    return out.join("\n") + "\n";
+}
+// Vista temporanea di /bg: vive nella regione dell'input e non nello storico
+// della chat. Esc, Invio o q la chiudono senza lasciare righe residue.
+async function showBackgroundPanel(ctl, theme, terminalColumns) {
+    const list = backgroundManager.list();
+    const width = Math.max(40, terminalColumns());
+    const lines = list.length
+        ? list.map((t) => {
+            const mark = t.status === "running" ? "●" : t.status === "done" ? "✓" : "✗";
+            const dur = t.endedAt
+                ? `${Math.round((t.endedAt - t.startedAt) / 1000)}s`
+                : `${Math.round((Date.now() - t.startedAt) / 1000)}s`;
+            return `${mark} ${t.id}  ${t.status} · ${dur}  ${truncate(t.command, Math.max(24, width - 30))}`;
+        })
+        : ["Nessuna attivita' shell in background."];
+    await showReadonlyOverlay({
+        title: list.length ? `attivita' in background · ${list.length}` : "attivita' in background",
+        lines,
+        ctl,
+        theme,
+        terminalColumns,
+    });
+}
+// Riconosce un comando git dentro un comando bash e ne ritorna un riassunto
+// leggibile (es. "push origin master", "commit", "checkout main"), o null se non
+// e' git. Estrae il primo segmento git (gestisce "cd x && git ...").
+export function gitSummary(command) {
+    const m = /\bgit\s+(?:-C\s+\S+\s+)?([a-z][\w-]*)/i.exec(command);
+    if (!m)
+        return null;
+    const sub = (m[1] ?? "").toLowerCase();
+    const withTarget = new Set(["push", "pull", "fetch", "checkout", "switch", "merge", "rebase", "branch", "clone", "remote"]);
+    if (withTarget.has(sub)) {
+        const after = command.slice(m.index + m[0].length).split(/&&|;|\||\n/)[0] ?? "";
+        const tokens = after.split(/\s+/).filter((t) => t && !t.startsWith("-")).slice(0, 2);
+        return tokens.length ? `${sub} ${tokens.join(" ")}` : sub;
+    }
+    return sub; // commit/add/status/log/diff/stash/...: niente messaggio/heredoc
+}
+function fmtTok(n) {
+    if (n >= 1_000_000) {
+        const v = n / 1_000_000;
+        return `${v >= 10 ? Math.round(v) : v.toFixed(1)}M`;
+    }
+    if (n >= 1000) {
+        const v = n / 1000;
+        return `${v >= 10 ? Math.round(v) : v.toFixed(1)}k`;
+    }
+    return `${n}`;
+}
+// Anteprima su una riga: serve alle notifiche brevi (per esempio il messaggio
+// consegnato al turno in corso), che non devono spezzare il flusso a schermo.
+export function oneLinePreview(text, max) {
+    const line = String(text ?? "").replace(/\s+/g, " ").trim();
+    return line.length > max ? `${line.slice(0, max - 1).trimEnd()}…` : line;
+}
+// Rimuove il markup di tool-call (<invoke>/<function_calls>) eventualmente
+// emesso come testo dal modello, per non mostrarlo in chat.
+function stripToolMarkup(text) {
+    if (!/<(?:antml:)?(?:invoke|function_calls)\b/.test(text))
+        return text;
+    return text
+        .replace(/<(?:antml:)?function_calls>[\s\S]*?<\/(?:antml:)?function_calls>/g, "")
+        .replace(/<(?:antml:)?invoke\s+name="[^"]*"\s*>[\s\S]*?<\/(?:antml:)?invoke>/g, "")
+        .replace(/^\s*call\s*$/gm, "")
+        .trim();
+}
+function safeRead(abs) {
+    try {
+        return readFileSync(abs, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+// Avviso di chat per i tool del regno. Ritorna true se l'evento e' stato reso
+// come avviso (e quindi NON serve la riga generica). Usa l'INPUT della call
+// (autorevole) e completa col conteggio castelli dall'output.
+function renderVascendToolNotice(call, output, theme, columns) {
+    if (call.name === "vascend_plan") {
+        const title = String(call.input["title"] ?? "");
+        const slug = String(call.input["group"] ?? call.input["castle"] ?? "master");
+        const tasks = Array.isArray(call.input["tasks"]) ? call.input["tasks"].map(String) : [];
+        const m = /(?:piano|regno):\s*(\d+)/.exec(output);
+        const kingdom = m ? Number(m[1]) : 1;
+        return renderCastleBorn({ title, slug, tasks, kingdomCount: kingdom }, theme, columns);
+    }
+    if (call.name === "vascend_mark") {
+        const task = String(call.input["task"] ?? "");
+        const slug = String(call.input["group"] ?? call.input["castle"] ?? "master");
+        const st = String(call.input["status"] ?? "completed");
+        const where = slug === "master" ? "" : `${slug}/`;
+        if (st === "running")
+            return renderVascendNotice("start", `attività ${where}${task} avviata`, theme);
+        if (st === "failed")
+            return renderVascendNotice("fail", `attività ${where}${task} non riuscita`, theme);
+        return renderVascendNotice("done", `attività ${where}${task} completata`, theme);
+    }
+    return null;
+}
+// Diff per i tool di scrittura: write_file (vecchio file su disco -> nuovo
+// contenuto) ed edit_file (old_string -> new_string, cioe' la regione cambiata).
+function diffForCall(call, pre, output, theme, columns) {
+    if (call.name === "write_file" && (output.startsWith("scritto:") || output.startsWith("accodato:"))) {
+        const path = typeof call.input["path"] === "string" ? call.input["path"] : undefined;
+        const append = call.input["append"] === true;
+        const next = String(call.input["content"] ?? "");
+        const existed = (pre ?? "") !== "";
+        const verb = append ? "aggiunto" : existed ? "modificato" : "creato";
+        // In append mostriamo solo l'aggiunta (base vuota); altrimenti il delta vs file.
+        return renderDiff(append ? "" : (pre ?? ""), next, theme, { path, verb, columns: columns - 1, wrapLines: true });
+    }
+    if (call.name === "edit_file" && output.startsWith("modificato:")) {
+        const path = typeof call.input["path"] === "string" ? call.input["path"] : undefined;
+        const oldS = String(call.input["old_string"] ?? "");
+        const newS = String(call.input["new_string"] ?? "");
+        return renderDiff(oldS, newS, theme, { path, verb: "modificato", context: 2, columns: columns - 1, wrapLines: true });
+    }
+    return "";
+}
+// Soglia riferita alle righe del confronto, escluse intestazione e separatore.
+function previewDiff(full, theme, width) {
+    const lines = full.replace(/\n$/, "").split("\n");
+    const limit = 100 + 2;
+    if (lines.length <= limit)
+        return full;
+    const head = lines.slice(0, limit);
+    const hidden = lines.length - limit;
+    const hint = `  … altre ${hidden} righe · Ctrl+O scegli file`;
+    head.push(theme.dim(fitLine(terminalWidth(hint) <= width ? hint : `  Ctrl+O · +${hidden} righe`, width)));
+    return head.join("\n") + "\n";
+}
+// Board live del regno (Kingdoms Mode): panoramica di TUTTI i vassalli aggiornata
+// in place nella regione viva, senza riempire la chat di righe. Tiene per ogni
+// vassallo lo stato (in coda/attivo/fatto/errore) + l'attività corrente, una coda
+// dei messaggi di cooperazione, e alimenta anche il viewer per-vassallo (Ctrl+G).
+function createKingdomLive(ctl, theme, castles) {
+    const total = castles.length;
+    const order = castles.map((c) => c.slug);
+    const afterOf = new Map(castles.map((c) => [c.slug, c.after ?? []]));
+    const vstate = new Map(order.map((s) => [s, { st: "pending", act: "" }]));
+    const msgs = [];
+    const startAt = Date.now();
+    const started = new Set();
+    let done = 0;
+    const logs = new Map(order.map((s) => [s, []]));
+    const textBuf = new Map();
+    const pushLine = (slug, line) => {
+        const a = logs.get(slug);
+        if (!a)
+            return;
+        a.push(line);
+        if (a.length > 400)
+            a.splice(0, a.length - 400);
+    };
+    const flushVassalText = (slug) => {
+        const t = (textBuf.get(slug) ?? "").trim();
+        if (t) {
+            for (const l of t.split("\n"))
+                pushLine(slug, theme.dim(`  ${l}`));
+            textBuf.set(slug, "");
+        }
+    };
+    const refreshView = () => ctl.setKingdomVassals(order.map((s) => ({ slug: s, lines: logs.get(s) ?? [] })));
+    const refreshStatus = (slug, act) => ctl.setStatus(`esecuzione parallela · ${done}/${total} gruppi · ${started.size} attivi · [${slug}] ${act}`);
+    const slugW = Math.min(22, Math.max(6, ...order.map((s) => s.length)));
+    const fmtClock = (sec) => `${Math.floor(sec / 60)}:${String(sec % 60).padStart(2, "0")}`;
+    const buildBoard = () => {
+        const states = order.map((s) => (vstate.get(s) ?? { st: "pending", act: "" }).st);
+        const active = states.filter((st) => st === "active").length;
+        const ko = states.filter((st) => st === "error").length;
+        const pend = states.filter((st) => st === "pending").length;
+        const el = Math.round((Date.now() - startAt) / 1000);
+        // Mini barra di avanzamento del regno (castelli conclusi su totale).
+        const barW = 14;
+        const fill = total > 0 ? Math.round((done / total) * barW) : 0;
+        const bar = theme.yellow("━".repeat(fill)) + theme.dim("─".repeat(Math.max(0, barW - fill)));
+        const counters = [
+            active ? theme.accent(`▸${active}`) : "",
+            pend ? theme.dim(`◇${pend}`) : "",
+            ko ? theme.red(`✗${ko}`) : "",
+            theme.yellow(`✦${done}`),
+        ].filter(Boolean).join(theme.dim(" "));
+        const innerW = slugW + 2 + 56;
+        const out = [
+            theme.accent("  ◆ esecuzione parallela") +
+                theme.dim(`  ${bar}  `) + theme.silver(`${done}/${total}`) +
+                theme.dim(`  ${counters}`) + (el >= 1 ? theme.dim(`  ⏱ ${fmtClock(el)}`) : ""),
+            theme.dim("  " + "┄".repeat(Math.min(innerW, 64))),
+        ];
+        for (const s of order) {
+            const v = vstate.get(s) ?? { st: "pending", act: "" };
+            const icon = v.st === "done" ? theme.yellow("✦") :
+                v.st === "error" ? theme.red("✗") :
+                    v.st === "active" ? theme.accent("▸") : theme.dim("◇");
+            const nameColor = v.st === "active" ? theme.silver : theme.dim;
+            const name = nameColor(`${s}`.padEnd(slugW).slice(0, slugW));
+            let detail;
+            if (v.st === "pending") {
+                const af = afterOf.get(s) ?? [];
+                detail = af.length ? theme.yellow(`⟸ dopo ${af.join(", ")}`) : theme.dim("in coda");
+            }
+            else if (v.st === "done")
+                detail = theme.yellow("completato");
+            else if (v.st === "error")
+                detail = theme.red(truncate(v.act || "errore", 52));
+            else
+                detail = theme.silver(truncate(v.act || "…", 54));
+            out.push(`  ${icon} ${name} ${theme.dim("·")} ${detail}`);
+        }
+        if (msgs.length) {
+            out.push(theme.dim("  " + "┄".repeat(Math.min(innerW, 64))));
+            out.push(theme.accent("  ✉ cooperazione"));
+            for (const m of msgs.slice(-3))
+                out.push(theme.dim(`    ${m}`));
+        }
+        out.push(theme.dim("  " + "┄".repeat(Math.min(innerW, 64))));
+        out.push(theme.dim("  Ctrl+G dettaglio collaboratore · Esc ferma"));
+        return out;
+    };
+    const refreshBoard = () => ctl.setKingdomBoard(buildBoard());
+    ctl.setStatus(`esecuzione parallela · 0/${total} gruppi`);
+    refreshView();
+    refreshBoard();
+    const vassalCalls = new Map();
+    const onEvent = (slug, e) => {
+        ctl.review?.recordActor(slug, e);
+        if (!started.has(slug)) {
+            started.add(slug);
+            vstate.set(slug, { st: "active", act: "avvio" });
+            pushLine(slug, theme.accent("▸ avviato"));
+            refreshBoard();
+        }
+        if (e.type === "text") {
+            textBuf.set(slug, (textBuf.get(slug) ?? "") + e.delta);
+            return;
+        }
+        if (e.type === "tool_call") {
+            flushVassalText(slug);
+            vassalCalls.set(e.call.id, e.call);
+            pushLine(slug, theme.accent(`● ${toolLabel(e.call.name)}`) + theme.dim(`(${toolArg(e.call)})`));
+            const arg = toolArg(e.call);
+            vstate.set(slug, { st: "active", act: `${toolLabel(e.call.name)}${arg ? ` ${arg}` : ""}` });
+            if (e.call.name === "kingdom_send") {
+                const to = typeof e.call.input["to"] === "string" && e.call.input["to"] ? e.call.input["to"] : "tutti";
+                msgs.push(`✉ ${slug}→${to}  ${truncate(String(e.call.input["text"] ?? ""), 54)}`);
+                if (msgs.length > 16)
+                    msgs.splice(0, msgs.length - 16);
+            }
+            refreshStatus(slug, e.call.name);
+            refreshBoard();
+        }
+        else if (e.type === "tool_result") {
+            const vcall = vassalCalls.get(e.result.callId);
+            const vsum = e.result.isError ? firstLine(e.result.output) : (resultSummary(vcall, e.result.output) ?? firstLine(e.result.output));
+            pushLine(slug, (e.result.isError ? theme.red("  ⎿ ") : theme.dim("  ⎿ ")) + theme.dim(vsum));
+        }
+        else if (e.type === "turn_start") {
+            const v = vstate.get(slug);
+            if (v && v.st === "active")
+                vstate.set(slug, { st: "active", act: "ragiona" });
+            refreshStatus(slug, "ragiona");
+            refreshBoard();
+        }
+        else if (e.type === "done") {
+            flushVassalText(slug);
+            done += 1;
+            vstate.set(slug, { st: "done", act: "" });
+            pushLine(slug, theme.yellow("✦ completato"));
+            refreshBoard();
+        }
+        else if (e.type === "error") {
+            flushVassalText(slug);
+            done += 1;
+            vstate.set(slug, { st: "error", act: e.message });
+            pushLine(slug, theme.red(`✗ ${e.message}`));
+            refreshBoard();
+        }
+        refreshView();
+    };
+    const finish = () => {
+        ctl.setKingdomBoard(null);
+        ctl.setKingdomVassals(null);
+        ctl.setStatus(null);
+    };
+    return { onEvent, finish };
+}
+// Eta' leggibile di un timestamp (per il picker delle sessioni).
+function fmtAge(ts) {
+    const s = Math.max(0, Math.round((Date.now() - ts) / 1000));
+    if (s < 60)
+        return tr("{count}s fa", "{count}s ago", { count: s });
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return tr("{count}m fa", "{count}m ago", { count: m });
+    const h = Math.round(m / 60);
+    if (h < 24)
+        return tr("{count}h fa", "{count}h ago", { count: h });
+    return tr("{count}g fa", "{count}d ago", { count: Math.round(h / 24) });
+}
+// Opzioni del picker /resume a partire dalle sintesi delle sessioni.
+function sessionOptions(list) {
+    return list.map((s) => ({
+        key: s.id,
+        label: sessionTitle(s.name ?? "") || s.preview || s.id,
+        detail: `${fmtAge(s.updatedAt)} · ${s.messages} msg · ${s.id}`,
+        value: s.id,
+    }));
+}
+// Riprende una sessione: la carica nell'harness (le closure vedono il nuovo
+// valore), ricarica il piano Vascend e sostituisce la conversazione visibile
+// nello scrollback cosi' l'utente ritrova il contesto. Le sessioni sopravvivono
+// ai riavvii/crash: il prompt non va piu' ridigitato.
+function resumeInto(harness, vascend, id, ctl, theme, tcols, resetSessionUi) {
+    let loaded;
+    try {
+        if (!existsSync(sessionFilePath(harness.config.sessionDir, id)))
+            throw new Error(tr("sessione non trovata", "session not found"));
+        loaded = harness.loadSession(id);
+    }
+    catch (err) {
+        ctl.write(theme.yellow("\n  " + tr("impossibile aprire la sessione {id}: {error}", "Unable to open session {id}: {error}", { id, error: err.message }) + "\n"));
+        return false;
+    }
+    vascend.loadPlan(harness.config.sessionDir, loaded.id);
+    resetSessionUi();
+    replaySession(loaded, ctl, theme, tcols());
+    return true;
+}
+// Etichetta leggibile del tool (stile Claude Code: Read/Write/Update/Bash...).
+function toolLabel(name) {
+    const map = {
+        read_file: "Read",
+        write_file: "Write",
+        edit_file: "Update",
+        list_dir: "List",
+        bash: "Bash",
+        bash_output: "BashOutput",
+        web_fetch: "Fetch",
+        ask_user: "Ask",
+        wait: "Wait",
+        tool_search: "ToolSearch",
+        tool_invoke: "Invoke",
+        skill_search: "SkillSearch",
+        skill_load: "SkillLoad",
+        output_page: "Page",
+        kingdoms_warm: tr("Collaboratori", "Collaborators"),
+        kingdom_send: "Send",
+        kingdom_inbox: "Inbox",
+        kingdom_wait: "WaitMsg",
+        glob: "Glob",
+        grep: "Grep",
+        recall: "Recall",
+        image_generate: "Image",
+        vascend_plan: tr("Lista attività", "Task list"),
+        vascend_mark: tr("Stato attività", "Task status"),
+        vascend_note: "Note",
+        vascend_skill: "Skill",
+        vascend_addtasks: tr("Aggiungi attività", "Add tasks"),
+        vascend_addrooms: tr("Aggiungi attività", "Add tasks"),
+        vascend_status: tr("Lista attività", "Task list"),
+    };
+    return map[name] ?? name;
+}
+// Argomento mostrato accanto al tool: il path se c'e', il comando per bash,
+// altrimenti gli argomenti compatti.
+function toolArg(call) {
+    const p = call.input["path"];
+    if (call.name === "run_program") {
+        const code = String(call.input["code"] ?? "");
+        return tr("JavaScript · {count} righe · Ctrl+R dettagli", "JavaScript · {count} lines · Ctrl+R details", { count: code.split("\n").length });
+    }
+    if (call.name === "tool_invoke") {
+        const inner = String(call.input["name"] ?? "");
+        const a = call.input["args"] && typeof call.input["args"] === "object" ? compactArgs(call.input["args"]) : "";
+        return truncate(`${inner}${a && a !== "{}" ? ` ${a}` : ""}`, 56);
+    }
+    if (call.name === "tool_search" || call.name === "skill_search")
+        return truncate(String(call.input["query"] ?? ""), 50);
+    if (call.name === "skill_load")
+        return String(call.input["name"] ?? "");
+    if (call.name === "grep" || call.name === "glob")
+        return truncate(String(call.input["pattern"] ?? ""), 50);
+    if (call.name === "wait") {
+        const until = call.input["until"];
+        return typeof until === "string" && until ? `until ${truncate(until, 44)}` : `${call.input["seconds"] ?? 5}s`;
+    }
+    // Tool del metodo Danilov: argomento LEGGIBILE invece del JSON grezzo
+    // (es. Mark(T01 → running) al posto di Mark({"task":"T01","status":"running"})).
+    const danilov = vascendArg(call);
+    if (danilov !== null)
+        return danilov;
+    if (typeof p === "string" && p)
+        return p;
+    if (call.name === "bash")
+        return truncate(oneLine(String(call.input["command"] ?? "")), 60);
+    return compactArgs(call.input);
+}
+// Argomento LEGGIBILE per i tool del metodo Danilov: trasforma l'input grezzo
+// in una sintesi human-friendly. Ritorna null se non e' un tool Danilov noto
+// (cosi' toolArg prosegue con la sua logica standard).
+function vascendArg(call) {
+    const i = call.input;
+    const castle = typeof i["castle"] === "string" && i["castle"] && i["castle"] !== "master" ? ` @${i["castle"]}` : "";
+    switch (call.name) {
+        case "vascend_mark": {
+            const task = String(i["task"] ?? "");
+            const status = String(i["status"] ?? "completed");
+            return truncate(`${task} → ${status}${castle}`, 56);
+        }
+        case "vascend_plan": {
+            const tasks = Array.isArray(i["tasks"]) ? i["tasks"].length : 0;
+            const title = typeof i["title"] === "string" ? i["title"] : "";
+            const n = tr("{count} attività", "{count} tasks", { count: tasks });
+            return truncate(title ? `${title} · ${n}${castle}` : `${n}${castle}`, 60);
+        }
+        case "vascend_addtasks": {
+            const tasks = Array.isArray(i["tasks"]) ? i["tasks"].length : 0;
+            return truncate("+" + tr("{count} attività", "{count} tasks", { count: tasks }) + castle, 56);
+        }
+        case "vascend_note": {
+            const task = typeof i["task"] === "string" && i["task"] ? `${i["task"]}: ` : "";
+            const text = String(i["text"] ?? i["note"] ?? "");
+            return truncate(`${task}${text}`, 56);
+        }
+        case "vascend_skill": {
+            const task = typeof i["task"] === "string" && i["task"] ? `${i["task"]}: ` : "";
+            const skills = Array.isArray(i["skills"]) ? i["skills"].join(", ") : String(i["skills"] ?? i["skill"] ?? "");
+            return truncate(`${task}${skills}`, 56);
+        }
+        default:
+            return null;
+    }
+}
+function compactArgs(input) {
+    const s = JSON.stringify(input);
+    return s.length > 80 ? s.slice(0, 77) + "..." : s;
+}
+function firstLine(s) {
+    const line = s.split("\n")[0] ?? "";
+    return line.length > 100 ? line.slice(0, 97) + "..." : line;
+}
+// Riepilogo sintetico del risultato per i tool di LETTURA: il loro output e' il
+// CONTENUTO grezzo (es. il file letto), la cui prima riga puo' essere vuota o
+// un solo "}", quindi inutile da mostrare sotto il connettore. Per questi tool
+// si mostra invece un conteggio leggibile (N righe, eventuale range). Ritorna
+// null per i tool dove la prima riga e' gia' un buon riassunto (read errori,
+// write/edit, bash, vascend...). `n` plurale italiano semplice.
+function resultSummary(call, output) {
+    if (!call)
+        return null;
+    const out = output ?? "";
+    // Conta le righe NON vuote del corpo, ignorando le note tra parentesi quadre
+    // che i tool aggiungono in coda (es. "[righe 10-40 di 200]", paginazione).
+    const lineWord = (n) => n === 1 ? tr("1 riga", "1 line") : tr("{count} righe", "{count} lines", { count: n });
+    switch (call.name) {
+        case "read_file": {
+            if (out.startsWith("errore"))
+                return null;
+            // Path letto in TESTA (e' l'informazione chiave: "cosa ho letto"); il
+            // conteggio righe segue dopo il separatore.
+            const path = String(call.input["path"] ?? "").trim();
+            const head = path ? `${path} · ` : "";
+            // Range esplicito aggiunto dal tool per le letture parziali.
+            const range = /\[righe (\d+)-(\d+) di (\d+)\]/.exec(out);
+            if (range) {
+                const from = Number(range[1]);
+                const to = Number(range[2]);
+                const tot = Number(range[3]);
+                return `${head}${lineWord(to - from + 1)} ` + tr("(righe {from}-{to} di {total})", "(lines {from}-{to} of {total})", { from, to, total: tot });
+            }
+            // Lettura intera (eventualmente paginata): conta le righe del corpo,
+            // escludendo l'eventuale nota di paginazione finale.
+            const body = out.replace(/\n\[file [^\]]*lungo: [^\]]*\]\s*$/s, "");
+            const trimmed = body.replace(/\s+$/s, "");
+            const lines = trimmed.length === 0 ? 0 : trimmed.split("\n").length;
+            const paged = out !== body ? tr(" (parziale)", " (partial)") : "";
+            if (lines === 0)
+                return head + tr("file vuoto", "empty file") + paged;
+            return `${head}${lineWord(lines)}${paged}`;
+        }
+        case "list_dir": {
+            if (out.startsWith("errore"))
+                return null;
+            if (out === "(vuota)")
+                return tr("cartella vuota", "empty folder");
+            const items = out.split("\n").filter(Boolean);
+            const dirs = items.filter((i) => i.endsWith("/")).length;
+            const files = items.length - dirs;
+            return tr("{count} voci ({dirs} cartelle, {files} file)", "{count} entries ({dirs} folders, {files} files)", { count: items.length, dirs, files });
+        }
+        // glob ("N file:") e grep ("N righe:") hanno gia' una prima riga sintetica:
+        // si lascia firstLine (return null).
+        default:
+            return null;
+    }
+}
+// Registro degli output collassabili per-canale (un canale = un comando come
+// "tree", "sessions", ...). Tiene l'id del fold dell'ultimo output mostrato per
+// quel canale, cosi':
+//  - una nuova invocazione RIMUOVE il vecchio output (niente duplicati in chat);
+//  - "<cmd> close" lo rimuove DAVVERO (cleanup reale, non resta in chat);
+//  - "<cmd> open"/"<cmd> toggle" lo ri-mostrano/espandono.
+// E' deliberatamente semplice: si appoggia a ctl.fold/expandFold/removeFold del
+// modello "fold" gia' presente in master (no API divergenti).
+const collapsibleChannels = new Map();
+// Mostra `body` sotto una riga `summary` e lo collassa in un fold navigabile.
+// Se per quel `channel` c'era gia' un output, lo rimuove prima (no accumulo).
+// Ritorna l'id del fold creato.
+function showCollapsible(ctl, channel, summary, body) {
+    ctl.write(summary + "\n" + body + "\n");
+    return -1;
+}
+// Apre/chiude/rimuove l'output collassabile di un canale. Ritorna true se c'era
+// qualcosa su cui agire.
+function controlCollapsible(ctl, channel, action) {
+    const cur = collapsibleChannels.get(channel);
+    if (!cur)
+        return false;
+    if (action === "close") {
+        // Chiusura = il blocco sparisce dalla chat (cleanup reale).
+        ctl.removeFold(cur.foldId);
+        collapsibleChannels.delete(channel);
+        return true;
+    }
+    // open/toggle: espande il fold (mostra il corpo). toggle ri-collassa se aperto.
+    if (action === "toggle")
+        return ctl.expandFold(cur.foldId) || true;
+    return ctl.expandFold(cur.foldId) || true;
+}
+// Ritorna: "quit" per uscire, input da inviare al modello, o null se il
+// comando e' stato gestito internamente.
+async function handleSlash(line, deps, ctl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, resetSessionUi) {
+    return withCommandFeedback(ctl, commandCtl => handleSlashCommand(line, deps, commandCtl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, resetSessionUi), lines => showReadonlyOverlay({ title: line.split(/\s+/)[0], lines, ctl, theme, terminalColumns }));
+}
+async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, resetSessionUi) {
+    const [cmd, ...rest] = line.slice(1).split(/\s+/);
+    const args = rest.join(" ");
+    const { harness } = deps;
+    switch (cmd) {
+        case "review":
+        case "revisione": {
+            if (ctl.showReview)
+                ctl.showReview(args);
+            else if (ctl.review)
+                ctl.write(reviewText(ctl.review, {
+                    cwd: harness.config.cwd, model: harness.config.model,
+                    permissions: harness.config.permMode, sessionId: harness.session.id,
+                }, theme, terminalColumns(), args));
+            return null;
+        }
+        case "copy": {
+            const text = line.replace(/^\/copy(?:\s+|$)/, "") || lastAssistantText(harness.session.history());
+            if (!text) {
+                ctl.write(theme.dim("\n  Nessuna risposta da copiare. Usa /copy una frase.\n"));
+                return null;
+            }
+            const copied = await copyText(text);
+            ctl.write(copied
+                ? theme.green("\n  Testo copiato negli appunti.\n")
+                : theme.yellow("\n  Appunti non disponibili. Seleziona con Shift+trascina e copia dal terminale (Ctrl+Shift+C o Cmd+C).\n"));
+            return null;
+        }
+        case "rename": {
+            const title = args.trim();
+            if (!title || title.length > 120) {
+                ctl.write(theme.dim("\n  Usa /rename Titolo della chat (da 1 a 120 caratteri).\n"));
+                return null;
+            }
+            harness.session.setName(title);
+            ctl.write(theme.green(`\n  Nome della chat: ${title}\n`));
+            return null;
+        }
+        case "help":
+        case "commands":
+        case "cmd": {
+            // Palette di TUTTI i comandi (builtin + estensioni + template + skill),
+            // NAVIGABILE e raggruppata per CATEGORIA: lista scorrevole con frecce;
+            // Enter su un comando eseguibile lo lancia, Esc chiude. Raggiungibile
+            // come /commands o digitando solo "/". Categoria e sintassi
+            // compaiono soltanto per la voce a fuoco e restano ricercabili.
+            const grouped = commandsByCategory();
+            const builtinItems = grouped.flatMap((g) => g.commands.map((c) => ({
+                key: c.name,
+                label: `/${c.name}`,
+                detail: c.desc,
+                group: g.label,
+                hint: c.hint,
+                value: c.name,
+            })));
+            const extraItems = [
+                ...[...harness.host.commands.values()].map((c) => ({
+                    key: c.name,
+                    label: `/${c.name}`,
+                    detail: c.description,
+                    group: tr("estensione", "extension"),
+                    value: c.name,
+                })),
+                ...templates.map((t) => ({
+                    key: t.name,
+                    label: `/${t.name}`,
+                    detail: t.description,
+                    group: "template",
+                    hint: t.argumentHint,
+                    value: t.name,
+                })),
+                ...harness.skills.map((s) => ({
+                    key: `skill:${s.name}`,
+                    label: `/skill:${s.name}`,
+                    detail: s.description,
+                    group: "skill",
+                    value: `skill:${s.name}`,
+                })),
+            ];
+            const items = [...builtinItems, ...extraItems];
+            // Fallback non interattivo: stampa la lista raggruppata per categoria.
+            if (!stdin.isTTY || !stdout.isTTY) {
+                ctl.write(theme.bold("\n  comandi\n"));
+                for (const g of grouped) {
+                    ctl.write(theme.accent(`\n  ${g.label}\n`));
+                    for (const c of g.commands) {
+                        ctl.write(theme.dim(`    /${c.name}${c.hint ? ` ${c.hint}` : ""}`) + theme.dark(`  ${c.desc}`) + "\n");
+                    }
+                }
+                if (extraItems.length) {
+                    ctl.write(theme.accent("\n  estensioni, template e skill\n"));
+                    for (const it of extraItems)
+                        ctl.write(theme.dim(`    ${it.label}${it.hint ? ` ${it.hint}` : ""}`) + theme.dark(`  ${it.detail}`) + "\n");
+                }
+                ctl.write("\n");
+                return null;
+            }
+            const selected = await selectOption({
+                title: tr("Comandi", "Commands"),
+                options: items,
+                filterable: true,
+                fullHeight: true,
+                wide: true,
+                selectedDetailsOnly: true,
+                mouse: true,
+                ctl,
+                theme,
+                terminalColumns,
+            });
+            if (!selected || ["help", "commands"].includes(selected.value))
+                return null;
+            // Esegue/riapre il comando scelto come se digitato.
+            return handleSlash(`/${selected.value}`, deps, ctl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, resetSessionUi);
+        }
+        case "logout": {
+            // Esce dall'account Vascend: revoca best-effort sul backend, poi rimuove
+            // il token locale. Al prossimo avvio il cancello chiedera' l'accesso.
+            const token = tokenVascend(harness.env);
+            if (!token) {
+                ctl.write(theme.dim("\n  nessun accesso Vascend attivo\n"));
+                return null;
+            }
+            await revocaSessione(harness.env, token);
+            rimuoviTokenVascend(harness.env);
+            // Via anche la prova offline: un logout che la lasciasse in giro
+            // regalerebbe una finestra offline a chi e' appena uscito.
+            rimuoviLicenzaLocale(harness.env);
+            ctl.write(theme.green("\n  uscito dall'account Vascend: al prossimo avvio verra' chiesto l'accesso\n"));
+            return null;
+        }
+        case "quit":
+        case "exit":
+            return "quit";
+        case "cwd":
+        case "cd": {
+            // Un cambio parziale di cwd contaminerebbe trust, system prompt, skill,
+            // estensioni, template, watcher e sessionDir del progetto precedente.
+            // Finche' non esiste un rebootstrap transazionale, il comando mostra il
+            // riavvio sicuro invece di fingere un cambio live incompleto.
+            const showState = async (verb) => {
+                const root = await repoRoot(harness.config.cwd);
+                const branch = await currentBranch(harness.config.cwd);
+                const th = makeTheme(harness.config.ui, themeCtl.spec());
+                ctl.write(th.green(`\n  ${verb}: ${harness.config.cwd}\n`) +
+                    theme.dim(`  repo: ${root ?? "(nessun repo git)"}${branch ? ` · ramo ${branch}` : ""}\n`));
+            };
+            if (!args.trim()) {
+                await showState("progetto seguito");
+                ctl.write(theme.dim("  usa /cwd <path> per seguire un altro progetto\n"));
+                return null;
+            }
+            const target = isAbsolute(args) ? args : resolve(harness.config.cwd, args);
+            if (!existsSync(target)) {
+                ctl.write(theme.yellow(`\n  path non valido: ${target}\n`));
+                return null;
+            }
+            ctl.write(theme.yellow("\n  cambio workspace live non applicato: richiede un rebootstrap sicuro.\n") +
+                theme.dim(`  riapri con: talos -C ${JSON.stringify(resolve(target))} --continue\n`) +
+                theme.dim("  cosi' trust, AGENTS.md, skill, estensioni, sessioni e Context Fabric vengono ricaricati insieme.\n"));
+            return null;
+        }
+        case "model": {
+            if (!args) {
+                await pickModel(harness, ctl, theme, terminalColumns);
+                return null;
+            }
+            await applyModelChoice(args, harness, ctl, theme, terminalColumns);
+            return null;
+        }
+        case "models": {
+            await pickModel(harness, ctl, theme, terminalColumns);
+            return null;
+        }
+        case "theme":
+        case "themes": {
+            if (args) {
+                if (themeCtl.apply(args)) {
+                    ctl.write(makeTheme(deps.harness.config.ui, themeCtl.spec()).green(`\n  tema impostato: ${args}\n`));
+                }
+                else {
+                    ctl.write(theme.yellow(`\n  tema sconosciuto: ${args}`) +
+                        theme.dim(`  disponibili: ${themeCtl.available.map((t) => t.name).join(", ")}\n`));
+                }
+                return null;
+            }
+            const options = themeCtl.available.map((t) => ({
+                key: t.name,
+                label: t.name,
+                detail: t.mode === "light" ? "chiaro" : "scuro",
+                value: t.name,
+            }));
+            const selected = await selectOption({
+                title: "Temi",
+                options,
+                currentKey: themeCtl.activeName(),
+                ctl,
+                theme,
+                terminalColumns,
+            });
+            if (selected && themeCtl.apply(selected.value)) {
+                ctl.write(makeTheme(deps.harness.config.ui, themeCtl.spec()).green(`\n  tema impostato: ${selected.value}\n`));
+            }
+            return null;
+        }
+        case "login": {
+            stats.limits?.clear();
+            await loginMenu(harness, ctl, theme, terminalColumns);
+            return null;
+        }
+        case "usage":
+        case "tokens": {
+            const snapshot = stats.cost.snapshot(harness.config.model);
+            const last = stats.last;
+            const context = (stats.context ?? new ContextMeter()).read(harness);
+            const lines = [theme.bold("\n  Consumi della sessione") + theme.dim(` · ${harness.session.name || harness.session.id}`)];
+            lines.push(theme.dim(`    ${SESSION_USAGE_EXPLANATION}`));
+            if (stats.incomplete)
+                lines.push(theme.yellow("    Storico parziale: le chiamate precedenti alla registrazione non sono ricostruibili."));
+            if (stats.missing)
+                lines.push(theme.yellow(`    ${stats.missing} chiamate senza conteggio token restituito dal provider.`));
+            if (stats.unsaved)
+                lines.push(theme.yellow("    Alcuni consumi non sono stati salvati su disco."));
+            if (snapshot.totalTurns === 0) {
+                lines.push(theme.dim("    Nessun conteggio token ricevuto dal provider per questa sessione."));
+            }
+            else {
+                lines.push(theme.silver(`    chiamate modello: ${formatTokenCount(snapshot.totalTurns)}`));
+                lines.push(theme.silver(`    input totale:    ${formatTokenCount(snapshot.totalPromptTokens)}`));
+                lines.push(theme.dim(`      nuovo:          ${formatTokenCount(snapshot.totalInputTokens)}`));
+                lines.push(theme.dim(`      cache letta:    ${formatTokenCount(snapshot.totalCacheReadTokens)}`));
+                lines.push(theme.dim(`      cache scritta:  ${formatTokenCount(snapshot.totalCacheWriteTokens)}`));
+                lines.push(theme.silver(`    output:          ${formatTokenCount(snapshot.totalOutputTokens)}`));
+                lines.push(theme.silver(`    totale provider: ${formatTokenCount(snapshot.totalProviderTokens)}`));
+            }
+            if (last) {
+                lines.push(theme.bold("\n  ultima chiamata"));
+                lines.push(theme.dim(`    input ${formatTokenCount(promptTokens(last))} = nuovo ${formatTokenCount(last.inputTokens)} + cache letta ${formatTokenCount(last.cacheReadTokens ?? 0)} + cache scritta ${formatTokenCount(last.cacheWriteTokens ?? 0)}`));
+                lines.push(theme.dim(`    output ${formatTokenCount(last.outputTokens)}`));
+            }
+            if (snapshot.perModel.length) {
+                lines.push(theme.bold("\n  Per modello (collaboratori inclusi quando collegati alla chat)"));
+                for (const row of snapshot.perModel)
+                    lines.push(theme.dim(`    ${row.modelId}: ${formatTokenCount(promptTokens(row) + row.outputTokens)} token · ${row.turns} chiamate`));
+            }
+            const providerId = harness.providers.resolve(harness.config.model)?.provider.id ?? "";
+            lines.push(...subscriptionDetails(providerId, stats.limits?.get(providerId), theme));
+            lines.push(theme.bold("\n  contesto vivo stimato") + theme.dim(" · non e' consumo API"));
+            lines.push(...contextDetails(context).map(line => theme.dim(`    ${line}`)));
+            ctl.write(lines.join("\n") + "\n");
+            return null;
+        }
+        case "provider":
+        case "providers": {
+            await providerMenu(harness, ctl, theme, terminalColumns);
+            return null;
+        }
+        case "arch":
+        case "architettura": {
+            // Mappa architetturale del progetto seguito: stesso motore del tool
+            // architecture_map (moduli, dipendenze interne, cicli, entry point,
+            // hotspot). Output collassabile come /config.
+            const sub = args.trim();
+            if (sub === "close" || sub === "open" || sub === "toggle") {
+                if (!controlCollapsible(ctl, "arch", sub) && sub === "close") {
+                    ctl.write(theme.dim("\n  nessuna mappa da chiudere: usa /arch\n\n"));
+                }
+                else if (sub === "close") {
+                    ctl.write(theme.dim("\n  mappa chiusa (output rimosso dalla chat)\n\n"));
+                }
+                return null;
+            }
+            const depthArg = Number(sub);
+            const depth = Number.isFinite(depthArg) && depthArg >= 1 ? Math.floor(depthArg) : undefined;
+            try {
+                const map = scanArchitectureMap(harness.config.cwd, depth !== undefined ? { moduleDepth: depth } : {});
+                if (!map.files) {
+                    ctl.write(theme.yellow("\n  nessun file sorgente riconosciuto nel progetto seguito\n"));
+                    return null;
+                }
+                const body = renderArchitectureMap(map)
+                    .split("\n")
+                    .map((row) => (row.startsWith("#") ? theme.bold(`  ${row.replace(/^#+\s*/, "")}`) : theme.dim(`    ${row}`)))
+                    .join("\n");
+                showCollapsible(ctl, "arch", theme.bold("\n  architettura") + theme.dim(` · ${map.files} file, ${map.modules.length} moduli, ${map.cycles.length} cicli · /arch close per nascondere`), body);
+            }
+            catch (err) {
+                ctl.write(theme.yellow(`\n  errore analisi architettura: ${err.message}\n`));
+            }
+            return null;
+        }
+        case "config": {
+            // In TTY /config e' un centro impostazioni a tutta altezza. La vista
+            // diagnostica testuale resta disponibile con /config details.
+            const csub = args.trim();
+            if (csub === "close" || csub === "open" || csub === "toggle") {
+                if (!controlCollapsible(ctl, "config", csub) && csub === "close") {
+                    ctl.write(theme.dim("\n  nessuna config da chiudere: usa /config\n\n"));
+                }
+                else if (csub === "close") {
+                    ctl.write(theme.dim("\n  config chiusa (output rimosso dalla chat)\n\n"));
+                }
+                return null;
+            }
+            if (!csub && stdin.isTTY && stdout.isTTY) {
+                const cfg = harness.config;
+                const resolved = harness.providers.resolve(cfg.model);
+                const provider = resolved
+                    ? (resolved.provider.label ?? resolved.provider.id)
+                    : "non configurato";
+                const settings = [
+                    { key: "model", label: "Modello", detail: cfg.model, value: "model" },
+                    { key: "provider", label: "Provider e accessi", detail: provider, value: "provider" },
+                    { key: "vibe", label: "Profilo operativo", detail: cfg.vibeMode, value: "vibe" },
+                    { key: "theme", label: "Tema", detail: themeCtl.activeName(), value: "theme" },
+                    { key: "cwd", label: "Workspace", detail: cfg.cwd, value: "cwd" },
+                    { key: "sessions", label: "Sessioni", detail: harness.session.id, value: "sessions" },
+                    { key: "extensions", label: "Estensioni", detail: `${harness.host.inventory().filter((item) => item.loaded).length} caricate`, value: "extensions" },
+                    { key: "usage", label: "Utilizzo e contesto", detail: "token provider, cache e finestra viva", value: "usage" },
+                ];
+                const selected = await selectOption({
+                    title: "Impostazioni",
+                    hint: "/config details mostra i file di configurazione",
+                    options: settings,
+                    fullHeight: true,
+                    wide: true,
+                    ctl,
+                    theme,
+                    terminalColumns,
+                });
+                if (!selected)
+                    return null;
+                return handleSlash(`/${selected.value}`, deps, ctl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, resetSessionUi);
+            }
+            const cfg = harness.config;
+            const files = cfg.loadedConfigFiles.length
+                ? cfg.loadedConfigFiles.map((file) => `    ${file}`).join("\n")
+                : "    nessun file caricato";
+            const body = theme.dim(`    modello: ${cfg.model}\n`) +
+                theme.dim(`    maxTokens: ${cfg.maxTokens > 0 ? cfg.maxTokens : "auto (max del modello)"}\n`) +
+                theme.dim(`    vibeMode: ${cfg.vibeMode}\n`) +
+                theme.dim(`    sessionDir: ${cfg.sessionDir}\n`) +
+                theme.dim(`    contextFiles: ${cfg.contextFiles.join(", ")}\n`) +
+                theme.dim(`    skill: ${harness.skills.length}${harness.skillCommandsEnabled ? "" : " (comandi off)"}${harness.skills.length ? ` (${harness.skills.map((s) => s.name).join(", ")})` : ""}\n`) +
+                theme.dim(`    progetto fidato: ${harness.projectTrusted ? "si" : "no (risorse locali non caricate)"}\n`) +
+                theme.bold("\n  tema\n") +
+                theme.dim(`    attivo: ${themeCtl.activeName()}${themeCtl.spec() ? ` (${themeCtl.spec()?.mode === "light" ? "chiaro" : "scuro"})` : ""}\n`) +
+                theme.dim(`    disponibili: ${themeCtl.available.map((t) => t.name).join(", ")}\n`) +
+                theme.dim(`    banner: ${cfg.ui.banner}\n`) +
+                theme.dim(`    prompt: ${JSON.stringify(cfg.ui.prompt)}\n`) +
+                theme.bold("\n  file\n") +
+                theme.dim(`${files}`);
+            showCollapsible(ctl, "config", theme.bold("\n  configurazione") + theme.dim(" · /config close per nascondere"), body);
+            return null;
+        }
+        case "vibe":
+        case "profile": {
+            const setMode = (value) => {
+                const parsed = parseVibeMode(value);
+                if (!parsed)
+                    return false;
+                harness.config = { ...harness.config, vibeMode: parsed };
+                saveGlobalSettings(harness.env, { vibeMode: parsed });
+                return true;
+            };
+            const requested = args.trim().toLowerCase();
+            if (requested) {
+                if (!setMode(requested)) {
+                    ctl.write(theme.yellow(`\n  modalita' sconosciuta: ${requested}\n`) +
+                        theme.dim(`  disponibili: auto, ${listVibeModes().map((mode) => mode.id).join(", ")}\n`));
+                    return null;
+                }
+                const spec = requested === "auto" ? null : listVibeModes().find((mode) => mode.id === requested);
+                ctl.write(theme.green(`\n  vibe mode: ${requested}\n`) +
+                    theme.dim(`  ${spec?.summary ?? "router automatico per ogni mission epoch"}\n`));
+                ctl.refresh?.();
+                return null;
+            }
+            const modes = listVibeModes();
+            if (!stdin.isTTY || !stdout.isTTY) {
+                ctl.write(theme.bold(`\n  vibe mode: ${harness.config.vibeMode}\n`));
+                for (const mode of modes)
+                    ctl.write(theme.dim(`    ${mode.id.padEnd(12)} ${mode.summary}\n`));
+                return null;
+            }
+            const selected = await selectOption({
+                title: `vibecoding mode · attuale ${harness.config.vibeMode}`,
+                hint: "La modalità cambia il modo di lavorare, i permessi richiesti e il contesto.",
+                options: [
+                    { key: "auto", label: "auto", detail: "router deterministico per missione/follow-up", value: "auto" },
+                    ...modes.map((mode) => ({ key: mode.id, label: mode.label, detail: `${mode.id} · ${mode.summary}`, value: mode.id })),
+                ],
+                currentKey: harness.config.vibeMode,
+                ctl,
+                theme,
+                terminalColumns,
+                filterable: true,
+            });
+            if (selected && setMode(selected.value)) {
+                ctl.write(theme.green(`\n  vibe mode: ${selected.value}\n`));
+                ctl.refresh?.();
+            }
+            return null;
+        }
+        case "context":
+        case "ctx": {
+            const parts = args.trim().split(/\s+/).filter(Boolean);
+            const sub = (parts[0] ?? "").toLowerCase();
+            if (sub === "close" || sub === "open" || sub === "toggle") {
+                if (!controlCollapsible(ctl, "context", sub) && sub === "close") {
+                    ctl.write(theme.dim("\n  nessuna ricevuta context da chiudere: usa /context\n"));
+                }
+                return null;
+            }
+            if (sub === "reset") {
+                resetContextFrame({
+                    sessionDir: harness.config.sessionDir,
+                    frameId: harness.session.id,
+                    cwd: harness.config.cwd,
+                    selection: harness.config.vibeMode,
+                });
+                ctl.write(theme.green("\n  Context Fabric resettato: il prossimo turno apre un nuovo epoch.\n"));
+                return null;
+            }
+            if (sub === "pin" || sub === "unpin") {
+                const value = parts.slice(1).join(" ");
+                if (!value) {
+                    ctl.write(theme.yellow(`\n  uso: /context ${sub} <termine o path>\n`));
+                    return null;
+                }
+                const updated = updateContextPins({
+                    sessionDir: harness.config.sessionDir,
+                    frameId: harness.session.id,
+                    cwd: harness.config.cwd,
+                    ...(sub === "pin" ? { add: [value] } : { remove: [value] }),
+                });
+                ctl.write(updated
+                    ? theme.green(`\n  context ${sub === "pin" ? "pin" : "unpin"}: ${value}\n`)
+                    : theme.yellow("\n  nessun epoch attivo: invia prima una richiesta.\n"));
+                return null;
+            }
+            if (sub && sub !== "explain" && sub !== "status") {
+                ctl.write(theme.yellow("\n  uso: /context [status|explain|pin <x>|unpin <x>|reset|close]\n"));
+                return null;
+            }
+            const frame = loadContextFrame(harness.config.sessionDir, harness.session.id, contextProjectKey(harness.config.cwd), true);
+            const body = [...contextDetails((stats.context ?? new ContextMeter()).read(harness)), "", ...renderContextFrame(frame).split("\n")]
+                .map((line) => theme.dim(`    ${line}`)).join("\n");
+            showCollapsible(ctl, "context", theme.bold("\n  Context Fabric") + theme.dim(" · /context close per nascondere"), body);
+            return null;
+        }
+        case "vascend": {
+            if (args.trim() === "off")
+                vascend.resetPlan(harness.config.sessionDir, harness.session.id);
+            const result = vascend.handleCommand(args);
+            ctl.write(theme.green(`\n  ${result.message}\n`));
+            ctl.write(renderVascendStatus(vascend.state(), theme, terminalColumns()));
+            return result.kind === "input" ? { input: result.input, vascend: true } : null;
+        }
+        case "queue":
+        case "coda":
+            if (ctl.showQueue)
+                ctl.showQueue();
+            else
+                ctl.write(theme.dim("\n  La gestione della coda richiede la TUI interattiva.\n"));
+            return null;
+        case "regno":
+        case "castello":
+        case "castelli":
+        case "todo":
+        case "tasks":
+        case "attivita":
+        case "piano": {
+            // Rinfresca dal disco (l'agente potrebbe aver pianificato) e mostra il
+            // lista: gruppi e attività navigabili. Gestione: svuota la lista.
+            vascend.loadPlan(harness.config.sessionDir, harness.session.id);
+            const castles = vascend.state().kingdom.castles;
+            if (!castles.length) {
+                ctl.write(theme.dim("\n  La lista delle attività è vuota.\n") +
+                    theme.dim("  Talos creerà automaticamente le attività quando il compito lo richiede.\n\n"));
+                return null;
+            }
+            const total = castles.flatMap((c) => c.tasks).length;
+            const done = castles.flatMap((c) => c.tasks).filter((t) => t.status === "completed").length;
+            if (!stdin.isTTY || !stdout.isTTY) {
+                ctl.write(theme.bold(`\n  Lista delle attività · ${castles.length} grupp${castles.length === 1 ? "o" : "i"} · ${done}/${total} completate\n`));
+                for (const c of castles) {
+                    ctl.write(theme.silver(`    ◆ ${c.title || c.slug} [${c.slug}]\n`));
+                    for (const t of c.tasks)
+                        ctl.write(theme.dim(`      ${vascendRoomGlyph(t.status)} ${t.title} · ${TASK_STATUS_LABELS[t.status]}\n`));
+                }
+                ctl.write("\n");
+                return null;
+            }
+            // Selettore a DUE livelli: scegli un gruppo, poi entri nelle sue attività.
+            for (;;) {
+                const fresh = vascend.state().kingdom.castles;
+                if (!fresh.length)
+                    break;
+                const tot = fresh.flatMap((c) => c.tasks).length;
+                const dn = fresh.flatMap((c) => c.tasks).filter((t) => t.status === "completed").length;
+                const castleOpts = fresh.map((c) => {
+                    const cd = c.tasks.filter((t) => t.status === "completed").length;
+                    const cf = c.tasks.filter((t) => t.status === "failed").length;
+                    return {
+                        key: `c:${c.slug}`,
+                        label: `◆ ${c.title || c.slug}`,
+                        detail: `${cd}/${c.tasks.length} completate${cf ? ` · ${cf} fallit${cf === 1 ? "a" : "e"}` : ""}`,
+                        value: `c:${c.slug}`,
+                    };
+                });
+                castleOpts.push({ key: "__clear__", label: "Svuota la lista", detail: "Rimuove tutti i gruppi e le attività", value: "__clear__" });
+                const pick = await selectOption({
+                    title: `Lista delle attività — ${fresh.length} grupp${fresh.length === 1 ? "o" : "i"} · ${dn}/${tot} completate`,
+                    hint: "↑/↓ · Invio apre il gruppo · Esc chiudi",
+                    options: castleOpts,
+                    ctl, theme, terminalColumns,
+                });
+                if (!pick)
+                    break;
+                if (pick.value === "__clear__") {
+                    vascend.resetPlan(harness.config.sessionDir, harness.session.id);
+                    ctl.write(theme.green("\n  Lista delle attività svuotata.\n"));
+                    break;
+                }
+                const slug = pick.value.slice(2);
+                const castle = fresh.find((c) => c.slug === slug);
+                if (!castle)
+                    break;
+                // Livello 2: attività del gruppo (sola lettura) + indietro.
+                const roomOpts = castle.tasks.map((t) => {
+                    const extra = [
+                        t.tokens !== undefined ? `↓ ${fmtTok(t.tokens)}` : "",
+                        t.skills?.length ? `@skill:${t.skills.join(",")}` : "",
+                        t.notes?.length ? `${t.notes.length} note` : "",
+                    ].filter(Boolean).join(" · ");
+                    return {
+                        key: t.id,
+                        label: `${vascendRoomGlyph(t.status)} ${t.title}`,
+                        detail: `${TASK_STATUS_LABELS[t.status]}${extra ? ` · ${extra}` : ""}`,
+                        value: t.id,
+                    };
+                });
+                roomOpts.push({ key: "__back__", label: "← indietro", detail: "Torna alla lista", value: "__back__" });
+                await selectOption({
+                    title: `${castle.title || castle.slug} — ${castle.tasks.filter((t) => t.status === "completed").length}/${castle.tasks.length}`,
+                    hint: "↑/↓ attività · Esc/indietro torna alla lista",
+                    options: roomOpts,
+                    ctl, theme, terminalColumns,
+                });
+                // qualunque cosa scelga, si torna al livello gruppi (loop).
+            }
+            return null;
+        }
+        case "bg": {
+            // /bg            -> lista; /bg <id> -> output; /bg kill <id> -> termina.
+            const parts = args.trim().split(/\s+/).filter(Boolean);
+            if (!parts.length) {
+                await showBackgroundPanel(ctl, theme, terminalColumns);
+                return null;
+            }
+            if (parts[0] === "kill") {
+                const id = parts[1] ?? "";
+                ctl.write(backgroundManager.kill(id) ? theme.green(`\n  terminato ${id}\n`) : theme.yellow(`\n  ${id || "(id mancante)"} non in esecuzione\n`));
+                return null;
+            }
+            const t = backgroundManager.get(parts[0] ?? "");
+            if (!t) {
+                ctl.write(theme.yellow(`\n  task non trovato: ${parts[0]}\n`));
+                return null;
+            }
+            const dur = t.endedAt ? `${Math.round((t.endedAt - t.startedAt) / 1000)}s` : `${Math.round((Date.now() - t.startedAt) / 1000)}s`;
+            await showReadonlyOverlay({
+                title: `${t.id} · ${t.status}${t.exitCode != null ? ` · uscita ${t.exitCode}` : ""} · ${dur}`,
+                lines: [t.command, "", ...(t.output || "(nessun output)").replace(/\n+$/, "").split("\n")],
+                ctl,
+                theme,
+                terminalColumns,
+            });
+            return null;
+        }
+        case "reload":
+        case "reload-ext": {
+            // Hot reload delle estensioni da .talos/extensions (parita' pi.dev):
+            // scarica cio' che le estensioni avevano registrato e ricarica i file da
+            // disco con cache-bust. Richiede project trust (come il caricamento iniziale).
+            if (!harness.projectTrusted) {
+                ctl.write(theme.yellow("\n  reload estensioni: progetto non fidato (estensioni disabilitate)\n"));
+                return null;
+            }
+            ctl.setStatus("ricarico estensioni...");
+            try {
+                const diff = await harness.host.reload();
+                ctl.setStatus(null);
+                const parts = [theme.green(`\n  estensioni ricaricate · ${diff.after.length} tool`)];
+                if (diff.added.length)
+                    parts.push(theme.dim(`  +${diff.added.join(", ")}`));
+                if (diff.removed.length)
+                    parts.push(theme.dim(`  -${diff.removed.join(", ")}`));
+                if (!diff.added.length && !diff.removed.length)
+                    parts.push(theme.dim("  (nessuna variazione di tool)"));
+                ctl.write(parts.join("") + "\n");
+            }
+            catch (err) {
+                ctl.setStatus(null);
+                ctl.write(theme.red(`\n  reload fallito: ${err.message}\n`));
+            }
+            return null;
+        }
+        case "extensions":
+        case "ext": {
+            // Lista e gestione estensioni: senza argomenti elenca; con "on/off <id>"
+            // abilita/disabilita; con "set <id> <chiave> <valore>" imposta un'opzione.
+            const parts = args.trim().split(/\s+/).filter(Boolean);
+            const sub = (parts[0] ?? "").toLowerCase();
+            if (sub === "on" || sub === "off" || sub === "enable" || sub === "disable") {
+                const idArg = parts[1];
+                if (!idArg) {
+                    ctl.write(theme.yellow("\n  uso: /extensions on|off <id>\n"));
+                    return null;
+                }
+                const id = harness.host.resolveId(idArg);
+                if (!id) {
+                    ctl.write(theme.red(`\n  estensione '${idArg}' non trovata\n`));
+                    return null;
+                }
+                const enable = sub === "on" || sub === "enable";
+                ctl.setStatus("aggiorno estensioni...");
+                const r = await harness.host.setEnabled(id, enable);
+                ctl.setStatus(null);
+                ctl.write(r.ok
+                    ? theme.green(`\n  ${id} ${enable ? "abilitata" : "disabilitata"}\n`)
+                    : theme.red(`\n  ${r.reason ?? "operazione fallita"}\n`));
+                return null;
+            }
+            if (sub === "set") {
+                const [, idArg, key, ...rest] = parts;
+                if (!idArg || !key || !rest.length) {
+                    ctl.write(theme.yellow("\n  uso: /extensions set <id> <chiave> <valore>\n"));
+                    return null;
+                }
+                const id = harness.host.resolveId(idArg);
+                if (!id) {
+                    ctl.write(theme.red(`\n  estensione '${idArg}' non trovata\n`));
+                    return null;
+                }
+                const rawVal = rest.join(" ");
+                let value = rawVal;
+                try {
+                    value = JSON.parse(rawVal);
+                }
+                catch {
+                    // non-JSON: tieni la stringa cosi' com'e'.
+                }
+                ctl.setStatus("aggiorno estensioni...");
+                const r = await harness.host.setOption(id, key, value);
+                ctl.setStatus(null);
+                ctl.write(r.ok
+                    ? theme.green(`\n  ${id}: ${key} = ${JSON.stringify(value)}\n`)
+                    : theme.red(`\n  ${r.reason ?? "operazione fallita"}\n`));
+                return null;
+            }
+            // Default: elenca le estensioni.
+            const inv = harness.host.inventory();
+            if (!inv.length) {
+                ctl.write(theme.dim("\n  nessuna estensione in .talos/extensions\n"));
+                return null;
+            }
+            const out = [theme.bold("\n  Estensioni (.talos/extensions)")];
+            for (const e of inv) {
+                const badge = e.enabled
+                    ? e.loaded
+                        ? theme.green("on")
+                        : theme.yellow("on*")
+                    : theme.red("off");
+                out.push(`\n  ${badge} ${theme.bold(e.id)}`);
+                const reg = [];
+                if (e.tools.length)
+                    reg.push(`tool ${e.tools.join(",")}`);
+                if (e.commands.length)
+                    reg.push(`cmd /${e.commands.join(" /")}`);
+                if (e.shortcuts.length)
+                    reg.push(`key ${e.shortcuts.join(",")}`);
+                if (e.events.length)
+                    reg.push(`ev ${e.events.join(",")}`);
+                if (e.systemHooks)
+                    reg.push(`hook ${e.systemHooks}`);
+                if (reg.length)
+                    out.push(theme.dim(`     ${reg.join(" · ")}`));
+                if (Object.keys(e.options).length)
+                    out.push(theme.dim(`     set ${JSON.stringify(e.options)}`));
+            }
+            out.push(theme.dim("\n  gestisci: /extensions on|off <id> · /extensions set <id> <chiave> <valore>\n"));
+            ctl.write(out.join("\n") + "\n");
+            return null;
+        }
+        case "expand": {
+            if (args.trim().toLowerCase() === "all") {
+                const n = ctl.expandAllFolds();
+                ctl.write(n ? theme.dim(`\n  espanse ${n} ondate di tool\n`) : theme.dim("\n  niente da espandere\n"));
+            }
+            else {
+                const ok = ctl.expandFold();
+                ctl.write(ok ? theme.dim("\n  ondata espansa\n") : theme.dim("\n  niente da espandere\n"));
+            }
+            return null;
+        }
+        case "vascend-clear": {
+            vascend.resetPlan(harness.config.sessionDir, harness.session.id);
+            const result = vascend.handleCommand("clear");
+            ctl.write(theme.green(`\n  ${result.message}\n`));
+            return null;
+        }
+        // Compact UNIFICATO: una sola operazione che (1) compatta il contesto vivo
+        // con riassunto LLM (stile Pi) e (2) salva il checkpoint Vascend/Danilov in
+        // .vascend-compact.md per la ripresa a freddo. /vascend-compact e' un alias.
+        case "vascend-compact":
+        case "compact": {
+            const hasModel = Boolean(harness.providers.resolve(harness.config.model));
+            // 1) Compattazione LLM del contesto della sessione.
+            if (hasModel) {
+                const meter = stats.context ?? new ContextMeter();
+                const before = meter.read(harness).tokens;
+                ctl.write(theme.dim(`\n  compatto ~${formatTokenCount(before)} token attivi; preservo richiesta, attivita aperte e lavoro recente...\n`));
+                const controller = new AbortController();
+                const onSigint = () => controller.abort();
+                process.once("SIGINT", onSigint);
+                try {
+                    const done = await compactNow(harness.deps(async () => false), controller.signal, (e) => {
+                        if (e.type === "usage")
+                            stats.observe?.(e);
+                    }, args || undefined);
+                    if (done) {
+                        const after = meter.read(harness);
+                        const archived = after.archived.reduce((sum, block) => sum + block.tokens, 0);
+                        ctl.write(theme.green(`  attivo ~${formatTokenCount(before)} → ~${formatTokenCount(after.tokens)} token · archivio originale ~${formatTokenCount(archived)}\n`));
+                    }
+                    if (!done)
+                        ctl.write(theme.dim(controller.signal.aborted
+                            ? "  compattazione interrotta; contesto conservato.\n"
+                            : "  nessuna compattazione applicata; contesto conservato.\n"));
+                }
+                catch (err) {
+                    ctl.write(theme.red(`  errore compattazione: ${err.message}\n`));
+                }
+                finally {
+                    process.removeListener("SIGINT", onSigint);
+                }
+            }
+            else {
+                ctl.write(theme.dim("\n  nessun modello configurato: salvo solo il checkpoint Vascend.\n"));
+            }
+            // 2) Checkpoint Vascend/Danilov sullo stato (gia' compattato) della sessione.
+            vascend.loadPlan(harness.config.sessionDir, harness.config.planStoreId ?? harness.config.roomStoreId ?? harness.session.id);
+            const checkpoint = vascend.compact(harness.session.history());
+            ctl.write(theme.green("  ✓ checkpoint Vascend salvato in .vascend-compact.md\n"));
+            ctl.write(theme.dim(`    piano e contesto pronti per la ripresa (${checkpoint.text.split("\n").length} righe)\n`));
+            return null;
+        }
+        case "tree": {
+            const sub = args.trim();
+            // /tree close|open|toggle: controlla l'output collassabile dell'albero.
+            // Alla chiusura il blocco SPARISCE dalla chat (cleanup reale), non resta
+            // un segnaposto: e' cio' che l'utente si aspetta quando lo richiude.
+            if (sub === "close" || sub === "open" || sub === "toggle") {
+                if (!controlCollapsible(ctl, "tree", sub)) {
+                    ctl.write(theme.dim("\n  nessun albero da " + (sub === "close" ? "chiudere" : "aprire") + ": usa /tree\n\n"));
+                }
+                else if (sub === "close") {
+                    ctl.write(theme.dim("\n  albero chiuso (output rimosso dalla chat)\n\n"));
+                }
+                return null;
+            }
+            // /tree <id>: naviga al nodo, riassumendo il ramo abbandonato (branch
+            // summarization, parita' Pi).
+            if (sub) {
+                const targetId = sub;
+                const previousHead = harness.session.head;
+                if (!harness.session.checkout(targetId)) {
+                    ctl.write(theme.yellow(`\n  nodo non trovato: ${targetId}\n`));
+                    return null;
+                }
+                if (previousHead && previousHead !== targetId && harness.providers.resolve(harness.config.model)) {
+                    const ancestor = harness.session.commonAncestor(previousHead, targetId);
+                    const abandoned = harness.session.branchMessages(previousHead, ancestor);
+                    if (abandoned.length) {
+                        ctl.write(theme.dim(`  navigato a ${targetId}; il ramo precedente resta nell'albero.\n`));
+                    }
+                }
+                ctl.write(theme.green(`\n  testa spostata su ${targetId}\n`));
+                resetSessionUi();
+                replaySession(harness.session, ctl, theme, terminalColumns());
+                return null;
+            }
+            // /tree senza argomenti: mostra l'albero come OUTPUT COLLASSABILE e
+            // navigabile. Se ce n'era gia' uno, viene rimosso e ricreato aggiornato
+            // (la chat non accumula duplicati dell'albero).
+            const nodes = harness.session.tree();
+            const lines = [];
+            for (const n of nodes) {
+                const head = n.id === harness.session.head ? theme.green(" ←") : "";
+                const preview = n.message.content
+                    .map((p) => (p.type === "text" ? p.text : `[${p.type}]`))
+                    .join(" ")
+                    .slice(0, 50);
+                lines.push(theme.dim(`    ${n.id} ${n.message.role}: `) + preview + head);
+            }
+            lines.push(theme.dim("    /tree <id> sposta la testa · /tree close nasconde questo output"));
+            showCollapsible(ctl, "tree", theme.bold(`\n  sessione (${nodes.length} nodi)`) + theme.dim(" · /tree close per nascondere"), lines.join("\n"));
+            return null;
+        }
+        case "sessions": {
+            const ssub = args.trim();
+            if (ssub === "close" || ssub === "open" || ssub === "toggle") {
+                if (!controlCollapsible(ctl, "sessions", ssub) && ssub === "close") {
+                    ctl.write(theme.dim("\n  nessun elenco da chiudere: usa /sessions\n\n"));
+                }
+                else if (ssub === "close") {
+                    ctl.write(theme.dim("\n  elenco chiuso (output rimosso dalla chat)\n\n"));
+                }
+                return null;
+            }
+            const list = listSessions(harness.config.sessionDir);
+            if (!list.length) {
+                ctl.write(theme.dim("\n  nessuna sessione salvata\n\n"));
+                return null;
+            }
+            const lines = [];
+            for (const s of list) {
+                const cur = s.id === harness.session.id ? theme.green(" ← corrente") : "";
+                lines.push(theme.dim(`    ${s.id}  `) + (s.name ? theme.silver(`${s.name} `) : "") + theme.dark(`${fmtAge(s.updatedAt)} · ${s.messages} msg`) + cur);
+                if (s.preview)
+                    lines.push(theme.dark(`      ${truncate(s.preview, terminalColumns() - 8)}`));
+            }
+            lines.push(theme.dim("    /resume <id> per riprenderne una · /sessions close per nascondere"));
+            showCollapsible(ctl, "sessions", theme.bold(`\n  sessioni (${list.length})`) + theme.dim(" · /sessions close per nascondere"), lines.join("\n"));
+            return null;
+        }
+        case "language":
+        case "lang":
+        case "lingua":
+        case "idioma":
+        case "sprache": {
+            const choices = [
+                { key: "system", label: tr("Automatico (sistema)", "Automatic (system)"), detail: "", value: "system" },
+                ...LANGUAGES.map(language => ({ key: language.id, label: language.nome, detail: "", value: language.id })),
+            ];
+            let preference = normalizePreference(args.trim().toLowerCase());
+            if (!args.trim()) {
+                if (!stdin.isTTY || !stdout.isTTY) {
+                    ctl.write(tr("Uso: /language system|it|en|es|de", "Usage: /language system|it|en|es|de") + "\n");
+                    return null;
+                }
+                const selected = await selectOption({ title: tr("Lingua", "Language"), options: choices,
+                    currentKey: languagePreference(leggiOnboarding(harness.env), harness.env), ctl, theme, terminalColumns });
+                if (!selected)
+                    return null;
+                preference = selected.value;
+            }
+            if (!preference) {
+                notifyStatus(ctl, tr("Uso: /language system|it|en|es|de", "Usage: /language system|it|en|es|de"), true);
+            }
+            else if (!saveLanguagePreference(harness.env, preference)) {
+                notifyStatus(ctl, tr("Impossibile salvare la preferenza della lingua", "Unable to save the language preference"), true);
+            }
+            else {
+                notifyStatus(ctl, tr("Lingua salvata", "Language saved"));
+                ctl.refresh?.();
+            }
+            return null;
+        }
+        case "new":
+        case "clear": {
+            // Sessione NUOVA e vuota, come /clear di Claude Code: azzera cronologia e
+            // contesto vivo senza riavviare il processo. Il piano del regno riparte
+            // pulito (resetPlan + svuotamento stato Vascend) e si riaggancia alla
+            // nuova sessione (loadPlan, che non trova nulla -> nessun custom plan).
+            const previousId = harness.session.id;
+            const fresh = harness.newSession();
+            resetContextFrame({
+                sessionDir: harness.config.sessionDir,
+                frameId: fresh.id,
+                cwd: harness.config.cwd,
+                selection: harness.config.vibeMode,
+                preservePins: false,
+            });
+            vascend.resetPlan(harness.config.sessionDir, fresh.id);
+            vascend.handleCommand("clear");
+            vascend.loadPlan(harness.config.sessionDir, fresh.id);
+            resetSessionUi();
+            await harness.host.emit("session_start", { reason: "new" });
+            ctl.write(tr("nuova sessione {id} · chat precedente salvata: /resume {previous}", "New session {id} · previous chat saved: /resume {previous}", { id: fresh.id, previous: previousId }) + "\n");
+            return null;
+        }
+        case "chats":
+        case "resume": {
+            const list = listSessions(harness.config.sessionDir);
+            if (!list.length) {
+                ctl.write(theme.dim("\n  " + tr("nessuna sessione da riprendere", "No saved sessions") + "\n\n"));
+                return null;
+            }
+            if (args.trim()) {
+                if (resumeInto(harness, vascend, args.trim(), ctl, theme, terminalColumns, resetSessionUi)) {
+                    await harness.host.emit("session_start", { reason: "resume" });
+                }
+                return null;
+            }
+            if (!stdin.isTTY || !stdout.isTTY) {
+                ctl.write(theme.dim("\n  indica l'id: /resume <id> (/sessions per la lista)\n\n"));
+                return null;
+            }
+            const selected = await selectOption({
+                title: tr("Chat salvate", "Saved chats"),
+                hint: tr("Scrivi per cercare · Invio apre · Esc torna alla chat corrente", "Type to search · Enter open · Esc return to the current chat"),
+                filterable: true,
+                options: sessionOptions(list).map((option) => ({ ...option,
+                    detail: option.detail + (option.value === harness.session.id ? " · " + tr("corrente", "current") : ""),
+                })),
+                ctl,
+                theme,
+                terminalColumns,
+            });
+            if (!selected)
+                return null;
+            if (resumeInto(harness, vascend, selected.value, ctl, theme, terminalColumns, resetSessionUi)) {
+                await harness.host.emit("session_start", { reason: "resume" });
+            }
+            return null;
+        }
+        case "fast": {
+            const arg = args.trim().toLowerCase();
+            const supported = harness.providers.resolve(harness.config.model)?.provider.supportsFastMode === true;
+            if (!["", "status", "on", "off"].includes(arg)) {
+                ctl.write(theme.dim("\n  Uso: /fast on, /fast off oppure /fast status.\n"));
+                return null;
+            }
+            if (arg === "on" && !supported) {
+                ctl.write(theme.yellow("\n  Fast non è disponibile con il provider selezionato.\n"));
+                return null;
+            }
+            if (arg === "on" || arg === "off") {
+                const fast = arg === "on";
+                harness.config = { ...harness.config, fast };
+                saveGlobalSettings(harness.env, { fast });
+            }
+            if (!arg || arg === "status")
+                notifyStatus(ctl, `Fast ${harness.config.fast && supported ? "attivo" : "disattivato"}`);
+            ctl.refresh?.();
+            return null;
+        }
+        case "effort": {
+            const resolved = harness.providers.resolve(harness.config.model);
+            const fullModel = resolved ? `${resolved.provider.id}/${resolved.modelId}` : harness.config.model;
+            await loadModelsDev(harness.env);
+            const levels = modelEfforts(fullModel, cachedModelCatalog(harness.env).get(fullModel));
+            const arg = args.trim().toLowerCase();
+            const effort = arg ? (["default", "auto"].includes(arg) ? "" : arg) : await pickEffort(fullModel, harness, ctl, theme, terminalColumns);
+            if (effort === null)
+                return null;
+            if (!levels.includes(effort)) {
+                notifyStatus(ctl, `Effort non disponibile per questo modello: ${arg}. Opzioni: default${levels.filter(Boolean).length ? ", " + levels.filter(Boolean).join(", ") : ""}`, true);
+                return null;
+            }
+            harness.config = { ...harness.config, effort: effort };
+            saveGlobalSettings(harness.env, { effort });
+            ctl.refresh?.();
+            return null;
+        }
+        case "collaboratori":
+        case "kingdoms":
+        case "warm": {
+            const parsed = parseCastles(args);
+            let castles = parsed.castles;
+            if (!castles.length) {
+                ctl.write(theme.dim("\n  uso: /collaboratori <attività1; attività2; ...>\n") +
+                    theme.dim("  ogni gruppo: \"slug: obiettivo\" oppure solo l'obiettivo.\n") +
+                    theme.dim("  esempio: /collaboratori auth: login OAuth; ui: pagina profilo; api: endpoint REST\n") +
+                    theme.dim("  un solo obiettivo viene suddiviso automaticamente in gruppi.\n") +
+                    theme.dim("  più gruppi possono usare collaboratori paralleli con memoria condivisa.\n\n"));
+                return null;
+            }
+            // Feedback sui warning di parsing (es. slug duplicati rinominati).
+            for (const w of parsed.warnings)
+                ctl.write(theme.yellow(`\n  attenzione: ${w}\n`));
+            // Un solo obiettivo senza ';': viene scomposto automaticamente in gruppi.
+            if (castles.length === 1 && !args.includes(";")) {
+                ctl.write(theme.dim("\n  suddivisione dell'obiettivo in gruppi di lavoro...\n"));
+                const decomposed = await decomposeKingdom({ harness, goal: args.trim(), signal });
+                if (decomposed.length > 1) {
+                    castles = decomposed;
+                    for (const c of castles)
+                        ctl.write(theme.silver(`    · ${c.slug}`) + theme.dim(`  ${truncate(c.goal, 70)}`) + "\n");
+                }
+                else {
+                    ctl.write(theme.dim("    obiettivo unico: eseguo un solo gruppo.\n"));
+                }
+            }
+            const threshold = kingdomThreshold(harness.env);
+            const conc = warmConcurrency(harness.env);
+            let parallel = castles.length >= threshold;
+            if (parallel) {
+                const choice = await selectOption({
+                    title: `esecuzione parallela — ${castles.length} gruppi`,
+                    hint: `fino a ${conc} collaboratori simultanei con memoria condivisa`,
+                    options: [
+                        { key: "yes", label: "Sì, in parallelo", detail: `${Math.min(conc, castles.length)} collaboratori simultanei`, value: true },
+                        { key: "no", label: "No, in sequenza", detail: "un gruppo alla volta", value: false },
+                    ],
+                    currentKey: "yes",
+                    ctl,
+                    theme,
+                    terminalColumns,
+                });
+                parallel = choice?.value === true;
+            }
+            const kingdomId = `kw-${harness.session.id}`;
+            const concurrency = parallel ? conc : 1;
+            ctl.write(theme.accent(`\n  Attività in parallelo`) +
+                theme.dim(` · ${castles.length} gruppi · ${parallel ? `${Math.min(conc, castles.length)} collaboratori paralleli` : "sequenziale"} · memoria condivisa\n`));
+            const live = createKingdomLive(ctl, theme, castles);
+            const reports = await runKingdomWarm({
+                harness,
+                kingdomId,
+                castles,
+                signal,
+                confirm: async () => true, // consenso dato in blocco: i vassalli eseguono i tool
+                concurrency,
+                onEvent: live.onEvent,
+            });
+            live.finish();
+            ctl.write(renderKingdomReport(reports, theme, terminalColumns()));
+            // GATE KPI di regno (opt-in): misura esecuzione + allineamento all'obiettivo.
+            if (selfImproveEnabled(harness.env) && reports.length && !signal.aborted) {
+                try {
+                    let roomIndex = "";
+                    try {
+                        const block = RoomMemory.open(harness.config.sessionDir, kingdomId).indexBlock();
+                        if (block.trim())
+                            roomIndex = block;
+                    }
+                    catch { /* nessuna memoria */ }
+                    const verdict = await runKingdomGate({
+                        harness,
+                        reports,
+                        goal: args.trim(),
+                        ...(roomIndex ? { roomIndex } : {}),
+                        signal,
+                    });
+                    ctl.write("\n  " + formatKingdomGate(verdict).split("\n").join("\n  ") + "\n");
+                }
+                catch { /* fail-open */ }
+            }
+            return null;
+        }
+        default: {
+            // Skill: /skill:nome [args] carica SKILL.md come input per il modello.
+            if (harness.skillCommandsEnabled && (cmd === "skill" || (cmd ?? "").startsWith("skill:"))) {
+                const skillName = cmd === "skill" ? (rest[0] ?? "") : (cmd ?? "").slice("skill:".length);
+                const skillArgs = cmd === "skill" ? rest.slice(1).join(" ") : args;
+                if (!skillName) {
+                    const names = harness.skills.map((s) => s.name).join(", ") || "nessuna";
+                    ctl.write(theme.dim(`\n  skill disponibili: ${names}\n`));
+                    return null;
+                }
+                const skill = findSkill(harness.skills, skillName);
+                if (!skill) {
+                    ctl.write(theme.yellow(`\n  skill sconosciuta: ${skillName}\n`));
+                    return null;
+                }
+                ctl.write("\n" + skillPreview(skill.name, theme, terminalColumns(), "ok").join("\n") + "\n");
+                return { input: renderSkillInvocation(skill, skillArgs) };
+            }
+            // Prompt template: espande il corpo e lo invia come input al modello.
+            const tpl = findTemplate(templates, cmd ?? "");
+            if (tpl) {
+                return { input: renderTemplate(tpl, args) };
+            }
+            const ext = harness.host.commands.get(cmd ?? "");
+            if (ext) {
+                const output = await ext.run(args, harness.host.publicApi());
+                return output ? { input: output } : null;
+            }
+            // Comando sconosciuto: suggerisci il piu' vicino fra TUTTI i comandi noti
+            // (builtin + alias + estensioni + template + skill) con edit distance.
+            const known = [
+                ...visibleBuiltinNames(),
+                ...[...harness.host.commands.keys()],
+                ...templates.map((t) => t.name),
+                ...harness.skills.map((s) => `skill:${s.name}`),
+            ];
+            const guesses = suggestCommands(cmd ?? "", known);
+            ctl.write(theme.red(`\n  comando sconosciuto: /${cmd}`));
+            if (guesses.length) {
+                ctl.write(theme.dim(`  forse intendevi: ${guesses.map((g) => `/${g}`).join(", ")}`));
+            }
+            else {
+                ctl.write(theme.dim("  usa /help per la lista dei comandi"));
+            }
+            ctl.write("\n");
+            return null;
+        }
+    }
+}
+// === Accesso provider (/login) ==============================================
+// Un solo flusso mostra lo stato reale, avvia i login dei CLI ufficiali e
+// ricarica subito il ProviderRegistry. Le API key e OpenRouter riusano il menu
+// provider, evitando due implementazioni divergenti delle credenziali.
+async function loginMenu(harness, ctl, theme, terminalColumns) {
+    for (;;) {
+        const rows = loginRows(harness.env, harness.providers);
+        const picked = await selectOption({
+            title: tr("accesso ai modelli", "model sign-in"),
+            hint: "Enter gestisci · digita per cercare · Esc chiudi",
+            options: rows.map((row) => ({
+                key: row.id,
+                label: row.label,
+                detail: `${loginStatusLabel(row)} · ${row.detail}`,
+                value: row,
+            })),
+            ctl,
+            theme,
+            terminalColumns,
+            filterable: true,
+        });
+        if (!picked)
+            return;
+        const row = picked.value;
+        if (row.id === "api-keys") {
+            await providerMenu(harness, ctl, theme, terminalColumns);
+            continue;
+        }
+        if (row.id === "openrouter") {
+            const provider = providerRows(harness.env, harness.providers, harness.config.model)
+                .find((item) => item.id === "openrouter");
+            if (provider)
+                await providerActions(provider, harness, ctl, theme, terminalColumns);
+            continue;
+        }
+        const action = await selectOption({
+            title: `${row.label} · ${loginStatusLabel(row)}`,
+            hint: row.command ? `comando: ${row.command.join(" ")}` : "",
+            options: [
+                {
+                    key: "login",
+                    label: row.configured && !row.needsRefresh ? tr("accedi di nuovo", "sign in again") : tr("accedi ora", "sign in"),
+                    detail: tr("apre la procedura di accesso nel terminale corrente", "opens the sign-in flow in the current terminal"),
+                    value: "login",
+                },
+                ...(row.configured && !row.needsRefresh
+                    ? [{
+                            key: "model",
+                            label: tr("scegli un modello", "choose a model"),
+                            detail: tr("usa questo abbonamento nel prossimo turno", "use this subscription on the next turn"),
+                            value: "model",
+                        }]
+                    : []),
+            ],
+            ctl,
+            theme,
+            terminalColumns,
+        });
+        if (!action)
+            continue;
+        if (action.value === "model") {
+            if (await pickModel(harness, ctl, theme, terminalColumns))
+                return;
+            continue;
+        }
+        if (!row.command)
+            continue;
+        const completed = await runInteractiveLogin(row.command, harness, ctl, theme);
+        harness.reloadProviders();
+        const refreshed = loginRows(harness.env, harness.providers).find((item) => item.id === row.id);
+        if (completed && refreshed?.configured && !refreshed.needsRefresh) {
+            ctl.write(theme.green(`\n  ${row.label}: accesso rilevato e modelli aggiornati.\n`));
+        }
+        else if (completed) {
+            ctl.write(theme.yellow(`\n  ${row.label}: il comando e' terminato, ma non trovo ancora una sessione valida.\n`));
+        }
+    }
+}
+async function runInteractiveLogin(command, harness, ctl, theme) {
+    const [executable, ...args] = command;
+    if (!executable)
+        return false;
+    if (!stdin.isTTY || !stdout.isTTY) {
+        ctl.write(theme.dim(`\n  esegui in un terminale: ${command.join(" ")}\n`));
+        return false;
+    }
+    ctl.write(theme.bold(`\n  avvio ${command.join(" ")}\n`));
+    ctl.write(theme.dim("  completa l'accesso; al termine tornerai automaticamente a Talos.\n\n"));
+    ctl.pause();
+    ctl.setOverlay(null);
+    ctl.setStatus(null);
+    const wasRaw = stdin.isRaw;
+    if (typeof stdin.setRawMode === "function")
+        stdin.setRawMode(false);
+    stdin.resume();
+    try {
+        const code = await new Promise((resolve) => {
+            const child = spawn(executable, args, {
+                env: harness.env,
+                stdio: "inherit",
+                shell: process.platform === "win32",
+            });
+            child.once("error", () => resolve(-1));
+            child.once("exit", (value) => resolve(value ?? -1));
+        });
+        if (code !== 0) {
+            ctl.write(theme.yellow(`\n  login non completato (uscita ${code}). Verifica che \`${executable}\` sia installato.\n`));
+            return false;
+        }
+        return true;
+    }
+    finally {
+        if (typeof stdin.setRawMode === "function")
+            stdin.setRawMode(Boolean(wasRaw));
+        ctl.resume();
+        ctl.refresh?.();
+    }
+}
+// === Menu provider navigabile (/provider) ===
+// Schermata interattiva: elenco provider con stato, scelta di uno, azioni
+// guidate (imposta chiave/endpoint, OAuth, scegli modello, rimuovi). Dopo ogni
+// modifica ricostruisce il registro (harness.reloadProviders) cosi' il provider
+// diventa attivo senza riavvio.
+async function providerMenu(harness, ctl, theme, terminalColumns) {
+    // Loop sull'elenco: si esce con Esc.
+    for (;;) {
+        const rows = providerRows(harness.env, harness.providers, harness.config.model);
+        const options = rows.map((row) => ({
+            key: row.id,
+            label: `${row.label}${row.active ? "  ←" : ""}`,
+            detail: `${rowStatusLabel(row)}${row.modelCount ? ` · ${row.modelCount} modelli` : ""}`,
+            value: row,
+        }));
+        const configured = rows.filter((r) => r.configured).length;
+        const picked = await selectOption({
+            title: `provider — ${configured} configurati su ${rows.length}`,
+            hint: "↑/↓ scegli · Enter apri · digita per cercare · Esc chiudi",
+            options,
+            ctl,
+            theme,
+            terminalColumns,
+            filterable: true,
+        });
+        if (!picked || !picked.value)
+            return; // Esc: chiudi il menu
+        const done = await providerActions(picked.value, harness, ctl, theme, terminalColumns);
+        if (done === "model-set")
+            return; // ha scelto un modello: torna alla chat
+        // altrimenti rientra nel loop con lo stato aggiornato
+    }
+}
+// Azioni su un singolo provider. Ritorna "model-set" se l'utente ha scelto un
+// modello (chiude il menu), altrimenti "back" per tornare all'elenco.
+async function providerActions(row, harness, ctl, theme, terminalColumns) {
+    for (;;) {
+        // Rilegge lo stato corrente del provider (puo' essere cambiato).
+        const fresh = providerRows(harness.env, harness.providers, harness.config.model).find((r) => r.id === row.id) ?? row;
+        const actions = actionsFor(harness.env, fresh);
+        const choice = await selectOption({
+            title: `${fresh.label} · ${rowStatusLabel(fresh)}`,
+            hint: fresh.baseUrl ? `endpoint: ${fresh.baseUrl}` : "",
+            options: actions.map((a) => ({ key: a.action, label: a.label, detail: a.detail, value: a.action })),
+            ctl,
+            theme,
+            terminalColumns,
+        });
+        if (!choice || choice.value === "back")
+            return "back";
+        switch (choice.value) {
+            case "set-key": {
+                const ok = await setKeyFlow(fresh, harness, ctl, theme);
+                if (ok)
+                    ctl.write(theme.green(`\n  ${fresh.label}: chiave salvata e provider attivato.\n`));
+                break;
+            }
+            case "set-endpoint": {
+                await setEndpointFlow(fresh, harness, ctl, theme);
+                break;
+            }
+            case "oauth": {
+                await oauthFlow(fresh, harness, ctl, theme, terminalColumns);
+                break;
+            }
+            case "use-model": {
+                const set = await pickModel(harness, ctl, theme, terminalColumns);
+                if (set)
+                    return "model-set";
+                break;
+            }
+            case "remove": {
+                const confirmed = await selectOption({
+                    title: `rimuovere la credenziale di ${fresh.label}?`,
+                    hint: "la chiave salvata verra' eliminata dal config",
+                    options: [
+                        { key: "no", label: "No, mantieni", detail: "", value: false },
+                        { key: "yes", label: "Sì, rimuovi", detail: "", value: true },
+                    ],
+                    currentKey: "no",
+                    ctl,
+                    theme,
+                    terminalColumns,
+                });
+                if (confirmed?.value) {
+                    const res = removeProvider(harness.env, fresh.id);
+                    if (res.ok) {
+                        harness.reloadProviders();
+                        ctl.write(theme.green(`\n  ${fresh.label}: credenziale rimossa.\n`));
+                    }
+                    else {
+                        ctl.write(theme.yellow(`\n  ${res.error ?? "rimozione non riuscita"}\n`));
+                    }
+                    return "back";
+                }
+                break;
+            }
+        }
+    }
+}
+// Flusso "imposta API key": chiede la chiave, la valida (per OpenRouter via
+// rete), la salva e ricostruisce il registro. Ritorna true se salvata.
+async function setKeyFlow(row, harness, ctl, theme) {
+    ctl.write(theme.dim(`\n  ${providerKeyHint(row.spec)}\n`));
+    const key = await ctl.promptInput(`API key per ${row.label} (Invio conferma · Esc annulla)`);
+    if (!key)
+        return false;
+    const trimmed = key.trim();
+    // Validazione di forma per OpenRouter (sk-or-...). Avviso non bloccante.
+    if (row.id === "openrouter" && !looksLikeApiKey(trimmed)) {
+        ctl.write(theme.yellow("\n  attenzione: la chiave non sembra una OpenRouter key (sk-or-...). Provo comunque.\n"));
+    }
+    // Validazione di rete (oggi solo OpenRouter espone /key). Best effort.
+    if (row.id === "openrouter") {
+        ctl.setStatus(theme.dim("verifico la chiave su OpenRouter…"));
+        try {
+            const v = await validateApiKey(trimmed);
+            ctl.setStatus(null);
+            if (!v.ok) {
+                ctl.write(theme.yellow(`\n  chiave non valida: ${v.error ?? "verifica fallita"}. Non salvata.\n`));
+                return false;
+            }
+            const credit = v.limitRemaining === null || v.limitRemaining === undefined
+                ? "credito illimitato"
+                : `credito residuo ${v.limitRemaining.toFixed(2)}`;
+            ctl.write(theme.green(`\n  chiave valida${v.label ? ` (${v.label})` : ""} · ${credit}\n`));
+        }
+        catch {
+            ctl.setStatus(null);
+        }
+    }
+    const res = saveProviderKey(harness.env, row.id, trimmed);
+    if (!res.ok) {
+        ctl.write(theme.yellow(`\n  ${res.error ?? "salvataggio non riuscito"}\n`));
+        return false;
+    }
+    // La env scoped serve a reloadProviders (che la rilegge dal disco), ma la
+    // impostiamo anche nel processo corrente per coerenza immediata.
+    const norm = row.id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    harness.env[`TALOS_${norm}_API_KEY`] = trimmed;
+    harness.reloadProviders();
+    return true;
+}
+// Flusso "imposta endpoint": chiede una baseUrl (vuota = ripristina default).
+async function setEndpointFlow(row, harness, ctl, theme) {
+    ctl.write(theme.dim(`\n  endpoint attuale: ${row.baseUrl ?? "(default del provider)"}  ·  vuoto = ripristina default\n`));
+    const url = await ctl.promptInput(`baseUrl per ${row.label} (Invio conferma · Esc annulla)`);
+    if (url === null)
+        return; // Esc
+    const res = saveProviderBaseUrl(harness.env, row.id, url);
+    if (!res.ok) {
+        ctl.write(theme.yellow(`\n  ${res.error ?? "salvataggio non riuscito"}\n`));
+        return;
+    }
+    const norm = row.id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    if (url.trim())
+        harness.env[`TALOS_${norm}_BASE_URL`] = url.trim();
+    else
+        delete harness.env[`TALOS_${norm}_BASE_URL`];
+    harness.reloadProviders();
+    ctl.write(theme.green(`\n  ${row.label}: endpoint ${url.trim() ? "aggiornato" : "ripristinato al default"}.\n`));
+}
+// Flusso OAuth (oggi: OpenRouter PKCE). Mostra l'URL da aprire nel browser e
+// raccoglie il code dal callback, poi scambia e salva la chiave.
+async function oauthFlow(row, harness, ctl, theme, terminalColumns) {
+    if (row.id !== "openrouter") {
+        transientNotice(ctl, "OAuth non disponibile per questo provider.", "failed", theme);
+        return;
+    }
+    // Il login e' una vista operativa temporanea: non deve diventare parte della
+    // conversazione. L'overlay viene aggiornato in place e rimosso al termine.
+    let authUrl = "";
+    let authState = "avvio il server locale…";
+    const drawOAuth = () => {
+        const lines = [authState];
+        if (authUrl)
+            lines.push("", "Se il browser non si apre, copia questo link:", authUrl);
+        lines.push("", "Questa schermata si chiudera' automaticamente.");
+        ctl.setOverlay([
+            theme.bold("  OpenRouter · accesso via browser"),
+            theme.dark(`  ${"─".repeat(Math.max(12, terminalColumns() - 4))}`),
+            ...lines.flatMap((line) => wrapPlain(line || " ", Math.max(20, terminalColumns() - 4)))
+                .map((line) => `  ${theme.silver(line)}`),
+        ]);
+    };
+    drawOAuth();
+    const onEvent = (ev) => {
+        switch (ev.phase) {
+            case "url_built":
+                authUrl = ev.detail ?? authUrl;
+                authState = "apro il browser per autorizzare…";
+                break;
+            case "browser_opened":
+                authState = "browser aperto · in attesa dell'autorizzazione…";
+                break;
+            case "browser_failed":
+                authState = "apri il link manualmente · in attesa dell'autorizzazione…";
+                break;
+            case "awaiting_code":
+                authState = "in attesa dell'autorizzazione nel browser…";
+                break;
+            case "exchanging":
+                authState = "autorizzazione ricevuta · attivo la API key…";
+                break;
+            default:
+                break;
+        }
+        drawOAuth();
+    };
+    try {
+        // Flusso automatico: server locale su loopback + apertura browser. Il
+        // redirect_uri e' http://127.0.0.1:PORT/callback (niente dominio pubblico).
+        const result = await orchestrateOAuth(harness.env, {
+            startServer: startCallbackServer,
+            buildAuthUrl: (redirectUri, challenge) => {
+                const u = new URL(redirectUri);
+                return buildAuthUrlForPort(Number(u.port), challenge, u.hostname);
+            },
+            openBrowser: async (url) => {
+                // print no-op: l'URL lo mostriamo gia' noi tramite onEvent(url_built).
+                const res = await openUrl(url, { print: () => { } });
+                return { opened: res.opened, error: res.error };
+            },
+            onEvent,
+        });
+        ctl.setStatus(null);
+        ctl.setOverlay(null);
+        if (result.ok && result.apiKey) {
+            // orchestrateOAuth ha gia' persistito le credenziali OpenRouter; allineiamo
+            // anche il config globale generico e la env scoped per reloadProviders.
+            saveProviderKey(harness.env, row.id, result.apiKey);
+            harness.env["TALOS_OPENROUTER_API_KEY"] = result.apiKey;
+            harness.reloadProviders();
+            transientNotice(ctl, "OpenRouter collegato e attivato", "done", theme);
+            return;
+        }
+        // Fallimento del flusso automatico (browser/timeout/callback/server):
+        // ricadiamo sul percorso manuale con un flow nuovo e coerente (PKCE
+        // proprio + authUrl mostrato all'utente, che incolla il code).
+        const reason = result.error ?? "callback automatico non riuscito";
+        const manualFlow = startOAuthFlow(harness.env, callbackUrlForPort());
+        const manualLines = [];
+        const manual = await runManualCodeFallback({
+            print: (line) => { manualLines.push(line); },
+            prompt: async (label) => {
+                await showReadonlyOverlay({
+                    title: "OpenRouter · autorizzazione manuale",
+                    lines: manualLines,
+                    ctl,
+                    theme,
+                    terminalColumns,
+                });
+                return ctl.promptInput(label);
+            },
+        }, manualFlow, { reason });
+        if (!manual.ok || !manual.apiKey) {
+            if (manual.error === "cancelled") {
+                transientNotice(ctl, "OAuth annullato", "done", theme);
+            }
+            else {
+                transientNotice(ctl, `OAuth non riuscito: ${manual.error ?? "scambio fallito"}`, "failed", theme);
+            }
+            return;
+        }
+        saveProviderKey(harness.env, row.id, manual.apiKey);
+        harness.env["TALOS_OPENROUTER_API_KEY"] = manual.apiKey;
+        harness.reloadProviders();
+        transientNotice(ctl, "OpenRouter collegato e attivato", "done", theme);
+    }
+    catch (err) {
+        ctl.setStatus(null);
+        ctl.setOverlay(null);
+        transientNotice(ctl, `errore OAuth: ${err.message}`, "failed", theme);
+    }
+}
+function transientNotice(ctl, label, state, theme) {
+    notifyStatus(ctl, label, state === "failed");
+}
+async function pickModel(harness, ctl, theme, terminalColumns) {
+    const providers = harness.providers.list();
+    const dynamic = await loadDynamicModels(providers, ctl, theme, harness.env);
+    const accessOptions = loginRows(harness.env, harness.providers)
+        .filter((row) => !row.configured || row.needsRefresh)
+        .map((row) => ({
+        key: `access:${row.id}`,
+        label: `${row.needsRefresh ? "Rinnova" : "Collega"}  ${row.label}`,
+        detail: `${loginStatusLabel(row)} · ${row.detail}`,
+        value: { providerId: `access:${row.id}`, modelId: "", fullModel: `access:${row.id}` },
+    }));
+    const options = [...accessOptions, ...modelOptions(providers, dynamic)];
+    if (!options.length) {
+        ctl.write(theme.yellow("\n  nessun provider configurato. Usa /login per collegare un abbonamento o una API key.\n"));
+        return false;
+    }
+    const current = canonicalModel(harness.config.model);
+    const selected = await selectOption({
+        title: "Modelli",
+        options,
+        currentKey: current?.fullModel,
+        ctl,
+        theme,
+        terminalColumns,
+        filterable: true,
+    });
+    if (!selected)
+        return false;
+    if (selected.value.providerId.startsWith("access:")) {
+        await loginMenu(harness, ctl, theme, terminalColumns);
+        return false;
+    }
+    const auth = await pickAuthMethod(selected.value, harness, ctl, theme, terminalColumns);
+    if (!auth)
+        return false;
+    return applyModelChoice(auth.value, harness, ctl, theme, terminalColumns);
+}
+async function pickAuthMethod(choice, harness, ctl, theme, terminalColumns) {
+    const options = authOptions(choice, harness.providers.list());
+    if (!options.length) {
+        ctl.write(theme.yellow(`\n  nessun metodo di accesso configurato per ${choice.fullModel}.\n`));
+        ctl.write(theme.dim(authHint(choice.providerId) + "\n"));
+        return null;
+    }
+    if (!requiresAuthChoice(choice.providerId))
+        return options[0] ?? null;
+    return selectOption({
+        title: "metodo accesso",
+        hint: "↑/↓ muovi  Enter conferma  Esc/q annulla",
+        options,
+        currentKey: harness.config.model,
+        ctl,
+        theme,
+        terminalColumns,
+    });
+}
+function modelOptions(providers, dynamic) {
+    const byId = new Map(providers.map((provider) => [provider.id, provider]));
+    const out = [];
+    for (const spec of PROVIDER_CATALOG) {
+        const authProviders = authProviderIds(spec.id).map((id) => byId.get(id)).filter((p) => Boolean(p));
+        if (!authProviders.length)
+            continue;
+        const dyn = dynamic?.get(spec.id) ?? [];
+        const dynById = new Map(dyn.map((d) => [d.id, d]));
+        const models = unique([
+            ...spec.models,
+            ...authProviders.flatMap((provider) => provider.models),
+            ...dyn.map((d) => d.id),
+        ]);
+        for (const model of models) {
+            const full = `${spec.id}/${model}`;
+            const detail = dynById.get(model)?.detail;
+            out.push({
+                key: full,
+                label: `${spec.label}  ${model}`,
+                detail: `${authSummary(spec.id, authProviders)}${detail ? ` · ${detail}` : ""}`,
+                value: { providerId: spec.id, modelId: model, fullModel: full },
+            });
+        }
+    }
+    return out;
+}
+// Carica i cataloghi dinamici dei provider che li espongono (oggi: OpenRouter).
+// Fallisce in modo morbido: in caso di rete assente, restituisce mappa vuota e
+// il picker resta coi suggerimenti statici.
+async function loadDynamicModels(providers, ctl, theme, env) {
+    const map = new Map();
+    const catalog = await loadModelsDev(env);
+    for (const spec of PROVIDER_CATALOG) {
+        if (!providers.some(p => authProviderIds(spec.id).includes(p.id)))
+            continue;
+        map.set(spec.id, catalog.list(spec.id)
+            .filter(m => m.status !== "deprecated" && m.outputModalities.includes("text") && m.toolCall !== false)
+            .map(m => ({ id: m.id, detail: modelDetail(m) })));
+    }
+    if (providers.some((p) => p.id === "openrouter")) {
+        ctl.setStatus(theme.dim("carico catalogo OpenRouter…"));
+        try {
+            const models = await fetchOpenRouterModels(env);
+            if (models.length) {
+                const existing = new Map((map.get("openrouter") ?? []).map(m => [m.id, m]));
+                for (const m of models)
+                    if (!existing.has(m.id))
+                        existing.set(m.id, { id: m.id, detail: openRouterDetail(m) });
+                map.set("openrouter", [...existing.values()]);
+            }
+        }
+        finally {
+            ctl.setStatus(null);
+        }
+    }
+    return map;
+}
+function authOptions(choice, providers) {
+    const byId = new Map(providers.map((provider) => [provider.id, provider]));
+    return authProviderIds(choice.providerId)
+        .map((id) => byId.get(id))
+        .filter(isProvider)
+        .filter((provider) => supportsModel(provider, choice.modelId))
+        .map((provider) => ({
+        key: `${provider.id}/${choice.modelId}`,
+        label: authLabel(choice.providerId, provider.id),
+        detail: provider.label ?? provider.id,
+        value: `${provider.id}/${choice.modelId}`,
+    }));
+}
+function isProvider(provider) {
+    return provider !== undefined;
+}
+function authProviderIds(providerId) {
+    if (providerId === "anthropic")
+        return ["claude-code", "anthropic"];
+    if (providerId === "openai")
+        return ["chatgpt", "openai"];
+    return [providerId];
+}
+function authLabel(canonicalProviderId, actualProviderId) {
+    if (canonicalProviderId === "anthropic" && actualProviderId === "claude-code")
+        return "OAuth abbonamento";
+    if (canonicalProviderId === "anthropic" && actualProviderId === "anthropic")
+        return "API key";
+    if (canonicalProviderId === "openai" && actualProviderId === "chatgpt")
+        return "OAuth abbonamento";
+    if (canonicalProviderId === "openai" && actualProviderId === "openai")
+        return "API key";
+    return actualProviderId === "ollama" ? "locale" : "API key";
+}
+function authSummary(providerId, providers) {
+    return providers.map((provider) => authLabel(providerId, provider.id)).join(" / ");
+}
+function requiresAuthChoice(providerId) {
+    return providerId === "anthropic" || providerId === "openai";
+}
+function supportsModel(provider, modelId) {
+    // OpenRouter aggrega centinaia di modelli (catalogo dinamico): accetta
+    // qualsiasi modelId, non solo quelli elencati staticamente nel catalogo.
+    if (provider.id !== "chatgpt" && provider.id !== "claude-code")
+        return true;
+    return provider.models.length === 0 || provider.models.includes(modelId);
+}
+function canonicalModel(model) {
+    const slash = model.indexOf("/");
+    if (slash <= 0)
+        return undefined;
+    const providerId = canonicalProviderId(model.slice(0, slash));
+    const modelId = model.slice(slash + 1);
+    return { providerId, modelId, fullModel: `${providerId}/${modelId}` };
+}
+function canonicalProviderId(providerId) {
+    if (providerId === "claude-code")
+        return "anthropic";
+    if (providerId === "chatgpt")
+        return "openai";
+    return providerId;
+}
+function authHint(providerId) {
+    if (providerId === "anthropic")
+        return "  Configura CLAUDE_CODE OAuth con `claude` oppure ANTHROPIC_API_KEY.";
+    if (providerId === "openai")
+        return "  Configura ChatGPT OAuth con `codex` oppure OPENAI_API_KEY.";
+    const spec = PROVIDER_CATALOG.find((item) => item.id === providerId);
+    return spec?.envKey ? `  Configura ${spec.envKey}.` : "  Verifica la configurazione del provider.";
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+// Pannello informativo effimero. A differenza di ctl.write non modifica il log
+// della conversazione: e' pensato per viste operative come /bg, diagnostica e
+// riepiloghi che servono soltanto mentre l'utente li consulta.
+async function showReadonlyOverlay(opts) {
+    if (!stdin.isTTY || !stdout.isTTY || typeof stdin.setRawMode !== "function") {
+        opts.ctl.write(`\n  ${opts.title}\n${opts.lines.map((line) => `    ${line}`).join("\n")}\n`);
+        return;
+    }
+    readline.emitKeypressEvents(stdin);
+    const wasRaw = stdin.isRaw;
+    const wasPaused = stdin.isPaused();
+    let offset = 0;
+    const pageSize = () => Math.max(3, (stdout.rows || 24) - 7);
+    const renderedLines = () => opts.lines.flatMap((line) => wrapPlain(line || " ", Math.max(12, opts.terminalColumns() - 4)));
+    const maxOffset = () => Math.max(0, renderedLines().length - pageSize());
+    const draw = () => {
+        const width = Math.max(32, opts.terminalColumns());
+        const allLines = renderedLines();
+        const body = allLines.slice(offset, offset + pageSize());
+        const rows = [
+            opts.theme.bold(`  ${opts.title}`),
+            opts.theme.dark(`  ${"─".repeat(Math.max(8, width - 4))}`),
+            ...body.map((line) => `  ${opts.theme.silver(truncate(line, Math.max(12, width - 4)))}`),
+            opts.theme.dark(`  ${allLines.length > pageSize() ? `↑/↓ scorri · ${offset + 1}-${Math.min(offset + pageSize(), allLines.length)}/${allLines.length} · ` : ""}Esc/Invio/q chiude`),
+        ];
+        opts.ctl.setOverlay(rows);
+    };
+    await new Promise((resolve) => {
+        let settled = false;
+        const cleanup = () => {
+            if (settled)
+                return;
+            settled = true;
+            stdin.off("keypress", onKeypress);
+            stdin.setRawMode(Boolean(wasRaw));
+            if (wasPaused)
+                stdin.pause();
+            opts.ctl.setOverlay(null);
+            opts.ctl.resume();
+            resolve();
+        };
+        const onKeypress = (_chunk, key) => {
+            if (key.name === "down" || (key.ctrl && key.name === "n")) {
+                offset = Math.min(maxOffset(), offset + 1);
+                draw();
+                return;
+            }
+            if (key.name === "up" || (key.ctrl && key.name === "p")) {
+                offset = Math.max(0, offset - 1);
+                draw();
+                return;
+            }
+            if (key.name === "pagedown") {
+                offset = Math.min(maxOffset(), offset + pageSize());
+                draw();
+                return;
+            }
+            if (key.name === "pageup") {
+                offset = Math.max(0, offset - pageSize());
+                draw();
+                return;
+            }
+            if (key.name === "escape" || key.name === "return" || key.name === "q" || (key.ctrl && key.name === "c"))
+                cleanup();
+        };
+        opts.ctl.pause();
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("keypress", onKeypress);
+        draw();
+    });
+}
+// Parsea i castelli da una stringa: separati da ";" (o newline). Ogni voce e'
+// "slug: obiettivo" oppure solo l'obiettivo (slug auto c1, c2, ...). Garantisce
+// slug UNICI (i duplicati ricevono un suffisso -2, -3, ...) e raccoglie warning
+// per dare feedback chiaro all'utente senza bloccare l'esecuzione.
+function parseCastles(args) {
+    const pieces = args.split(/[;\n]+/).map((s) => s.trim()).filter(Boolean);
+    const warnings = [];
+    const used = new Set();
+    const castles = pieces.map((piece, i) => {
+        const m = /^([A-Za-z][\w-]{0,23}):\s*(.+)$/.exec(piece);
+        let slug = m && m[2] ? m[1] : `c${i + 1}`;
+        const goal = m && m[2] ? m[2] : piece;
+        // Slug unico: se gia' usato, aggiungi un suffisso progressivo.
+        if (used.has(slug)) {
+            const base = slug;
+            let n = 2;
+            while (used.has(`${base}-${n}`))
+                n++;
+            slug = `${base}-${n}`;
+            warnings.push(`slug "${base}" duplicato, rinominato in "${slug}"`);
+        }
+        used.add(slug);
+        return { slug, goal };
+    });
+    return { castles, warnings };
+}
+function kingdomThreshold(env) {
+    const n = Number(env["TALOS_KINGDOM_THRESHOLD"]);
+    return Number.isInteger(n) && n > 0 ? n : 3;
+}
+function renderKingdomReport(reports, theme, columns) {
+    const width = Math.max(40, Math.min(96, columns - 4));
+    const ok = reports.filter((r) => r.ok).length;
+    const out = [
+        "",
+        theme.accent("  report al Imperatore") + theme.dim(`  ${ok}/${reports.length} gruppi ok`),
+    ];
+    for (const r of reports) {
+        const mark = r.ok ? theme.green("  ✓ ") : theme.red("  ✗ ");
+        const head = `${r.slug}` + (r.rooms ? ` · ${r.rooms} attivita` : "") + (r.error ? ` · ${r.error}` : "");
+        out.push(mark + theme.silver(head));
+        const line = (r.summary.split("\n").find((l) => l.trim()) ?? "").slice(0, width - 6);
+        if (line)
+            out.push(theme.dim(`      ${line}`));
+    }
+    // Stash da risolvere: rami di vassallo non merge-ati (conflitti) lasciati per
+    // la risoluzione manuale. Elencali in chiaro con i comandi per chiuderli.
+    const conflicts = collectConflicts(reports);
+    if (conflicts.length) {
+        out.push("");
+        out.push(theme.yellow(`  ⚠ ${conflicts.length} ramo/i da risolvere a mano (merge non riuscito)`));
+        for (const c of conflicts) {
+            out.push(theme.red("  • ") + theme.silver(c.slug) + theme.dim(` · ${c.branch} · ${c.conflict ? "conflitto" : "errore"}`));
+            out.push(theme.dim(`      git merge --no-ff ${c.branch}   # risolvi, poi git add -A && git commit`));
+        }
+    }
+    out.push("");
+    return out.join("\n") + "\n";
+}
+function vascendRoomGlyph(status) {
+    if (status === "completed")
+        return "✦";
+    if (status === "running")
+        return "▸";
+    if (status === "failed")
+        return "✗";
+    return "·";
+}
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    if (max <= 1)
+        return value.slice(0, max);
+    return `${value.slice(0, max - 1)}…`;
+}
+function padRight(value, width) {
+    const pad = width - visibleLength(value);
+    return pad > 0 ? `${value}${" ".repeat(pad)}` : value;
+}
+function visibleLength(value) {
+    return value.replace(/\x1b\[[0-9;]*m/g, "").length;
+}