@vascend/talos 0.1.5 → 0.1.6

package/dist/tui/branding.js

@@ -3,11 +3,12 @@ import { renderMarkdown } from "./markdown.js";
 import { tokenAnsi } from "./theme.js";
 import { fitLine, padLine, plainText, wrapText as wrapTerminalText } from "./terminal-text.js";
 import { createAttachmentHighlighter } from "./attachment-highlight.js";
+import { tr } from "./i18n.js";
 const RESET = "\x1b[0m";
 const SILVER = "\x1b[38;2;210;214;220m";
 const DARK_SILVER = "\x1b[38;2;104;111;122m";
 const CHAT_TEXT = "\x1b[38;2;232;235;239m";
-const CHAT_BG = "\x1b[48;2;29;41;56m";
+const CHAT_BG = "\x1b[48;2;43;43;43m";
 const ANSI = {
     blue: "\x1b[34m",
     cyan: "\x1b[36m",
@@ -94,7 +95,10 @@ export function makeTheme(ui, spec) {
                 const code = `${composerBg}${fg("userMessageText")}`;
                 return wrap(code, s.replace(/\x1b\[0m/g, RESET + code));
             },
-            selected: (s) => wrap(`${bg("selectedBg")}${fg("text")}\x1b[1m`, s),
+            selected: (s) => {
+                const code = `${bg("selectedBg")}${fg("text")}\x1b[1m`;
+                return wrap(code, s.replace(/\x1b\[0m/g, RESET + code));
+            },
             dark: (s) => wrap(fg("muted"), s),
             diffAdded: (s) => wrap(`${bg("toolDiffAddedBg")}${fg("toolDiffAdded")}`, s),
             diffBorder: (s) => wrap(fg("toolDiffBorder"), s),
@@ -201,7 +205,7 @@ export function renderAssistantSegment(text, theme, columns, imageCtx, _kind = "
     ].join("\n") + "\n";
 }
 export function renderAssistantTurnEnd(theme, sequence, status = "completed") {
-    return status === "error" ? theme.red("  × Risposta interrotta\n") : "";
+    return status === "error" ? theme.red(`  × ${tr("Risposta interrotta", "Response interrupted")}\n`) : "";
 }
 // Compatibilita' con i renderer esterni: una chat box isolata e' una risposta
 // completa, mentre il REPL usa renderAssistantSegment per la gerarchia live.
@@ -332,7 +336,7 @@ export function renderUserMessage(text, theme, columns, label) {
         const start = source.indexOf(line, offset);
         const highlighted = highlight(line, start);
         offset = start + line.length;
-        return " " + theme.chatText(padLine((index === 0 ? "› " : "  ") + highlighted, width));
+        return " " + theme.chatText((index === 0 ? "› " : "  ") + highlighted + " ");
     }).join("\n") + "\n";
 }
 // Badge di un'immagine allegata, stile artifact Claude Code: un riquadro con

package/dist/tui/capability-lists.d.ts

@@ -0,0 +1,10 @@
+import type { Skill } from "../skills/skills.js";
+import type { ToolRegistry } from "../tools/registry.js";
+export declare function skillList(skills: readonly Skill[], commandsEnabled: boolean): {
+    title: string;
+    lines: string[];
+};
+export declare function mcpList(tools: ToolRegistry): {
+    title: string;
+    lines: string[];
+};

package/dist/tui/capability-lists.js

@@ -0,0 +1,41 @@
+import { plainText } from "./terminal-text.js";
+import { tr } from "./i18n.js";
+const line = (value) => plainText(value).replace(/\s+/g, " ").trim();
+export function skillList(skills, commandsEnabled) {
+    const lines = [];
+    if (!skills.length)
+        lines.push(tr("Nessuna skill caricata in questa sessione.", "No skills loaded in this session."));
+    else if (!commandsEnabled)
+        lines.push(tr("I comandi delle skill sono disabilitati.", "Skill commands are disabled."));
+    for (const skill of [...skills].sort((a, b) => a.name.localeCompare(b.name))) {
+        lines.push("", line(skill.name), `  ${line(skill.description)}`, `  ${line(skill.path)}`);
+        if (commandsEnabled)
+            lines.push(`  /skill:${skill.name}`);
+        if (skill.disableModelInvocation)
+            lines.push("  " + tr("Solo invocazione manuale", "Manual invocation only"));
+    }
+    return { title: tr("Skill disponibili ({count})", "Available skills ({count})", { count: skills.length }), lines };
+}
+export function mcpList(tools) {
+    const servers = new Map();
+    // Read the full runtime registry, including deferred tools. Registration
+    // does not imply that a remote server is reachable or authenticated.
+    for (const name of tools.names()) {
+        const match = /^mcp__(.+?)__(.+)$/.exec(name) ?? /^([\w-]+)\.([\w.-]+)$/.exec(name);
+        if (!match)
+            continue;
+        const entries = servers.get(match[1]) ?? [];
+        entries.push({ name: match[2], description: tools.get(name)?.description ?? "" });
+        servers.set(match[1], entries);
+    }
+    const lines = [servers.size
+            ? tr("Strumenti registrati nella sessione; lo stato della connessione non viene verificato.", "Tools registered in this session; connection status is not checked.")
+            : tr("Nessun server MCP con strumenti registrati in questa sessione.", "No MCP servers with registered tools in this session.")];
+    for (const [server, entries] of [...servers].sort(([a], [b]) => a.localeCompare(b))) {
+        lines.push("", tr("{name} ({count} strumenti)", "{name} ({count} tools)", { name: line(server), count: entries.length }));
+        for (const tool of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`  ${line(tool.name)}`, ...(tool.description ? [`    ${line(tool.description)}`] : []));
+        }
+    }
+    return { title: tr("Server MCP ({count})", "MCP servers ({count})", { count: servers.size }), lines };
+}

