@vascend/talos 0.1.4 → 0.1.6

package/dist/tui/repl.js

@@ -1,4 +1,5 @@
 import { reviewContinuation } from "../core/continuation-review.js";
+import { skillList, mcpList } from "./capability-lists.js";
 import * as readline from "node:readline";
 import { spawn } from "node:child_process";
 import { watch, existsSync, readFileSync } from "node:fs";
@@ -6,17 +7,23 @@ 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 { renderDiffParts } from "./diff.js";
 import { renderMarkdown, wrapPlain } from "./markdown.js";
 import { SessionUsageState } from "./session-usage.js";
+import { readSessionUsage } from "../core/session-usage.js";
+import { storageHealth } from "../core/storage-health.js";
+import { storageWarning } from "./storage-warning.js";
 import { ContextMeter, contextDetails } from "./context-meter.js";
-import { buildUsageFooter, subscriptionDetails, SESSION_USAGE_EXPLANATION } from "./usage-footer.js";
+import { buildUsageFooter, subscriptionDetails, sessionUsageExplanation } from "./usage-footer.js";
 import { copyText, lastAssistantText } from "./clipboard-text.js";
+import { sendWorker, stopWorker, deleteWorker, workerFooter, bindWorkerInbox, wakeWorker } from "./session-controls.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 { providerLabel } from "./provider-label.js";
 import { applyModelChoice, pickEffort } from "./model-selection.js";