package/dist/tui/command-output-registry.js

@@ -11,9 +11,12 @@ import { BUILTIN_COMMANDS } from "./commands.js";
 // Inventario completo: una voce per ciascun comando builtin canonico.
 // Classificazione derivata dall'analisi dei case di dispatch in repl.ts.
 const ENTRIES = [
+    { name: "skills", category: "sistema", output: "navigable", mechanism: "panel", argDependent: false, longOutput: true, note: "skill caricate, descrizioni, percorsi e comandi in un pannello temporaneo" },
+    { name: "mcp", category: "sistema", output: "navigable", mechanism: "panel", argDependent: false, longOutput: true, note: "server e strumenti MCP registrati, inclusi quelli on demand" },
     { name: "fast", category: "modello", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "imposta o mostra Fast; indicatore accanto al modello" },
     { name: "queue", category: "interfaccia", output: "navigable", mechanism: "live-viewer", argDependent: false, longOutput: true, note: "gestione immediata dei messaggi in attesa, modifica e momento di consegna" },
     { name: "review", category: "interfaccia", output: "navigable", mechanism: "live-viewer", argDependent: true, longOutput: true, note: "schermata dedicata con sezioni, ricerca e dettaglio per operazione; Ctrl+R anche durante il run" },
+    { name: "agents", category: "interfaccia", output: "navigable", mechanism: "live-viewer", argDependent: false, longOutput: true, note: "selettore delle sessioni degli agenti; stessa vista accessibile con Alt+A" },
     { name: "help", category: "sistema", output: "navigable", mechanism: "picker", argDependent: false, longOutput: false, note: "palette comandi temporanea, Esc chiude senza lasciare testo" },
     { name: "copy", category: "interfaccia", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "copia testo negli appunti locali; conferma solo se il helper riesce" },
     { name: "rename", category: "sessione", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "salva un titolo della chat; errore di sintassi se assente" },
@@ -44,6 +47,7 @@ const ENTRIES = [
     { name: "resume", category: "sessione", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "picker sessioni se senza arg; azione diretta se passato id" },
     { name: "new", category: "sessione", output: "none", mechanism: "action", argDependent: false, longOutput: false, note: "crea una sessione nuova e vuota (alias /clear); azzera il contesto" },
     { name: "language", category: "interfaccia", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "sceglie la lingua o segue il sistema; preferenza persistita" },
+    { name: "remote", category: "sistema", output: "static", mechanism: "inline-text", argDependent: true, longOutput: false, note: "accende il controllo remoto e scrive in chat il link di abbinamento; status e off rispondono con una riga" },
     { name: "logout", category: "sistema", output: "transient", mechanism: "notice", argDependent: false, longOutput: false, note: "revoca best-effort sul backend + rimozione del token locale; una riga di conferma" },
     { name: "quit", category: "sistema", output: "none", mechanism: "action", argDependent: false, longOutput: false, note: "esce, nessun output" },
 ];

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

@@ -3,7 +3,7 @@ import type { TuiTheme } from "./branding.js";
 export type CommandState = "running" | "ok" | "error" | "background" | "stopped";
 export declare function commandSource(call: Pick<ToolCallPart, "name" | "input">): string | undefined;
 export declare function highlightCommand(source: string, t: TuiTheme): string;
-export declare function commandHeader(firstRow: string, state: CommandState, t: TuiTheme, columns: number): string;
+export declare function commandHeader(_firstRow: string, state: CommandState, t: TuiTheme, columns: number): string;
 export declare function commandPreview(source: string, t: TuiTheme, columns: number, state?: CommandState): {
     firstRow: string;
     lines: string[];

package/dist/tui/command-transcript.js

@@ -41,13 +41,13 @@ export function highlightCommand(source, t) {
 function label(state, columns) {
     return columns < 40
         ? ({ running: "…", ok: "OK", error: "×", background: "BG", stopped: "–" })[state].padEnd(2)
-        : ({ running: tr("Esegue", "Running"), ok: tr("Eseguito", "Executed"), error: tr("Errore", "Error"),
-            background: tr("Avviato", "Started"), stopped: tr("Fermato", "Stopped") })[state].padEnd(8);
+        : ({ running: tr("Esegue comando", "Running command"), ok: tr("Comando eseguito", "Ran command"), error: tr("Errore comando", "Command failed"),
+            background: tr("Comando avviato", "Command started"), stopped: tr("Comando fermato", "Command stopped") })[state];
 }
-export function commandHeader(firstRow, state, t, columns) {
-    const color = state === "ok" ? t.green : state === "error" ? t.red : state === "stopped" ? t.yellow : t.accent;
-    return fitLine("  " + color(state === "error" ? "× " : "● ") + t.bold(label(state, columns)) + " "
-        + highlightCommand(firstRow, t), Math.max(1, columns - 1));
+export function commandHeader(_firstRow, state, t, columns) {
+    const color = state === "error" ? t.red : state === "stopped" ? t.yellow : t.muted;
+    return fitLine(" " + color(state === "error" ? "× " : state === "running" ? "◇ " : "◆ ")
+        + t.bold(color(label(state, columns))), Math.max(1, columns - 1));
 }
 function moreRows(count, t, width) {
     const full = tr("… +{count} righe · Ctrl+R dettagli", "… +{count} lines · Ctrl+R details", { count });
@@ -56,30 +56,26 @@ function moreRows(count, t, width) {
 }
 export function commandPreview(source, t, columns, state = "running") {
     const width = Math.max(2, columns - 1);
-    const prefix = columns < 40 ? "    " : "    │ ";
+    const prefix = " │ ";
     const bodyWidth = Math.max(2, width - terminalWidth(prefix));
-    const firstWidth = Math.max(2, width - terminalWidth("  ● " + label(state, columns) + " "));
-    const sourceRows = plainText(source).trimEnd().split("\n");
-    const firstLine = sourceRows.shift() || tr("(comando vuoto)", "(empty command)");
-    const firstRow = fitLine(firstLine, firstWidth, false);
-    const firstPlain = plainText(firstRow);
-    const rest = firstLine.slice(firstPlain.length);
-    const rows = [...(rest ? wrapText(rest, bodyWidth) : []), ...sourceRows.flatMap(row => wrapText(row, bodyWidth))];
-    const lines = [commandHeader(firstPlain, state, t, columns),
-        ...rows.slice(0, PREVIEW_ROWS - 1).map(row => t.dim(prefix) + highlightCommand(row, t))];
-    if (rows.length >= PREVIEW_ROWS)
-        lines.push(t.dim(prefix) + moreRows(rows.length - PREVIEW_ROWS + 1, t, bodyWidth));
-    return { firstRow: firstPlain, lines };
+    const sourceRows = plainText(source).trimEnd() || tr("(comando vuoto)", "(empty command)");
+    const rows = wrapText(sourceRows, bodyWidth);
+    const firstRow = rows[0] ?? "";
+    const lines = [commandHeader(firstRow, state, t, columns),
+        ...rows.slice(0, PREVIEW_ROWS).map(row => t.dim(prefix) + t.muted(row))];
+    if (rows.length > PREVIEW_ROWS)
+        lines.push(t.dim(prefix) + moreRows(rows.length - PREVIEW_ROWS, t, bodyWidth));
+    return { firstRow, lines: lines.map(row => fitLine(row, width)) };
 }
 export function commandOutput(output, t, columns, isError = false) {
     const width = Math.max(2, columns - 1);
-    const prefix = columns < 40 ? "    " : "    │ ";
+    const prefix = " │ ";
     const bodyWidth = Math.max(2, width - terminalWidth(prefix));
     const rows = wrapText(plainText(output).trim() || tr("(nessun output)", "(no output)"), bodyWidth);
     const shown = rows.slice(0, PREVIEW_ROWS);
     const more = rows.length - shown.length;
     return [...shown.map((row, index) => {
-            const gutter = !more && index === shown.length - 1 && columns >= 40 ? "    └ " : prefix;
+            const gutter = !more && index === shown.length - 1 ? " └ " : prefix;
             return t.dim(gutter) + (isError ? t.red(row) : t.dim(row));
         }), ...(more ? [t.dim(prefix) + moreRows(more, t, bodyWidth)] : [])].map(row => fitLine(row, width));
 }

package/dist/tui/commands.js

@@ -21,6 +21,8 @@ export const CATEGORY_ORDER = [
 ];
 // Comandi slash builtin (per autocomplete, help navigabile, suggerimenti).
 export const BUILTIN_COMMANDS = [
+    { name: "skills", hint: "", get desc() { return tr("Elenca le skill disponibili e come richiamarle", "List available skills and how to invoke them"); }, category: "sistema" },
+    { name: "mcp", hint: "", get desc() { return tr("Elenca i server MCP e gli strumenti della sessione", "List MCP servers and session tools"); }, category: "sistema" },
     { name: "help", hint: "", get desc() { return tr("Sfoglia i comandi con frecce o mouse", "Browse commands with arrow keys or the mouse"); }, category: "sistema" },
     { name: "copy", hint: "[testo]", get desc() { return tr("Copia l’ultima risposta o il testo indicato", "Copy the last response or the specified text"); }, category: "interfaccia" },
     { name: "queue", hint: "", get desc() { return tr("Gestisci la coda · Alt+Q; da 3 richieste, Alt+T invia al team", "Manage queued messages; Alt+Q; Alt+T sends 3 or more requests to a team"); }, category: "interfaccia", aliases: ["coda"] },
@@ -40,7 +42,7 @@ export const BUILTIN_COMMANDS = [
     { name: "language", hint: "[system|it|en|es|de]", get desc() { return tr("Scegli la lingua dell'interfaccia o segui il sistema", "Choose the interface language or follow the system"); }, category: "interfaccia", aliases: ["lang", "lingua", "idioma", "sprache"] },
     { name: "review", hint: "[attivita|modifiche|team|problemi]", get desc() { return tr("Esamina attività e modifiche · Ctrl+R", "Review tasks and changes; Ctrl+R"); }, category: "interfaccia", aliases: ["revisione"] },
     { name: "agents", hint: "", get desc() { return tr("Sessioni degli agenti · Alt+A", "Agent sessions; Alt+A"); }, category: "interfaccia", aliases: ["agenti"] },
-    { name: "compact", hint: "[istruzioni]", get desc() { return tr("Compatta conservando obiettivo, attivita aperte e lavoro recente; salva un checkpoint", "Compact while preserving the goal, open tasks and recent work; save a checkpoint"); }, category: "vascend", aliases: ["vascend-compact"] },
+    { name: "compact", hint: "[istruzioni]", get desc() { return tr("Compatta la cronologia JSON conservando obiettivo, attivita aperte e lavoro recente", "Compact the JSON session history while preserving the goal, open tasks and recent work"); }, category: "vascend" },
     { name: "vascend", hint: "[on|off|goal]", get desc() { return tr("Configura il metodo di lavoro Vascend", "Configure the Vascend workflow"); }, category: "vascend" },
     { name: "todo", hint: "", get desc() { return tr("Lista delle attività: da fare, in corso, completate e fallite · Ctrl+G", "Task list: pending, running, completed and failed; Ctrl+G"); }, category: "attivita", aliases: ["piano", "tasks", "attivita", "regno", "castello", "castelli"] },
     { name: "collaboratori", hint: "<attività1; attività2; ...>", get desc() { return tr("Assegna attività a collaboratori in parallelo", "Assign parallel tasks to collaborators"); }, category: "attivita", aliases: ["kingdoms", "warm"] },
@@ -55,6 +57,7 @@ export const BUILTIN_COMMANDS = [
     { name: "sessions", hint: "[close]", get desc() { return tr("elenco sessioni salvate (collassabile, /sessions close lo nasconde)", "List saved sessions; /sessions close hides the list"); }, category: "sessione" },
     { name: "resume", hint: "[id]", get desc() { return tr("Cerca e riapri le chat salvate", "Find and reopen saved chats"); }, category: "sessione", aliases: ["chats"] },
     { name: "new", hint: "", get desc() { return tr("Apri una chat vuota; la precedente resta salvata", "Start an empty chat; the previous chat stays saved"); }, category: "sessione", aliases: ["clear"] },
+    { name: "remote", hint: "[status|off]", get desc() { return tr("controlla questa sessione dal telefono: /remote, /remote status, /remote off", "Control this session from your phone: /remote, /remote status, /remote off"); }, category: "sistema", aliases: ["remoto"] },
     { name: "logout", hint: "", get desc() { return tr("esci dall'account Vascend (al prossimo avvio serve di nuovo l'accesso)", "Sign out of Vascend; sign-in is required on the next start"); }, category: "sistema" },
     { name: "quit", hint: "", get desc() { return tr("esci", "Exit Talos"); }, category: "sistema", aliases: ["exit"] },
 ];

package/dist/tui/compaction-status.d.ts

@@ -0,0 +1,7 @@
+export declare function shimmerText(text: string, frame: number): string;
+export declare function renderCompactionStatus(input: {
+    readonly frame: number;
+    readonly elapsedSeconds: number;
+    readonly columns: number;
+    readonly style?: (text: string) => string;
+}): readonly string[];

package/dist/tui/compaction-status.js

@@ -0,0 +1,39 @@
+import { frostPaint } from "./branding.js";
+import { tr } from "./i18n.js";
+import { fitLine, terminalWidth } from "./terminal-text.js";
+const identity = (text) => text;
+function elapsedLabel(seconds) {
+    const safe = Math.max(0, Math.floor(seconds));
+    if (safe < 60)
+        return `${safe}s`;
+    return `${Math.floor(safe / 60)}m ${safe % 60}s`;
+}
+// A narrow light band moves over the title. Only ANSI colors change between
+// frames, so the terminal painter rewrites this row without touching chat or
+// composer content.
+export function shimmerText(text, frame) {
+    const chars = Array.from(text);
+    const travel = chars.length + 10;
+    const head = ((frame % travel) + travel) % travel - 5;
+    return chars.map((char, index) => {
+        const distance = Math.abs(index - head);
+        const light = distance < 0.75 ? 1 : distance < 1.75 ? 0.82 : distance < 3.25 ? 0.55 : 0.24;
+        return frostPaint(light, char);
+    }).join("");
+}
+export function renderCompactionStatus(input) {
+    const width = Math.max(1, input.columns - 1);
+    const style = input.style ?? identity;
+    const title = shimmerText(tr("Compattazione del contesto", "Compacting context"), input.frame);
+    const left = `  ${style("╭─")} ${frostPaint(0.72, "✦")} ${title}`;
+    const elapsed = style(elapsedLabel(input.elapsedSeconds));
+    const gap = Math.max(2, width - terminalWidth(left) - terminalWidth(elapsed));
+    const headline = terminalWidth(left) + 2 + terminalWidth(elapsed) <= width
+        ? left + " ".repeat(gap) + elapsed
+        : `${left} ${elapsed}`;
+    return [
+        fitLine(headline, width),
+        fitLine(`  ${style("│")}  ${frostPaint(0.58, tr("Creo spazio per continuare…", "Making room to continue…"))}`, width),
+        fitLine(`  ${style("╰─")} ${style(tr("Esc interrompe", "Esc to interrupt"))}`, width),
+    ];
+}

package/dist/tui/config-recovery.d.ts

@@ -0,0 +1,12 @@
+import { buildConfig } from "../core/config.js";
+export type RecoveryChoice = "reset" | "manual";
+export declare const recoveryOptions: ({
+    value: "reset";
+    label: string;
+    detail: string;
+} | {
+    value: "manual";
+    label: string;
+    detail: string;
+})[];
+export declare function prepareStartupConfig(opts: Parameters<typeof buildConfig>[0], interactive: boolean, choose?: () => Promise<RecoveryChoice | null>, write?: (text: string) => void): Promise<boolean>;

package/dist/tui/config-recovery.js

@@ -0,0 +1,54 @@
+import { buildConfig, DEFAULT_UI, InvalidConfigError } from "../core/config.js";
+import { resetInvalidConfig } from "../core/config-storage.js";
+import { makeTheme } from "./branding.js";
+import { selectOption } from "./selector.js";
+export const recoveryOptions = [
+    { value: "reset", label: "Reimposta le impostazioni predefinite", detail: "Conserva un backup del file corrotto. Potrebbe essere necessario accedere di nuovo." },
+    { value: "manual", label: "No, aggiusto manualmente", detail: "Esci senza modificare il file di configurazione." },
+];
+async function chooseRecovery() {
+    let rows = 0;
+    const selected = await selectOption({
+        title: "Configurazione non valida: come vuoi procedere?",
+        options: recoveryOptions, current: "manual", theme: makeTheme(DEFAULT_UI),
+        filterable: false, terminalColumns: () => process.stdout.columns || 80,
+        ctl: {
+            pause() { }, resume() { }, write: (text) => { process.stdout.write(text); },
+            setOverlay(lines) {
+                if (rows)
+                    process.stdout.write(`\x1b[${rows}A\r\x1b[J`);
+                rows = lines?.length ?? 0;
+                if (lines)
+                    process.stdout.write(lines.join("\n") + "\n");
+            },
+        },
+    });
+    return selected?.value ?? null;
+}
+// Preflight prima di bootstrap/login. Print, RPC e pipe non devono mai
+// attendere input ne' reimpostare configurazioni implicitamente.
+export async function prepareStartupConfig(opts, interactive, choose = chooseRecovery, write = (text) => { process.stderr.write(text); }) {
+    for (;;) {
+        try {
+            buildConfig(opts);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof InvalidConfigError) || !interactive)
+                throw error;
+            write(`\nConfigurazione JSON non valida: ${error.path}\n`);
+            if (await choose() !== "reset") {
+                write(`Correggi o ripristina ${error.path}, quindi riavvia Talos. Nessun file modificato per questa scelta.\n`);
+                return false;
+            }
+            try {
+                const backup = resetInvalidConfig(error.path);
+                write(backup ? `Impostazioni reimpostate. Backup: ${backup}\n` : "Il file è già stato corretto; riprovo il caricamento.\n");
+            }
+            catch {
+                write(`Ripristino non riuscito: ${error.path}. Controlla i permessi e correggi il file manualmente.\n`);
+                return false;
+            }
+        }
+    }
+}

package/dist/tui/context-meter.d.ts

@@ -16,7 +16,10 @@ export interface ContextReading {
 export declare class ContextMeter {
     private cache?;
     private observed?;
+    private archive?;
+    private archiveTokens;
     reset(): void;
+    private archivedPrefix;
     observe(source: ContextSource, ledger: ContextLedger): void;
     read(source: ContextSource): ContextReading;
     private baseline;

package/dist/tui/context-meter.js

@@ -3,6 +3,7 @@ import { contextWindowFor, estimateMessagesTokens } from "../core/compaction.js"
 import { applyToolResultDemotion, planToolResultDemotion, toolIndexPolicy, applyMediaEviction, mediaBudgetPolicy, planMediaEviction } from "../core/tool-result-index.js";
 import { ToolOutputStore } from "../core/tool-result-store.js";
 import { contextPolicy, workingContextLimits } from "../core/context-policy.js";
+import { maxInputFor, resolveMaxTokens } from "../core/model-limits.js";
 // La cronologia su disco contiene ancora gli output integrali. Il contatore
 // usa la stessa proiezione del loop; il registro della richiesta aggiunge il
 // system effettivo e i blocchi di contesto compilati. Fra due richieste si
@@ -10,7 +11,32 @@ import { contextPolicy, workingContextLimits } from "../core/context-policy.js";
 export class ContextMeter {
     cache;
     observed;
-    reset() { this.cache = undefined; this.observed = undefined; }
+    archive;
+    archiveTokens = new WeakMap();
+    reset() {
+        this.cache = undefined;
+        this.observed = undefined;
+        this.archive = undefined;
+        this.archiveTokens = new WeakMap();
+    }
+    archivedPrefix(session, boundary) {
+        if (this.archive?.session === session && this.archive.boundary === boundary)
+            return this.archive.blocks;
+        // Nodes are immutable. Estimate each archived message once; subsequent
+        // live messages reuse the prefix, even when the live ledger is refreshed.
+        const nodes = session.nodeChain();
+        const cutoff = nodes.findIndex(node => node.id === boundary);
+        const archived = nodes.slice(0, Math.max(0, cutoff)).map(node => {
+            let tokens = this.archiveTokens.get(node.message);
+            if (tokens === undefined) {
+                tokens = estimateMessagesTokens([node.message]);
+                this.archiveTokens.set(node.message, tokens);
+            }
+            return { tokens, at: node.ts };
+        }).filter(block => block.tokens > 0);
+        this.archive = { session, boundary, blocks: archived };
+        return this.archive.blocks;
+    }
     observe(source, ledger) {
         if (ledger.model !== source.config.model)
             return;
@@ -32,7 +58,7 @@ export class ContextMeter {
         const history = session.history(), defs = tools.defs();
         const scaledPolicy = toolIndexPolicy(env, contextWindowFor(config.model, config.contextWindow));
         const mediaPolicy = mediaBudgetPolicy(env);
-        const limits = workingContextLimits(contextPolicy(env), contextWindowFor(config.model, config.contextWindow), config.compaction.reserveTokens);
+        const limits = workingContextLimits(contextPolicy(env), contextWindowFor(config.model, config.contextWindow), config.compaction.reserveTokens, resolveMaxTokens(config.maxTokens, config.model), maxInputFor(config.model));
         const key = JSON.stringify([config.model, config.contextWindow, config.sessionDir, config.roomStoreId, scaledPolicy, mediaPolicy,
             limits, config.compaction.enabled, config.compaction.perRoom, contextPolicy(env).roomCompaction]);
         const cached = this.cache;
@@ -46,17 +72,18 @@ export class ContextMeter {
         const ledger = buildContextLedger({ model: config.model, contextWindow: config.contextWindow,
             system: config.system, tools: defs, messages });
         const demoted = new Map(demotion.refs.map(ref => [ref.callId, ref.tokens]));
-        const chain = session.nodeChain();
-        const kept = session.lastCompaction ? chain.findIndex(node => node.id === session.lastCompaction.firstKeptId) : -1;
-        const archived = [];
-        for (const [index, node] of chain.entries()) {
+        const boundary = session.lastCompaction?.firstKeptId;
+        const chain = session.nodeChain(boundary);
+        const archived = boundary && chain[0]?.id === boundary
+            ? [...this.archivedPrefix(session, boundary)] : [];
+        for (const node of chain) {
             // Le due porzioni sono disgiunte: un risultato gia' dentro il prefisso
             // riassunto non si riconta come risultato retrocesso nella parte viva.
-            const tokens = index < kept ? estimateMessagesTokens([node.message]) : node.message.content.reduce((sum, part) => sum + (part.type === "tool_result" ? demoted.get(part.callId) ?? 0 : 0), 0);
+            const tokens = node.message.content.reduce((sum, part) => sum + (part.type === "tool_result" ? demoted.get(part.callId) ?? 0 : 0), 0);
             if (tokens > 0)
                 archived.push({ tokens, at: node.ts });
         }
-        const reading = { tokens: ledger.tokens, window: ledger.window, archived, nodes: session.tree().length,
+        const reading = { tokens: ledger.tokens, window: ledger.window, archived, nodes: session.nodeCount,
             ...(config.compaction.enabled ? { workingTarget: limits.active,
                 ...(config.compaction.perRoom && contextPolicy(env).roomCompaction !== "never" ? { checkpointAt: limits.checkpoint } : {}),
             } : {}),

package/dist/tui/diff.d.ts

@@ -5,5 +5,14 @@ export interface DiffOptions {
     readonly context?: number;
     readonly columns?: number;
     readonly wrapLines?: boolean;
+    readonly maxRows?: number;
 }
+export interface RenderedDiff {
+    readonly header: string;
+    readonly body: string;
+    readonly added: number;
+    readonly deleted: number;
+    readonly hiddenRows?: number;
+}
+export declare function renderDiffParts(oldText: string, newText: string, theme: TuiTheme, opts?: DiffOptions): RenderedDiff | null;
 export declare function renderDiff(oldText: string, newText: string, theme: TuiTheme, opts?: DiffOptions): string;

package/dist/tui/diff.js

@@ -1,4 +1,4 @@
-import { fitLine, padLine, plainText, wrapText } from "./terminal-text.js";
+import { fitLine, padLine, plainText, terminalWidth, wrapText, wrappedLineCount } from "./terminal-text.js";
 // Riduce prima il problema alle righe cambiate; limita la matrice quadratica.
 function diffLines(oldLines, newLines) {
     let prefix = 0;
@@ -60,7 +60,7 @@ function diffMiddle(oldLines, newLines) {
     }
     return ops;
 }
-export function renderDiff(oldText, newText, theme, opts = {}) {
+export function renderDiffParts(oldText, newText, theme, opts = {}) {
     const context = opts.context ?? 3;
     const cols = Math.max(4, opts.columns ?? 80);
     const oldLines = oldText === "" ? [] : plainText(oldText).replace(/\r?\n$/, "").split(/\r?\n/);
@@ -69,10 +69,16 @@ export function renderDiff(oldText, newText, theme, opts = {}) {
     const added = ops.filter((o) => o.kind === "add").length;
     const deleted = ops.filter((o) => o.kind === "del").length;
     if (added === 0 && deleted === 0)
-        return "";
-    // Numero di riga lato NUOVO file (per add/contesto); le rimozioni non ne hanno.
-    let n = 0;
-    const rows = ops.map((op) => ({ ...op, no: op.kind === "del" ? null : (n += 1) }));
+        return null;
+    // Deletions use the old file's numbers; additions use the new file's.
+    let oldNo = 0, newNo = 0;
+    const rows = ops.map(op => {
+        if (op.kind !== "add")
+            oldNo++;
+        if (op.kind !== "del")
+            newNo++;
+        return { ...op, no: op.kind === "del" ? oldNo : newNo };
+    });
     // Tieni solo le righe entro `context` da una modifica; il resto e' un "gap".
     const keep = new Array(rows.length).fill(false);
     rows.forEach((r, i) => {
@@ -81,17 +87,24 @@ export function renderDiff(oldText, newText, theme, opts = {}) {
         for (let k = Math.max(0, i - context); k <= Math.min(rows.length - 1, i + context); k += 1)
             keep[k] = true;
     });
-    const numW = Math.max(2, String(newLines.length || 1).length);
+    const numW = Math.max(2, String(Math.max(oldLines.length, newLines.length, 1)).length);
     const verb = opts.verb ?? "modificato";
     const path = plainText(opts.path ?? "file").replace(/[\r\n]/g, " ");
-    const bodyWidth = Math.max(1, cols - numW - 5);
+    const bodyWidth = Math.max(1, cols - numW - 6);
     // Estende il testo (privo di ANSI) fino a `cols` colonne, cosi' lo sfondo del
     // pittore copre l'intera larghezza della riga (look "a blocco" del diff).
     const pad = (s) => padLine(fitLine(s, cols), cols);
-    const out = [
-        "",
-        theme.diffHeader(pad(`  ${verb} ${path}   +${added} −${deleted}`)),
-    ];
+    const counts = `+${added} −${deleted}`;
+    const displayVerb = terminalWidth(`  ${verb}   ${counts}`) <= cols ? verb : `${verb.slice(0, 3)}.`;
+    const fixedHeader = ` ● ${displayVerb}    ${counts}`;
+    const pathWidth = Math.max(0, cols - terminalWidth(fixedHeader));
+    const displayPath = pathWidth ? plainText(fitLine(path, pathWidth, false)) : "";
+    // Keep the heading unboxed; reserve background fills for changed code.
+    const header = fitLine(" " + theme.green("● " + displayVerb)
+        + (displayPath ? " " + theme.bold(theme.silver(displayPath)) : "") + theme.dim(`   ${counts}`), cols);
+    const out = [];
+    const maxRows = opts.maxRows === undefined ? Infinity : Math.max(0, Math.floor(opts.maxRows));
+    let hiddenRows = 0;
     let gap = 0;
     rows.forEach((r, i) => {
         if (!keep[i]) {
@@ -99,21 +112,32 @@ export function renderDiff(oldText, newText, theme, opts = {}) {
             return;
         }
         if (gap > 0) {
-            out.push(theme.diffBorder(fitLine(`  ${" ".repeat(numW)}  ⋯ ${gap} righe invariate`, cols)));
+            if (out.length < maxRows)
+                out.push(theme.diffBorder(fitLine(`  ${" ".repeat(numW)}  ⋯ ${gap} righe invariate`, cols)));
+            else
+                hiddenRows++;
             gap = 0;
         }
-        const numStr = r.no === null ? " ".repeat(numW) : String(r.no).padStart(numW);
+        const numStr = String(r.no).padStart(numW);
         const text = r.line.replace(/\t/g, "  ");
-        const lines = opts.wrapLines ? wrapText(text, bodyWidth) : [fitLine(text, bodyWidth)];
+        const remaining = Math.max(0, maxRows - out.length);
+        const lines = remaining === 0 ? [] : opts.wrapLines ? wrapText(text, bodyWidth, false, remaining) : [fitLine(text, bodyWidth)];
+        if (Number.isFinite(maxRows) && (remaining === 0 || lines.length === remaining)) {
+            hiddenRows += (opts.wrapLines ? wrappedLineCount(text, bodyWidth) : 1) - lines.length;
+        }
         lines.forEach((line, part) => {
             const number = part ? " ".repeat(numW) : numStr;
             if (r.kind === "add")
-                out.push(theme.diffAdded(pad(`  ${number} + ${line}`)));
+                out.push(theme.diffAdded(pad(` │ ${number} + ${line}`)));
             else if (r.kind === "del")
-                out.push(theme.diffRemoved(pad(`  ${number} - ${line}`)));
+                out.push(theme.diffRemoved(pad(` │ ${number} - ${line}`)));
             else
-                out.push(theme.diffContext(pad(`  ${number}   ${line}`)));
+                out.push(theme.diffContext(pad(` │ ${number}   ${line}`)));
         });
     });
-    return out.join("\n") + "\n";
+    return { header, body: out.join("\n") + "\n", added, deleted, ...(opts.maxRows === undefined ? {} : { hiddenRows }) };
+}
+export function renderDiff(oldText, newText, theme, opts = {}) {
+    const rendered = renderDiffParts(oldText, newText, theme, opts);
+    return rendered ? `\n${rendered.header}\n${rendered.body}` : "";
 }

package/dist/tui/fusion-menu.d.ts

@@ -0,0 +1,5 @@
+import type { Harness } from "../core/bootstrap.js";
+import type { InputControl } from "./repl.js";
+import type { TuiTheme } from "./branding.js";
+import { selectOption } from "./selector.js";
+export declare function pickFusion(harness: Harness, ctl: InputControl, theme: TuiTheme, terminalColumns: () => number, select?: typeof selectOption): Promise<boolean>;