+import { pickFusion } from "./fusion-menu.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";
@@ -29,6 +36,7 @@ import { frostPaint, makeTheme, renderAssistantSegment, renderAssistantTurnEnd,
 import { renderVascendTerminalLogo } from "./logo.js";
 import { enterAccount } from "./account-entry.js";
 import { tr } from "./i18n.js";
+import { runtimeError, isUserInterruption } from "./runtime-error.js";
 import { LANGUAGES, normalizePreference } from "./locales.js";
 import { languagePreference, saveLanguagePreference } from "./language-preference.js";
 import { leggiOnboarding } from "./onboarding.js";
@@ -45,7 +53,7 @@ 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 { livePreview, liveResultSummary, backgroundResultSummary } 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";
@@ -58,6 +66,7 @@ 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 { kingdomLive } from "../vascend/kingdom-live.js";
 import { runKingdomForHost } from "../vascend/kingdom-run.js";
 import { kingdomBus } from "../vascend/kingdom-bus.js";
 import { resolveKingdomBus } from "../vascend/kingdom-channel.js";
@@ -76,16 +85,22 @@ 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 { nameSession } from "../core/session-naming.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 { TASK_STATUS_LABELS, taskActivityLabel } from "./task-labels.js";
+import { liveCommandAllowed } from "./live-command.js";
+import { rimuoviLicenzaLocale, rimuoviTokenVascend, revocaSessione, } from "./vascend-login.js";
+import { leggiSessione, revocaSessioneId, rimuoviSessione, tokenAgente } from "./vascend-id.js";
+import { paintToolName, pulseDot } from "./tool-style.js";
+import { toolArg, toolLabel } from "./tool-presentation.js";
 import { listVibeModes, parseVibeMode } from "../core/vibe-modes.js";
 import { contextProjectKey, loadContextFrame, renderContextFrame, resetContextFrame, updateContextPins, } from "../vascend/context-fabric.js";
+import { collegaMani, fermaRemoto, messaggioUtente, osservaEvento, permessoConGara, sessioneRemota } from "../remote/index.js";
+import { comandoRemoto } from "./remote-command.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) {
@@ -323,7 +338,10 @@ export async function startRepl(deps) {
     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.sessions.conversations.configure((buffer, width) => makeSink(theme, () => width, harness.config.cwd, env, { ...buffer, setStatus: () => { }, setTokens: () => { },
+        refresh: () => { } }, undefined, true), () => theme);
     review.reset(sessionConversation(harness.session));
+    review.sessions.restoreMain(readSessionUsage(harness.config.sessionDir, harness.session.id));
     const reviewContext = () => {
         const cost = costTracker.snapshot(harness.config.model);
         const tasks = vascend.state().kingdom.castles.flatMap(c => c.tasks);
@@ -348,7 +366,7 @@ export async function startRepl(deps) {
             ? last.cacheReadTokens / Math.max(1, last.inputTokens + last.cacheReadTokens)
             : undefined;
         return {
-            provider: current ? (current.provider.label ?? current.provider.id) : "non configurato",
+            provider: current ? providerLabel(current.provider) : tr("non configurato", "not configured"),
             sessionId: harness.session.id,
             sessionNodes: stima.nodi,
             headId: harness.session.head,
@@ -411,7 +429,7 @@ export async function startRepl(deps) {
     const startupMeta = () => {
         const resolved = harness.providers.resolve(harness.config.model);
         return {
-            provider: resolved ? (resolved.provider.label ?? resolved.provider.id) : "non configurato",
+            provider: resolved ? providerLabel(resolved.provider) : tr("non configurato", "not configured"),
             sessionId: harness.session.id,
             sessionNodes: harness.session.tree().length,
             headId: harness.session.head,
@@ -445,8 +463,10 @@ export async function startRepl(deps) {
     // questa sessione soltanto: dopo /new, `txt #1` sarebbe un altro testo.
     const pasteRegistry = new PasteRegistry();
     const resetSessionUi = (ctl) => {
+        kingdomLive.clearAll();
         ctl.clearConversation?.();
         review.reset(sessionConversation(harness.session));
+        review.sessions.restoreMain(readSessionUsage(harness.config.sessionDir, harness.session.id));
         imageRegistry.clear();
         pasteRegistry.reset();
         ctl.restoreQueue?.();
@@ -501,6 +521,7 @@ export async function startRepl(deps) {
         try {
             if (!line.startsWith("/")) {
                 ctl.write(renderUserMessage(line, theme, terminalColumns(), fromQueue ? tr("Dalla coda · consegnato", "From queue · delivered") : undefined));
+                messaggioUtente(line);
                 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
@@ -518,6 +539,10 @@ export async function startRepl(deps) {
                     ctl.write(reviewText(review, reviewContext(), theme, terminalColumns(), section));
                 return;
             }
+            if (/^\/(?:agents|agenti)\s*$/i.test(line)) {
+                ctl.showAgents?.();
+                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);
@@ -628,7 +653,7 @@ export async function startRepl(deps) {
                 ? { done: all.filter((t) => t.status === "completed").length, total: all.length, castles: castles.length }
                 : null;
             return {
-                model: harness.config.model,
+                model: harness.config.fusion ? `Fusion: Jev + ${harness.config.model}` : harness.config.model,
                 provider: m.provider,
                 cwd: harness.config.cwd,
                 effort: harness.config.effort || "default",
@@ -650,15 +675,25 @@ export async function startRepl(deps) {
         };
         const input = new BottomInput({
             review,
+            onSessionSubmit: sendWorker,
+            bindSessionInbox: bindWorkerInbox,
+            wakeSession: wakeWorker,
+            onSessionStop: stopWorker,
+            onSessionDelete: deleteWorker,
+            onSessionBackground: session => ({ ok: !!backgroundManager.requestBackground(session.id) }),
+            sessionFooter: (session, width) => workerFooter(session, width, theme, stats, model => harness.providers.resolve(model)?.provider.id ?? "").slice(0, 1),
+            sessionBelowInput: (session, width) => workerFooter(session, width, theme, stats, model => harness.providers.resolve(model)?.provider.id ?? "").slice(1),
             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")),
+            placeholder: () => theme.muted(tr("Descrivi un'attività o digita / per i comandi", "Describe a task or type / for commands")),
             composerPadding: () => !harness.session.head,
             composerStyle: (s) => theme.composerText?.(s) ?? theme.chatText(s),
             attachmentStyle: (s) => theme.attachmentRef?.(s) ?? s,
+            currentModel: () => harness.config.model,
+            limitWarningStyle: s => theme.yellow(s),
             belowInputLines: () => {
                 if (!harness.session.head)
                     return [buildStartupRuntime(statusData(), theme)];
@@ -671,6 +706,7 @@ export async function startRepl(deps) {
                 const providerId = harness.providers.resolve(harness.config.model)?.provider.id ?? "";
                 return buildUsageFooter(statusData(), theme, stats, providerId, statusOpts()).slice(0, 1);
             },
+            warningLines: () => storageWarning(storageHealth.snapshot(harness.config.sessionDir), terminalColumns(), theme.yellow),
             completion,
             hint: slashHint,
             statusStyle: (s) => theme.dark(s),
@@ -692,14 +728,14 @@ export async function startRepl(deps) {
             // 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();
+                const task = backgroundManager.requestBackground(harness.session.id);
                 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,
+            runningHint: () => backgroundManager.hasForeground(harness.session.id) ? "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),
@@ -709,6 +745,18 @@ export async function startRepl(deps) {
                 if (result === "quit")
                     input.requestQuit();
             },
+            onCommandDuringRun: async (line, signal) => {
+                const ctl = new Proxy(input, {
+                    get(target, prop, receiver) {
+                        if (prop === "busyCommands")
+                            return true;
+                        const value = Reflect.get(target, prop, receiver);
+                        return typeof value === "function" ? value.bind(target) : value;
+                    },
+                });
+                // Bypass processLine: its finally closes the active turn's inbox.
+                await handleSlash(line === "/" ? "/commands" : line, deps, ctl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, () => { });
+            },
             // Incollo: un path/data-URI immagine diventa "img #N", un testo lungo
             // diventa "txt #N", il resto si inserisce come testo normale.
             onPaste: onPasteInput,
@@ -721,23 +769,28 @@ export async function startRepl(deps) {
                 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");
+                input.write(buildTerminalWelcome(terminalColumns(), theme, accessoNota));
                 if (harness.session.head)
                     replaySession(harness.session, input, theme, terminalColumns());
                 if (deps.resumePicker)
                     void processLine("/resume", input, new AbortController().signal);
             },
             onQuit: () => {
+                kingdomLive.clearAll();
+                review.sessions.conversations.reset();
                 void harness.host.emit("session_shutdown", {});
-                stdout.write("\n");
-                process.exit(0);
+                const esci = () => { stdout.write("\n"); process.exit(0); };
+                // Il telefono deve sapere che la sessione e' finita, senza trattenere l'uscita.
+                if (sessioneRemota())
+                    void Promise.race([fermaRemoto(), new Promise(r => setTimeout(r, 2_000))]).finally(esci);
+                else
+                    esci();
             },
         });
         // Le notify delle estensioni vanno nella regione viva (no corruzione).
         commit = (t) => input.write(t);
+        // Controllo remoto: il telefono scrive e ferma attraverso la barra di input.
+        collegaMani({ invia: (testo, subito) => input.submitExternal(testo, subito), ferma: () => input.requestStop() });
         // 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({
@@ -778,11 +831,21 @@ export async function startRepl(deps) {
         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("✗");
+            if (t.status === "done") {
+                notifyStatus(input, tr("Background {id} completato · /bg {id} per l'output", "Background {id} completed · /bg {id} for output", { id: t.id }));
+                return;
+            }
+            const mark = 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();
+        const unsubscribeStorage = storageHealth.subscribe(() => input.refresh());
+        try {
+            await input.start();
+        }
+        finally {
+            unsubscribeStorage();
+        }
         return;
     }
     // Fallback (non-TTY o TALOS_CLASSIC_INPUT=1): loop readline classico inline.
@@ -790,6 +853,13 @@ export async function startRepl(deps) {
     if (harness.session.head)
         replaySession(harness.session, { write: text => stdout.write(text) }, theme, terminalColumns());
     const rl = readline.createInterface({ input: stdin, output: stdout });
+    const reportStorage = () => {
+        const rows = storageWarning(storageHealth.snapshot(harness.config.sessionDir), terminalColumns(), theme.yellow);
+        if (rows.length)
+            stdout.write("\n" + rows.join("\n") + "\n");
+    };
+    const unsubscribeStorage = storageHealth.subscribe(reportStorage);
+    reportStorage();
     const ctl = {
         review,
         pause: () => rl.pause(),
@@ -826,7 +896,7 @@ export async function startRepl(deps) {
         processLine: (raw, signal) => processLine(raw, ctl, signal),
         prompt,
         requestClose: () => rl.close(),
-        onError: (error) => notifyStatus(ctl, theme.red(`\n  errore: ${error.message}\n`)),
+        onError: (error) => notifyStatus(ctl, theme.red(`\n  ${tr("Errore", "Error")}: ${runtimeError(error.message)}\n`)),
         installAbort: (abort) => {
             const onSigint = () => abort();
             process.once("SIGINT", onSigint);
@@ -848,6 +918,7 @@ export async function startRepl(deps) {
         void lineQueue.enqueue(raw);
     });
     rl.on("close", () => {
+        unsubscribeStorage();
         lineQueue.close();
         harness.dispose?.();
         void harness.host.emit("session_shutdown", {});
@@ -868,15 +939,26 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
     // 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) => {
+    const confirm = async (action, detail, requestSignal = signal) => {
         if (autoApproves(getPermMode(), action))
             return true;
+        // Con il controllo remoto acceso risponde chi arriva prima, TUI o telefono.
+        return permessoConGara(action, detail, requestSignal, (gara) => confirmInTui(action, detail, gara));
+    };
+    const confirmInTui = async (action, detail, requestSignal) => {
         const choice = await selectOption({
-            title: `consenti: ${action}`,
-            hint: detail,
+            signal: requestSignal,
+            title: tr("consenti: {p0}", "Allow: {p0}", { p0: action }),
+            hint: tr("{p0}\nShift+Tab: cambia permessi anche durante la conferma", "{p0}\nShift+Tab: change permissions during confirmation", { p0: detail }),
+            onCycleMode: ctl.cyclePermissionMode ? () => {
+                ctl.cyclePermissionMode();
+                return autoApproves(getPermMode(), action)
+                    ? { label: tr("Consentito dalla modalità corrente", "Allowed by the current mode"), detail: "", value: true }
+                    : undefined;
+            } : undefined,
             options: [
-                { key: "yes", label: "Sì, esegui", detail: "consenti questa azione", value: true },
-                { key: "no", label: "No, annulla", detail: "blocca l'azione", value: false },
+                { key: "yes", label: tr("Sì, esegui", "Yes, run it"), detail: tr("consenti questa azione", "allow this action"), value: true },
+                { key: "no", label: tr("No, annulla", "No, cancel"), detail: tr("blocca l'azione", "block the action"), value: false },
             ],
             currentKey: "yes",
             ctl,
@@ -886,11 +968,12 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
         return choice?.value === true;
     };
     // Domanda all'utente in chat (tool ask_user): opzioni -> picker; libera -> input.
-    const ask = async (question, options) => {
+    const ask = async (question, options, requestSignal = signal) => {
         if (ctl.queueQuestion)
-            return ctl.queueQuestion(question, options, signal);
+            return ctl.queueQuestion(question, options, requestSignal);
         if (options && options.length) {
             const choice = await selectOption({
+                signal: requestSignal,
                 title: question,
                 question: true,
                 options: options.map((o) => ({ label: o, detail: "", value: o })),
@@ -901,15 +984,20 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
             return choice?.value ?? null;
         }
         ctl.write(renderQuestion(question, theme, terminalColumns()));
-        return ctl.promptInput("rispondi qui (Invio conferma · Esc annulla)");
+        return ctl.promptInput(tr("rispondi qui (Invio conferma · Esc annulla)", "Reply here (Enter confirm · Esc cancel)"));
     };
     // 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 onWorkerEvent = (actor, event) => {
+        if (event.type !== "kingdom" && event.type !== "usage")
+            ctl.review?.recordActor(actor, event);
+    };
     const spawnKingdom = async (castles, kopts) => {
         if (kopts?.detach)
             return runKingdomForHost({
-                harness: deps.harness, castles, signal, sink: wrappedSink, confirm, ask, env, detach: true,
+                harness: deps.harness, castles, signal, sink: wrappedSink, confirm, ask, env, detach: true, retainSessions: "queued",
+                onWorkerEvent,
                 ...(kopts.baseBranch ? { baseBranch: kopts.baseBranch } : {}),
             });
         // Obiettivo complessivo del regno: esplicito > goal grezzo del turno.
@@ -941,6 +1029,7 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
             concurrency: conc,
             ask,
             onEvent: live.onEvent,
+            retainSessions: "queued",
             worktree: wt,
             ...(kopts?.baseBranch ? { baseBranch: kopts.baseBranch } : {}),
             onNotice: (text) => notifyStatus(ctl, theme.accent("    ⎇ ") + theme.dim(text) + "\n"),
@@ -1007,6 +1096,7 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
     ctl.setStatus(tr("avvio", "starting"));
     let turnFailed = false;
     const wrappedSink = (event) => {
+        osservaEvento(event);
         if (event.type === "error" || (event.type === "turn_end" && event.stopReason === "error"))
             turnFailed = true;
         ctl.review?.record(event);
@@ -1057,7 +1147,7 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
         const turnInput = imageParts && imageParts.length
             ? [{ type: "text", text: input }, ...imageParts]
             : input;
-        await runTurn({ ...deps.harness.deps(confirm), ask, spawnKingdom, inbox }, turnInput, wrappedSink, signal);
+        await runTurn({ ...deps.harness.deps(confirm), env: { ...env, TALOS_AUTO_TITLE: "1" }, ask, spawnKingdom, onWorkerEvent, inbox }, turnInput, wrappedSink, signal);
         if (turnFailed || signal.aborted)
             return;
         // REVISORE di team: per i task complessi (molte stanze) con stanze fatte e
@@ -1122,8 +1212,14 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
         }
     }
     catch (err) {
-        ctl.review?.record({ type: "error", message: err.message });
-        notifyStatus(ctl, theme.red(`\n  errore: ${err.message}\n`));
+        if (signal.aborted) {
+            ctl.setRoomStatus?.(null);
+            ctl.write(theme.yellow(`\n  ${tr("Interrotto · puoi inviare un nuovo messaggio per continuare.", "Interrupted · send a new message to continue.")}\n`));
+        }
+        else {
+            ctl.review?.record({ type: "error", message: err.message });
+            notifyStatus(ctl, theme.red(`\n  ${tr("Errore", "Error")}: ${runtimeError(err.message)}\n`));
+        }
     }
     finally {
         ctl.review?.finish(signal.aborted);
@@ -1209,7 +1305,7 @@ async function runTeamReviewer(deps, vascend, sdir, sid, ctl, theme, terminalCol
     }
     vascend.loadPlan(sdir, sid);
 }
-export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
+export function makeSink(theme, terminalColumns, cwd, env, ctl, plan, replay = false) {
     let textBuffer = "";
     let assistantSegments = 0;
     let assistantStarted = false;
@@ -1217,6 +1313,11 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
     const writeNotice = (text, failed = false) => {
         notifyStatus(ctl, text, failed);
     };
+    const writeWarning = (text) => {
+        ctl.setRoomStatus?.(null);
+        const rows = wrapText(text, Math.max(8, terminalColumns() - 4));
+        ctl.write("\n" + rows.map(row => theme.yellow(`  ${row}`)).join("\n") + "\n");
+    };
     // Correlazione call->risultato e contenuto PRE-scrittura, per gli avvisi del
     // regno e per il diff dei tool di scrittura.
     const calls = new Map();
@@ -1226,6 +1327,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
     const mcpCards = new Map();
     const toolCards = new Map();
     const skillCards = new Map();
+    const backgroundPolls = 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)
@@ -1281,21 +1383,21 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
         }
         // 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));
+            ctl.setLogLine(liveDot.index, fitLine(" " + theme.muted("◇ ") + 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
+        if (!ctl.setLogLine || replay)
+            return; // Replay has no timers or terminal side effects.
         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));
+            ctl.setLogLine(liveDot.index, fitLine(" " + pulseDot(liveDot.name, liveFrame) + " " + liveDot.tail, terminalColumns() - 1));
         }, 140);
     };
     const beginCommand = () => {
@@ -1304,7 +1406,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
         stopDot();
         ctl.write("\n");
     };
-    return (event) => {
+    const sink = (event) => {
         switch (event.type) {
             case "context_window":
                 ctl.refresh?.();
@@ -1335,7 +1437,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 // 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"));
+                    notifyStatus(ctl, theme.dim(`\n  ${tr("Output al limite del modello: continuo automaticamente…", "Model output limit reached: continuing automatically…")}\n`));
                 }
                 break;
             case "status":
@@ -1344,6 +1446,15 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     break;
                 // Attivita' del modello senza testo (es. streaming di un input grande).
                 ctl.setStatus(event.label);
+                {
+                    const limit = event.label.match(/^Limite sessione di 5 ore raggiunto · reset alle (.+?) · riprendo automaticamente al reset · Esc per annullare$/);
+                    if (limit) {
+                        flushText("final");
+                        const time = limit[1];
+                        writeWarning(tr("Limite della sessione raggiunto · reset alle {time}", "You've hit your session limit · resets {time}", { time }));
+                        writeWarning(tr("Ripresa automatica alle {time} · Esc per annullare", "Continuing automatically at {time} · esc to cancel", { time: time.replace(/\s*\([^)]*\)$/, "") }));
+                    }
+                }
                 break;
             case "text":
                 ctl.setStatus(tr("risposta in corso", "responding"));
@@ -1358,6 +1469,10 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                         parent.child = true;
                 }
                 calls.set(event.call.id, event.call);
+                if (event.call.name === "bash_output") {
+                    ctl.setStatus(tr("leggo output background", "reading background output"));
+                    break;
+                }
                 // 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") {
@@ -1404,7 +1519,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     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.setStatus(tr("Esecuzione comando", "Running command"));
                     ctl.setStatusTool?.(event.call.name);
                     break;
                 }
@@ -1421,11 +1536,11 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     const st = String(event.call.input["status"] ?? "completed");
                     const where = slug === "master" ? "" : `${slug}/`;
                     if (st === "running")
-                        ctl.setRoomStatus?.(`attività ${where}${task} avviata`, "running");
+                        ctl.setRoomStatus?.(taskActivityLabel(`${where}${task}`, "running"), "running");
                     else if (st === "failed")
-                        ctl.setRoomStatus?.(`attività ${where}${task} non riuscita`, "failed");
+                        ctl.setRoomStatus?.(taskActivityLabel(`${where}${task}`, "failed"), "failed");
                     else
-                        ctl.setRoomStatus?.(`attività ${where}${task} completata`, "done");
+                        ctl.setRoomStatus?.(taskActivityLabel(`${where}${task}`, "completed"), "done");
                     break;
                 }
                 // Each operation owns a small separate block. Full data stays in review.
@@ -1438,7 +1553,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 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") {
+                if (!replay && event.call.name === "write_file") {
                     const p = event.call.input["path"];
                     if (typeof p === "string" && p) {
                         const abs = isAbsolute(p) ? p : resolve(cwd, p);
@@ -1454,18 +1569,15 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 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));
+                // Quiet action headers leave the emphasis to results and changed code.
+                const nameRendered = theme.muted(label);
                 // 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);
+                const tail = nameRendered + " " + argRendered;
+                const header = fitLine(" " + theme.muted("◇ ") + tail, terminalColumns() - 1);
+                const index = ctl.logLength();
                 ctl.write(header + "\n");
-                toolCards.set(event.call.id, { end: ctl.logLength(), header });
+                toolCards.set(event.call.id, { index, end: ctl.logLength(), header });
                 if (event.call.name === "ask_user")
                     startDot(ctl.logLength() - 1, event.call.name, tail);
                 break;
@@ -1474,6 +1586,9 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 ctl.setStatus(tr("elaboro", "working"));
                 stopDot(); // ferma l'animazione del bullet: il tool e' finito
                 const call = calls.get(event.result.callId);
+                const before = preContent.get(event.result.callId);
+                calls.delete(event.result.callId);
+                preContent.delete(event.result.callId);
                 const toolCard = toolCards.get(event.result.callId);
                 toolCards.delete(event.result.callId);
                 if (event.parentId) {
@@ -1483,6 +1598,20 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                         parent.isError = event.result.isError;
                     }
                 }
+                if (call?.name === "bash_output") {
+                    const id = String(call.input["id"] ?? call.id);
+                    const snapshot = JSON.stringify([event.result.isError ?? false, event.result.output, event.result.media]);
+                    if (backgroundPolls.get(id) === snapshot)
+                        break;
+                    backgroundPolls.set(id, snapshot);
+                    flushText();
+                    ensureAssistantStarted();
+                    const summary = backgroundResultSummary(event.result.output, terminalColumns());
+                    ctl.write("\n" + fitLine(" " + (event.result.isError ? theme.red("× ") : theme.muted("◇ "))
+                        + theme.muted(toolLabel("bash_output")), terminalColumns() - 1) + "\n"
+                        + theme.dark(" └ ") + (event.result.isError ? theme.red(summary) : theme.dim(summary)) + "\n");
+                    break;
+                }
                 const skillCard = skillCards.get(event.result.callId);
                 if (skillCard) {
                     skillCards.delete(event.result.callId);
@@ -1534,7 +1663,8 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 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;
+                    const retained = !ctl.getLogLine || (ctl.getLogLine(card.index) === card.header
+                        && ctl.getLogLine(card.index + 1) === commandPreview(commandSource(call), theme, card.columns).lines[1]);
                     if (retained)
                         ctl.setLogLine?.(card.index, commandHeader(card.firstRow, state, theme, card.columns));
                     // Parallel calls can complete in a different order. Repeat the
@@ -1548,7 +1678,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     break;
                 }
                 if (call && !event.result.isError && call.name === "write_file") {
-                    ctl.review?.change(call.id, { before: call.input["append"] === true ? "" : preContent.get(call.id),
+                    ctl.review?.change(call.id, { before: call.input["append"] === true ? "" : before,
                         after: String(call.input["content"] ?? ""), scope: call.input["append"] === true ? "append" : "file" });
                 }
                 // Token per stanza/castello (solo con vascend attivo). Snapshot a
@@ -1564,11 +1694,11 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     const st = String(call.input["status"] ?? "completed");
                     const where = slug === "master" ? "" : `${slug}/`;
                     if (st === "running")
-                        ctl.setRoomStatus?.(`attività ${where}${task} avviata`, "running");
+                        ctl.setRoomStatus?.(taskActivityLabel(`${where}${task}`, "running"), "running");
                     else if (st === "failed")
-                        ctl.setRoomStatus?.(`attività ${where}${task} non riuscita`, "failed");
+                        ctl.setRoomStatus?.(taskActivityLabel(`${where}${task}`, "failed"), "failed");
                     else
-                        ctl.setRoomStatus?.(`attività ${where}${task} completata`, "done");
+                        ctl.setRoomStatus?.(taskActivityLabel(`${where}${task}`, "completed"), "done");
                     break;
                 }
                 // Detailed plans are available in the task panel.
@@ -1579,6 +1709,23 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     notifyStatus(ctl, notice);
                     break;
                 }
+                const diff = call && !event.result.isError
+                    ? diffForCall(call, before, event.result.output, theme, terminalColumns())
+                    : undefined;
+                if (diff) {
+                    const retained = Boolean(toolCard && (!ctl.getLogLine || ctl.getLogLine(toolCard.index) === toolCard.header));
+                    // Con un risultato sequenziale trasformiamo Update(path) direttamente
+                    // nell'intestazione finale. Nessun secondo riepilogo "modificato" e
+                    // nessuna intestazione duplicata sopra la diff.
+                    if (toolCard && retained && ctl.setLogLine && toolCard.end === ctl.logLength()) {
+                        ctl.setLogLine(toolCard.index, fitLine(diff.header, terminalColumns() - 1));
+                    }
+                    else {
+                        ctl.write("\n" + fitLine(diff.header, terminalColumns() - 1) + "\n");
+                    }
+                    ctl.write(previewDiff(diff.body, theme, terminalColumns() - 1, diff.hiddenRows));
+                    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())
@@ -1588,18 +1735,22 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 // 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("⎿ ")) +
+                    ctl.write(theme.dark(" └ ") + (event.result.isError ? theme.red("× ") : "") +
                         (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 "session_naming":
+                ctl.setSessionNaming?.(event.phase, event.title);
+                break;
+            case "compacting":
+                stopDot();
+                flushText();
+                ctl.setCompacting?.(true);
+                break;
+            case "compaction_end":
+                ctl.setCompacting?.(false);
+                break;
             case "compacted":
                 stopDot();
                 flushText();
@@ -1635,7 +1786,12 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                         ctl.setLogLine?.(card.index, commandHeader(card.firstRow, "stopped", theme, card.columns));
                 }
                 commandCards.clear();
-                writeNotice(`errore: ${event.message}`, true);
+                if (isUserInterruption(event.message)) {
+                    writeWarning(tr("Interrotto · puoi inviare un nuovo messaggio per continuare.", "Interrupted · send a new message to continue."));
+                }
+                else {
+                    writeNotice(`${tr("Errore", "Error")}: ${runtimeError(event.message)}`, true);
+                }
                 break;
             case "done":
                 for (const card of mcpCards.values()) {
@@ -1654,11 +1810,15 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 // 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"));
+                    notifyStatus(ctl, theme.yellow(`\n  ${tr("Output ancora al limite dopo le continuazioni automatiche: suddividi il compito o aumenta TALOS_MAX_AUTOCONTINUE.", "Output still at the limit after automatic continuations: split the task or increase TALOS_MAX_AUTOCONTINUE.")}\n`));
                 }
                 break;
         }
     };
+    return Object.assign(sink, { preview: () => {
+            const text = stripToolMarkup(textBuffer).trimEnd();
+            return text ? renderAssistantSegment(text, theme, terminalColumns(), { cwd, env }, assistantStarted ? "progress" : "start", assistantSegments + 1) : "";
+        } });
 }
 // Attribuzione token alle stanze + riepilogo per castello (metodo Danilov).
 // All'avvio della stanza (running) salva lo snapshot di outTok; a stanza
@@ -1847,10 +2007,10 @@ function renderVascendToolNotice(call, output, theme, columns) {
         const st = String(call.input["status"] ?? "completed");
         const where = slug === "master" ? "" : `${slug}/`;
         if (st === "running")
-            return renderVascendNotice("start", `attività ${where}${task} avviata`, theme);
+            return renderVascendNotice("start", taskActivityLabel(`${where}${task}`, "running"), theme);
         if (st === "failed")
-            return renderVascendNotice("fail", `attività ${where}${task} non riuscita`, theme);
-        return renderVascendNotice("done", `attività ${where}${task} completata`, theme);
+            return renderVascendNotice("fail", taskActivityLabel(`${where}${task}`, "failed"), theme);
+        return renderVascendNotice("done", taskActivityLabel(`${where}${task}`, "completed"), theme);
     }
     return null;
 }
@@ -1862,26 +2022,26 @@ function diffForCall(call, pre, output, theme, columns) {
         const append = call.input["append"] === true;
         const next = String(call.input["content"] ?? "");
         const existed = (pre ?? "") !== "";
-        const verb = append ? "aggiunto" : existed ? "modificato" : "creato";
+        const verb = append ? tr("aggiunto", "appended") : existed ? tr("modificato", "modified") : tr("creato", "created");
         // 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 });
+        return renderDiffParts(append ? "" : (pre ?? ""), next, theme, { path, verb, columns: columns - 1, wrapLines: true, maxRows: 100 }) ?? undefined;
     }
     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 renderDiffParts(oldS, newS, theme, { path, verb: tr("modificato", "modified"), context: 2, columns: columns - 1, wrapLines: true, maxRows: 100 }) ?? undefined;
     }
-    return "";
+    return undefined;
 }
 // Soglia riferita alle righe del confronto, escluse intestazione e separatore.
-function previewDiff(full, theme, width) {
+function previewDiff(full, theme, width, hiddenRows = 0) {
     const lines = full.replace(/\n$/, "").split("\n");
-    const limit = 100 + 2;
-    if (lines.length <= limit)
+    const limit = 100;
+    if (lines.length <= limit && hiddenRows === 0)
         return full;
     const head = lines.slice(0, limit);
-    const hidden = lines.length - limit;
+    const hidden = Math.max(0, lines.length - limit) + hiddenRows;
     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";
@@ -2061,6 +2221,7 @@ function sessionOptions(list) {
         label: sessionTitle(s.name ?? "") || s.preview || s.id,
         detail: `${fmtAge(s.updatedAt)} · ${s.messages} msg · ${s.id}`,
         value: s.id,
+        age: fmtAge(s.updatedAt),
     }));
 }
 // Riprende una sessione: la carica nell'harness (le closure vedono il nuovo
@@ -2083,115 +2244,6 @@ function resumeInto(harness, vascend, id, ctl, theme, tcols, 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;
@@ -2287,6 +2339,10 @@ function controlCollapsible(ctl, channel, action) {
 // 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) {
+    if (ctl.busyCommands && !liveCommandAllowed(line)) {
+        notifyStatus(ctl, tr("{command}: disponibile a fine turno. Non inviato al modello; attendi o premi Esc per interrompere.", "{command}: available after the turn. Not sent to the model; wait or press Esc to interrupt.", { command: line.split(/\s+/)[0] }));
+        return null;
+    }
     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) {
@@ -2294,6 +2350,12 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
     const args = rest.join(" ");
     const { harness } = deps;
     switch (cmd) {
+        case "skills":
+        case "mcp": {
+            const inventory = cmd === "skills" ? skillList(harness.skills, harness.skillCommandsEnabled) : mcpList(harness.tools);
+            await showReadonlyOverlay({ ...inventory, ctl, theme, terminalColumns });
+            return null;
+        }
         case "review":
         case "revisione": {
             if (ctl.showReview)
@@ -2318,8 +2380,45 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
             return null;
         }
         case "rename": {
-            const title = args.trim();
-            if (!title || title.length > 120) {
+            let title = args.trim();
+            if (!title) {
+                const choice = await selectOption({
+                    title: tr("Rinomina chat", "Rename chat"),
+                    question: true,
+                    options: [
+                        { key: "generate", label: tr("Rigenera dall'ultimo prompt", "Regenerate from the latest prompt"),
+                            detail: tr("Usa il modello selezionato per scegliere il titolo.", "Use the selected model to choose the title."), value: "generate" },
+                        { key: "manual", label: tr("Imposta manualmente", "Set manually"),
+                            detail: tr("Scrivi il nuovo nome della chat.", "Type the new chat name."), value: "manual" },
+                    ],
+                    ctl, theme, terminalColumns,
+                });
+                if (!choice || signal.aborted)
+                    return null;
+                if (choice.value === "manual") {
+                    const entered = await ctl.promptInput(tr("Nome della chat (Invio conferma · Esc annulla)", "Chat name (Enter confirms · Esc cancels)"));
+                    if (!entered?.trim() || signal.aborted)
+                        return null;
+                    title = entered.trim();
+                }
+            }
+            if (!title) {
+                const last = [...harness.session.history()].reverse().find(message => message.role === "user");
+                const prompt = last?.content.filter(part => part.type === "text").map(part => part.text).join(" ") || "";
+                if (!prompt) {
+                    notifyStatus(ctl, "Invia prima un messaggio per generare il titolo.");
+                    return null;
+                }
+                await nameSession(harness.deps(async () => false), prompt, event => {
+                    if (event.type === "usage")
+                        stats.observe?.(event);
+                    if (event.type === "session_naming")
+                        ctl.setSessionNaming?.(event.phase, event.title);
+                }, signal, true);
+                ctl.refresh?.();
+                return null;
+            }
+            if (title.length > 120) {
                 ctl.write(theme.dim("\n  Usa /rename Titolo della chat (da 1 a 120 caratteri).\n"));
                 return null;
             }
@@ -2403,15 +2502,29 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
             // Esegue/riapre il comando scelto come se digitato.
             return handleSlash(`/${selected.value}`, deps, ctl, theme, terminalColumns, themeCtl, templates, vascend, stats, signal, resetSessionUi);
         }
+        case "remote":
+        case "remoto": {
+            await comandoRemoto(args, ctl, theme, harness.env, harness.config.cwd, (testo) => {
+                if (ctl.setRoomStatus)
+                    ctl.setRoomStatus(testo, "done");
+            });
+            return null;
+        }
         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) {
+            // Il controllo remoto si chiude prima: usa la stessa sessione.
+            await fermaRemoto();
+            if (!leggiSessione(harness.env)) {
+                rimuoviTokenVascend(harness.env);
                 ctl.write(theme.dim("\n  nessun accesso Vascend attivo\n"));
                 return null;
             }
-            await revocaSessione(harness.env, token);
+            const { token } = await tokenAgente(harness.env);
+            if (token)
+                await revocaSessione(harness.env, token);
+            await revocaSessioneId(harness.env);
+            rimuoviSessione(harness.env);
             rimuoviTokenVascend(harness.env);
             // Via anche la prova offline: un logout che la lasciasse in giro
             // regalerebbe una finestra offline a chi e' appena uscito.
@@ -2455,7 +2568,10 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
                 await pickModel(harness, ctl, theme, terminalColumns);
                 return null;
             }
-            await applyModelChoice(args, harness, ctl, theme, terminalColumns);
+            if (args.trim().toLowerCase() === "fusion")
+                await pickFusion(harness, ctl, theme, terminalColumns);
+            else
+                await applyModelChoice(args, harness, ctl, theme, terminalColumns);
             return null;
         }
         case "models": {
@@ -2466,22 +2582,22 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
         case "themes": {
             if (args) {
                 if (themeCtl.apply(args)) {
-                    ctl.write(makeTheme(deps.harness.config.ui, themeCtl.spec()).green(`\n  tema impostato: ${args}\n`));
+                    ctl.write(makeTheme(deps.harness.config.ui, themeCtl.spec()).green(("\n  " + tr("tema impostato: {p0}", "Theme set: {p0}", { p0: args }) + "\n")));
                 }
                 else {
-                    ctl.write(theme.yellow(`\n  tema sconosciuto: ${args}`) +
-                        theme.dim(`  disponibili: ${themeCtl.available.map((t) => t.name).join(", ")}\n`));
+                    ctl.write(theme.yellow(("\n  " + tr("tema sconosciuto: {p0}", "Unknown theme: {p0}", { p0: args }))) +
+                        theme.dim(("  " + tr("disponibili: {p0}", "available: {p0}", { p0: 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",
+                detail: t.mode === "light" ? tr("chiaro", "light") : tr("scuro", "dark"),
                 value: t.name,
             }));
             const selected = await selectOption({
-                title: "Temi",
+                title: tr("Temi", "Themes"),
                 options,
                 currentKey: themeCtl.activeName(),
                 ctl,
@@ -2489,7 +2605,7 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
                 terminalColumns,
             });
             if (selected && themeCtl.apply(selected.value)) {
-                ctl.write(makeTheme(deps.harness.config.ui, themeCtl.spec()).green(`\n  tema impostato: ${selected.value}\n`));
+                ctl.write(makeTheme(deps.harness.config.ui, themeCtl.spec()).green(("\n  " + tr("tema impostato: {p0}", "Theme set: {p0}", { p0: selected.value }) + "\n")));
             }
             return null;
         }
@@ -2503,39 +2619,39 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
             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}`));
+            const lines = [theme.bold(("\n  " + tr("Consumi della sessione", "Session usage"))) + theme.dim(` · ${harness.session.name || harness.session.id}`)];
+            lines.push(theme.dim(`    ${sessionUsageExplanation()}`));
             if (stats.incomplete)
-                lines.push(theme.yellow("    Storico parziale: le chiamate precedenti alla registrazione non sono ricostruibili."));
+                lines.push(theme.yellow(("    " + tr("Storico parziale: le chiamate precedenti alla registrazione non sono ricostruibili.", "Partial history: calls made before recording cannot be reconstructed."))));
             if (stats.missing)
-                lines.push(theme.yellow(`    ${stats.missing} chiamate senza conteggio token restituito dal provider.`));
+                lines.push(theme.yellow(("    " + tr("{p0} chiamate senza conteggio token restituito dal provider.", "{p0} calls without token counts reported by the provider.", { p0: stats.missing }))));
             if (stats.unsaved)
-                lines.push(theme.yellow("    Alcuni consumi non sono stati salvati su disco."));
+                lines.push(theme.yellow(("    " + tr("Alcuni consumi non sono stati salvati su disco.", "Some usage records were not saved to disk."))));
             if (snapshot.totalTurns === 0) {
-                lines.push(theme.dim("    Nessun conteggio token ricevuto dal provider per questa sessione."));
+                lines.push(theme.dim(("    " + tr("Nessun conteggio token ricevuto dal provider per questa sessione.", "No token counts received from the provider for this session."))));
             }
             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(("    " + tr("chiamate modello: {p0}", "model calls: {p0}", { p0: formatTokenCount(snapshot.totalTurns) }))));
+                lines.push(theme.silver(("    " + tr("input totale:    {p0}", "total input:     {p0}", { p0: formatTokenCount(snapshot.totalPromptTokens) }))));
+                lines.push(theme.dim(("      " + tr("nuovo:          {p0}", "new:            {p0}", { p0: formatTokenCount(snapshot.totalInputTokens) }))));
+                lines.push(theme.dim(("      " + tr("cache letta:    {p0}", "cache read:     {p0}", { p0: formatTokenCount(snapshot.totalCacheReadTokens) }))));
+                lines.push(theme.dim(("      " + tr("cache scritta:  {p0}", "cache written:  {p0}", { p0: formatTokenCount(snapshot.totalCacheWriteTokens) }))));
                 lines.push(theme.silver(`    output:          ${formatTokenCount(snapshot.totalOutputTokens)}`));
-                lines.push(theme.silver(`    totale provider: ${formatTokenCount(snapshot.totalProviderTokens)}`));
+                lines.push(theme.silver(("    " + tr("totale provider: {p0}", "provider total: {p0}", { p0: 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.bold(("\n  " + tr("ultima chiamata", "last call"))));
+                lines.push(theme.dim(("    " + tr("input {p0} = nuovo {p1} + cache letta {p2} + cache scritta {p3}", "input {p0} = new {p1} + cache read {p2} + cache written {p3}", { p0: formatTokenCount(promptTokens(last)), p1: formatTokenCount(last.inputTokens), p2: formatTokenCount(last.cacheReadTokens ?? 0), p3: 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)"));
+                lines.push(theme.bold(("\n  " + tr("Per modello (collaboratori inclusi quando collegati alla chat)", "Per model (including collaborators linked to the chat)"))));
                 for (const row of snapshot.perModel)
-                    lines.push(theme.dim(`    ${row.modelId}: ${formatTokenCount(promptTokens(row) + row.outputTokens)} token · ${row.turns} chiamate`));
+                    lines.push(theme.dim(("    " + tr("{p0}: {p1} token · {p2} chiamate", "{p0}: {p1} tokens · {p2} calls", { p0: row.modelId, p1: formatTokenCount(promptTokens(row) + row.outputTokens), p2: row.turns }))));
             }
             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(theme.bold(("\n  " + tr("contesto vivo stimato", "estimated active context"))) + theme.dim((" " + tr("· non e' consumo API", "· not API usage"))));
             lines.push(...contextDetails(context).map(line => theme.dim(`    ${line}`)));
             ctl.write(lines.join("\n") + "\n");
             return null;
@@ -2585,10 +2701,10 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
             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"));
+                    ctl.write(theme.dim(("\n  " + tr("nessuna config da chiudere: usa /config", "No configuration view to close: use /config") + "\n\n")));
                 }
                 else if (csub === "close") {
-                    ctl.write(theme.dim("\n  config chiusa (output rimosso dalla chat)\n\n"));
+                    ctl.write(theme.dim(("\n  " + tr("config chiusa (output rimosso dalla chat)", "Configuration closed (output removed from chat)") + "\n\n")));
                 }
                 return null;
             }
@@ -2596,21 +2712,21 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
                 const cfg = harness.config;
                 const resolved = harness.providers.resolve(cfg.model);
                 const provider = resolved
-                    ? (resolved.provider.label ?? resolved.provider.id)
-                    : "non configurato";
+                    ? providerLabel(resolved.provider)
+                    : tr("non configurato", "not configured");
                 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: "model", label: tr("Modello", "Model"), detail: cfg.model, value: "model" },
+                    { key: "provider", label: tr("Provider e accessi", "Providers and sign-ins"), detail: provider, value: "provider" },
+                    { key: "vibe", label: tr("Profilo operativo", "Work profile"), detail: cfg.vibeMode, value: "vibe" },
+                    { key: "theme", label: tr("Tema", "Theme"), 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" },
+                    { key: "sessions", label: tr("Sessioni", "Sessions"), detail: harness.session.id, value: "sessions" },
+                    { key: "extensions", label: tr("Estensioni", "Extensions"), detail: tr("{p0} caricate", "{p0} loaded", { p0: harness.host.inventory().filter((item) => item.loaded).length }), value: "extensions" },
+                    { key: "usage", label: tr("Utilizzo e contesto", "Usage and context"), detail: tr("token provider, cache e finestra viva", "provider tokens, cache and active context"), value: "usage" },
                 ];
                 const selected = await selectOption({
-                    title: "Impostazioni",
-                    hint: "/config details mostra i file di configurazione",
+                    title: tr("Impostazioni", "Settings"),
+                    hint: tr("/config details mostra i file di configurazione", "/config details shows configuration files"),
                     options: settings,
                     fullHeight: true,
                     wide: true,
@@ -2625,22 +2741,22 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
             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`) +
+                : ("    " + tr("nessun file caricato", "no files loaded"));
+            const body = theme.dim(("    " + tr("modello: {p0}", "model: {p0}", { p0: cfg.model }) + "\n")) +
+                theme.dim(`    maxTokens: ${cfg.maxTokens > 0 ? cfg.maxTokens : tr("auto (max del modello)", "auto (model maximum)")}\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(`    skill: ${harness.skills.length}${harness.skillCommandsEnabled ? "" : (" " + tr("(comandi off)", "(commands off)"))}${harness.skills.length ? ` (${harness.skills.map((s) => s.name).join(", ")})` : ""}\n`) +
+                theme.dim(("    " + tr("progetto fidato: {p0}", "trusted project: {p0}", { p0: harness.projectTrusted ? tr("si", "yes") : tr("no (risorse locali non caricate)", "no (local resources not loaded)") }) + "\n")) +
+                theme.bold(("\n  " + tr("tema", "theme") + "\n")) +
+                theme.dim(("    " + tr("attivo: {p0}{p1}", "active: {p0}{p1}", { p0: themeCtl.activeName(), p1: themeCtl.spec() ? ` (${themeCtl.spec()?.mode === "light" ? tr("chiaro", "light") : tr("scuro", "dark")})` : "" }) + "\n")) +
+                theme.dim(("    " + tr("disponibili: {p0}", "available: {p0}", { p0: 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);
+            showCollapsible(ctl, "config", theme.bold(("\n  " + tr("configurazione", "configuration"))) + theme.dim((" " + tr("· /config close per nascondere", "· /config close to hide"))), body);
             return null;
         }
         case "vibe":
@@ -3001,50 +3117,53 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
             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":
+        // Compatta direttamente la cronologia JSON della sessione. Piano e stato
+        // operativo hanno gia i rispettivi store JSON: nessun checkpoint parallelo.
         case "compact": {
             const hasModel = Boolean(harness.providers.resolve(harness.config.model));
+            let feedback = "Nessun modello configurato; contesto conservato.";
+            let failed = false;
             // 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();
+                if (signal.aborted)
+                    controller.abort();
+                signal.addEventListener("abort", onSigint, { once: true });
                 process.once("SIGINT", onSigint);
                 try {
                     const done = await compactNow(harness.deps(async () => false), controller.signal, (e) => {
                         if (e.type === "usage")
                             stats.observe?.(e);
+                        if (e.type === "compacting")
+                            ctl.setCompacting?.(true);
+                        if (e.type === "compaction_end")
+                            ctl.setCompacting?.(false);
                     }, 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`));
+                        feedback = tr("Contesto compattato: ~{before} -> ~{after} token", "Context compacted: ~{before} -> ~{after} tokens", { before: formatTokenCount(before), after: formatTokenCount(after.tokens) });
+                    }
+                    else {
+                        feedback = controller.signal.aborted
+                            ? tr("Compattazione interrotta; contesto conservato.", "Compaction interrupted; context preserved.")
+                            : tr("Nessuna compattazione necessaria; contesto conservato.", "No compaction needed; context preserved.");
                     }
-                    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`));
+                    feedback = tr("Compattazione non riuscita: {detail}", "Compaction failed: {detail}", { detail: runtimeError(err.message) });
+                    failed = true;
                 }
                 finally {
                     process.removeListener("SIGINT", onSigint);
+                    signal.removeEventListener("abort", onSigint);
+                    ctl.setCompacting?.(false);
+                    ctl.setStatus(null);
                 }
             }
-            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`));
+            notifyStatus(ctl, feedback, failed);
             return null;
         }
         case "tree": {
@@ -3200,9 +3319,11 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
                 return null;
             }
             const selected = await selectOption({
-                title: tr("Chat salvate", "Saved chats"),
+                title: "Resume a previous session",
                 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,
+                sessionList: true,
+                fullHeight: true,
                 options: sessionOptions(list).map((option) => ({ ...option,
                     detail: option.detail + (option.value === harness.session.id ? " · " + tr("corrente", "current") : ""),
                 })),
@@ -3400,7 +3521,7 @@ async function loginMenu(harness, ctl, theme, terminalColumns) {
         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",
+            hint: tr("Enter gestisci · digita per cercare · Esc chiudi", "Enter manage · type to search · Esc close"),
             options: rows.map((row) => ({
                 key: row.id,
                 label: row.label,
@@ -3428,7 +3549,7 @@ async function loginMenu(harness, ctl, theme, terminalColumns) {
         }
         const action = await selectOption({
             title: `${row.label} · ${loginStatusLabel(row)}`,
-            hint: row.command ? `comando: ${row.command.join(" ")}` : "",
+            hint: row.command ? tr("comando: {p0}", "command: {p0}", { p0: row.command.join(" ") }) : "",
             options: [
                 {
                     key: "login",
@@ -3462,10 +3583,10 @@ async function loginMenu(harness, ctl, theme, terminalColumns) {
         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`));
+            ctl.write(theme.green(("\n  " + tr("{p0}: accesso rilevato e modelli aggiornati.", "{p0}: sign-in detected and models updated.", { p0: row.label }) + "\n")));
         }
         else if (completed) {
-            ctl.write(theme.yellow(`\n  ${row.label}: il comando e' terminato, ma non trovo ancora una sessione valida.\n`));
+            ctl.write(theme.yellow(("\n  " + tr("{p0}: il comando e' terminato, ma non trovo ancora una sessione valida.", "{p0}: the command finished, but no valid session was found.", { p0: row.label }) + "\n")));
         }
     }
 }
@@ -3474,11 +3595,11 @@ async function runInteractiveLogin(command, harness, ctl, theme) {
     if (!executable)
         return false;
     if (!stdin.isTTY || !stdout.isTTY) {
-        ctl.write(theme.dim(`\n  esegui in un terminale: ${command.join(" ")}\n`));
+        ctl.write(theme.dim(("\n  " + tr("esegui in un terminale: {p0}", "Run in a terminal: {p0}", { p0: 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.write(theme.bold(("\n  " + tr("avvio {p0}", "Starting {p0}", { p0: command.join(" ") }) + "\n")));
+    ctl.write(theme.dim(("  " + tr("completa l'accesso; al termine tornerai automaticamente a Talos.", "Complete sign-in; you will return to Talos automatically.") + "\n\n")));
     ctl.pause();
     ctl.setOverlay(null);
     ctl.setStatus(null);
@@ -3497,7 +3618,7 @@ async function runInteractiveLogin(command, harness, ctl, theme) {
             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`));
+            ctl.write(theme.yellow(("\n  " + tr("login non completato (uscita {p0}). Verifica che `{p1}` sia installato.", "Sign-in incomplete (exit {p0}). Check that `{p1}` is installed.", { p0: code, p1: executable }) + "\n")));
             return false;
         }
         return true;
@@ -3521,13 +3642,13 @@ async function providerMenu(harness, ctl, theme, terminalColumns) {
         const options = rows.map((row) => ({
             key: row.id,
             label: `${row.label}${row.active ? "  ←" : ""}`,
-            detail: `${rowStatusLabel(row)}${row.modelCount ? ` · ${row.modelCount} modelli` : ""}`,
+            detail: `${rowStatusLabel(row)}${row.modelCount ? (" " + tr("· {p0} modelli", "· {p0} models", { p0: row.modelCount })) : ""}`,
             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",
+            title: tr("provider — {p0} configurati su {p1}", "providers — {p0} of {p1} configured", { p0: configured, p1: rows.length }),
+            hint: tr("↑/↓ scegli · Enter apri · digita per cercare · Esc chiudi", "↑/↓ select · Enter open · type to search · Esc close"),
             options,
             ctl,
             theme,
@@ -3563,7 +3684,7 @@ async function providerActions(row, harness, ctl, theme, terminalColumns) {
             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`));
+                    ctl.write(theme.green(("\n  " + tr("{p0}: chiave salvata e provider attivato.", "{p0}: key saved and provider activated.", { p0: fresh.label }) + "\n")));
                 break;
             }
             case "set-endpoint": {
@@ -3582,11 +3703,11 @@ async function providerActions(row, harness, ctl, theme, terminalColumns) {
             }
             case "remove": {
                 const confirmed = await selectOption({
-                    title: `rimuovere la credenziale di ${fresh.label}?`,
-                    hint: "la chiave salvata verra' eliminata dal config",
+                    title: tr("rimuovere la credenziale di {p0}?", "Remove the credential for {p0}?", { p0: fresh.label }),
+                    hint: tr("la chiave salvata verra' eliminata dal config", "The saved key will be deleted from configuration"),
                     options: [
-                        { key: "no", label: "No, mantieni", detail: "", value: false },
-                        { key: "yes", label: "Sì, rimuovi", detail: "", value: true },
+                        { key: "no", label: tr("No, mantieni", "No, keep it"), detail: "", value: false },
+                        { key: "yes", label: tr("Sì, rimuovi", "Yes, remove it"), detail: "", value: true },
                     ],
                     currentKey: "no",
                     ctl,
@@ -3597,10 +3718,10 @@ async function providerActions(row, harness, ctl, theme, terminalColumns) {
                     const res = removeProvider(harness.env, fresh.id);
                     if (res.ok) {
                         harness.reloadProviders();
-                        ctl.write(theme.green(`\n  ${fresh.label}: credenziale rimossa.\n`));
+                        ctl.write(theme.green(("\n  " + tr("{p0}: credenziale rimossa.", "{p0}: credential removed.", { p0: fresh.label }) + "\n")));
                     }
                     else {
-                        ctl.write(theme.yellow(`\n  ${res.error ?? "rimozione non riuscita"}\n`));
+                        ctl.write(theme.yellow(`\n  ${res.error ?? tr("rimozione non riuscita", "removal failed")}\n`));
                     }
                     return "back";
                 }
@@ -3613,28 +3734,28 @@ async function providerActions(row, harness, ctl, theme, terminalColumns) {
 // 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)`);
+    const key = await ctl.promptInput(tr("API key per {p0} (Invio conferma · Esc annulla)", "API key for {p0} (Enter confirm · Esc cancel)", { p0: row.label }));
     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"));
+        ctl.write(theme.yellow(("\n  " + tr("attenzione: la chiave non sembra una OpenRouter key (sk-or-...). Provo comunque.", "Warning: the key does not look like an OpenRouter key (sk-or-...). Trying anyway.") + "\n")));
     }
     // Validazione di rete (oggi solo OpenRouter espone /key). Best effort.
     if (row.id === "openrouter") {
-        ctl.setStatus(theme.dim("verifico la chiave su OpenRouter…"));
+        ctl.setStatus(theme.dim(tr("verifico la chiave su OpenRouter…", "Checking the key on 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`));
+                ctl.write(theme.yellow(("\n  " + tr("chiave non valida: {p0}. Non salvata.", "Invalid key: {p0}. Not saved.", { p0: v.error ?? tr("verifica fallita", "verification failed") }) + "\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`));
+                ? tr("credito illimitato", "unlimited credit")
+                : tr("credito residuo {p0}", "remaining credit {p0}", { p0: v.limitRemaining.toFixed(2) });
+            ctl.write(theme.green(("\n  " + tr("chiave valida{p0} · {p1}", "valid key{p0} · {p1}", { p0: v.label ? ` (${v.label})` : "", p1: credit }) + "\n")));
         }
         catch {
             ctl.setStatus(null);
@@ -3642,7 +3763,7 @@ async function setKeyFlow(row, harness, ctl, theme) {
     }
     const res = saveProviderKey(harness.env, row.id, trimmed);
     if (!res.ok) {
-        ctl.write(theme.yellow(`\n  ${res.error ?? "salvataggio non riuscito"}\n`));
+        ctl.write(theme.yellow(`\n  ${res.error ?? tr("salvataggio non riuscito", "save failed")}\n`));
         return false;
     }
     // La env scoped serve a reloadProviders (che la rilegge dal disco), ma la
@@ -3654,13 +3775,13 @@ async function setKeyFlow(row, harness, ctl, theme) {
 }
 // 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)`);
+    ctl.write(theme.dim(("\n  " + tr("endpoint attuale: {p0}  ·  vuoto = ripristina default", "Current endpoint: {p0}  ·  empty = restore default", { p0: row.baseUrl ?? tr("(default del provider)", "(provider default)") }) + "\n")));
+    const url = await ctl.promptInput(tr("baseUrl per {p0} (Invio conferma · Esc annulla)", "baseUrl for {p0} (Enter confirm · Esc cancel)", { p0: row.label }));
     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`));
+        ctl.write(theme.yellow(`\n  ${res.error ?? tr("salvataggio non riuscito", "save failed")}\n`));
         return;
     }
     const norm = row.id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
@@ -3669,26 +3790,26 @@ async function setEndpointFlow(row, harness, ctl, theme) {
     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`));
+    ctl.write(theme.green(("\n  " + tr("{p0}: endpoint {p1}.", "{p0}: endpoint {p1}.", { p0: row.label, p1: url.trim() ? tr("aggiornato", "updated") : tr("ripristinato al default", "restored to 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);
+        transientNotice(ctl, tr("OAuth non disponibile per questo provider.", "OAuth is not available for this 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…";
+    let authState = tr("avvio il server locale…", "Starting the local server…");
     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.");
+            lines.push("", tr("Se il browser non si apre, copia questo link:", "If the browser does not open, copy this link:"), authUrl);
+        lines.push("", tr("Questa schermata si chiudera' automaticamente.", "This screen will close automatically."));
         ctl.setOverlay([
-            theme.bold("  OpenRouter · accesso via browser"),
+            theme.bold(("  " + tr("OpenRouter · accesso via browser", "OpenRouter · browser sign-in"))),
             theme.dark(`  ${"─".repeat(Math.max(12, terminalColumns() - 4))}`),
             ...lines.flatMap((line) => wrapPlain(line || " ", Math.max(20, terminalColumns() - 4)))
                 .map((line) => `  ${theme.silver(line)}`),
@@ -3699,19 +3820,19 @@ async function oauthFlow(row, harness, ctl, theme, terminalColumns) {
         switch (ev.phase) {
             case "url_built":
                 authUrl = ev.detail ?? authUrl;
-                authState = "apro il browser per autorizzare…";
+                authState = tr("apro il browser per autorizzare…", "Opening the browser for authorization…");
                 break;
             case "browser_opened":
-                authState = "browser aperto · in attesa dell'autorizzazione…";
+                authState = tr("browser aperto · in attesa dell'autorizzazione…", "Browser opened · waiting for authorization…");
                 break;
             case "browser_failed":
-                authState = "apri il link manualmente · in attesa dell'autorizzazione…";
+                authState = tr("apri il link manualmente · in attesa dell'autorizzazione…", "Open the link manually · waiting for authorization…");
                 break;
             case "awaiting_code":
-                authState = "in attesa dell'autorizzazione nel browser…";
+                authState = tr("in attesa dell'autorizzazione nel browser…", "Waiting for authorization in the browser…");
                 break;
             case "exchanging":
-                authState = "autorizzazione ricevuta · attivo la API key…";
+                authState = tr("autorizzazione ricevuta · attivo la API key…", "Authorization received · activating the API key…");
                 break;
             default:
                 break;
@@ -3742,20 +3863,20 @@ async function oauthFlow(row, harness, ctl, theme, terminalColumns) {
             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);
+            transientNotice(ctl, tr("OpenRouter collegato e attivato", "OpenRouter connected and activated"), "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 reason = result.error ?? tr("callback automatico non riuscito", "automatic callback failed");
         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",
+                    title: tr("OpenRouter · autorizzazione manuale", "OpenRouter · manual authorization"),
                     lines: manualLines,
                     ctl,
                     theme,
@@ -3763,25 +3884,25 @@ async function oauthFlow(row, harness, ctl, theme, terminalColumns) {
                 });
                 return ctl.promptInput(label);
             },
-        }, manualFlow, { reason });
+        }, manualFlow, { reason, translate: tr });
         if (!manual.ok || !manual.apiKey) {
             if (manual.error === "cancelled") {
-                transientNotice(ctl, "OAuth annullato", "done", theme);
+                transientNotice(ctl, tr("OAuth annullato", "OAuth cancelled"), "done", theme);
             }
             else {
-                transientNotice(ctl, `OAuth non riuscito: ${manual.error ?? "scambio fallito"}`, "failed", theme);
+                transientNotice(ctl, tr("OAuth non riuscito: {p0}", "OAuth failed: {p0}", { p0: manual.error ?? tr("scambio fallito", "exchange failed") }), "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);
+        transientNotice(ctl, tr("OpenRouter collegato e attivato", "OpenRouter connected and activated"), "done", theme);
     }
     catch (err) {
         ctl.setStatus(null);
         ctl.setOverlay(null);
-        transientNotice(ctl, `errore OAuth: ${err.message}`, "failed", theme);
+        transientNotice(ctl, tr("errore OAuth: {p0}", "OAuth error: {p0}", { p0: err.message }), "failed", theme);
     }
 }
 function transientNotice(ctl, label, state, theme) {
@@ -3794,18 +3915,22 @@ async function pickModel(harness, ctl, theme, terminalColumns) {
         .filter((row) => !row.configured || row.needsRefresh)
         .map((row) => ({
         key: `access:${row.id}`,
-        label: `${row.needsRefresh ? "Rinnova" : "Collega"}  ${row.label}`,
+        label: `${row.needsRefresh ? tr("Rinnova", "Renew") : tr("Collega", "Connect")}  ${row.label}`,
         detail: `${loginStatusLabel(row)} · ${row.detail}`,
         value: { providerId: `access:${row.id}`, modelId: "", fullModel: `access:${row.id}` },
     }));
-    const options = [...accessOptions, ...modelOptions(providers, dynamic)];
+    const options = [{ key: "fusion", label: "Fusion",
+            detail: tr("Jev decide (modello, focus, permessi), l'agente esegue · piani a pagamento", "Jev decides (model, focus, permissions), the agent executes · paid plans"),
+            value: { providerId: "fusion", modelId: "", fullModel: "fusion" } }, ...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"));
+        ctl.write(theme.yellow(("\n  " + tr("nessun provider configurato. Usa /login per collegare un abbonamento o una API key.", "No provider configured. Use /login to connect a subscription or an API key.") + "\n")));
         return false;
     }
     const current = canonicalModel(harness.config.model);
     const selected = await selectOption({
-        title: "Modelli",
+        title: tr("Modelli", "Models"),
+        modelList: true,
+        fullHeight: true,
         options,
         currentKey: current?.fullModel,
         ctl,
@@ -3815,6 +3940,8 @@ async function pickModel(harness, ctl, theme, terminalColumns) {
     });
     if (!selected)
         return false;
+    if (selected.value.providerId === "fusion")
+        return pickFusion(harness, ctl, theme, terminalColumns);
     if (selected.value.providerId.startsWith("access:")) {
         await loginMenu(harness, ctl, theme, terminalColumns);
         return false;
@@ -3827,15 +3954,15 @@ async function pickModel(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.yellow(("\n  " + tr("nessun metodo di accesso configurato per {p0}.", "No sign-in method configured for {p0}.", { p0: 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",
+        title: tr("metodo accesso", "sign-in method"),
+        hint: tr("↑/↓ muovi  Enter conferma  Esc/q annulla", "↑/↓ move  Enter confirm  Esc/q cancel"),
         options,
         currentKey: harness.config.model,
         ctl,
@@ -3862,7 +3989,9 @@ function modelOptions(providers, dynamic) {
             const detail = dynById.get(model)?.detail;
             out.push({
                 key: full,
-                label: `${spec.label}  ${model}`,
+                label: model,
+                group: spec.label,
+                modelInfo: dynById.get(model)?.modelInfo,
                 detail: `${authSummary(spec.id, authProviders)}${detail ? ` · ${detail}` : ""}`,
                 value: { providerId: spec.id, modelId: model, fullModel: full },
             });
@@ -3881,10 +4010,11 @@ async function loadDynamicModels(providers, ctl, theme, env) {
             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) })));
+            .map(m => ({ id: m.id, detail: modelDetail(m), modelInfo: { context: m.context,
+                reasoning: m.reasoning, cost: m.cost } })));
     }
     if (providers.some((p) => p.id === "openrouter")) {
-        ctl.setStatus(theme.dim("carico catalogo OpenRouter…"));
+        ctl.setStatus(theme.dim(tr("carico catalogo OpenRouter…", "Loading the OpenRouter catalog…")));
         try {
             const models = await fetchOpenRouterModels(env);
             if (models.length) {
@@ -3910,7 +4040,7 @@ function authOptions(choice, providers) {
         .map((provider) => ({
         key: `${provider.id}/${choice.modelId}`,
         label: authLabel(choice.providerId, provider.id),
-        detail: provider.label ?? provider.id,
+        detail: providerLabel(provider),
         value: `${provider.id}/${choice.modelId}`,
     }));
 }
@@ -3926,14 +4056,14 @@ function authProviderIds(providerId) {
 }
 function authLabel(canonicalProviderId, actualProviderId) {
     if (canonicalProviderId === "anthropic" && actualProviderId === "claude-code")
-        return "OAuth abbonamento";
+        return tr("OAuth abbonamento", "OAuth subscription");
     if (canonicalProviderId === "anthropic" && actualProviderId === "anthropic")
         return "API key";
     if (canonicalProviderId === "openai" && actualProviderId === "chatgpt")
-        return "OAuth abbonamento";
+        return tr("OAuth abbonamento", "OAuth subscription");
     if (canonicalProviderId === "openai" && actualProviderId === "openai")
         return "API key";
-    return actualProviderId === "ollama" ? "locale" : "API key";
+    return actualProviderId === "ollama" ? tr("locale", "local") : "API key";
 }
 function authSummary(providerId, providers) {
     return providers.map((provider) => authLabel(providerId, provider.id)).join(" / ");
@@ -3965,11 +4095,11 @@ function canonicalProviderId(providerId) {
 }
 function authHint(providerId) {
     if (providerId === "anthropic")
-        return "  Configura CLAUDE_CODE OAuth con `claude` oppure ANTHROPIC_API_KEY.";
+        return ("  " + tr("Configura CLAUDE_CODE OAuth con `claude` oppure ANTHROPIC_API_KEY.", "Configure CLAUDE_CODE OAuth with `claude` or ANTHROPIC_API_KEY."));
     if (providerId === "openai")
-        return "  Configura ChatGPT OAuth con `codex` oppure OPENAI_API_KEY.";
+        return ("  " + tr("Configura ChatGPT OAuth con `codex` oppure OPENAI_API_KEY.", "Configure ChatGPT OAuth with `codex` or OPENAI_API_KEY."));
     const spec = PROVIDER_CATALOG.find((item) => item.id === providerId);
-    return spec?.envKey ? `  Configura ${spec.envKey}.` : "  Verifica la configurazione del provider.";
+    return spec?.envKey ? ("  " + tr("Configura {p0}.", "Configure {p0}.", { p0: spec.envKey })) : ("  " + tr("Verifica la configurazione del provider.", "Check the provider configuration."));
 }
 function unique(values) {
     return [...new Set(values)];
@@ -3997,7 +4127,7 @@ async function showReadonlyOverlay(opts) {
             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.theme.dark(`  ${allLines.length > pageSize() ? `${tr("↑/↓ scorri", "↑/↓ scroll")} · ${offset + 1}-${Math.min(offset + pageSize(), allLines.length)}/${allLines.length} · ` : ""}${tr("Esc/Invio/q chiude", "Esc/Enter/q closes")}`),
         ];
         opts.ctl.setOverlay(rows);
     };